frida 16.2.0 → 16.2.2

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

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+
+from pathlib import PurePath
+
+def destdir_join(d1: str, d2: str) -> str:
+    if not d1:
+        return d2
+    # c:\destdir + c:\prefix must produce c:\destdir\prefix
+    return str(PurePath(d1, *PurePath(d2).parts[1:]))

package/releng/meson/mesonbuild/scripts/clangformat.py

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2018 The Meson development team
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from .run_tool import run_tool
+from ..environment import detect_clangformat
+from ..mesonlib import version_compare
+from ..programs import ExternalProgram
+import typing as T
+
+def run_clang_format(fname: Path, exelist: T.List[str], check: bool, cformat_ver: T.Optional[str]) -> subprocess.CompletedProcess:
+    clangformat_10 = False
+    if check and cformat_ver:
+        if version_compare(cformat_ver, '>=10'):
+            clangformat_10 = True
+            exelist = exelist + ['--dry-run', '--Werror']
+        else:
+            original = fname.read_bytes()
+    before = fname.stat().st_mtime
+    ret = subprocess.run(exelist + ['-style=file', '-i', str(fname)])
+    after = fname.stat().st_mtime
+    if before != after:
+        print('File reformatted: ', fname)
+        if check and not clangformat_10:
+            # Restore the original if only checking.
+            fname.write_bytes(original)
+            ret.returncode = 1
+    return ret
+
+def run(args: T.List[str]) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--check', action='store_true')
+    parser.add_argument('sourcedir')
+    parser.add_argument('builddir')
+    options = parser.parse_args(args)
+
+    srcdir = Path(options.sourcedir)
+    builddir = Path(options.builddir)
+
+    exelist = detect_clangformat()
+    if not exelist:
+        print('Could not execute clang-format "%s"' % ' '.join(exelist))
+        return 1
+
+    if options.check:
+        cformat_ver = ExternalProgram('clang-format', exelist, silent=True).get_version()
+    else:
+        cformat_ver = None
+
+    return run_tool('clang-format', srcdir, builddir, run_clang_format, exelist, options.check, cformat_ver)

package/releng/meson/mesonbuild/scripts/clangtidy.py

@@ -0,0 +1,30 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from .run_tool import run_tool
+import typing as T
+
+def run_clang_tidy(fname: Path, builddir: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(['clang-tidy', '-p', str(builddir), str(fname)])
+
+def run_clang_tidy_fix(fname: Path, builddir: Path) -> subprocess.CompletedProcess:
+    return subprocess.run(['run-clang-tidy', '-fix', '-format', '-quiet', '-p', str(builddir), str(fname)])
+
+def run(args: T.List[str]) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--fix', action='store_true')
+    parser.add_argument('sourcedir')
+    parser.add_argument('builddir')
+    options = parser.parse_args(args)
+
+    srcdir = Path(options.sourcedir)
+    builddir = Path(options.builddir)
+
+    run_func = run_clang_tidy_fix if options.fix else run_clang_tidy
+    return run_tool('clang-tidy', srcdir, builddir, run_func, builddir)

package/releng/meson/mesonbuild/scripts/cleantrees.py

@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2016 The Meson development team
+
+from __future__ import annotations
+
+import os
+import sys
+import shutil
+import pickle
+import typing as T
+
+def rmtrees(build_dir: str, trees: T.List[str]) -> None:
+    for t in trees:
+        # Never delete trees outside of the builddir
+        if os.path.isabs(t):
+            print(f'Cannot delete dir with absolute path {t!r}')
+            continue
+        bt = os.path.join(build_dir, t)
+        # Skip if it doesn't exist, or if it is not a directory
+        if os.path.isdir(bt):
+            shutil.rmtree(bt, ignore_errors=True)
+
+def run(args: T.List[str]) -> int:
+    if len(args) != 1:
+        print('Cleaner script for Meson. Do not run on your own please.')
+        print('cleantrees.py <data-file>')
+        return 1
+    with open(args[0], 'rb') as f:
+        data = pickle.load(f)
+    rmtrees(data.build_dir, data.trees)
+    # Never fail cleaning
+    return 0
+
+if __name__ == '__main__':
+    run(sys.argv[1:])

package/releng/meson/mesonbuild/scripts/cmake_run_ctgt.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import subprocess
+import shutil
+import sys
+from pathlib import Path
+import typing as T
+
+def run(argsv: T.List[str]) -> int:
+    commands: T.List[T.List[str]] = [[]]
+    SEPARATOR = ';;;'
+
+    # Generate CMD parameters
+    parser = argparse.ArgumentParser(description='Wrapper for add_custom_command')
+    parser.add_argument('-d', '--directory', type=str, metavar='D', required=True, help='Working directory to cwd to')
+    parser.add_argument('-o', '--outputs', nargs='+', metavar='O', required=True, help='Expected output files')
+    parser.add_argument('-O', '--original-outputs', nargs='*', metavar='O', default=[], help='Output files expected by CMake')
+    parser.add_argument('commands', nargs=argparse.REMAINDER, help=f'A "{SEPARATOR}" separated list of commands')
+
+    # Parse
+    args = parser.parse_args(argsv)
+    directory = Path(args.directory)
+
+    dummy_target = None
+    if len(args.outputs) == 1 and len(args.original_outputs) == 0:
+        dummy_target = Path(args.outputs[0])
+    elif len(args.outputs) != len(args.original_outputs):
+        print('Length of output list and original output list differ')
+        return 1
+
+    for i in args.commands:
+        if i == SEPARATOR:
+            commands += [[]]
+            continue
+
+        i = i.replace('"', '')  # Remove leftover quotes
+        commands[-1] += [i]
+
+    # Execute
+    for i in commands:
+        # Skip empty lists
+        if not i:
+            continue
+
+        cmd = []
+        stdout = None
+        stderr = None
+        capture_file = ''
+
+        for j in i:
+            if j in {'>', '>>'}:
+                stdout = subprocess.PIPE
+                continue
+            elif j in {'&>', '&>>'}:
+                stdout = subprocess.PIPE
+                stderr = subprocess.STDOUT
+                continue
+
+            if stdout is not None or stderr is not None:
+                capture_file += j
+            else:
+                cmd += [j]
+
+        try:
+            directory.mkdir(parents=True, exist_ok=True)
+
+            res = subprocess.run(cmd, stdout=stdout, stderr=stderr, cwd=str(directory), check=True)
+            if capture_file:
+                out_file = directory / capture_file
+                out_file.write_bytes(res.stdout)
+        except subprocess.CalledProcessError:
+            return 1
+
+    if dummy_target:
+        dummy_target.touch()
+        return 0
+
+    # Copy outputs
+    zipped_outputs = zip([Path(x) for x in args.outputs], [Path(x) for x in args.original_outputs])
+    for expected, generated in zipped_outputs:
+        do_copy = False
+        if not expected.exists():
+            if not generated.exists():
+                print('Unable to find generated file. This can cause the build to fail:')
+                print(generated)
+                do_copy = False
+            else:
+                do_copy = True
+        elif generated.exists():
+            if generated.stat().st_mtime > expected.stat().st_mtime:
+                do_copy = True
+
+        if do_copy:
+            if expected.exists():
+                expected.unlink()
+            shutil.copyfile(str(generated), str(expected))
+
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(run(sys.argv[1:]))

package/releng/meson/mesonbuild/scripts/cmd_or_ps.ps1

@@ -0,0 +1,17 @@
+# Copied from GStreamer project
+# Author: Seungha Yang <seungha.yang@navercorp.com>
+#         Xavier Claessens <xclaesse@gmail.com>
+
+$i=1
+$ppid=$PID
+do {
+  $ppid=(Get-CimInstance Win32_Process -Filter "ProcessId=$ppid").parentprocessid
+  $pname=(Get-Process -id $ppid).Name
+  if($pname -eq "cmd" -Or $pname -eq "powershell" -Or $pname -eq "pwsh") {
+    Write-Host ("{0}.exe" -f $pname)
+    Break
+  }
+  # not found yet, find grand parent
+  # 10 times iteration seems to be sufficient
+  $i++
+} while ($i -lt 10)

package/releng/meson/mesonbuild/scripts/copy.py

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2021-2023 Intel Corporation
+from __future__ import annotations
+
+"""Helper script to copy files at build time.
+
+This is easier than trying to detect whether to use copy, cp, or something else.
+"""
+
+import shutil
+import typing as T
+
+
+def run(args: T.List[str]) -> int:
+    try:
+        shutil.copy2(args[0], args[1])
+    except Exception:
+        return 1
+    return 0

package/releng/meson/mesonbuild/scripts/coverage.py

@@ -0,0 +1,214 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2017 The Meson development team
+
+from __future__ import annotations
+
+from mesonbuild import environment, mesonlib
+
+import argparse, re, sys, os, subprocess, pathlib, stat
+import typing as T
+
+def coverage(outputs: T.List[str], source_root: str, subproject_root: str, build_root: str, log_dir: str, use_llvm_cov: bool,
+             gcovr_exe: str, llvm_cov_exe: str) -> int:
+    outfiles = []
+    exitcode = 0
+
+    if gcovr_exe == '':
+        gcovr_exe = None
+    else:
+        gcovr_exe, gcovr_version = environment.detect_gcovr(gcovr_exe)
+    if llvm_cov_exe == '' or not mesonlib.exe_exists([llvm_cov_exe, '--version']):
+        llvm_cov_exe = None
+
+    lcov_exe, lcov_version, genhtml_exe = environment.detect_lcov_genhtml()
+
+    # load config files for tools if available in the source tree
+    # - lcov requires manually specifying a per-project config
+    # - gcovr picks up the per-project config, and also supports filtering files
+    #   so don't exclude subprojects ourselves, if the project has a config,
+    #   because they either don't want that, or should set it themselves
+    lcovrc = os.path.join(source_root, '.lcovrc')
+    if os.path.exists(lcovrc):
+        lcov_config = ['--config-file', lcovrc]
+    else:
+        lcov_config = []
+
+    if lcov_exe and mesonlib.version_compare(lcov_version, '>=2.0'):
+        lcov_exe_rc_branch_coverage = ['--rc', 'branch_coverage=1']
+    else:
+        lcov_exe_rc_branch_coverage = ['--rc', 'lcov_branch_coverage=1']
+
+    gcovr_config = ['-e', re.escape(subproject_root)]
+
+    # gcovr >= 4.2 requires a different syntax for out of source builds
+    if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
+        gcovr_base_cmd = [gcovr_exe, '-r', source_root, build_root]
+        # it also started supporting the config file
+        if os.path.exists(os.path.join(source_root, 'gcovr.cfg')):
+            gcovr_config = []
+    else:
+        gcovr_base_cmd = [gcovr_exe, '-r', build_root]
+
+    if use_llvm_cov:
+        gcov_exe_args = ['--gcov-executable', llvm_cov_exe + ' gcov']
+    else:
+        gcov_exe_args = []
+
+    if not outputs or 'xml' in outputs:
+        if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
+                                  ['-x',
+                                   '-o', os.path.join(log_dir, 'coverage.xml')
+                                   ] + gcov_exe_args)
+            outfiles.append(('Xml', pathlib.Path(log_dir, 'coverage.xml')))
+        elif outputs:
+            print('gcovr >= 3.3 needed to generate Xml coverage report')
+            exitcode = 1
+
+    if not outputs or 'sonarqube' in outputs:
+        if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
+                                  ['--sonarqube',
+                                   '-o', os.path.join(log_dir, 'sonarqube.xml'),
+                                   ] + gcov_exe_args)
+            outfiles.append(('Sonarqube', pathlib.Path(log_dir, 'sonarqube.xml')))
+        elif outputs:
+            print('gcovr >= 4.2 needed to generate Xml coverage report')
+            exitcode = 1
+
+    if not outputs or 'text' in outputs:
+        if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
+                                  ['-o', os.path.join(log_dir, 'coverage.txt')] +
+                                  gcov_exe_args)
+            outfiles.append(('Text', pathlib.Path(log_dir, 'coverage.txt')))
+        elif outputs:
+            print('gcovr >= 3.3 needed to generate text coverage report')
+            exitcode = 1
+
+    if not outputs or 'html' in outputs:
+        if lcov_exe and genhtml_exe:
+            htmloutdir = os.path.join(log_dir, 'coveragereport')
+            covinfo = os.path.join(log_dir, 'coverage.info')
+            initial_tracefile = covinfo + '.initial'
+            run_tracefile = covinfo + '.run'
+            raw_tracefile = covinfo + '.raw'
+            lcov_subpoject_exclude = []
+            if os.path.exists(subproject_root):
+                lcov_subpoject_exclude.append(os.path.join(subproject_root, '*'))
+            if use_llvm_cov:
+                # Create a shim to allow using llvm-cov as a gcov tool.
+                if mesonlib.is_windows():
+                    llvm_cov_shim_path = os.path.join(log_dir, 'llvm-cov.bat')
+                    with open(llvm_cov_shim_path, 'w', encoding='utf-8') as llvm_cov_bat:
+                        llvm_cov_bat.write(f'@"{llvm_cov_exe}" gcov %*')
+                else:
+                    llvm_cov_shim_path = os.path.join(log_dir, 'llvm-cov.sh')
+                    with open(llvm_cov_shim_path, 'w', encoding='utf-8') as llvm_cov_sh:
+                        llvm_cov_sh.write(f'#!/usr/bin/env sh\nexec "{llvm_cov_exe}" gcov $@')
+                    os.chmod(llvm_cov_shim_path, os.stat(llvm_cov_shim_path).st_mode | stat.S_IEXEC)
+                gcov_tool_args = ['--gcov-tool', llvm_cov_shim_path]
+            else:
+                gcov_tool_args = []
+            subprocess.check_call([lcov_exe,
+                                   '--directory', build_root,
+                                   '--capture',
+                                   '--initial',
+                                   '--output-file',
+                                   initial_tracefile] +
+                                  lcov_config +
+                                  gcov_tool_args)
+            subprocess.check_call([lcov_exe,
+                                   '--directory', build_root,
+                                   '--capture',
+                                   '--output-file', run_tracefile,
+                                   '--no-checksum',
+                                   *lcov_exe_rc_branch_coverage] +
+                                  lcov_config +
+                                  gcov_tool_args)
+            # Join initial and test results.
+            subprocess.check_call([lcov_exe,
+                                   '-a', initial_tracefile,
+                                   '-a', run_tracefile,
+                                   *lcov_exe_rc_branch_coverage,
+                                   '-o', raw_tracefile] + lcov_config)
+            # Remove all directories outside the source_root from the covinfo
+            subprocess.check_call([lcov_exe,
+                                   '--extract', raw_tracefile,
+                                   os.path.join(source_root, '*'),
+                                   *lcov_exe_rc_branch_coverage,
+                                   '--output-file', covinfo] + lcov_config)
+            # Remove all directories inside subproject dir
+            subprocess.check_call([lcov_exe,
+                                   '--remove', covinfo,
+                                   *lcov_subpoject_exclude,
+                                   *lcov_exe_rc_branch_coverage,
+                                   '--ignore-errors', 'unused',
+                                   '--output-file', covinfo] + lcov_config)
+            subprocess.check_call([genhtml_exe,
+                                   '--prefix', build_root,
+                                   '--prefix', source_root,
+                                   '--output-directory', htmloutdir,
+                                   '--title', 'Code coverage',
+                                   '--legend',
+                                   '--show-details',
+                                   '--branch-coverage',
+                                   covinfo] + lcov_config)
+            outfiles.append(('Html', pathlib.Path(htmloutdir, 'index.html')))
+        elif gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
+            htmloutdir = os.path.join(log_dir, 'coveragereport')
+            if not os.path.isdir(htmloutdir):
+                os.mkdir(htmloutdir)
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
+                                  ['--html',
+                                   '--html-details',
+                                   '--print-summary',
+                                   '-o', os.path.join(htmloutdir, 'index.html'),
+                                   ] + gcov_exe_args)
+            outfiles.append(('Html', pathlib.Path(htmloutdir, 'index.html')))
+        elif outputs:
+            print('lcov/genhtml or gcovr >= 3.3 needed to generate Html coverage report')
+            exitcode = 1
+
+    if not outputs and not outfiles:
+        print('Need gcovr or lcov/genhtml to generate any coverage reports')
+        exitcode = 1
+
+    if outfiles:
+        print('')
+        for (filetype, path) in outfiles:
+            print(filetype + ' coverage report can be found at', path.as_uri())
+
+    return exitcode
+
+def run(args: T.List[str]) -> int:
+    if not os.path.isfile('build.ninja'):
+        print('Coverage currently only works with the Ninja backend.')
+        return 1
+    parser = argparse.ArgumentParser(description='Generate coverage reports')
+    parser.add_argument('--text', dest='outputs', action='append_const',
+                        const='text', help='generate Text report')
+    parser.add_argument('--xml', dest='outputs', action='append_const',
+                        const='xml', help='generate Xml report')
+    parser.add_argument('--sonarqube', dest='outputs', action='append_const',
+                        const='sonarqube', help='generate Sonarqube Xml report')
+    parser.add_argument('--html', dest='outputs', action='append_const',
+                        const='html', help='generate Html report')
+    parser.add_argument('--use-llvm-cov', action='store_true',
+                        help='use llvm-cov')
+    parser.add_argument('--gcovr', action='store', default='',
+                        help='The gcovr executable to use if specified')
+    parser.add_argument('--llvm-cov', action='store', default='',
+                        help='The llvm-cov executable to use if specified')
+    parser.add_argument('source_root')
+    parser.add_argument('subproject_root')
+    parser.add_argument('build_root')
+    parser.add_argument('log_dir')
+    options = parser.parse_args(args)
+    return coverage(options.outputs, options.source_root,
+                    options.subproject_root, options.build_root,
+                    options.log_dir, options.use_llvm_cov,
+                    options.gcovr, options.llvm_cov)
+
+if __name__ == '__main__':
+    sys.exit(run(sys.argv[1:]))

package/releng/meson/mesonbuild/scripts/delwithsuffix.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2013 The Meson development team
+
+from __future__ import annotations
+
+import os, sys
+import typing as T
+
+def run(args: T.List[str]) -> int:
+    if len(args) != 2:
+        print('delwithsuffix.py <root of subdir to process> <suffix to delete>')
+        sys.exit(1)
+
+    topdir = args[0]
+    suffix = args[1]
+    if suffix[0] != '.':
+        suffix = '.' + suffix
+
+    for (root, _, files) in os.walk(topdir):
+        for f in files:
+            if f.endswith(suffix):
+                fullname = os.path.join(root, f)
+                os.unlink(fullname)
+    return 0
+
+if __name__ == '__main__':
+    run(sys.argv[1:])