From 3edcdf0df4695d4ef3f9d195d78367739542bbb1 Mon Sep 17 00:00:00 2001 From: John Ericson Date: Wed, 12 Dec 2018 00:19:03 -0500 Subject: [PATCH] Never access coreutils.compiler_options Instead use environment.properties. This brings the cross and native code paths closer together. TOP BE SQUASHED Fix static analysis errors TO BE SQUASHED __get__ should be __getitem__ TO BE SQUASHED fix making options from cros file We have to iterate over the options, not the cross file dictionary, so we also include default options that were never changed. --- mesonbuild/backend/backends.py | 19 ++++++--- mesonbuild/backend/ninjabackend.py | 13 ++++-- mesonbuild/backend/vs2010backend.py | 26 +++++++----- mesonbuild/compilers/c.py | 15 ++++--- mesonbuild/compilers/compilers.py | 15 ++++--- mesonbuild/compilers/d.py | 13 ++++-- mesonbuild/coredata.py | 36 +++++++++++------ mesonbuild/environment.py | 15 ++++--- mesonbuild/interpreter.py | 62 +++++++++++++++++++---------- mesonbuild/mconf.py | 3 +- mesonbuild/mintro.py | 42 +++++++++++++------ mesonbuild/modules/gnome.py | 21 ++++------ run_tests.py | 2 +- run_unittests.py | 10 ++--- 14 files changed, 186 insertions(+), 106 deletions(-) diff --git a/mesonbuild/backend/backends.py b/mesonbuild/backend/backends.py index 22920f49bc22..e0571e8dd9a5 100644 --- a/mesonbuild/backend/backends.py +++ b/mesonbuild/backend/backends.py @@ -20,7 +20,7 @@ from .. import mlog import json import subprocess -from ..mesonlib import MesonException, OrderedSet +from ..mesonlib import MachineChoice, MesonException, OrderedSet from ..mesonlib import classify_unity_sources from ..mesonlib import File from ..compilers import CompilerArgs, VisualStudioCCompiler @@ -183,9 +183,14 @@ def get_base_options_for_target(self, target): self.environment.coredata.base_options) def get_compiler_options_for_target(self, target): - return OptionOverrideProxy(target.option_overrides, - # no code depends on builtins for now - self.environment.coredata.compiler_options) + if self.environment.is_cross_build() and not target.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST + + return OptionOverrideProxy( + target.option_overrides, + self.environment.coredata.compiler_options[for_machine]) def get_option_for_target(self, option_name, target): if option_name in target.option_overrides: @@ -572,10 +577,14 @@ def generate_basic_compiler_args(self, target, compiler, no_warn_args=False): # Add compile args added using add_global_arguments() # These override per-project arguments commands += self.build.get_global_args(compiler, target.is_cross) + if self.environment.is_cross_build() and not target.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST if not target.is_cross: # Compile args added from the env: CFLAGS/CXXFLAGS, etc. We want these # to override all the defaults, but not the per-target compile args. - commands += self.environment.coredata.get_external_args(compiler.get_language()) + commands += self.environment.coredata.get_external_args(for_machine, compiler.get_language()) # Always set -fPIC for shared libraries if isinstance(target, build.SharedLibrary): commands += compiler.get_pic_args() diff --git a/mesonbuild/backend/ninjabackend.py b/mesonbuild/backend/ninjabackend.py index 44bdaab55dad..ac6ff5cc97b5 100644 --- a/mesonbuild/backend/ninjabackend.py +++ b/mesonbuild/backend/ninjabackend.py @@ -31,7 +31,7 @@ from .. import compilers from ..compilers import CompilerArgs, CCompiler, VisualStudioCCompiler from ..linkers import ArLinker -from ..mesonlib import File, MesonException, OrderedSet +from ..mesonlib import File, MachineChoice, MesonException, OrderedSet from ..mesonlib import get_compiler_for_source, has_path_sep from .backends import CleanTrees from ..build import InvalidArguments @@ -1391,7 +1391,7 @@ def generate_dynamic_link_rules(self, outfile): or langname == 'cs': continue crstr = '' - cross_args = self.environment.properties.host.get_external_link_args(langname) + cross_args = self.environment.coredata.get_external_link_args(MachineChoice.HOST, langname) if is_cross: crstr = '_CROSS' rule = 'rule %s%s_LINKER\n' % (langname, crstr) @@ -2396,6 +2396,11 @@ def generate_link(self, target, outfile, outname, obj_list, linker, extra_args=[ if not isinstance(target, build.StaticLibrary): commands += self.get_link_whole_args(linker, target) + if self.environment.is_cross_build() and not target.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST + if not isinstance(target, build.StaticLibrary): # Add link args added using add_project_link_arguments() commands += self.build.get_project_link_args(linker, target.subproject, target.is_cross) @@ -2405,7 +2410,7 @@ def generate_link(self, target, outfile, outname, obj_list, linker, extra_args=[ if not target.is_cross: # Link args added from the env: LDFLAGS. We want these to # override all the defaults but not the per-target link args. - commands += self.environment.coredata.get_external_link_args(linker.get_language()) + commands += self.environment.coredata.get_external_link_args(for_machine, linker.get_language()) # Now we will add libraries and library paths from various sources @@ -2451,7 +2456,7 @@ def generate_link(self, target, outfile, outname, obj_list, linker, extra_args=[ # to be after all internal and external libraries so that unresolved # symbols from those can be found here. This is needed when the # *_winlibs that we want to link to are static mingw64 libraries. - commands += linker.get_option_link_args(self.environment.coredata.compiler_options) + commands += linker.get_option_link_args(self.environment.coredata.compiler_options[for_machine]) dep_targets = [] dep_targets.extend(self.guess_external_link_dependencies(linker, target, commands, internal)) diff --git a/mesonbuild/backend/vs2010backend.py b/mesonbuild/backend/vs2010backend.py index 939f7b44f9bc..c7dfd4cb625b 100644 --- a/mesonbuild/backend/vs2010backend.py +++ b/mesonbuild/backend/vs2010backend.py @@ -25,7 +25,9 @@ from .. import mlog from .. import compilers from ..compilers import CompilerArgs -from ..mesonlib import MesonException, File, python_command, replace_if_different +from ..mesonlib import ( + MesonException, MachineChoice, File, python_command, replace_if_different +) from ..environment import Environment, build_filename def autodetect_vs_version(build): @@ -856,10 +858,14 @@ def gen_vcxproj(self, target, ofname, guid): file_inc_dirs = dict((lang, []) for lang in target.compilers) # The order in which these compile args are added must match # generate_single_compile() and generate_basic_compiler_args() + if self.environment.is_cross_build() and not target.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST for l, comp in target.compilers.items(): if l in file_args: file_args[l] += compilers.get_base_compile_args(self.get_base_options_for_target(target), comp) - file_args[l] += comp.get_option_compile_args(self.environment.coredata.compiler_options) + file_args[l] += comp.get_option_compile_args(self.environment.coredata.compiler_options[for_machine]) # Add compile args added using add_project_arguments() for l, args in self.build.projects_args.get(target.subproject, {}).items(): @@ -871,9 +877,10 @@ def gen_vcxproj(self, target, ofname, guid): if l in file_args: file_args[l] += args if not target.is_cross: - # Compile args added from the env: CFLAGS/CXXFLAGS, etc. We want these - # to override all the defaults, but not the per-target compile args. - for key, opt in self.environment.coredata.compiler_options.items(): + # Compile args added from the env or cross file: CFLAGS/CXXFLAGS, + # etc. We want these to override all the defaults, but not the + # per-target compile args. + for key, opt in self.environment.coredata.compiler_options[for_machine].items(): l, suffix = key.split('_', 1) if suffix == 'args' and l in file_args: file_args[l] += opt.value @@ -1039,9 +1046,10 @@ def gen_vcxproj(self, target, ofname, guid): # These override per-project link arguments extra_link_args += self.build.get_global_link_args(compiler, target.is_cross) if not target.is_cross: - # Link args added from the env: LDFLAGS. We want these to - # override all the defaults but not the per-target link args. - extra_link_args += self.environment.coredata.get_external_link_args(compiler.get_language()) + # Link args added from the env: LDFLAGS, or the cross file. We + # want these to override all the defaults but not the + # per-target link args. + extra_link_args += self.environment.coredata.get_external_link_args(for_machine, compiler.get_language()) # Only non-static built targets need link args and link dependencies extra_link_args += target.link_args # External deps must be last because target link libraries may depend on them. @@ -1064,7 +1072,7 @@ def gen_vcxproj(self, target, ofname, guid): # to be after all internal and external libraries so that unresolved # symbols from those can be found here. This is needed when the # *_winlibs that we want to link to are static mingw64 libraries. - extra_link_args += compiler.get_option_link_args(self.environment.coredata.compiler_options) + extra_link_args += compiler.get_option_link_args(self.environment.coredata.compiler_options[for_machine]) (additional_libpaths, additional_links, extra_link_args) = self.split_link_args(extra_link_args.to_native()) # Add more libraries to be linked if needed diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py index 92a9fa6d77ba..8f1dc977cc1b 100644 --- a/mesonbuild/compilers/c.py +++ b/mesonbuild/compilers/c.py @@ -24,8 +24,9 @@ from .. import coredata from . import compilers from ..mesonlib import ( - EnvironmentException, MesonException, version_compare, Popen_safe, listify, - for_windows, for_darwin, for_cygwin, for_haiku, for_openbsd, + EnvironmentException, MachineChoice, MesonException, version_compare, + Popen_safe, listify, for_windows, for_darwin, for_cygwin, for_haiku, + for_openbsd, ) from .c_function_attributes import C_FUNC_ATTRIBUTES @@ -422,12 +423,16 @@ def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile' # Read c_args/cpp_args/etc from the cross-info file (if needed) args += self.get_cross_extra_flags(env, link=(mode == 'link')) if not self.is_cross: + if env.is_cross_build() and not self.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST if mode == 'preprocess': # Add CPPFLAGS from the env. - args += env.coredata.get_external_preprocess_args(self.language) + args += env.coredata.get_external_preprocess_args(for_machine, self.language) elif mode == 'compile': # Add CFLAGS/CXXFLAGS/OBJCFLAGS/OBJCXXFLAGS from the env - sys_args = env.coredata.get_external_args(self.language) + sys_args = env.coredata.get_external_args(for_machine, self.language) # 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 @@ -436,7 +441,7 @@ def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile' args += cleaned_sys_args elif mode == 'link': # Add LDFLAGS from the env - args += env.coredata.get_external_link_args(self.language) + args += env.coredata.get_external_link_args(for_machine, self.language) args += self.get_compiler_check_args() # extra_args must override all other arguments, so we add them last args += extra_args diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py index 2be6ef1242d5..9500349e86bb 100644 --- a/mesonbuild/compilers/compilers.py +++ b/mesonbuild/compilers/compilers.py @@ -20,8 +20,8 @@ from .. import mlog from .. import mesonlib from ..mesonlib import ( - EnvironmentException, MesonException, OrderedSet, version_compare, - Popen_safe + EnvironmentException, MachineChoice, MesonException, OrderedSet, + version_compare, Popen_safe ) """This file contains the data files of all compilers Meson knows @@ -973,7 +973,11 @@ def get_options(self): opts = {} # build afresh every time # Take default values from env variables. - compile_args, link_args = self.get_args_from_envvars() + if not self.is_cross: + compile_args, link_args = self.get_args_from_envvars() + else: + compile_args = [] + link_args = [] description = 'Extra arguments passed to the {}'.format(self.get_display_language()) opts.update({ self.language + '_args': coredata.UserArrayOption( @@ -1045,10 +1049,9 @@ def has_multi_link_arguments(self, args, env): def get_cross_extra_flags(self, environment, link): extra_flags = [] if self.is_cross and environment: - props = environment.properties.host - extra_flags += props.get_external_args(self.language) + extra_flags += environment.coredata.get_external_args(MachineChoice.HOST, self.language) if link: - extra_flags += props.get_external_link_args(self.language) + extra_flags += environment.coredata.get_external_link_args(MachineChoice.HOST, self.language) return extra_flags def _get_compile_output(self, dirname, mode): diff --git a/mesonbuild/compilers/d.py b/mesonbuild/compilers/d.py index 2cf0fbd92fe9..8a9de00493b4 100644 --- a/mesonbuild/compilers/d.py +++ b/mesonbuild/compilers/d.py @@ -14,7 +14,9 @@ import os.path, subprocess -from ..mesonlib import EnvironmentException, version_compare, is_windows, is_osx +from ..mesonlib import ( + EnvironmentException, MachineChoice, version_compare, is_windows, is_osx +) from .compilers import ( CompilerType, @@ -293,12 +295,17 @@ def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile' # Add link flags needed to find dependencies args += d.get_link_args() + if env.is_cross_build() and not self.is_cross: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST + if mode == 'compile': # Add DFLAGS from the env - args += env.coredata.get_external_args(self.language) + args += env.coredata.get_external_args(for_machine, self.language) elif mode == 'link': # Add LDFLAGS from the env - args += env.coredata.get_external_link_args(self.language) + args += env.coredata.get_external_link_args(for_machine, self.language) # extra_args must override all other arguments, so we add them last args += extra_args return args diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py index b650f78b7953..0a76b3ffd9f5 100644 --- a/mesonbuild/coredata.py +++ b/mesonbuild/coredata.py @@ -19,7 +19,8 @@ from pathlib import PurePath from collections import OrderedDict from .mesonlib import ( - MesonException, default_libdir, default_libexecdir, default_prefix + MesonException, MachineChoice, PerMachine, + default_libdir, default_libexecdir, default_prefix ) from .wrap import WrapMode import ast @@ -253,9 +254,9 @@ def __init__(self, options): self.init_builtins() self.backend_options = {} self.user_options = {} - self.compiler_options = {} + self.compiler_options = PerMachine({}, {}, {}) self.base_options = {} - self.external_preprocess_args = {} # CPPFLAGS only + self.external_preprocess_args = PerMachine({}, {}, {}) # CPPFLAGS only self.cross_file = self.__load_cross_file(options.cross_file) self.compilers = OrderedDict() self.cross_compilers = OrderedDict() @@ -449,10 +450,20 @@ def set_buildtype_from_others(self): mode = 'custom' self.builtins['buildtype'].set_value(mode) + @staticmethod + def suffix_options(suffix, opts): + return {k + suffix: v for k, v in opts.items()} + + def get_all_compiler_options(self): + yield self.suffix_options('_for_build', self.compiler_options.build) + yield self.compiler_options.host + yield self.suffix_options('_for_target', self.compiler_options.target) + def _get_all_nonbuiltin_options(self): yield self.backend_options yield self.user_options - yield self.compiler_options + for co in self.get_all_compiler_options(): + yield co yield self.base_options def get_all_options(self): @@ -467,14 +478,14 @@ def validate_option_value(self, option_name, override_value): return opt.validate_value(override_value) raise MesonException('Tried to validate unknown option %s.' % option_name) - def get_external_args(self, lang): - return self.compiler_options[lang + '_args'].value + def get_external_args(self, for_machine: MachineChoice, lang): + return self.compiler_options[for_machine][lang + '_args'].value - def get_external_link_args(self, lang): - return self.compiler_options[lang + '_link_args'].value + def get_external_link_args(self, for_machine: MachineChoice, lang): + return self.compiler_options[for_machine][lang + '_link_args'].value - def get_external_preprocess_args(self, lang): - return self.external_preprocess_args[lang] + def get_external_preprocess_args(self, for_machine: MachineChoice, lang): + return self.external_preprocess_args[for_machine][lang] def merge_user_options(self, options): for (name, value) in options.items(): @@ -485,7 +496,7 @@ def merge_user_options(self, options): if type(oldval) != type(value): self.user_options[name] = value - def set_options(self, options, subproject=''): + def set_options(self, options, subproject='', warn_unknown=True): # Set prefix first because it's needed to sanitize other options prefix = self.builtins['prefix'].value if 'prefix' in options: @@ -509,8 +520,7 @@ def set_options(self, options, subproject=''): break else: unknown_options.append(k) - - if unknown_options: + if unknown_options and warn_unknown: unknown_options = ', '.join(sorted(unknown_options)) sub = 'In subproject {}: '.format(subproject) if subproject else '' mlog.warning('{}Unknown options: "{}"'.format(sub, unknown_options)) diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py index b10f826ee1f0..04b8baed6d36 100644 --- a/mesonbuild/environment.py +++ b/mesonbuild/environment.py @@ -1188,14 +1188,8 @@ def from_config_parser(cls, parser: configparser.ConfigParser): return out class Properties: - def __init__(self): - self.properties = {} - - def get_external_args(self, language): - return mesonlib.stringlistify(self.properties.get(language + '_args', [])) - - def get_external_link_args(self, language): - return mesonlib.stringlistify(self.properties.get(language + '_link_args', [])) + def __init__(self, properties: dict = {}): + self.properties = properties def has_stdlib(self, language): return language + '_stdlib' in self.properties @@ -1209,6 +1203,11 @@ def get_root(self): def get_sys_root(self): return self.properties.get('sys_root', None) + def __eq__(self, other): + if self.__class__ is other.__class__: + return self.properties == other.properties + return NotImplemented + # TODO consider removing so Properties is less freeform def __getitem__(self, key): return self.properties[key] diff --git a/mesonbuild/interpreter.py b/mesonbuild/interpreter.py index f849f3ce0367..e49e4addc667 100644 --- a/mesonbuild/interpreter.py +++ b/mesonbuild/interpreter.py @@ -996,8 +996,13 @@ def determine_args(self, kwargs, mode='link'): idir = os.path.join(self.environment.get_source_dir(), i.held_object.get_curdir(), idir) args += self.compiler.get_include_args(idir, False) + native = kwargs.get('native', None) + if native: + for_machine = MachineChoice.BUILD + else: + for_machine = MachineChoice.HOST if not nobuiltins: - opts = self.environment.coredata.compiler_options + opts = self.environment.coredata.compiler_options[for_machine] args += self.compiler.get_option_compile_args(opts) if mode == 'link': args += self.compiler.get_option_link_args(opts) @@ -2439,8 +2444,7 @@ def do_subproject(self, dirname, kwargs): def get_option_internal(self, optname): # Some base options are not defined in some environments, return the # default value from compilers.base_options in that case. - for d in [self.coredata.base_options, compilers.base_options, - self.coredata.builtins, self.coredata.compiler_options]: + for d in self.coredata.get_all_options(): try: return d[optname] except KeyError: @@ -2658,28 +2662,46 @@ def detect_compilers(self, lang, need_cross_compiler): if comp is None: raise InvalidCode('Tried to use unknown language "%s".' % lang) + # Native compiler always exist so always add its options. + new_options_for_build = comp.get_options() + preproc_flags_for_build = comp.get_preproc_flags() + if need_cross_compiler: + assert cross_comp is not None + new_options_for_host = cross_comp.get_options() + preproc_flags_for_host = cross_comp.get_preproc_flags() + else: + new_options_for_host = comp.get_options() + preproc_flags_for_host = comp.get_preproc_flags() + + opts_machines_list = [ + (new_options_for_build, preproc_flags_for_build, MachineChoice.BUILD), + (new_options_for_host, preproc_flags_for_host, MachineChoice.HOST), + ] + + optprefix = lang + '_' + for opts, preproc_flags, for_machine in opts_machines_list: + optsuffix = { + MachineChoice.BUILD: '_for_build', + MachineChoice.HOST: '', + MachineChoice.TARGET: '_for_target', + }[for_machine] + for k, o in opts.items(): + if not k.startswith(optprefix): + raise InterpreterException('Internal error, %s has incorrect prefix.' % k) + if k + optsuffix in self.environment.cmd_line_options: + o.set_value(self.environment.cmd_line_options[k + optsuffix]) + self.coredata.compiler_options[for_machine].setdefault(k, o) + # Unlike compiler and linker flags, preprocessor flags are not in + # compiler_options because they are not visible to user. + preproc_flags = shlex.split(preproc_flags) + self.coredata.external_preprocess_args[for_machine].setdefault(lang, preproc_flags) + + # Sanity check uses compiler options so do after. comp.sanity_check(self.environment.get_scratch_dir(), self.environment) self.coredata.compilers[lang] = comp - # Native compiler always exist so always add its options. - new_options = comp.get_options() if cross_comp is not None: cross_comp.sanity_check(self.environment.get_scratch_dir(), self.environment) self.coredata.cross_compilers[lang] = cross_comp - new_options.update(cross_comp.get_options()) - - optprefix = lang + '_' - for k, o in new_options.items(): - if not k.startswith(optprefix): - raise InterpreterException('Internal error, %s has incorrect prefix.' % k) - if k in self.environment.cmd_line_options: - o.set_value(self.environment.cmd_line_options[k]) - self.coredata.compiler_options.setdefault(k, o) - - # Unlike compiler and linker flags, preprocessor flags are not in - # compiler_options because they are not visible to user. - preproc_flags = comp.get_preproc_flags() - preproc_flags = shlex.split(preproc_flags) - self.coredata.external_preprocess_args.setdefault(lang, preproc_flags) return comp, cross_comp diff --git a/mesonbuild/mconf.py b/mesonbuild/mconf.py index 28589dab0a7f..bc466364e2c2 100644 --- a/mesonbuild/mconf.py +++ b/mesonbuild/mconf.py @@ -139,7 +139,8 @@ def print_conf(self): self.print_options('Core options', core_options) self.print_options('Backend options', self.coredata.backend_options) self.print_options('Base options', self.coredata.base_options) - self.print_options('Compiler options', self.coredata.compiler_options) + # TODO others + self.print_options('Compiler options', self.coredata.compiler_options.build) self.print_options('Directories', dir_options) self.print_options('Project options', self.coredata.user_options) self.print_options('Testing options', test_options) diff --git a/mesonbuild/mintro.py b/mesonbuild/mintro.py index 3896c92769b1..b2ba111b12f2 100644 --- a/mesonbuild/mintro.py +++ b/mesonbuild/mintro.py @@ -28,6 +28,7 @@ from . import mlog from . import compilers from . import optinterpreter +from .mesonlib import MachineChoice from .interpreterbase import InvalidArguments from .backend import ninjabackend, backends import sys, os @@ -171,20 +172,36 @@ def detect_compilers(self, lang, need_cross_compiler): if comp is None: return None, None - self.coredata.compilers[lang] = comp # Native compiler always exist so always add its options. - new_options = comp.get_options() - if cross_comp is not None: - self.coredata.cross_compilers[lang] = cross_comp - new_options.update(cross_comp.get_options()) + new_options_for_build = comp.get_options() + if need_cross_compiler: + assert cross_comp is not None + new_options_for_host = cross_comp.get_options() + else: + new_options_for_host = comp.get_options() + + opts_machines_list = [ + (new_options_for_build, MachineChoice.BUILD), + (new_options_for_host, MachineChoice.HOST), + ] optprefix = lang + '_' - for k, o in new_options.items(): - if not k.startswith(optprefix): - raise RuntimeError('Internal error, %s has incorrect prefix.' % k) - if k in self.environment.cmd_line_options: - o.set_value(self.environment.cmd_line_options[k]) - self.coredata.compiler_options.setdefault(k, o) + for opts, for_machine in opts_machines_list: + optsuffix = { + MachineChoice.BUILD: '_for_build', + MachineChoice.HOST: '', + MachineChoice.TARGET: '_for_target', + }[for_machine] + for k, o in opts.items(): + if not k.startswith(optprefix): + raise RuntimeError('Internal error, %s has incorrect prefix.' % k) + if k + optsuffix in self.environment.cmd_line_options: + o.set_value(self.environment.cmd_line_options[k + optsuffix]) + self.coredata.compiler_options[for_machine].setdefault(k, o) + + self.coredata.compilers[lang] = comp + if cross_comp is not None: + self.coredata.cross_compilers[lang] = cross_comp return comp, cross_comp @@ -309,7 +326,8 @@ def list_buildoptions(coredata): add_keys(optlist, core_options, 'core') add_keys(optlist, coredata.backend_options, 'backend') add_keys(optlist, coredata.base_options, 'base') - add_keys(optlist, coredata.compiler_options, 'compiler') + # TODO others + add_keys(optlist, coredata.compiler_options.build, 'compiler') add_keys(optlist, dir_options, 'directory') add_keys(optlist, coredata.user_options, 'user') add_keys(optlist, test_options, 'test') diff --git a/mesonbuild/modules/gnome.py b/mesonbuild/modules/gnome.py index 2ab575c4cbce..678a5ab091d1 100644 --- a/mesonbuild/modules/gnome.py +++ b/mesonbuild/modules/gnome.py @@ -29,7 +29,9 @@ from . import get_include_args from . import ExtensionModule from . import ModuleReturnValue -from ..mesonlib import MesonException, OrderedSet, Popen_safe, extract_as_list +from ..mesonlib import ( + MachineChoice, MesonException, OrderedSet, Popen_safe, extract_as_list +) from ..dependencies import Dependency, PkgConfigDependency, InternalDependency from ..interpreterbase import noKwargs, permittedKwargs, FeatureNew, FeatureNewKwargs @@ -531,11 +533,7 @@ def _scan_langs(self, state, langs): ret = [] for lang in langs: - if state.environment.is_cross_build(): - link_args = state.environment.properties.host.get_external_link_args(lang) - else: - link_args = state.environment.coredata.get_external_link_args(lang) - + link_args = state.environment.coredata.get_external_link_args(MachineChoice.HOST, lang) for link_arg in link_args: if link_arg.startswith('-L'): ret.append(link_arg) @@ -714,10 +712,7 @@ def _gather_typelib_includes_and_update_depends(self, state, deps, depends): def _get_external_args_for_langs(self, state, langs): ret = [] for lang in langs: - if state.environment.is_cross_build(): - ret += state.environment.properties.host.get_external_args(lang) - else: - ret += state.environment.coredata.get_external_args(lang) + ret += state.environment.coredata.get_external_args(MachineChoice.HOST, lang) return ret @staticmethod @@ -1042,13 +1037,11 @@ def _get_build_args(self, kwargs, state, depends): ldflags.update(internal_ldflags) ldflags.update(external_ldflags) + cflags.update(state.environment.coredata.get_external_args(MachineChoice.HOST, 'c')) + ldflags.update(state.environment.coredata.get_external_link_args(MachineChoice.HOST, 'c')) if state.environment.is_cross_build(): - cflags.update(state.environment.properties.host.get_external_args('c')) - ldflags.update(state.environment.properties.host.get_external_link_args('c')) compiler = state.environment.coredata.cross_compilers.get('c') else: - cflags.update(state.environment.coredata.get_external_args('c')) - ldflags.update(state.environment.coredata.get_external_link_args('c')) compiler = state.environment.coredata.compilers.get('c') compiler_flags = self._get_langs_compilers_flags(state, [('c', compiler)]) diff --git a/run_tests.py b/run_tests.py index 25a2d7f97711..0ab04e1e71f6 100755 --- a/run_tests.py +++ b/run_tests.py @@ -80,7 +80,7 @@ def get_fake_env(sdir, bdir, prefix, opts = None): if opts is None: opts = get_fake_options(prefix) env = Environment(sdir, bdir, opts) - env.coredata.compiler_options['c_args'] = FakeCompilerOptions() + env.coredata.compiler_options.host['c_args'] = FakeCompilerOptions() return env diff --git a/run_unittests.py b/run_unittests.py index 9259b03c8902..8943f2d665dc 100755 --- a/run_unittests.py +++ b/run_unittests.py @@ -721,7 +721,7 @@ def test_pkgconfig_parse_libs(self): env = get_fake_env('', '', '') compiler = env.detect_c_compiler(False) env.coredata.compilers = {'c': compiler} - env.coredata.compiler_options['c_link_args'] = FakeCompilerOptions() + env.coredata.compiler_options.host['c_link_args'] = FakeCompilerOptions() p1 = Path(tmpdir) / '1' p2 = Path(tmpdir) / '2' p1.mkdir() @@ -2826,10 +2826,10 @@ def test_command_line(self): # c_args value should be parsed with shlex self.init(testdir, extra_args=['-Dc_args=foo bar "one two"']) obj = mesonbuild.coredata.load(self.builddir) - self.assertEqual(obj.compiler_options['c_args'].value, ['foo', 'bar', 'one two']) + self.assertEqual(obj.compiler_options.host['c_args'].value, ['foo', 'bar', 'one two']) self.setconf('-Dc_args="foo bar" one two') obj = mesonbuild.coredata.load(self.builddir) - self.assertEqual(obj.compiler_options['c_args'].value, ['foo bar', 'one', 'two']) + self.assertEqual(obj.compiler_options.host['c_args'].value, ['foo bar', 'one', 'two']) self.wipe() # Setting a 2nd time the same option should override the first value @@ -2842,7 +2842,7 @@ def test_command_line(self): self.assertEqual(obj.builtins['bindir'].value, 'bar') self.assertEqual(obj.builtins['buildtype'].value, 'release') self.assertEqual(obj.base_options['b_sanitize'].value, 'thread') - self.assertEqual(obj.compiler_options['c_args'].value, ['bar']) + self.assertEqual(obj.compiler_options.host['c_args'].value, ['bar']) self.setconf(['--bindir=bar', '--bindir=foo', '-Dbuildtype=release', '-Dbuildtype=plain', '-Db_sanitize=thread', '-Db_sanitize=address', @@ -2851,7 +2851,7 @@ def test_command_line(self): self.assertEqual(obj.builtins['bindir'].value, 'foo') self.assertEqual(obj.builtins['buildtype'].value, 'plain') self.assertEqual(obj.base_options['b_sanitize'].value, 'address') - self.assertEqual(obj.compiler_options['c_args'].value, ['foo']) + self.assertEqual(obj.compiler_options.host['c_args'].value, ['foo']) self.wipe() except KeyError: # Ignore KeyError, it happens on CI for compilers that does not