perf: resolve fingerprints using method maps

src/main/kotlin/app/revanced/patcher/Patcher.kt

@@ -4,8 +4,14 @@ import app.revanced.patcher.data.Context
 import app.revanced.patcher.extensions.PatchExtensions.dependencies
 import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.extensions.PatchExtensions.requiresIntegrations
-import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolve
-import app.revanced.patcher.patch.*
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint
+import app.revanced.patcher.fingerprint.method.impl.MethodFingerprint.Companion.resolveUsingLookupMap
+import app.revanced.patcher.patch.BytecodePatch
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.PatchResult
+import app.revanced.patcher.patch.PatchResultError
+import app.revanced.patcher.patch.PatchResultSuccess
+import app.revanced.patcher.patch.ResourcePatch
 import app.revanced.patcher.util.VersionReader
 import brut.androlib.Androlib
 import brut.androlib.meta.UsesFramework
@@ -259,6 +265,8 @@ class Patcher(private val options: PatcherOptions) {
                 metadata.metaInfo.versionInfo = resourceTable.versionInfo
                 metadata.metaInfo.sdkInfo = resourceTable.sdkInfo
             }
+
+            MethodFingerprint.createMethodLookupMap(context.bytecodeContext.classes.classes)
         } finally {
             extInputFile.close()
         }
@@ -315,10 +323,7 @@ class Patcher(private val options: PatcherOptions) {
                 context.resourceContext
             } else {
                 context.bytecodeContext.also { context ->
-                    (patchInstance as BytecodePatch).fingerprints?.resolve(
-                        context,
-                        context.classes.classes
-                    )
+                    (patchInstance as BytecodePatch).fingerprints?.resolveUsingLookupMap(context, logger)
                 }
             }
 
@@ -359,6 +364,7 @@ class Patcher(private val options: PatcherOptions) {
                     if (stopOnError && patchResult.isError()) return@sequence
                 }
             } finally {
+                MethodFingerprint.clearMethodLookupMap() // No more resolving can occur.
                 executedPatches.values.reversed().forEach { (patch, _) ->
                     patch.close()
                 }

src/main/kotlin/app/revanced/patcher/fingerprint/method/impl/MethodFingerprint.kt

@@ -2,29 +2,47 @@ package app.revanced.patcher.fingerprint.method.impl
 
 import app.revanced.patcher.data.BytecodeContext
 import app.revanced.patcher.extensions.MethodFingerprintExtensions.fuzzyPatternScanMethod
+import app.revanced.patcher.extensions.MethodFingerprintExtensions.name
 import app.revanced.patcher.fingerprint.Fingerprint
 import app.revanced.patcher.fingerprint.method.annotation.FuzzyPatternScanMethod
+import app.revanced.patcher.logging.Logger
+import app.revanced.patcher.logging.impl.NopLogger
+import app.revanced.patcher.patch.PatchResultError
 import app.revanced.patcher.util.proxy.ClassProxy
+import org.jf.dexlib2.AccessFlags
 import org.jf.dexlib2.Opcode
 import org.jf.dexlib2.iface.ClassDef
 import org.jf.dexlib2.iface.Method
 import org.jf.dexlib2.iface.instruction.Instruction
 import org.jf.dexlib2.iface.instruction.ReferenceInstruction
 import org.jf.dexlib2.iface.reference.StringReference
 import org.jf.dexlib2.util.MethodUtil
+import java.util.LinkedList
 
 private typealias StringMatch = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult.StringMatch
 private typealias StringsScanResult = MethodFingerprintResult.MethodFingerprintScanResult.StringsScanResult
 
 /**
- * Represents the [MethodFingerprint] for a method.
- * @param returnType The return type of the method.
- * @param accessFlags The access flags of the method.
- * @param parameters The parameters of the method.
- * @param opcodes The list of opcodes of the method.
+ * A finger print for identifying a method.
+ *
+ * To improve patching performance:
+ * - fastest: specify at least [strings], with the first string being an exact (non-partial) match.
+ * - faster: specify at least [accessFlags], [returnType], [parameters].
+ * - fast: specify at least [accessFlags], [returnType].
+ * - slowest: specify only [opcodes] and nothing else.
+ *
+ * For target apps with only a few patches, the resolving speed does not matter and even the
+ * slowest resolving fingerprints will not be noticed. Only when using dozens of fingerprints
+ * does the patching speed become apparent.
+ *
+ * @param returnType The return type of the method. Partial matches are allowed, and values are compared using startWith.
+ *                   For example: "L" matches any object, while "Landroid/view/View;" matches only to an Android view parameter.
+ * @param accessFlags The access flags of the method using values of [AccessFlags].  Must be an exact match.
+ * @param parameters The parameters of the method. Partial matches allowed and follow same rules as [returnType].
+ * @param opcodes The list of opcodes of the method, and a `null` opcode means unknown or wildcard value.
  * @param strings A list of strings which a method contains.
+ *                Partial matches are allowed, and are compared using contains. For example, "app" matches "happy".
  * @param customFingerprint A custom condition for this fingerprint.
- * A `null` opcode is equals to an unknown opcode.
  */
 abstract class MethodFingerprint(
     internal val returnType: String? = null,
@@ -40,6 +58,136 @@ abstract class MethodFingerprint(
     var result: MethodFingerprintResult? = null
 
     companion object {
+
+        private class ClassAndMethod(val classDef: ClassDef, val method: Method)
+        /**
+         * All methods in the target app.
+         */
+        private val allMethods = mutableListOf<ClassAndMethod>()
+        /**
+         * Map of all methods in the target app, keyed to the access/return/parameter signature.
+         */
+        private val signatureMap = mutableMapOf<String, MutableList<ClassAndMethod>>()
+        /**
+         * Map of all Strings found in the target app, and the class/method they were found in.
+         */
+        private val stringMap = mutableMapOf<String, MutableList<ClassAndMethod>>()
+
+        private fun StringBuilder.appendSignatureKeyParameters(parameters: Iterable<CharSequence>) {
+            // Maximum parameters to use in the signature key.
+            // Used to reduce the map size by grouping together uncommon methods.
+            val maxSignatureParameters = 5
+            append("p:")
+            parameters.forEachIndexed { index, parameter ->
+                if (index >= maxSignatureParameters) return
+                append(parameter.first())
+            }
+        }
+
+        /**
+         * @return all app methods that contain the first string declared in this signature,
+         *         or NULL if no strings are declared or no exact matches exist.
+         */
+        private fun MethodFingerprint.appMethodsWithSameStrings() : List<ClassAndMethod>? {
+            if (strings != null && strings.count() > 0) {
+                // Only check the first String declared
+                return stringMap[strings.first()]
+            }
+            return null
+        }
+
+        /**
+         * @return all app methods that could match this signature.
+         */
+        private fun MethodFingerprint.appMethodsWithSameSignature() : List<ClassAndMethod> {
+            if (accessFlags == null) return allMethods
+
+            var returnTypeValue = returnType
+            if (returnTypeValue == null) {
+                if (AccessFlags.CONSTRUCTOR.isSet(accessFlags)) {
+                    // Constructors always have void return type
+                    returnTypeValue = "V"
+                } else {
+                    return allMethods
+                }
+            }
+
+            val key = buildString {
+                append(accessFlags)
+                append(returnTypeValue.first())
+                if (parameters != null) appendSignatureKeyParameters(parameters)
+            }
+            return signatureMap[key]!!
+        }
+
+        internal fun clearMethodLookupMap() {
+            allMethods.clear()
+            signatureMap.clear()
+            stringMap.clear()
+        }
+
+        /**
+         * resolve faster, by creating culled lists based on method signature and Strings contained.
+         */
+        internal fun createMethodLookupMap(classes: Iterable<ClassDef>) {
+            fun addMethodToMapList(map: MutableMap<String, MutableList<ClassAndMethod>>,
+                                   key: String, keyValue:  ClassAndMethod) {
+                var list = map[key]
+                if (list == null) {
+                    list = LinkedList()
+                    map[key] = list
+                }
+                list += keyValue
+            }
+
+            for (classDef in classes) {
+                for (method in classDef.methods) {
+                    // Key structure is: (access)(returnType)(optional: parameter types)
+                    val accessFlagsReturnKey = method.accessFlags.toString() + method.returnType.first()
+                    val accessFlagsReturnParametersKey = buildString {
+                        append(accessFlagsReturnKey)
+                        appendSignatureKeyParameters(method.parameterTypes)
+                    }
+                    val classAndMethod = ClassAndMethod(classDef, method)
+
+                    // For signatures with no access or return type specified.
+                    allMethods += classAndMethod
+                    // Access and return type.
+                    addMethodToMapList(signatureMap, accessFlagsReturnKey, classAndMethod)
+                    // Access, return, and parameters.
+                    addMethodToMapList(signatureMap, accessFlagsReturnParametersKey, classAndMethod)
+
+                    // Look up by Strings (the fastest way to resolve).
+                    method.implementation?.instructions?.forEach { instruction ->
+                        if (instruction.opcode == Opcode.CONST_STRING || instruction.opcode == Opcode.CONST_STRING_JUMBO) {
+                            val string = ((instruction as ReferenceInstruction).reference as StringReference).string
+                            addMethodToMapList(stringMap, string, classAndMethod)
+                        }
+                    }
+
+                    // The only additional lookup that could benefit, is a map of the full class name to its methods.
+                    // This would require adding a 'class name' field to MethodFingerprint,
+                    // as currently the class name can be specified only with a custom fingerprint.
+                }
+            }
+        }
+
+        /**
+         * Resolve using map built in [createMethodLookupMap]
+         *
+         * @param logger optional logger, to record the time to resolve each fingerprint.
+         */
+        internal fun Iterable<MethodFingerprint>.resolveUsingLookupMap(context: BytecodeContext, logger : Logger = NopLogger) {
+            if (allMethods.isEmpty()) throw PatchResultError("lookup map not initialized")
+
+            for (fingerprint in this) {
+                var time = System.currentTimeMillis()
+                fingerprint.resolveUsingLookupMap(context, logger)
+                time = System.currentTimeMillis() - time
+                if (time > 20) logger.trace("${fingerprint.name} resolved in $time ms")
+            }
+        }
+
         /**
          * Resolve a list of [MethodFingerprint] against a list of [ClassDef].
          *
@@ -54,6 +202,30 @@ abstract class MethodFingerprint(
                         break@classes // if the resolution succeeded, continue with the next fingerprint
         }
 
+        /**
+         * Resolve using map built in [createMethodLookupMap]
+         */
+        internal fun MethodFingerprint.resolveUsingLookupMap(context: BytecodeContext, logger : Logger = NopLogger): Boolean {
+            fun MethodFingerprint.resolveUsingClassMethod(classMethods: Iterable<ClassAndMethod>): Boolean {
+                for (classAndMethod in classMethods) {
+                    if (resolve(context, classAndMethod.method, classAndMethod.classDef)) {
+                        return true
+                    }
+                }
+                return false
+            }
+
+            var methodsWithStrings = appMethodsWithSameStrings()
+            if (methodsWithStrings != null) {
+                if (resolveUsingClassMethod(methodsWithStrings)) return true
+                logger.trace("$name: could not quickly resolve using declared strings (verify first string is an exact match)")
+            }
+
+            // No String declared, or none matched (partial matches are allowed).
+            // Use signature matching.
+            return resolveUsingClassMethod(appMethodsWithSameSignature())
+        }
+
         /**
          * Resolve a [MethodFingerprint] against a [ClassDef].
          *