Implement SymbolInfo::getFilename() on Win32

Author: grynspan

include/swift/Runtime/Win32Strings.h

@@ -0,0 +1,35 @@
+//===--- Win32Strings.h ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Includes conversion functions for use with Windows API that produces or
+// consumes wide strings (wchar_t) which, on Windows, are UTF-16.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_WIN32STRINGS_H
+#define SWIFT_RUNTIME_WIN32STRINGS_H
+
+#if defined(_WIN32)
+namespace swift {
+/// Convert an argument, represented by a wide string, to UTF-8.
+///
+/// @param str The string to convert.
+///
+/// @returns The string, converted to UTF-8. The caller is responsible for
+///   freeing this string with @c free() when done with it.
+///
+/// If @a str cannot be converted to UTF-8, @c nullptr is returned.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+char *swift_win32_copyUTF8FromWide(const wchar_t *str);
+}
+#endif
+#endif

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -138,10 +138,15 @@ internal func _getMetadataSection(_ index: UInt) -> UnsafeRawPointer?
 @_silgen_name("swift_getMetadataSectionCount")
 internal func _getMetadataSectionCount() -> UInt
 
-@_silgen_name("swift_getMetadataSectionName")
-internal func _getMetadataSectionName(
+@_silgen_name("swift_copyMetadataSectionName")
+internal func _copyMetadataSectionName(
   _ metadata_section: UnsafeRawPointer
-) -> UnsafePointer<CChar>
+) -> UnsafeMutablePointer<CChar>?
+
+@_silgen_name("swift_freeMetadataSectionName")
+internal func _freeMetadataSectionName(
+  _ name: UnsafeMutablePointer<CChar>
+) -> Void
 #endif
 
 extension Section {
@@ -154,9 +159,13 @@ extension Section {
 internal func getReflectionInfoForImage(atIndex i: UInt32) -> ReflectionInfo? {
 #if INTERNAL_CHECKS_ENABLED
   return _getMetadataSection(UInt(i)).map { rawPointer in
-    let name = _getMetadataSectionName(rawPointer)
+    let cName = _copyMetadataSectionName(rawPointer)
+    defer {
+      _freeMetadataSectionName(cName)
+    }
+    let name = cName.flatMap { String(validatingUTF8: $0) } ?? "<unavailable>"
     let metadataSection = rawPointer.bindMemory(to: MetadataSections.self, capacity: 1).pointee
-    return ReflectionInfo(imageName: String(validatingUTF8: name)!,
+    return ReflectionInfo(imageName: name,
             fieldmd: Section(range: metadataSection.swift5_fieldmd),
             assocty: Section(range: metadataSection.swift5_assocty),
             builtin: Section(range: metadataSection.swift5_builtin),

stdlib/public/CommandLineSupport/CommandLine.cpp

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "swift/Runtime/Debug.h"
+#include "swift/Runtime/Win32Strings.h"
 
 #include "swift/shims/GlobalObjects.h"
 #include "swift/shims/RuntimeStubs.h"
@@ -193,48 +194,6 @@ static void swift::enumerateUnsafeArgv(const F& body) {
 #elif defined(_WIN32)
 #include <stdlib.h>
 
-namespace swift {
-  /// Convert an argument, represented by a wide string, to UTF-8.
-  ///
-  /// @param str The string to convert.
-  /// 
-  /// @returns The string, converted to UTF-8. The caller is responsible for
-  ///   freeing this string when done with it.
-  /// 
-  /// If @a str cannot be converted to UTF-8, a fatal error occurs.
-  static char *copyUTF8FromWide(wchar_t *str) {
-    char *result = nullptr;
-
-    int resultLength = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, str,
-      -1, nullptr, 0, nullptr, nullptr);
-    if (resultLength <= 0) {
-      swift::fatalError(0,
-        "Fatal error: Could not get length of commandline "
-        "argument '%ls': %lu\n",
-        str, GetLastError());
-    }
-
-    result = reinterpret_cast<char *>(malloc(resultLength));
-    if (!result) {
-      swift::fatalError(0,
-        "Fatal error: Could not allocate space for commandline "
-        "argument '%ls': %d\n",
-        str, errno);
-    }
-
-    resultLength = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, str, -1,
-      result, resultLength, nullptr, nullptr);
-    if (resultLength <= 0) {
-      swift::fatalError(0,
-        "Fatal error: Conversion to UTF-8 failed for "
-        "commandline argument '%ls': %lu\n",
-        str, GetLastError());
-    }
-
-    return result;
-  }
-}
-
 static char **swift::getUnsafeArgvArgc(int *outArgLen) {
   return nullptr;
 }
@@ -244,7 +203,13 @@ static void swift::enumerateUnsafeArgv(const F& body) {
   int argc = 0;
   if (LPWSTR *wargv = CommandLineToArgvW(GetCommandLineW(), &argc)) {
     std::for_each(wargv, wargv + argc, [=] (wchar_t *warg) {
-      auto arg = copyUTF8FromWide(warg);
+      auto arg = swift_win32_copyUTF8FromWide(warg);
+      if (!arg) {
+        swift::fatalError(0,
+                          "Fatal error: Could not convert commandline argument "
+                          "'%ls' to UTF-8: Windows error %lu, C error %d.\n",
+                          warg, GetLastError(), errno);
+      }
       body(argc, arg);
       free(arg);
     });

stdlib/public/runtime/CMakeLists.txt

@@ -69,7 +69,8 @@ set(swift_runtime_sources
     SwiftDtoa.cpp
     SwiftTLSContext.cpp
     ThreadingError.cpp
-    AccessibleFunction.cpp)
+    AccessibleFunction.cpp
+    Win32Strings.cpp)
 
 # Acknowledge that the following sources are known.
 set(LLVM_OPTIONAL_SOURCES

stdlib/public/runtime/Errors.cpp

@@ -78,8 +78,7 @@ enum: uint32_t {
 using namespace swift;
 
 #if SWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING && SWIFT_STDLIB_HAS_DLADDR
-static bool getSymbolNameAddr(llvm::StringRef libraryName,
-                              const SymbolInfo &syminfo,
+static bool getSymbolNameAddr(const SymbolInfo &syminfo,
                               std::string &symbolName, uintptr_t &addrOut) {
   // If we failed to find a symbol and thus dlinfo->dli_sname is nullptr, we
   // need to use the hex address.
@@ -149,12 +148,14 @@ void swift::dumpStackTraceEntry(unsigned index, void *framePC,
     return;
   }
 
-  // If SymbolInfo:lookup succeeded then fileName is non-null. Thus, we find the
+  // If SymbolInfo:lookup succeeded and fileName is non-null, we can find the
   // library name here. Avoid using StringRef::rsplit because its definition
   // is not provided in the header so that it requires linking with
   // libSupport.a.
-  llvm::StringRef libraryName{syminfo->getFilename()};
-  libraryName = libraryName.substr(libraryName.rfind('/')).substr(1);
+  const char *libraryName = syminfo->getImageFilename();
+  if (!libraryName) {
+    libraryName = "<unavailable>";
+  }
 
   // Next we get the symbol name that we are going to use in our backtrace.
   std::string symbolName;
@@ -163,12 +164,12 @@ void swift::dumpStackTraceEntry(unsigned index, void *framePC,
   // we just get HexAddr + 0.
   uintptr_t symbolAddr = uintptr_t(framePC);
   bool foundSymbol =
-      getSymbolNameAddr(libraryName, syminfo.value(), symbolName, symbolAddr);
+      getSymbolNameAddr(syminfo.value(), symbolName, symbolAddr);
   ptrdiff_t offset = 0;
   if (foundSymbol) {
     offset = ptrdiff_t(uintptr_t(framePC) - symbolAddr);
   } else {
-    auto baseAddress = syminfo->getBaseAddress();
+    const void *baseAddress = syminfo->getImageBaseAddress();
     offset = ptrdiff_t(uintptr_t(framePC) - uintptr_t(baseAddress));
     symbolAddr = uintptr_t(framePC);
     symbolName = "<unavailable>";
@@ -182,12 +183,11 @@ void swift::dumpStackTraceEntry(unsigned index, void *framePC,
   // This gives enough info to reconstruct identical debugging target after
   // this process terminates.
   if (shortOutput) {
-    fprintf(stderr, "%s`%s + %td", libraryName.data(), symbolName.c_str(),
-            offset);
+    fprintf(stderr, "%s`%s + %td", libraryName, symbolName.c_str(), offset);
   } else {
     constexpr const char *format = "%-4u %-34s 0x%0.16" PRIxPTR " %s + %td\n";
-    fprintf(stderr, format, index, libraryName.data(), symbolAddr,
-            symbolName.c_str(), offset);
+    fprintf(stderr, format, index, libraryName, symbolAddr, symbolName.c_str(),
+            offset);
   }
 #else
   if (shortOutput) {

stdlib/public/runtime/ImageInspectionCommon.cpp

@@ -64,10 +64,10 @@ static void fixupMetadataSectionBaseAddress(swift::MetadataSections *sections) {
   if (fixupNeeded) {
     // We need to fix up the base address. We'll need a known-good address in
     // the same image: `sections` itself will work nicely.
-    auto symbolInfo = SymbolInfo::lookup(sections);
-    if (symbolInfo.has_value() && symbolInfo->getBaseAddress()) {
-        sections->baseAddress.store(symbolInfo->getBaseAddress(),
-                                    std::memory_order_relaxed);
+    if (auto symbolInfo = SymbolInfo::lookup(sections)) {
+      if (const void *baseAddress = symbolInfo->getImageBaseAddress()) {
+        sections->baseAddress.store(baseAddress, std::memory_order_relaxed);
+      }
     }
   }
 }
@@ -188,22 +188,26 @@ const swift::MetadataSections *swift_getMetadataSection(size_t index) {
 }
 
 SWIFT_RUNTIME_EXPORT
-const char *
-swift_getMetadataSectionName(const swift::MetadataSections *section) {
+char *swift_copyMetadataSectionName(const swift::MetadataSections *section) {
   if (auto info = SymbolInfo::lookup(section)) {
-    if (info->getFilename()) {
-      return info->getFilename();
+    if (const char *imagePath = info->getImagePath()) {
+      return strdup(imagePath);
     }
   }
   return "";
 }
 
+SWIFT_RUNTIME_EXPORT
+void swift_freeMetadataSectionName(char *name) {
+  free(name);
+}
+
 SWIFT_RUNTIME_EXPORT
 void swift_getMetadataSectionBaseAddress(const swift::MetadataSections *section,
                                          void const **out_actual,
                                          void const **out_expected) {
   if (auto info = SymbolInfo::lookup(section)) {
-    *out_actual = info->getBaseAddress();
+    *out_actual = info->getImageBaseAddress();
   } else {
     *out_actual = nullptr;
   }

stdlib/public/runtime/ImageInspectionCommon.h

@@ -86,8 +86,11 @@ void swift_enumerateAllMetadataSections(
 #ifndef NDEBUG
 
 SWIFT_RUNTIME_EXPORT
-const char *
-swift_getMetadataSectionName(const struct swift::MetadataSections *section);
+char *
+swift_copyMetadataSectionName(const struct swift::MetadataSections *section);
+
+SWIFT_RUNTIME_EXPORT
+void swift_freeMetadataSectionName(char *name);
 
 SWIFT_RUNTIME_EXPORT
 void swift_getMetadataSectionBaseAddress(

stdlib/public/runtime/ReflectionMirror.cpp

@@ -1117,8 +1117,8 @@ id swift_reflectionMirror_quickLookObject(OpaqueValue *value, const Metadata *T)
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
 const char *swift_keyPath_copySymbolName(void *address) {
   if (auto info = SymbolInfo::lookup(address)) {
-    if (info->getSymbolName()) {
-      return strdup(info->getSymbolName());
+    if (const char *symbolName = info->getSymbolName()) {
+      return strdup(symbolName);
     }
   }
   return nullptr;