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 when done with it.
+///
+/// If @a str cannot be converted to UTF-8, @c nullptr is returned.
+SWIFT_RUNTIME_STDLIB_INTERNAL
+char *swift_copyUTF8FromWide(const wchar_t *str);
+}
+#endif
+#endif

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -138,10 +138,10 @@ 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>?
 #endif
 
 extension Section {
@@ -154,9 +154,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 {
+      cName.deallocate()
+    }
+    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_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

@@ -149,12 +149,15 @@ 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);
+  llvm::StringRef libraryName{"<unavailable>"};
+  if (const char *filename = syminfo->getFilename()) {
+    libraryName = filename;
+    libraryName = libraryName.substr(libraryName.rfind('/')).substr(1);
+  }
 
   // Next we get the symbol name that we are going to use in our backtrace.
   std::string symbolName;
@@ -168,7 +171,7 @@ void swift::dumpStackTraceEntry(unsigned index, void *framePC,
   if (foundSymbol) {
     offset = ptrdiff_t(uintptr_t(framePC) - symbolAddr);
   } else {
-    auto baseAddress = syminfo->getBaseAddress();
+    const void *baseAddress = syminfo->getBaseAddress();
     offset = ptrdiff_t(uintptr_t(framePC) - uintptr_t(baseAddress));
     symbolAddr = uintptr_t(framePC);
     symbolName = "<unavailable>";

stdlib/public/runtime/ImageInspectionCommon.cpp

@@ -188,11 +188,10 @@ 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();
+      return strdup(info->getFilename());
     }
   }
   return "";

stdlib/public/runtime/ImageInspectionCommon.h

@@ -86,8 +86,8 @@ 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_getMetadataSectionBaseAddress(

stdlib/public/runtime/ReflectionMirror.cpp

@@ -1116,10 +1116,9 @@ 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());
-    }
+  auto info = SymbolInfo::lookup(address);
+  if (info.has_value() && info->getSymbolName()) {
+    return strdup(info->getSymbolName());
   }
   return nullptr;
 }

stdlib/public/runtime/SymbolInfo.cpp

@@ -1,8 +1,8 @@
-//===--- ImageInspectionWin32.cpp - Win32 image inspection ----------------===//
+//===--- SymbolInfo.cpp ---------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// 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
@@ -17,17 +17,62 @@
 #define NOMINMAX
 #include <Windows.h>
 #include <DbgHelp.h>
+#include <Psapi.h>
 #elif SWIFT_STDLIB_HAS_DLADDR
 #include <dlfcn.h>
 #endif
 
+#include <array>
+#include <cstdlib>
+
 #include "ImageInspection.h"
+#include "swift/Runtime/Win32Strings.h"
 
 using namespace swift;
 
+SymbolInfo::SymbolInfo()
+#if defined(_WIN32) && !defined(__CYGWIN__)
+: _package({}),
+#elif SWIFT_STDLIB_HAS_DLADDR
+: _info({}),
+#endif
+_address(nullptr)
+{
+}
+
+SymbolInfo::~SymbolInfo() {
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  if (char *filename = _filename.getValueOr(nullptr)) {
+    free(filename);
+  }
+#endif
+}
+
+const void *SymbolInfo::getAddress() const {
+  return _address;
+}
+
 const char *SymbolInfo::getFilename() const {
 #if defined(_WIN32) && !defined(__CYGWIN__)
-  return nullptr;
+  if (!_filename.has_value()) {
+    // On Win32/Win64, the base address of a loaded image and its HMODULE are
+    // the same pointer, so we can simply cast from one to the other.
+    HMODULE hModule = reinterpret_cast<HMODULE>(getBaseAddress());
+    if (!hModule) {
+      _filename = nullptr;
+      return;
+    }
+
+    // Call GetModuleFileNameW() instead of SymGetModuleInfoW() because it
+    // doesn't require the use of the global DbgHelp lock and doesn't fetch
+    // other information we don't need.
+    std::array<wchar_t, MAX_PATH> filename;
+    if (GetModuleFileNameW(hModule, filename.data(), filename.size())) {
+      _filename = swift_copyUTF8FromWide(filename.data());
+    }
+  }
+
+  return _filename.getValueOr(nullptr);
 #elif SWIFT_STDLIB_HAS_DLADDR
   return _info.dli_fname;
 #else
@@ -76,14 +121,25 @@ llvm::Optional<SymbolInfo> SymbolInfo::lookup(const void *address) {
 #elif defined(_WIN32) && !defined(__CYGWIN__)
   _swift_win32_withDbgHelpLibrary([&] (HANDLE hProcess) {
     if (!hProcess) {
-        return;
+      return;
     }
 
+    // If there are real-world examples of symbol names with Unicode characters
+    // that we need to consider, SymbolInfo can hold a SYMBOL_INFO_PACKAGEW and
+    // call SymFromAddrW(), then lazily convert to UTF-8 on the first call to
+    // getSymbolName() as is done in getFilename().
     SymbolInfo info;
     info._package.si.SizeOfStruct = sizeof(SYMBOL_INFO);
     info._package.si.MaxNameLen = MAX_SYM_NAME;
     if (SymFromAddr(hProcess, reinterpret_cast<const DWORD64>(address),
                     nullptr, &info._package.si)) {
+      // Symbols without debug information available, such as those from the OS,
+      // may not resolve a module base address. We can resolve it manually by
+      // calling SymGetModuleBase() here.
+      if (info._package.si.Address != 0 && info._package.si.ModBase == 0) {
+        info._package.si.ModBase = SymGetModuleBase(hProcess,
+                                                    info._package.si.Address);
+      }
       result = info;
     }
   });
@@ -94,5 +150,10 @@ llvm::Optional<SymbolInfo> SymbolInfo::lookup(const void *address) {
   }
 #endif
 
+  if (result.has_value()) {
+    result->_address = address;
+  }
+
   return result;
 }
+

stdlib/public/runtime/SymbolInfo.h

@@ -1,22 +1,14 @@
-//===--- ImageInspection.h - Image inspection routines ----------*- C++ -*-===//
+//===--- SymbolInfo.h -----------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// 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
 //
 //===----------------------------------------------------------------------===//
-///
-/// \file
-///
-/// This file includes routines that extract metadata from executable and
-/// dynamic library image files generated by the Swift compiler. The concrete
-/// implementations vary greatly by platform.
-///
-//===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_RUNTIME_SYMBOLINFO_H
 #define SWIFT_RUNTIME_SYMBOLINFO_H
@@ -44,13 +36,20 @@ struct SymbolInfo {
 private:
 #if defined(_WIN32) && !defined(__CYGWIN__)
   SYMBOL_INFO_PACKAGE _package;
+  mutable llvm::Optional<char *> _filename;
 #elif SWIFT_STDLIB_HAS_DLADDR
   Dl_info _info;
 #endif
+  const void *_address;
 
-public:
   SymbolInfo() {}
 
+public:
+  ~SymbolInfo();
+
+  /// Get the address that was originally passed when this instance was created.
+  const void *getAddress() const;
+
   /// Get the file name of the image where the symbol was found.
   ///
   /// The resulting C string is only valid for the lifetime of \c this.
@@ -61,10 +60,16 @@ struct SymbolInfo {
 
   /// Get the name of the symbol.
   ///
+  /// If the input address is valid within a loaded library, but does not
+  /// correspond to any known symbol, the resulting pointer may be \c nullptr.
+  ///
   /// The resulting C string is only valid for the lifetime of \c this.
   const char *getSymbolName() const;
 
   /// Get the address of the symbol.
+  ///
+  /// If the input address is valid within a loaded library, but does not
+  /// correspond to any known symbol, the resulting pointer may be \c nullptr.
   const void *getSymbolAddress() const;
 
   /// Look up a symbol by address.