frida 16.2.1 → 16.2.3

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

@@ -0,0 +1,167 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The meson development team
+
+from __future__ import annotations
+
+"""Abstractions for the Intel Compiler families.
+
+Intel provides both a posix/gcc-like compiler (ICC) for MacOS and Linux,
+with Meson mixin IntelGnuLikeCompiler.
+For Windows, the Intel msvc-like compiler (ICL) Meson mixin
+is IntelVisualStudioLikeCompiler.
+"""
+
+import os
+import typing as T
+
+from ... import mesonlib
+from ..compilers import CompileCheckMode
+from .gnu import GnuLikeCompiler
+from .visualstudio import VisualStudioLikeCompiler
+
+# XXX: avoid circular dependencies
+# TODO: this belongs in a posix compiler class
+# NOTE: the default Intel optimization is -O2, unlike GNU which defaults to -O0.
+# this can be surprising, particularly for debug builds, so we specify the
+# default as -O0.
+# https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-o
+# https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-g
+# https://software.intel.com/en-us/fortran-compiler-developer-guide-and-reference-o
+# https://software.intel.com/en-us/fortran-compiler-developer-guide-and-reference-g
+# https://software.intel.com/en-us/fortran-compiler-developer-guide-and-reference-traceback
+# https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html
+
+
+class IntelGnuLikeCompiler(GnuLikeCompiler):
+    """
+    Tested on linux for ICC 14.0.3, 15.0.6, 16.0.4, 17.0.1, 19.0
+    debugoptimized: -g -O2
+    release: -O3
+    minsize: -O2
+    """
+
+    DEBUG_ARGS: T.Dict[bool, T.List[str]] = {
+        False: [],
+        True: ['-g', '-traceback']
+    }
+
+    OPTIM_ARGS: T.Dict[str, T.List[str]] = {
+        'plain': [],
+        '0': ['-O0'],
+        'g': ['-O0'],
+        '1': ['-O1'],
+        '2': ['-O2'],
+        '3': ['-O3'],
+        's': ['-Os'],
+    }
+    id = 'intel'
+
+    def __init__(self) -> None:
+        super().__init__()
+        # As of 19.0.0 ICC doesn't have sanitizer, color, or lto support.
+        #
+        # It does have IPO, which serves much the same purpose as LOT, but
+        # there is an unfortunate rule for using IPO (you can't control the
+        # name of the output file) which break assumptions meson makes
+        self.base_options = {mesonlib.OptionKey(o) for o in [
+            'b_pch', 'b_lundef', 'b_asneeded', 'b_pgo', 'b_coverage',
+            'b_ndebug', 'b_staticpic', 'b_pie']}
+        self.lang_header = 'none'
+
+    def get_pch_suffix(self) -> str:
+        return 'pchi'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        return ['-pch', '-pch_dir', os.path.join(pch_dir), '-x',
+                self.lang_header, '-include', header, '-x', 'none']
+
+    def get_pch_name(self, name: str) -> str:
+        return os.path.basename(name) + '.' + self.get_pch_suffix()
+
+    def openmp_flags(self) -> T.List[str]:
+        if mesonlib.version_compare(self.version, '>=15.0.0'):
+            return ['-qopenmp']
+        else:
+            return ['-openmp']
+
+    def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+        extra_args = [
+            '-diag-error', '10006',  # ignoring unknown option
+            '-diag-error', '10148',  # Option not supported
+            '-diag-error', '10155',  # ignoring argument required
+            '-diag-error', '10156',  # ignoring not argument allowed
+            '-diag-error', '10157',  # Ignoring argument of the wrong type
+            '-diag-error', '10158',  # Argument must be separate. Can be hit by trying an option like -foo-bar=foo when -foo=bar is a valid option but -foo-bar isn't
+        ]
+        return super().get_compiler_check_args(mode) + extra_args
+
+    def get_profile_generate_args(self) -> T.List[str]:
+        return ['-prof-gen=threadsafe']
+
+    def get_profile_use_args(self) -> T.List[str]:
+        return ['-prof-use']
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return self.DEBUG_ARGS[is_debug]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return self.OPTIM_ARGS[optimization_level]
+
+    def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+        return ['-diag-error', '1292']
+
+
+class IntelVisualStudioLikeCompiler(VisualStudioLikeCompiler):
+
+    """Abstractions for ICL, the Intel compiler on Windows."""
+
+    DEBUG_ARGS: T.Dict[bool, T.List[str]] = {
+        False: [],
+        True: ['/Zi', '/traceback']
+    }
+
+    OPTIM_ARGS: T.Dict[str, T.List[str]] = {
+        'plain': [],
+        '0': ['/Od'],
+        'g': ['/Od'],
+        '1': ['/O1'],
+        '2': ['/O2'],
+        '3': ['/O3'],
+        's': ['/Os'],
+    }
+
+    id = 'intel-cl'
+
+    def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+        args = super().get_compiler_check_args(mode)
+        if mode is not CompileCheckMode.LINK:
+            args.extend([
+                '/Qdiag-error:10006',  # ignoring unknown option
+                '/Qdiag-error:10148',  # Option not supported
+                '/Qdiag-error:10155',  # ignoring argument required
+                '/Qdiag-error:10156',  # ignoring not argument allowed
+                '/Qdiag-error:10157',  # Ignoring argument of the wrong type
+                '/Qdiag-error:10158',  # Argument must be separate. Can be hit by trying an option like -foo-bar=foo when -foo=bar is a valid option but -foo-bar isn't
+            ])
+        return args
+
+    def get_toolset_version(self) -> T.Optional[str]:
+        # ICL provides a cl.exe that returns the version of MSVC it tries to
+        # emulate, so we'll get the version from that and pass it to the same
+        # function the real MSVC uses to calculate the toolset version.
+        _, _, err = mesonlib.Popen_safe(['cl.exe'])
+        v1, v2, *_ = mesonlib.search_version(err).split('.')
+        version = int(v1 + v2)
+        return self._calculate_toolset_version(version)
+
+    def openmp_flags(self) -> T.List[str]:
+        return ['/Qopenmp']
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return self.DEBUG_ARGS[is_debug]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return self.OPTIM_ARGS[optimization_level]
+
+    def get_pch_base_name(self, header: str) -> str:
+        return os.path.basename(header)

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

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The Meson development team
+
+from __future__ import annotations
+
+"""Mixins for compilers that *are* linkers.
+
+While many compilers (such as gcc and clang) are used by meson to dispatch
+linker commands and other (like MSVC) are not, a few (such as DMD) actually
+are both the linker and compiler in one binary. This module provides mixin
+classes for those cases.
+"""
+
+import typing as T
+
+from ...mesonlib import EnvironmentException, MesonException, is_windows
+
+if T.TYPE_CHECKING:
+    from ...coredata import KeyedOptionDictType
+    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
+
+
+class BasicLinkerIsCompilerMixin(Compiler):
+
+    """Provides a baseline of methods that a linker would implement.
+
+    In every case this provides a "no" or "empty" answer. If a compiler
+    implements any of these it needs a different mixin or to override that
+    functionality itself.
+    """
+
+    def sanitizer_link_args(self, value: str) -> T.List[str]:
+        return []
+
+    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default',
+                          thinlto_cache_dir: T.Optional[str] = None) -> T.List[str]:
+        return []
+
+    def can_linker_accept_rsp(self) -> bool:
+        return is_windows()
+
+    def get_linker_exelist(self) -> T.List[str]:
+        return self.exelist.copy()
+
+    def get_linker_output_args(self, outputname: str) -> T.List[str]:
+        return []
+
+    def get_linker_always_args(self) -> T.List[str]:
+        return []
+
+    def get_linker_lib_prefix(self) -> str:
+        return ''
+
+    def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+        return []
+
+    def has_multi_link_args(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return False, False
+
+    def get_link_debugfile_args(self, targetfile: str) -> T.List[str]:
+        return []
+
+    def get_std_shared_lib_link_args(self) -> T.List[str]:
+        return []
+
+    def get_std_shared_module_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+        return self.get_std_shared_lib_link_args()
+
+    def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+        raise EnvironmentException(f'Linker {self.id} does not support link_whole')
+
+    def get_allow_undefined_link_args(self) -> T.List[str]:
+        raise EnvironmentException(f'Linker {self.id} does not support allow undefined')
+
+    def get_pie_link_args(self) -> T.List[str]:
+        raise EnvironmentException(f'Linker {self.id} does not support position-independent executable')
+
+    def get_undefined_link_args(self) -> T.List[str]:
+        return []
+
+    def get_coverage_link_args(self) -> T.List[str]:
+        return []
+
+    def no_undefined_link_args(self) -> T.List[str]:
+        return []
+
+    def bitcode_args(self) -> T.List[str]:
+        raise MesonException("This linker doesn't support bitcode bundles")
+
+    def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+                        suffix: str, soversion: str,
+                        darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+        raise MesonException("This linker doesn't support soname args")
+
+    def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+                         rpath_paths: T.Tuple[str, ...], build_rpath: str,
+                         install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+        return ([], set())
+
+    def get_asneeded_args(self) -> T.List[str]:
+        return []
+
+    def get_optimization_link_args(self, optimization_level: str) -> T.List[str]:
+        return []
+
+    def get_link_debugfile_name(self, targetfile: str) -> T.Optional[str]:
+        return None
+
+    def thread_flags(self, env: 'Environment') -> T.List[str]:
+        return []
+
+    def thread_link_flags(self, env: 'Environment') -> T.List[str]:
+        return []

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

@@ -0,0 +1,279 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2019 The Meson development team
+
+from __future__ import annotations
+
+"""Representations specific to the Metrowerks/Freescale Embedded C/C++ compiler family."""
+
+import os
+import typing as T
+
+from ...mesonlib import EnvironmentException, OptionKey
+
+if T.TYPE_CHECKING:
+    from ...envconfig import MachineInfo
+    from ...compilers.compilers import Compiler, CompileCheckMode
+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
+
+mwccarm_instruction_set_args: T.Dict[str, T.List[str]] = {
+    'generic': ['-proc', 'generic'],
+    'v4': ['-proc', 'v4'],
+    'v4t': ['-proc', 'v4t'],
+    'v5t': ['-proc', 'v5t'],
+    'v5te': ['-proc', 'v5te'],
+    'v6': ['-proc', 'v6'],
+    'arm7tdmi': ['-proc', 'arm7tdmi'],
+    'arm710t': ['-proc', 'arm710t'],
+    'arm720t': ['-proc', 'arm720t'],
+    'arm740t': ['-proc', 'arm740t'],
+    'arm7ej': ['-proc', 'arm7ej'],
+    'arm9tdmi': ['-proc', 'arm9tdmi'],
+    'arm920t': ['-proc', 'arm920t'],
+    'arm922t': ['-proc', 'arm922t'],
+    'arm940t': ['-proc', 'arm940t'],
+    'arm9ej': ['-proc', 'arm9ej'],
+    'arm926ej': ['-proc', 'arm926ej'],
+    'arm946e': ['-proc', 'arm946e'],
+    'arm966e': ['-proc', 'arm966e'],
+    'arm1020e': ['-proc', 'arm1020e'],
+    'arm1022e': ['-proc', 'arm1022e'],
+    'arm1026ej': ['-proc', 'arm1026ej'],
+    'dbmx1': ['-proc', 'dbmx1'],
+    'dbmxl': ['-proc', 'dbmxl'],
+    'XScale': ['-proc', 'XScale'],
+    'pxa255': ['-proc', 'pxa255'],
+    'pxa261': ['-proc', 'pxa261'],
+    'pxa262': ['-proc', 'pxa262'],
+    'pxa263': ['-proc', 'pxa263']
+}
+
+mwcceppc_instruction_set_args: T.Dict[str, T.List[str]] = {
+    'generic': ['-proc', 'generic'],
+    '401': ['-proc', '401'],
+    '403': ['-proc', '403'],
+    '505': ['-proc', '505'],
+    '509': ['-proc', '509'],
+    '555': ['-proc', '555'],
+    '601': ['-proc', '601'],
+    '602': ['-proc', '602'],
+    '603': ['-proc', '603'],
+    '603e': ['-proc', '603e'],
+    '604': ['-proc', '604'],
+    '604e': ['-proc', '604e'],
+    '740': ['-proc', '740'],
+    '750': ['-proc', '750'],
+    '801': ['-proc', '801'],
+    '821': ['-proc', '821'],
+    '823': ['-proc', '823'],
+    '850': ['-proc', '850'],
+    '860': ['-proc', '860'],
+    '7400': ['-proc', '7400'],
+    '7450': ['-proc', '7450'],
+    '8240': ['-proc', '8240'],
+    '8260': ['-proc', '8260'],
+    'e500': ['-proc', 'e500'],
+    'gekko': ['-proc', 'gekko'],
+}
+
+mwasmarm_instruction_set_args: T.Dict[str, T.List[str]] = {
+    'arm4': ['-proc', 'arm4'],
+    'arm4t': ['-proc', 'arm4t'],
+    'arm4xm': ['-proc', 'arm4xm'],
+    'arm4txm': ['-proc', 'arm4txm'],
+    'arm5': ['-proc', 'arm5'],
+    'arm5T': ['-proc', 'arm5T'],
+    'arm5xM': ['-proc', 'arm5xM'],
+    'arm5TxM': ['-proc', 'arm5TxM'],
+    'arm5TE': ['-proc', 'arm5TE'],
+    'arm5TExP': ['-proc', 'arm5TExP'],
+    'arm6': ['-proc', 'arm6'],
+    'xscale': ['-proc', 'xscale']
+}
+
+mwasmeppc_instruction_set_args: T.Dict[str, T.List[str]] = {
+    '401': ['-proc', '401'],
+    '403': ['-proc', '403'],
+    '505': ['-proc', '505'],
+    '509': ['-proc', '509'],
+    '555': ['-proc', '555'],
+    '56X': ['-proc', '56X'],
+    '601': ['-proc', '601'],
+    '602': ['-proc', '602'],
+    '603': ['-proc', '603'],
+    '603e': ['-proc', '603e'],
+    '604': ['-proc', '604'],
+    '604e': ['-proc', '604e'],
+    '740': ['-proc', '740'],
+    '74X': ['-proc', '74X'],
+    '750': ['-proc', '750'],
+    '75X': ['-proc', '75X'],
+    '801': ['-proc', '801'],
+    '821': ['-proc', '821'],
+    '823': ['-proc', '823'],
+    '850': ['-proc', '850'],
+    '85X': ['-proc', '85X'],
+    '860': ['-proc', '860'],
+    '86X': ['-proc', '86X'],
+    '87X': ['-proc', '87X'],
+    '88X': ['-proc', '88X'],
+    '5100': ['-proc', '5100'],
+    '5200': ['-proc', '5200'],
+    '7400': ['-proc', '7400'],
+    '744X': ['-proc', '744X'],
+    '7450': ['-proc', '7450'],
+    '745X': ['-proc', '745X'],
+    '82XX': ['-proc', '82XX'],
+    '8240': ['-proc', '8240'],
+    '824X': ['-proc', '824X'],
+    '8260': ['-proc', '8260'],
+    '827X': ['-proc', '827X'],
+    '8280': ['-proc', '8280'],
+    'e300': ['-proc', 'e300'],
+    'e300c2': ['-proc', 'e300c2'],
+    'e300c3': ['-proc', 'e300c3'],
+    'e300c4': ['-proc', 'e300c4'],
+    'e600': ['-proc', 'e600'],
+    '85xx': ['-proc', '85xx'],
+    'e500': ['-proc', 'e500'],
+    'e500v2': ['-proc', 'e500v2'],
+    'Zen': ['-proc', 'Zen'],
+    '5565': ['-proc', '5565'],
+    '5674': ['-proc', '5674'],
+    'gekko': ['-proc', 'gekko'],
+    'generic': ['-proc', 'generic'],
+}
+
+mwcc_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': ['-O0'],
+    'g': ['-Op'],
+    '1': ['-O1'],
+    '2': ['-O2'],
+    '3': ['-O4,p'],
+    's': ['-Os']
+}
+
+mwcc_debug_args: T.Dict[bool, T.List[str]] = {
+    False: [],
+    True: ['-g']
+}
+
+
+class MetrowerksCompiler(Compiler):
+    id = 'mwcc'
+
+    # These compilers can actually invoke the linker, but they choke on
+    # linker-specific flags. So it's best to invoke the linker directly
+    INVOKES_LINKER = False
+
+    def __init__(self) -> None:
+        if not self.is_cross:
+            raise EnvironmentException(f'{id} supports only cross-compilation.')
+
+        self.base_options = {
+            OptionKey(o) for o in ['b_pch', 'b_ndebug']}
+
+        default_warn_args: T.List[str] = []
+        self.warn_args: T.Dict[str, T.List[str]] = {
+            '0': ['-w', 'off'],
+            '1': default_warn_args,
+            '2': default_warn_args + ['-w', 'most'],
+            '3': default_warn_args + ['-w', 'all'],
+            'everything': default_warn_args + ['-w', 'full']}
+
+    def depfile_for_object(self, objfile: str) -> T.Optional[str]:
+        # Earlier versions of these compilers do not support specifying
+        # a custom name for a depfile, and can only generate '<input_file>.d'
+        return os.path.splitext(objfile)[0] + '.' + self.get_depfile_suffix()
+
+    def get_always_args(self) -> T.List[str]:
+        return ['-gccinc']
+
+    def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+        return []
+
+    def get_compile_only_args(self) -> T.List[str]:
+        return ['-c']
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return mwcc_debug_args[is_debug]
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        # Check comment in depfile_for_object()
+        return ['-gccdep', '-MD']
+
+    def get_depfile_suffix(self) -> str:
+        return 'd'
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        if not path:
+            path = '.'
+        return ['-I' + path]
+
+    def get_no_optimization_args(self) -> T.List[str]:
+        return ['-opt', 'off']
+
+    def get_no_stdinc_args(self) -> T.List[str]:
+        return ['-nostdinc']
+
+    def get_no_stdlib_link_args(self) -> T.List[str]:
+        return ['-nostdlib']
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return mwcc_optimization_args[optimization_level]
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['-o', outputname]
+
+    def get_pic_args(self) -> T.List[str]:
+        return ['-pic']
+
+    def get_preprocess_only_args(self) -> T.List[str]:
+        return ['-E']
+
+    def get_preprocess_to_file_args(self) -> T.List[str]:
+        return ['-P']
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        return ['-prefix', self.get_pch_name(header)]
+
+    def get_pch_name(self, name: str) -> str:
+        return os.path.basename(name) + '.' + self.get_pch_suffix()
+
+    def get_pch_suffix(self) -> str:
+        return 'mch'
+
+    def get_warn_args(self, level: str) -> T.List[str]:
+        return self.warn_args[level]
+
+    def get_werror_args(self) -> T.List[str]:
+        return ['-w', 'error']
+
+    @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 = '-D' + i[2:]
+            if i.startswith('-I'):
+                i = '-I' + i[2:]
+            if i.startswith('-Wl,-rpath='):
+                continue
+            elif i == '--print-search-dirs':
+                continue
+            elif i.startswith('-L'):
+                continue
+            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[:2] == '-I':
+                parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
+
+        return parameter_list

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

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2019 The meson development team
+
+from __future__ import annotations
+
+"""Abstractions for the PGI family of compilers."""
+
+import typing as T
+import os
+from pathlib import Path
+
+from ..compilers import clike_debug_args, clike_optimization_args
+from ...mesonlib import OptionKey
+
+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
+
+
+class PGICompiler(Compiler):
+
+    id = 'pgi'
+
+    def __init__(self) -> None:
+        self.base_options = {OptionKey('b_pch')}
+
+        default_warn_args = ['-Minform=inform']
+        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_module_incdir_args(self) -> T.Tuple[str]:
+        return ('-module', )
+
+    def gen_import_library_args(self, implibname: str) -> T.List[str]:
+        return []
+
+    def get_pic_args(self) -> T.List[str]:
+        # PGI -fPIC is Linux only.
+        if self.info.is_linux():
+            return ['-fPIC']
+        return []
+
+    def openmp_flags(self) -> T.List[str]:
+        return ['-mp']
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return clike_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
+
+    def get_always_args(self) -> T.List[str]:
+        return []
+
+    def get_pch_suffix(self) -> str:
+        # PGI defaults to .pch suffix for PCH on Linux and Windows with --pch option
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        # PGI supports PCH for C++ only.
+        hdr = Path(pch_dir).resolve().parent / header
+        if self.language == 'cpp':
+            return ['--pch',
+                    '--pch_dir', str(hdr.parent),
+                    f'-I{hdr.parent}']
+        else:
+            return []
+
+    def thread_flags(self, env: 'Environment') -> T.List[str]:
+        # PGI cannot accept -pthread, it's already threaded
+        return []