# SPDX-License-Identifier: Apache-2.0 # Copyright 2019 The meson development team # Copyright © 2023 Intel Corporation from __future__ import annotations """Abstractions to simplify compilers that implement an MSVC compatible interface. """ import abc import os import typing as T from ... import arglist from ... import mesonlib from ... import mlog from mesonbuild.compilers.compilers import CompileCheckMode from ...options import OptionKey from mesonbuild.linkers.linkers import ClangClDynamicLinker if T.TYPE_CHECKING: from ...environment import Environment from ...dependencies import Dependency from .clike import CLikeCompiler as 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 vs32_instruction_set_args: T.Dict[str, T.Optional[T.List[str]]] = { 'mmx': ['/arch:SSE'], # There does not seem to be a flag just for MMX 'sse': ['/arch:SSE'], 'sse2': ['/arch:SSE2'], 'sse3': ['/arch:AVX'], # VS leaped from SSE2 directly to AVX. 'sse41': ['/arch:AVX'], 'sse42': ['/arch:AVX'], 'avx': ['/arch:AVX'], 'avx2': ['/arch:AVX2'], 'neon': None, } # The 64 bit compiler defaults to /arch:avx. vs64_instruction_set_args: T.Dict[str, T.Optional[T.List[str]]] = { 'mmx': ['/arch:AVX'], 'sse': ['/arch:AVX'], 'sse2': ['/arch:AVX'], 'sse3': ['/arch:AVX'], 'ssse3': ['/arch:AVX'], 'sse41': ['/arch:AVX'], 'sse42': ['/arch:AVX'], 'avx': ['/arch:AVX'], 'avx2': ['/arch:AVX2'], 'neon': None, } msvc_optimization_args: T.Dict[str, T.List[str]] = { 'plain': [], '0': ['/Od'], 'g': [], # No specific flag to optimize debugging, /Zi or /ZI will create debug information '1': ['/O1'], '2': ['/O2'], '3': ['/O2', '/Gw'], 's': ['/O1', '/Gw'], } msvc_debug_args: T.Dict[bool, T.List[str]] = { False: [], True: ['/Zi'] } class VisualStudioLikeCompiler(Compiler, metaclass=abc.ABCMeta): """A common interface for all compilers implementing an MSVC-style interface. A number of compilers attempt to mimic MSVC, with varying levels of success, such as Clang-CL and ICL (the Intel C/C++ Compiler for Windows). This class implements as much common logic as possible. """ std_warn_args = ['/W3'] std_opt_args = ['/O2'] ignore_libs = arglist.UNIXY_COMPILER_INTERNAL_LIBS + ['execinfo'] internal_libs: T.List[str] = [] crt_args: T.Dict[str, T.List[str]] = { 'none': [], 'md': ['/MD'], 'mdd': ['/MDd'], 'mt': ['/MT'], 'mtd': ['/MTd'], } # /showIncludes is needed for build dependency tracking in Ninja # See: https://ninja-build.org/manual.html#_deps # Assume UTF-8 sources by default, but self.unix_args_to_native() removes it # if `/source-charset` is set too. # It is also dropped if Visual Studio 2013 or earlier is used, since it would # not be supported in that case. always_args = ['/nologo', '/showIncludes', '/utf-8'] warn_args: T.Dict[str, T.List[str]] = { '0': [], '1': ['/W2'], '2': ['/W3'], '3': ['/W4'], 'everything': ['/Wall'], } INVOKES_LINKER = False def __init__(self, target: str): self.base_options = {OptionKey(o) for o in ['b_pch', 'b_ndebug', 'b_vscrt']} # FIXME add lto, pgo and the like self.target = target self.is_64 = ('x64' in target) or ('x86_64' in target) # do some canonicalization of target machine if 'x86_64' in target: self.machine = 'x64' elif '86' in target: self.machine = 'x86' elif 'aarch64' in target: self.machine = 'arm64' elif 'arm' in target: self.machine = 'arm' else: self.machine = target if mesonlib.version_compare(self.version, '>=19.28.29910'): # VS 16.9.0 includes cl 19.28.29910 self.base_options.add(OptionKey('b_sanitize')) assert self.linker is not None self.linker.machine = self.machine # Override CCompiler.get_always_args def get_always_args(self) -> T.List[str]: # TODO: use ImmutableListProtocol[str] here instead return self.always_args.copy() def get_pch_suffix(self) -> str: return 'pch' def get_pch_name(self, name: str) -> str: chopped = os.path.basename(name).split('.')[:-1] chopped.append(self.get_pch_suffix()) pchname = '.'.join(chopped) return pchname def get_pch_base_name(self, header: str) -> str: # This needs to be implemented by inheriting classes raise NotImplementedError def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]: base = self.get_pch_base_name(header) pchname = self.get_pch_name(header) return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)] def get_preprocess_only_args(self) -> T.List[str]: return ['/EP'] def get_preprocess_to_file_args(self) -> T.List[str]: return ['/EP', '/P'] def get_compile_only_args(self) -> T.List[str]: return ['/c'] def get_no_optimization_args(self) -> T.List[str]: return ['/Od', '/Oi-'] def sanitizer_compile_args(self, value: T.List[str]) -> T.List[str]: if not value: return value return [f'/fsanitize={",".join(value)}'] def get_output_args(self, outputname: str) -> T.List[str]: if self.mode == 'PREPROCESSOR': return ['/Fi' + outputname] if outputname.endswith('.exe'): return ['/Fe' + outputname] return ['/Fo' + outputname] def get_debug_args(self, is_debug: bool) -> T.List[str]: return msvc_debug_args[is_debug] def get_optimization_args(self, optimization_level: str) -> T.List[str]: args = msvc_optimization_args[optimization_level] if mesonlib.version_compare(self.version, '<18.0'): args = [arg for arg in args if arg != '/Gw'] return args def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]: return ['/link'] + args def get_pic_args(self) -> T.List[str]: return [] # PIC is handled by the loader on Windows def gen_vs_module_defs_args(self, defsfile: str) -> T.List[str]: if not isinstance(defsfile, str): raise RuntimeError('Module definitions file should be str') # With MSVC, DLLs only export symbols that are explicitly exported, # so if a module defs file is specified, we use that to export symbols return ['/DEF:' + defsfile] def gen_pch_args(self, header: str, source: str, pchname: str) -> T.Tuple[str, T.List[str]]: objname = os.path.splitext(source)[0] + '.obj' return objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname] def openmp_flags(self, env: Environment) -> T.List[str]: return ['/openmp'] def openmp_link_flags(self, env: Environment) -> T.List[str]: return [] # FIXME, no idea what these should be. def thread_flags(self, env: 'Environment') -> T.List[str]: return [] @classmethod def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]: result: T.List[str] = [] for i in args: # -mms-bitfields is specific to MinGW-GCC # -pthread is only valid for GCC if i in {'-mms-bitfields', '-pthread'}: continue if i.startswith('-LIBPATH:'): i = '/LIBPATH:' + i[9:] elif i.startswith('-L'): i = '/LIBPATH:' + i[2:] # Translate GNU-style -lfoo library name to the import library elif i.startswith('-l'): name = i[2:] if name in cls.ignore_libs: # With MSVC, these are provided by the C runtime which is # linked in by default continue else: i = name + '.lib' elif i.startswith('-isystem'): # just use /I for -isystem system include path s if i.startswith('-isystem='): i = '/I' + i[9:] else: i = '/I' + i[8:] elif i.startswith('-idirafter'): # same as -isystem, but appends the path instead if i.startswith('-idirafter='): i = '/I' + i[11:] else: i = '/I' + i[10:] # -pthread in link flags is only used on Linux elif i == '-pthread': continue # cl.exe does not allow specifying both, so remove /utf-8 that we # added automatically in the case the user overrides it manually. elif (i.startswith('/source-charset:') or i.startswith('/execution-charset:') or i == '/validate-charset-'): try: result.remove('/utf-8') except ValueError: pass result.append(i) return result @classmethod def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]: result: T.List[str] = [] for arg in args: if arg.startswith(('/LIBPATH:', '-LIBPATH:')): result.append('-L' + arg[9:]) elif arg.endswith(('.a', '.lib')) and not os.path.isabs(arg): result.append('-l' + arg) else: result.append(arg) return result def get_werror_args(self) -> T.List[str]: return ['/WX'] def get_include_args(self, path: str, is_system: bool) -> T.List[str]: if path == '': path = '.' # msvc does not have a concept of system header dirs. return ['-I' + path] 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] == '/I': parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:])) elif i[:9] == '/LIBPATH:': parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:])) return parameter_list # Visual Studio is special. It ignores some arguments it does not # understand and you can't tell it to error out on those. # http://stackoverflow.com/questions/15259720/how-can-i-make-the-microsoft-c-compiler-treat-unknown-flags-as-errors-rather-t def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: CompileCheckMode) -> T.Tuple[bool, bool]: warning_text = '4044' if mode == CompileCheckMode.LINK else '9002' with self._build_wrapper(code, env, extra_args=args, mode=mode) as p: if p.returncode != 0: return False, p.cached return not (warning_text in p.stderr or warning_text in p.stdout), p.cached def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]: pdbarr = rel_obj.split('.')[:-1] pdbarr += ['pdb'] args = ['/Fd' + '.'.join(pdbarr)] return args def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: if self.is_64: return vs64_instruction_set_args.get(instruction_set, None) return vs32_instruction_set_args.get(instruction_set, None) def _calculate_toolset_version(self, version: int) -> T.Optional[str]: if version < 1310: return '7.0' elif version < 1400: return '7.1' # (Visual Studio 2003) elif version < 1500: return '8.0' # (Visual Studio 2005) elif version < 1600: return '9.0' # (Visual Studio 2008) elif version < 1700: return '10.0' # (Visual Studio 2010) elif version < 1800: return '11.0' # (Visual Studio 2012) elif version < 1900: return '12.0' # (Visual Studio 2013) elif version < 1910: return '14.0' # (Visual Studio 2015) elif version < 1920: return '14.1' # (Visual Studio 2017) elif version < 1930: return '14.2' # (Visual Studio 2019) elif version < 1940: return '14.3' # (Visual Studio 2022) elif version < 1950: return '14.4' # (Visual Studio current preview version, might not be final) mlog.warning(f'Could not find toolset for version {self.version!r}') return None def get_toolset_version(self) -> T.Optional[str]: # See boost/config/compiler/visualc.cpp for up to date mapping try: version = int(''.join(self.version.split('.')[0:2])) except ValueError: return None return self._calculate_toolset_version(version) def get_default_include_dirs(self) -> T.List[str]: if 'INCLUDE' not in os.environ: return [] return os.environ['INCLUDE'].split(os.pathsep) def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]: crt_val = self.get_crt_val(crt_val, buildtype) return self.crt_args[crt_val] def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuple[bool, bool]: # MSVC doesn't have __attribute__ like Clang and GCC do, so just return # false without compiling anything return name in {'dllimport', 'dllexport'}, False @staticmethod def get_argument_syntax() -> str: return 'msvc' def symbols_have_underscore_prefix(self, env: 'Environment') -> bool: ''' Check if the compiler prefixes an underscore to global C symbols. This overrides the Clike method, as for MSVC checking the underscore prefix based on the compiler define never works, so do not even try. ''' # 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 return self._symbols_have_underscore_prefix_searchbin(env) def get_pie_args(self) -> T.List[str]: return [] class MSVCCompiler(VisualStudioLikeCompiler): """Specific to the Microsoft Compilers.""" id = 'msvc' def __init__(self, target: str): super().__init__(target) # Visual Studio 2013 and earlier don't support the /utf-8 argument. # We want to remove it. We also want to make an explicit copy so we # don't mutate class constant state if mesonlib.version_compare(self.version, '<19.00') and '/utf-8' in self.always_args: self.always_args = [r for r in self.always_args if r != '/utf-8'] def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]: args = super().get_compile_debugfile_args(rel_obj, pch) # When generating a PDB file with PCH, all compile commands write # to the same PDB file. Hence, we need to serialize the PDB # writes using /FS since we do parallel builds. This slows down the # build obviously, which is why we only do this when PCH is on. # This was added in Visual Studio 2013 (MSVC 18.0). Before that it was # always on: https://msdn.microsoft.com/en-us/library/dn502518.aspx if pch and mesonlib.version_compare(self.version, '>=18.0'): args = ['/FS'] + args return args # Override CCompiler.get_always_args # We want to drop '/utf-8' for Visual Studio 2013 and earlier def get_always_args(self) -> T.List[str]: return self.always_args def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: if self.version.split('.')[0] == '16' and instruction_set == 'avx': # VS documentation says that this exists and should work, but # it does not. The headers do not contain AVX intrinsics # and they cannot be called. return None return super().get_instruction_set_args(instruction_set) def get_pch_base_name(self, header: str) -> str: return os.path.basename(header) # MSVC requires linking to the generated object file when linking a build target # that uses a precompiled header def should_link_pch_object(self) -> bool: return True class ClangClCompiler(VisualStudioLikeCompiler): """Specific to Clang-CL.""" id = 'clang-cl' def __init__(self, target: str): super().__init__(target) self.base_options.update( {OptionKey('b_lto_threads'), OptionKey('b_lto'), OptionKey('b_lto_mode'), OptionKey('b_thinlto_cache'), OptionKey('b_thinlto_cache_dir')}) # Assembly self.can_compile_suffixes.add('s') self.can_compile_suffixes.add('sx') def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: CompileCheckMode) -> T.Tuple[bool, bool]: if mode != CompileCheckMode.LINK: args = args + ['-Werror=unknown-argument', '-Werror=unknown-warning-option'] return super().has_arguments(args, env, code, mode) def get_toolset_version(self) -> T.Optional[str]: # XXX: what is the right thing to do here? return '14.1' def get_pch_base_name(self, header: str) -> str: return header def get_include_args(self, path: str, is_system: bool) -> T.List[str]: if path == '': path = '.' return ['/clang:-isystem' + path] if is_system else ['-I' + path] @classmethod def use_linker_args(cls, linker: str, version: str) -> T.List[str]: # Clang additionally can use a linker specified as a path, unlike MSVC. if linker == 'lld-link': return ['-fuse-ld=lld-link'] return super().use_linker_args(linker, version) def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]: # clang-cl forwards arguments span-wise with the /LINK flag # therefore -Wl will be received by lld-link or LINK and rejected return super().use_linker_args(self.linker.id, '') + super().linker_to_compiler_args([flag[4:] if flag.startswith('-Wl,') else flag for flag in args]) def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]: if dep.get_include_type() == 'system': converted: T.List[str] = [] for i in dep.get_compile_args(): if i.startswith('-isystem'): converted += ['/clang:' + i] else: converted += [i] return converted else: return dep.get_compile_args() def openmp_link_flags(self, env: Environment) -> T.List[str]: # see https://github.com/mesonbuild/meson/issues/5298 libs = self.find_library('libomp', env, []) if libs is None: raise mesonlib.MesonBugException('Could not find libomp') return super().openmp_link_flags(env) + libs def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]: args: T.List[str] = [] if mode == 'thin': # LTO data generated by clang-cl is only usable by lld-link if not isinstance(self.linker, ClangClDynamicLinker): raise mesonlib.MesonException(f"LLVM's ThinLTO only works with lld-link, not {self.linker.id}") args.append(f'-flto={mode}') else: assert mode == 'default', 'someone forgot to wire something up' args.extend(super().get_lto_compile_args(threads=threads)) return args def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default', thinlto_cache_dir: T.Optional[str] = None) -> T.List[str]: args = [] if mode == 'thin' and thinlto_cache_dir is not None: args.extend(self.linker.get_thinlto_cache_args(thinlto_cache_dir)) # lld-link /threads:N has the same behaviour as -flto-jobs=N in lld if threads > 0: # clang-cl was released after clang already had LTO support, so it # is safe to assume that all versions of clang-cl support LTO args.append(f'/threads:{threads}') return args