frida 16.2.1 → 16.2.2

package/releng/meson/mesonbuild/cmake/tracetargets.py

@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2021 The Meson development team
+from __future__ import annotations
+
+from .common import cmake_is_debug
+from .. import mlog
+from ..mesonlib import Version
+
+from pathlib import Path
+import re
+import typing as T
+
+if T.TYPE_CHECKING:
+    from .traceparser import CMakeTraceParser
+    from ..environment import Environment
+    from ..compilers import Compiler
+    from ..dependencies import MissingCompiler
+
+# Small duplication of ExtraFramework to parse full
+# framework paths as exposed by CMake
+def _get_framework_latest_version(path: Path) -> str:
+    versions: list[Version] = []
+    for each in path.glob('Versions/*'):
+        # macOS filesystems are usually case-insensitive
+        if each.name.lower() == 'current':
+            continue
+        versions.append(Version(each.name))
+    if len(versions) == 0:
+        # most system frameworks do not have a 'Versions' directory
+        return 'Headers'
+    return 'Versions/{}/Headers'.format(sorted(versions)[-1]._s)
+
+def _get_framework_include_path(path: Path) -> T.Optional[str]:
+    trials = ('Headers', 'Versions/Current/Headers', _get_framework_latest_version(path))
+    for each in trials:
+        trial = path / each
+        if trial.is_dir():
+            return trial.as_posix()
+    return None
+
+class ResolvedTarget:
+    def __init__(self) -> None:
+        self.include_directories: T.List[str] = []
+        self.link_flags:          T.List[str] = []
+        self.public_compile_opts: T.List[str] = []
+        self.libraries:           T.List[str] = []
+
+def resolve_cmake_trace_targets(target_name: str,
+                                trace: 'CMakeTraceParser',
+                                env: 'Environment',
+                                *,
+                                clib_compiler: T.Union['MissingCompiler', 'Compiler'] = None,
+                                not_found_warning: T.Callable[[str], None] = lambda x: None) -> ResolvedTarget:
+    res = ResolvedTarget()
+    targets = [target_name]
+
+    # recognise arguments we should pass directly to the linker
+    reg_is_lib = re.compile(r'^(-l[a-zA-Z0-9_]+|-l?pthread)$')
+    reg_is_maybe_bare_lib = re.compile(r'^[a-zA-Z0-9_]+$')
+
+    is_debug = cmake_is_debug(env)
+
+    processed_targets: T.List[str] = []
+    while len(targets) > 0:
+        curr = targets.pop(0)
+
+        # Skip already processed targets
+        if curr in processed_targets:
+            continue
+
+        if curr not in trace.targets:
+            curr_path = Path(curr)
+            if reg_is_lib.match(curr):
+                res.libraries += [curr]
+            elif curr_path.is_absolute() and curr_path.exists():
+                if any(x.endswith('.framework') for x in curr_path.parts):
+                    # Frameworks detected by CMake are passed as absolute paths
+                    # Split into -F/path/to/ and -framework name
+                    path_to_framework = []
+                    # Try to slice off the `Versions/X/name.tbd`
+                    for x in curr_path.parts:
+                        path_to_framework.append(x)
+                        if x.endswith('.framework'):
+                            break
+                    curr_path = Path(*path_to_framework)
+                    framework_path = curr_path.parent
+                    framework_name = curr_path.stem
+                    res.libraries += [f'-F{framework_path}', '-framework', framework_name]
+                else:
+                    res.libraries += [curr]
+            elif reg_is_maybe_bare_lib.match(curr) and clib_compiler:
+                # CMake library dependencies can be passed as bare library names,
+                # CMake brute-forces a combination of prefix/suffix combinations to find the
+                # right library. Assume any bare argument passed which is not also a CMake
+                # target must be a system library we should try to link against.
+                flib = clib_compiler.find_library(curr, env, [])
+                if flib is not None:
+                    res.libraries += flib
+                else:
+                    not_found_warning(curr)
+            else:
+                not_found_warning(curr)
+            continue
+
+        tgt = trace.targets[curr]
+        cfgs = []
+        cfg = ''
+        mlog.debug(tgt)
+
+        if 'INTERFACE_INCLUDE_DIRECTORIES' in tgt.properties:
+            res.include_directories += [x for x in tgt.properties['INTERFACE_INCLUDE_DIRECTORIES'] if x]
+
+        if 'INTERFACE_LINK_OPTIONS' in tgt.properties:
+            res.link_flags += [x for x in tgt.properties['INTERFACE_LINK_OPTIONS'] if x]
+
+        if 'INTERFACE_COMPILE_DEFINITIONS' in tgt.properties:
+            res.public_compile_opts += ['-D' + re.sub('^-D', '', x) for x in tgt.properties['INTERFACE_COMPILE_DEFINITIONS'] if x]
+
+        if 'INTERFACE_COMPILE_OPTIONS' in tgt.properties:
+            res.public_compile_opts += [x for x in tgt.properties['INTERFACE_COMPILE_OPTIONS'] if x]
+
+        if 'IMPORTED_CONFIGURATIONS' in tgt.properties:
+            cfgs = [x for x in tgt.properties['IMPORTED_CONFIGURATIONS'] if x]
+            cfg = cfgs[0]
+
+        if is_debug:
+            if 'DEBUG' in cfgs:
+                cfg = 'DEBUG'
+            elif 'RELEASE' in cfgs:
+                cfg = 'RELEASE'
+        else:
+            if 'RELEASE' in cfgs:
+                cfg = 'RELEASE'
+
+        if f'IMPORTED_IMPLIB_{cfg}' in tgt.properties:
+            res.libraries += [x for x in tgt.properties[f'IMPORTED_IMPLIB_{cfg}'] if x]
+        elif 'IMPORTED_IMPLIB' in tgt.properties:
+            res.libraries += [x for x in tgt.properties['IMPORTED_IMPLIB'] if x]
+        elif f'IMPORTED_LOCATION_{cfg}' in tgt.properties:
+            res.libraries += [x for x in tgt.properties[f'IMPORTED_LOCATION_{cfg}'] if x]
+        elif 'IMPORTED_LOCATION' in tgt.properties:
+            res.libraries += [x for x in tgt.properties['IMPORTED_LOCATION'] if x]
+
+        if 'LINK_LIBRARIES' in tgt.properties:
+            targets += [x for x in tgt.properties['LINK_LIBRARIES'] if x]
+        if 'INTERFACE_LINK_LIBRARIES' in tgt.properties:
+            targets += [x for x in tgt.properties['INTERFACE_LINK_LIBRARIES'] if x]
+
+        if f'IMPORTED_LINK_DEPENDENT_LIBRARIES_{cfg}' in tgt.properties:
+            targets += [x for x in tgt.properties[f'IMPORTED_LINK_DEPENDENT_LIBRARIES_{cfg}'] if x]
+        elif 'IMPORTED_LINK_DEPENDENT_LIBRARIES' in tgt.properties:
+            targets += [x for x in tgt.properties['IMPORTED_LINK_DEPENDENT_LIBRARIES'] if x]
+
+        processed_targets += [curr]
+
+    # Do not sort flags here -- this breaks
+    # semantics of eg. `-framework CoreAudio`
+    # or `-Lpath/to/root -llibrary`
+    # see eg. #11113
+
+    return res

package/releng/meson/mesonbuild/compilers/__init__.py

@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2017 The Meson development team
+
+# Public symbols for compilers sub-package when using 'from . import compilers'
+__all__ = [
+    'Compiler',
+    'RunResult',
+
+    'all_languages',
+    'base_options',
+    'clib_langs',
+    'clink_langs',
+    'c_suffixes',
+    'cpp_suffixes',
+    'get_base_compile_args',
+    'get_base_link_args',
+    'is_assembly',
+    'is_header',
+    'is_library',
+    'is_llvm_ir',
+    'is_object',
+    'is_source',
+    'is_known_suffix',
+    'lang_suffixes',
+    'LANGUAGES_USING_LDFLAGS',
+    'sort_clink',
+    'SUFFIX_TO_LANG',
+
+    'compiler_from_language',
+    'detect_compiler_for',
+    'detect_static_linker',
+    'detect_c_compiler',
+    'detect_cpp_compiler',
+    'detect_cuda_compiler',
+    'detect_fortran_compiler',
+    'detect_objc_compiler',
+    'detect_objcpp_compiler',
+    'detect_java_compiler',
+    'detect_cs_compiler',
+    'detect_vala_compiler',
+    'detect_rust_compiler',
+    'detect_d_compiler',
+    'detect_swift_compiler',
+]
+
+# Bring symbols from each module into compilers sub-package namespace
+from .compilers import (
+    Compiler,
+    RunResult,
+    all_languages,
+    base_options,
+    clib_langs,
+    clink_langs,
+    c_suffixes,
+    cpp_suffixes,
+    get_base_compile_args,
+    get_base_link_args,
+    is_header,
+    is_source,
+    is_assembly,
+    is_llvm_ir,
+    is_object,
+    is_library,
+    is_known_suffix,
+    lang_suffixes,
+    LANGUAGES_USING_LDFLAGS,
+    sort_clink,
+    SUFFIX_TO_LANG,
+)
+from .detect import (
+    compiler_from_language,
+    detect_compiler_for,
+    detect_static_linker,
+    detect_c_compiler,
+    detect_cpp_compiler,
+    detect_cuda_compiler,
+    detect_objc_compiler,
+    detect_objcpp_compiler,
+    detect_fortran_compiler,
+    detect_java_compiler,
+    detect_cs_compiler,
+    detect_vala_compiler,
+    detect_rust_compiler,
+    detect_d_compiler,
+    detect_swift_compiler,
+)

package/releng/meson/mesonbuild/compilers/asm.py

@@ -0,0 +1,307 @@
+from __future__ import annotations
+
+import os
+import typing as T
+
+from ..mesonlib import EnvironmentException, OptionKey, get_meson_command
+from .compilers import Compiler
+from .mixins.metrowerks import MetrowerksCompiler, mwasmarm_instruction_set_args, mwasmeppc_instruction_set_args
+
+if T.TYPE_CHECKING:
+    from ..environment import Environment
+    from ..linkers.linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
+    from ..envconfig import MachineInfo
+
+nasm_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': ['-O0'],
+    'g': ['-O0'],
+    '1': ['-O1'],
+    '2': ['-Ox'],
+    '3': ['-Ox'],
+    's': ['-Ox'],
+}
+
+
+class NasmCompiler(Compiler):
+    language = 'nasm'
+    id = 'nasm'
+
+    # https://learn.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features
+    crt_args: T.Dict[str, T.List[str]] = {
+        'none': [],
+        'md': ['/DEFAULTLIB:ucrt.lib', '/DEFAULTLIB:vcruntime.lib', '/DEFAULTLIB:msvcrt.lib'],
+        'mdd': ['/DEFAULTLIB:ucrtd.lib', '/DEFAULTLIB:vcruntimed.lib', '/DEFAULTLIB:msvcrtd.lib'],
+        'mt': ['/DEFAULTLIB:libucrt.lib', '/DEFAULTLIB:libvcruntime.lib', '/DEFAULTLIB:libcmt.lib'],
+        'mtd': ['/DEFAULTLIB:libucrtd.lib', '/DEFAULTLIB:libvcruntimed.lib', '/DEFAULTLIB:libcmtd.lib'],
+    }
+
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
+                 for_machine: 'MachineChoice', info: 'MachineInfo',
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None, is_cross: bool = False):
+        super().__init__(ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        if 'link' in self.linker.id:
+            self.base_options.add(OptionKey('b_vscrt'))
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.List[str]:
+        cpu = '64' if self.info.is_64_bit else '32'
+        if self.info.is_windows() or self.info.is_cygwin():
+            plat = 'win'
+            define = f'WIN{cpu}'
+        elif self.info.is_darwin():
+            plat = 'macho'
+            define = 'MACHO'
+        else:
+            plat = 'elf'
+            define = 'ELF'
+        args = ['-f', f'{plat}{cpu}', f'-D{define}']
+        if self.info.is_64_bit:
+            args.append('-D__x86_64__')
+        return args
+
+    def get_werror_args(self) -> T.List[str]:
+        return ['-Werror']
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['-o', outputname]
+
+    def unix_args_to_native(self, args: T.List[str]) -> T.List[str]:
+        outargs: T.List[str] = []
+        for arg in args:
+            if arg == '-pthread':
+                continue
+            outargs.append(arg)
+        return outargs
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return nasm_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        if is_debug:
+            if self.info.is_windows():
+                return []
+            return ['-g', '-F', 'dwarf']
+        return []
+
+    def get_depfile_suffix(self) -> str:
+        return 'd'
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['-MD', outfile, '-MQ', outtarget]
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'x86', 'x86_64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_pic_args(self) -> T.List[str]:
+        return []
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        if not path:
+            path = '.'
+        return ['-I' + path]
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+                                               build_dir: str) -> T.List[str]:
+        for idx, i in enumerate(parameter_list):
+            if i[:2] == '-I':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        return []
+
+    # Linking ASM-only objects into an executable or DLL
+    # require this, otherwise it'll fail to find
+    # _WinMain or _DllMainCRTStartup.
+    def get_crt_link_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        if not self.info.is_windows():
+            return []
+        return self.crt_args[self.get_crt_val(crt_val, buildtype)]
+
+class YasmCompiler(NasmCompiler):
+    id = 'yasm'
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        # Yasm is incompatible with Nasm optimization flags.
+        return []
+
+    def get_exelist(self, ccache: bool = True) -> T.List[str]:
+        # Wrap yasm executable with an internal script that will write depfile.
+        exelist = super().get_exelist(ccache)
+        return get_meson_command() + ['--internal', 'yasm'] + exelist
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        if is_debug:
+            if self.info.is_windows():
+                return ['-g', 'null']
+            return ['-g', 'dwarf2']
+        return []
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['--depfile', outfile]
+
+# https://learn.microsoft.com/en-us/cpp/assembler/masm/ml-and-ml64-command-line-reference
+class MasmCompiler(Compiler):
+    language = 'masm'
+    id = 'ml'
+
+    def get_compile_only_args(self) -> T.List[str]:
+        return ['/c']
+
+    def get_argument_syntax(self) -> str:
+        return 'msvc'
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.List[str]:
+        return ['/nologo']
+
+    def get_werror_args(self) -> T.List[str]:
+        return ['/WX']
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['/Fo', outputname]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return []
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        if is_debug:
+            return ['/Zi']
+        return []
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'x86', 'x86_64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_pic_args(self) -> T.List[str]:
+        return []
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        if not path:
+            path = '.'
+        return ['-I' + path]
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+                                               build_dir: str) -> T.List[str]:
+        for idx, i in enumerate(parameter_list):
+            if i[:2] == '-I' or i[:2] == '/I':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        return []
+
+    def depfile_for_object(self, objfile: str) -> T.Optional[str]:
+        return None
+
+
+# https://learn.microsoft.com/en-us/cpp/assembler/arm/arm-assembler-command-line-reference
+class MasmARMCompiler(Compiler):
+    language = 'masm'
+    id = 'armasm'
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.List[str]:
+        return ['-nologo']
+
+    def get_werror_args(self) -> T.List[str]:
+        return []
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['-o', outputname]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return []
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        if is_debug:
+            return ['-g']
+        return []
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'arm', 'aarch64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_pic_args(self) -> T.List[str]:
+        return []
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        if not path:
+            path = '.'
+        return ['-i' + path]
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+                                               build_dir: str) -> T.List[str]:
+        for idx, i in enumerate(parameter_list):
+            if i[:2] == '-I':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        return []
+
+    def depfile_for_object(self, objfile: str) -> T.Optional[str]:
+        return None
+
+
+class MetrowerksAsmCompiler(MetrowerksCompiler, Compiler):
+    language = 'nasm'
+
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
+                 for_machine: 'MachineChoice', info: 'MachineInfo',
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None, is_cross: bool = False):
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        MetrowerksCompiler.__init__(self)
+
+        self.warn_args: T.Dict[str, T.List[str]] = {
+            '0': [],
+            '1': [],
+            '2': [],
+            '3': [],
+            'everything': []}
+        self.can_compile_suffixes.add('s')
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        return []
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return []
+
+    def get_pic_args(self) -> T.List[str]:
+        return []
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+
+class MetrowerksAsmCompilerARM(MetrowerksAsmCompiler):
+    id = 'mwasmarm'
+
+    def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
+        return mwasmarm_instruction_set_args.get(instruction_set, None)
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'arm'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+
+class MetrowerksAsmCompilerEmbeddedPowerPC(MetrowerksAsmCompiler):
+    id = 'mwasmeppc'
+
+    def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
+        return mwasmeppc_instruction_set_args.get(instruction_set, None)
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'ppc'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')