frida 16.2.1 → 16.2.3

package/releng/meson/mesonbuild/compilers/mixins/arm.py

@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2020 Meson development team
+
+from __future__ import annotations
+
+"""Representations specific to the arm family of compilers."""
+
+import os
+import typing as T
+
+from ... import mesonlib
+from ...linkers.linkers import ArmClangDynamicLinker
+from ...mesonlib import OptionKey
+from ..compilers import clike_debug_args
+from .clang import clang_color_args
+
+if T.TYPE_CHECKING:
+    from ...environment import Environment
+    from ...compilers.compilers import Compiler
+else:
+    # This is a bit clever, for mypy we pretend that these mixins descend from
+    # Compiler, so we get all of the methods and attributes defined for us, but
+    # for runtime we make them descend from object (which all classes normally
+    # do). This gives up DRYer type checking, with no runtime impact
+    Compiler = object
+
+arm_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': ['-O0'],
+    'g': ['-g'],
+    '1': ['-O1'],
+    '2': [], # Compiler defaults to -O2
+    '3': ['-O3', '-Otime'],
+    's': ['-O3'], # Compiler defaults to -Ospace
+}
+
+armclang_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': [], # Compiler defaults to -O0
+    'g': ['-g'],
+    '1': ['-O1'],
+    '2': ['-O2'],
+    '3': ['-O3'],
+    's': ['-Oz']
+}
+
+
+class ArmCompiler(Compiler):
+
+    """Functionality that is common to all ARM family compilers."""
+
+    id = 'arm'
+
+    def __init__(self) -> None:
+        if not self.is_cross:
+            raise mesonlib.EnvironmentException('armcc supports only cross-compilation.')
+        default_warn_args: T.List[str] = []
+        self.warn_args = {'0': [],
+                          '1': default_warn_args,
+                          '2': default_warn_args + [],
+                          '3': default_warn_args + [],
+                          'everything': default_warn_args + []}
+        # Assembly
+        self.can_compile_suffixes.add('s')
+        self.can_compile_suffixes.add('sx')
+
+    def get_pic_args(self) -> T.List[str]:
+        # FIXME: Add /ropi, /rwpi, /fpic etc. qualifiers to --apcs
+        return []
+
+    # Override CCompiler.get_always_args
+    def get_always_args(self) -> T.List[str]:
+        return []
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['--depend_target', outtarget, '--depend', outfile, '--depend_single_line']
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        # FIXME: Add required arguments
+        # NOTE from armcc user guide:
+        # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
+        # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
+        # PCH files."
+        return []
+
+    def get_pch_suffix(self) -> str:
+        # NOTE from armcc user guide:
+        # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
+        # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
+        # PCH files."
+        return 'pch'
+
+    def thread_flags(self, env: 'Environment') -> T.List[str]:
+        return []
+
+    def get_coverage_args(self) -> T.List[str]:
+        return []
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return arm_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return clike_debug_args[is_debug]
+
+    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] == '-L':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+
+        return parameter_list
+
+
+class ArmclangCompiler(Compiler):
+    '''
+    This is the Keil armclang.
+    '''
+
+    id = 'armclang'
+
+    def __init__(self) -> None:
+        if not self.is_cross:
+            raise mesonlib.EnvironmentException('armclang supports only cross-compilation.')
+        # Check whether 'armlink' is available in path
+        if not isinstance(self.linker, ArmClangDynamicLinker):
+            raise mesonlib.EnvironmentException(f'Unsupported Linker {self.linker.exelist}, must be armlink')
+        if not mesonlib.version_compare(self.version, '==' + self.linker.version):
+            raise mesonlib.EnvironmentException('armlink version does not match with compiler version')
+        self.base_options = {
+            OptionKey(o) for o in
+            ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
+             'b_ndebug', 'b_staticpic', 'b_colorout']}
+        # Assembly
+        self.can_compile_suffixes.add('s')
+        self.can_compile_suffixes.add('sx')
+
+    def get_pic_args(self) -> T.List[str]:
+        # PIC support is not enabled by default for ARM,
+        # if users want to use it, they need to add the required arguments explicitly
+        return []
+
+    def get_colorout_args(self, colortype: str) -> T.List[str]:
+        return clang_color_args[colortype][:]
+
+    def get_pch_suffix(self) -> str:
+        return 'gch'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
+        # This flag is internal to Clang (or at least not documented on the man page)
+        # so it might change semantics at any time.
+        return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['-MD', '-MT', outtarget, '-MF', outfile]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return armclang_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return clike_debug_args[is_debug]
+
+    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] == '-L':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+
+        return parameter_list

package/releng/meson/mesonbuild/compilers/mixins/ccrx.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2019 The Meson development team
+
+from __future__ import annotations
+
+"""Representations specific to the Renesas CC-RX compiler family."""
+
+import os
+import typing as T
+
+from ...mesonlib import EnvironmentException
+
+if T.TYPE_CHECKING:
+    from ...envconfig import MachineInfo
+    from ...environment import Environment
+    from ...compilers.compilers import Compiler
+else:
+    # This is a bit clever, for mypy we pretend that these mixins descend from
+    # Compiler, so we get all of the methods and attributes defined for us, but
+    # for runtime we make them descend from object (which all classes normally
+    # do). This gives up DRYer type checking, with no runtime impact
+    Compiler = object
+
+ccrx_optimization_args: T.Dict[str, T.List[str]] = {
+    '0': ['-optimize=0'],
+    'g': ['-optimize=0'],
+    '1': ['-optimize=1'],
+    '2': ['-optimize=2'],
+    '3': ['-optimize=max'],
+    's': ['-optimize=2', '-size']
+}
+
+ccrx_debug_args: T.Dict[bool, T.List[str]] = {
+    False: [],
+    True: ['-debug']
+}
+
+
+class CcrxCompiler(Compiler):
+
+    if T.TYPE_CHECKING:
+        is_cross = True
+        can_compile_suffixes: T.Set[str] = set()
+
+    id = 'ccrx'
+
+    def __init__(self) -> None:
+        if not self.is_cross:
+            raise EnvironmentException('ccrx supports only cross-compilation.')
+        # Assembly
+        self.can_compile_suffixes.add('src')
+        default_warn_args: T.List[str] = []
+        self.warn_args: T.Dict[str, T.List[str]] = {
+            '0': [],
+            '1': default_warn_args,
+            '2': default_warn_args + [],
+            '3': default_warn_args + [],
+            'everything': default_warn_args + []}
+
+    def get_pic_args(self) -> T.List[str]:
+        # PIC support is not enabled by default for CCRX,
+        # if users want to use it, they need to add the required arguments explicitly
+        return []
+
+    def get_pch_suffix(self) -> str:
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        return []
+
+    def thread_flags(self, env: 'Environment') -> T.List[str]:
+        return []
+
+    def get_coverage_args(self) -> T.List[str]:
+        return []
+
+    def get_no_stdinc_args(self) -> T.List[str]:
+        return []
+
+    def get_no_stdlib_link_args(self) -> T.List[str]:
+        return []
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return ccrx_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return ccrx_debug_args[is_debug]
+
+    @classmethod
+    def _unix_args_to_native(cls, args: T.List[str], info: MachineInfo) -> T.List[str]:
+        result: T.List[str] = []
+        for i in args:
+            if i.startswith('-D'):
+                i = '-define=' + i[2:]
+            if i.startswith('-I'):
+                i = '-include=' + i[2:]
+            if i.startswith('-Wl,-rpath='):
+                continue
+            elif i == '--print-search-dirs':
+                continue
+            elif i.startswith('-L'):
+                continue
+            elif not i.startswith('-lib=') and i.endswith(('.a', '.lib')):
+                i = '-lib=' + i
+            result.append(i)
+        return result
+
+    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[:9] == '-include=':
+                parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
+
+        return parameter_list

package/releng/meson/mesonbuild/compilers/mixins/clang.py

@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019-2022 The meson development team
+
+from __future__ import annotations
+
+"""Abstractions for the LLVM/Clang compiler family."""
+
+import os
+import shutil
+import typing as T
+
+from ... import mesonlib
+from ...linkers.linkers import AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker, \
+    MoldDynamicLinker
+from ...mesonlib import OptionKey
+from ..compilers import CompileCheckMode
+from .gnu import GnuLikeCompiler
+
+if T.TYPE_CHECKING:
+    from ...environment import Environment
+    from ...dependencies import Dependency  # noqa: F401
+
+clang_color_args: T.Dict[str, T.List[str]] = {
+    'auto': ['-fdiagnostics-color=auto'],
+    'always': ['-fdiagnostics-color=always'],
+    'never': ['-fdiagnostics-color=never'],
+}
+
+clang_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': ['-O0'],
+    'g': ['-Og'],
+    '1': ['-O1'],
+    '2': ['-O2'],
+    '3': ['-O3'],
+    's': ['-Oz'],
+}
+
+class ClangCompiler(GnuLikeCompiler):
+
+    id = 'clang'
+
+    def __init__(self, defines: T.Optional[T.Dict[str, str]]):
+        super().__init__()
+        self.defines = defines or {}
+        self.base_options.update(
+            {OptionKey('b_colorout'), OptionKey('b_lto_threads'), OptionKey('b_lto_mode'), OptionKey('b_thinlto_cache'),
+             OptionKey('b_thinlto_cache_dir')})
+
+        # TODO: this really should be part of the linker base_options, but
+        # linkers don't have base_options.
+        if isinstance(self.linker, AppleDynamicLinker):
+            self.base_options.add(OptionKey('b_bitcode'))
+        # All Clang backends can also do LLVM IR
+        self.can_compile_suffixes.add('ll')
+
+    def get_colorout_args(self, colortype: str) -> T.List[str]:
+        return clang_color_args[colortype][:]
+
+    def has_builtin_define(self, define: str) -> bool:
+        return define in self.defines
+
+    def get_builtin_define(self, define: str) -> T.Optional[str]:
+        return self.defines.get(define)
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return clang_optimization_args[optimization_level]
+
+    def get_pch_suffix(self) -> str:
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
+        # This flag is internal to Clang (or at least not documented on the man page)
+        # so it might change semantics at any time.
+        return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
+
+    def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+        # Clang is different than GCC, it will return True when a symbol isn't
+        # defined in a header. Specifically this seems to have something to do
+        # with functions that may be in a header on some systems, but not all of
+        # them. `strlcat` specifically with can trigger this.
+        myargs: T.List[str] = ['-Werror=implicit-function-declaration']
+        if mode is CompileCheckMode.COMPILE:
+            myargs.extend(['-Werror=unknown-warning-option', '-Werror=unused-command-line-argument'])
+            if mesonlib.version_compare(self.version, '>=3.6.0'):
+                myargs.append('-Werror=ignored-optimization-argument')
+        return super().get_compiler_check_args(mode) + myargs
+
+    def has_function(self, funcname: str, prefix: str, env: 'Environment', *,
+                     extra_args: T.Optional[T.List[str]] = None,
+                     dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+        if extra_args is None:
+            extra_args = []
+        # Starting with XCode 8, we need to pass this to force linker
+        # visibility to obey OS X/iOS/tvOS minimum version targets with
+        # -mmacosx-version-min, -miphoneos-version-min, -mtvos-version-min etc.
+        # https://github.com/Homebrew/homebrew-core/issues/3727
+        # TODO: this really should be communicated by the linker
+        if isinstance(self.linker, AppleDynamicLinker) and mesonlib.version_compare(self.version, '>=8.0'):
+            extra_args.append('-Wl,-no_weak_imports')
+        return super().has_function(funcname, prefix, env, extra_args=extra_args,
+                                    dependencies=dependencies)
+
+    def openmp_flags(self) -> T.List[str]:
+        if mesonlib.version_compare(self.version, '>=3.8.0'):
+            return ['-fopenmp']
+        elif mesonlib.version_compare(self.version, '>=3.7.0'):
+            return ['-fopenmp=libomp']
+        else:
+            # Shouldn't work, but it'll be checked explicitly in the OpenMP dependency.
+            return []
+
+    @classmethod
+    def use_linker_args(cls, linker: str, version: str) -> T.List[str]:
+        # Clang additionally can use a linker specified as a path, which GCC
+        # (and other gcc-like compilers) cannot. This is because clang (being
+        # llvm based) is retargetable, while GCC is not.
+        #
+
+        # qcld: Qualcomm Snapdragon linker, based on LLVM
+        if linker == 'qcld':
+            return ['-fuse-ld=qcld']
+        if linker == 'mold':
+            return ['-fuse-ld=mold']
+
+        if shutil.which(linker):
+            if not shutil.which(linker):
+                raise mesonlib.MesonException(
+                    f'Cannot find linker {linker}.')
+            return [f'-fuse-ld={linker}']
+        return super().use_linker_args(linker, version)
+
+    def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+        # Clang only warns about unknown or ignored attributes, so force an
+        # error.
+        return ['-Werror=attributes']
+
+    def get_coverage_link_args(self) -> T.List[str]:
+        return ['--coverage']
+
+    def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]:
+        args: T.List[str] = []
+        if mode == 'thin':
+            # ThinLTO requires the use of gold, lld, ld64, lld-link or mold 1.1+
+            if isinstance(self.linker, (MoldDynamicLinker)):
+                # https://github.com/rui314/mold/commit/46995bcfc3e3113133620bf16445c5f13cd76a18
+                if not mesonlib.version_compare(self.linker.version, '>=1.1'):
+                    raise mesonlib.MesonException("LLVM's ThinLTO requires mold 1.1+")
+            elif not isinstance(self.linker, (AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker)):
+                raise mesonlib.MesonException(f"LLVM's ThinLTO only works with gold, lld, lld-link, ld64 or mold, not {self.linker.id}")
+            args.append(f'-flto={mode}')
+        else:
+            assert mode == 'default', 'someone forgot to wire something up'
+            args.extend(super().get_lto_compile_args(threads=threads))
+        return args
+
+    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default',
+                          thinlto_cache_dir: T.Optional[str] = None) -> T.List[str]:
+        args = self.get_lto_compile_args(threads=threads, mode=mode)
+        if mode == 'thin' and thinlto_cache_dir is not None:
+            # We check for ThinLTO linker support above in get_lto_compile_args, and all of them support
+            # get_thinlto_cache_args as well
+            args.extend(self.linker.get_thinlto_cache_args(thinlto_cache_dir))
+        # In clang -flto-jobs=0 means auto, and is the default if unspecified, just like in meson
+        if threads > 0:
+            if not mesonlib.version_compare(self.version, '>=4.0.0'):
+                raise mesonlib.MesonException('clang support for LTO threads requires clang >=4.0')
+            args.append(f'-flto-jobs={threads}')
+        return args