frida 16.2.0 → 16.2.2

package/releng/env_apple.py

@@ -0,0 +1,176 @@
+from configparser import ConfigParser
+from pathlib import Path
+import shlex
+import subprocess
+from typing import Callable, Optional
+
+from .machine_file import strv_to_meson
+from .machine_spec import MachineSpec
+
+
+def init_machine_config(machine: MachineSpec,
+                        build_machine: MachineSpec,
+                        is_cross_build: bool,
+                        environ: dict[str, str],
+                        toolchain_prefix: Optional[Path],
+                        sdk_prefix: Optional[Path],
+                        call_selected_meson: Callable,
+                        config: ConfigParser,
+                        outpath: list[str],
+                        outenv: dict[str, str],
+                        outdir: Path):
+    xcenv = {**environ}
+    if machine.arch == "arm64eoabi":
+        try:
+            xcenv["DEVELOPER_DIR"] = (Path(xcenv["XCODE11"]) / "Contents" / "Developer").as_posix()
+        except KeyError:
+            raise Xcode11NotFoundError("for arm64eoabi support, XCODE11 must be set to the location of your Xcode 11 app bundle")
+
+    def xcrun(*args):
+        try:
+            return subprocess.run(["xcrun"] + list(args),
+                                  env=xcenv,
+                                  capture_output=True,
+                                  encoding="utf-8",
+                                  check=True).stdout.strip()
+        except subprocess.CalledProcessError as e:
+            raise XCRunError("\n\t| ".join(e.stderr.strip().split("\n")))
+
+    clang_arch = APPLE_CLANG_ARCHS.get(machine.arch, machine.arch)
+
+    os_minver = APPLE_MINIMUM_OS_VERSIONS.get(machine.os_dash_arch,
+                                              APPLE_MINIMUM_OS_VERSIONS[machine.os])
+
+    target = f"{clang_arch}-apple-{machine.os}{os_minver}"
+    if machine.config is not None:
+        target += "-" + machine.config
+
+    sdk_name = APPLE_SDKS[machine.os_dash_config]
+    sdk_path = xcrun("--sdk", sdk_name, "--show-sdk-path")
+
+    use_static_libcxx = sdk_prefix is not None \
+            and (sdk_prefix / "lib" / "c++" / "libc++.a").exists() \
+            and machine.os != "watchos"
+
+    binaries = config["binaries"]
+    clang_path = None
+    for (identifier, tool_name, *rest) in APPLE_BINARIES:
+        if tool_name.startswith("#"):
+            binaries[identifier] = binaries[tool_name[1:]]
+            continue
+
+        path = xcrun("--sdk", sdk_name, "-f", tool_name)
+        if tool_name == "clang":
+            clang_path = Path(path)
+
+        argv = [path]
+        if len(rest) != 0:
+            argv += rest[0]
+        if identifier == "cpp" and not use_static_libcxx:
+            argv += ["-stdlib=libc++"]
+        if identifier == "swift":
+            argv += ["-target", target, "-sdk", sdk_path]
+
+        raw_val = str(argv)
+        if identifier in {"c", "cpp"}:
+            raw_val += " + common_flags"
+
+        binaries[identifier] = raw_val
+
+    read_envflags = lambda name: shlex.split(environ.get(name, ""))
+
+    c_like_flags = read_envflags("CPPFLAGS")
+
+    linker_flags = ["-Wl,-dead_strip"]
+    if (clang_path.parent / "ld-classic").exists():
+        # New linker links with libresolv even if we're not using any symbols from it,
+        # at least as of Xcode 15.0 beta 7.
+        linker_flags += ["-Wl,-ld_classic"]
+    linker_flags += read_envflags("LDFLAGS")
+
+    constants = config["constants"]
+    constants["common_flags"] = strv_to_meson([
+        "-target", target,
+        "-isysroot", sdk_path,
+    ])
+    constants["c_like_flags"] = strv_to_meson(c_like_flags)
+    constants["linker_flags"] = strv_to_meson(linker_flags)
+
+    if use_static_libcxx:
+        constants["cxx_like_flags"] = strv_to_meson([
+            "-nostdinc++",
+            "-isystem" + str(sdk_prefix / "include" / "c++"),
+        ])
+        constants["cxx_link_flags"] = strv_to_meson([
+            "-nostdlib++",
+            "-L" + str(sdk_prefix / "lib" / "c++"),
+            "-lc++",
+            "-lc++abi",
+        ])
+    else:
+        constants["cxx_like_flags"] = strv_to_meson([])
+        constants["cxx_link_flags"] = strv_to_meson([])
+
+    options = config["built-in options"]
+    options["c_args"] = "c_like_flags + " + strv_to_meson(read_envflags("CFLAGS"))
+    options["cpp_args"] = "c_like_flags + cxx_like_flags + " + strv_to_meson(read_envflags("CXXFLAGS"))
+    options["objc_args"] = "c_like_flags + " + strv_to_meson(read_envflags("OBJCFLAGS"))
+    options["objcpp_args"] = "c_like_flags + cxx_like_flags + " + strv_to_meson(read_envflags("OBJCXXFLAGS"))
+    options["c_link_args"] = "linker_flags"
+    options["cpp_link_args"] = "linker_flags + cxx_link_flags"
+    options["objc_link_args"] = "linker_flags"
+    options["objcpp_link_args"] = "linker_flags + cxx_link_flags"
+    options["b_lundef"] = "true"
+
+
+class XCRunError(Exception):
+    pass
+
+
+class Xcode11NotFoundError(Exception):
+    pass
+
+
+APPLE_SDKS = {
+    "macos":             "macosx",
+    "ios":               "iphoneos",
+    "ios-simulator":     "iphonesimulator",
+    "watchos":           "watchos",
+    "watchos-simulator": "watchsimulator",
+    "tvos":              "appletvos",
+    "tvos-simulator":    "appletvsimulator",
+}
+
+APPLE_CLANG_ARCHS = {
+    "x86":        "i386",
+    "arm":        "armv7",
+    "arm64eoabi": "arm64e",
+}
+
+APPLE_MINIMUM_OS_VERSIONS = {
+    "macos":        "10.13",
+    "macos-arm64":  "11.0",
+    "macos-arm64e": "11.0",
+    "ios":          "8.0",
+    "watchos":      "9.0",
+    "tvos":         "13.0",
+}
+
+APPLE_BINARIES = [
+    ("c",                 "clang"),
+    ("cpp",               "clang++"),
+    ("objc",              "#c"),
+    ("objcpp",            "#cpp"),
+    ("swift",             "swiftc"),
+
+    ("ar",                "ar"),
+    ("nm",                "llvm-nm"),
+    ("ranlib",            "ranlib"),
+    ("strip",             "strip", ["-Sx"]),
+    ("libtool",           "libtool"),
+
+    ("install_name_tool", "install_name_tool"),
+    ("otool",             "otool"),
+    ("codesign",          "codesign"),
+    ("lipo",              "lipo"),
+]

package/releng/env_generic.py

@@ -0,0 +1,373 @@
+from collections import OrderedDict
+from configparser import ConfigParser
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+from typing import Callable, Optional, Mapping, Sequence
+
+from . import winenv
+from .machine_file import strv_to_meson
+from .machine_spec import MachineSpec
+
+
+def init_machine_config(machine: MachineSpec,
+                        build_machine: MachineSpec,
+                        is_cross_build: bool,
+                        environ: dict[str, str],
+                        toolchain_prefix: Optional[Path],
+                        sdk_prefix: Optional[Path],
+                        call_selected_meson: Callable,
+                        config: ConfigParser,
+                        outpath: list[str],
+                        outenv: dict[str, str],
+                        outdir: Path):
+    allow_undefined_symbols = machine.os == "freebsd"
+
+    options = config["built-in options"]
+    options["c_args"] = "c_like_flags"
+    options["cpp_args"] = "c_like_flags + cxx_like_flags"
+    options["c_link_args"] = "linker_flags"
+    options["cpp_link_args"] = "linker_flags + cxx_link_flags"
+    options["b_lundef"] = str(not allow_undefined_symbols).lower()
+
+    binaries = config["binaries"]
+    cc = None
+    common_flags = []
+    c_like_flags = []
+    linker_flags = []
+    cxx_like_flags = []
+    cxx_link_flags = []
+
+    triplet = machine.triplet
+    if triplet is not None:
+        try:
+            cc, gcc_binaries = resolve_gcc_binaries(toolprefix=triplet + "-")
+            binaries.update(gcc_binaries)
+        except CompilerNotFoundError:
+            pass
+
+    diagnostics = None
+    if cc is None:
+        with tempfile.TemporaryDirectory() as raw_prober_dir:
+            prober_dir = Path(raw_prober_dir)
+            machine_file = prober_dir / "machine.txt"
+
+            argv = [
+                "env2mfile",
+                "-o", machine_file,
+                "--native" if machine == build_machine else "--cross",
+            ]
+
+            if machine != build_machine:
+                argv += [
+                    "--system", machine.system,
+                    "--subsystem", machine.subsystem,
+                    "--kernel", machine.kernel,
+                    "--cpu-family", machine.cpu_family,
+                    "--cpu", machine.cpu,
+                    "--endian", machine.endian,
+                ]
+
+            process = call_selected_meson(argv,
+                                          cwd=raw_prober_dir,
+                                          env=environ,
+                                          stdout=subprocess.PIPE,
+                                          stderr=subprocess.STDOUT,
+                                          encoding="utf-8")
+            if process.returncode == 0:
+                mcfg = ConfigParser()
+                mcfg.read(machine_file)
+
+                for section in mcfg.sections():
+                    copy = config[section] if section in config else OrderedDict()
+                    for key, val in mcfg.items(section):
+                        if section == "binaries":
+                            argv = eval(val.replace("\\", "\\\\"))
+                            if not Path(argv[0]).is_absolute():
+                                path = shutil.which(argv[0])
+                                if path is None:
+                                    raise BinaryNotFoundError(f"unable to locate {argv[0]}")
+                                argv[0] = path
+                            val = strv_to_meson(argv)
+                            if key in {"c", "cpp"}:
+                                val += " + common_flags"
+                        if key in copy and section == "built-in options" and key.endswith("_args"):
+                            val = val + " + " + copy[key]
+                        copy[key] = val
+                    config[section] = copy
+
+                raw_cc = binaries.get("c", None)
+                if raw_cc is not None:
+                    cc = eval(raw_cc.replace("\\", "\\\\"), None, {"common_flags": []})
+            else:
+                diagnostics = process.stdout
+
+    linker_flavor = None
+
+    if cc is not None \
+            and machine.os == "windows" \
+            and machine.toolchain_is_msvc:
+        linker_flavor = detect_linker_flavor(cc)
+        detected_wrong_toolchain = linker_flavor != "msvc"
+        if detected_wrong_toolchain:
+            cc = None
+            linker_flavor = None
+
+    if cc is None:
+        if machine.os == "windows":
+            detect_tool_path = lambda name: winenv.detect_msvs_tool_path(machine, build_machine, name, toolchain_prefix)
+
+            cc = [str(detect_tool_path("cl.exe"))]
+            lib = [str(detect_tool_path("lib.exe"))]
+            link = [str(detect_tool_path("link.exe"))]
+            assembler_name = MSVC_ASSEMBLER_NAMES[machine.arch]
+            assembler_tool = [str(detect_tool_path(assembler_name + ".exe"))]
+
+            raw_cc = strv_to_meson(cc) + " + common_flags"
+            binaries["c"] = raw_cc
+            binaries["cpp"] = raw_cc
+            binaries["lib"] = strv_to_meson(lib) + " + common_flags"
+            binaries["link"] = strv_to_meson(link) + " + common_flags"
+            binaries[assembler_name] = strv_to_meson(assembler_tool) + " + common_flags"
+
+            runtime_dirs = winenv.detect_msvs_runtime_path(machine, build_machine, toolchain_prefix)
+            outpath.extend(runtime_dirs)
+
+            vs_dir = winenv.detect_msvs_installation_dir(toolchain_prefix)
+            outenv["VSINSTALLDIR"] = str(vs_dir) + "\\"
+            outenv["VCINSTALLDIR"] = str(vs_dir / "VC") + "\\"
+            outenv["Platform"] = machine.msvc_platform
+            outenv["INCLUDE"] = ";".join([str(path) for path in winenv.detect_msvs_include_path(toolchain_prefix)])
+            outenv["LIB"] = ";".join([str(path) for path in winenv.detect_msvs_library_path(machine, toolchain_prefix)])
+        elif machine != build_machine \
+                and "CC" not in environ \
+                and "CFLAGS" not in environ \
+                and machine.os == build_machine.os \
+                and machine.os == "linux" \
+                and machine.pointer_size == 4 \
+                and build_machine.pointer_size == 8:
+            try:
+                cc, gcc_binaries = resolve_gcc_binaries()
+                binaries.update(gcc_binaries)
+                common_flags += ["-m32"]
+            except CompilerNotFoundError:
+                pass
+
+    if cc is None:
+        suffix = ":\n" + diagnostics if diagnostics is not None else ""
+        raise CompilerNotFoundError("no C compiler found" + suffix)
+
+    if "cpp" not in binaries:
+        raise CompilerNotFoundError("no C++ compiler found")
+
+    if linker_flavor is None:
+        linker_flavor = detect_linker_flavor(cc)
+
+    strip_binary = binaries.get("strip", None)
+    if strip_binary is not None:
+        strip_arg = "-Sx" if linker_flavor == "apple" else "--strip-all"
+        binaries["strip"] = strip_binary[:-1] + f", '{strip_arg}']"
+
+    if linker_flavor == "msvc":
+        for gnu_tool in ["ar", "as", "ld", "nm", "objcopy", "objdump",
+                         "ranlib", "readelf", "size", "strip", "windres"]:
+            binaries.pop(gnu_tool, None)
+
+        c_like_flags += [
+            "/GS-",
+            "/Gy",
+            "/Zc:inline",
+            "/fp:fast",
+        ]
+        if machine.arch == "x86":
+            c_like_flags += ["/arch:SSE2"]
+
+        # Relax C++11 compliance for XP compatibility.
+        cxx_like_flags += ["/Zc:threadSafeInit-"]
+    else:
+        if machine.os == "qnx":
+            common_flags += ARCH_COMMON_FLAGS_QNX.get(machine.arch, [])
+        else:
+            common_flags += ARCH_COMMON_FLAGS_UNIX.get(machine.arch, [])
+        c_like_flags += ARCH_C_LIKE_FLAGS_UNIX.get(machine.arch, [])
+
+        c_like_flags += [
+            "-ffunction-sections",
+            "-fdata-sections",
+        ]
+
+        if linker_flavor.startswith("gnu-"):
+            linker_flags += ["-static-libgcc"]
+            if machine.os != "windows":
+                linker_flags += [
+                    "-Wl,-z,relro",
+                    "-Wl,-z,noexecstack",
+                ]
+            cxx_link_flags += ["-static-libstdc++"]
+
+        if linker_flavor == "apple":
+            linker_flags += ["-Wl,-dead_strip"]
+        else:
+            linker_flags += ["-Wl,--gc-sections"]
+        if linker_flavor == "gnu-gold":
+            linker_flags += ["-Wl,--icf=all"]
+
+    constants = config["constants"]
+    constants["common_flags"] = strv_to_meson(common_flags)
+    constants["c_like_flags"] = strv_to_meson(c_like_flags)
+    constants["linker_flags"] = strv_to_meson(linker_flags)
+    constants["cxx_like_flags"] = strv_to_meson(cxx_like_flags)
+    constants["cxx_link_flags"] = strv_to_meson(cxx_link_flags)
+
+
+def resolve_gcc_binaries(toolprefix: str = "") -> tuple[list[str], dict[str, str]]:
+    cc = None
+    binaries = OrderedDict()
+
+    for identifier in GCC_TOOL_IDS:
+        name = GCC_TOOL_NAMES.get(identifier, identifier)
+        full_name = toolprefix + name
+
+        val = shutil.which(full_name)
+        if val is None:
+            raise CompilerNotFoundError(f"missing {full_name}")
+
+        # QNX SDP 6.5 gcc-* tools are broken, erroring out with:
+        # > sorry - this program has been built without plugin support
+        # We detect this and use the tool without the gcc-* prefix.
+        if name.startswith("gcc-"):
+            p = subprocess.run([val, "--version"], capture_output=True)
+            if p.returncode != 0:
+                full_name = toolprefix + name[4:]
+                val = shutil.which(full_name)
+                if val is None:
+                    raise CompilerNotFoundError(f"missing {full_name}")
+
+        if identifier == "c":
+            cc = [val]
+
+        extra = " + common_flags" if identifier in {"c", "cpp"} else ""
+
+        binaries[identifier] = strv_to_meson([val]) + extra
+
+    return (cc, binaries)
+
+
+def detect_linker_flavor(cc: list[str]) -> str:
+    linker_version = subprocess.run(cc + ["-Wl,--version"],
+                                    stdout=subprocess.PIPE,
+                                    stderr=subprocess.STDOUT,
+                                    encoding="utf-8").stdout
+    if linker_version.startswith("Microsoft "):
+        return "msvc"
+    if "GNU ld " in linker_version:
+        return "gnu-ld"
+    if "GNU gold " in linker_version:
+        return "gnu-gold"
+    if linker_version.startswith("LLD "):
+        return "lld"
+    if linker_version.startswith("ld: "):
+        return "apple"
+
+    excerpt = linker_version.split("\n")[0].rstrip()
+    raise LinkerDetectionError(f"unknown linker: '{excerpt}'")
+
+
+class CompilerNotFoundError(Exception):
+    pass
+
+
+class BinaryNotFoundError(Exception):
+    pass
+
+
+class LinkerDetectionError(Exception):
+    pass
+
+
+ARCH_COMMON_FLAGS_UNIX = {
+    "x86": [
+        "-march=pentium4",
+    ],
+    "arm": [
+        "-march=armv5t",
+    ],
+    "armbe8": [
+        "-march=armv6",
+        "-mbe8",
+    ],
+    "armhf": [
+        "-march=armv7-a",
+    ],
+    "arm64": [
+        "-march=armv8-a",
+    ],
+    "mips": [
+        "-march=mips1",
+        "-mfp32",
+    ],
+    "mipsel": [
+        "-march=mips1",
+        "-mfp32",
+    ],
+    "mips64": [
+        "-march=mips64r2",
+        "-mabi=64",
+    ],
+    "mips64el": [
+        "-march=mips64r2",
+        "-mabi=64",
+    ],
+    "s390x": [
+        "-march=z10",
+        "-m64",
+    ],
+}
+
+ARCH_COMMON_FLAGS_QNX = {
+    "x86": [
+        "-march=i686",
+    ],
+    "arm": [
+        "-march=armv6",
+        "-mno-unaligned-access",
+    ],
+    "armeabi": [
+        "-march=armv7-a",
+        "-mno-unaligned-access",
+    ],
+}
+
+ARCH_C_LIKE_FLAGS_UNIX = {
+    "x86": [
+        "-mfpmath=sse",
+        "-mstackrealign",
+    ],
+}
+
+GCC_TOOL_IDS = [
+    "c",
+    "cpp",
+    "ar",
+    "nm",
+    "ranlib",
+    "strip",
+    "readelf",
+    "objcopy",
+    "objdump",
+]
+
+GCC_TOOL_NAMES = {
+    "c": "gcc",
+    "cpp": "g++",
+    "ar": "gcc-ar",
+    "nm": "gcc-nm",
+    "ranlib": "gcc-ranlib",
+}
+
+MSVC_ASSEMBLER_NAMES = {
+    "x86": "ml",
+    "x86_64": "ml64",
+    "arm64": "armasm64",
+}

package/releng/frida_version.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+import argparse
+from dataclasses import dataclass
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+RELENG_DIR = Path(__file__).resolve().parent
+ROOT_DIR = RELENG_DIR.parent
+
+
+@dataclass
+class FridaVersion:
+    name: str
+    major: int
+    minor: int
+    micro: int
+    nano: int
+    commit: str
+
+
+def main(argv: list[str]):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("repo", nargs="?", type=Path, default=ROOT_DIR)
+    args = parser.parse_args()
+
+    version = detect(args.repo)
+    print(version.name)
+
+
+def detect(repo: Path) -> FridaVersion:
+    version_name = "0.0.0"
+    major = 0
+    minor = 0
+    micro = 0
+    nano = 0
+    commit = ""
+
+    if (repo / ".git").exists():
+        description = subprocess.run(["git", "describe", "--tags", "--always", "--long"],
+                                     cwd=repo,
+                                     capture_output=True,
+                                     encoding="utf-8").stdout
+
+        tokens = description.strip().replace("-", ".").split(".")
+        if len(tokens) > 1:
+            (raw_major, raw_minor, raw_micro, raw_nano, commit) = tokens
+            major = int(raw_major)
+            minor = int(raw_minor)
+            micro = int(raw_micro)
+            nano = int(raw_nano)
+            if nano > 0:
+                micro += 1
+
+            if nano == 0:
+                version_name = f"{major}.{minor}.{micro}"
+            else:
+                version_name = f"{major}.{minor}.{micro}-dev.{nano - 1}"
+        else:
+            commit = tokens[0]
+
+    return FridaVersion(version_name, major, minor, micro, nano, commit)
+
+
+if __name__ == "__main__":
+    main(sys.argv)

package/releng/machine_file.py

@@ -0,0 +1,44 @@
+from configparser import ConfigParser
+from pathlib import Path
+from typing import Sequence, Union
+
+
+def load(mfile: Path) -> dict[str, Union[str, list[str]]]:
+    config = ConfigParser()
+    config.read(mfile)
+
+    hidden_constants = {
+        "true": True,
+        "false": False,
+    }
+
+    items = {}
+    if config.has_section("constants"):
+        for name, raw_value in config.items("constants"):
+            items[name] = eval(raw_value, hidden_constants, items)
+
+    for section_name, section in config.items():
+        if section_name in ("DEFAULT", "constants"):
+            continue
+        for name, raw_value in section.items():
+            value = eval(raw_value, hidden_constants, items)
+            if section_name == "binaries" and isinstance(value, str):
+                value = [value]
+            items[name] = value
+
+    if len(items) == 0:
+        return None
+
+    return items
+
+
+def bool_to_meson(b: bool) -> str:
+    return "true" if b else "false"
+
+
+def strv_to_meson(strv: Sequence[str]) -> str:
+    return "[" + ", ".join(map(str_to_meson, strv)) + "]"
+
+
+def str_to_meson(s: str) -> str:
+    return "'" + s + "'"