Adopt PrettyStackTrace in LLDB

[spyffe]

Summary

LLDB needs some minor changes to adopt PrettyStackTrace after https://reviews.llvm.org/D27683.
We remove our own SetCrashDescription() function and use LLVM-provided RAII objects instead.
We also make sure LLDB doesn't define __crashtracer_info__ which would collide with LLVM's definition.

[clayborg]

Looks fine.

lldb/trunk/include/lldb/Host/Host.h

public:
   ///     if \b true is returned. Otherwise \a file is left untouched.
   ///
   /// @return
   ///     \b true if \a file was resolved, \b false if this function
   ///     was not able to resolve the path.
   //------------------------------------------------------------------
   static bool ResolveExecutableInBundle(FileSpec &file);
 
-  //------------------------------------------------------------------
-  /// Set a string that can be displayed if host application crashes.
-  ///
-  /// Some operating systems have the ability to print a description
-  /// for shared libraries when a program crashes. If the host OS
-  /// supports such a mechanism, it should be implemented to help
-  /// with crash triage.
-  ///
-  /// @param[in] format
-  ///     A printf format that will be used to form a new crash
-  ///     description string.
-  //------------------------------------------------------------------
-  static void SetCrashDescriptionWithFormat(const char *format, ...)
-      __attribute__((format(printf, 1, 2)));
-
-  static void SetCrashDescription(const char *description);
-
   static uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
                                 ProcessInstanceInfoList &proc_infos);
 
   typedef std::map<lldb::pid_t, bool> TidMap;
   typedef std::pair<lldb::pid_t, bool> TidPair;
   static bool FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach);
 
   static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info);

lldb/trunk/scripts/Xcode/build-llvm.py

def cmake_flags():
     cmake_flags = CMAKE_FLAGS()[lldb_configuration()]
     cmake_flags += ["-GNinja",
                     "-DCMAKE_C_COMPILER={}".format(get_c_compiler()),
                     "-DCMAKE_CXX_COMPILER={}".format(get_cxx_compiler()),
                     "-DCMAKE_INSTALL_PREFIX={}".format(expected_package_build_path_for("llvm")),
                     "-DCMAKE_C_FLAGS={}".format(get_c_flags()),
                     "-DCMAKE_CXX_FLAGS={}".format(get_cxx_flags()),
                     "-DCMAKE_EXE_LINKER_FLAGS={}".format(get_exe_linker_flags()),
-                    "-DCMAKE_SHARED_LINKER_FLAGS={}".format(get_shared_linker_flags())]
+                    "-DCMAKE_SHARED_LINKER_FLAGS={}".format(get_shared_linker_flags()),
+                    "-DHAVE_CRASHREPORTER_INFO=1"]
     deployment_target = get_deployment_target()
     if deployment_target:
         cmake_flags.append(
             "-DCMAKE_OSX_DEPLOYMENT_TARGET={}".format(deployment_target))
     return cmake_flags
 
 
 def run_cmake(cmake_build_dir, ninja_binary_path):

lldb/trunk/source/API/SBFrame.cpp

 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBSymbolContext.h"
 #include "lldb/API/SBThread.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBVariablesOptions.h"
 
+#include "llvm/Support/PrettyStackTrace.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {}
 
 SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
     : m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
#endif
   Target *target = exe_ctx.GetTargetPtr();
   Process *process = exe_ctx.GetProcessPtr();
 
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
+        std::unique_ptr<llvm::PrettyStackTraceFormat> PST;
         if (target->GetDisplayExpressionsInCrashlogs()) {
           StreamString frame_description;
           frame->DumpUsingSettingsFormat(&frame_description);
-          Host::SetCrashDescriptionWithFormat(
+          PST = llvm::make_unique<llvm::PrettyStackTraceFormat>(
               "SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
               "= %u) %s",
               expr, options.GetFetchDynamicValue(),
               frame_description.GetData());
         }
 
         exe_results = target->EvaluateExpression(expr, frame, expr_value_sp,
                                                  options.ref());
         expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
-
-        if (target->GetDisplayExpressionsInCrashlogs())
-          Host::SetCrashDescription(nullptr);
       } else {
         if (log)
           log->Printf("SBFrame::EvaluateExpression () => error: could not "
                       "reconstruct frame object for this SBFrame.");
       }
     } else {
       if (log)
         log->Printf(

lldb/trunk/source/API/SBTarget.cpp

 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 
 #include "../source/Commands/CommandObjectBreakpoint.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 #define DEFAULT_DISASM_BYTE_SIZE 32
 
 namespace {
if (target_sp) {
     frame = exe_ctx.GetFramePtr();
     Target *target = exe_ctx.GetTargetPtr();
 
     if (target) {
 #ifdef LLDB_CONFIGURATION_DEBUG
       StreamString frame_description;
       if (frame)
         frame->DumpUsingSettingsFormat(&frame_description);
-      Host::SetCrashDescriptionWithFormat(
+      llvm::PrettyStackTraceFormat PST(
           "SBTarget::EvaluateExpression (expr = \"%s\", fetch_dynamic_value = "
           "%u) %s",
           expr, options.GetFetchDynamicValue(),
           frame_description.GetString().str().c_str());
 #endif
       exe_results =
           target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
 
       expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
-#ifdef LLDB_CONFIGURATION_DEBUG
-      Host::SetCrashDescription(NULL);
-#endif
     } else {
       if (log)
         log->Printf("SBTarget::EvaluateExpression () => error: could not "
                     "reconstruct frame object for this SBTarget.");
     }
   }
 #ifndef LLDB_DISABLE_PYTHON
   if (expr_log)

lldb/trunk/source/Host/common/Host.cpp

 #endif
 
 #if !defined(__APPLE__)
 bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
                                     uint32_t line_no) {
   return false;
 }
 
-void Host::SetCrashDescriptionWithFormat(const char *format, ...) {}
-
-void Host::SetCrashDescription(const char *description) {}
-
 #endif
 
 const UnixSignalsSP &Host::GetUnixSignals() {
   static const auto s_unix_signals_sp =
       UnixSignals::Create(HostInfo::GetArchitecture());
   return s_unix_signals_sp;
 }

lldb/trunk/source/Host/macosx/Host.mm

LaunchInNewTerminalWithAppleScript(const char *exe_path,
   [applescript release];
   if (pid != LLDB_INVALID_PROCESS_ID)
     launch_info.SetProcessID(pid);
   return error;
 }
 
 #endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 
-// On MacOSX CrashReporter will display a string for each shared library if
-// the shared library has an exported symbol named "__crashreporter_info__".
-
-static std::mutex &GetCrashReporterMutex() {
-  static std::mutex g_mutex;
-  return g_mutex;
-}
-
-extern "C" {
-const char *__crashreporter_info__ = NULL;
-}
-
-asm(".desc ___crashreporter_info__, 0x10");
-
-void Host::SetCrashDescriptionWithFormat(const char *format, ...) {
-  static StreamString g_crash_description;
-  std::lock_guard<std::mutex> guard(GetCrashReporterMutex());
-
-  if (format) {
-    va_list args;
-    va_start(args, format);
-    g_crash_description.GetString() = llvm::StringRef("");
-    g_crash_description.PrintfVarArg(format, args);
-    va_end(args);
-    __crashreporter_info__ = g_crash_description.GetData();
-  } else {
-    __crashreporter_info__ = NULL;
-  }
-}
-
-void Host::SetCrashDescription(const char *cstr) {
-  std::lock_guard<std::mutex> guard(GetCrashReporterMutex());
-  static std::string g_crash_description;
-  if (cstr) {
-    g_crash_description.assign(cstr);
-    __crashreporter_info__ = g_crash_description.c_str();
-  } else {
-    __crashreporter_info__ = NULL;
-  }
-}
-
 bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
                                     uint32_t line_no) {
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
   return false;
 #else
   // We attach this to an 'odoc' event to specify a particular selection
   typedef struct {
     int16_t reserved0; // must be zero

lldb/trunk/source/Initialization/SystemInitializerCommon.cpp

 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #endif
 
 #if defined(_MSC_VER)
 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
 #include "lldb/Host/windows/windows.h"
 #endif
 
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include <string>
 
 using namespace lldb_private;
 
-static void fatal_error_handler(void *user_data, const std::string &reason,
-                                bool gen_crash_diag) {
-  Host::SetCrashDescription(reason.c_str());
-  ::abort();
-}
-
 SystemInitializerCommon::SystemInitializerCommon() {}
 
 SystemInitializerCommon::~SystemInitializerCommon() {}
 
 void SystemInitializerCommon::Initialize() {
 #if defined(_MSC_VER)
   const char *disable_crash_dialog_var = getenv("LLDB_DISABLE_CRASH_DIALOG");
   if (disable_crash_dialog_var &&
if (disable_crash_dialog_var &&
     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
   }
 #endif
 
+  llvm::EnablePrettyStackTrace();
   Log::Initialize();
   HostInfo::Initialize();
   Timer scoped_timer(LLVM_PRETTY_FUNCTION, LLVM_PRETTY_FUNCTION);
 
-  llvm::install_fatal_error_handler(fatal_error_handler, 0);
-
   process_gdb_remote::ProcessGDBRemoteLog::Initialize();
 
   // Initialize plug-ins
   ObjectContainerBSDArchive::Initialize();
   ObjectFileELF::Initialize();
   ObjectFilePECOFF::Initialize();
 
   EmulateInstructionARM::Initialize();

lldb/trunk/source/Interpreter/CommandInterpreter.cpp

 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/Thread.h"
 
 #include "lldb/Utility/CleanUp.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/PrettyStackTrace.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static const char *k_white_space = " \t\v";
 
 static PropertyDefinition g_properties[] = {
     {"expand-regex-aliases", OptionValue::eTypeBoolean, true, false, nullptr,
bool CommandInterpreter::HandleCommand(const char *command_line,
                                        bool no_context_switching)
 
 {
 
   std::string command_string(command_line);
   std::string original_command_string(command_line);
 
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMANDS));
-  Host::SetCrashDescriptionWithFormat("HandleCommand(command = \"%s\")",
-                                      command_line);
+  llvm::PrettyStackTraceFormat PST("HandleCommand(command = \"%s\")",
 
-  // Make a scoped cleanup object that will clear the crash description string
-  // on exit of this function.
-  lldb_utility::CleanUp<const char *> crash_description_cleanup(
-      nullptr, Host::SetCrashDescription);
-
   if (log)
     log->Printf("Processing command: %s", command_line);
 
   Timer scoped_timer(LLVM_PRETTY_FUNCTION, "Handling command: %s.",
                      command_line);
 
   if (!no_context_switching)
     UpdateExecutionContext(override_context);

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

                                   break;
                                 }
                               }
                             }
                           }
                         }
 
                         if (add_method) {
-                          // REMOVE THE CRASH DESCRIPTION BELOW
-                          Host::SetCrashDescriptionWithFormat(
+                          llvm::PrettyStackTraceFormat PST(
                               "SymbolFileDWARF::ParseType() is adding a method "
                               "%s to class %s in DIE 0x%8.8" PRIx64 " from %s",
                               type_name_cstr,
                               class_type->GetName().GetCString(), die.GetID(),
                               dwarf->GetObjectFile()
                                   ->GetFileSpec()
                                   .GetPath()
                                   .c_str());
 
                           const bool is_attr_used = false;
                           // Neither GCC 4.2 nor clang++ currently set a valid
                           // accessibility
                           // in the DWARF for C++ methods... Default to public
                           // for now...
                           if (accessibility == eAccessNone)
                             accessibility = eAccessPublic;
 
-                          clang::CXXMethodDecl *cxx_method_decl;
-                          cxx_method_decl = m_ast.AddMethodToCXXRecordType(
+                          clang::CXXMethodDecl *cxx_method_decl =
+                              m_ast.AddMethodToCXXRecordType(
                                   class_opaque_type.GetOpaqueQualType(),
                                   type_name_cstr, clang_type, accessibility,
                                   is_virtual, is_static, is_inline, is_explicit,
                                   is_attr_used, is_artificial);
 
                           type_handled = cxx_method_decl != NULL;
 
                           if (type_handled) {
                             LinkDeclContextToDIE(
                                 ClangASTContext::GetAsDeclContext(
                                     cxx_method_decl),
                                 die);
 
-                            Host::SetCrashDescription(NULL);
-
                             ClangASTMetadata metadata;
                             metadata.SetUserID(die.GetID());
 
                             if (!object_pointer_name.empty()) {
                               metadata.SetObjectPtrName(
                                   object_pointer_name.c_str());
                               if (log)
                                 log->Printf(