Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
4.6 KB
Raw Blame
"""tools/hip/dll_closure.py - which DLLs a DLL needs, read from the PE import tables (no pefile, no objdump).

    python tools/hip/dll_closure.py DIR amdhip64_7.dll amd_comgr.dll      # prints the closure inside DIR

Why: the Windows HIP engine puts amdhip64_7.dll and amd_comgr.dll next to strata.exe so that Windows binds THEM and not
an AMD driver's copy in System32 (#468, #461).  But amdhip64_7.dll itself imports rocm_kpack.dll, which imports the
MSVC runtime; with only the two DLLs beside the exe the full-path load fails (error 126, ERROR_MOD_NOT_FOUND), Windows
falls back to System32's copy, and the first big prompt dies with hipErrorInvalidDeviceFunction (#461, maraa081).  So
what goes beside the exe is the DLLs' whole dependency closure, computed here from the files actually shipped rather
than from a list of names that goes stale with the next ROCm.

A name is followed only when the DLL exists in `search_dir` (the bundle's rocm/bin).  Everything else - kernel32,
user32, setupapi, the api-ms-win-* forwarders - is a Windows system DLL and is left alone.
"""
from __future__ import annotations

import struct
import sys
from pathlib import Path


def pe_imports(path) -> list[str]:
    """The DLL names in a PE file's import table and delay-import table, in file order.  [] for a file that is not a
    PE image (or is truncated): the caller treats it as a leaf."""
    try:
        data = Path(path).read_bytes()
    except OSError:
        return []
    try:
        if data[:2] != b"MZ":
            return []
        pe = struct.unpack_from("<I", data, 0x3C)[0]
        if data[pe:pe + 4] != b"PE\0\0":
            return []
        nsec, = struct.unpack_from("<H", data, pe + 6)
        opt_size, = struct.unpack_from("<H", data, pe + 20)
        opt = pe + 24
        magic, = struct.unpack_from("<H", data, opt)
        dd = opt + (112 if magic == 0x20B else 96)          # PE32+ : 112, PE32 : 96
        secs = []
        sec0 = opt + opt_size
        for i in range(nsec):
            o = sec0 + 40 * i
            vsize, va, rsize, raw = struct.unpack_from("<IIII", data, o + 8)
            secs.append((va, max(vsize, rsize), raw))

        def off(rva):
            for va, size, raw in secs:
                if va <= rva < va + size:
                    return rva - va + raw
            return None

        def cstr(o):
            e = data.index(b"\0", o)
            return data[o:e].decode("ascii", "replace")

        names: list[str] = []
        imp_rva, = struct.unpack_from("<I", data, dd + 8 * 1)                 # directory 1: imports
        o = off(imp_rva) if imp_rva else None
        while o is not None:
            name_rva = struct.unpack_from("<I", data, o + 12)[0]
            if name_rva == 0:
                break
            n = off(name_rva)
            if n is not None:
                names.append(cstr(n))
            o += 20
        dly_rva, = struct.unpack_from("<I", data, dd + 8 * 13)                # directory 13: delay imports
        o = off(dly_rva) if dly_rva else None
        while o is not None:
            attrs, name_rva = struct.unpack_from("<II", data, o)
            if name_rva == 0:
                break
            n = off(name_rva)                                                 # (RVA form, attrs bit 0)
            if n is not None:
                names.append(cstr(n))
            o += 32
        return names
    except (struct.error, ValueError, IndexError):
        return []


def dll_closure(search_dir, roots, imports=pe_imports) -> list[str]:
    """`roots` (file names inside `search_dir`) plus every DLL in `search_dir` they import, followed recursively.
    The names are returned as spelled on disk, roots first, the rest in discovery order.  A root that is not in the
    directory is skipped; an import that is not in the directory (a Windows system DLL) is not followed."""
    d = Path(search_dir)
    on_disk = {p.name.lower(): p.name for p in d.iterdir() if p.is_file() and p.suffix.lower() == ".dll"} \
        if d.is_dir() else {}
    out: list[str] = []
    todo = [r for r in roots]
    seen: set[str] = set()
    while todo:
        name = todo.pop(0)
        low = name.lower()
        if low in seen or low not in on_disk:
            continue
        seen.add(low)
        real = on_disk[low]
        out.append(real)
        for dep in imports(d / real):
            if dep.lower() not in seen:
                todo.append(dep)
    return out


def main() -> int:
    if len(sys.argv) < 3:
        print(__doc__)
        return 2
    for n in dll_closure(sys.argv[1], sys.argv[2:]):
        print(n)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())