# SPDX-License-Identifier: Apache-2.0 # Copyright 2019-2022 The meson development team # Copyright © 2023-2025 Intel Corporation from __future__ import annotations """Provides mixins for GNU compilers and GNU-like compilers.""" import abc import functools import os import pathlib import re import subprocess import typing as T from ... import mesonlib from ... import mlog from ...options import OptionKey, UserStdOption from mesonbuild.compilers.compilers import CompileCheckMode if T.TYPE_CHECKING: from ..._typing import ImmutableListProtocol from ...options import MutableKeyedOptionDictType from ...environment import Environment from ..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 # XXX: prevent circular references. # FIXME: this really is a posix interface not a c-like interface clike_debug_args: T.Dict[bool, T.List[str]] = { False: [], True: ['-g'], } gnu_optimization_args: T.Dict[str, T.List[str]] = { 'plain': [], '0': ['-O0'], 'g': ['-Og'], '1': ['-O1'], '2': ['-O2'], '3': ['-O3'], 's': ['-Os'], } gnulike_instruction_set_args: T.Dict[str, T.List[str]] = { 'mmx': ['-mmmx'], 'sse': ['-msse'], 'sse2': ['-msse2'], 'sse3': ['-msse3'], 'ssse3': ['-mssse3'], 'sse41': ['-msse4.1'], 'sse42': ['-msse4.2'], 'avx': ['-mavx'], 'avx2': ['-mavx2'], 'neon': ['-mfpu=neon'], } gnu_symbol_visibility_args: T.Dict[str, T.List[str]] = { '': [], 'default': ['-fvisibility=default'], 'internal': ['-fvisibility=internal'], 'hidden': ['-fvisibility=hidden'], 'protected': ['-fvisibility=protected'], 'inlineshidden': ['-fvisibility=hidden', '-fvisibility-inlines-hidden'], } gnu_color_args: T.Dict[str, T.List[str]] = { 'auto': ['-fdiagnostics-color=auto'], 'always': ['-fdiagnostics-color=always'], 'never': ['-fdiagnostics-color=never'], } # Warnings collected from the GCC source and documentation. This is an # objective set of all the warnings flags that apply to general projects: the # only ones omitted are those that require a project-specific value, or are # related to non-standard or legacy language support. This behaves roughly # like -Weverything in clang. Warnings implied by -Wall, -Wextra, or # higher-level warnings already enabled here are not included in these lists to # keep them as short as possible. History goes back to GCC 3.0.0, everything # earlier is considered historical and listed under version 0.0.0. # GCC warnings for all C-family languages # Omitted non-general warnings: # -Wabi= # -Waggregate-return # -Walloc-size-larger-than=BYTES # -Walloca-larger-than=BYTES # -Wframe-larger-than=BYTES # -Wlarger-than=BYTES # -Wstack-usage=BYTES # -Wsystem-headers # -Wtrampolines # -Wvla-larger-than=BYTES # # Omitted warnings enabled elsewhere in meson: # -Winvalid-pch (GCC 3.4.0) gnu_common_warning_args: T.Dict[str, T.List[str]] = { "0.0.0": [ "-Wcast-qual", "-Wconversion", "-Wfloat-equal", "-Wformat=2", "-Winline", "-Wmissing-declarations", "-Wredundant-decls", "-Wshadow", "-Wundef", "-Wuninitialized", "-Wwrite-strings", ], "3.0.0": [ "-Wdisabled-optimization", "-Wpacked", "-Wpadded", ], "3.3.0": [ "-Wmultichar", "-Wswitch-default", "-Wswitch-enum", "-Wunused-macros", ], "4.0.0": [ "-Wmissing-include-dirs", ], "4.1.0": [ "-Wunsafe-loop-optimizations", "-Wstack-protector", ], "4.2.0": [ "-Wstrict-overflow=5", ], "4.3.0": [ "-Warray-bounds=2", "-Wlogical-op", "-Wstrict-aliasing=3", "-Wvla", ], "4.6.0": [ "-Wdouble-promotion", "-Wsuggest-attribute=const", "-Wsuggest-attribute=noreturn", "-Wsuggest-attribute=pure", "-Wtrampolines", ], "4.7.0": [ "-Wvector-operation-performance", ], "4.8.0": [ "-Wsuggest-attribute=format", ], "4.9.0": [ "-Wdate-time", ], "5.1.0": [ "-Wformat-signedness", "-Wnormalized=nfc", ], "6.1.0": [ "-Wduplicated-cond", "-Wnull-dereference", "-Wshift-negative-value", "-Wshift-overflow=2", "-Wunused-const-variable=2", ], "7.1.0": [ "-Walloca", "-Walloc-zero", "-Wformat-overflow=2", "-Wformat-truncation=2", "-Wstringop-overflow=3", ], "7.2.0": [ "-Wduplicated-branches", ], "8.1.0": [ "-Wcast-align=strict", "-Wsuggest-attribute=cold", "-Wsuggest-attribute=malloc", ], "9.1.0": [ "-Wattribute-alias=2", ], "10.1.0": [ "-Wanalyzer-too-complex", "-Warith-conversion", ], "12.1.0": [ "-Wbidi-chars=ucn", "-Wopenacc-parallelism", "-Wtrivial-auto-var-init", ], } # GCC warnings for C # Omitted non-general or legacy warnings: # -Wc11-c2x-compat # -Wc90-c99-compat # -Wc99-c11-compat # -Wdeclaration-after-statement # -Wtraditional # -Wtraditional-conversion # -Wunsuffixed-float-constants gnu_c_warning_args: T.Dict[str, T.List[str]] = { "0.0.0": [ "-Wbad-function-cast", "-Wmissing-prototypes", "-Wnested-externs", "-Wstrict-prototypes", ], "3.4.0": [ "-Wold-style-definition", "-Winit-self", ], "4.1.0": [ "-Wc++-compat", ], } # GCC warnings for C++ # Omitted non-general or legacy warnings: # -Wc++0x-compat # -Wc++1z-compat # -Wc++2a-compat # -Wctad-maybe-unsupported # -Wnamespaces # -Wtemplates gnu_cpp_warning_args: T.Dict[str, T.List[str]] = { "0.0.0": [ "-Wctor-dtor-privacy", "-Weffc++", "-Wnon-virtual-dtor", "-Wold-style-cast", "-Woverloaded-virtual", "-Wsign-promo", ], "4.0.1": [ "-Wstrict-null-sentinel", ], "4.6.0": [ "-Wnoexcept", ], "4.7.0": [ "-Wzero-as-null-pointer-constant", ], "4.8.0": [ "-Wabi-tag", "-Wuseless-cast", ], "4.9.0": [ "-Wconditionally-supported", ], "5.1.0": [ "-Wsuggest-final-methods", "-Wsuggest-final-types", "-Wsuggest-override", ], "6.1.0": [ "-Wmultiple-inheritance", "-Wplacement-new=2", "-Wvirtual-inheritance", ], "7.1.0": [ "-Waligned-new=all", "-Wnoexcept-type", "-Wregister", ], "8.1.0": [ "-Wcatch-value=3", "-Wextra-semi", ], "9.1.0": [ "-Wdeprecated-copy-dtor", "-Wredundant-move", ], "10.1.0": [ "-Wcomma-subscript", "-Wmismatched-tags", "-Wredundant-tags", "-Wvolatile", ], "11.1.0": [ "-Wdeprecated-enum-enum-conversion", "-Wdeprecated-enum-float-conversion", "-Winvalid-imported-macros", ], } # GCC warnings for Objective C and Objective C++ # Omitted non-general or legacy warnings: # -Wtraditional # -Wtraditional-conversion gnu_objc_warning_args: T.Dict[str, T.List[str]] = { "0.0.0": [ "-Wselector", ], "3.3": [ "-Wundeclared-selector", ], "4.1.0": [ "-Wassign-intercept", "-Wstrict-selector-match", ], } gnu_lang_map = { 'c': 'c', 'cpp': 'c++', 'objc': 'objective-c', 'objcpp': 'objective-c++' } @functools.lru_cache(maxsize=None) def gnulike_default_include_dirs(compiler: T.Tuple[str, ...], lang: str) -> 'ImmutableListProtocol[str]': if lang not in gnu_lang_map: return [] lang = gnu_lang_map[lang] env = os.environ.copy() env["LC_ALL"] = 'C' cmd = list(compiler) + [f'-x{lang}', '-E', '-v', '-'] _, stdout, _ = mesonlib.Popen_safe(cmd, stderr=subprocess.STDOUT, env=env) parse_state = 0 paths: T.List[str] = [] for line in stdout.split('\n'): line = line.strip(' \n\r\t') if parse_state == 0: if line == '#include "..." search starts here:': parse_state = 1 elif parse_state == 1: if line == '#include <...> search starts here:': parse_state = 2 else: paths.append(line) elif parse_state == 2: if line == 'End of search list.': break else: paths.append(line) if not paths: mlog.warning('No include directory found parsing "{cmd}" output'.format(cmd=" ".join(cmd))) # Append a normalized copy of paths to make path lookup easier paths += [os.path.normpath(x) for x in paths] return paths class GnuLikeCompiler(Compiler, metaclass=abc.ABCMeta): """ GnuLikeCompiler is a common interface to all compilers implementing the GNU-style commandline interface. This includes GCC, Clang and ICC. Certain functionality between them is different and requires that the actual concrete subclass define their own implementation. """ LINKER_PREFIX = '-Wl,' def __init__(self) -> None: self.base_options = { OptionKey(o) for o in ['b_pch', 'b_lto', 'b_pgo', 'b_coverage', 'b_ndebug', 'b_staticpic', 'b_pie']} if not (self.info.is_windows() or self.info.is_cygwin() or self.info.is_openbsd()): self.base_options.add(OptionKey('b_lundef')) if not self.info.is_windows() or self.info.is_cygwin(): self.base_options.add(OptionKey('b_asneeded')) if not self.info.is_hurd(): self.base_options.add(OptionKey('b_sanitize')) # All GCC-like backends can do assembly self.can_compile_suffixes.add('s') self.can_compile_suffixes.add('sx') def get_pic_args(self) -> T.List[str]: if self.info.is_windows() or self.info.is_cygwin() or self.info.is_darwin(): return [] # On Window and OS X, pic is always on. return ['-fPIC'] def get_pie_args(self) -> T.List[str]: return ['-fPIE'] @abc.abstractmethod def get_optimization_args(self, optimization_level: str) -> T.List[str]: pass def get_debug_args(self, is_debug: bool) -> T.List[str]: return clike_debug_args[is_debug] @abc.abstractmethod def get_pch_suffix(self) -> str: pass def split_shlib_to_parts(self, fname: str) -> T.Tuple[str, str]: return os.path.dirname(fname), fname def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: return gnulike_instruction_set_args.get(instruction_set, None) def get_default_include_dirs(self) -> T.List[str]: return gnulike_default_include_dirs(tuple(self.get_exelist(ccache=False)), self.language).copy() @abc.abstractmethod def openmp_flags(self, env: Environment) -> T.List[str]: pass def gnu_symbol_visibility_args(self, vistype: str) -> T.List[str]: if vistype == 'inlineshidden' and self.language not in {'cpp', 'objcpp'}: vistype = 'hidden' return gnu_symbol_visibility_args[vistype] 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') # On Windows targets, .def files may be specified on the linker command # line like an object file. if self.info.is_windows() or self.info.is_cygwin(): return [defsfile] # For other targets, discard the .def file. return [] @staticmethod def get_argument_syntax() -> str: return 'gcc' def get_profile_generate_args(self) -> T.List[str]: return ['-fprofile-generate'] def get_profile_use_args(self) -> T.List[str]: return ['-fprofile-use'] 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 @functools.lru_cache() def _get_search_dirs(self, env: 'Environment') -> str: extra_args = ['--print-search-dirs'] with self._build_wrapper('', env, extra_args=extra_args, dependencies=None, mode=CompileCheckMode.COMPILE, want_output=True) as p: return p.stdout def _split_fetch_real_dirs(self, pathstr: str) -> T.List[str]: # We need to use the path separator used by the compiler for printing # lists of paths ("gcc --print-search-dirs"). By default # we assume it uses the platform native separator. pathsep = os.pathsep # clang uses ':' instead of ';' on Windows https://reviews.llvm.org/D61121 # so we need to repair things like 'C:\foo:C:\bar' if pathsep == ';': pathstr = re.sub(r':([^/\\])', r';\1', pathstr) # pathlib treats empty paths as '.', so filter those out paths = [p for p in pathstr.split(pathsep) if p] result: T.List[str] = [] for p in paths: # GCC returns paths like this: # /usr/lib/gcc/x86_64-linux-gnu/8/../../../../x86_64-linux-gnu/lib # It would make sense to normalize them to get rid of the .. parts # Sadly when you are on a merged /usr fs it also kills these: # /lib/x86_64-linux-gnu # since /lib is a symlink to /usr/lib. This would mean # paths under /lib would be considered not a "system path", # which is wrong and breaks things. Store everything, just to be sure. pobj = pathlib.Path(p) if pobj.exists(): try: resolved = pobj.resolve(True).as_posix() if resolved not in result: result.append(resolved) except FileNotFoundError: pass unresolved = pobj.as_posix() if unresolved not in result: result.append(unresolved) return result def get_compiler_dirs(self, env: 'Environment', name: str) -> T.List[str]: ''' Get dirs from the compiler, either `libraries:` or `programs:` ''' stdo = self._get_search_dirs(env) for line in stdo.split('\n'): if line.startswith(name + ':'): return self._split_fetch_real_dirs(line.split('=', 1)[1]) return [] def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]: # This provides a base for many compilers, GCC and Clang override this # for their specific arguments return ['-flto'] def sanitizer_compile_args(self, value: T.List[str]) -> T.List[str]: if not value: return value args = ['-fsanitize=' + ','.join(value)] if 'address' in value: args.append('-fno-omit-frame-pointer') return args def get_output_args(self, outputname: str) -> T.List[str]: return ['-o', outputname] def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]: return ['-MD', '-MQ', outtarget, '-MF', outfile] def get_compile_only_args(self) -> T.List[str]: return ['-c'] def get_include_args(self, path: str, is_system: bool) -> T.List[str]: if not path: path = '.' if is_system: return ['-isystem' + path] return ['-I' + path] @classmethod def use_linker_args(cls, linker: str, version: str) -> T.List[str]: if linker not in {'gold', 'bfd', 'lld'}: raise mesonlib.MesonException( f'Unsupported linker, only bfd, gold, and lld are supported, not {linker}.') return [f'-fuse-ld={linker}'] def get_coverage_args(self) -> T.List[str]: return ['--coverage'] def get_preprocess_to_file_args(self) -> T.List[str]: # We want to allow preprocessing files with any extension, such as # foo.c.in. In that case we need to tell GCC/CLANG to treat them as # assembly file. lang = gnu_lang_map.get(self.language, 'assembler-with-cpp') return self.get_preprocess_only_args() + [f'-x{lang}'] class GnuCompiler(GnuLikeCompiler): """ GnuCompiler represents an actual GCC in its many incarnations. Compilers imitating GCC (Clang/Intel) should use the GnuLikeCompiler ABC. """ id = 'gcc' def __init__(self, defines: T.Optional[T.Dict[str, str]]): super().__init__() self.defines = defines or {} self.base_options.update({OptionKey('b_colorout'), OptionKey('b_lto_threads')}) self._has_color_support = mesonlib.version_compare(self.version, '>=4.9.0') self._has_wpedantic_support = mesonlib.version_compare(self.version, '>=4.8.0') self._has_lto_auto_support = mesonlib.version_compare(self.version, '>=10.0') def get_colorout_args(self, colortype: str) -> T.List[str]: if self._has_color_support: return gnu_color_args[colortype][:] return [] def get_warn_args(self, level: str) -> T.List[str]: # Mypy doesn't understand cooperative inheritance args = super().get_warn_args(level) if not self._has_wpedantic_support and '-Wpedantic' in args: # -Wpedantic was added in 4.8.0 # https://gcc.gnu.org/gcc-4.8/changes.html args[args.index('-Wpedantic')] = '-pedantic' return args def supported_warn_args(self, warn_args_by_version: T.Dict[str, T.List[str]]) -> T.List[str]: result: T.List[str] = [] for version, warn_args in warn_args_by_version.items(): if mesonlib.version_compare(self.version, '>=' + version): result += warn_args return result def has_builtin_define(self, define: str) -> bool: return define in self.defines def get_builtin_define(self, define: str) -> T.Optional[str]: if define in self.defines: return self.defines[define] return None def get_optimization_args(self, optimization_level: str) -> T.List[str]: return gnu_optimization_args[optimization_level] def get_pch_suffix(self) -> str: return 'gch' def openmp_flags(self, env: Environment) -> T.List[str]: return ['-fopenmp'] def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: CompileCheckMode) -> T.Tuple[bool, bool]: # For some compiler command line arguments, the GNU compilers will # emit a warning on stderr indicating that an option is valid for a # another language, but still complete with exit_success with self._build_wrapper(code, env, args, None, mode) as p: result = p.returncode == 0 if self.language in {'cpp', 'objcpp'} and 'is valid for C/ObjC' in p.stderr: result = False if self.language in {'c', 'objc'} and 'is valid for C++/ObjC++' in p.stderr: result = False return result, p.cached def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]: # GCC only warns about unknown or ignored attributes, so force an # error. return ['-Werror=attributes'] def get_prelink_args(self, prelink_name: str, obj_list: T.List[str]) -> T.Tuple[T.List[str], T.List[str]]: return [prelink_name], ['-r', '-o', prelink_name] + obj_list def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]: if threads == 0: if self._has_lto_auto_support: return ['-flto=auto'] # This matches clang's behavior of using the number of cpus, but # obeying meson's MESON_NUM_PROCESSES convention. return [f'-flto={mesonlib.determine_worker_count()}'] elif threads > 0: return [f'-flto={threads}'] return super().get_lto_compile_args(threads=threads) @classmethod def use_linker_args(cls, linker: str, version: str) -> T.List[str]: if linker == 'mold' and mesonlib.version_compare(version, '>=12.0.1'): return ['-fuse-ld=mold'] return super().use_linker_args(linker, version) def get_profile_use_args(self) -> T.List[str]: return super().get_profile_use_args() + ['-fprofile-correction'] class GnuCStds(Compiler): """Mixin class for gcc based compilers for setting C standards.""" _C18_VERSION = '>=8.0.0' _C2X_VERSION = '>=9.0.0' _C23_VERSION = '>=14.0.0' _C2Y_VERSION = '>=15.0.0' def get_options(self) -> MutableKeyedOptionDictType: opts = super().get_options() stds = ['c89', 'c99', 'c11'] if mesonlib.version_compare(self.version, self._C18_VERSION): stds += ['c17', 'c18'] if mesonlib.version_compare(self.version, self._C2X_VERSION): stds += ['c2x'] if mesonlib.version_compare(self.version, self._C23_VERSION): stds += ['c23'] if mesonlib.version_compare(self.version, self._C2Y_VERSION): stds += ['c2y'] key = self.form_compileropt_key('std') std_opt = opts[key] assert isinstance(std_opt, UserStdOption), 'for mypy' std_opt.set_versions(stds, gnu=True) return opts class GnuCPPStds(Compiler): """Mixin class for GNU based compilers for setting CPP standards.""" _CPP23_VERSION = '>=11.0.0' _CPP26_VERSION = '>=14.0.0' def get_options(self) -> MutableKeyedOptionDictType: opts = super().get_options() stds = [ 'c++98', 'c++03', 'c++11', 'c++14', 'c++17', 'c++1z', 'c++2a', 'c++20', ] if mesonlib.version_compare(self.version, self._CPP23_VERSION): stds.append('c++23') if mesonlib.version_compare(self.version, self._CPP26_VERSION): stds.append('c++26') key = self.form_compileropt_key('std') std_opt = opts[key] assert isinstance(std_opt, UserStdOption), 'for mypy' std_opt.set_versions(stds, gnu=True) return opts