address some code review comments

Author: andrurogerz

tools/swift-inspect/Sources/SwiftInspectLinux/AuxVec.swift

@@ -14,60 +14,36 @@ import Foundation
 import LinuxSystemHeaders
 
 internal class AuxVec {
-  enum Error: Swift.Error { case FileReadFailure(_ filePath: String) }
-
-  // enum values must match the constants defined in usr/include/linux/auxv.h
-  enum Tag: UInt64 {
-    case AT_NULL = 0
-    case AT_IGNORE = 1
-    case AT_EXECFD = 2
-    case AT_PHDR = 3
-    case AT_PHENT = 4
-    case AT_PHNUM = 5
-    case AT_PAGESZ = 6
-    case AT_BASE = 7
-    case AT_FLAGS = 8
-    case AT_ENTRY = 9
-    case AT_NOTELF = 10
-    case AT_UID = 11
-    case AT_EUID = 12
-    case AT_GID = 13
-    case AT_EGID = 14
-    case AT_PLATFORM = 15
-    case AT_HWCAP = 16
-    case AT_CLKTCK = 17
-    case AT_SECURE = 23
-    case AT_BASE_PLATFORM = 24
-    case AT_RANDOM = 25
-    case AT_HWCAP2 = 26
-    case AT_RSEQ_FEATURE_SIZE = 27
-    case AT_RSEQ_ALIGN = 28
-    case AT_EXECFN = 31
-    case AT_SYSINFO_EHDR = 33
-    case AT_MINSIGSTKSZ = 51
-  }
-
-  static func load(for process: Process) throws -> [Tag: UInt64] {
+  // loads the auxiliary vector for a process
+  public static func load(for process: Process) -> [Int32 : UInt64]? {
     let filePath = "/proc/\(process.pid)/auxv"
-
-    let fileHandle = try FileHandle(forReadingFrom: URL(fileURLWithPath: filePath))
+    guard let fileHandle = FileHandle(forReadingAtPath: filePath) else { return nil }
     defer { fileHandle.closeFile() }
 
-    guard let data = try fileHandle.readToEnd() else { throw Error.FileReadFailure(filePath) }
+    guard let data = try? fileHandle.readToEnd(), data.count > 0 else { return nil }
 
-    // aux vector is an array of 8-byte pairs in a 64-bit process
-    assert(process.elfFile.isElf64, "only 64-bit processes are supported")
-    let auxVec: [(UInt64, UInt64)] = data.withUnsafeBytes {
-      let count = $0.count / MemoryLayout<(UInt64, UInt64)>.stride
-      return Array($0.bindMemory(to: (UInt64, UInt64).self)[..<count])
+    func fromData<T: UnsignedInteger>(_ data: Data) -> [(T, T)] {
+      return data.withUnsafeBytes {
+        let count = $0.count / MemoryLayout<(T, T)>.stride
+        return Array($0.bindMemory(to: (T, T).self)[..<count])
+      }
     }
 
-    var entries: [Tag: UInt64] = [:]
-    for (rawTag, value) in auxVec {
-      guard let tag = Tag(rawValue: rawTag) else { continue }
-      entries[tag] = value
+    func fromArray<T: UnsignedInteger>(_ array: [(T, T)]) -> [Int32: UInt64] {
+      var entries: [Int32: UInt64] = [:]
+      for (rawTag, value) in array {
+        // the AT_ constants defined in linux/auxv.h are imported as Int32
+        guard let tag = Int32(exactly: rawTag) else { continue }
+        entries[tag] = UInt64(value)
+      }
+      return entries
     }
 
-    return entries
+    // in a 32-bit process, aux vector is an array of 4-byte pairs
+    // in a 64-bit process, aux vector is an array of 8-byte pairs
+    return process.elfFile.isElf64
+        ? fromArray(fromData(data) as [(UInt64, UInt64)])
+        : fromArray(fromData(data) as [(UInt32, UInt32)])
   }
+
 }

tools/swift-inspect/Sources/SwiftInspectLinux/ElfFile.swift

@@ -77,7 +77,7 @@ class ElfFile {
   public func loadSymbols(baseAddress: UInt64 = 0) throws -> SymbolMap {
     guard let sectionCount = UInt(exactly: self.ehdr.shnum) else {
       throw Error.MalformedElfFile(
-        self.filePath, description: "invalid ehdr.shnum: \(self.ehdr.shnum)")
+        self.filePath, description: "invalid ElfEhdr.e_shnum: \(self.ehdr.shnum)")
     }
 
     var symbols: SymbolMap = [:]

tools/swift-inspect/Sources/SwiftInspectLinux/LinkMap.swift

@@ -28,14 +28,17 @@ class LinkMap {
   public let entries: [Entry]
 
   public init(for process: Process) throws {
-    let auxVec = try AuxVec.load(for: process)
-    guard let phdrAddr = auxVec[.AT_PHDR] else { throw Error.MissingAuxVecEntry("missing AT_PHDR") }
+    guard let auxVec = AuxVec.load(for: process) else {
+      throw Error.MissingAuxVecEntry("failed reading auxvec for \(process)")
+    }
+
+    guard let phdrAddr = auxVec[AT_PHDR] else { throw Error.MissingAuxVecEntry("missing AT_PHDR") }
 
-    guard let phdrSize = auxVec[.AT_PHENT] else {
+    guard let phdrSize = auxVec[AT_PHENT] else {
       throw Error.MissingAuxVecEntry("missing AT_PHENT")
     }
 
-    guard let phdrCount = auxVec[.AT_PHNUM] else {
+    guard let phdrCount = auxVec[AT_PHNUM] else {
       throw Error.MissingAuxVecEntry("missing AT_PHNUM")
     }
 

tools/swift-inspect/Sources/swift-inspect/Operations/DumpArray.swift

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if os(iOS) || os(macOS) || os(tvOS) || os(watchOS) || os(Windows)
+#if !os(Linux)
 
 import ArgumentParser
 import SwiftRemoteMirror