[Backtracing] Various improvements following Johannes' remarks.

Removed some unnecessary memory rebinding.

Made `CFString` conversion slightly more efficient.

Provide the `SharedCacheInfo` fields everywhere, but make it optional all
over as well.

rdar://104336548

Author: al45tair

stdlib/public/Backtracing/Backtrace.swift

@@ -180,7 +180,6 @@ public struct Backtrace: CustomStringConvertible, Sendable {
 
   /// Holds information about the shared cache.
   public struct SharedCacheInfo: Sendable {
-    #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
     /// The UUID from the shared cache.
     public var uuid: [UInt8]
 
@@ -189,7 +188,6 @@ public struct Backtrace: CustomStringConvertible, Sendable {
 
     /// Says whether there is in fact a shared cache.
     public var noCache: Bool
-    #endif
   }
 
   /// Information about the shared cache.
@@ -401,34 +399,31 @@ public struct Backtrace: CustomStringConvertible, Sendable {
   /// Capture shared cache information.
   ///
   /// @returns A `SharedCacheInfo`.
-  public static func captureSharedCacheInfo() -> SharedCacheInfo {
+  public static func captureSharedCacheInfo() -> SharedCacheInfo? {
     #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
     return captureSharedCacheInfo(for: mach_task_self_)
     #else
-    return SharedCacheInfo()
+    return nil
     #endif
   }
 
   @_spi(Internal)
-  public static func captureSharedCacheInfo(for t: Any) -> SharedCacheInfo {
+  public static func captureSharedCacheInfo(for t: Any) -> SharedCacheInfo? {
     #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
     let task = t as! task_t
     return withDyldProcessInfo(for: task){ dyldInfo in
       var cacheInfo = dyld_process_cache_info()
       _dyld_process_info_get_cache(dyldInfo, &cacheInfo)
       let theUUID = withUnsafePointer(to: cacheInfo.cacheUUID){
-        $0.withMemoryRebound(to: UInt8.self,
-                             capacity: MemoryLayout<uuid_t>.size) {
-          Array(UnsafeBufferPointer(start: $0,
-                                    count: MemoryLayout<uuid_t>.size))
-        }
+        Array(UnsafeRawBufferPointer(start: $0,
+                                     count: MemoryLayout<uuid_t>.size))
       }
       return SharedCacheInfo(uuid: theUUID,
                              baseAddress: cacheInfo.cacheBaseAddress,
                              noCache: cacheInfo.noCache)
     }
     #else // !os(Darwin)
-    return SharedCacheInfo()
+    return nil
     #endif
   }
 

stdlib/public/Backtracing/BacktraceFormatter.swift

@@ -690,7 +690,7 @@ public struct BacktraceFormatter {
 
     while feof(fp) == 0 && ferror(fp) == 0 {
       guard let result = fgets(buffer.baseAddress,
-                               Int32(buffer.count), fp) else {
+                               CInt(buffer.count), fp) else {
         break
       }
 

stdlib/public/Backtracing/CoreSymbolication.swift

@@ -117,8 +117,8 @@ private enum Sym {
 // CFString.  As a result, we need to do the dance manually.
 
 private func toCFString(_ s: String) -> CFString! {
-  let bytes = Array<UInt8>(s.utf8)
-  return bytes.withUnsafeBufferPointer{
+  var s = s
+  return s.withUTF8 {
     return CFStringCreateWithBytes(nil,
                                    $0.baseAddress,
                                    $0.count,
@@ -135,10 +135,8 @@ private func fromCFString(_ cf: CFString) -> String {
 
   if let ptr = CFStringGetCStringPtr(cf,
                                      CFStringBuiltInEncodings.ASCII.rawValue) {
-    return ptr.withMemoryRebound(to: UInt8.self, capacity: length) {
-      return String(decoding: UnsafeBufferPointer(start: $0, count: length),
-                    as: UTF8.self)
-    }
+    return String(decoding: UnsafeRawBufferPointer(start: ptr, count: length),
+                  as: UTF8.self)
   } else {
     var byteLen = CFIndex(0)
 

stdlib/public/Backtracing/SymbolicatedBacktrace.swift

@@ -211,7 +211,7 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
   public var images: [Backtrace.Image]
 
   /// Shared cache information.
-  public var sharedCacheInfo: Backtrace.SharedCacheInfo
+  public var sharedCacheInfo: Backtrace.SharedCacheInfo?
 
   /// True if this backtrace is a Swift runtime failure.
   public var isSwiftRuntimeFailure: Bool {
@@ -233,7 +233,7 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
 
   /// Construct a SymbolicatedBacktrace from a backtrace and a list of images.
   private init(backtrace: Backtrace, images: [Backtrace.Image],
-               sharedCacheInfo: Backtrace.SharedCacheInfo,
+               sharedCacheInfo: Backtrace.SharedCacheInfo?,
                frames: [Frame]) {
     self.backtrace = backtrace
     self.images = images
@@ -258,7 +258,7 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
 
   /// Create a symbolicator.
   private static func withSymbolicator<T>(images: [Backtrace.Image],
-                                          sharedCacheInfo: Backtrace.SharedCacheInfo,
+                                          sharedCacheInfo: Backtrace.SharedCacheInfo?,
                                           fn: (CSSymbolicatorRef) throws -> T) rethrows -> T {
     let binaryImageList = images.map{ image in
       BinaryImageInformation(
@@ -357,7 +357,7 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
       theImages = Backtrace.captureImages()
     }
 
-    let theCacheInfo: Backtrace.SharedCacheInfo
+    let theCacheInfo: Backtrace.SharedCacheInfo?
     if let sharedCacheInfo = sharedCacheInfo {
       theCacheInfo = sharedCacheInfo
     } else if let sharedCacheInfo = backtrace.sharedCacheInfo {
@@ -450,14 +450,14 @@ public struct SymbolicatedBacktrace: CustomStringConvertible {
       lines.append("\(n)\t\(image)")
     }
 
-    #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-    lines.append("")
-    lines.append("Shared Cache:")
-    lines.append("")
-    lines.append("    UUID: \(hex(sharedCacheInfo.uuid))")
-    lines.append("    Base: \(hex(sharedCacheInfo.baseAddress))")
-    lines.append("  Active: \(!sharedCacheInfo.noCache)")
-    #endif
+    if let sharedCacheInfo = sharedCacheInfo {
+      lines.append("")
+      lines.append("Shared Cache:")
+      lines.append("")
+      lines.append("    UUID: \(hex(sharedCacheInfo.uuid))")
+      lines.append("    Base: \(hex(sharedCacheInfo.baseAddress))")
+      lines.append("  Active: \(!sharedCacheInfo.noCache)")
+    }
 
     return lines.joined(separator: "\n")
   }