"""One loaded NSO module as the generator and its analyses see it: image at a guest base, .text as words, function seeds, and bounded-cache instruction lifting. The function seeds and the .eh_frame_hdr reader are adapted from LAS Recomp tools/analyze.py and tools/gen.py @ da35b83 (MIT, Copyright (c) 2026 Peiikai). """ import struct from collections import OrderedDict import numpy as np from lifter import Insn, Lifter, Unsupported, hx from nso import DT_INIT, DT_INIT_ARRAY, DT_INIT_ARRAYSZ, Nso, R_AARCH64_RELATIVE LIFT_CACHE = 1 << 16 # lifted instructions kept per module; analyses revisit nearby addresses only def _read_encoded(img, off, enc, pc_base): fmt, app = enc & 0x0F, enc & 0x70 if fmt == 0x0B: # sdata4 v, size = struct.unpack_from('): its init functions are seeds too n = self.nso self.image = bytes(n.image) self.lo = base + n.text[0] self.hi = self.lo + n.text[1] self.words = np.frombuffer(self.image, dtype='> 2]) def read(self, a, n, signed=False): """Little-endian integer of n bytes at guest address a (unrelocated image).""" o = a - self.base return int.from_bytes(self.image[o:o + n], 'little', signed=signed) # ---- lifting def lift(self, a): """Lifted instruction at a; Unsupported becomes an rt_udf trap.""" ins = self._cache.get(a) if ins is not None: self._cache.move_to_end(a) return ins try: ins = self.lifter.lift(self.word(a), a) except Unsupported as e: ins = Insn('trap', f'rt_udf(c, {hx(a)}); /* {e} */') self._cache[a] = ins if len(self._cache) > LIFT_CACHE: self._cache.popitem(last=False) return ins # ---- function seeds def eh_frame_functions(self): """Function starts from .eh_frame_hdr's binary search table (absolute addresses).""" img, hdr = self.image, self.nso.eh_start if not hdr or hdr >= len(img) or self.nso.eh_end <= hdr: # MOD0 with an empty .eh_frame_hdr range (exlaunch) return [] _, ptr_enc, cnt_enc, tbl_enc = img[hdr:hdr + 4] off = hdr + 4 _, sz = _read_encoded(img, off, ptr_enc, hdr) off += sz count, sz = _read_encoded(img, off, cnt_enc, hdr) off += sz starts = [] for _ in range(count): loc, sz = _read_encoded(img, off, tbl_enc, hdr) off += sz _, sz = _read_encoded(img, off, tbl_enc, hdr) off += sz starts.append(self.base + loc) return starts def init_functions(self): """DT_INIT and the DT_INIT_ARRAY entries (absolute addresses). rtld calls DT_INIT only; the module's DT_INIT runs the array through blr (SDK and exlaunch modules alike), so the entries are seeds too. An entry holds its target as the addend of its R_AARCH64_RELATIVE relocation, or as the word itself when no relocation names it.""" dyn, out = self.nso.dyn, [] if dyn.get(DT_INIT): out.append(self.base + dyn[DT_INIT]) if dyn.get(DT_INIT_ARRAY): addends = {off: add for off, typ, _, add in self.nso.relocs if typ == R_AARCH64_RELATIVE} for off in range(dyn[DT_INIT_ARRAY], dyn[DT_INIT_ARRAY] + dyn.get(DT_INIT_ARRAYSZ, 0), 8): out.append(self.base + addends.get(off, self.nso.u64(off))) return out def seeds(self): """Known function starts: .eh_frame_hdr, exported FUNC symbols, R_AARCH64_RELATIVE targets in .text; for a plugin also its init functions (exlaunch's DT_INIT starts inside a function discovery would merge it into).""" starts = set(self.eh_frame_functions()) if self.plugin: starts.update(self.init_functions()) for _, info, shndx, value, _ in self.nso.syms: if shndx and (info & 0xF) == 2: starts.add(self.base + value) for _, typ, _, add in self.nso.relocs: if typ == R_AARCH64_RELATIVE: starts.add(self.base + add) return sorted(a for a in starts if self.in_text(a))