Add more missed matches

tools/identify_matching_functions_by_call.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+from typing import Dict, List
+
+import cxxfilt
+from colorama import Fore
+
+from util import utils, checker, elf
+
+
+class Checker(checker.FunctionChecker):
+    def __init__(self):
+        super().__init__()
+        self.checking = ""
+        self.invalid_call_descriptions: List[str] = []
+        self.addr_to_symbol = elf.build_addr_to_symbol_table(elf.my_symtab)
+        self._possible_calls: Dict[int, int] = dict()
+
+    def reset(self) -> None:
+        self._possible_calls.clear()
+
+    def get_possible_calls(self) -> Dict[int, int]:
+        return self._possible_calls
+
+    def on_unknown_fn_call(self, orig_addr: int, decomp_addr: int):
+        existing_addr = self._possible_calls.get(orig_addr)
+        if existing_addr is not None and existing_addr != decomp_addr:
+            self.invalid_call_descriptions.append(
+                f"{orig_addr | 0x7100000000:#x} was mapped to {self.addr_to_symbol[existing_addr]} "
+                f"({existing_addr:#x}) "
+                f"but now maps to {self.addr_to_symbol[decomp_addr]} ({decomp_addr:#x})"
+                f" (while checking {self.checking})")
+            return
+        self._possible_calls[orig_addr] = decomp_addr
+
+
+def main() -> None:
+    functions_by_addr: Dict[int, utils.FunctionInfo] = {fn.addr: fn for fn in utils.get_functions()}
+    fn_checker = Checker()
+    for fn in functions_by_addr.values():
+        if fn.status != utils.FunctionStatus.Matching:
+            continue
+
+        base_fn = elf.get_fn_from_base_elf(fn.addr, fn.size)
+        try:
+            my_fn = elf.get_fn_from_my_elf(fn.decomp_name)
+        except KeyError:
+            utils.warn(f"could not find function {fn.decomp_name}")
+            continue
+
+        fn_checker.checking = fn.decomp_name
+        fn_checker.check(base_fn, my_fn)
+
+    if fn_checker.invalid_call_descriptions:
+        for x in fn_checker.invalid_call_descriptions:
+            utils.print_note(x)
+        utils.fail("invalid calls detected")
+
+    new_matches: Dict[int, str] = dict()
+    calls = fn_checker.get_possible_calls().copy()
+    for base_target, my_target in calls.items():
+        target_info = functions_by_addr[base_target]
+        if target_info.status != utils.FunctionStatus.NotDecompiled:
+            continue
+
+        base_fn = elf.get_fn_from_base_elf(target_info.addr, target_info.size)
+        try:
+            name = fn_checker.addr_to_symbol[my_target]
+            my_fn = elf.get_fn_from_my_elf(name)
+        except KeyError:
+            continue
+
+        if fn_checker.check(base_fn, my_fn):
+            new_matches[base_target] = name
+            utils.print_note(f"new match: {Fore.BLUE}{cxxfilt.demangle(name)}{Fore.RESET}")
+
+    utils.add_decompiled_functions(new_matches)
+
+
+if __name__ == '__main__':
+    main()