diff --git a/mesonbuild/backend/backends.py b/mesonbuild/backend/backends.py index 8144ef92187d..7ca289522a68 100644 --- a/mesonbuild/backend/backends.py +++ b/mesonbuild/backend/backends.py @@ -705,6 +705,9 @@ def determine_linker_and_stdlib_args(self, target: build.BuildTarget) -> T.Tuple If we're building a static library, there is only one static linker. Otherwise, we query the target for the dynamic linker. ''' + print("determine_linker_and_stdlib_args()") + print("\ttarget:", target) + print("\ttarget.for_machine:", target.for_machine) if isinstance(target, build.StaticLibrary): return self.build.static_linker[target.for_machine], [] l, stdlib_args = target.get_clink_dynamic_linker_and_stdlibs() diff --git a/mesonbuild/backend/ninjabackend.py b/mesonbuild/backend/ninjabackend.py index 407726fee6a4..3871ee66bdbe 100644 --- a/mesonbuild/backend/ninjabackend.py +++ b/mesonbuild/backend/ninjabackend.py @@ -834,6 +834,8 @@ def create_target_linker_introspection(self, target: build.Target, linker: T.Uni tgt[lnk_hash] = lnk_block def generate_target(self, target): + print("generate_target():", target) + print("\tfor_machine:", target.for_machine) try: if isinstance(target, build.BuildTarget): os.makedirs(self.get_target_private_dir_abs(target)) @@ -1040,6 +1042,9 @@ def generate_target(self, target): final_obj_list = self.generate_prelink(target, obj_list) else: final_obj_list = obj_list + print("calling generate_link()") + print("\tlinker:", linker) + print("\tlinker.for_machine:", linker.for_machine) elem = self.generate_link(target, outname, final_obj_list, linker, pch_objects, stdlib_args=stdlib_args) self.generate_dependency_scan_target(target, compiled_sources, source2object, generated_source_files, fortran_order_deps) self.add_build(elem) @@ -3323,6 +3328,10 @@ def guess_external_link_dependencies(self, linker, target, commands, internal): try: static_patterns = linker.get_library_naming(self.environment, LibType.STATIC, strict=True) shared_patterns = linker.get_library_naming(self.environment, LibType.SHARED, strict=True) + print("calling linker.get_library_dirs()") + print("\tlinker:", linker) + print("\ttarget:", target) + print("\ttarget.for_machine:", target.for_machine) search_dirs = tuple(search_dirs) + tuple(linker.get_library_dirs(self.environment)) for libname in libs: # be conservative and record most likely shared and static resolution, because we don't know exactly diff --git a/mesonbuild/build.py b/mesonbuild/build.py index 126f1f909802..434fb3f6e953 100644 --- a/mesonbuild/build.py +++ b/mesonbuild/build.py @@ -338,6 +338,7 @@ def merge(self, other: Build) -> None: self.__dict__[k] = v if is_native_clone: + self.environment.coredata.merge_from_native_cross(other.environment.coredata) print("TODOOOO") pass @@ -1647,6 +1648,7 @@ def get_clink_dynamic_linker_and_stdlibs(self) -> T.Tuple['Compiler', T.List[str ''' # If the user set the link_language, just return that. if self.link_language: + print("get_clink_dynamic_linker_and_stdlibs(): A") comp = self.all_compilers[self.link_language] return comp, comp.language_stdlib_only_link_flags(self.environment) @@ -1654,10 +1656,22 @@ def get_clink_dynamic_linker_and_stdlibs(self) -> T.Tuple['Compiler', T.List[str # languages we don't have in self.all_compilers. Use the global list of # all compilers here. all_compilers = self.environment.coredata.compilers[self.for_machine] + print("get_clink_dynamic_linker_and_stdlibs(): B") + print("\tself.for_machine:", self.for_machine) # Languages used by dependencies dep_langs = self.get_langs_used_by_deps() + import pprint + print("\tself.compilers:") + print("\tvvv") + pprint.pp(self.compilers) + print("\t^^^") + print("\tall_compilers:") + print("\tvvv") + pprint.pp(all_compilers) + print("\t^^^") + # Pick a compiler based on the language priority-order for l in clink_langs: if l in self.compilers or l in dep_langs: @@ -1668,11 +1682,16 @@ def get_clink_dynamic_linker_and_stdlibs(self) -> T.Tuple['Compiler', T.List[str f'Could not get a dynamic linker for build target {self.name!r}. ' f'Requires a linker for language "{l}", but that is not ' 'a project language.') + print("\textracted linker:") + print(linker) + print("\twhich has for_machine:", linker.for_machine) stdlib_args: T.List[str] = self.get_used_stdlib_args(linker.language) # Type of var 'linker' is Compiler. # Pretty hard to fix because the return value is passed everywhere return linker, stdlib_args + print("get_clink_dynamic_linker_and_stdlibs(): C") + # None of our compilers can do clink, this happens for example if the # target only has ASM sources. Pick the first capable compiler. for l in clink_langs: diff --git a/mesonbuild/compilers/mixins/clike.py b/mesonbuild/compilers/mixins/clike.py index 1e3e0811aa9c..48d3d3e48ad4 100644 --- a/mesonbuild/compilers/mixins/clike.py +++ b/mesonbuild/compilers/mixins/clike.py @@ -389,6 +389,10 @@ def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) - pass # Add CFLAGS/CXXFLAGS/OBJCFLAGS/OBJCXXFLAGS and CPPFLAGS from the env + print("calling env.coredata.get_external_args()") + print("\tself:", self) + print("\tfor_machine:", self.for_machine) + print("\tself.language:", self.language) sys_args = env.coredata.get_external_args(self.for_machine, self.language) if isinstance(sys_args, str): sys_args = [sys_args] diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py index 7a979932cf4d..dedd1e0e7037 100644 --- a/mesonbuild/coredata.py +++ b/mesonbuild/coredata.py @@ -610,6 +610,10 @@ def copy_to_native(self) -> CoreData: return other + def merge_from_native_cross(self, other: CoreData) -> None: + compiler_opts = {k.as_build(): v for k, v in other.options.items() if k.type is OptionType.COMPILER} + self.options.update(compiler_opts) + @staticmethod def __load_config_files(options: argparse.Namespace, scratch_dir: str, ftype: str) -> T.List[str]: # Need to try and make the passed filenames absolute because when the diff --git a/mesonbuild/interpreter/interpreter.py b/mesonbuild/interpreter/interpreter.py index 9cfb05fe19d1..cbc1993973b8 100644 --- a/mesonbuild/interpreter/interpreter.py +++ b/mesonbuild/interpreter/interpreter.py @@ -1003,8 +1003,8 @@ def _do_subproject_meson(self, subp_name: str, subp_id: str, subdir: str, mlog.log('Generated Meson AST:', meson_filename) mlog.cmd_ci_include(meson_filename) - is_native_cross = native and self.coredata.is_cross_build() and not self.coredata.is_native_clone - if is_native_cross: + is_native_cross_boundary = native and self.coredata.is_cross_build() and not self.coredata.is_native_clone + if is_native_cross_boundary: new_build = self.build.copy_to_native() default_options = {k.as_build(): v for k, v in default_options.items()} new_subprojects = {k: v for k, v in self.subprojects.items() if k[1] is MachineChoice.BUILD} @@ -1033,7 +1033,7 @@ def _do_subproject_meson(self, subp_name: str, subp_id: str, subdir: str, try: subi.run() finally: - if is_native_cross: + if is_native_cross_boundary: self._merge_native_cross_subprojects(new_subprojects, prev_subproject_ids) subi_warnings = mlog.get_warning_count() mlog.log('Subproject', mlog.bold(subp_name), 'finished.') @@ -1375,15 +1375,14 @@ def func_add_languages(self, node: mparser.FunctionNode, args: T.Tuple[T.List[st for lang in sorted(langs, key=compilers.sort_clink): mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled') return False + if self.coredata.is_native_clone: + print("add_langauges() XXX") + return self.add_languages(langs, required, MachineChoice.BUILD) if native is not None: print("add_langauges() A") print("using machine:", self.machine_from_native_kwarg(kwargs)) for_machine = self.machine_from_native_kwarg(kwargs) - success = self.add_languages(langs, required, for_machine) - if self.coredata.is_native_clone: - other_machine = MachineChoice.BUILD if for_machine is MachineChoice.HOST else MachineChoice.HOST - success &= self.add_languages(langs, required, other_machine) - return success + return self.add_languages(langs, required, for_machine) else: print("add_langauges() B") # absent 'native' means 'both' for backwards compatibility