Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
14796 Commits
76 Branches
171 Tags
74 MiB
Tag: Branch: Tree: 814e581537
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '814e581537'
${ noResults }
meson/mesonbuild/linkers/detect.py

233 lines
10 KiB
Raw Normal View History Unescape

Use SPDX-License-Identifier consistently This replaces all of the Apache blurbs at the start of each file with an `# SPDX-License-Identifier: Apache-2.0` string. It also fixes existing uses to be consistent in capitalization, and to be placed above any copyright notices. This removes nearly 3000 lines of boilerplate from the project (only python files), which no developer cares to look at. SPDX is in common use, particularly in the Linux kernel, and is the recommended format for Meson's own `project(license: )` field
12 months ago
# SPDX-License-Identifier: Apache-2.0
linkers: Add support for mold linker [why] Support for the relatively new mold linker is missing. If someone wants to use mold as linker `LDFLAGS="-B/path/to/mold"` has to be added instead of the usual `CC_LD=mold meson ...` or `CXX_LD=mold meson ...`. [how] Allow `mold' as linker for clang and newer GCC versions (that versions that have support). The error message can be a bit off, because it is generic for all GNU like compilers, but I guess that is ok. (i.e. 'mold' is not listed as possible linker, even if it would be possible for the given compiler.) [note] GCC Version 12.0.1 is not sufficient to say `mold` is supported. The expected release with support will be 12.1.0. On the other hand people that use the un-released 12.0.1 will probably have built it from trunk. Allowing 12.0.1 is helping bleeding edge developers to use mold in Meson already now. Fixes: #9072 Signed-off-by: Fini Jastrow <ulf.fini.jastrow@desy.de>
3 years ago
# Copyright 2012-2022 The Meson development team
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
move a bunch of imports into TYPE_CHECKING blocks These are only used for type checking, so don't bother importing them at runtime. Generally add future annotations at the same time, to make sure that existing uses of these imports don't need to be quoted.
3 years ago
from __future__ import annotations
linkers: include linker detection output in the debug logs We do something similar when running get_compiler() method checks from the DSL. This ensures that if errors happen, the log file we tell people to check actually works.
2 years ago
from .. import mlog
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
from ..mesonlib import (
linkers: detection should invoke the linker with lang_link_args only Currently we invoke it with lang_args only, which is wrong and probably useless. Fixes misdetecting the linker when overridden as -fuse-ld, which led to Meson trying to pass incompatible flags, outright failing if CFLAGS contained flags that only work with a non-default linker, or in the most benevolent case, having the status log report the wrong linker.
2 years ago
EnvironmentException,
WIP: refactor loggable popen calls for consistency
1 year ago
Popen_safe, Popen_safe_logged, join_args, search_version
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
)
import re
import shlex
import typing as T
if T.TYPE_CHECKING:
move a bunch of imports into TYPE_CHECKING blocks These are only used for type checking, so don't bother importing them at runtime. Generally add future annotations at the same time, to make sure that existing uses of these imports don't need to be quoted.
3 years ago
from .linkers import DynamicLinker, GnuDynamicLinker
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
from ..environment import Environment
from ..compilers import Compiler
move a bunch of imports into TYPE_CHECKING blocks These are only used for type checking, so don't bother importing them at runtime. Generally add future annotations at the same time, to make sure that existing uses of these imports don't need to be quoted.
3 years ago
from ..mesonlib import MachineChoice
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
defaults: T.Dict[str, T.List[str]] = {}
defaults['static_linker'] = ['ar', 'gar']
defaults['vs_static_linker'] = ['lib']
defaults['clang_cl_static_linker'] = ['llvm-lib']
defaults['cuda_static_linker'] = ['nvlink']
defaults['gcc_static_linker'] = ['gcc-ar']
defaults['clang_static_linker'] = ['llvm-ar']
def __failed_to_detect_linker(compiler: T.List[str], args: T.List[str], stdout: str, stderr: str) -> 'T.NoReturn':
linkers: better reporting of command failures Use join_args to ensure that commands are rendered correctly and with less code.
2 years ago
msg = 'Unable to detect linker for compiler `{}`\nstdout: {}\nstderr: {}'.format(
join_args(compiler + args), stdout, stderr)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
raise EnvironmentException(msg)
def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Type['Compiler'],
linkers: Add support for mold linker [why] Support for the relatively new mold linker is missing. If someone wants to use mold as linker `LDFLAGS="-B/path/to/mold"` has to be added instead of the usual `CC_LD=mold meson ...` or `CXX_LD=mold meson ...`. [how] Allow `mold' as linker for clang and newer GCC versions (that versions that have support). The error message can be a bit off, because it is generic for all GNU like compilers, but I guess that is ok. (i.e. 'mold' is not listed as possible linker, even if it would be possible for the given compiler.) [note] GCC Version 12.0.1 is not sufficient to say `mold` is supported. The expected release with support will be 12.1.0. On the other hand people that use the un-released 12.0.1 will probably have built it from trunk. Allowing 12.0.1 is helping bleeding edge developers to use mold in Meson already now. Fixes: #9072 Signed-off-by: Fini Jastrow <ulf.fini.jastrow@desy.de>
3 years ago
comp_version: str, for_machine: MachineChoice, *,
fix various flake8 whitespace errors
3 years ago
use_linker_prefix: bool = True, invoked_directly: bool = True,
extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
from . import linkers
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
# Explicitly pass logo here so that we can get the version of link.exe
if not use_linker_prefix or comp_class.LINKER_PREFIX is None:
check_args = ['/logo', '--version']
elif isinstance(comp_class.LINKER_PREFIX, str):
check_args = [comp_class.LINKER_PREFIX + '/logo', comp_class.LINKER_PREFIX + '--version']
pylint: fix false positive for missing else branch We cover every case as if/elif/elif. mypy can handle this fine, but pylint doesn't do control flow or type checking and thinks in the missing else case, the variable might not be defined. For mypy as well, doing this instance check is unnecessary as it can be inferred. So just micro-optimize the check and allow pylint to safely analyze the logic.
6 months ago
else: # list
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
check_args = comp_class.LINKER_PREFIX + ['/logo'] + comp_class.LINKER_PREFIX + ['--version']
linkers: detection should invoke the linker with lang_link_args only Currently we invoke it with lang_args only, which is wrong and probably useless. Fixes misdetecting the linker when overridden as -fuse-ld, which led to Meson trying to pass incompatible flags, outright failing if CFLAGS contained flags that only work with a non-default linker, or in the most benevolent case, having the status log report the wrong linker.
2 years ago
check_args += env.coredata.get_external_link_args(for_machine, comp_class.language)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
treewide: automatic rewriting of all comment-style type annotations Performed using https://github.com/ilevkivskyi/com2ann This has no actual effect on the codebase as type checkers (still) support both and negligible effect on runtime performance since __future__ annotations ameliorates that. Technically, the bytecode would be bigger for non function-local annotations, of which we have many either way. So if it doesn't really matter, why do a large-scale refactor? Simple: because people keep wanting to, but it's getting nickle-and-dimed. If we're going to do this we might as well do it consistently in one shot, using tooling that guarantees repeatability and correctness. Repeat with: ``` com2ann mesonbuild/ ```
1 year ago
override: T.List[str] = []
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
if value is not None:
linkers: Add support for mold linker [why] Support for the relatively new mold linker is missing. If someone wants to use mold as linker `LDFLAGS="-B/path/to/mold"` has to be added instead of the usual `CC_LD=mold meson ...` or `CXX_LD=mold meson ...`. [how] Allow `mold' as linker for clang and newer GCC versions (that versions that have support). The error message can be a bit off, because it is generic for all GNU like compilers, but I guess that is ok. (i.e. 'mold' is not listed as possible linker, even if it would be possible for the given compiler.) [note] GCC Version 12.0.1 is not sufficient to say `mold` is supported. The expected release with support will be 12.1.0. On the other hand people that use the un-released 12.0.1 will probably have built it from trunk. Allowing 12.0.1 is helping bleeding edge developers to use mold in Meson already now. Fixes: #9072 Signed-off-by: Fini Jastrow <ulf.fini.jastrow@desy.de>
3 years ago
override = comp_class.use_linker_args(value[0], comp_version)
compilers: Forward Meson's preference of lld-link to clang-cl The latter prefers LINK.exe by default, which rejects GNU-like linker flags.
1 year ago
check_args += override
elif 'lld-link' in compiler:
override = comp_class.use_linker_args('lld-link', comp_version)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
check_args += override
if extra_args is not None:
check_args.extend(extra_args)
p, o, _ = Popen_safe(compiler + check_args)
pylint: enable use-maxsplit-arg This finds a bunch of places where we can do more efficient string splitting.
2 years ago
if 'LLD' in o.split('\n', maxsplit=1)[0]:
linkers: Loosen the check for GNU interface style in LLD for Windows Don't require the string to be enclosed in parentheses. https://github.com/llvm/llvm-project/pull/97323 changed the LLD version printout to no longer be enclosed in parentheses, which made Meson fail to detect the linker style used here. The LLD change is being reverted in https://github.com/llvm/llvm-project/pull/97698 in order to fix building with existing Meson versions, but for the future, loosen the check slightly, to not require the parentheses.
5 months ago
if 'compatible with GNU linkers' in o:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
return linkers.LLVMDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
compiler, for_machine, comp_class.LINKER_PREFIX,
override, version=search_version(o))
elif not invoked_directly:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
return linkers.ClangClDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX,
version=search_version(o), direct=False, machine=None)
if value is not None and invoked_directly:
compiler = value
fix various spelling issues Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>
2 years ago
# We've already handled the non-direct case above
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
p, o, e = Popen_safe(compiler + check_args)
pylint: enable use-maxsplit-arg This finds a bunch of places where we can do more efficient string splitting.
2 years ago
if 'LLD' in o.split('\n', maxsplit=1)[0]:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
return linkers.ClangClDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
for_machine, [],
prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
exelist=compiler, version=search_version(o), direct=invoked_directly)
elif 'OPTLINK' in o:
Fix various spelling errors Found with codespell.
2 years ago
# Optlink's stdout *may* begin with a \r character.
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
return linkers.OptlinkDynamicLinker(compiler, for_machine, version=search_version(o))
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
elif o.startswith('Microsoft') or e.startswith('Microsoft'):
out = o or e
match = re.search(r'.*(X86|X64|ARM|ARM64).*', out)
if match:
target = str(match.group(1))
else:
target = 'x86'
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
return linkers.MSVCDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
for_machine, [], machine=target, exelist=compiler,
prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
version=search_version(out), direct=invoked_directly)
elif 'GNU coreutils' in o:
Improve linker detection failure error message.
3 years ago
import shutil
fullpath = shutil.which(compiler[0])
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
raise EnvironmentException(
fix typo in error message breaking newline escape Broken in commit 3feaea6b29197cd224fbce0ac65fd43d08c3beac.
3 years ago
f"Found GNU link.exe instead of MSVC link.exe in {fullpath}.\n"
Improve linker detection failure error message.
3 years ago
"This link.exe is not a linker.\n"
"You may need to reorder entries to your %PATH% variable to resolve this.")
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
__failed_to_detect_linker(compiler, check_args, o, e)
def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Type['Compiler'],
flake8: fix various whitespace nits
2 years ago
comp_version: str, for_machine: MachineChoice, *,
fix various flake8 whitespace errors
3 years ago
extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
"""Helper for guessing what linker to use on Unix-Like OSes.
:compiler: Invocation to use to get linker
:comp_class: The Compiler Type (uninstantiated)
linkers: Add support for mold linker [why] Support for the relatively new mold linker is missing. If someone wants to use mold as linker `LDFLAGS="-B/path/to/mold"` has to be added instead of the usual `CC_LD=mold meson ...` or `CXX_LD=mold meson ...`. [how] Allow `mold' as linker for clang and newer GCC versions (that versions that have support). The error message can be a bit off, because it is generic for all GNU like compilers, but I guess that is ok. (i.e. 'mold' is not listed as possible linker, even if it would be possible for the given compiler.) [note] GCC Version 12.0.1 is not sufficient to say `mold` is supported. The expected release with support will be 12.1.0. On the other hand people that use the un-released 12.0.1 will probably have built it from trunk. Allowing 12.0.1 is helping bleeding edge developers to use mold in Meson already now. Fixes: #9072 Signed-off-by: Fini Jastrow <ulf.fini.jastrow@desy.de>
3 years ago
:comp_version: The compiler version string
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
:for_machine: which machine this linker targets
:extra_args: Any additional arguments required (such as a source file)
"""
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
from . import linkers
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
extra_args = extra_args or []
fix linker regression for compilers that don't accept LDFLAGS directly e.g. ldc -- the compiler needs to process args before consuming them. Fixes #10693
2 years ago
ldflags = env.coredata.get_external_link_args(for_machine, comp_class.language)
extra_args += comp_class._unix_args_to_native(ldflags, env.machines[for_machine])
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
if isinstance(comp_class.LINKER_PREFIX, str):
check_args = [comp_class.LINKER_PREFIX + '--version'] + extra_args
else:
check_args = comp_class.LINKER_PREFIX + ['--version'] + extra_args
treewide: automatic rewriting of all comment-style type annotations Performed using https://github.com/ilevkivskyi/com2ann This has no actual effect on the codebase as type checkers (still) support both and negligible effect on runtime performance since __future__ annotations ameliorates that. Technically, the bytecode would be bigger for non function-local annotations, of which we have many either way. So if it doesn't really matter, why do a large-scale refactor? Simple: because people keep wanting to, but it's getting nickle-and-dimed. If we're going to do this we might as well do it consistently in one shot, using tooling that guarantees repeatability and correctness. Repeat with: ``` com2ann mesonbuild/ ```
1 year ago
override: T.List[str] = []
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
if value is not None:
linkers: Add support for mold linker [why] Support for the relatively new mold linker is missing. If someone wants to use mold as linker `LDFLAGS="-B/path/to/mold"` has to be added instead of the usual `CC_LD=mold meson ...` or `CXX_LD=mold meson ...`. [how] Allow `mold' as linker for clang and newer GCC versions (that versions that have support). The error message can be a bit off, because it is generic for all GNU like compilers, but I guess that is ok. (i.e. 'mold' is not listed as possible linker, even if it would be possible for the given compiler.) [note] GCC Version 12.0.1 is not sufficient to say `mold` is supported. The expected release with support will be 12.1.0. On the other hand people that use the un-released 12.0.1 will probably have built it from trunk. Allowing 12.0.1 is helping bleeding edge developers to use mold in Meson already now. Fixes: #9072 Signed-off-by: Fini Jastrow <ulf.fini.jastrow@desy.de>
3 years ago
override = comp_class.use_linker_args(value[0], comp_version)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
check_args += override
linkers: include linker detection output in the debug logs We do something similar when running get_compiler() method checks from the DSL. This ensures that if errors happen, the log file we tell people to check actually works.
2 years ago
mlog.debug('-----')
WIP: refactor loggable popen calls for consistency
1 year ago
p, o, e = Popen_safe_logged(compiler + check_args, msg='Detecting linker via')
linkers: include linker detection output in the debug logs We do something similar when running get_compiler() method checks from the DSL. This ensures that if errors happen, the log file we tell people to check actually works.
2 years ago
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
v = search_version(o + e)
linker: DynamicLinker
Basic support for TI ARM-CLANG toolchain
2 years ago
if 'LLD' in o.split('\n', maxsplit=1)[0] or 'tiarmlnk' in e:
linkers: detect ld64 as AppleDynamicLinker
2 years ago
if isinstance(comp_class.LINKER_PREFIX, str):
cmd = compiler + override + [comp_class.LINKER_PREFIX + '-v'] + extra_args
else:
cmd = compiler + override + comp_class.LINKER_PREFIX + ['-v'] + extra_args
WIP: refactor loggable popen calls for consistency
1 year ago
_, newo, newerr = Popen_safe_logged(cmd, msg='Detecting LLD linker via')
linkers: detect ld64 as AppleDynamicLinker
2 years ago
lld_cls: T.Type[DynamicLinker]
if 'ld64.lld' in newerr:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
lld_cls = linkers.LLVMLD64DynamicLinker
linkers: detect ld64 as AppleDynamicLinker
2 years ago
else:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
lld_cls = linkers.LLVMDynamicLinker
linkers: detect ld64 as AppleDynamicLinker
2 years ago
linker = lld_cls(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
elif 'Snapdragon' in e and 'LLVM' in e:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
linker = linkers.QualcommLLVMDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
compiler, 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
# files were specified), instead of printing the version number.
# Let's try to extract the linker invocation command to grab the version.
_, o, e = Popen_safe(compiler + check_args + ['-v'])
try:
linker_cmd = re.match(r'.*\n(.*?)\nlld-link: ', e, re.DOTALL).group(1)
linker_cmd = shlex.split(linker_cmd)[0]
except (AttributeError, IndexError, ValueError):
pass
else:
_, o, e = Popen_safe([linker_cmd, '--version'])
v = search_version(o)
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
linker = linkers.LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
linkers_detect: detect xtools (Apple ld64 derivative) xtools is in use on Gentoo Prefix x86_64 and ppc based Darwin installs. Pick it up as a valid linker. Since xtools is answering with a version to --version, as opposed to ld64, detection of xtools in the ld64 handling block is not possible, since --version already succeeded. Bug: https://bugs.gentoo.org/868516 Bug: https://github.com/mesonbuild/meson/issues/10805 Signed-off-by: Fabian Groffen <grobian@gentoo.org> Signed-off-by: Eli Schwartz <eschwartz93@gmail.com>
10 months ago
# 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, version=v)
Handle macos linker reporting error message in pluring during detection Previously macos reported "ld: unknown option: --version" when being passed --version, but now sometimes it reports in plural, albeit without an obvious pattern when. To handle that, simply just check for the prefix without the : Fixes: https://github.com/mesonbuild/meson/issues/12552
1 year ago
# First might be apple clang, second is for real gcc, the third is icc.
# Note that "ld: unknown option: " sometimes instead is "ld: unknown options:".
elif e.endswith('(use -v to see invocation)\n') or 'macosx_version' in e or 'ld: unknown option' in e:
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
if isinstance(comp_class.LINKER_PREFIX, str):
linkers: make sure the linker is actually Apple when matching failure Not all "use -v" errors are Apple ld, and if it doesn't have better output with -v instead of --version, we should not assume that is what it is.
2 years ago
cmd = compiler + [comp_class.LINKER_PREFIX + '-v'] + extra_args
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
else:
linkers: make sure the linker is actually Apple when matching failure Not all "use -v" errors are Apple ld, and if it doesn't have better output with -v instead of --version, we should not assume that is what it is.
2 years ago
cmd = compiler + comp_class.LINKER_PREFIX + ['-v'] + extra_args
WIP: refactor loggable popen calls for consistency
1 year ago
_, newo, newerr = Popen_safe_logged(cmd, msg='Detecting Apple linker via')
linkers: make sure the linker is actually Apple when matching failure Not all "use -v" errors are Apple ld, and if it doesn't have better output with -v instead of --version, we should not assume that is what it is.
2 years ago
for line in newerr.split('\n'):
Fix Xcode 15 beta linker detection. Closes #11958.
1 year ago
if 'PROJECT:ld' in line or 'PROJECT:dyld' in line:
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
v = line.split('-')[1]
break
else:
linkers: make sure the linker is actually Apple when matching failure Not all "use -v" errors are Apple ld, and if it doesn't have better output with -v instead of --version, we should not assume that is what it is.
2 years ago
__failed_to_detect_linker(compiler, check_args, o, e)
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
linker = linkers.AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
elif 'GNU' in o or 'GNU' in e:
linkers: detect ld64 as AppleDynamicLinker
2 years ago
gnu_cls: T.Type[GnuDynamicLinker]
linkers: try a bit harder to autodetect the correct linker id mingw GCC using ld.bfd emits diagnostics that include "-plugin-opt=-pass-through=-lmoldname" and this triggers a match for mold when it should not. Instead, always check the very beginning of the output for the linker id. This is pretty consistent: - it is always on stdout - GCC may put additional things on stderr we don't care about - swift is bizarre and on some OSes redirects the linker stdout to swiftc's stderr, but it will still be the only stderr; we didn't even check stderr at all until commit 712cbe056811ebdf0d7358ba07a874717a1c736f For gold/bfd linkers, the linker id is always the *second* word, after the legally mandated "GNU" we already check for.
3 years ago
# this is always the only thing on stdout, except for swift
# which may or may not redirect the linker stdout to stderr
if o.startswith('GNU gold') or e.startswith('GNU gold'):
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
gnu_cls = linkers.GnuGoldDynamicLinker
linkers: try a bit harder to autodetect the correct linker id mingw GCC using ld.bfd emits diagnostics that include "-plugin-opt=-pass-through=-lmoldname" and this triggers a match for mold when it should not. Instead, always check the very beginning of the output for the linker id. This is pretty consistent: - it is always on stdout - GCC may put additional things on stderr we don't care about - swift is bizarre and on some OSes redirects the linker stdout to swiftc's stderr, but it will still be the only stderr; we didn't even check stderr at all until commit 712cbe056811ebdf0d7358ba07a874717a1c736f For gold/bfd linkers, the linker id is always the *second* word, after the legally mandated "GNU" we already check for.
3 years ago
elif o.startswith('mold') or e.startswith('mold'):
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
gnu_cls = linkers.MoldDynamicLinker
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
else:
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
gnu_cls = linkers.GnuBFDDynamicLinker
linkers: detect ld64 as AppleDynamicLinker
2 years ago
linker = gnu_cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
elif 'Solaris' in e or 'Solaris' in o:
for line in (o+e).split('\n'):
if 'ld: Software Generation Utilities' in line:
v = line.split(':')[2].lstrip()
break
else:
v = 'unknown version'
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
linker = linkers.SolarisDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
compiler, 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):
_, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-V'] + extra_args)
else:
_, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-V'] + extra_args)
linkers: delay implementations import until detect is run This saves on a 1500-line import at startup and may be skipped entirely if no compiled languages are used. In exchange, we move the implementation to a new file that is imported instead. Followup to commit ab20eb5bbc21ae855bcd211131132d2778602bcf.
2 years ago
linker = linkers.AIXDynamicLinker(
Split compiler detection from Environment This moves all the compiler detection logic into the new compilers.detect module. This dramatically reduces the size and complexity of Environment.
4 years ago
compiler, for_machine, comp_class.LINKER_PREFIX, override,
version=search_version(e))
else:
__failed_to_detect_linker(compiler, check_args, o, e)
return linker