frida 16.2.1 → 16.2.2

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

@@ -0,0 +1,120 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2017 The Meson development team
+
+from __future__ import annotations
+
+import typing as T
+
+from .. import coredata
+from ..mesonlib import OptionKey
+
+from .compilers import Compiler
+from .c import _ALL_STDS, _ClangCStds
+from .mixins.clike import CLikeCompiler
+from .mixins.gnu import GnuCompiler, gnu_common_warning_args, gnu_objc_warning_args
+from .mixins.clang import ClangCompiler
+
+if T.TYPE_CHECKING:
+    from ..envconfig import MachineInfo
+    from ..environment import Environment
+    from ..linkers.linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
+
+
+class ObjCCompiler(CLikeCompiler, Compiler):
+
+    language = 'objc'
+
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+                          is_cross=is_cross, full_version=full_version,
+                          linker=linker)
+        CLikeCompiler.__init__(self)
+
+    @staticmethod
+    def get_display_language() -> str:
+        return 'Objective-C'
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        code = '#import<stddef.h>\nint main(void) { return 0; }\n'
+        return self._sanity_check_impl(work_dir, environment, 'sanitycheckobjc.m', code)
+
+
+class GnuObjCCompiler(GnuCompiler, ObjCCompiler):
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 defines: T.Optional[T.Dict[str, str]] = None,
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+                              info, linker=linker, full_version=full_version)
+        GnuCompiler.__init__(self, defines)
+        default_warn_args = ['-Wall', '-Winvalid-pch']
+        self.warn_args = {'0': [],
+                          '1': default_warn_args,
+                          '2': default_warn_args + ['-Wextra'],
+                          '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+                          'everything': (default_warn_args + ['-Wextra', '-Wpedantic'] +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_objc_warning_args))}
+
+
+class ClangObjCCompiler(ClangCompiler, ObjCCompiler):
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 defines: T.Optional[T.Dict[str, str]] = None,
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+                              info, linker=linker, full_version=full_version)
+        ClangCompiler.__init__(self, defines)
+        self._clang_objcstds = _ClangObjCStds(version, for_machine)
+        default_warn_args = ['-Wall', '-Winvalid-pch']
+        self.warn_args = {'0': [],
+                          '1': default_warn_args,
+                          '2': default_warn_args + ['-Wextra'],
+                          '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+                          'everything': ['-Weverything']}
+
+    def get_options(self) -> 'coredata.MutableKeyedOptionDictType':
+        opts = super().get_options()
+        opts.update(self._clang_objcstds.get_options())
+        return opts
+
+    def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
+        args = []
+        std = options[OptionKey('std', machine=self.for_machine, lang='c')]
+        if std.value != 'none':
+            args.append('-std=' + std.value)
+        return args
+
+class _ClangObjCStdsBase:
+    language = 'c'
+
+    def __init__(self, version: str, for_machine: MachineChoice):
+        self.version = version
+        self.for_machine = for_machine
+
+    def get_options(self) -> 'coredata.MutableKeyedOptionDictType':
+        key = OptionKey('std', machine=self.for_machine, lang=self.language)
+        return {key: coredata.UserStdOption('C', _ALL_STDS)}
+
+class _ClangObjCStds(_ClangCStds, _ClangObjCStdsBase):
+    def __init__(self, version: str, for_machine: MachineChoice):
+        _ClangObjCStdsBase.__init__(self, version, for_machine)
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        pass
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return []
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        pass
+
+class AppleClangObjCCompiler(ClangObjCCompiler):
+
+    """Handle the differences between Apple's clang and vanilla clang."""

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

@@ -0,0 +1,102 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2017 The Meson development team
+
+from __future__ import annotations
+
+import typing as T
+
+from .. import coredata
+from ..mesonlib import OptionKey
+
+from .mixins.clike import CLikeCompiler
+from .compilers import Compiler
+from .mixins.gnu import GnuCompiler, gnu_common_warning_args, gnu_objc_warning_args
+from .mixins.clang import ClangCompiler
+
+if T.TYPE_CHECKING:
+    from ..envconfig import MachineInfo
+    from ..environment import Environment
+    from ..linkers.linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
+
+class ObjCPPCompiler(CLikeCompiler, Compiler):
+
+    language = 'objcpp'
+
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+                          is_cross=is_cross, full_version=full_version,
+                          linker=linker)
+        CLikeCompiler.__init__(self)
+
+    @staticmethod
+    def get_display_language() -> str:
+        return 'Objective-C++'
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        code = '#import<stdio.h>\nclass MyClass;int main(void) { return 0; }\n'
+        return self._sanity_check_impl(work_dir, environment, 'sanitycheckobjcpp.mm', code)
+
+
+class GnuObjCPPCompiler(GnuCompiler, ObjCPPCompiler):
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 defines: T.Optional[T.Dict[str, str]] = None,
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+                                info, linker=linker, full_version=full_version)
+        GnuCompiler.__init__(self, defines)
+        default_warn_args = ['-Wall', '-Winvalid-pch']
+        self.warn_args = {'0': [],
+                          '1': default_warn_args,
+                          '2': default_warn_args + ['-Wextra'],
+                          '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+                          'everything': (default_warn_args + ['-Wextra', '-Wpedantic'] +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_objc_warning_args))}
+
+
+class ClangObjCPPCompiler(ClangCompiler, ObjCPPCompiler):
+
+    def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 defines: T.Optional[T.Dict[str, str]] = None,
+                 linker: T.Optional['DynamicLinker'] = None,
+                 full_version: T.Optional[str] = None):
+        ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
+                                info, linker=linker, full_version=full_version)
+        ClangCompiler.__init__(self, defines)
+        default_warn_args = ['-Wall', '-Winvalid-pch']
+        self.warn_args = {'0': [],
+                          '1': default_warn_args,
+                          '2': default_warn_args + ['-Wextra'],
+                          '3': default_warn_args + ['-Wextra', '-Wpedantic'],
+                          'everything': ['-Weverything']}
+
+    def get_options(self) -> coredata.MutableKeyedOptionDictType:
+        return self.update_options(
+            super().get_options(),
+            self.create_option(coredata.UserComboOption,
+                               OptionKey('std', machine=self.for_machine, lang='cpp'),
+                               'C++ language standard to use',
+                               ['none', 'c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++2b',
+                                'gnu++98', 'gnu++11', 'gnu++14', 'gnu++17', 'gnu++20',
+                                'gnu++2b'],
+                               'none'),
+        )
+
+    def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
+        args = []
+        std = options[OptionKey('std', machine=self.for_machine, lang='cpp')]
+        if std.value != 'none':
+            args.append('-std=' + std.value)
+        return args
+
+
+class AppleClangObjCPPCompiler(ClangObjCPPCompiler):
+
+    """Handle the differences between Apple's clang and vanilla clang."""

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

@@ -0,0 +1,230 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2022 The Meson development team
+
+from __future__ import annotations
+
+import functools
+import subprocess, os.path
+import textwrap
+import re
+import typing as T
+
+from .. import coredata
+from ..mesonlib import EnvironmentException, MesonException, Popen_safe_logged, OptionKey
+from .compilers import Compiler, clike_debug_args
+
+if T.TYPE_CHECKING:
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
+    from ..envconfig import MachineInfo
+    from ..environment import Environment  # noqa: F401
+    from ..linkers.linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
+    from ..dependencies import Dependency
+
+
+rust_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': [],
+    'g': ['-C', 'opt-level=0'],
+    '1': ['-C', 'opt-level=1'],
+    '2': ['-C', 'opt-level=2'],
+    '3': ['-C', 'opt-level=3'],
+    's': ['-C', 'opt-level=s'],
+}
+
+class RustCompiler(Compiler):
+
+    # rustc doesn't invoke the compiler itself, it doesn't need a LINKER_PREFIX
+    language = 'rust'
+    id = 'rustc'
+
+    _WARNING_LEVELS: T.Dict[str, T.List[str]] = {
+        '0': ['-A', 'warnings'],
+        '1': [],
+        '2': [],
+        '3': ['-W', 'warnings'],
+    }
+
+    # Those are static libraries, but we use dylib= here as workaround to avoid
+    # rust --tests to use /WHOLEARCHIVE.
+    # https://github.com/rust-lang/rust/issues/116910
+    MSVCRT_ARGS: T.Mapping[str, T.List[str]] = {
+        'none': [],
+        'md': [], # this is the default, no need to inject anything
+        'mdd': ['-l', 'dylib=msvcrtd'],
+        'mt': ['-l', 'dylib=libcmt'],
+        'mtd': ['-l', 'dylib=libcmtd'],
+    }
+
+    def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 full_version: T.Optional[str] = None,
+                 linker: T.Optional['DynamicLinker'] = None):
+        super().__init__([], exelist, version, for_machine, info,
+                         is_cross=is_cross, full_version=full_version,
+                         linker=linker)
+        self.base_options.update({OptionKey(o) for o in ['b_colorout', 'b_ndebug']})
+        if 'link' in self.linker.id:
+            self.base_options.add(OptionKey('b_vscrt'))
+        self.native_static_libs: T.List[str] = []
+
+    def needs_static_linker(self) -> bool:
+        return False
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        source_name = os.path.join(work_dir, 'sanity.rs')
+        output_name = os.path.join(work_dir, 'rusttest')
+        with open(source_name, 'w', encoding='utf-8') as ofile:
+            ofile.write(textwrap.dedent(
+                '''fn main() {
+                }
+                '''))
+
+        cmdlist = self.exelist + ['-o', output_name, source_name]
+        pc, stdo, stde = Popen_safe_logged(cmdlist, cwd=work_dir)
+        if pc.returncode != 0:
+            raise EnvironmentException(f'Rust compiler {self.name_string()} cannot compile programs.')
+        self._native_static_libs(work_dir, source_name)
+        if environment.need_exe_wrapper(self.for_machine):
+            if not environment.has_exe_wrapper():
+                # Can't check if the binaries run so we have to assume they do
+                return
+            cmdlist = environment.exe_wrapper.get_command() + [output_name]
+        else:
+            cmdlist = [output_name]
+        pe = subprocess.Popen(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        pe.wait()
+        if pe.returncode != 0:
+            raise EnvironmentException(f'Executables created by Rust compiler {self.name_string()} are not runnable.')
+
+    def _native_static_libs(self, work_dir: str, source_name: str) -> None:
+        # Get libraries needed to link with a Rust staticlib
+        cmdlist = self.exelist + ['--crate-type', 'staticlib', '--print', 'native-static-libs', source_name]
+        p, stdo, stde = Popen_safe_logged(cmdlist, cwd=work_dir)
+        if p.returncode != 0:
+            raise EnvironmentException('Rust compiler cannot compile staticlib.')
+        match = re.search('native-static-libs: (.*)$', stde, re.MULTILINE)
+        if not match:
+            raise EnvironmentException('Failed to find native-static-libs in Rust compiler output.')
+        # Exclude some well known libraries that we don't need because they
+        # are always part of C/C++ linkers. Rustc probably should not print
+        # them, pkg-config for example never specify them.
+        # FIXME: https://github.com/rust-lang/rust/issues/55120
+        exclude = {'-lc', '-lgcc_s', '-lkernel32', '-ladvapi32'}
+        self.native_static_libs = [i for i in match.group(1).split() if i not in exclude]
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['--dep-info', outfile]
+
+    def get_sysroot(self) -> str:
+        cmd = self.get_exelist(ccache=False) + ['--print', 'sysroot']
+        p, stdo, stde = Popen_safe_logged(cmd)
+        return stdo.split('\n', maxsplit=1)[0]
+
+    @functools.lru_cache(maxsize=None)
+    def get_crt_static(self) -> bool:
+        cmd = self.get_exelist(ccache=False) + ['--print', 'cfg']
+        p, stdo, stde = Popen_safe_logged(cmd)
+        return bool(re.search('^target_feature="crt-static"$', stdo, re.MULTILINE))
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return clike_debug_args[is_debug]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return rust_optimization_args[optimization_level]
+
+    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] == '-L':
+                for j in ['dependency', 'crate', 'native', 'framework', 'all']:
+                    combined_len = len(j) + 3
+                    if i[:combined_len] == f'-L{j}=':
+                        parameter_list[idx] = i[:combined_len] + os.path.normpath(os.path.join(build_dir, i[combined_len:]))
+                        break
+
+        return parameter_list
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['-o', outputname]
+
+    @classmethod
+    def use_linker_args(cls, linker: str, version: str) -> T.List[str]:
+        return ['-C', f'linker={linker}']
+
+    # Rust does not have a use_linker_args because it dispatches to a gcc-like
+    # C compiler for dynamic linking, as such we invoke the C compiler's
+    # use_linker_args method instead.
+
+    def get_options(self) -> MutableKeyedOptionDictType:
+        return dict((self.create_option(coredata.UserComboOption,
+                                        OptionKey('std', machine=self.for_machine, lang=self.language),
+                                        'Rust edition to use',
+                                        ['none', '2015', '2018', '2021'],
+                                        'none'),))
+
+    def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]:
+        # Rust doesn't have dependency compile arguments so simply return
+        # nothing here. Dependencies are linked and all required metadata is
+        # provided by the linker flags.
+        return []
+
+    def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+        args = []
+        key = OptionKey('std', machine=self.for_machine, lang=self.language)
+        std = options[key]
+        if std.value != 'none':
+            args.append('--edition=' + std.value)
+        return args
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        # Rust handles this for us, we don't need to do anything
+        return []
+
+    def get_crt_link_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        if self.linker.id not in {'link', 'lld-link'}:
+            return []
+        return self.MSVCRT_ARGS[self.get_crt_val(crt_val, buildtype)]
+
+    def get_colorout_args(self, colortype: str) -> T.List[str]:
+        if colortype in {'always', 'never', 'auto'}:
+            return [f'--color={colortype}']
+        raise MesonException(f'Invalid color type for rust {colortype}')
+
+    def get_linker_always_args(self) -> T.List[str]:
+        args: T.List[str] = []
+        for a in super().get_linker_always_args():
+            args.extend(['-C', f'link-arg={a}'])
+        return args
+
+    def get_werror_args(self) -> T.List[str]:
+        # Use -D warnings, which makes every warning not explicitly allowed an
+        # error
+        return ['-D', 'warnings']
+
+    def get_warn_args(self, level: str) -> T.List[str]:
+        # TODO: I'm not really sure what to put here, Rustc doesn't have warning
+        return self._WARNING_LEVELS[level]
+
+    def get_pic_args(self) -> T.List[str]:
+        # relocation-model=pic is rustc's default already.
+        return []
+
+    def get_pie_args(self) -> T.List[str]:
+        # Rustc currently has no way to toggle this, it's controlled by whether
+        # pic is on by rustc
+        return []
+
+    def get_assert_args(self, disable: bool) -> T.List[str]:
+        action = "no" if disable else "yes"
+        return ['-C', f'debug-assertions={action}', '-C', 'overflow-checks=no']
+
+
+class ClippyRustCompiler(RustCompiler):
+
+    """Clippy is a linter that wraps Rustc.
+
+    This just provides us a different id
+    """
+
+    id = 'clippy-driver rustc'

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

@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2017 The Meson development team
+
+from __future__ import annotations
+
+import subprocess, os.path
+import typing as T
+
+from ..mesonlib import EnvironmentException
+
+from .compilers import Compiler, clike_debug_args
+
+if T.TYPE_CHECKING:
+    from ..dependencies import Dependency
+    from ..envconfig import MachineInfo
+    from ..environment import Environment
+    from ..linkers.linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
+
+swift_optimization_args: T.Dict[str, T.List[str]] = {
+    'plain': [],
+    '0': [],
+    'g': [],
+    '1': ['-O'],
+    '2': ['-O'],
+    '3': ['-O'],
+    's': ['-Osize'],
+}
+
+class SwiftCompiler(Compiler):
+
+    LINKER_PREFIX = ['-Xlinker']
+    language = 'swift'
+    id = 'llvm'
+
+    def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo', full_version: T.Optional[str] = None,
+                 linker: T.Optional['DynamicLinker'] = None):
+        super().__init__([], exelist, version, for_machine, info,
+                         is_cross=is_cross, full_version=full_version,
+                         linker=linker)
+        self.version = version
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_werror_args(self) -> T.List[str]:
+        return ['--fatal-warnings']
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
+        return ['-emit-dependencies']
+
+    def get_dependency_link_args(self, dep: 'Dependency') -> T.List[str]:
+        result = []
+        for arg in dep.get_link_args():
+            if arg.startswith("-Wl,"):
+                for flag in arg[4:].split(","):
+                    result += ["-Xlinker", flag]
+            else:
+                result.append(arg)
+        return result
+
+    def depfile_for_object(self, objfile: str) -> T.Optional[str]:
+        return os.path.splitext(objfile)[0] + '.' + self.get_depfile_suffix()
+
+    def get_depfile_suffix(self) -> str:
+        return 'd'
+
+    def get_output_args(self, target: str) -> T.List[str]:
+        return ['-o', target]
+
+    def get_header_import_args(self, headername: str) -> T.List[str]:
+        return ['-import-objc-header', headername]
+
+    def get_warn_args(self, level: str) -> T.List[str]:
+        return []
+
+    def get_std_exe_link_args(self) -> T.List[str]:
+        return ['-emit-executable']
+
+    def get_std_shared_lib_link_args(self) -> T.List[str]:
+        return ['-emit-library']
+
+    def get_module_args(self, modname: str) -> T.List[str]:
+        return ['-module-name', modname]
+
+    def get_mod_gen_args(self) -> T.List[str]:
+        return ['-emit-module']
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        return ['-I' + path]
+
+    def get_compile_only_args(self) -> T.List[str]:
+        return ['-c']
+
+    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 sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        src = 'swifttest.swift'
+        source_name = os.path.join(work_dir, src)
+        output_name = os.path.join(work_dir, 'swifttest')
+        extra_flags: T.List[str] = []
+        extra_flags += environment.coredata.get_external_args(self.for_machine, self.language)
+        if self.is_cross:
+            extra_flags += self.get_compile_only_args()
+        else:
+            extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
+        with open(source_name, 'w', encoding='utf-8') as ofile:
+            ofile.write('''print("Swift compilation is working.")
+''')
+        pc = subprocess.Popen(self.exelist + extra_flags + ['-emit-executable', '-o', output_name, src], cwd=work_dir)
+        pc.wait()
+        if pc.returncode != 0:
+            raise EnvironmentException('Swift compiler %s cannot compile programs.' % self.name_string())
+        if self.is_cross:
+            # Can't check if the binaries run so we have to assume they do
+            return
+        if subprocess.call(output_name) != 0:
+            raise EnvironmentException('Executables created by Swift compiler %s are not runnable.' % self.name_string())
+
+    def get_debug_args(self, is_debug: bool) -> T.List[str]:
+        return clike_debug_args[is_debug]
+
+    def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+        return swift_optimization_args[optimization_level]