xcframework_converter 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2df06815d507bcbbd8d8ea83882fe3c55463dcc9532063d4566f8d196e378ada
-  data.tar.gz: f49c4301fb89b90b1e30e77cbee37e175ea1d432a1c104f62131d689857d0a58
+  metadata.gz: 8ed138cd025eb265a64d714f9342520dd10ca44c9d78120a20eb6695623f1e86
+  data.tar.gz: 870d95ae53553761641a9572a6e08f58103435f4312035749794353c2d34979c
 SHA512:
-  metadata.gz: bdcc77aeb67f7eb84dbb8c469186e27a730616f9fa2c51a9e6a7e9ca91f800b4563858c18fd3c93a91298b911241aad577f9e0ba8086ba198f19932368868701
-  data.tar.gz: ea641b22490269b45530b719ca48435092055ed5515b8cce8fe7b9ddc866567a418bdb16d6b463b3482319c664cabd49253f963864a16bfa705fa5dd6ab4faf6
+  metadata.gz: f5f9e9d85f7385b2a1f7406b5942741c7060c9263e751a9e59bdeb13c234e117c0ba1f58a3f3f2c0f509d797b76c9b51afbb12131fde7bdfefe9940a29e4ac4d
+  data.tar.gz: a2201235913e84433ee593288511da552b23cdf9e0e09ca0efdcc525f82ebd2e884d9d134b71f7323ed07a7b1ea88d70d49406492c51e2834afa3af02c1071e9

data/lib/arm64-to-sim/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "arm64-to-sim",
+    platforms: [
+        .macOS(.v11)
+    ],
+    products: [
+        .executable(name: "arm64-to-sim", targets: ["arm64-to-sim"])
+    ],
+    dependencies: [
+    ],
+    targets: [
+        .target(
+            name: "arm64-to-sim",
+            dependencies: [ "Arm64ToSimLib" ]),
+        .target(
+            name: "Arm64ToSimLib",
+            dependencies: []),
+        .testTarget(
+          name: "Tests",
+          dependencies: ["Arm64ToSimLib"],
+          resources: [
+            .copy("TestResources"),
+          ])
+    ]
+)

data/lib/{arm2sim.swift → arm64-to-sim/Sources/Arm64ToSimLib/Transmogrifier.swift}

@@ -7,12 +7,12 @@ extension Data {
         let lc: load_command = withUnsafeBytes { $0.load(as: load_command.self) }
         return lc.cmd
     }
-    
+
     var commandSize: Int {
         let lc: load_command = withUnsafeBytes { $0.load(as: load_command.self) }
         return Int(lc.cmdsize)
     }
-    
+
     func asStruct<T>(fromByteOffset offset: Int = 0) -> T {
         return withUnsafeBytes { $0.load(fromByteOffset: offset, as: T.self) }
     }
@@ -35,63 +35,75 @@ extension FileHandle {
     }
 }
 
-enum Transmogrifier {
-    private static func readBinary(atPath path: String) -> (Data, [Data], Data) {
+public enum Transmogrifier {
+    private static func readBinary(atPath path: String, isDynamic: Bool = false) -> (Data, [Data], Data) {
         guard let handle = FileHandle(forReadingAtPath: path) else {
             fatalError("Cannot open a handle for the file at \(path). Aborting.")
         }
-        
+
         // chop up the file into a relevant number of segments
         let headerData = try! handle.read(upToCount: MemoryLayout<mach_header_64>.stride)!
-        
+
         let header: mach_header_64 = headerData.asStruct()
         if header.magic != MH_MAGIC_64 || header.cputype != CPU_TYPE_ARM64 {
             fatalError("The file is not a correct arm64 binary. Try thinning (via lipo) or unarchiving (via ar) first.")
         }
-        
+
         let loadCommandsData: [Data] = (0..<header.ncmds).map { _ in
             let loadCommandPeekData = try! handle.peek(upToCount: MemoryLayout<load_command>.stride)
             return try! handle.read(upToCount: Int(loadCommandPeekData!.commandSize))!
         }
-        
+
+        if isDynamic {
+            let bytesToDiscard = abs(MemoryLayout<build_version_command>.stride - MemoryLayout<version_min_command>.stride)
+            _ = handle.readData(ofLength: bytesToDiscard)
+        }
+
         let programData = try! handle.readToEnd()!
-        
+
         try! handle.close()
-        
+
         return (headerData, loadCommandsData, programData)
     }
-    
+
     private static func updateSegment64(_ data: Data, _ offset: UInt32) -> Data {
         // decode both the segment_command_64 and the subsequent section_64s
         var segment: segment_command_64 = data.asStruct()
-        
+
         let sections: [section_64] = (0..<Int(segment.nsects)).map { index in
             let offset = MemoryLayout<segment_command_64>.stride + index * MemoryLayout<section_64>.stride
             return data.asStruct(fromByteOffset: offset)
         }
-        
+
         // shift segment information by the offset
         segment.fileoff += UInt64(offset)
         segment.filesize += UInt64(offset)
         segment.vmsize += UInt64(offset)
-        
+
         let offsetSections = sections.map { section -> section_64 in
+            let sectionType = section.flags & UInt32(SECTION_TYPE)
+            switch Int32(sectionType) {
+            case S_ZEROFILL, S_GB_ZEROFILL, S_THREAD_LOCAL_ZEROFILL:
+                return section
+            case _: break
+            }
+
             var section = section
             section.offset += UInt32(offset)
             section.reloff += section.reloff > 0 ? UInt32(offset) : 0
             return section
         }
-        
+
         var datas = [Data]()
         datas.append(Data(bytes: &segment, count: MemoryLayout<segment_command_64>.stride))
         datas.append(contentsOf: offsetSections.map { section in
             var section = section
             return Data(bytes: &section, count: MemoryLayout<section_64>.stride)
         })
-        
+
         return datas.merge()
     }
-    
+
     private static func updateVersionMin(_ data: Data, _ offset: UInt32, minos: UInt32, sdk: UInt32) -> Data {
         var command = build_version_command(cmd: UInt32(LC_BUILD_VERSION),
                                             cmdsize: UInt32(MemoryLayout<build_version_command>.stride),
@@ -99,68 +111,124 @@ enum Transmogrifier {
                                             minos: minos << 16 | 0 << 8 | 0,
                                             sdk: sdk << 16 | 0 << 8 | 0,
                                             ntools: 0)
-        
+
         return Data(bytes: &command, count: MemoryLayout<build_version_command>.stride)
     }
-    
+
     private static func updateDataInCode(_ data: Data, _ offset: UInt32) -> Data {
         var command: linkedit_data_command = data.asStruct()
         command.dataoff += offset
         return Data(bytes: &command, count: data.commandSize)
     }
-    
+
     private static func updateSymTab(_ data: Data, _ offset: UInt32) -> Data {
         var command: symtab_command = data.asStruct()
         command.stroff += offset
         command.symoff += offset
         return Data(bytes: &command, count: data.commandSize)
     }
-    
-    static func processBinary(atPath path: String, minos: UInt32 = 13, sdk: UInt32 = 13) {
-        guard CommandLine.arguments.count > 1 else {
-            fatalError("Please add a path to command!")
-        }
-        let (headerData, loadCommandsData, programData) = readBinary(atPath: path)
-        
-        // `offset` is kind of a magic number here, since we know that's the only meaningful change to binary size
-        // having a dynamic `offset` requires two passes over the load commands and is left as an exercise to the reader
-        let offset = UInt32(abs(MemoryLayout<build_version_command>.stride - MemoryLayout<version_min_command>.stride))
-        
+
+  private static func computeLoadCommandsEditor(_ loadCommandsData: [Data], isDynamic: Bool) -> ((Data, UInt32, UInt32) -> Data) {
+
+    if isDynamic {
+      return updateDylibFile
+    }
+
+    var contains_LC_VERSION_MIN_IPHONEOS = false
+    var contains_LC_BUILD_VERSION = false
+    for lc in loadCommandsData {
+      let loadCommand = UInt32(lc.loadCommand)
+      if loadCommand == LC_VERSION_MIN_IPHONEOS {
+        contains_LC_VERSION_MIN_IPHONEOS = true
+      } else if loadCommand == LC_BUILD_VERSION {
+        contains_LC_BUILD_VERSION = true
+      }
+    }
+
+    if contains_LC_VERSION_MIN_IPHONEOS == contains_LC_BUILD_VERSION {
+      if contains_LC_BUILD_VERSION == true {
+        fatalError("Bad Mach-O Object file: Both LC_VERSION_MIN_IPHONEOS and LC_BUILD_VERSION are present.\nEither one of them should be present")
+      } else {
+        fatalError("Bad Mach-O Object file: does not contain LC_VERSION_MIN_IPHONEOS or LC_BUILD_VERSION.\nEither one of them should be present")
+      }
+    }
+
+    if contains_LC_VERSION_MIN_IPHONEOS {
+      // `offset` is kind of a magic number here, since we know that's the only meaningful change to binary size
+      // having a dynamic `offset` requires two passes over the load commands and is left as an exercise to the reader
+      return updatePreiOS12ObjectFile
+    } else {
+      return updatePostiOS12ObjectFile
+    }
+  }
+
+
+  static func updatePostiOS12ObjectFile(lc: Data, minos: UInt32, sdk: UInt32) -> Data {
+      let cmd = Int32(bitPattern: lc.loadCommand)
+      switch cmd {
+      case LC_BUILD_VERSION:
+          return updateVersionMin(lc, 0, minos: minos, sdk: sdk)
+      default:
+          return lc
+      }
+  }
+
+  static func updatePreiOS12ObjectFile(lc: Data, minos: UInt32, sdk: UInt32) -> Data {
+    // `offset` is kind of a magic number here, since we know that's the only meaningful change to binary size
+    // having a dynamic `offset` requires two passes over the load commands and is left as an exercise to the reader
+    let offset = UInt32(abs(MemoryLayout<build_version_command>.stride - MemoryLayout<version_min_command>.stride))
+    let cmd = Int32(bitPattern: lc.loadCommand)
+      switch  cmd {
+          case LC_SEGMENT_64:
+              return updateSegment64(lc, offset)
+          case LC_VERSION_MIN_IPHONEOS:
+              return updateVersionMin(lc, offset, minos: minos, sdk: sdk)
+          case LC_DATA_IN_CODE, LC_LINKER_OPTIMIZATION_HINT:
+              return updateDataInCode(lc, offset)
+          case LC_SYMTAB:
+              return updateSymTab(lc, offset)
+          case LC_BUILD_VERSION:
+              return updateVersionMin(lc, offset, minos: minos, sdk: sdk)
+          default:
+              return lc
+      }
+  }
+
+  static func updateDylibFile(lc: Data, minos: UInt32, sdk: UInt32) -> Data {
+    // `offset` is kind of a magic number here, since we know that's the only meaningful change to binary size
+    // having a dynamic `offset` requires two passes over the load commands and is left as an exercise to the reader
+    let offset = UInt32(abs(MemoryLayout<build_version_command>.stride - MemoryLayout<version_min_command>.stride))
+    let cmd = Int32(bitPattern: lc.loadCommand)
+    guard cmd != LC_BUILD_VERSION else {
+        fatalError("This arm64 binary already contains an LC_BUILD_VERSION load command!")
+    }
+    if cmd == LC_VERSION_MIN_IPHONEOS {
+        return updateVersionMin(lc, offset, minos: minos, sdk: sdk)
+    }
+    return lc
+  }
+
+
+    public static func processBinary(atPath path: String, minos: UInt32 = 13, sdk: UInt32 = 13, isDynamic: Bool = false) {
+        let (headerData, loadCommandsData, programData) = readBinary(atPath: path, isDynamic: isDynamic)
+
+        let editor = computeLoadCommandsEditor(loadCommandsData, isDynamic: isDynamic)
+
         let editedCommandsData = loadCommandsData
-            .map { (lc) -> Data in
-                switch Int32(lc.loadCommand) {
-                case LC_SEGMENT_64:
-                    return updateSegment64(lc, offset)
-                case LC_VERSION_MIN_IPHONEOS:
-                    return updateVersionMin(lc, offset, minos: minos, sdk: sdk)
-                case LC_DATA_IN_CODE, LC_LINKER_OPTIMIZATION_HINT:
-                    return updateDataInCode(lc, offset)
-                case LC_SYMTAB:
-                    return updateSymTab(lc, offset)
-                case LC_BUILD_VERSION:
-                    fatalError("This arm64 binary already contains an LC_BUILD_VERSION load command!")
-                default:
-                    return lc
-                }
-            }
-            .merge()
-        
+        .map { return editor($0, minos, sdk) }
+        .merge()
+
         var header: mach_header_64 = headerData.asStruct()
         header.sizeofcmds = UInt32(editedCommandsData.count)
-        
+
         // reassemble the binary
         let reworkedData = [
             Data(bytes: &header, count: MemoryLayout<mach_header_64>.stride),
             editedCommandsData,
             programData
         ].merge()
-        
+
         // save back to disk
         try! reworkedData.write(to: URL(fileURLWithPath: path))
     }
 }
-
-let binaryPath = CommandLine.arguments[1]
-let minos = UInt32(CommandLine.arguments[2]) ?? 13
-let sdk = UInt32(CommandLine.arguments[3]) ?? 13
-Transmogrifier.processBinary(atPath: binaryPath, minos: minos, sdk: sdk)

data/lib/arm64-to-sim/Sources/Tests/Arm64ToSimTestCase.swift

@@ -0,0 +1,73 @@
+import Foundation
+import XCTest
+import Arm64ToSimLib
+
+class Arm64ToSimTestCase: XCTestCase {
+
+
+  var tempDir: URL!
+  override func setUp() {
+    self.tempDir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID.init().uuidString)
+    try! FileManager.default.createDirectory(at: self.tempDir, withIntermediateDirectories: false, attributes: nil)
+    copyFixtures()
+  }
+
+  override func tearDown() {
+    try! FileManager.default.removeItem(at: self.tempDir)
+  }
+
+  private func copyFixtures() {
+    let testResourcesPath = Bundle.module.resourcePath!.appending("/TestResources")
+    if let files = try? FileManager.default.contentsOfDirectory(atPath: testResourcesPath){
+      for file in files {
+        var isDir : ObjCBool = false
+        let fileURL = URL(fileURLWithPath: testResourcesPath).appendingPathComponent(file)
+        if FileManager.default.fileExists(atPath: fileURL.path, isDirectory: &isDir) {
+          if !isDir.boolValue {
+            try! FileManager.default.copyItem(at: fileURL, to: tempDir.appendingPathComponent(fileURL.lastPathComponent.replacingOccurrences(of: ".fixture", with: "")))
+          }
+        }
+      }
+    }
+  }
+
+  @discardableResult func runCommand(args: [String]) -> (String, Int32) {
+    let task = Process()
+    task.executableURL = URL(fileURLWithPath: args[0])
+    task.arguments = Array(args.dropFirst())
+    task.currentDirectoryURL = tempDir
+    let pipe = Pipe()
+    task.standardOutput = pipe
+    task.standardError = pipe
+    task.launch()
+    task.waitUntilExit()
+    let data = pipe.fileHandleForReading.readDataToEndOfFile()
+    let output = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
+    return (output!, task.terminationStatus)
+  }
+
+  private func testConvert(deviceTarget: String, simulatorTarget:String, file: StaticString = #file, line: UInt = #line) {
+    let (sysroot, _) = runCommand(args: ["/usr/bin/xcrun", "--show-sdk-path", "--sdk", "iphonesimulator"])
+    runCommand(args: ["/usr/bin/clang", "-isysroot", sysroot, "-target", simulatorTarget, "-c", "main.c", "-o", "main.arm64.ios.simulator.o"])
+    runCommand(args: ["/usr/bin/clang", "-isysroot", sysroot, "-target", deviceTarget, "-c", "return2.c", "-o", "return2.ios.device.o"])
+    let (loadCommandsOutput, _) = runCommand(args: ["/usr/bin/otool", "-l", "return2.ios.device.o" ])
+    print("LOAD_COMMANDS:")
+    for lc in loadCommandsOutput.split(separator: "\n").filter({$0.contains("cmd")}) {
+      print(lc)
+    }
+    let (_, link_status_failing) = runCommand(args: ["/usr/bin/clang", "-isysroot", sysroot, "-target", deviceTarget, "main.arm64.ios.simulator.o", "return2.ios.device.o"])
+    XCTAssert(link_status_failing != 0)
+    Transmogrifier.processBinary(atPath: tempDir.appendingPathComponent("return2.ios.device.o").path, minos: 13, sdk: 13, isDynamic: false)
+    let (_, link_status_success) = runCommand(args: ["/usr/bin/clang", "-isysroot", sysroot, "-target", "arm64-apple-ios-simulator", "main.arm64.ios.simulator.o", "return2.ios.device.o"])
+    XCTAssert(link_status_success == 0)
+  }
+
+  func testConvertPreiOS12FileFormatToSim() {
+    testConvert(deviceTarget: "arm64-apple-ios11", simulatorTarget: "arm64-apple-ios12-simulator")
+  }
+
+  func testConvertNewObjectFileFormatToSim() {
+    testConvert(deviceTarget: "arm64-apple-ios12", simulatorTarget: "arm64-apple-ios12-simulator")
+  }
+
+}

data/lib/arm64-to-sim/Sources/arm64-to-sim/main.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Arm64ToSimLib
+
+guard CommandLine.arguments.count > 1 else {
+    fatalError("Please add a path to command!")
+}
+
+let binaryPath = CommandLine.arguments[1]
+let minos = (CommandLine.arguments.count > 2 ? UInt32(CommandLine.arguments[2]) : nil) ?? 12
+let sdk = (CommandLine.arguments.count > 3 ? UInt32(CommandLine.arguments[3]) : nil) ?? 13
+let isDynamic = (CommandLine.arguments.count > 4 ? Bool(CommandLine.arguments[4]) : nil) ?? false
+if isDynamic {
+    print("[arm64-to-sim] notice: running in dynamic framework mode")
+}
+
+Transmogrifier.processBinary(atPath: binaryPath, minos: minos, sdk: sdk, isDynamic: isDynamic)

data/lib/xcframework_converter/arm_patcher.rb

@@ -42,8 +42,18 @@ module XCFrameworkConverter
         extracted_path.rmtree
       end
 
+      def gem_path(fragment)
+        Pathname.new(__FILE__).dirname.join('../..').join(fragment)
+      end
+
       def arm2sim_path
-        Pathname.new(__FILE__).dirname.join('../arm2sim.swift')
+        @arm2sim_path ||= begin
+          warn 'Pre-building `arm64-to-sim` with SwiftPM'
+          Dir.chdir gem_path('lib/arm64-to-sim') do
+            system 'xcrun swift build -c release --arch arm64 --arch x86_64'
+          end
+          gem_path('lib/arm64-to-sim/.build/apple/Products/Release/arm64-to-sim')
+        end
       end
 
       def patch_arm_binary_static(slice)
@@ -55,8 +65,10 @@ module XCFrameworkConverter
         Dir[extracted_path_dir.join('*.o')].each do |object_file|
           file = MachO::MachOFile.new(object_file)
           sdk_version = file[:LC_VERSION_MIN_IPHONEOS].first.version_string.to_i
-          `xcrun swift \"#{arm2sim_path}\" \"#{object_file}\" \"#{sdk_version}\" \"#{sdk_version}\"`
+          `\"#{arm2sim_path}\" \"#{object_file}\" \"#{sdk_version}\" \"#{sdk_version}\"`
+          $stderr.printf '.'
         end
+        $stderr.puts
         `cd \"#{extracted_path_dir}\" ; ar crv \"#{extracted_path}\" *.o`
 
         `xcrun lipo \"#{slice.binary_path}\" -replace arm64 \"#{extracted_path}\" -output \"#{slice.binary_path}\"`

data/lib/xcframework_converter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module XCFrameworkConverter
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/xcframework_converter.rb

@@ -44,8 +44,12 @@ module XCFrameworkConverter
 
         convert_xcframeworks_if_present(frameworks_to_convert)
 
+        remember_spec_as_patched(spec) unless frameworks_to_convert.empty?
+
         remove_troublesome_xcconfig_items(spec)
       end
+
+      warn "Specs with patched XCFrameworks: #{@patched_specs.sort.join(', ')}"
     end
 
     def convert_xcframeworks_if_present(frameworks_to_convert)
@@ -61,12 +65,27 @@ module XCFrameworkConverter
     end
 
     def remove_troublesome_xcconfig_items(spec)
-      # some pods put these as a way to NOT support arm64 sim
-      # may stop working if a pod decides to put these in a platform proxy
-      spec.attributes_hash['pod_target_xcconfig']&.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
-      spec.attributes_hash['user_target_xcconfig']&.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
-      spec.attributes_hash['pod_target_xcconfig']&.delete('VALID_ARCHS[sdk=iphonesimulator*]')
-      spec.attributes_hash['user_target_xcconfig']&.delete('VALID_ARCHS[sdk=iphonesimulator*]')
+      xcconfigs = %w[
+        pod_target_xcconfig
+        user_target_xcconfig
+      ].map { |key| spec.attributes_hash[key] }.compact
+
+      xcconfigs.each do |xcconfig|
+        # some pods put these as a way to NOT support arm64 sim
+        # may stop working if a pod decides to put these in a platform proxy
+        excluded_arm = xcconfig['EXCLUDED_ARCHS[sdk=iphonesimulator*]']&.include?('arm64')
+        not_inlcuded_arm = xcconfig['VALID_ARCHS[sdk=iphonesimulator*]'] && !xcconfig['VALID_ARCHS[sdk=iphonesimulator*]'].include?('arm64')
+
+        remember_spec_as_patched(spec) if excluded_arm || not_inlcuded_arm
+
+        xcconfig.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
+        xcconfig.delete('VALID_ARCHS[sdk=iphonesimulator*]')
+      end
+    end
+
+    def remember_spec_as_patched(spec)
+      @patched_specs ||= Set.new
+      @patched_specs << spec.root.name
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcframework_converter
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Igor Makarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-18 00:00:00.000000000 Z
+date: 2022-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocoapods
@@ -51,7 +51,10 @@ files:
 - README.md
 - bin/xcfconvert
 - bin/xcfpatch
-- lib/arm2sim.swift
+- lib/arm64-to-sim/Package.swift
+- lib/arm64-to-sim/Sources/Arm64ToSimLib/Transmogrifier.swift
+- lib/arm64-to-sim/Sources/Tests/Arm64ToSimTestCase.swift
+- lib/arm64-to-sim/Sources/arm64-to-sim/main.swift
 - lib/xcframework_converter.rb
 - lib/xcframework_converter/arm_patcher.rb
 - lib/xcframework_converter/creation.rb