[Backtracing] Add platform and architecture information.

It's useful to capture the platform and platform version with the image map.
Also, display both the platform and architecture information when generating
a crash log.

rdar://124913332

Author: al45tair

docs/CompactImageMapFormat.md

@@ -39,10 +39,14 @@ follows:
 |   10   | 64-bit            |
 |   11   | Reserved          |
 
-This is followed immediately by a field encoding the number of images
-in the image map; this field is encoded as a sequence of bytes, each
-holding seven bits of data, with the top bit clear for the final byte.
-The most significant byte is the first.  e.g.
+This is followed immediately by a field containing the name of the platform
+that generated this image map.  This field consists of a single byte length
+followed by a UTF-8 string of that length.
+
+After that is a field encoding the number of images in the image map;
+this field is encoded as a sequence of bytes, each holding seven bits
+of data, with the top bit clear for the final byte.  The most
+significant byte is the first.  e.g.
 
 | `count` | Encoding    |
 | ------: | :---------- |

stdlib/public/RuntimeModule/Address.swift

@@ -164,7 +164,7 @@ extension FixedWidthInteger {
   ///
   /// This initializer will return nil if the address width is larger than the
   /// type you are attempting to convert into.
-  init?(_ address: Backtrace.Address) {
+  public init?(_ address: Backtrace.Address) {
     guard let result = address.toFixedWidth(type: Self.self) else {
       return nil
     }
@@ -174,7 +174,7 @@ extension FixedWidthInteger {
 
 extension Backtrace.Address {
   /// Convert from a UInt16.
-  init(_ value: UInt16) {
+  public init(_ value: UInt16) {
     if value == 0 {
       self.representation = .null
       return
@@ -183,7 +183,7 @@ extension Backtrace.Address {
   }
 
   /// Convert from a UInt32.
-  init(_ value: UInt32) {
+  public init(_ value: UInt32) {
     if value == 0 {
       self.representation = .null
       return
@@ -192,7 +192,7 @@ extension Backtrace.Address {
   }
 
   /// Convert from a UInt64.
-  init(_ value: UInt64) {
+  public init(_ value: UInt64) {
     if value == 0 {
       self.representation = .null
       return
@@ -201,21 +201,16 @@ extension Backtrace.Address {
   }
 
   /// Convert from a FixedWidthInteger
-  init<T: FixedWidthInteger>(_ value: T) {
-    if value == 0 {
-      self.representation = .null
-      return
-    }
-
+  public init?<T: FixedWidthInteger>(_ value: T) {
     switch T.bitWidth {
       case 16:
-        self.representation = .sixteenBit(UInt16(value))
+        self.init(UInt16(value))
       case 32:
-        self.representation = .thirtyTwoBit(UInt32(value))
+        self.init(UInt32(value))
       case 64:
-        self.representation = .sixtyFourBit(UInt64(value))
+        self.init(UInt64(value))
       default:
-        fatalError("Unsupported address width")
+        return nil
     }
   }
 }

stdlib/public/RuntimeModule/Backtrace.swift

@@ -229,7 +229,7 @@ public struct Backtrace: CustomStringConvertible, Sendable {
   }
 
   /// The architecture of the system that captured this backtrace.
-  public var architecture: String
+  public internal(set) var architecture: String
 
   /// The actual backtrace data, stored in Compact Backtrace Format.
   var representation: [UInt8]
@@ -345,7 +345,7 @@ public struct Backtrace: CustomStringConvertible, Sendable {
 
   /// Provide a textual version of the backtrace.
   public var description: String {
-    var lines: [String] = []
+    var lines: [String] = ["Architecture: \(architecture)", ""]
 
     var n = 0
     for frame in frames {

stdlib/public/RuntimeModule/CMakeLists.txt

@@ -48,6 +48,7 @@ set(RUNTIME_SOURCES
   Libc.swift
   LimitSequence.swift
   MemoryReader.swift
+  OSReleaseScanner.swift
   ProcMapsScanner.swift
   Registers.swift
   Runtime.swift

stdlib/public/RuntimeModule/CompactImageMap.swift

@@ -101,6 +101,25 @@ public enum CompactImageMapFormat {
       return value
     }
 
+    mutating func decodeString() -> String? {
+      guard let utf8Length = iterator.next() else {
+        return nil
+      }
+
+      var bytes: [UInt8] = []
+      bytes.reserveCapacity(Int(utf8Length))
+
+      for _ in 0..<utf8Length {
+        guard let byte = iterator.next() else {
+          return nil
+        }
+
+        bytes.append(byte)
+      }
+
+      return String(decoding: bytes, as: UTF8.self)
+    }
+
     mutating func decodeAddress(_ count: Int) -> UInt64? {
       var word: UInt64
       guard let firstByte = iterator.next() else {
@@ -250,7 +269,7 @@ public enum CompactImageMapFormat {
       }
     }
 
-    mutating func decode() -> ([ImageMap.Image], ImageMap.WordSize)? {
+    mutating func decode() -> (String, [ImageMap.Image], ImageMap.WordSize)? {
       // Check the version and decode the size
       guard let infoByte = iterator.next() else {
         return nil
@@ -274,6 +293,11 @@ public enum CompactImageMapFormat {
           wordMask = 0xffffffffffffff00
       }
 
+      // Now decode the platform
+      guard let platform = decodeString() else {
+        return nil
+      }
+
       // Next is the image count
       guard let count = decodeCount() else {
         return nil
@@ -392,7 +416,7 @@ public enum CompactImageMapFormat {
           wsMap = .sixtyFourBit
       }
 
-      return (images, wsMap)
+      return (platform, images, wsMap)
     }
   }
 
@@ -414,6 +438,7 @@ public enum CompactImageMapFormat {
     public struct Iterator: IteratorProtocol {
       enum State {
         case start
+        case platform(Int)
         case count(Int)
         case image
         case baseAddress(Int)
@@ -483,14 +508,39 @@ public enum CompactImageMapFormat {
                 size = .sixtyFourBit
             }
 
-            let count = source.images.count
-            let bits = Int.bitWidth - count.leadingZeroBitCount
-            state = .count(7 * (bits / 7))
+            state = .platform(-1)
 
             let version: UInt8 = 0
             let infoByte = (version << 2) | size.rawValue
             return infoByte
 
+          case let .platform(ndx):
+            let length = UInt8(source.platform.utf8.count)
+            let byte: UInt8
+
+            if ndx == -1 {
+              // The length byte comes first
+              byte = length
+            } else {
+              byte = source.platform.utf8[
+                source.platform.utf8.index(
+                  source.platform.utf8.startIndex,
+                  offsetBy: ndx
+                )
+              ]
+            }
+
+            // If we're done, move to the .count state
+            if ndx + 1 == length {
+              let count = source.images.count
+              let bits = Int.bitWidth - count.leadingZeroBitCount
+              state = .count(7 * (bits / 7))
+            } else {
+              state = .platform(ndx + 1)
+            }
+
+            return byte
+
           case let .count(ndx):
             let count = source.images.count
             let byte = UInt8(truncatingIfNeeded:(count >> ndx) & 0x7f)

stdlib/public/RuntimeModule/ImageMap+Darwin.swift

@@ -21,8 +21,44 @@ import Swift
 internal import Darwin
 internal import BacktracingImpl.OS.Darwin
 
+fileprivate func getSysCtlString(_ name: String) -> String? {
+  return withUnsafeTemporaryAllocation(byteCount: 256, alignment: 16) {
+    (buffer: UnsafeMutableRawBufferPointer) -> String? in
+
+    var len = buffer.count
+    let ret = sysctlbyname(name,
+                           buffer.baseAddress, &len,
+                           nil, 0)
+    if ret != 0 {
+      return nil
+    }
+
+    return String(validatingUTF8:
+                    buffer.baseAddress!.assumingMemoryBound(to: CChar.self))
+  }
+}
+
 extension ImageMap {
 
+  private static let platform = {
+    #if os(macOS)
+    var platform = "macOS"
+    #elseif os(iOS)
+    var platform = "iOS"
+    #elseif os(watchOS)
+    var platform = "watchOS"
+    #elseif os(tvOS)
+    var platform = "tvOS"
+    #elseif os(visionOS)
+    var platform = "visionOS"
+    #endif
+
+    let osVersion = getSysCtlString("kern.osversion") ?? "<unknown>"
+    let osProductVersion = getSysCtlString("kern.osproductversion") ?? "<unknown>"
+
+    return "\(platform) \(osProductVersion) (\(osVersion))"
+  }()
+
   private static func withDyldProcessInfo<T>(for task: task_t,
                                              fn: (OpaquePointer?) throws -> T)
     rethrows -> T {
@@ -83,7 +119,11 @@ extension ImageMap {
 
     images.sort(by: { $0.baseAddress < $1.baseAddress })
 
-    return ImageMap(images: images, wordSize: .sixtyFourBit)
+    return ImageMap(
+      platform: ImageMap.platform,
+      images: images,
+      wordSize: .sixtyFourBit
+    )
   }
 
 }

stdlib/public/RuntimeModule/ImageMap+Linux.swift

@@ -26,8 +26,52 @@ internal import Musl
 
 internal import BacktracingImpl.ImageFormats.Elf
 
+fileprivate func readOSRelease(fd: CInt) -> [String:String]? {
+  let len = lseek(fd, 0, SEEK_END)
+  guard len >= 0 else {
+    return nil
+  }
+  return withUnsafeTemporaryAllocation(byteCount: len, alignment: 16) {
+    (buffer: UnsafeMutableRawBufferPointer) -> [String:String]? in
+
+    _ = lseek(fd, 0, SEEK_SET)
+    let bytesRead = read(fd, buffer.baseAddress, buffer.count)
+    guard bytesRead == buffer.count else {
+      return nil
+    }
+
+    let asString = String(decoding: buffer, as: UTF8.self)
+    return Dictionary(OSReleaseScanner(asString),
+                      uniquingKeysWith: { $1 })
+  }
+}
+
+fileprivate func readOSRelease() -> [String:String]? {
+  var fd = open("/etc/os-release", O_RDONLY)
+  if fd == -1 {
+    fd = open("/usr/lib/os-release", O_RDONLY)
+  }
+  if fd == -1 {
+    return nil
+  }
+  defer {
+    close(fd)
+  }
+
+  return readOSRelease(fd: fd)
+}
+
 extension ImageMap {
 
+  private static var platform = {
+    guard let info = readOSRelease(),
+          let pretty = info["PRETTY_NAME"] else {
+      return "Linux (unknown)"
+    }
+
+    return "Linux (\(pretty))"
+  }()
+
   private struct AddressRange {
     var low: Address = 0
     var high: Address = 0
@@ -59,7 +103,7 @@ extension ImageMap {
     }
 
     guard let procMaps = readString(from: path) else {
-      return ImageMap(images: [], wordSize: wordSize)
+      return ImageMap(platform: ImageMap.platform, images: [], wordSize: wordSize)
     }
 
     // Find all the mapped files and get high/low ranges
@@ -113,7 +157,11 @@ extension ImageMap {
 
     images.sort(by: { $0.baseAddress < $1.baseAddress })
 
-    return ImageMap(images: images, wordSize: wordSize)
+    return ImageMap(
+      platform: ImageMap.platform,
+      images: images,
+      wordSize: wordSize
+    )
   }
 
 }