frida 16.2.0 → 16.2.2

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

@@ -0,0 +1,1330 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2023 The Meson development team
+
+from __future__ import annotations
+
+
+"""Mixin classes to be shared between C and C++ compilers.
+
+Without this we'll end up with awful diamond inheritance problems. The goal
+of this is to have mixin's, which are classes that are designed *not* to be
+standalone, they only work through inheritance.
+"""
+
+import collections
+import functools
+import glob
+import itertools
+import os
+import re
+import subprocess
+import copy
+import typing as T
+from pathlib import Path
+
+from ... import arglist
+from ... import mesonlib
+from ... import mlog
+from ...linkers.linkers import GnuLikeDynamicLinkerMixin, SolarisDynamicLinker, CompCertDynamicLinker
+from ...mesonlib import LibType, OptionKey
+from .. import compilers
+from ..compilers import CompileCheckMode
+from .visualstudio import VisualStudioLikeCompiler
+
+if T.TYPE_CHECKING:
+    from ...dependencies import Dependency
+    from ..._typing import ImmutableListProtocol
+    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
+
+GROUP_FLAGS = re.compile(r'''^(?!-Wl,) .*\.so (?:\.[0-9]+)? (?:\.[0-9]+)? (?:\.[0-9]+)?$ |
+                             ^(?:-Wl,)?-l |
+                             \.a$''', re.X)
+
+class CLikeCompilerArgs(arglist.CompilerArgs):
+    prepend_prefixes = ('-I', '-L')
+    dedup2_prefixes = ('-I', '-isystem', '-L', '-D', '-U')
+
+    # NOTE: not thorough. A list of potential corner cases can be found in
+    # https://github.com/mesonbuild/meson/pull/4593#pullrequestreview-182016038
+    dedup1_prefixes = ('-l', '-Wl,-l', '-Wl,--export-dynamic')
+    dedup1_suffixes = ('.lib', '.dll', '.so', '.dylib', '.a')
+    dedup1_args = ('-c', '-S', '-E', '-pipe', '-pthread')
+
+    def to_native(self, copy: bool = False) -> T.List[str]:
+        # This seems to be allowed, but could never work?
+        assert isinstance(self.compiler, compilers.Compiler), 'How did you get here'
+
+        # Check if we need to add --start/end-group for circular dependencies
+        # between static libraries, and for recursively searching for symbols
+        # needed by static libraries that are provided by object files or
+        # shared libraries.
+        self.flush_pre_post()
+        if copy:
+            new = self.copy()
+        else:
+            new = self
+        # This covers all ld.bfd, ld.gold, ld.gold, and xild on Linux, which
+        # all act like (or are) gnu ld
+        # TODO: this could probably be added to the DynamicLinker instead
+        if isinstance(self.compiler.linker, (GnuLikeDynamicLinkerMixin, SolarisDynamicLinker, CompCertDynamicLinker)):
+            group_start = -1
+            group_end = -1
+            for i, each in enumerate(new):
+                if not GROUP_FLAGS.search(each):
+                    continue
+                group_end = i
+                if group_start < 0:
+                    # First occurrence of a library
+                    group_start = i
+            # Only add groups if there are multiple libraries.
+            if group_end > group_start >= 0:
+                # Last occurrence of a library
+                new.insert(group_end + 1, '-Wl,--end-group')
+                new.insert(group_start, '-Wl,--start-group')
+        # Remove system/default include paths added with -isystem
+        default_dirs = self.compiler.get_default_include_dirs()
+        if default_dirs:
+            real_default_dirs = [self._cached_realpath(i) for i in default_dirs]
+            bad_idx_list: T.List[int] = []
+            for i, each in enumerate(new):
+                if not each.startswith('-isystem'):
+                    continue
+
+                # Remove the -isystem and the path if the path is a default path
+                if (each == '-isystem' and
+                        i < (len(new) - 1) and
+                        self._cached_realpath(new[i + 1]) in real_default_dirs):
+                    bad_idx_list += [i, i + 1]
+                elif each.startswith('-isystem=') and self._cached_realpath(each[9:]) in real_default_dirs:
+                    bad_idx_list += [i]
+                elif self._cached_realpath(each[8:]) in real_default_dirs:
+                    bad_idx_list += [i]
+            for i in reversed(bad_idx_list):
+                new.pop(i)
+        return self.compiler.unix_args_to_native(new._container)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def _cached_realpath(arg: str) -> str:
+        return os.path.realpath(arg)
+
+    def __repr__(self) -> str:
+        self.flush_pre_post()
+        return f'CLikeCompilerArgs({self.compiler!r}, {self._container!r})'
+
+
+class CLikeCompiler(Compiler):
+
+    """Shared bits for the C and CPP Compilers."""
+
+    if T.TYPE_CHECKING:
+        warn_args: T.Dict[str, T.List[str]] = {}
+
+    # TODO: Replace this manual cache with functools.lru_cache
+    find_library_cache: T.Dict[T.Tuple[T.Tuple[str, ...], str, T.Tuple[str, ...], str, LibType], T.Optional[T.List[str]]] = {}
+    find_framework_cache: T.Dict[T.Tuple[T.Tuple[str, ...], str, T.Tuple[str, ...], bool], T.Optional[T.List[str]]] = {}
+    internal_libs = arglist.UNIXY_COMPILER_INTERNAL_LIBS
+
+    def __init__(self) -> None:
+        # If a child ObjC or CPP class has already set it, don't set it ourselves
+        self.can_compile_suffixes.add('h')
+        # Lazy initialized in get_preprocessor()
+        self.preprocessor: T.Optional[Compiler] = None
+
+    def compiler_args(self, args: T.Optional[T.Iterable[str]] = None) -> CLikeCompilerArgs:
+        # This is correct, mypy just doesn't understand co-operative inheritance
+        return CLikeCompilerArgs(self, args)
+
+    def needs_static_linker(self) -> bool:
+        return True # When compiling static libraries, so yes.
+
+    def get_always_args(self) -> T.List[str]:
+        '''
+        Args that are always-on for all C compilers other than MSVC
+        '''
+        return self.get_largefile_args()
+
+    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_warn_args(self, level: str) -> T.List[str]:
+        # TODO: this should be an enum
+        return self.warn_args[level]
+
+    def get_depfile_suffix(self) -> str:
+        return 'd'
+
+    def get_preprocess_only_args(self) -> T.List[str]:
+        return ['-E', '-P']
+
+    def get_compile_only_args(self) -> T.List[str]:
+        return ['-c']
+
+    def get_no_optimization_args(self) -> T.List[str]:
+        return ['-O0']
+
+    def get_output_args(self, outputname: str) -> T.List[str]:
+        return ['-o', outputname]
+
+    def get_werror_args(self) -> T.List[str]:
+        return ['-Werror']
+
+    def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+        if path == '':
+            path = '.'
+        if is_system:
+            return ['-isystem', path]
+        return ['-I' + path]
+
+    def get_compiler_dirs(self, env: 'Environment', name: str) -> T.List[str]:
+        '''
+        Get dirs from the compiler, either `libraries:` or `programs:`
+        '''
+        return []
+
+    @functools.lru_cache()
+    def _get_library_dirs(self, env: 'Environment',
+                          elf_class: T.Optional[int] = None) -> 'ImmutableListProtocol[str]':
+        # TODO: replace elf_class with enum
+        dirs = self.get_compiler_dirs(env, 'libraries')
+        if elf_class is None or elf_class == 0:
+            return dirs
+
+        # if we do have an elf class for 32-bit or 64-bit, we want to check that
+        # the directory in question contains libraries of the appropriate class. Since
+        # system directories aren't mixed, we only need to check one file for each
+        # directory and go by that. If we can't check the file for some reason, assume
+        # the compiler knows what it's doing, and accept the directory anyway.
+        retval: T.List[str] = []
+        for d in dirs:
+            files = [f for f in os.listdir(d) if f.endswith('.so') and os.path.isfile(os.path.join(d, f))]
+            # if no files, accept directory and move on
+            if not files:
+                retval.append(d)
+                continue
+
+            for f in files:
+                file_to_check = os.path.join(d, f)
+                try:
+                    with open(file_to_check, 'rb') as fd:
+                        header = fd.read(5)
+                        # if file is not an ELF file, it's weird, but accept dir
+                        # if it is elf, and the class matches, accept dir
+                        if header[1:4] != b'ELF' or int(header[4]) == elf_class:
+                            retval.append(d)
+                        # at this point, it's an ELF file which doesn't match the
+                        # appropriate elf_class, so skip this one
+                    # stop scanning after the first successful read
+                    break
+                except OSError:
+                    # Skip the file if we can't read it
+                    pass
+
+        return retval
+
+    def get_library_dirs(self, env: 'Environment',
+                         elf_class: T.Optional[int] = None) -> T.List[str]:
+        """Wrap the lru_cache so that we return a new copy and don't allow
+        mutation of the cached value.
+        """
+        return self._get_library_dirs(env, elf_class).copy()
+
+    @functools.lru_cache()
+    def _get_program_dirs(self, env: 'Environment') -> 'ImmutableListProtocol[str]':
+        '''
+        Programs used by the compiler. Also where toolchain DLLs such as
+        libstdc++-6.dll are found with MinGW.
+        '''
+        return self.get_compiler_dirs(env, 'programs')
+
+    def get_program_dirs(self, env: 'Environment') -> T.List[str]:
+        return self._get_program_dirs(env).copy()
+
+    def get_pic_args(self) -> T.List[str]:
+        return ['-fPIC']
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+        return ['-include', os.path.basename(header)]
+
+    def get_pch_name(self, name: str) -> str:
+        return os.path.basename(name) + '.' + self.get_pch_suffix()
+
+    def get_default_include_dirs(self) -> T.List[str]:
+        return []
+
+    def gen_export_dynamic_link_args(self, env: 'Environment') -> T.List[str]:
+        return self.linker.export_dynamic_args(env)
+
+    def gen_import_library_args(self, implibname: str) -> T.List[str]:
+        return self.linker.import_library_args(implibname)
+
+    def _sanity_check_impl(self, work_dir: str, environment: 'Environment',
+                           sname: str, code: str) -> None:
+        mlog.debug('Sanity testing ' + self.get_display_language() + ' compiler:', mesonlib.join_args(self.exelist))
+        mlog.debug(f'Is cross compiler: {self.is_cross!s}.')
+
+        source_name = os.path.join(work_dir, sname)
+        binname = sname.rsplit('.', 1)[0]
+        mode = CompileCheckMode.LINK
+        if self.is_cross:
+            binname += '_cross'
+            if environment.need_exe_wrapper(self.for_machine) and not environment.has_exe_wrapper():
+                # Linking cross built C/C++ apps is painful. You can't really
+                # tell if you should use -nostdlib or not and for example
+                # on OSX the compiler binary is the same but you need
+                # a ton of compiler flags to differentiate between
+                # arm and x86_64. So just compile.
+                mode = CompileCheckMode.COMPILE
+        cargs, largs = self._get_basic_compiler_args(environment, mode)
+        extra_flags = cargs + self.linker_to_compiler_args(largs)
+
+        # Is a valid executable output for all toolchains and platforms
+        binname += '.exe'
+        # Write binary check source
+        binary_name = os.path.join(work_dir, binname)
+        with open(source_name, 'w', encoding='utf-8') as ofile:
+            ofile.write(code)
+        # Compile sanity check
+        # NOTE: extra_flags must be added at the end. On MSVC, it might contain a '/link' argument
+        # after which all further arguments will be passed directly to the linker
+        cmdlist = self.exelist + [sname] + self.get_output_args(binname) + extra_flags
+        pc, stdo, stde = mesonlib.Popen_safe(cmdlist, cwd=work_dir)
+        mlog.debug('Sanity check compiler command line:', mesonlib.join_args(cmdlist))
+        mlog.debug('Sanity check compile stdout:')
+        mlog.debug(stdo)
+        mlog.debug('-----\nSanity check compile stderr:')
+        mlog.debug(stde)
+        mlog.debug('-----')
+        if pc.returncode != 0:
+            raise mesonlib.EnvironmentException(f'Compiler {self.name_string()} cannot compile programs.')
+        # Run sanity check
+        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() + [binary_name]
+        else:
+            cmdlist = [binary_name]
+        mlog.debug('Running test binary command: ', mesonlib.join_args(cmdlist))
+        try:
+            # fortran code writes to stdout
+            pe = subprocess.run(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except Exception as e:
+            raise mesonlib.EnvironmentException(f'Could not invoke sanity test executable: {e!s}.')
+        if pe.returncode != 0:
+            raise mesonlib.EnvironmentException(f'Executables created by {self.language} compiler {self.name_string()} are not runnable.')
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        code = 'int main(void) { int class=0; return class; }\n'
+        return self._sanity_check_impl(work_dir, environment, 'sanitycheckc.c', code)
+
+    def check_header(self, hname: str, prefix: str, env: 'Environment', *,
+                     extra_args: T.Union[None, T.List[str], T.Callable[['CompileCheckMode'], T.List[str]]] = None,
+                     dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+        code = f'''{prefix}
+        #include <{hname}>\n'''
+        return self.compiles(code, env, extra_args=extra_args,
+                             dependencies=dependencies)
+
+    def has_header(self, hname: str, prefix: str, env: 'Environment', *,
+                   extra_args: T.Union[None, T.List[str], T.Callable[['CompileCheckMode'], T.List[str]]] = None,
+                   dependencies: T.Optional[T.List['Dependency']] = None,
+                   disable_cache: bool = False) -> T.Tuple[bool, bool]:
+        code = f'''{prefix}
+        #ifdef __has_include
+         #if !__has_include("{hname}")
+          #error "Header '{hname}' could not be found"
+         #endif
+        #else
+         #include <{hname}>
+        #endif\n'''
+        return self.compiles(code, env, extra_args=extra_args,
+                             dependencies=dependencies, mode=CompileCheckMode.PREPROCESS, disable_cache=disable_cache)
+
+    def has_header_symbol(self, hname: str, symbol: str, prefix: str,
+                          env: 'Environment', *,
+                          extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+                          dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+        t = f'''{prefix}
+        #include <{hname}>
+        int main(void) {{
+            /* If it's not defined as a macro, try to use as a symbol */
+            #ifndef {symbol}
+                {symbol};
+            #endif
+            return 0;
+        }}\n'''
+        return self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)
+
+    def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) -> T.Tuple[T.List[str], T.List[str]]:
+        cargs: T.List[str] = []
+        largs: T.List[str] = []
+        if mode is CompileCheckMode.LINK:
+            # Sometimes we need to manually select the CRT to use with MSVC.
+            # One example is when trying to do a compiler check that involves
+            # linking with static libraries since MSVC won't select a CRT for
+            # us in that case and will error out asking us to pick one.
+            try:
+                crt_val = env.coredata.options[OptionKey('b_vscrt')].value
+                buildtype = env.coredata.options[OptionKey('buildtype')].value
+                cargs += self.get_crt_compile_args(crt_val, buildtype)
+            except (KeyError, AttributeError):
+                pass
+
+        # Add CFLAGS/CXXFLAGS/OBJCFLAGS/OBJCXXFLAGS and CPPFLAGS from the env
+        sys_args = env.coredata.get_external_args(self.for_machine, self.language)
+        if isinstance(sys_args, str):
+            sys_args = [sys_args]
+        # Apparently it is a thing to inject linker flags both
+        # via CFLAGS _and_ LDFLAGS, even though the former are
+        # also used during linking. These flags can break
+        # argument checks. Thanks, Autotools.
+        cleaned_sys_args = self.remove_linkerlike_args(sys_args)
+        cargs += cleaned_sys_args
+
+        if mode is CompileCheckMode.LINK:
+            ld_value = env.lookup_binary_entry(self.for_machine, self.language + '_ld')
+            if ld_value is not None:
+                largs += self.use_linker_args(ld_value[0], self.version)
+
+            # Add LDFLAGS from the env
+            sys_ld_args = env.coredata.get_external_link_args(self.for_machine, self.language)
+            # CFLAGS and CXXFLAGS go to both linking and compiling, but we want them
+            # to only appear on the command line once. Remove dupes.
+            largs += [x for x in sys_ld_args if x not in sys_args]
+
+        cargs += self.get_compiler_args_for_mode(mode)
+        return cargs, largs
+
+    def build_wrapper_args(self, env: 'Environment',
+                           extra_args: T.Union[None, arglist.CompilerArgs, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]],
+                           dependencies: T.Optional[T.List['Dependency']],
+                           mode: CompileCheckMode = CompileCheckMode.COMPILE) -> arglist.CompilerArgs:
+        # TODO: the caller should handle the listing of these arguments
+        if extra_args is None:
+            extra_args = []
+        else:
+            # TODO: we want to do this in the caller
+            extra_args = mesonlib.listify(extra_args)
+        extra_args = mesonlib.listify([e(mode.value) if callable(e) else e for e in extra_args])
+
+        if dependencies is None:
+            dependencies = []
+        elif not isinstance(dependencies, collections.abc.Iterable):
+            # TODO: we want to ensure the front end does the listifing here
+            dependencies = [dependencies]
+        # Collect compiler arguments
+        cargs: arglist.CompilerArgs = self.compiler_args()
+        largs: T.List[str] = []
+        for d in dependencies:
+            # Add compile flags needed by dependencies
+            cargs += d.get_compile_args()
+            system_incdir = d.get_include_type() == 'system'
+            for i in d.get_include_dirs():
+                for idir in i.to_string_list(env.get_source_dir(), env.get_build_dir()):
+                    cargs.extend(self.get_include_args(idir, system_incdir))
+            if mode is CompileCheckMode.LINK:
+                # Add link flags needed to find dependencies
+                largs += d.get_link_args()
+
+        ca, la = self._get_basic_compiler_args(env, mode)
+        cargs += ca
+        largs += la
+
+        cargs += self.get_compiler_check_args(mode)
+
+        # on MSVC compiler and linker flags must be separated by the "/link" argument
+        # at this point, the '/link' argument may already be part of extra_args, otherwise, it is added here
+        if self.linker_to_compiler_args([]) == ['/link'] and largs != [] and '/link' not in extra_args:
+            extra_args += ['/link']
+
+        args = cargs + extra_args + largs
+        return args
+
+    def _compile_int(self, expression: str, prefix: str, env: 'Environment',
+                     extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]],
+                     dependencies: T.Optional[T.List['Dependency']]) -> bool:
+        t = f'''{prefix}
+        #include <stddef.h>
+        int main(void) {{ static int a[1-2*!({expression})]; a[0]=0; return 0; }}\n'''
+        return self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)[0]
+
+    def cross_compute_int(self, expression: str, low: T.Optional[int], high: T.Optional[int],
+                          guess: T.Optional[int], prefix: str, env: 'Environment',
+                          extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+                          dependencies: T.Optional[T.List['Dependency']] = None) -> int:
+        # Try user's guess first
+        if isinstance(guess, int):
+            if self._compile_int(f'{expression} == {guess}', prefix, env, extra_args, dependencies):
+                return guess
+
+        # If no bounds are given, compute them in the limit of int32
+        maxint = 0x7fffffff
+        minint = -0x80000000
+        if not isinstance(low, int) or not isinstance(high, int):
+            if self._compile_int(f'{expression} >= 0', prefix, env, extra_args, dependencies):
+                low = cur = 0
+                while self._compile_int(f'{expression} > {cur}', prefix, env, extra_args, dependencies):
+                    low = cur + 1
+                    if low > maxint:
+                        raise mesonlib.EnvironmentException('Cross-compile check overflowed')
+                    cur = min(cur * 2 + 1, maxint)
+                high = cur
+            else:
+                high = cur = -1
+                while self._compile_int(f'{expression} < {cur}', prefix, env, extra_args, dependencies):
+                    high = cur - 1
+                    if high < minint:
+                        raise mesonlib.EnvironmentException('Cross-compile check overflowed')
+                    cur = max(cur * 2, minint)
+                low = cur
+        else:
+            # Sanity check limits given by user
+            if high < low:
+                raise mesonlib.EnvironmentException('high limit smaller than low limit')
+            condition = f'{expression} <= {high} && {expression} >= {low}'
+            if not self._compile_int(condition, prefix, env, extra_args, dependencies):
+                raise mesonlib.EnvironmentException('Value out of given range')
+
+        # Binary search
+        while low != high:
+            cur = low + int((high - low) / 2)
+            if self._compile_int(f'{expression} <= {cur}', prefix, env, extra_args, dependencies):
+                high = cur
+            else:
+                low = cur + 1
+
+        return low
+
+    def compute_int(self, expression: str, low: T.Optional[int], high: T.Optional[int],
+                    guess: T.Optional[int], prefix: str, env: 'Environment', *,
+                    extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]],
+                    dependencies: T.Optional[T.List['Dependency']] = None) -> int:
+        if extra_args is None:
+            extra_args = []
+        if self.is_cross:
+            return self.cross_compute_int(expression, low, high, guess, prefix, env, extra_args, dependencies)
+        t = f'''{prefix}
+        #include<stddef.h>
+        #include<stdio.h>
+        int main(void) {{
+            printf("%ld\\n", (long)({expression}));
+            return 0;
+        }}'''
+        res = self.run(t, env, extra_args=extra_args,
+                       dependencies=dependencies)
+        if not res.compiled:
+            return -1
+        if res.returncode != 0:
+            raise mesonlib.EnvironmentException('Could not run compute_int test binary.')
+        return int(res.stdout)
+
+    def cross_sizeof(self, typename: str, prefix: str, env: 'Environment', *,
+                     extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+                     dependencies: T.Optional[T.List['Dependency']] = None) -> int:
+        if extra_args is None:
+            extra_args = []
+        t = f'''{prefix}
+        #include <stddef.h>
+        int main(void) {{
+            {typename} something;
+            return 0;
+        }}\n'''
+        if not self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)[0]:
+            return -1
+        return self.cross_compute_int(f'sizeof({typename})', None, None, None, prefix, env, extra_args, dependencies)
+
+    def sizeof(self, typename: str, prefix: str, env: 'Environment', *,
+               extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+               dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[int, bool]:
+        if extra_args is None:
+            extra_args = []
+        if self.is_cross:
+            r = self.cross_sizeof(typename, prefix, env, extra_args=extra_args,
+                                  dependencies=dependencies)
+            return r, False
+        t = f'''{prefix}
+        #include<stddef.h>
+        #include<stdio.h>
+        int main(void) {{
+            printf("%ld\\n", (long)(sizeof({typename})));
+            return 0;
+        }}'''
+        res = self.cached_run(t, env, extra_args=extra_args,
+                              dependencies=dependencies)
+        if not res.compiled:
+            return -1, False
+        if res.returncode != 0:
+            raise mesonlib.EnvironmentException('Could not run sizeof test binary.')
+        return int(res.stdout), res.cached
+
+    def cross_alignment(self, typename: str, prefix: str, env: 'Environment', *,
+                        extra_args: T.Optional[T.List[str]] = None,
+                        dependencies: T.Optional[T.List['Dependency']] = None) -> int:
+        if extra_args is None:
+            extra_args = []
+        t = f'''{prefix}
+        #include <stddef.h>
+        int main(void) {{
+            {typename} something;
+            return 0;
+        }}\n'''
+        if not self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)[0]:
+            return -1
+        t = f'''{prefix}
+        #include <stddef.h>
+        struct tmp {{
+            char c;
+            {typename} target;
+        }};'''
+        return self.cross_compute_int('offsetof(struct tmp, target)', None, None, None, t, env, extra_args, dependencies)
+
+    def alignment(self, typename: str, prefix: str, env: 'Environment', *,
+                  extra_args: T.Optional[T.List[str]] = None,
+                  dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[int, bool]:
+        if extra_args is None:
+            extra_args = []
+        if self.is_cross:
+            r = self.cross_alignment(typename, prefix, env, extra_args=extra_args,
+                                     dependencies=dependencies)
+            return r, False
+        t = f'''{prefix}
+        #include <stdio.h>
+        #include <stddef.h>
+        struct tmp {{
+            char c;
+            {typename} target;
+        }};
+        int main(void) {{
+            printf("%d", (int)offsetof(struct tmp, target));
+            return 0;
+        }}'''
+        res = self.cached_run(t, env, extra_args=extra_args,
+                              dependencies=dependencies)
+        if not res.compiled:
+            raise mesonlib.EnvironmentException('Could not compile alignment test.')
+        if res.returncode != 0:
+            raise mesonlib.EnvironmentException('Could not run alignment test binary.')
+        align = int(res.stdout)
+        if align == 0:
+            raise mesonlib.EnvironmentException(f'Could not determine alignment of {typename}. Sorry. You might want to file a bug.')
+        return align, res.cached
+
+    def get_define(self, dname: str, prefix: str, env: 'Environment',
+                   extra_args: T.Union[T.List[str], T.Callable[[CompileCheckMode], T.List[str]]],
+                   dependencies: T.Optional[T.List['Dependency']],
+                   disable_cache: bool = False) -> T.Tuple[str, bool]:
+        delim_start = '"MESON_GET_DEFINE_DELIMITER_START"\n'
+        delim_end = '\n"MESON_GET_DEFINE_DELIMITER_END"'
+        sentinel_undef = '"MESON_GET_DEFINE_UNDEFINED_SENTINEL"'
+        code = f'''
+        {prefix}
+        #ifndef {dname}
+        # define {dname} {sentinel_undef}
+        #endif
+        {delim_start}{dname}{delim_end}'''
+        args = self.build_wrapper_args(env, extra_args, dependencies,
+                                       mode=CompileCheckMode.PREPROCESS).to_native()
+        func = functools.partial(self.cached_compile, code, env.coredata, extra_args=args, mode=CompileCheckMode.PREPROCESS)
+        if disable_cache:
+            func = functools.partial(self.compile, code, extra_args=args, mode=CompileCheckMode.PREPROCESS)
+        with func() as p:
+            cached = p.cached
+            if p.returncode != 0:
+                raise mesonlib.EnvironmentException(f'Could not get define {dname!r}')
+
+        # Get the preprocessed value between the delimiters
+        star_idx = p.stdout.find(delim_start)
+        end_idx = p.stdout.rfind(delim_end)
+        if (star_idx == -1) or (end_idx == -1) or (star_idx == end_idx):
+            raise mesonlib.MesonBugException('Delimiters not found in preprocessor output.')
+        define_value = p.stdout[star_idx + len(delim_start):end_idx]
+
+        if define_value == sentinel_undef:
+            define_value = None
+        else:
+            # Merge string literals
+            define_value = self._concatenate_string_literals(define_value).strip()
+
+        return define_value, cached
+
+    def get_return_value(self, fname: str, rtype: str, prefix: str,
+                         env: 'Environment', extra_args: T.Optional[T.List[str]],
+                         dependencies: T.Optional[T.List['Dependency']]) -> T.Union[str, int]:
+        # TODO: rtype should be an enum.
+        # TODO: maybe we can use overload to tell mypy when this will return int vs str?
+        if rtype == 'string':
+            fmt = '%s'
+            cast = '(char*)'
+        elif rtype == 'int':
+            fmt = '%lli'
+            cast = '(long long int)'
+        else:
+            raise AssertionError(f'BUG: Unknown return type {rtype!r}')
+        code = f'''{prefix}
+        #include <stdio.h>
+        int main(void) {{
+            printf ("{fmt}", {cast} {fname}());
+            return 0;
+        }}'''
+        res = self.run(code, env, extra_args=extra_args, dependencies=dependencies)
+        if not res.compiled:
+            raise mesonlib.EnvironmentException(f'Could not get return value of {fname}()')
+        if rtype == 'string':
+            return res.stdout
+        elif rtype == 'int':
+            try:
+                return int(res.stdout.strip())
+            except ValueError:
+                raise mesonlib.EnvironmentException(f'Return value of {fname}() is not an int')
+        assert False, 'Unreachable'
+
+    @staticmethod
+    def _no_prototype_templ() -> T.Tuple[str, str]:
+        """
+        Try to find the function without a prototype from a header by defining
+        our own dummy prototype and trying to link with the C library (and
+        whatever else the compiler links in by default). This is very similar
+        to the check performed by Autoconf for AC_CHECK_FUNCS.
+        """
+        # Define the symbol to something else since it is defined by the
+        # includes or defines listed by the user or by the compiler. This may
+        # include, for instance _GNU_SOURCE which must be defined before
+        # limits.h, which includes features.h
+        # Then, undef the symbol to get rid of it completely.
+        head = '''
+        #define {func} meson_disable_define_of_{func}
+        {prefix}
+        #include <limits.h>
+        #undef {func}
+        '''
+        # Override any GCC internal prototype and declare our own definition for
+        # the symbol. Use char because that's unlikely to be an actual return
+        # value for a function which ensures that we override the definition.
+        head += '''
+        #ifdef __cplusplus
+        extern "C"
+        #endif
+        char {func} (void);
+        '''
+        # The actual function call
+        main = '''
+        int main(void) {{
+          return {func} ();
+        }}'''
+        return head, main
+
+    @staticmethod
+    def _have_prototype_templ() -> T.Tuple[str, str]:
+        """
+        Returns a head-er and main() call that uses the headers listed by the
+        user for the function prototype while checking if a function exists.
+        """
+        # Add the 'prefix', aka defines, includes, etc that the user provides
+        # This may include, for instance _GNU_SOURCE which must be defined
+        # before limits.h, which includes features.h
+        head = '{prefix}\n#include <limits.h>\n'
+        # We don't know what the function takes or returns, so return it as an int.
+        # Just taking the address or comparing it to void is not enough because
+        # compilers are smart enough to optimize it away. The resulting binary
+        # is not run so we don't care what the return value is.
+        main = '''\nint main(void) {{
+            void *a = (void*) &{func};
+            long long b = (long long) a;
+            return (int) b;
+        }}'''
+        return head, main
+
+    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]:
+        """Determine if a function exists.
+
+        First, this function looks for the symbol in the default libraries
+        provided by the compiler (stdlib + a few others usually). If that
+        fails, it checks if any of the headers specified in the prefix provide
+        an implementation of the function, and if that fails, it checks if it's
+        implemented as a compiler-builtin.
+        """
+        if extra_args is None:
+            extra_args = []
+
+        # Short-circuit if the check is already provided by the cross-info file
+        varname = 'has function ' + funcname
+        varname = varname.replace(' ', '_')
+        if self.is_cross:
+            val = env.properties.host.get(varname, None)
+            if val is not None:
+                if isinstance(val, bool):
+                    return val, False
+                raise mesonlib.EnvironmentException(f'Cross variable {varname} is not a boolean.')
+
+        # TODO: we really need a protocol for this,
+        #
+        # class StrProto(typing.Protocol):
+        #    def __str__(self) -> str: ...
+        fargs: T.Dict[str, T.Union[str, bool, int]] = {'prefix': prefix, 'func': funcname}
+
+        # glibc defines functions that are not available on Linux as stubs that
+        # fail with ENOSYS (such as e.g. lchmod). In this case we want to fail
+        # instead of detecting the stub as a valid symbol.
+        # We already included limits.h earlier to ensure that these are defined
+        # for stub functions.
+        stubs_fail = '''
+        #if defined __stub_{func} || defined __stub___{func}
+        fail fail fail this function is not going to work
+        #endif
+        '''
+
+        # If we have any includes in the prefix supplied by the user, assume
+        # that the user wants us to use the symbol prototype defined in those
+        # includes. If not, then try to do the Autoconf-style check with
+        # a dummy prototype definition of our own.
+        # This is needed when the linker determines symbol availability from an
+        # SDK based on the prototype in the header provided by the SDK.
+        # Ignoring this prototype would result in the symbol always being
+        # marked as available.
+        if '#include' in prefix:
+            head, main = self._have_prototype_templ()
+        else:
+            head, main = self._no_prototype_templ()
+        templ = head + stubs_fail + main + '\n'
+
+        res, cached = self.links(templ.format(**fargs), env, extra_args=extra_args,
+                                 dependencies=dependencies)
+        if res:
+            return True, cached
+
+        # MSVC does not have compiler __builtin_-s.
+        if self.get_id() in {'msvc', 'intel-cl'}:
+            return False, False
+
+        # Detect function as a built-in
+        #
+        # Some functions like alloca() are defined as compiler built-ins which
+        # are inlined by the compiler and you can't take their address, so we
+        # need to look for them differently. On nice compilers like clang, we
+        # can just directly use the __has_builtin() macro.
+        fargs['no_includes'] = '#include' not in prefix
+        is_builtin = funcname.startswith('__builtin_')
+        fargs['is_builtin'] = is_builtin
+        fargs['__builtin_'] = '' if is_builtin else '__builtin_'
+        t = '''{prefix}
+        int main(void) {{
+
+        /* With some toolchains (MSYS2/mingw for example) the compiler
+         * provides various builtins which are not really implemented and
+         * fall back to the stdlib where they aren't provided and fail at
+         * build/link time. In case the user provides a header, including
+         * the header didn't lead to the function being defined, and the
+         * function we are checking isn't a builtin itself we assume the
+         * builtin is not functional and we just error out. */
+        #if !{no_includes:d} && !defined({func}) && !{is_builtin:d}
+            #error "No definition for {__builtin_}{func} found in the prefix"
+        #endif
+
+        #ifdef __has_builtin
+            #if !__has_builtin({__builtin_}{func})
+                #error "{__builtin_}{func} not found"
+            #endif
+        #elif ! defined({func})
+            {__builtin_}{func};
+        #endif
+        return 0;
+        }}\n'''
+        return self.links(t.format(**fargs), env, extra_args=extra_args,
+                          dependencies=dependencies)
+
+    def has_members(self, typename: str, membernames: T.List[str],
+                    prefix: str, env: 'Environment', *,
+                    extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+                    dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+        if extra_args is None:
+            extra_args = []
+        # Create code that accesses all members
+        members = ''.join(f'foo.{member};\n' for member in membernames)
+        t = f'''{prefix}
+        void bar(void) {{
+            {typename} foo;
+            {members}
+        }}\n'''
+        return self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)
+
+    def has_type(self, typename: str, prefix: str, env: 'Environment',
+                 extra_args: T.Union[T.List[str], T.Callable[[CompileCheckMode], T.List[str]]], *,
+                 dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+        t = f'''{prefix}
+        void bar(void) {{
+            sizeof({typename});
+        }}\n'''
+        return self.compiles(t, env, extra_args=extra_args,
+                             dependencies=dependencies)
+
+    def _symbols_have_underscore_prefix_searchbin(self, env: 'Environment') -> bool:
+        '''
+        Check if symbols have underscore prefix by compiling a small test binary
+        and then searching the binary for the string,
+        '''
+        symbol_name = b'meson_uscore_prefix'
+        code = '''#ifdef __cplusplus
+        extern "C" {
+        #endif
+        void ''' + symbol_name.decode() + ''' (void) {}
+        #ifdef __cplusplus
+        }
+        #endif
+        '''
+        args = self.get_compiler_check_args(CompileCheckMode.COMPILE)
+        n = '_symbols_have_underscore_prefix_searchbin'
+        with self._build_wrapper(code, env, extra_args=args, mode=CompileCheckMode.COMPILE, want_output=True) as p:
+            if p.returncode != 0:
+                raise RuntimeError(f'BUG: Unable to compile {n!r} check: {p.stderr}')
+            if not os.path.isfile(p.output_name):
+                raise RuntimeError(f'BUG: Can\'t find compiled test code for {n!r} check')
+            with open(p.output_name, 'rb') as o:
+                for line in o:
+                    # Check if the underscore form of the symbol is somewhere
+                    # in the output file.
+                    if b'_' + symbol_name in line:
+                        mlog.debug("Underscore prefix check found prefixed function in binary")
+                        return True
+                    # Else, check if the non-underscored form is present
+                    elif symbol_name in line:
+                        mlog.debug("Underscore prefix check found non-prefixed function in binary")
+                        return False
+        raise RuntimeError(f'BUG: {n!r} check did not find symbol string in binary')
+
+    def _symbols_have_underscore_prefix_define(self, env: 'Environment') -> T.Optional[bool]:
+        '''
+        Check if symbols have underscore prefix by querying the
+        __USER_LABEL_PREFIX__ define that most compilers provide
+        for this. Return if functions have underscore prefix or None
+        if it was not possible to determine, like when the compiler
+        does not set the define or the define has an unexpected value.
+        '''
+        delim = '"MESON_HAVE_UNDERSCORE_DELIMITER" '
+        code = f'''
+        #ifndef __USER_LABEL_PREFIX__
+        #define MESON_UNDERSCORE_PREFIX unsupported
+        #else
+        #define MESON_UNDERSCORE_PREFIX __USER_LABEL_PREFIX__
+        #endif
+        {delim}MESON_UNDERSCORE_PREFIX
+        '''
+        with self._build_wrapper(code, env, mode=CompileCheckMode.PREPROCESS, want_output=False) as p:
+            if p.returncode != 0:
+                raise RuntimeError(f'BUG: Unable to preprocess _symbols_have_underscore_prefix_define check: {p.stdout}')
+            symbol_prefix = p.stdout.partition(delim)[-1].rstrip()
+
+            mlog.debug(f'Queried compiler for function prefix: __USER_LABEL_PREFIX__ is "{symbol_prefix!s}"')
+            if symbol_prefix == '_':
+                return True
+            elif symbol_prefix == '':
+                return False
+            else:
+                return None
+
+    def _symbols_have_underscore_prefix_list(self, env: 'Environment') -> T.Optional[bool]:
+        '''
+        Check if symbols have underscore prefix by consulting a hardcoded
+        list of cases where we know the results.
+        Return if functions have underscore prefix or None if unknown.
+        '''
+        m = env.machines[self.for_machine]
+        # Darwin always uses the underscore prefix, not matter what
+        if m.is_darwin():
+            return True
+        # Windows uses the underscore prefix on x86 (32bit) only
+        if m.is_windows() or m.is_cygwin():
+            return m.cpu_family == 'x86'
+        return None
+
+    def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
+        '''
+        Check if the compiler prefixes an underscore to global C symbols
+        '''
+        # First, try to query the compiler directly
+        result = self._symbols_have_underscore_prefix_define(env)
+        if result is not None:
+            return result
+
+        # Else, try to consult a hardcoded list of cases we know
+        # absolutely have an underscore prefix
+        result = self._symbols_have_underscore_prefix_list(env)
+        if result is not None:
+            return result
+
+        # As a last resort, try search in a compiled binary, which is the
+        # most unreliable way of checking this, see #5482
+        return self._symbols_have_underscore_prefix_searchbin(env)
+
+    def _get_patterns(self, env: 'Environment', prefixes: T.List[str], suffixes: T.List[str], shared: bool = False) -> T.List[str]:
+        patterns: T.List[str] = []
+        for p in prefixes:
+            for s in suffixes:
+                patterns.append(p + '{}.' + s)
+        if shared and env.machines[self.for_machine].is_openbsd():
+            # Shared libraries on OpenBSD can be named libfoo.so.X.Y:
+            # https://www.openbsd.org/faq/ports/specialtopics.html#SharedLibs
+            #
+            # This globbing is probably the best matching we can do since regex
+            # is expensive. It's wrong in many edge cases, but it will match
+            # correctly-named libraries and hopefully no one on OpenBSD names
+            # their files libfoo.so.9a.7b.1.0
+            for p in prefixes:
+                patterns.append(p + '{}.so.[0-9]*.[0-9]*')
+        return patterns
+
+    def get_library_naming(self, env: 'Environment', libtype: LibType, strict: bool = False) -> T.Tuple[str, ...]:
+        '''
+        Get library prefixes and suffixes for the target platform ordered by
+        priority
+        '''
+        stlibext = ['a']
+        # We've always allowed libname to be both `foo` and `libfoo`, and now
+        # people depend on it. Also, some people use prebuilt `foo.so` instead
+        # of `libfoo.so` for unknown reasons, and may also want to create
+        # `foo.so` by setting name_prefix to ''
+        if strict and not isinstance(self, VisualStudioLikeCompiler): # lib prefix is not usually used with msvc
+            prefixes = ['lib']
+        else:
+            prefixes = ['lib', '']
+        # Library suffixes and prefixes
+        if env.machines[self.for_machine].is_darwin():
+            shlibext = ['dylib', 'so']
+        elif env.machines[self.for_machine].is_windows():
+            # FIXME: .lib files can be import or static so we should read the
+            # file, figure out which one it is, and reject the wrong kind.
+            if isinstance(self, VisualStudioLikeCompiler):
+                shlibext = ['lib']
+            else:
+                shlibext = ['dll.a', 'lib', 'dll']
+            # Yep, static libraries can also be foo.lib
+            stlibext += ['lib']
+        elif env.machines[self.for_machine].is_cygwin():
+            shlibext = ['dll', 'dll.a']
+            prefixes = ['cyg'] + prefixes
+        elif self.id.lower() == 'c6000' or self.id.lower() == 'ti':
+            # TI C6000 compiler can use both extensions for static or dynamic libs.
+            stlibext = ['a', 'lib']
+            shlibext = ['dll', 'so']
+        else:
+            # Linux/BSDs
+            shlibext = ['so']
+        # Search priority
+        if libtype is LibType.PREFER_SHARED:
+            patterns = self._get_patterns(env, prefixes, shlibext, True)
+            patterns.extend([x for x in self._get_patterns(env, prefixes, stlibext, False) if x not in patterns])
+        elif libtype is LibType.PREFER_STATIC:
+            patterns = self._get_patterns(env, prefixes, stlibext, False)
+            patterns.extend([x for x in self._get_patterns(env, prefixes, shlibext, True) if x not in patterns])
+        elif libtype is LibType.SHARED:
+            patterns = self._get_patterns(env, prefixes, shlibext, True)
+        else:
+            assert libtype is LibType.STATIC
+            patterns = self._get_patterns(env, prefixes, stlibext, False)
+        return tuple(patterns)
+
+    @staticmethod
+    def _sort_shlibs_openbsd(libs: T.List[str]) -> T.List[str]:
+        def tuple_key(x: str) -> T.Tuple[int, ...]:
+            ver = x.rsplit('.so.', maxsplit=1)[1]
+            return tuple(int(i) for i in ver.split('.'))
+
+        filtered: T.List[str] = []
+        for lib in libs:
+            # Validate file as a shared library of type libfoo.so.X.Y
+            ret = lib.rsplit('.so.', maxsplit=1)
+            if len(ret) != 2:
+                continue
+            try:
+                tuple(int(i) for i in ret[1].split('.'))
+            except ValueError:
+                continue
+            filtered.append(lib)
+        return sorted(filtered, key=tuple_key, reverse=True)
+
+    @classmethod
+    def _get_trials_from_pattern(cls, pattern: str, directory: str, libname: str) -> T.List[Path]:
+        f = Path(directory) / pattern.format(libname)
+        # Globbing for OpenBSD
+        if '*' in pattern:
+            # NOTE: globbing matches directories and broken symlinks
+            # so we have to do an isfile test on it later
+            return [Path(x) for x in cls._sort_shlibs_openbsd(glob.glob(str(f)))]
+        return [f]
+
+    @staticmethod
+    def _get_file_from_list(env: Environment, paths: T.List[Path]) -> T.Optional[Path]:
+        '''
+        We just check whether the library exists. We can't do a link check
+        because the library might have unresolved symbols that require other
+        libraries. On macOS we check if the library matches our target
+        architecture.
+        '''
+        for p in paths:
+            if p.is_file():
+
+                if env.machines.host.is_darwin() and env.machines.build.is_darwin():
+                    # Run `lipo` and check if the library supports the arch we want
+                    archs = mesonlib.darwin_get_object_archs(str(p))
+                    if not archs or env.machines.host.cpu_family not in archs:
+                        mlog.debug(f'Rejected {p}, supports {archs} but need {env.machines.host.cpu_family}')
+                        continue
+
+                return p
+
+        return None
+
+    @functools.lru_cache()
+    def output_is_64bit(self, env: 'Environment') -> bool:
+        '''
+        returns true if the output produced is 64-bit, false if 32-bit
+        '''
+        return self.sizeof('void *', '', env)[0] == 8
+
+    def _find_library_real(self, libname: str, env: 'Environment', extra_dirs: T.List[str], code: str, libtype: LibType, lib_prefix_warning: bool) -> T.Optional[T.List[str]]:
+        # First try if we can just add the library as -l.
+        # Gcc + co seem to prefer builtin lib dirs to -L dirs.
+        # Only try to find std libs if no extra dirs specified.
+        # The built-in search procedure will always favour .so and then always
+        # search for .a. This is only allowed if libtype is LibType.PREFER_SHARED
+        if ((not extra_dirs and libtype is LibType.PREFER_SHARED) or
+                libname in self.internal_libs):
+            cargs = ['-l' + libname]
+            largs = self.get_linker_always_args() + self.get_allow_undefined_link_args()
+            extra_args = cargs + self.linker_to_compiler_args(largs)
+
+            if self.links(code, env, extra_args=extra_args, disable_cache=True)[0]:
+                return cargs
+            # Don't do a manual search for internal libs
+            if libname in self.internal_libs:
+                return None
+        # Not found or we want to use a specific libtype? Try to find the
+        # library file itself.
+        patterns = self.get_library_naming(env, libtype)
+        # try to detect if we are 64-bit or 32-bit. If we can't
+        # detect, we will just skip path validity checks done in
+        # get_library_dirs() call
+        try:
+            if self.output_is_64bit(env):
+                elf_class = 2
+            else:
+                elf_class = 1
+        except (mesonlib.MesonException, KeyError): # TODO evaluate if catching KeyError is wanted here
+            elf_class = 0
+        # Search in the specified dirs, and then in the system libraries
+        for d in itertools.chain(extra_dirs, self.get_library_dirs(env, elf_class)):
+            for p in patterns:
+                trials = self._get_trials_from_pattern(p, d, libname)
+                if not trials:
+                    continue
+                trial = self._get_file_from_list(env, trials)
+                if not trial:
+                    continue
+                if libname.startswith('lib') and trial.name.startswith(libname) and lib_prefix_warning:
+                    mlog.warning(f'find_library({libname!r}) starting in "lib" only works by accident and is not portable')
+                return [trial.as_posix()]
+        return None
+
+    def _find_library_impl(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+                           code: str, libtype: LibType, lib_prefix_warning: bool) -> T.Optional[T.List[str]]:
+        # These libraries are either built-in or invalid
+        if libname in self.ignore_libs:
+            return []
+        if isinstance(extra_dirs, str):
+            extra_dirs = [extra_dirs]
+        key = (tuple(self.exelist), libname, tuple(extra_dirs), code, libtype)
+        if key not in self.find_library_cache:
+            value = self._find_library_real(libname, env, extra_dirs, code, libtype, lib_prefix_warning)
+            self.find_library_cache[key] = value
+        else:
+            value = self.find_library_cache[key]
+        if value is None:
+            return None
+        return value.copy()
+
+    def find_library(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+                     libtype: LibType = LibType.PREFER_SHARED, lib_prefix_warning: bool = True) -> T.Optional[T.List[str]]:
+        code = 'int main(void) { return 0; }\n'
+        return self._find_library_impl(libname, env, extra_dirs, code, libtype, lib_prefix_warning)
+
+    def find_framework_paths(self, env: 'Environment') -> T.List[str]:
+        '''
+        These are usually /Library/Frameworks and /System/Library/Frameworks,
+        unless you select a particular macOS SDK with the -isysroot flag.
+        You can also add to this by setting -F in CFLAGS.
+        '''
+        # TODO: this really needs to be *AppleClang*, not just any clang.
+        if self.id != 'clang':
+            raise mesonlib.MesonException('Cannot find framework path with non-clang compiler')
+        # Construct the compiler command-line
+        commands = self.get_exelist(ccache=False) + ['-v', '-E', '-']
+        commands += self.get_always_args()
+        # Add CFLAGS/CXXFLAGS/OBJCFLAGS/OBJCXXFLAGS from the env
+        commands += env.coredata.get_external_args(self.for_machine, self.language)
+        mlog.debug('Finding framework path by running: ', ' '.join(commands), '\n')
+        os_env = os.environ.copy()
+        os_env['LC_ALL'] = 'C'
+        _, _, stde = mesonlib.Popen_safe(commands, env=os_env, stdin=subprocess.PIPE)
+        paths: T.List[str] = []
+        for line in stde.split('\n'):
+            if '(framework directory)' not in line:
+                continue
+            # line is of the form:
+            # ` /path/to/framework (framework directory)`
+            paths.append(line[:-21].strip())
+        return paths
+
+    def _find_framework_real(self, name: str, env: 'Environment', extra_dirs: T.List[str], allow_system: bool) -> T.Optional[T.List[str]]:
+        code = 'int main(void) { return 0; }'
+        link_args: T.List[str] = []
+        for d in extra_dirs:
+            link_args += ['-F' + d]
+        # We can pass -Z to disable searching in the system frameworks, but
+        # then we must also pass -L/usr/lib to pick up libSystem.dylib
+        extra_args = [] if allow_system else ['-Z', '-L/usr/lib']
+        link_args += ['-framework', name]
+        if self.links(code, env, extra_args=(extra_args + link_args), disable_cache=True)[0]:
+            return link_args
+        return None
+
+    def _find_framework_impl(self, name: str, env: 'Environment', extra_dirs: T.List[str],
+                             allow_system: bool) -> T.Optional[T.List[str]]:
+        if isinstance(extra_dirs, str):
+            extra_dirs = [extra_dirs]
+        key = (tuple(self.exelist), name, tuple(extra_dirs), allow_system)
+        if key in self.find_framework_cache:
+            value = self.find_framework_cache[key]
+        else:
+            value = self._find_framework_real(name, env, extra_dirs, allow_system)
+            self.find_framework_cache[key] = value
+        if value is None:
+            return None
+        return value.copy()
+
+    def find_framework(self, name: str, env: 'Environment', extra_dirs: T.List[str],
+                       allow_system: bool = True) -> T.Optional[T.List[str]]:
+        '''
+        Finds the framework with the specified name, and returns link args for
+        the same or returns None when the framework is not found.
+        '''
+        # TODO: should probably check for macOS?
+        return self._find_framework_impl(name, env, extra_dirs, allow_system)
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        # TODO: does this belong here or in GnuLike or maybe PosixLike?
+        return []
+
+    def get_crt_link_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+        # TODO: does this belong here or in GnuLike or maybe PosixLike?
+        return []
+
+    def thread_flags(self, env: 'Environment') -> T.List[str]:
+        # TODO: does this belong here or in GnuLike or maybe PosixLike?
+        host_m = env.machines[self.for_machine]
+        if host_m.is_haiku() or host_m.is_darwin():
+            return []
+        return ['-pthread']
+
+    def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]:
+        return args.copy()
+
+    def has_arguments(self, args: T.List[str], env: 'Environment', code: str,
+                      mode: CompileCheckMode) -> T.Tuple[bool, bool]:
+        return self.compiles(code, env, extra_args=args, mode=mode)
+
+    def _has_multi_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
+        new_args: T.List[str] = []
+        for arg in args:
+            # some compilers, e.g. GCC, don't warn for unsupported warning-disable
+            # flags, so when we are testing a flag like "-Wno-forgotten-towel", also
+            # check the equivalent enable flag too "-Wforgotten-towel"
+            if arg.startswith('-Wno-'):
+                new_args.append('-W' + arg[5:])
+            if arg.startswith('-Wl,'):
+                mlog.warning(f'{arg} looks like a linker argument, '
+                             'but has_argument and other similar methods only '
+                             'support checking compiler arguments. Using them '
+                             'to check linker arguments are never supported, '
+                             'and results are likely to be wrong regardless of '
+                             'the compiler you are using. has_link_argument or '
+                             'other similar method can be used instead.')
+            new_args.append(arg)
+        return self.has_arguments(new_args, env, code, mode=CompileCheckMode.COMPILE)
+
+    def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return self._has_multi_arguments(args, env, 'extern int i;\nint i;\n')
+
+    def _has_multi_link_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
+        # First time we check for link flags we need to first check if we have
+        # --fatal-warnings, otherwise some linker checks could give some
+        # false positive.
+        args = self.linker.fatal_warnings() + args
+        args = self.linker_to_compiler_args(args)
+        return self.has_arguments(args, env, code, mode=CompileCheckMode.LINK)
+
+    def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+        return self._has_multi_link_arguments(args, env, 'int main(void) { return 0; }\n')
+
+    @staticmethod
+    def _concatenate_string_literals(s: str) -> str:
+        pattern = re.compile(r'(?P<pre>.*([^\\]")|^")(?P<str1>([^\\"]|\\.)*)"\s+"(?P<str2>([^\\"]|\\.)*)(?P<post>".*)')
+        ret = s
+        m = pattern.match(ret)
+        while m:
+            ret = ''.join(m.group('pre', 'str1', 'str2', 'post'))
+            m = pattern.match(ret)
+        return ret
+
+    def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+        # Most compilers (such as GCC and Clang) only warn about unknown or
+        # ignored attributes, so force an error. Overridden in GCC and Clang
+        # mixins.
+        return ['-Werror']
+
+    def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuple[bool, bool]:
+        # Just assume that if we're not on windows that dllimport and dllexport
+        # don't work
+        m = env.machines[self.for_machine]
+        if not (m.is_windows() or m.is_cygwin()):
+            if name in {'dllimport', 'dllexport'}:
+                return False, False
+
+        return self.compiles(self.attribute_check_func(name), env,
+                             extra_args=self.get_has_func_attribute_extra_args(name))
+
+    def get_assert_args(self, disable: bool) -> T.List[str]:
+        if disable:
+            return ['-DNDEBUG']
+        return []
+
+    @functools.lru_cache(maxsize=None)
+    def can_compile(self, src: 'mesonlib.FileOrString') -> bool:
+        # Files we preprocess can be anything, e.g. .in
+        if self.mode == 'PREPROCESSOR':
+            return True
+        return super().can_compile(src)
+
+    def get_preprocessor(self) -> Compiler:
+        if not self.preprocessor:
+            self.preprocessor = copy.copy(self)
+            self.preprocessor.exelist = self.exelist + self.get_preprocess_to_file_args()
+            self.preprocessor.mode = 'PREPROCESSOR'
+            self.modes.append(self.preprocessor)
+        return self.preprocessor