[Backtracing] Add an indication that we're working on a backtrace.

When we crash, emit a message straight away that says we're working
on a backtrace.  If starting the backtracer fails, report that also.

Finally, add a duration to the messages output by the backtracer, so
that we can see how long it took.

rdar://118055527

Author: al45tair

include/swift/Runtime/Backtrace.h

@@ -31,114 +31,17 @@
 
 #include <inttypes.h>
 
-#ifdef _WIN32
-// For DWORD
-#define WIN32_LEAN_AND_MEAN
-#define NOMINMAX
-#include <windows.h>
-
-// For wchar_t
-#include <cwchar>
-#endif
-
 #ifdef __cplusplus
 namespace swift {
 namespace runtime {
 namespace backtrace {
 #endif
 
-#ifdef _WIN32
-typedef wchar_t ArgChar;
-typedef DWORD ErrorCode;
-#else
-typedef char ArgChar;
-typedef int ErrorCode;
-#endif
-
-SWIFT_RUNTIME_STDLIB_INTERNAL ErrorCode _swift_installCrashHandler();
-
-#ifdef __linux__
-SWIFT_RUNTIME_STDLIB_INTERNAL bool _swift_spawnBacktracer(const ArgChar * const *argv, int memserver_fd);
-#else
-SWIFT_RUNTIME_STDLIB_INTERNAL bool _swift_spawnBacktracer(const ArgChar * const *argv);
-#endif
-
-enum class UnwindAlgorithm {
-  Auto = 0,
-  Fast = 1,
-  Precise = 2
-};
-
-enum class OnOffTty {
-  Off = 0,
-  On = 1,
-  TTY = 2
-};
-
-enum class Preset {
-  Auto = -1,
-  Friendly = 0,
-  Medium = 1,
-  Full = 2
-};
-
-enum class ThreadsToShow {
-  Preset = -1,
-  All = 0,
-  Crashed = 1
-};
-
-enum class RegistersToShow {
-  Preset = -1,
-  None = 0,
-  All = 1,
-  Crashed = 2
-};
-
-enum class ImagesToShow {
-  Preset = -1,
-  None = 0,
-  All = 1,
-  Mentioned = 2
-};
-
-enum class SanitizePaths {
-  Preset = -1,
-  Off = 0,
-  On = 1
-};
-
-enum class OutputTo {
-  Auto = -1,
-  Stdout = 0,
-  Stderr = 2,
-};
-
-struct BacktraceSettings {
-  UnwindAlgorithm  algorithm;
-  OnOffTty         enabled;
-  bool             demangle;
-  OnOffTty         interactive;
-  OnOffTty         color;
-  unsigned         timeout;
-  ThreadsToShow    threads;
-  RegistersToShow  registers;
-  ImagesToShow     images;
-  unsigned         limit;
-  unsigned         top;
-  SanitizePaths    sanitize;
-  Preset           preset;
-  bool             cache;
-  OutputTo         outputTo;
-  const char      *swiftBacktracePath;
-};
-
-SWIFT_RUNTIME_STDLIB_INTERNAL BacktraceSettings _swift_backtraceSettings;
-
-inline bool _swift_backtrace_isEnabled() {
-  return _swift_backtraceSettings.enabled == OnOffTty::On;
-}
-
+// Test if a given function is a Swift thunk of some sort.
+//
+// @param mangledName is the name of the symbol to test.
+//
+// @returns true if the function is a thunk.
 SWIFT_RUNTIME_STDLIB_SPI
 bool _swift_backtrace_isThunkFunction(const char *mangledName);
 

stdlib/public/libexec/swift-backtrace/main.swift

@@ -113,6 +113,38 @@ internal struct SwiftBacktrace {
     }
   }
 
+  static func subtract(timespec ts: timespec, from: timespec) -> timespec {
+    var sec = from.tv_sec - ts.tv_sec
+    var nsec = from.tv_nsec - ts.tv_nsec
+    if nsec < 0 {
+      sec -= 1
+      nsec += 1000000000
+    }
+    return timespec(tv_sec: sec, tv_nsec: nsec)
+  }
+
+  // We can't use Foundation here, so there's no String(format:, ...)
+  static func format(duration: timespec) -> String {
+    let centisRounded = (duration.tv_nsec + 5000000) / 10000000
+    let centis = centisRounded % 100
+    let secs = duration.tv_sec + (centisRounded / 100)
+    let d1 = centis / 10
+    let d2 = centis % 10
+
+    return "\(secs).\(d1)\(d2)"
+  }
+
+  static func measureDuration(_ body: () -> ()) -> timespec {
+    var startTime = timespec()
+    var endTime = timespec()
+
+    clock_gettime(CLOCK_MONOTONIC, &startTime)
+    body()
+    clock_gettime(CLOCK_MONOTONIC, &endTime)
+
+    return subtract(timespec: startTime, from: endTime)
+  }
+
   static func usage() {
     print("""
 usage: swift-backtrace [--unwind <algorithm>] [--demangle [<bool>]] [--interactive [<bool>]] [--color [<bool>]] [--timeout <seconds>] [--preset <preset>] [--threads [<bool>]] [--registers <registers>] [--images <images>] [--cache [<bool>]] [--output-to <stream>] --crashinfo <addr>
@@ -460,16 +492,25 @@ Generate a backtrace for the parent process.
     // want to do it *once* for all the backtraces we showed.
     formattingOptions = formattingOptions.showImages(.none)
 
-    target = Target(crashInfoAddr: crashInfoAddr,
-                    limit: args.limit, top: args.top,
-                    cache: args.cache)
+    // Target's initializer fetches and symbolicates backtraces, so
+    // we want to time that part here.
+    let duration = measureDuration {
+      target = Target(crashInfoAddr: crashInfoAddr,
+                      limit: args.limit, top: args.top,
+                      cache: args.cache)
 
-    currentThread = target!.crashingThreadNdx
+      currentThread = target!.crashingThreadNdx
+    }
 
     printCrashLog()
 
     writeln("")
 
+    let formattedDuration = format(duration: duration)
+
+    writeln("Backtrace took \(formattedDuration)s")
+    writeln("")
+
     if args.interactive {
       // Make sure we're line buffered
       setvbuf(stdout, nil, _IOLBF, 0)
@@ -611,7 +652,13 @@ Generate a backtrace for the parent process.
       description = "Program crashed: \(target.signalDescription) at \(hex(target.faultAddress))"
     }
 
-    writeln("")
+    // Clear the message written by the crash handler
+    if args.color {
+      write("\r\u{1b}[0K")
+    } else {
+      write("\r" + String(repeating:" ", count: 80) + "\r")
+    }
+
     writeln(theme.crashReason(description))
 
     var mentionedImages = Set<Int>()

stdlib/public/runtime/Backtrace.cpp

@@ -58,6 +58,8 @@
 #include <cxxabi.h>
 #endif
 
+#include "BacktracePrivate.h"
+
 #define DEBUG_BACKTRACING_SETTINGS 0
 
 #ifndef lengthof
@@ -987,6 +989,57 @@ _swift_spawnBacktracer(const ArgChar * const *argv)
 #endif
 }
 
+// N.B. THIS FUNCTION MUST BE SAFE TO USE FROM A CRASH HANDLER.  On Linux
+// and macOS, that means it must be async-signal-safe.  On Windows, there
+// isn't an equivalent notion but a similar restriction applies.
+SWIFT_RUNTIME_STDLIB_INTERNAL void
+_swift_displayCrashMessage(int signum, const void *pc)
+{
+#if !SWIFT_BACKTRACE_ON_CRASH_SUPPORTED
+  return;
+#else
+  int fd = STDOUT_FILENO;
+
+  if (_swift_backtraceSettings.outputTo == OutputTo::Stderr)
+    fd = STDERR_FILENO;
+
+  const char *intro;
+  if (_swift_backtraceSettings.color == OnOffTty::On) {
+    intro = "\n💣 \033[91mProgram crashed: ";
+  } else {
+    intro = "\n*** Program crashed: ";
+  }
+  write(fd, intro, strlen(intro));
+
+  char sigbuf[30];
+  strcpy(sigbuf, "Signal ");
+  _swift_formatUnsigned((unsigned)signum, sigbuf + 7);
+  write(fd, sigbuf, strlen(sigbuf));
+
+  const char *message;
+  if (!pc) {
+    message = ": Backtracing";
+  } else {
+    message = ": Backtracing from 0x";
+  }
+  write(fd, message, strlen(message));
+
+  if (pc) {
+    char pcbuf[18];
+    _swift_formatAddress(pc, pcbuf);
+    write(fd, pcbuf, strlen(pcbuf));
+  }
+
+  const char *outro;
+  if (_swift_backtraceSettings.color == OnOffTty::On) {
+    outro = "...\033[0m";
+  } else {
+    outro = "...";
+  }
+  write(fd, outro, strlen(outro));
+#endif
+}
+
 } // namespace backtrace
 } // namespace runtime
 } // namespace swift