Enforced arm64 or x86_64 architecture

Author: lukaskubanek

Sources/ITKSuperBuilder/include/ITKSuperBuilder.h

@@ -1,7 +1,9 @@
-#if __APPLE__
-#import <Foundation/Foundation.h>
+#if !(defined(__APPLE__) && (defined(__arm64__) || defined(__x86_64__)))
+#error "[InterposeKit] Supported only on Apple platforms with arm64 or x86_64 architecture."
 #endif
 
+#import <Foundation/Foundation.h>
+
 NS_ASSUME_NONNULL_BEGIN
 
 /**
@@ -44,7 +46,7 @@ There are a few important details:
 
 @see https://steipete.com/posts/calling-super-at-runtime/
 */
-@interface ITKSuperBuilder : NSObject
+@interface ITKSuperBuilder: NSObject
 
 /// Adds an empty super implementation instance method to originalClass.
 /// If a method already exists, this will return NO and a descriptive error message.
@@ -53,22 +55,14 @@ There are a few important details:
                                 error:(NSError **)error;
 
 /// Check if the instance method in `originalClass` is a super trampoline.
-+ (BOOL)isSuperTrampolineForClass:(Class)originalClass selector:(SEL)selector;
-
-/// x86-64 and ARM64 are currently supported.
-@property(class, readonly) BOOL isSupportedArchitecture;
-
-#if (defined (__arm64__) || defined (__x86_64__)) && __APPLE__
-/// Helper that does not exist if architecture is not supported.
-+ (BOOL)isCompileTimeSupportedArchitecture;
-#endif
++ (BOOL)isSuperTrampolineForClass:(Class)originalClass
+                         selector:(SEL)selector;
 
 @end
 
 NSString *const ITKSuperBuilderErrorDomain;
 
 typedef NS_ERROR_ENUM(ITKSuperBuilderErrorDomain, ITKSuperBuilderErrorCode) {
-    SuperBuilderErrorCodeArchitectureNotSupported,
     SuperBuilderErrorCodeNoSuperClass,
     SuperBuilderErrorCodeNoDynamicallyDispatchedMethodAvailable,
     SuperBuilderErrorCodeFailedToAddMethod

Sources/ITKSuperBuilder/src/ITKSuperBuilder.m

@@ -17,9 +17,9 @@
 static IMP ITKGetTrampolineForTypeEncoding(__unused const char *typeEncoding) {
     BOOL requiresStructDispatch = NO;
     #if defined (__arm64__)
-    // ARM64 doesn't use stret dispatch. Yay!
+    // arm64 doesn't use stret dispatch. Yay!
     #elif defined (__x86_64__)
-        // On x86-64, stret dispatch is ~used whenever return type doesn't fit into two registers
+        // On x86_64, stret dispatch is ~used whenever return type doesn't fit into two registers
         //
         // http://www.sealiesoftware.com/blog/archive/2008/10/30/objc_explain_objc_msgSend_stret.html
         // x86_64 is more complicated, including rules for returning floating-point struct fields in FPU registers, and ppc64's rules and exceptions will make your head spin. The gory details are documented in the Mac OS X ABI Guide, though as usual if the documentation and the compiler disagree then the documentation is wrong.
@@ -41,32 +41,12 @@ static IMP ITKGetTrampolineForTypeEncoding(__unused const char *typeEncoding) {
 
 @implementation ITKSuperBuilder
 
-+ (BOOL)isSupportedArchitecture {
-#if defined (__arm64__) || defined (__x86_64__)
-    return YES;
-#else
-    return NO;
-#endif
-}
-
-#if defined (__arm64__) || defined (__x86_64__)
-+ (BOOL)isCompileTimeSupportedArchitecture {
-    return [self isSupportedArchitecture];
-}
-#endif
-
 + (BOOL)isSuperTrampolineForClass:(Class)originalClass selector:(SEL)selector {
-    // No architecture check needed - will just be NO.
     let method = class_getInstanceMethod(originalClass, selector);
     return ITKMethodIsSuperTrampoline(method);
 }
 
 + (BOOL)addSuperInstanceMethodToClass:(Class)originalClass selector:(SEL)selector error:(NSError **)error {
-    if (!self.isSupportedArchitecture) {
-        let msg = @"Unsupported Architecture. (Support includes ARM64 and x86-64 )";
-        ERROR_AND_RETURN(SuperBuilderErrorCodeArchitectureNotSupported, msg)
-    }
-
     // Check that class has a superclass
     let superClass = class_getSuperclass(originalClass);
     if (superClass == nil) {

Sources/InterposeKit/Hooks/HookStrategy/ObjectHookStrategy/InterposeSubclass.swift

@@ -7,9 +7,6 @@ class InterposeSubclass {
         static let subclassSuffix = "InterposeKit_"
     }
 
-    /// The object that is being hooked.
-    let object: AnyObject
-
     /// Subclass that we create on the fly
     private(set) var dynamicClass: AnyClass
 
@@ -19,8 +16,15 @@ class InterposeSubclass {
     /// Making KVO and Object-based hooking work at the same time is difficult.
     /// If we make a dynamic subclass over KVO, invalidating the token crashes in cache_getImp.
     init(object: AnyObject) throws {
-        self.object = object
-        self.dynamicClass = try Self.getExistingSubclass(object: object) ?? Self.createSubclass(object: object)
+        let dynamicClass: AnyClass = try { () throws -> AnyClass in
+            if let dynamicClass = Self.getExistingSubclass(object: object) {
+                return dynamicClass
+            }
+            
+            return try Self.createSubclass(object: object)
+        }()
+        
+        self.dynamicClass = dynamicClass
     }
 
     private static func createSubclass(object: AnyObject) throws -> AnyClass {
@@ -63,10 +67,6 @@ class InterposeSubclass {
         return nil
     }
 
-    class var supportsSuperTrampolines: Bool {
-        ITKSuperBuilder.isSupportedArchitecture
-    }
-
     func addSuperTrampoline(selector: Selector) {
         do {
             try ITKSuperBuilder.addSuperInstanceMethod(to: dynamicClass, selector: selector)

Sources/InterposeKit/Hooks/HookStrategy/ObjectHookStrategy/ObjectHookStrategy.swift

@@ -30,9 +30,6 @@ final class ObjectHookStrategy: HookStrategy {
     /// Subclass that we create on the fly
     var interposeSubclass: InterposeSubclass?
 
-    // Logic switch to use super builder
-    let generatesSuperIMP = InterposeSubclass.supportsSuperTrampolines
-    
     var dynamicSubclass: AnyClass {
         interposeSubclass!.dynamicClass
     }
@@ -75,46 +72,25 @@ final class ObjectHookStrategy: HookStrategy {
         let classImplementsMethod = class_implementsInstanceMethod(self.dynamicSubclass, self.selector)
         let encoding = method_getTypeEncoding(method)
 
-        if self.generatesSuperIMP {
-            // If the subclass is empty, we create a super trampoline first.
-            // If a hook already exists, we must skip this.
-            if !classImplementsMethod {
-                // TODO: Make this failable
-                self.interposeSubclass!.addSuperTrampoline(selector: self.selector)
-            }
-            
-            // Replace IMP (by now we guarantee that it exists)
-            self.storedOriginalIMP = class_replaceMethod(self.dynamicSubclass, self.selector, hookIMP, encoding)
-            guard self.storedOriginalIMP != nil else {
-                // This should not happen if the class implements the method or we have installed
-                // the super trampoline. Instead, we should make the trampoline implementation
-                // failable.
-                throw InterposeError.implementationNotFound(
-                    class: self.dynamicSubclass,
-                    selector: self.selector
-                )
-            }
-            Interpose.log("Added -[\(self.class).\(self.selector)] IMP: \(self.storedOriginalIMP!) -> \(hookIMP)")
-        } else {
-            // Could potentially be unified in the code paths
-            if classImplementsMethod {
-                self.storedOriginalIMP = class_replaceMethod(self.dynamicSubclass, self.selector, hookIMP, encoding)
-                if self.storedOriginalIMP != nil {
-                    Interpose.log("Added -[\(self.class).\(self.selector)] IMP: \(hookIMP) via replacement")
-                } else {
-                    Interpose.log("Unable to replace: -[\(self.class).\(self.selector)] IMP: \(hookIMP)")
-                    throw InterposeError.unableToAddMethod(self.class, self.selector)
-                }
-            } else {
-                let didAddMethod = class_addMethod(self.dynamicSubclass, self.selector, hookIMP, encoding)
-                if didAddMethod {
-                    Interpose.log("Added -[\(self.class).\(self.selector)] IMP: \(hookIMP)")
-                } else {
-                    Interpose.log("Unable to add: -[\(self.class).\(self.selector)] IMP: \(hookIMP)")
-                    throw InterposeError.unableToAddMethod(self.class, self.selector)
-                }
-            }
+        // If the subclass is empty, we create a super trampoline first.
+        // If a hook already exists, we must skip this.
+        if !classImplementsMethod {
+            // TODO: Make this failable
+            self.interposeSubclass!.addSuperTrampoline(selector: self.selector)
+        }
+        
+        // Replace IMP (by now we guarantee that it exists)
+        self.storedOriginalIMP = class_replaceMethod(self.dynamicSubclass, self.selector, hookIMP, encoding)
+        guard self.storedOriginalIMP != nil else {
+            // This should not happen if the class implements the method or we have installed
+            // the super trampoline. Instead, we should make the trampoline implementation
+            // failable.
+            throw InterposeError.implementationNotFound(
+                class: self.dynamicSubclass,
+                selector: self.selector
+            )
         }
+        Interpose.log("Added -[\(self.class).\(self.selector)] IMP: \(self.storedOriginalIMP!) -> \(hookIMP)")
     }
 
     func restoreImplementation() throws {

Sources/InterposeKit/Interpose.swift

@@ -1,3 +1,7 @@
+#if !(arch(arm64) || arch(x86_64))
+#error("[InterposeKit] This code only supports arm64 and x86_64 architectures.")
+#endif
+
 import ObjectiveC
 
 /// Interpose is a modern library to swizzle elegantly in Swift.

Sources/InterposeKit/InterposeError.swift

@@ -48,9 +48,6 @@ public enum InterposeError: LocalizedError {
     /// Unable to register subclass for object-based interposing.
     case failedToAllocateClassPair(class: AnyClass, subclassName: String)
 
-    /// Unable to add method  for object-based interposing.
-    case unableToAddMethod(AnyClass, Selector)
-
     /// Object-based hooking does not work if an object is using KVO.
     /// The KVO mechanism also uses subclasses created at runtime but doesn't check for additional overrides.
     /// Adding a hook eventually crashes the KVO management code so we reject hooking altogether in this case.
@@ -89,8 +86,6 @@ extension InterposeError: Equatable {
             return "Unexpected Implementation in -[\(klass) \(selector)]: \(String(describing: IMP))"
         case .failedToAllocateClassPair(let klass, let subclassName):
             return "Failed to allocate class pair: \(klass), \(subclassName)"
-        case .unableToAddMethod(let klass, let selector):
-            return "Unable to add method: -[\(klass) \(selector)]"
         case .kvoDetected(let obj):
             return "Unable to hook object that uses Key Value Observing: \(obj)"
         case .objectPosingAsDifferentClass(let obj, let actualClass):