"""Read dynamic symbols from a 32-bit little-endian ARM ELF.

Companion to elfdeps.py. elfdeps answers "which libraries does this need";
this answers "which symbols does it need from them, and which does a library
provide". That is the difference between assuming a library substitution is
safe and checking it.

The netBook Pro rootfs carries its own OpenEmbedded build of several
libraries that Debian packages also ship -- libgcrypt, libgnutls,
libgnomeprint and friends. Where both exist the device's copy is kept, since
other installed programs already link against it, but only after confirming
it still defines everything the incoming binaries reference.
"""

import struct
import sys

SHT_DYNSYM = 11
STT_FUNC, STT_OBJECT = 2, 1
SHN_UNDEF = 0
STB_WEAK = 2


def _read(path):
    try:
        d = open(path, "rb").read()
    except OSError:
        return None
    if d[:4] != b"\x7fELF" or d[4] != 1:        # 32-bit only
        return None
    return d


def _sections(d):
    e_shoff, = struct.unpack_from("<I", d, 32)
    e_shentsize, e_shnum = struct.unpack_from("<HH", d, 46)
    if not e_shoff or not e_shnum:
        return []
    out = []
    for i in range(e_shnum):
        o = e_shoff + i * e_shentsize
        name, typ, flags, addr, off, size, link, info, align, entsize = \
            struct.unpack_from("<IIIIIIIIII", d, o)
        out.append({"type": typ, "off": off, "size": size,
                    "link": link, "entsize": entsize})
    return out


def symbols(path):
    """Return (defined, undefined) sets of dynamic symbol names.

    Weak undefined symbols are left out of "undefined". Every binary gcc
    produces carries _Jv_RegisterClasses and __gmon_start__ as weak
    undefined references that are meant to stay unresolved; counting them
    would flag every single binary as broken.
    """
    defined, undefined = set(), set()
    d = _read(path)
    if d is None:
        return defined, undefined

    for sh in _sections(d):
        if sh["type"] != SHT_DYNSYM or not sh["entsize"]:
            continue
        strs = _sections(d)[sh["link"]]
        sbase, slen = strs["off"], strs["size"]
        n = sh["size"] // sh["entsize"]
        for i in range(n):
            o = sh["off"] + i * sh["entsize"]
            if o + 16 > len(d):
                break
            st_name, st_value, st_size, st_info, st_other, st_shndx = \
                struct.unpack_from("<IIIBBH", d, o)
            if not st_name:
                continue
            p = sbase + st_name
            if p >= sbase + slen:
                continue
            end = d.find(b"\x00", p)
            nm = d[p:end].decode("ascii", "replace")
            # strip the @VERSION suffix; the device's libraries are mostly
            # unversioned and comparing bare names is what matters here
            nm = nm.split("@", 1)[0]
            if st_shndx == SHN_UNDEF:
                if st_info >> 4 != STB_WEAK:
                    undefined.add(nm)
            else:
                defined.add(nm)
    return defined, undefined


if __name__ == "__main__":
    for p in sys.argv[1:]:
        dfn, und = symbols(p)
        print(f"{p}: {len(dfn)} defined, {len(und)} undefined")