frida 16.2.1 → 16.2.2

package/releng/machine_spec.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+from dataclasses import dataclass
+import platform
+import re
+from typing import Optional
+
+
+@dataclass
+class MachineSpec:
+    os: str
+    arch: str
+    config: Optional[str] = None
+    triplet: Optional[str] = None
+
+    @staticmethod
+    def make_from_local_system() -> MachineSpec:
+        return MachineSpec(detect_os(), detect_arch())
+
+    @staticmethod
+    def parse(raw_spec: str) -> MachineSpec:
+        os = None
+        arch = None
+        config = None
+        triplet = None
+
+        tokens = raw_spec.split("-")
+        if len(tokens) in {3, 4}:
+            arch = tokens[0]
+            m = TARGET_TRIPLET_ARCH_PATTERN.match(arch)
+            if m is not None:
+                kernel = tokens[-2]
+                system = tokens[-1]
+
+                if kernel == "w64":
+                    os = "windows"
+                elif kernel == "nto":
+                    os = "qnx"
+                else:
+                    os = kernel
+
+                if arch[0] == "i":
+                    arch = "x86"
+                elif arch == "arm":
+                    if system == "gnueabihf":
+                        arch = "armhf"
+                    elif os == "qnx" and system.endswith("eabi"):
+                        arch = "armeabi"
+                elif arch == "aarch64":
+                    arch = "arm64"
+
+                if system.startswith("musl"):
+                    config = "musl"
+                elif kernel == "w64":
+                    config = "mingw"
+
+                triplet = raw_spec
+
+        if os is None:
+            os, arch, *rest = tokens
+            if rest:
+                assert len(rest) == 1
+                config = rest[0]
+
+        return MachineSpec(os, arch, config, triplet)
+
+    def evolve(self,
+               os: Optional[str] = None,
+               arch: Optional[str] = None,
+               config: Optional[str] = None,
+               triplet: Optional[str] = None) -> MachineSpec:
+        return MachineSpec(
+            os if os is not None else self.os,
+            arch if arch is not None else self.arch,
+            config if config is not None else self.config,
+            triplet if triplet is not None else self.triplet,
+        )
+
+    def default_missing(self, recommended_vscrt: Optional[str] = None) -> MachineSpec:
+        config = self.config
+        if config is None and self.toolchain_is_msvc:
+            if recommended_vscrt is not None:
+                config = recommended_vscrt
+            else:
+                config = "mt"
+        return self.evolve(config=config)
+
+    def maybe_adapt_to_host(self, host_machine: MachineSpec) -> MachineSpec:
+        if self.identifier == host_machine.identifier and host_machine.triplet is not None:
+            return host_machine
+        if self.os == "windows":
+            if self.arch == "x86_64" and host_machine.arch == "x86":
+                return host_machine
+            if self.arch == host_machine.arch:
+                return host_machine
+        return self
+
+    @property
+    def identifier(self) -> str:
+        parts = [self.os, self.arch]
+        if self.config is not None:
+            parts += [self.config]
+        return "-".join(parts)
+
+    @property
+    def os_dash_arch(self) -> str:
+        return f"{self.os}-{self.arch}"
+
+    @property
+    def os_dash_config(self) -> str:
+        parts = [self.os]
+        if self.config is not None:
+            parts += [self.config]
+        return "-".join(parts)
+
+    @property
+    def config_is_optimized(self) -> bool:
+        if self.toolchain_is_msvc:
+            return self.config in {"md", "mt"}
+        return True
+
+    @property
+    def meson_optimization_options(self) -> list[str]:
+        if self.config_is_optimized:
+            optimization = "s"
+            ndebug = "true"
+        else:
+            optimization = "0"
+            ndebug = "false"
+        return [
+            f"-Doptimization={optimization}",
+            f"-Db_ndebug={ndebug}",
+        ]
+
+    @property
+    def executable_suffix(self) -> str:
+        return ".exe" if self.os == "windows" else ""
+
+    @property
+    def msvc_platform(self) -> str:
+        return "x64" if self.arch == "x86_64" else "x86"
+
+    @property
+    def is_apple(self) -> str:
+        return self.os in {"macos", "ios", "watchos", "tvos"}
+
+    @property
+    def system(self) -> str:
+        return "darwin" if self.is_apple else self.os
+
+    @property
+    def subsystem(self) -> str:
+        return self.os_dash_config if self.is_apple else self.os
+
+    @property
+    def kernel(self) -> str:
+        return KERNELS.get(self.os, self.os)
+
+    @property
+    def cpu_family(self) -> str:
+        arch = self.arch
+        return CPU_FAMILIES.get(arch, arch)
+
+    @property
+    def cpu(self) -> str:
+        arch = self.arch
+
+        mappings_to_search = [
+            CPU_TYPES_PER_OS_OVERRIDES.get(self.os, {}),
+            CPU_TYPES,
+        ]
+        for m in mappings_to_search:
+            cpu = m.get(arch, None)
+            if cpu is not None:
+                return cpu
+
+        return arch
+
+    @property
+    def endian(self) -> str:
+        return "big" if self.arch in BIG_ENDIAN_ARCHS else "little"
+
+    @property
+    def pointer_size(self) -> int:
+        arch = self.arch
+        if arch in {"x86_64", "s390x"}:
+            return 8
+        if arch.startswith("arm64") or arch.startswith("mips64"):
+            return 8
+        return 4
+
+    @property
+    def libdatadir(self) -> str:
+        return "libdata" if self.os == "freebsd" else "lib"
+
+    @property
+    def toolchain_is_msvc(self) -> bool:
+        return self.os == "windows" and self.config != "mingw"
+
+    @property
+    def toolchain_can_strip(self) -> bool:
+        return not self.toolchain_is_msvc
+
+    def __eq__(self, other):
+        if isinstance(other, MachineSpec):
+            return other.identifier == self.identifier
+        return False
+
+
+def detect_os() -> str:
+    os = platform.system().lower()
+    if os == "darwin":
+        os = "macos"
+    return os
+
+
+def detect_arch() -> str:
+    arch = platform.machine().lower()
+    return ARCHS.get(arch, arch)
+
+
+ARCHS = {
+    "amd64": "x86_64",
+    "armv7l": "armhf",
+    "aarch64": "arm64",
+}
+
+KERNELS = {
+    "windows": "nt",
+
+    "macos":   "xnu",
+    "ios":     "xnu",
+    "watchos": "xnu",
+    "tvos":    "xnu",
+
+    "qnx":     "nto",
+}
+
+CPU_FAMILIES = {
+    "armbe8":     "arm",
+    "armeabi":    "arm",
+    "armhf":      "arm",
+
+    "arm64":      "aarch64",
+    "arm64e":     "aarch64",
+    "arm64eoabi": "aarch64",
+
+    "mipsel":     "mips",
+    "mips64el":   "mips64",
+}
+
+CPU_TYPES = {
+    "arm":        "armv7",
+    "armbe8":     "armv6",
+    "armhf":      "armv7hf",
+    "armeabi":    "armv7eabi",
+
+    "arm64":      "aarch64",
+    "arm64e":     "aarch64",
+    "arm64eoabi": "aarch64",
+}
+
+CPU_TYPES_PER_OS_OVERRIDES = {
+    "linux": {
+        "arm":        "armv5t",
+        "armbe8":     "armv6t",
+        "armhf":      "armv7a",
+
+        "mips":       "mips1",
+        "mipsel":     "mips1",
+
+        "mips64":     "mips64r2",
+        "mips64el":   "mips64r2",
+    },
+    "android": {
+        "x86":        "i686",
+    },
+    "qnx": {
+        "arm":        "armv6",
+        "armeabi":    "armv7",
+    },
+}
+
+BIG_ENDIAN_ARCHS = {
+    "armbe8",
+    "mips",
+    "mips64",
+    "s390x",
+}
+
+TARGET_TRIPLET_ARCH_PATTERN = re.compile(r"^(i.86|x86_64|arm(v\w+)?|aarch64|mips\w*|s390x)$")

package/releng/meson/meson.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+# Copyright © 2023 Intel Corporation
+
+import sys
+
+# Check python version before importing anything else, we might have an older
+# Python that would error on f-string syntax for example.
+if sys.version_info < (3, 7):
+    print('Meson works correctly only with python 3.7+.')
+    print('You have python {}.'.format(sys.version))
+    print('Please update your environment')
+    sys.exit(1)
+
+from pathlib import Path
+
+# If we're run uninstalled, add the script directory to sys.path to ensure that
+# we always import the correct mesonbuild modules even if PYTHONPATH is mangled
+meson_exe = Path(sys.argv[0]).resolve()
+if (meson_exe.parent / 'mesonbuild').is_dir():
+    sys.path.insert(0, str(meson_exe.parent))
+
+from mesonbuild import mesonmain
+
+if __name__ == '__main__':
+    sys.exit(mesonmain.main())

package/releng/meson/mesonbuild/_pathlib.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2021 The Meson development team
+
+'''
+    This module soly exists to work around a pathlib.resolve bug on
+    certain Windows systems:
+
+    https://github.com/mesonbuild/meson/issues/7295
+    https://bugs.python.org/issue31842
+
+    It should **never** be used directly. Instead, it is automatically
+    used when `import pathlib` is used. This is achieved by messing with
+    `sys.modules['pathlib']` in mesonmain.
+
+    Additionally, the sole purpose of this module is to work around a
+    python bug. This only bugfixes to pathlib functions and classes are
+    allowed here. Finally, this file should be removed once all upstream
+    python bugs are fixed and it is OK to tell our users to "just upgrade
+    python".
+'''
+from __future__ import annotations
+
+import pathlib
+import os
+import platform
+
+__all__ = [
+    'PurePath',
+    'PurePosixPath',
+    'PureWindowsPath',
+    'Path',
+]
+
+PurePath = pathlib.PurePath
+PurePosixPath = pathlib.PurePosixPath
+PureWindowsPath = pathlib.PureWindowsPath
+
+# Only patch on platforms where the bug occurs
+if platform.system().lower() in {'windows'}:
+    # Can not directly inherit from pathlib.Path because the __new__
+    # operator of pathlib.Path() returns a {Posix,Windows}Path object.
+    class Path(type(pathlib.Path())):
+        def resolve(self, strict: bool = False) -> 'Path':
+            '''
+                Work around a resolve bug on certain Windows systems:
+
+                https://github.com/mesonbuild/meson/issues/7295
+                https://bugs.python.org/issue31842
+            '''
+
+            try:
+                return super().resolve(strict=strict)
+            except OSError:
+                return Path(os.path.normpath(self))
+else:
+    Path = pathlib.Path
+    PosixPath = pathlib.PosixPath
+    WindowsPath = pathlib.WindowsPath
+
+    __all__ += [
+        'PosixPath',
+        'WindowsPath',
+    ]

package/releng/meson/mesonbuild/_typing.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2020 The Meson development team
+# Copyright © 2020-2023 Intel Corporation
+
+"""Meson specific typing helpers.
+
+Holds typing helper classes, such as the ImmutableProtocol classes
+"""
+
+__all__ = [
+    'Protocol',
+    'ImmutableListProtocol'
+]
+
+import typing
+
+# We can change this to typing when we require python 3.8
+from typing_extensions import Protocol
+
+
+T = typing.TypeVar('T')
+
+
+class StringProtocol(Protocol):
+    def __str__(self) -> str: ...
+
+class SizedStringProtocol(Protocol, StringProtocol, typing.Sized):
+    pass
+
+class ImmutableListProtocol(Protocol[T]):
+
+    """A protocol used in cases where a list is returned, but should not be
+    mutated.
+
+    This provides all of the methods of a Sequence, as well as copy(). copy()
+    returns a list, which allows mutation as it's a copy and that's (hopefully)
+    safe.
+
+    One particular case this is important is for cached values, since python is
+    a pass-by-reference language.
+    """
+
+    def __iter__(self) -> typing.Iterator[T]: ...
+
+    @typing.overload
+    def __getitem__(self, index: int) -> T: ...
+    @typing.overload
+    def __getitem__(self, index: slice) -> typing.List[T]: ...
+
+    def __contains__(self, item: T) -> bool: ...
+
+    def __reversed__(self) -> typing.Iterator[T]: ...
+
+    def __len__(self) -> int: ...
+
+    def __add__(self, other: typing.List[T]) -> typing.List[T]: ...
+
+    def __eq__(self, other: typing.Any) -> bool: ...
+    def __ne__(self, other: typing.Any) -> bool: ...
+    def __le__(self, other: typing.Any) -> bool: ...
+    def __lt__(self, other: typing.Any) -> bool: ...
+    def __gt__(self, other: typing.Any) -> bool: ...
+    def __ge__(self, other: typing.Any) -> bool: ...
+
+    def count(self, item: T) -> int: ...
+
+    def index(self, item: T) -> int: ...
+
+    def copy(self) -> typing.List[T]: ...