The Meson Build System
http://mesonbuild.com/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
348 lines
12 KiB
348 lines
12 KiB
# Copyright 2019 The meson development team |
|
# |
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
|
# you may not use this file except in compliance with the License. |
|
# You may obtain a copy of the License at |
|
# |
|
# http://www.apache.org/licenses/LICENSE-2.0 |
|
# |
|
# Unless required by applicable law or agreed to in writing, software |
|
# distributed under the License is distributed on an "AS IS" BASIS, |
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
# See the License for the specific language governing permissions and |
|
# limitations under the License. |
|
|
|
"""Provides mixins for GNU compilers and GNU-like compilers.""" |
|
|
|
import abc |
|
import functools |
|
import os |
|
import pathlib |
|
import re |
|
import subprocess |
|
import typing |
|
|
|
from ... import mesonlib |
|
from ... import mlog |
|
|
|
if typing.TYPE_CHECKING: |
|
from ...coredata import UserOption # noqa: F401 |
|
from ...environment import Environment |
|
|
|
# XXX: prevent circular references. |
|
# FIXME: this really is a posix interface not a c-like interface |
|
clike_debug_args = { |
|
False: [], |
|
True: ['-g'], |
|
} # type: typing.Dict[bool, typing.List[str]] |
|
|
|
gnulike_buildtype_args = { |
|
'plain': [], |
|
'debug': [], |
|
'debugoptimized': [], |
|
'release': [], |
|
'minsize': [], |
|
'custom': [], |
|
} # type: typing.Dict[str, typing.List[str]] |
|
|
|
gnu_optimization_args = { |
|
'0': [], |
|
'g': ['-Og'], |
|
'1': ['-O1'], |
|
'2': ['-O2'], |
|
'3': ['-O3'], |
|
's': ['-Os'], |
|
} # type: typing.Dict[str, typing.List[str]] |
|
|
|
gnulike_instruction_set_args = { |
|
'mmx': ['-mmmx'], |
|
'sse': ['-msse'], |
|
'sse2': ['-msse2'], |
|
'sse3': ['-msse3'], |
|
'ssse3': ['-mssse3'], |
|
'sse41': ['-msse4.1'], |
|
'sse42': ['-msse4.2'], |
|
'avx': ['-mavx'], |
|
'avx2': ['-mavx2'], |
|
'neon': ['-mfpu=neon'], |
|
} # type: typing.Dict[str, typing.List[str]] |
|
|
|
gnu_symbol_visibility_args = { |
|
'': [], |
|
'default': ['-fvisibility=default'], |
|
'internal': ['-fvisibility=internal'], |
|
'hidden': ['-fvisibility=hidden'], |
|
'protected': ['-fvisibility=protected'], |
|
'inlineshidden': ['-fvisibility=hidden', '-fvisibility-inlines-hidden'], |
|
} # type: typing.Dict[str, typing.List[str]] |
|
|
|
gnu_color_args = { |
|
'auto': ['-fdiagnostics-color=auto'], |
|
'always': ['-fdiagnostics-color=always'], |
|
'never': ['-fdiagnostics-color=never'], |
|
} # type: typing.Dict[str, typing.List[str]] |
|
|
|
|
|
@functools.lru_cache(maxsize=None) |
|
def gnulike_default_include_dirs(compiler: typing.Tuple[str], lang: str) -> typing.List[str]: |
|
if lang == 'cpp': |
|
lang = 'c++' |
|
env = os.environ.copy() |
|
env["LC_ALL"] = 'C' |
|
cmd = list(compiler) + ['-x{}'.format(lang), '-E', '-v', '-'] |
|
p = subprocess.Popen( |
|
cmd, |
|
stdin=subprocess.DEVNULL, |
|
stderr=subprocess.PIPE, |
|
stdout=subprocess.PIPE, |
|
env=env |
|
) |
|
stderr = p.stderr.read().decode('utf-8', errors='replace') |
|
parse_state = 0 |
|
paths = [] |
|
for line in stderr.split('\n'): |
|
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[1:]) |
|
elif parse_state == 2: |
|
if line == 'End of search list.': |
|
break |
|
else: |
|
paths.append(line[1:]) |
|
if not paths: |
|
mlog.warning('No include directory found parsing "{cmd}" output'.format(cmd=" ".join(cmd))) |
|
return paths |
|
|
|
|
|
class GnuLikeCompiler(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): |
|
self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', '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.append('b_lundef') |
|
if not self.info.is_windows() or self.info.is_cygwin(): |
|
self.base_options.append('b_asneeded') |
|
# All GCC-like backends can do assembly |
|
self.can_compile_suffixes.add('s') |
|
|
|
def get_pic_args(self) -> typing.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) -> typing.List[str]: |
|
return ['-fPIE'] |
|
|
|
def get_buildtype_args(self, buildtype: str) -> typing.List[str]: |
|
return gnulike_buildtype_args[buildtype] |
|
|
|
@abc.abstractmethod |
|
def get_optimization_args(self, optimization_level: str) -> typing.List[str]: |
|
raise NotImplementedError("get_optimization_args not implemented") |
|
|
|
def get_debug_args(self, is_debug: bool) -> typing.List[str]: |
|
return clike_debug_args[is_debug] |
|
|
|
@abc.abstractmethod |
|
def get_pch_suffix(self) -> str: |
|
raise NotImplementedError("get_pch_suffix not implemented") |
|
|
|
def split_shlib_to_parts(self, fname: str) -> typing.Tuple[str, str]: |
|
return os.path.dirname(fname), fname |
|
|
|
def get_instruction_set_args(self, instruction_set: str) -> typing.Optional[typing.List[str]]: |
|
return gnulike_instruction_set_args.get(instruction_set, None) |
|
|
|
def get_default_include_dirs(self) -> typing.List[str]: |
|
return gnulike_default_include_dirs(tuple(self.exelist), self.language) |
|
|
|
@abc.abstractmethod |
|
def openmp_flags(self) -> typing.List[str]: |
|
raise NotImplementedError("openmp_flags not implemented") |
|
|
|
def gnu_symbol_visibility_args(self, vistype: str) -> typing.List[str]: |
|
return gnu_symbol_visibility_args[vistype] |
|
|
|
def gen_vs_module_defs_args(self, defsfile: str) -> typing.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 [] |
|
|
|
def get_argument_syntax(self) -> str: |
|
return 'gcc' |
|
|
|
def get_profile_generate_args(self) -> typing.List[str]: |
|
return ['-fprofile-generate'] |
|
|
|
def get_profile_use_args(self) -> typing.List[str]: |
|
return ['-fprofile-use', '-fprofile-correction'] |
|
|
|
def get_gui_app_args(self, value: bool) -> typing.List[str]: |
|
if self.info.is_windows() or self.info.is_cygwin(): |
|
return ['-mwindows' if value else '-mconsole'] |
|
return [] |
|
|
|
def compute_parameters_with_absolute_paths(self, parameter_list: typing.List[str], build_dir: str) -> typing.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'] |
|
stdo = None |
|
with self._build_wrapper('', env, extra_args=extra_args, |
|
dependencies=None, mode='compile', |
|
want_output=True) as p: |
|
stdo = p.stdo |
|
return stdo |
|
|
|
def _split_fetch_real_dirs(self, pathstr: str) -> typing.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 = [] |
|
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) |
|
unresolved = pobj.as_posix() |
|
if pobj.exists(): |
|
if unresolved not in result: |
|
result.append(unresolved) |
|
try: |
|
resolved = pathlib.Path(p).resolve().as_posix() |
|
if resolved not in result: |
|
result.append(resolved) |
|
except FileNotFoundError: |
|
pass |
|
return result |
|
|
|
def get_compiler_dirs(self, env: 'Environment', name: str) -> typing.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) -> typing.List[str]: |
|
return ['-flto'] |
|
|
|
def sanitizer_compile_args(self, value: str) -> typing.List[str]: |
|
if value == 'none': |
|
return [] |
|
args = ['-fsanitize=' + value] |
|
if 'address' in value: # for -fsanitize=address,undefined |
|
args.append('-fno-omit-frame-pointer') |
|
return args |
|
|
|
def get_output_args(self, target: str) -> typing.List[str]: |
|
return ['-o', target] |
|
|
|
def get_dependency_gen_args(self, outtarget, outfile): |
|
return ['-MD', '-MQ', outtarget, '-MF', outfile] |
|
|
|
def get_compile_only_args(self) -> typing.List[str]: |
|
return ['-c'] |
|
|
|
def get_include_args(self, path: str, is_system: bool) -> typing.List[str]: |
|
if not path: |
|
path = '.' |
|
if is_system: |
|
return ['-isystem' + path] |
|
return ['-I' + path] |
|
|
|
|
|
class GnuCompiler(GnuLikeCompiler): |
|
""" |
|
GnuCompiler represents an actual GCC in its many incarnations. |
|
Compilers imitating GCC (Clang/Intel) should use the GnuLikeCompiler ABC. |
|
""" |
|
|
|
def __init__(self, defines: typing.Dict[str, str]): |
|
super().__init__() |
|
self.id = 'gcc' |
|
self.defines = defines or {} |
|
self.base_options.append('b_colorout') |
|
|
|
def get_colorout_args(self, colortype: str) -> typing.List[str]: |
|
if mesonlib.version_compare(self.version, '>=4.9.0'): |
|
return gnu_color_args[colortype][:] |
|
return [] |
|
|
|
def get_warn_args(self, level: str) -> typing.List[str]: |
|
args = super().get_warn_args(level) |
|
if mesonlib.version_compare(self.version, '<4.8.0') 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 has_builtin_define(self, define: str) -> bool: |
|
return define in self.defines |
|
|
|
def get_builtin_define(self, define: str) -> typing.Optional[str]: |
|
if define in self.defines: |
|
return self.defines[define] |
|
return None |
|
|
|
def get_optimization_args(self, optimization_level: str) -> typing.List[str]: |
|
return gnu_optimization_args[optimization_level] |
|
|
|
def get_pch_suffix(self) -> str: |
|
return 'gch' |
|
|
|
def openmp_flags(self) -> typing.List[str]: |
|
return ['-fopenmp'] |
|
|
|
def has_arguments(self, args, env, code, mode): |
|
# 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, disable_cache=False, want_output=True) as p: |
|
result = p.returncode == 0 |
|
if self.language in {'cpp', 'objcpp'} and 'is valid for C/ObjC' in p.stde: |
|
result = False |
|
if self.language in {'c', 'objc'} and 'is valid for C++/ObjC++' in p.stde: |
|
result = False |
|
return result, p.cached
|
|
|