autoPatchelfHook: add `patchelfFlags` option

    found: bool = False     # Whether it was found somewhere

def auto_patchelf_file(path: Path, runtime_deps: list[Path], append_rpaths: List[Path] = []) -> list[Dependency]:

def auto_patchelf_file(path: Path, runtime_deps: list[Path], append_rpaths: List[Path] = [], extra_args: List[str] = []) -> list[Dependency]:

    try:

        with open_elf(path) as elf:

    if file_is_dynamic_executable:

        print("setting interpreter of", path)

        subprocess.run(

                ["patchelf", "--set-interpreter", interpreter_path.as_posix(), path.as_posix()],

                ["patchelf", "--set-interpreter", interpreter_path.as_posix(), path.as_posix()] + extra_args,

                check=True)

        rpath += runtime_deps

    if rpath:

        print("setting RPATH to:", rpath_str)

        subprocess.run(

                ["patchelf", "--set-rpath", rpath_str, path.as_posix()],

                ["patchelf", "--set-rpath", rpath_str, path.as_posix()] + extra_args,

                check=True)

    return dependencies

        runtime_deps: List[Path],

        recursive: bool = True,

        ignore_missing: List[str] = [],

        append_rpaths: List[Path] = []) -> None:

        append_rpaths: List[Path] = [],

        extra_args: List[str] = []) -> None:

    if not paths_to_patch:

        sys.exit("No paths to patch, stopping.")

    dependencies = []

    for path in chain.from_iterable(glob(p, '*', recursive) for p in paths_to_patch):

        if not path.is_symlink() and path.is_file():

            dependencies += auto_patchelf_file(path, runtime_deps, append_rpaths)

            dependencies += auto_patchelf_file(path, runtime_deps, append_rpaths, extra_args)

    missing = [dep for dep in dependencies if not dep.found]

        type=Path,

        help="Paths to append to all runtime paths unconditionally",

    )

    parser.add_argument(

        "--extra-args",

        nargs="*",

        type=str,

        help="Extra arguments to pass to patchelf"

    )

    print("automatically fixing dependencies for ELF files")

    args = parser.parse_args()

        args.runtime_dependencies,

        args.recursive,

        args.ignore_missing,

        append_rpaths=args.append_rpaths)

        append_rpaths=args.append_rpaths,

        extra_args=args.extra_args)

interpreter_path: Path  = None # type: ignore

    local appendRunpathsArray=($appendRunpaths)

    local runtimeDependenciesArray=($runtimeDependencies)

    local patchelfFlagsArray=($patchelfFlags)

    @pythonInterpreter@ @autoPatchelfScript@                            \

        ${norecurse:+--no-recurse}                                      \

        --ignore-missing "${ignoreMissingDepsArray[@]}"                 \

        --libs "${autoPatchelfLibs[@]}"                                 \

               "${extraAutoPatchelfLibs[@]}"                            \

        --runtime-dependencies "${runtimeDependenciesArray[@]/%//lib}"  \

        --append-rpaths "${appendRunpathsArray[@]}"

        --append-rpaths "${appendRunpathsArray[@]}"                     \

        --extra-args "${patchelfFlagsArray[@]}"

}

# XXX: This should ultimately use fixupOutputHooks but we currently don't have