xcframework_converter 0.3.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b2d19f2b78a5ddedb9c26708a8ead42cfe3a76a21dfeeb244f6f9e49f835ef2
-  data.tar.gz: 5334b7a2cea325d36a5e15ca30cd14aafd47c49a40f99fb0ff5e2ff45094edd9
+  metadata.gz: 77324350e0b69d68739d71e4e2bd510b2c46e82076d82c066eb1af2ab7019ff0
+  data.tar.gz: dd8c817ba142772da87f18c46fffe50f32e2bad22d4bb8a9e3101650b38818a0
 SHA512:
-  metadata.gz: 519151d17e2cb3aa6c4140ee9bf4c05b55b4deb1582508271d99e6d9fb26a4f8c450b60b9f9b3c9ed590d8fd7c7b352ec1624e5a294b3a31700bf74a626c4205
-  data.tar.gz: fc7b29d598afe23fc1d3047dcc2446bb160986da8b8297b81ef9b8103e18635104f0ea043898c4c7ff3d27b03e1a38c673ece942c8b084bbc1292d0ab9eccd40
+  metadata.gz: e7a7693803108e192822db1f4ab0de16bed32d4dc134dd3a69b1b6e54eab4e185e4d466d0626ecd46adc4c0bee677de8a9b8ca28d99485a0f5975147133cd94b
+  data.tar.gz: 59a9cac8d54309ddd9efea3901425ad5499cccac741cd6d35cb4a493794a8cf35d083ad63ba6e0528065cd717ee1521c7a8794cd445d2093813f65336af9209e

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,134 +35,204 @@ 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
-            var section = section
-            if section.flags != S_ZEROFILL {
-                section.offset += UInt32(offset)
-                section.reloff += section.reloff > 0 ? UInt32(offset) : 0
+            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 {
+
+    private static func createLcBuildVersion(minos: UInt32, sdk: UInt32) -> Data {
         var command = build_version_command(cmd: UInt32(LC_BUILD_VERSION),
                                             cmdsize: UInt32(MemoryLayout<build_version_command>.stride),
                                             platform: UInt32(PLATFORM_IOSSIMULATOR),
                                             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 updateLcBuildVersion(_ data: Data, minos: UInt32, sdk: UInt32) -> Data {
+        var command: build_version_command = data.asStruct()
+        command.platform = UInt32(PLATFORM_IOSSIMULATOR)
+        command.minos = minos << 16 | 0 << 8 | 0
+        command.sdk = sdk << 16 | 0 << 8 | 0
+
+        return Data(bytes: &command, count: data.count)
+    }
+
     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 {
+      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 updateLcBuildVersion(lc, 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 createLcBuildVersion(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("pre-12 object file shold not contain LC_BUILD_VERSION!")
+          default:
+              return lc
+      }
+  }
+
+  static func updateDylibFile(lc: Data, minos: UInt32, sdk: UInt32) -> Data {
+    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 createLcBuildVersion(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

@@ -2,10 +2,12 @@
 
 require 'cocoapods'
 require 'cocoapods/xcode/xcframework'
+require 'digest/md5'
 require 'fileutils'
+require 'shellwords'
 require 'xcodeproj'
 
-# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
 module XCFrameworkConverter
   # Patches a binary (static or dynamic), turning an arm64-device into an arm64-simualtor.
@@ -35,15 +37,24 @@ module XCFrameworkConverter
         extracted_path = slice.path.join('arm64.dylib')
         `xcrun lipo \"#{slice.binary_path}\" -thin arm64 -output \"#{extracted_path}\"`
 
-        file = MachO::MachOFile.new(extracted_path)
-        sdk_version = file[:LC_VERSION_MIN_IPHONEOS].first.version_string
-        `xcrun vtool -arch arm64 -set-build-version 7 #{sdk_version} #{sdk_version} -replace -output \"#{extracted_path}\" \"#{extracted_path}\"`
+        minos_version, sdk_version = version_strings(extracted_path).map(&:to_i)
+        `xcrun vtool -arch arm64 -set-build-version 7 #{minos_version} #{sdk_version} -replace -output \"#{extracted_path}\" \"#{extracted_path}\"`
         `xcrun lipo \"#{slice.binary_path}\" -replace arm64 \"#{extracted_path}\" -output \"#{slice.binary_path}\"`
         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)
@@ -51,21 +62,61 @@ module XCFrameworkConverter
         `xcrun lipo \"#{slice.binary_path}\" -thin arm64 -output \"#{extracted_path}\"`
         extracted_path_dir = slice.path.join('arm64-objects')
         extracted_path_dir.mkdir
-        `cd \"#{extracted_path_dir}\" ; ar x \"#{extracted_path}\"`
-        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}\"`
-          $stderr.printf '.'
+        if macho_file_type(extracted_path) == :object
+          patch_object_file(extracted_path)
+        else
+          object_files = `ar t \"#{extracted_path}\"`.split("\n").map(&:chomp).sort
+                                                     .select { |o| o.end_with?('.o') }
+                                                     .group_by(&:itself).transform_values(&:count)
+          processed_files = []
+          index = 0
+          while object_files.any?
+            object_files.keys.each do |object_file|
+              file_shard = Digest::MD5.hexdigest(object_file).to_s[0..2]
+              file_dir = extracted_path_dir.join("#{index}-#{file_shard}")
+              file_path = file_dir.join(object_file)
+              file_dir.mkdir unless file_dir.exist?
+              `ar p \"#{extracted_path}\" \"#{object_file}\" > \"#{file_path}\"`
+              patch_object_file(file_path)
+              $stderr.printf '.'
+              processed_files << file_path
+            end
+            `ar d \"#{extracted_path}\" #{object_files.keys.map(&:shellescape).join(' ')}`
+            $stderr.printf '#'
+            object_files.reject! { |_, count| count <= index + 1 }
+            index += 1
+          end
+          $stderr.puts
+          `cd \"#{extracted_path_dir}\" ; ar cqv \"#{extracted_path}\" #{processed_files.map(&:shellescape).join(' ')}`
         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}\"`
         extracted_path_dir.rmtree
         extracted_path.rmtree
       end
 
+      def macho_file_type(file_path)
+        MachO.open(file_path).filetype
+      rescue MachO::MagicError
+        nil
+      end
+
+      def patch_object_file(file_path)
+        minos_version, sdk_version = version_strings(file_path).map(&:to_i)
+        `\"#{arm2sim_path}\" \"#{file_path}\" \"#{minos_version}\" \"#{sdk_version}\"`
+      end
+
+      def version_strings(file_path)
+        macho_file = MachO::MachOFile.new(file_path)
+        if (version_min_command = macho_file.load_commands.find { |c| c.is_a?(MachO::LoadCommands::VersionMinCommand) })
+          return [version_min_command.version_string, version_min_command.sdk_string]
+        end
+        if (build_version_command = macho_file.load_commands.find { |c| c.is_a?(MachO::LoadCommands::BuildVersionCommand) })
+          return [build_version_command.minos_string, build_version_command.sdk_string]
+        end
+
+        raise "Could not find version strings in #{file_path}"
+      end
+
       public
 
       def cleanup_unused_archs(slice)

data/lib/xcframework_converter/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xcframework_converter
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Igor Makarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-30 00:00:00.000000000 Z
+date: 2022-05-23 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