diff options
| -rw-r--r-- | mesonbuild/compilers/detect.py | 51 | ||||
| -rw-r--r-- | mesonbuild/linkers/detect.py | 34 | ||||
| -rw-r--r-- | mesonbuild/linkers/linkers.py | 66 | ||||
| -rw-r--r-- | unittests/internaltests.py | 15 |
4 files changed, 89 insertions, 77 deletions
diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py index ff6eb2631..83f7fff4c 100644 --- a/mesonbuild/compilers/detect.py +++ b/mesonbuild/compilers/detect.py @@ -386,7 +386,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin _, o, _ = Popen_safe(cmd) linker = linkers.WASMDynamicLinker( - compiler, for_machine, cls.LINKER_PREFIX, + compiler, env, for_machine, cls.LINKER_PREFIX, [], version=search_version(o)) return cls( ccache, compiler, version, for_machine, env, @@ -419,7 +419,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin version = search_version(arm_ver_str) full_version = arm_ver_str cls = c.ArmclangCCompiler if lang == 'c' else cpp.ArmclangCPPCompiler - linker = linkers.ArmClangDynamicLinker(for_machine, version=version) + linker = linkers.ArmClangDynamicLinker(env, for_machine, version=version) env.add_lang_args(cls.language, cls, for_machine) return cls( ccache, compiler, version, for_machine, env, @@ -456,7 +456,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin cls = compiler_classes[0] if lang == 'c' else compiler_classes[1] lnk = compiler_classes[2] env.add_lang_args(cls.language, cls, for_machine) - linker = lnk(compiler, for_machine, version=version) + linker = lnk(compiler, env, for_machine, version=version) return cls( ccache, compiler, version, for_machine, env, full_version=full_version, linker=linker) @@ -493,7 +493,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin target = 'x86' if 'IA-32' in err else 'x86_64' cls = c.IntelClCCompiler if lang == 'c' else cpp.IntelClCPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version) return cls( compiler, version, for_machine, env, target, linker=linker) @@ -502,7 +502,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin target = 'x86' if 'IA-32' in err else 'x86_64' cls = c.IntelLLVMClCCompiler if lang == 'c' else cpp.IntelLLVMClCPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version) return cls( compiler, version, for_machine, env, target, linker=linker) @@ -536,14 +536,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if 'PGI Compilers' in out: cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) + linker = linkers.PGIDynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache, compiler, version, for_machine, env, linker=linker) if 'NVIDIA Compilers and Tools' in out: cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) + linker = linkers.NvidiaHPC_DynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache, compiler, version, for_machine, env, linker=linker) @@ -562,14 +562,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if 'ARM' in out and not ('Metrowerks' in out or 'Freescale' in out): cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.ArmDynamicLinker(for_machine, version=version) + linker = linkers.ArmDynamicLinker(env, for_machine, version=version) return cls( ccache, compiler, version, for_machine, env, full_version=full_version, linker=linker) if 'RX Family' in out: cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.CcrxDynamicLinker(for_machine, version=version) + linker = linkers.CcrxDynamicLinker(env, for_machine, version=version) return cls( ccache, compiler, version, for_machine, env, full_version=full_version, linker=linker) @@ -588,7 +588,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin cls.gcc_version = _get_gnu_version_from_defines(defines) env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.Xc32DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) + linker = linkers.Xc32DynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache, compiler, version, for_machine, @@ -597,7 +597,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin else: cls = c.Xc16CCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.Xc16DynamicLinker(for_machine, version=version) + linker = linkers.Xc16DynamicLinker(env, for_machine, version=version) return cls( ccache, compiler, version, for_machine, env, @@ -606,7 +606,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if 'CompCert' in out: cls = c.CompCertCCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.CompCertDynamicLinker(for_machine, version=version) + linker = linkers.CompCertDynamicLinker(env, for_machine, version=version) return cls( ccache, compiler, version, for_machine, env, full_version=full_version, linker=linker) @@ -633,7 +633,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin assert mwld_ver_match is not None, 'for mypy' # because mypy *should* be complaining that this could be None linker_version = '.'.join(x for x in mwld_ver_match.groups() if x is not None) - linker = lnk(ld, for_machine, version=linker_version) + linker = lnk(ld, env, for_machine, version=linker_version) else: raise EnvironmentException(f'Failed to detect linker for {cls.id!r} compiler. Please update your cross file(s).') @@ -653,7 +653,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if ld is None: raise MesonException(f'{cls.language}_ld was not properly defined in your cross file') - linker = lnk(ld, for_machine, version=tasking_version) + linker = lnk(ld, env, for_machine, version=tasking_version) return cls( ccache, compiler, tasking_version, for_machine, env, full_version=full_version, linker=linker) @@ -708,7 +708,7 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp val = env.options[key] assert isinstance(val, list) env.coredata.optstore.set_option(key, cls.to_host_flags_base(val, Phase.LINKER)) - linker = CudaLinker(compiler, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version()) + linker = CudaLinker(compiler, env, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version()) return cls(ccache, compiler, version, for_machine, cpp_compiler, env, linker=linker) raise EnvironmentException(f'Could not find suitable CUDA compiler: "{"; ".join([" ".join(c) for c in compilers])}"') @@ -791,7 +791,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C target = 'x86' if 'IA-32' in err else 'x86_64' cls = fortran.IntelLLVMClFortranCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version) return cls( compiler, version, for_machine, env, target, linker=linker) @@ -801,7 +801,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C target = 'x86' if 'IA-32' in err else 'x86_64' cls = fortran.IntelClFortranCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) + linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version) return cls( compiler, version, for_machine, env, target, linker=linker) @@ -828,7 +828,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C if 'PGI Compilers' in out: cls = fortran.PGIFortranCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.PGIDynamicLinker(compiler, for_machine, + linker = linkers.PGIDynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( compiler, version, for_machine, env, @@ -837,7 +837,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C if 'NVIDIA Compilers and Tools' in out: cls = fortran.NvidiaHPC_FortranCompiler env.add_lang_args(cls.language, cls, for_machine) - linker = linkers.PGIDynamicLinker(compiler, for_machine, + linker = linkers.PGIDynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( compiler, version, for_machine, env, @@ -889,7 +889,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C cls = fortran.NAGFortranCompiler env.add_lang_args(cls.language, cls, for_machine) linker = linkers.NAGDynamicLinker( - compiler, for_machine, cls.LINKER_PREFIX, [], + compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( compiler, version, for_machine, env, @@ -1139,11 +1139,16 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust # so we can initialize a new copy for the Rust Compiler # TODO rewrite this without type: ignore assert cc.linker is not None, 'for mypy' + linker: DynamicLinker if is_link_exe: - linker = type(cc.linker)(for_machine, always_args, exelist=cc.linker.exelist, # type: ignore - version=cc.linker.version, **extra_args) # type: ignore + # TODO: Due to initializer mismatch we can't use the VisualStudioLikeMixin here + # But all of these ahve the same API so we can just pick one. + linker = T.cast('T.Type[linkers.MSVCDynamicLinker]', type(cc.linker))( + env, for_machine, always_args, + exelist=cc.linker.exelist, version=cc.linker.version, + **extra_args) # type: ignore else: - linker = type(cc.linker)(compiler, for_machine, cc.LINKER_PREFIX, + linker = type(cc.linker)(compiler, env, for_machine, cc.LINKER_PREFIX, always_args=always_args, system=cc.linker.system, version=cc.linker.version, **extra_args) elif 'link' in override[0]: diff --git a/mesonbuild/linkers/detect.py b/mesonbuild/linkers/detect.py index 5ff19ae3d..d9be37925 100644 --- a/mesonbuild/linkers/detect.py +++ b/mesonbuild/linkers/detect.py @@ -73,11 +73,11 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty if 'LLD' in o.split('\n', maxsplit=1)[0]: if 'compatible with GNU linkers' in o: return linkers.LLVMDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=search_version(o)) elif not invoked_directly: return linkers.ClangClDynamicLinker( - for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX, + env, for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX, version=search_version(o), direct=False, machine=None, rsp_syntax=rsp_syntax) @@ -88,13 +88,13 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty p, o, e = Popen_safe(compiler + check_args) if 'LLD' in o.split('\n', maxsplit=1)[0]: return linkers.ClangClDynamicLinker( - for_machine, [], + env, for_machine, [], prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [], exelist=compiler, version=search_version(o), direct=invoked_directly, rsp_syntax=rsp_syntax) elif 'OPTLINK' in o: # Optlink's stdout *may* begin with a \r character. - return linkers.OptlinkDynamicLinker(compiler, for_machine, version=search_version(o)) + return linkers.OptlinkDynamicLinker(compiler, env, for_machine, version=search_version(o)) elif o.startswith('Microsoft') or e.startswith('Microsoft'): out = o or e match = re.search(r'.*(X86|X64|ARM|ARM64).*', out) @@ -104,7 +104,7 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty target = 'x86' return linkers.MSVCDynamicLinker( - for_machine, [], machine=target, exelist=compiler, + env, for_machine, [], machine=target, exelist=compiler, prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [], version=search_version(out), direct=invoked_directly, rsp_syntax=rsp_syntax) @@ -170,13 +170,13 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty lld_cls = linkers.LLVMDynamicLinker linker = lld_cls( - compiler, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v) + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v) elif o.startswith("eld"): linker = linkers.ELDDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) elif 'Snapdragon' in e and 'LLVM' in e: linker = linkers.QualcommLLVMDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) elif e.startswith('lld-link: '): # The LLD MinGW frontend didn't respond to --version before version 9.0.0, # and produced an error message about failing to link (when no object @@ -194,7 +194,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty _, o, e = Popen_safe([linker_cmd, '--version']) v = search_version(o) - linker = linkers.LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) + linker = linkers.LLVMDynamicLinker(compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) elif 'GNU' in o or 'GNU' in e: gnu_cls: T.Type[GnuDynamicLinker] # this is always the only thing on stdout, except for swift @@ -205,7 +205,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty gnu_cls = linkers.MoldDynamicLinker else: gnu_cls = linkers.GnuBFDDynamicLinker - linker = gnu_cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) + linker = gnu_cls(compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) elif 'Solaris' in e or 'Solaris' in o: for line in (o+e).split('\n'): if 'ld: Software Generation Utilities' in line: @@ -214,7 +214,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty else: v = 'unknown version' linker = linkers.SolarisDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) elif 'ld: 0706-012 The -- flag is not recognized' in e: if isinstance(comp_class.LINKER_PREFIX, str): @@ -222,17 +222,17 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty else: _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-V'] + extra_args) linker = linkers.AIXDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=search_version(e)) elif o.startswith('zig ld'): linker = linkers.ZigCCDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v) # detect xtools first, bug #10805 elif 'xtools-' in o.split('\n', maxsplit=1)[0]: xtools = o.split(' ', maxsplit=1)[0] v = xtools.split('-', maxsplit=2)[1] linker = linkers.AppleDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v ) # detect linker on MacOS - must be after other platforms because the @@ -254,16 +254,16 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty else: __failed_to_detect_linker(compiler, check_args, o, e) linker = linkers.AppleDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v ) elif 'ld.exe: unrecognized option' in e: linker = linkers.OS2AoutDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version='none') elif 'emxomfld: invalid option' in e: linker = linkers.OS2OmfDynamicLinker( - compiler, for_machine, comp_class.LINKER_PREFIX, override, + compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version='none') else: __failed_to_detect_linker(compiler, check_args, o, e) diff --git a/mesonbuild/linkers/linkers.py b/mesonbuild/linkers/linkers.py index efb151bea..c53e482da 100644 --- a/mesonbuild/linkers/linkers.py +++ b/mesonbuild/linkers/linkers.py @@ -139,11 +139,12 @@ class DynamicLinker(metaclass=abc.ABCMeta): ret += self.prefix_arg + [arg] return ret - def __init__(self, exelist: T.List[str], + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]], always_args: T.List[str], *, system: str = 'unknown system', version: str = 'unknown version'): self.exelist = exelist + self.environment = env self.for_machine = for_machine self.system = system self.version = version @@ -972,11 +973,11 @@ class LLVMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, Dyna id = 'ld.lld' - def __init__(self, exelist: T.List[str], + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]], always_args: T.List[str], *, system: str = 'unknown system', version: str = 'unknown version'): - super().__init__(exelist, for_machine, prefix_arg, always_args, system=system, version=version) + super().__init__(exelist, env, for_machine, prefix_arg, always_args, system=system, version=version) # Some targets don't seem to support this argument (windows, wasm, ...) self.has_allow_shlib_undefined = self._supports_flag('--allow-shlib-undefined', always_args) @@ -1062,9 +1063,9 @@ class CcrxDynamicLinker(DynamicLinker): id = 'rlink' - def __init__(self, for_machine: mesonlib.MachineChoice, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(['rlink.exe'], for_machine, '', [], + super().__init__(['rlink.exe'], env, for_machine, '', [], version=version) def get_accepts_rsp(self) -> bool: @@ -1096,9 +1097,9 @@ class Xc16DynamicLinker(DynamicLinker): id = 'xc16-gcc' - def __init__(self, for_machine: mesonlib.MachineChoice, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(['xc16-gcc'], for_machine, '', [], + super().__init__(['xc16-gcc'], env, for_machine, '', [], version=version) def get_link_whole_for(self, args: T.List[str]) -> T.List[str]: @@ -1158,9 +1159,9 @@ class CompCertDynamicLinker(DynamicLinker): id = 'ccomp' - def __init__(self, for_machine: mesonlib.MachineChoice, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(['ccomp'], for_machine, '', [], + super().__init__(['ccomp'], env, for_machine, '', [], version=version) def get_link_whole_for(self, args: T.List[str]) -> T.List[str]: @@ -1200,9 +1201,9 @@ class TIDynamicLinker(DynamicLinker): id = 'ti' - def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice, + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(exelist, for_machine, '', [], + super().__init__(exelist, env, for_machine, '', [], version=version) def get_link_whole_for(self, args: T.List[str]) -> T.List[str]: @@ -1246,9 +1247,9 @@ class ArmDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker): id = 'armlink' - def __init__(self, for_machine: mesonlib.MachineChoice, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(['armlink'], for_machine, '', [], + super().__init__(['armlink'], env, for_machine, '', [], version=version) def get_accepts_rsp(self) -> bool: @@ -1393,12 +1394,12 @@ class VisualStudioLikeLinkerMixin(DynamicLinkerBase): 's': ['/INCREMENTAL:NO', '/OPT:REF'], } - def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice, - prefix_arg: T.Union[str, T.List[str]], always_args: T.List[str], *, - version: str = 'unknown version', direct: bool = True, machine: str = 'x86', - rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC): - # There's no way I can find to make mypy understand what's going on here - super().__init__(exelist, for_machine, prefix_arg, always_args, version=version) + def __init__(self, exelist: T.List[str], env: Environment, + for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]], + always_args: T.List[str], *, version: str = 'unknown version', + direct: bool = True, machine: str = 'x86', rsp_syntax: + RSPFileSyntax = RSPFileSyntax.MSVC): + super().__init__(exelist, env, for_machine, prefix_arg, always_args, version=version) self.machine = machine self.direct = direct self.rsp_syntax = rsp_syntax @@ -1457,12 +1458,13 @@ class MSVCDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker): id = 'link' - def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, + always_args: T.List[str], *, exelist: T.Optional[T.List[str]] = None, prefix: T.Union[str, T.List[str]] = '', machine: str = 'x86', version: str = 'unknown version', direct: bool = True, rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC): - super().__init__(exelist or ['link.exe'], for_machine, + super().__init__(exelist or ['link.exe'], env, for_machine, prefix, always_args, machine=machine, version=version, direct=direct, rsp_syntax=rsp_syntax) @@ -1482,12 +1484,13 @@ class ClangClDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker): id = 'lld-link' - def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, + always_args: T.List[str], *, exelist: T.Optional[T.List[str]] = None, prefix: T.Union[str, T.List[str]] = '', machine: str = 'x86', version: str = 'unknown version', direct: bool = True, rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC): - super().__init__(exelist or ['lld-link.exe'], for_machine, + super().__init__(exelist or ['lld-link.exe'], env, for_machine, prefix, always_args, machine=machine, version=version, direct=direct, rsp_syntax=rsp_syntax) @@ -1515,12 +1518,13 @@ class XilinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker): id = 'xilink' - def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *, + def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice, + always_args: T.List[str], *, exelist: T.Optional[T.List[str]] = None, prefix: T.Union[str, T.List[str]] = '', machine: str = 'x86', version: str = 'unknown version', direct: bool = True): - super().__init__(['xilink.exe'], for_machine, '', always_args, version=version) + super().__init__(['xilink.exe'], env, for_machine, '', always_args, version=version) def get_win_subsystem_args(self, value: str) -> T.List[str]: return self._apply_prefix([f'/SUBSYSTEM:{value.upper()}']) @@ -1667,11 +1671,11 @@ class OptlinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker): id = 'optlink' - def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice, + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): # Use optlink instead of link so we don't interfere with other link.exe # implementations. - super().__init__(exelist, for_machine, '', [], version=version) + super().__init__(exelist, env, for_machine, '', [], version=version) def get_allow_undefined_args(self) -> T.List[str]: return [] @@ -1738,9 +1742,9 @@ class CudaLinker(PosixDynamicLinkerMixin, DynamicLinker): class MetrowerksLinker(DynamicLinker): - def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice, + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(exelist, for_machine, '', [], + super().__init__(exelist, env, for_machine, '', [], version=version) def fatal_warnings(self) -> T.List[str]: @@ -1789,9 +1793,9 @@ class TaskingLinker(DynamicLinker): 's': ['-Os'], } - def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice, + def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice, *, version: str = 'unknown version'): - super().__init__(exelist, for_machine, '', [], + super().__init__(exelist, env, for_machine, '', [], version=version) def get_accepts_rsp(self) -> bool: diff --git a/unittests/internaltests.py b/unittests/internaltests.py index a1c18efba..8a3e2fd2e 100644 --- a/unittests/internaltests.py +++ b/unittests/internaltests.py @@ -214,9 +214,10 @@ class InternalTests(unittest.TestCase): def test_compiler_args_class_visualstudio(self): - linker = linkers.MSVCDynamicLinker(MachineChoice.HOST, []) + env = get_fake_env() + linker = linkers.MSVCDynamicLinker(env, MachineChoice.HOST, []) # Version just needs to be > 19.0.0 - cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, get_fake_env(), 'x64', linker=linker) + cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, env, 'x64', linker=linker) a = cc.compiler_args(cc.get_always_args()) self.assertEqual(a.to_native(copy=True), ['/nologo', '/showIncludes', '/utf-8', '/Zc:__cplusplus']) @@ -236,8 +237,9 @@ class InternalTests(unittest.TestCase): def test_compiler_args_class_gnuld(self): ## Test --start/end-group - linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', []) - gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, get_fake_env(), linker=linker) + env = get_fake_env() + linker = linkers.GnuBFDDynamicLinker([], env, MachineChoice.HOST, '-Wl,', []) + gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, env, linker=linker) ## Ensure that the fake compiler is never called by overriding the relevant function gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include'] ## Test that 'direct' append and extend works @@ -264,8 +266,9 @@ class InternalTests(unittest.TestCase): def test_compiler_args_remove_system(self): ## Test --start/end-group - linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', []) - gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, get_fake_env(), linker=linker) + env = get_fake_env() + linker = linkers.GnuBFDDynamicLinker([], env, MachineChoice.HOST, '-Wl,', []) + gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, env, linker=linker) ## Ensure that the fake compiler is never called by overriding the relevant function gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include'] ## Test that 'direct' append and extend works |