[Demangler][Runtime] Give the demangler its own error handling.

The demangling library can't use the error handling from the main runtime
because it isn't always linked with it.  However, it's useful to have
some error handling, and in particular to be able to get data into the
crash logs.

This is complicated because of the way the demangling library gets used,
the upshot of which is that I've had to add a second object library just
for libswiftCore's use, so that the demangler will use the runtime's
error handling functions when present, and fall back on its own when
they aren't.

rdar://89139049

Author: al45tair

include/swift/Demangling/Demangle.h

@@ -19,6 +19,7 @@
 #ifndef SWIFT_DEMANGLING_DEMANGLE_H
 #define SWIFT_DEMANGLING_DEMANGLE_H
 
+#include "swift/Demangling/Errors.h"
 #include "swift/Demangling/NamespaceMacros.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Compiler.h"

include/swift/Demangling/Errors.h

@@ -0,0 +1,96 @@
+//===--- Errors.h - Demangling library error handling -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file exists because not every client links to libswiftCore (the
+// runtime), so calling swift::fatalError() or swift::warning() from within
+// the demangler is not an option.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_DEMANGLING_ERRORS_H
+#define SWIFT_DEMANGLING_ERRORS_H
+
+#include "../../../stdlib/public/SwiftShims/Visibility.h"
+#include "swift/Demangling/NamespaceMacros.h"
+#include <inttypes.h>
+#include <stdarg.h>
+
+#ifndef SWIFT_FORMAT
+// SWIFT_FORMAT(fmt,first) marks a function as taking a format string argument
+// at argument `fmt`, with the first argument for the format string as `first`.
+#if __has_attribute(format)
+#define SWIFT_FORMAT(fmt, first) __attribute__((format(printf, fmt, first)))
+#else
+#define SWIFT_FORMAT(fmt, first)
+#endif
+#endif
+
+#ifndef SWIFT_VFORMAT
+// SWIFT_VFORMAT(fmt) marks a function as taking a format string argument at
+// argument `fmt`, with the arguments in a `va_list`.
+#if __has_attribute(format)
+#define SWIFT_VFORMAT(fmt) __attribute__((format(printf, fmt, 0)))
+#else
+#define SWIFT_VFORMAT(fmt)
+#endif
+#endif
+
+#ifdef SWIFT_HAVE_CRASHREPORTERCLIENT
+
+#define CRASHREPORTER_ANNOTATIONS_VERSION 5
+#define CRASHREPORTER_ANNOTATIONS_SECTION "__crash_info"
+
+struct crashreporter_annotations_t {
+  uint64_t version;          // unsigned long
+  uint64_t message;          // char *
+  uint64_t signature_string; // char *
+  uint64_t backtrace;        // char *
+  uint64_t message2;         // char *
+  uint64_t thread;           // uint64_t
+  uint64_t dialog_mode;      // unsigned int
+  uint64_t abort_cause;      // unsigned int
+};
+
+extern "C" {
+SWIFT_RUNTIME_LIBRARY_VISIBILITY
+extern struct crashreporter_annotations_t gCRAnnotations;
+}
+
+SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
+static inline void CRSetCrashLogMessage(const char *message) {
+  gCRAnnotations.message = reinterpret_cast<uint64_t>(message);
+}
+
+SWIFT_RUNTIME_ATTRIBUTE_ALWAYS_INLINE
+static inline const char *CRGetCrashLogMessage() {
+  return reinterpret_cast<const char *>(gCRAnnotations.message);
+}
+
+#endif
+
+namespace swift {
+namespace Demangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+SWIFT_NORETURN SWIFT_FORMAT(2, 3) void fatal(uint32_t flags, const char *format,
+                                             ...);
+SWIFT_FORMAT(2, 3) void warn(uint32_t flags, const char *format, ...);
+
+SWIFT_NORETURN SWIFT_VFORMAT(2) void fatalv(uint32_t flags, const char *format,
+                                            va_list val);
+SWIFT_VFORMAT(2) void warnv(uint32_t flags, const char *format, va_list val);
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Demangle
+} // end namespace swift
+
+#endif // SWIFT_DEMANGLING_DEMANGLE_H

include/swift/Runtime/Debug.h

@@ -82,7 +82,13 @@ static inline void crash(const char *message) {
   swift_unreachable("Expected compiler to crash.");
 }
 
-// swift::fatalError() halts with a crash log message, 
+// swift::fatalErrorv() halts with a crash log message,
+// but makes no attempt to preserve register state.
+SWIFT_RUNTIME_ATTRIBUTE_NORETURN
+SWIFT_VFORMAT(2)
+extern void fatalErrorv(uint32_t flags, const char *format, va_list args);
+
+// swift::fatalError() halts with a crash log message,
 // but makes no attempt to preserve register state.
 SWIFT_RUNTIME_ATTRIBUTE_NORETURN
 SWIFT_FORMAT(2, 3)

lib/Demangling/CMakeLists.txt

@@ -1,3 +1,13 @@
+set(swift_demangling_compile_flags
+  LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1
+  SWIFT_SUPPORT_OLD_MANGLING=1
+  SWIFT_STDLIB_HAS_TYPE_PRINTING=1)
+
+if(SWIFT_RUNTIME_CRASH_REPORTER_CLIENT)
+  list(APPEND swift_demangling_compile_flags
+      "-DSWIFT_HAVE_CRASHREPORTERCLIENT=1")
+endif()
+
 add_swift_host_library(swiftDemangling STATIC
   Demangler.cpp
   Context.cpp
@@ -7,11 +17,10 @@ add_swift_host_library(swiftDemangling STATIC
   OldDemangler.cpp
   OldRemangler.cpp
   Punycode.cpp
-  Remangler.cpp)
+  Remangler.cpp
+  Errors.cpp)
 target_compile_definitions(swiftDemangling PRIVATE
-  LLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING=1
-  SWIFT_SUPPORT_OLD_MANGLING=1
-  SWIFT_STDLIB_HAS_TYPE_PRINTING=1)
+  ${swift_demangling_compile_flags})
 
 # NOTE: Runtime libraries that depend on swiftDemangling should define
 # SWIFT_INLINE_NAMESPACE to specify the identifier that will be used for an

lib/Demangling/Demangler.cpp

@@ -95,12 +95,10 @@ void swift::Demangle::failAssert(const char *file, unsigned line,
                                  NodePointer node, const char *expr) {
   std::string treeStr = getNodeTreeAsString(node);
 
-  fprintf(stderr,
-          "%s:%u: assertion failed for Node %p: %s\n"
-          "%s:%u: Node %p is:\n%s\n",
-          file, line, node, expr,
-          file, line, node, treeStr.c_str());
-  abort();
+  fatal(0,
+        "%s:%u: assertion failed for Node %p: %s\n"
+        "%s:%u: Node %p is:\n%s\n",
+        file, line, node, expr, file, line, node, treeStr.c_str());
 }
 
 bool swift::Demangle::isContext(Node::Kind kind) {
@@ -751,7 +749,7 @@ NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind) {
   NodePointer resolved = nullptr;
   if (SymbolicReferenceResolver)
     resolved = SymbolicReferenceResolver(kind, direct, value, at);
-    
+
   // With no resolver, or a resolver that failed, refuse to demangle further.
   if (!resolved)
     return nullptr;

lib/Demangling/Errors.cpp

@@ -0,0 +1,222 @@
+//===--- Errors.cpp - Demangling library error handling ---------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is the public API of the demangler library.
+// Tools which use the demangler library (like lldb) must include this - and
+// only this - header file.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Demangling/Errors.h"
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <io.h>
+#endif
+
+#if SWIFT_STDLIB_HAS_ASL
+#include <asl.h>
+#elif defined(__ANDROID__)
+#include <android/log.h>
+#endif
+
+#if SWIFT_DEMANGLE_USE_RUNTIME_ERRORS
+#include "swift/Runtime/Debug.h"
+#endif
+
+#if !SWIFT_DEMANGLE_USE_RUNTIME_ERRORS
+
+// -- Declarations -----------------------------------------------------------
+
+static SWIFT_NORETURN void demangleFatal(uint32_t flags, const char *format,
+                                         va_list val);
+static void demangleWarn(uint32_t flags, const char *format, va_list val);
+
+// -- Crash reporter integration ---------------------------------------------
+
+#if SWIFT_HAVE_CRASHREPORTERCLIENT
+#include <malloc/malloc.h>
+#include <pthread.h>
+
+// Instead of linking to CrashReporterClient.a (because it complicates the
+// build system), define the only symbol from that static archive ourselves.
+//
+// The layout of this struct is CrashReporter ABI, so there are no ABI concerns
+// here.
+extern "C" {
+SWIFT_LIBRARY_VISIBILITY
+struct crashreporter_annotations_t gCRAnnotations __attribute__((
+    __section__("__DATA," CRASHREPORTER_ANNOTATIONS_SECTION))) = {
+    CRASHREPORTER_ANNOTATIONS_VERSION, 0, 0, 0, 0, 0, 0, 0};
+}
+
+// Report a message to any forthcoming crash log.
+static void reportOnCrash(uint32_t flags, const char *message) {
+  // We must use an "unsafe" mutex in this pathway since the normal "safe"
+  // mutex calls fatal when an error is detected and fatal ends up
+  // calling us. In other words we could get infinite recursion if the
+  // mutex errors.
+  static pthread_mutex_t crashlogLock = PTHREAD_MUTEX_INITIALIZER;
+
+  pthread_mutex_lock(&crashlogLock);
+
+  char *oldMessage = (char *)CRGetCrashLogMessage();
+  char *newMessage;
+  if (oldMessage) {
+    swift_asprintf(&newMessage, "%s%s", oldMessage, message);
+    if (malloc_size(oldMessage))
+      free(oldMessage);
+  } else {
+    newMessage = strdup(message);
+  }
+
+  CRSetCrashLogMessage(newMessage);
+
+  pthread_mutex_unlock(&crashlogLock);
+}
+
+#else
+static void
+
+reportOnCrash(uint32_t flags, const char *message) {
+  // empty
+}
+
+#endif // SWIFT_HAVE_CRASHREPORTERCLIENT
+
+// -- Utility functions ------------------------------------------------------
+
+// Report a message to system console and stderr.
+static void reportNow(uint32_t flags, const char *message) {
+#if defined(_WIN32)
+#define STDERR_FILENO 2
+  _write(STDERR_FILENO, message, strlen(message));
+#else
+  fputs(message, stderr);
+  fflush(stderr);
+#endif
+#if SWIFT_STDLIB_HAS_ASL
+  asl_log(nullptr, nullptr, ASL_LEVEL_ERR, "%s", message);
+#elif defined(__ANDROID__)
+  __android_log_print(ANDROID_LOG_FATAL, "SwiftDemangle", "%s", message);
+#endif
+}
+
+/// Report a fatal error to system console, stderr, and crash logs.
+/// Does not crash by itself.
+static void reportError(uint32_t flags, const char *message) {
+  reportNow(flags, message);
+  reportOnCrash(flags, message);
+}
+
+/// Not everything has vasprintf()
+SWIFT_VFORMAT(2)
+static int demangle_vasprintf(char **strp, const char *format, va_list args) {
+  va_list args_for_len;
+
+  va_copy(args_for_len, args);
+  int len = vsnprintf(nullptr, 0, format, args_for_len);
+  va_end(args_for_len);
+
+  *strp = nullptr;
+
+  if (len < 0)
+    return -1;
+
+  size_t bufsiz = len + 1;
+  char *buffer = reinterpret_cast<char *>(malloc(bufsiz));
+  if (!buffer)
+    return -1;
+
+  int result = vsnprintf(buffer, bufsiz, format, args);
+  if (result < 0) {
+    free(buffer);
+    return -1;
+  }
+
+  *strp = buffer;
+  return result;
+}
+
+// -- Implementation ---------------------------------------------------------
+
+static SWIFT_NORETURN void demangleFatal(uint32_t flags, const char *format,
+                                         va_list val) {
+  char *message;
+
+  if (demangle_vasprintf(&message, format, val) < 0) {
+    reportError(flags, "unable to format fatal error message");
+    abort();
+  }
+
+  reportError(flags, message);
+  abort();
+}
+
+static void demangleWarn(uint32_t flags, const char *format, va_list val) {
+  char *message;
+
+  if (demangle_vasprintf(&message, format, val) < 0) {
+    reportNow(flags, "unable to format warning message");
+    return;
+  }
+
+  reportNow(flags, message);
+  free(message);
+}
+
+#endif // !SWIFT_DEMANGLE_USE_RUNTIME_ERRORS
+
+// -- Public API -------------------------------------------------------------
+
+namespace swift {
+namespace Demangle {
+SWIFT_BEGIN_INLINE_NAMESPACE
+
+SWIFT_NORETURN void fatal(uint32_t flags, const char *format, ...) {
+  va_list val;
+
+  va_start(val, format);
+  fatalv(flags, format, val);
+}
+
+void warn(uint32_t flags, const char *format, ...) {
+  va_list val;
+
+  va_start(val, format);
+  warnv(flags, format, val);
+  va_end(val);
+}
+
+SWIFT_NORETURN void fatalv(uint32_t flags, const char *format, va_list val) {
+#if SWIFT_DEMANGLE_USE_RUNTIME_ERRORS
+  swift::fatalErrorv(flags, format, val);
+#else
+  demangleFatal(flags, format, val);
+#endif
+}
+
+void warnv(uint32_t flags, const char *format, va_list val) {
+#if SWIFT_DEMANGLE_USE_RUNTIME_ERRORS
+  swift::warningv(flags, format, val);
+#else
+  demangleWarn(flags, format, val);
+#endif
+}
+
+SWIFT_END_INLINE_NAMESPACE
+} // end namespace Demangle
+} // end namespace swift