[lldb] Print lldbassert to debugger diagnostics

[JDevlieghere]

Summary

When hitting an lldbassert in a non-assert build, we emit a blurb including the assertion, the triggering file and line and a pretty backtrace leading up to the issue. Currently, this emitted to stderr. That's fine for the command line, but when used as library, for example from Xcode or VSCode, this information doesn't make it to the user. This patch redirects these messages to use the diagnostic infrastructure so they're emitted as diagnostic events.

The patch is slightly more complicated than I would've liked because of layering. lldbassert is part of Utility while the diagnostics are implemented in Core.

[bulbazord]

I like this idea quite a bit! I assume that when somebody hits a bug, they can give us their diagnostics file and we will hopefully see the assertion somewhere (if there was one)?

lldb/source/Target/Target.cpp

115

.

[JDevlieghere]

In D152866#4419406, @bulbazord wrote:

I like this idea quite a bit! I assume that when somebody hits a bug, they can give us their diagnostics file and we will hopefully see the assertion somewhere (if there was one)?

Unfortunate naming, but these are different diagnostics: these are errors and warnings that are emitted as events. What you're thinking of is the Diagnostic class.

• I should really rename one of them to avoid confusion.
• We could totally combine the two and emit a file with the lldbassert in the "diagnostics dir" that we generate on crash. I'll tackle that in a follow-up commit.

[bulbazord]

In D152866#4419413, @JDevlieghere wrote:

In D152866#4419406, @bulbazord wrote:

I like this idea quite a bit! I assume that when somebody hits a bug, they can give us their diagnostics file and we will hopefully see the assertion somewhere (if there was one)?

Unfortunate naming, but these are different diagnostics: these are errors and warnings that are emitted as events. What you're thinking of is the Diagnostic class.

• I should really rename one of them to avoid confusion.
• We could totally combine the two and emit a file with the lldbassert in the "diagnostics dir" that we generate on crash. I'll tackle that in a follow-up commit.

Oh I see. Yeah, the fact that we have multiple things named Diagnostics is confusing. :( Unfortunate but still better than nothing. Let's definitely figure out a resolution as a follow-up.

[JDevlieghere]

Separate out message, backtrace and prompt. This works better for a custom (downstream) callback that prompts the user to automatically file a bug report.

lldb/include/lldb/Core/Debugger.h

public:
   static lldb::DebuggerSP GetDebuggerAtIndex(size_t index);
 
   static bool FormatDisassemblerAddress(const FormatEntity::Entry *format,
                                         const SymbolContext *sc,
                                         const SymbolContext *prev_sc,
                                         const ExecutionContext *exe_ctx,
                                         const Address *addr, Stream &s);
 
+  static void AssertCallback(std::string message);
+
   void Clear();
 
   bool GetAsyncExecution();
 
   void SetAsyncExecution(bool async);
 
   lldb::FileSP GetInputFileSP() { return m_input_file_sp; }
 
public:
   ///   * CommandInterpreter::InterruptCommand: Interrupts the command currently
   ///     running in the command interpreter IOHandler thread
   ///   * Debugger::RequestInterrupt: Interrupts are active on anything but the
   ///     CommandInterpreter thread till CancelInterruptRequest is called.
   ///
   /// Since the two checks are mutually exclusive, however, it's also convenient
   /// to have just one function to check the interrupt state.
 
-
   /// Bump the "interrupt requested" count on the debugger to support
   /// cooperative interruption.  If this is non-zero, InterruptRequested will
   /// return true.  Interruptible operations are expected to query the
   /// InterruptRequested API periodically, and interrupt what they were doing
   /// if it returns \b true.
   ///
   void RequestInterrupt();
   

lldb/include/lldb/Utility/LLDBAssert.h

 //===----------------- LLDBAssert.h ------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UTILITY_LLDBASSERT_H
 #define LLDB_UTILITY_LLDBASSERT_H
 
+#include <string>
+
 #ifndef NDEBUG
 #define lldbassert(x) assert(x)
 #else
 #if defined(__clang__)
 // __FILE_NAME__ is a Clang-specific extension that functions similar to
 // __FILE__ but only renders the last path component (the filename) instead of
 // an invocation dependent full path to that file.
 #define lldbassert(x)                                                          \
   lldb_private::lldb_assert(static_cast<bool>(x), #x, __FUNCTION__,            \
                             __FILE_NAME__, __LINE__)
 #else
 #define lldbassert(x)                                                          \
   lldb_private::lldb_assert(static_cast<bool>(x), #x, __FUNCTION__, __FILE__,  \
                             __LINE__)
 #endif
 #endif
 
 namespace lldb_private {
 void lldb_assert(bool expression, const char *expr_text, const char *func,
                  const char *file, unsigned int line);
+
+typedef void (*LLDBAssertCallback)(std::string message);
+
+void SetLLDBAssertCallback(LLDBAssertCallback callback);
 } // namespace lldb_private
 
 #endif // LLDB_UTILITY_LLDBASSERT_H

lldb/source/API/SystemInitializerFull.cpp

#include "Plugins/Plugins.def"
 
   // Scan for any system or user LLDB plug-ins
   PluginManager::Initialize();
 
   // The process settings need to know about installed plug-ins, so the
   // Settings must be initialized AFTER PluginManager::Initialize is called.
   Debugger::SettingsInitialize();
 
+  // Use the Debugger's LLDBAssert callback.
+  SetLLDBAssertCallback(Debugger::AssertCallback);
+
   return llvm::Error::success();
 }
 
 void SystemInitializerFull::Terminate() {
   Debugger::SettingsTerminate();
 
   // Terminate plug-ins in core LLDB
   ProcessTrace::Terminate();

lldb/source/Core/Debugger.cpp

bool Debugger::FormatDisassemblerAddress(const FormatEntity::Entry *format,
   if ((sc && (sc->function || sc->symbol)) && prev_sc &&
       (prev_sc->function == nullptr && prev_sc->symbol == nullptr)) {
     initial_function = true;
   }
   return FormatEntity::Format(*format, s, sc, exe_ctx, addr, nullptr,
                               function_changed, initial_function);
 }
 
+void Debugger::AssertCallback(std::string message) {
+  Debugger::ReportError(std::move(message));
+}
+
 void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                   void *baton) {
   // For simplicity's sake, I am not going to deal with how to close down any
   // open logging streams, I just redirect everything from here on out to the
   // callback.
   m_callback_handler_sp =
       std::make_shared<CallbackLogHandler>(log_callback, baton);
 }

lldb/source/Target/Target.cpp

: TargetProperties(this),
       m_frame_recognizer_manager_up(
           std::make_unique<StackFrameRecognizerManager>()) {
   SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
   SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
   SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
   SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
   SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
 
+  lldbassert(false && "foo");
   CheckInWithManager();
 
   LLDB_LOG(GetLog(LLDBLog::Object), "{0} Target::Target()",
            static_cast<void *>(this));
   if (target_arch.IsValid()) {
     LLDB_LOG(GetLog(LLDBLog::Target),
              "Target::Target created with architecture {0} ({1})",
              target_arch.GetArchitectureName(),

lldb/source/Utility/LLDBAssert.cpp

 //===-- LLDBAssert.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/LLDBAssert.h"
 #include "llvm/Config/llvm-config.h"
-#include "llvm/Support/Format.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
 #include <os/log.h>
 #endif
 
-using namespace llvm;
-using namespace lldb_private;
+namespace lldb_private {
 
-void lldb_private::lldb_assert(bool expression, const char *expr_text,
-                               const char *func, const char *file,
-                               unsigned int line) {
+static void DefaultLLDBAssertCallback(std::string message) {
+  llvm::errs() << message << '\n';
+}
+
+static std::atomic<LLDBAssertCallback> g_lldb_assert_callback =
+    &DefaultLLDBAssertCallback;
+
+void lldb_assert(bool expression, const char *expr_text, const char *func,
+                 const char *file, unsigned int line) {
   if (LLVM_LIKELY(expression))
     return;
 
 #if LLVM_SUPPORT_XCODE_SIGNPOSTS
   if (__builtin_available(macos 10.12, iOS 10, tvOS 10, watchOS 3, *)) {
     os_log_fault(OS_LOG_DEFAULT,
                  "Assertion failed: (%s), function %s, file %s, line %u\n",
                  expr_text, func, file, line);
   }
 #endif
 
   // Print a warning and encourage the user to file a bug report, similar to
   // LLVM’s crash handler, and then return execution.
-  errs() << format("Assertion failed: (%s), function %s, file %s, line %u\n",
-                   expr_text, func, file, line);
-  errs() << "backtrace leading to the failure:\n";
-  llvm::sys::PrintStackTrace(errs());
-  errs() << "please file a bug report against lldb reporting this failure "
-            "log, and as many details as possible\n";
+  std::string buffer;
+  llvm::raw_string_ostream backtrace(buffer);
+  llvm::sys::PrintStackTrace(backtrace);
+
+  std::string message =
+      llvm::formatv("Assertion failed: ({0}), function {1}, file {2}, line "
+                    "{3}\n{4}Please file a bug report against lldb reporting "
+                    "this failure log, and as many details as possible",
+                    expr_text, func, file, line, backtrace.str())
+          .str();
+
+  (*g_lldb_assert_callback.load())(std::move(message));
+}
+
+void SetLLDBAssertCallback(LLDBAssertCallback callback) {
+  g_lldb_assert_callback.exchange(callback);
 }
+
+} // namespace lldb_private