perf(loaders): share a single lief.parse across all loader accessors

PE/ELF/MachO file loaders previously each called lief.parse(binary) inside
several of their static accessors. FileLoader._loadFile calls 6 of these
accessors in sequence (mapBinary, getBaseAddress, getBitness, getCodeAreas,
getArchitecture, getAbi), so a single PE binary was re-parsed up to 2 times,
ELF up to 4 times, and MachO up to 5 times on every load. lief.parse is the
single most expensive step for any non-trivial binary.

Refactor:
- Each LIEF-aware loader now exposes parseBinary(binary) -> lief obj | None
  as a single parse entry point.
- Every accessor on PE / ELF / MachO accepts an optional parsed=None kwarg
  and reuses it when supplied (falling back to lief.parse(binary) when
  None, preserving the legacy direct-call contract).
- ELF's existing elffile= and MachO's macho_file= kwargs are renamed to
  parsed= for uniform API. grep across src/ and tests/ confirms no external
  caller passed those by name; the only callers were in-file (mapBinary
  -> getBaseAddress) and were updated.
- FileLoader._loadFile parses once via loader.parseBinary(self._raw_data)
  and threads the parsed object through every accessor via **kw. Delphi/Dex
  loaders don't have parseBinary, so kw stays empty for them.
- PE accessors that never used lief (mapBinary/getBaseAddress/getBitness/
  getAbi) accept parsed= for API uniformity and `del parsed` it. Cheap to
  pass, keeps the FileLoader call site uniform.

Net effect: 1 lief.parse per binary load instead of 2/4/5.

Validation:
- pytest tests/test* -> 111 passed, 79 subtests passed
- testFileFormatParsers (PE/ELF/MachO/CIL paths) all pass
- testPeFileLoader passes
- ruff check + format --check clean
- No external callers reference elffile= or macho_file= by keyword

Author: claude

src/smda/utility/ElfFileLoader.py

@@ -32,9 +32,14 @@ def isCompatible(data):
         return data[:4] == b"\x7fELF"
 
     @staticmethod
-    def getBaseAddress(binary, elffile=None):
-        if elffile is None:
-            elffile = lief.parse(binary)
+    def parseBinary(binary):
+        # Single lief.parse entry point so FileLoader can share one parse
+        # across all accessors instead of each accessor re-parsing.
+        return lief.parse(binary)
+
+    @staticmethod
+    def getBaseAddress(binary, parsed=None):
+        elffile = parsed if parsed is not None else lief.parse(binary)
         # Determine base address of binary
         #
         base_addr = 0
@@ -152,15 +157,15 @@ def _map_sections(elffile, mapped_binary, base_addr):
                 mapped_binary[rva : rva + section.size] = content_to_be_mapped
 
     @staticmethod
-    def mapBinary(binary):
+    def mapBinary(binary, parsed=None):
         """
         map the ELF file sections and segments into a contiguous bytearray
         as if into virtual memory with the given base address.
         """
-        elffile = lief.parse(binary)
+        elffile = parsed if parsed is not None else lief.parse(binary)
         if not elffile:
             return b""
-        base_addr = ElfFileLoader.getBaseAddress(binary, elffile=elffile)
+        base_addr = ElfFileLoader.getBaseAddress(binary, parsed=elffile)
 
         LOGGER.debug("ELF: base address: 0x%x", base_addr)
 
@@ -208,25 +213,25 @@ def mapBinary(binary):
         return bytes(mapped_binary)
 
     @staticmethod
-    def getAbi(binary):
+    def getAbi(binary, parsed=None):
         abi = ""
         try:
-            elffile = lief.parse(binary)
+            elffile = parsed if parsed is not None else lief.parse(binary)
             if elffile:
                 abi = elffile.header.identity_os_abi.name
         except lief.bad_file as exc:
             LOGGER.warning("Failed to determine ELF ABI: %s", exc)
         return abi
 
     @staticmethod
-    def getArchitecture(binary):
-        architecture = "intel"
-        return architecture
+    def getArchitecture(binary, parsed=None):
+        del binary, parsed
+        return "intel"
 
     @staticmethod
-    def getBitness(binary):
+    def getBitness(binary, parsed=None):
         # TODO add machine types whenever we add more architectures
-        elffile = lief.parse(binary)
+        elffile = parsed if parsed is not None else lief.parse(binary)
         if not elffile:
             return 0
         machine_type = elffile.header.machine_type
@@ -254,9 +259,9 @@ def mergeCodeAreas(code_areas):
         return merged_code_areas
 
     @staticmethod
-    def getCodeAreas(binary):
+    def getCodeAreas(binary, parsed=None):
         # TODO add machine types whenever we add more architectures
-        elffile = lief.parse(binary)
+        elffile = parsed if parsed is not None else lief.parse(binary)
         if elffile is None:
             return []
         code_areas = []

src/smda/utility/FileLoader.py

@@ -38,12 +38,18 @@ def _loadFile(self, buffer=None):
         if self._map_file:
             for loader in self.file_loaders:
                 if loader.isCompatible(self._raw_data):
-                    self._data = loader.mapBinary(self._raw_data)
-                    self._base_addr = loader.getBaseAddress(self._raw_data)
-                    self._bitness = loader.getBitness(self._raw_data)
-                    self._code_areas = loader.getCodeAreas(self._raw_data)
-                    self._architecture = loader.getArchitecture(self._raw_data)
-                    self._abi = loader.getAbi(self._raw_data)
+                    # PE/ELF/MachO loaders expose parseBinary() so we can
+                    # share a single lief.parse(...) across every accessor
+                    # and skip multiple redundant re-parses per binary
+                    # load. Delphi/Dex loaders don't need lief, so kw
+                    # stays empty for them.
+                    kw = {"parsed": loader.parseBinary(self._raw_data)} if hasattr(loader, "parseBinary") else {}
+                    self._data = loader.mapBinary(self._raw_data, **kw)
+                    self._base_addr = loader.getBaseAddress(self._raw_data, **kw)
+                    self._bitness = loader.getBitness(self._raw_data, **kw)
+                    self._code_areas = loader.getCodeAreas(self._raw_data, **kw)
+                    self._architecture = loader.getArchitecture(self._raw_data, **kw)
+                    self._abi = loader.getAbi(self._raw_data, **kw)
                     break
         else:
             self._data = self._raw_data

src/smda/utility/MachoFileLoader.py

@@ -30,9 +30,14 @@ def isCompatible(data):
         return data[:4] == b"\xce\xfa\xed\xfe" or data[:4] == b"\xcf\xfa\xed\xfe"
 
     @staticmethod
-    def getBaseAddress(binary, macho_file=None):
-        if macho_file is None:
-            macho_file = lief.parse(binary)
+    def parseBinary(binary):
+        # Single lief.parse entry point so FileLoader can share one parse
+        # across all accessors instead of each accessor re-parsing.
+        return lief.parse(binary)
+
+    @staticmethod
+    def getBaseAddress(binary, parsed=None):
+        macho_file = parsed if parsed is not None else lief.parse(binary)
         # Determine base address of binary
         #
         base_addr = 0
@@ -47,17 +52,17 @@ def getBaseAddress(binary, macho_file=None):
         return base_addr
 
     @staticmethod
-    def mapBinary(binary):
+    def mapBinary(binary, parsed=None):
         """
         map the MachO file sections and segments into a contiguous bytearray
         as if into virtual memory with the given base address.
         """
         # MachO needs a file-like object...
         # Attention: for Python 2.x use the cStringIO package for StringIO
-        macho_file = lief.parse(binary)
+        macho_file = parsed if parsed is not None else lief.parse(binary)
         if not macho_file:
             return b""
-        base_addr = MachoFileLoader.getBaseAddress(binary, macho_file=macho_file)
+        base_addr = MachoFileLoader.getBaseAddress(binary, parsed=macho_file)
 
         LOGGER.debug("MachO: base address: 0x%x", base_addr)
 
@@ -162,13 +167,14 @@ def mapBinary(binary):
         return bytes(mapped_binary)
 
     @staticmethod
-    def getAbi(binary):
+    def getAbi(binary, parsed=None):
+        del binary, parsed
         return ""
 
     @staticmethod
-    def getArchitecture(binary):
+    def getArchitecture(binary, parsed=None):
         # TODO add machine types whenever we add more architectures
-        macho_file = lief.parse(binary)
+        macho_file = parsed if parsed is not None else lief.parse(binary)
         if not macho_file:
             return ""
         machine_type = macho_file.header.cpu_type
@@ -185,9 +191,9 @@ def getArchitecture(binary):
         raise NotImplementedError("SMDA does not support this architecture yet.")
 
     @staticmethod
-    def getBitness(binary):
+    def getBitness(binary, parsed=None):
         # TODO add machine types whenever we add more architectures
-        macho_file = lief.parse(binary)
+        macho_file = parsed if parsed is not None else lief.parse(binary)
         if not macho_file:
             return 0
         machine_type = macho_file.header.cpu_type
@@ -217,9 +223,9 @@ def mergeCodeAreas(code_areas):
         return merged_code_areas
 
     @staticmethod
-    def getCodeAreas(binary):
+    def getCodeAreas(binary, parsed=None):
         # TODO add machine types whenever we add more architectures
-        macho_file = lief.parse(binary)
+        macho_file = parsed if parsed is not None else lief.parse(binary)
         if not macho_file:
             return []
         ins_flags = (

src/smda/utility/PeFileLoader.py

@@ -16,7 +16,16 @@ def isCompatible(data):
         return data[:2] == b"MZ"
 
     @staticmethod
-    def mapBinary(binary):
+    def parseBinary(binary):
+        # Single lief.parse entry point so FileLoader can share one parse
+        # across all accessors instead of each accessor re-parsing.
+        return lief.parse(binary)
+
+    @staticmethod
+    def mapBinary(binary, parsed=None):
+        # parsed accepted for API uniformity with ELF/MachO; PE mapping is
+        # done via struct.unpack on the raw bytes and never needs lief.
+        del parsed
         # This is a pretty rough implementation but does the job for now
         mapped_binary = bytearray([])
         pe_offset = PeFileLoader.getPeOffset(binary)
@@ -88,15 +97,21 @@ def mapBinary(binary):
         return bytes(mapped_binary)
 
     @staticmethod
-    def getBitness(binary):
+    def getBitness(binary, parsed=None):
+        # parsed accepted for API uniformity; PE bitness is read from the
+        # COFF header via struct.unpack.
+        del parsed
         bitness_id = 0
         pe_offset = PeFileLoader.getPeOffset(binary)
         if pe_offset and len(binary) >= pe_offset + 0x6:
             bitness_id = struct.unpack("H", binary[pe_offset + 0x4 : pe_offset + 0x6])[0]
         return PeFileLoader.BITNESS_MAP.get(bitness_id, 0)
 
     @staticmethod
-    def getBaseAddress(binary):
+    def getBaseAddress(binary, parsed=None):
+        # parsed accepted for API uniformity; PE base address comes from the
+        # optional header via struct.unpack.
+        del parsed
         base_addr = 0
         pe_offset = PeFileLoader.getPeOffset(binary)
         if pe_offset and len(binary) >= pe_offset + 0x38:
@@ -128,13 +143,14 @@ def getOEP(binary):
         return oep_rva
 
     @staticmethod
-    def getAbi(binary):
+    def getAbi(binary, parsed=None):
+        del binary, parsed
         return ""
 
     @staticmethod
-    def getArchitecture(binary):
+    def getArchitecture(binary, parsed=None):
         architecture = "intel"
-        pefile = lief.parse(binary)
+        pefile = parsed if parsed is not None else lief.parse(binary)
         if pefile:
             for d in pefile.data_directories:
                 if d.type == lief.PE.DataDirectory.TYPES.CLR_RUNTIME_HEADER and d.size > 0:
@@ -150,8 +166,8 @@ def checkPe(binary):
         return False
 
     @staticmethod
-    def getCodeAreas(binary):
-        pefile = lief.parse(binary)
+    def getCodeAreas(binary, parsed=None):
+        pefile = parsed if parsed is not None else lief.parse(binary)
         code_areas = []
         base_address = PeFileLoader.getBaseAddress(binary)
         if pefile and pefile.sections: