from collections import OrderedDict from configparser import ConfigParser import locale from pathlib import Path import shutil import subprocess import tempfile from typing import Callable, Dict, List, Optional, Mapping, Sequence, Tuple from . import winenv from .machine_file import strv_to_meson from .machine_spec import MachineSpec def init_machine_config(machine: MachineSpec, build_machine: MachineSpec, is_cross_build: bool, environ: Dict[str, str], toolchain_prefix: Optional[Path], sdk_prefix: Optional[Path], call_selected_meson: Callable, config: ConfigParser, outpath: List[str], outenv: Dict[str, str], outdir: Path, apple_min_os: Optional[Dict[str, str]] = None): allow_undefined_symbols = machine.os == "freebsd" options = config["built-in options"] options["c_args"] = "c_like_flags" options["cpp_args"] = "c_like_flags + cxx_like_flags" options["c_link_args"] = "linker_flags" options["cpp_link_args"] = "linker_flags + cxx_link_flags" options["b_lundef"] = str(not allow_undefined_symbols).lower() binaries = config["binaries"] cc = None common_flags = [] c_like_flags = [] linker_flags = [] cxx_like_flags = [] cxx_link_flags = [] triplet = machine.triplet if triplet is not None: try: cc, gcc_binaries = resolve_gcc_binaries(toolprefix=triplet + "-") binaries.update(gcc_binaries) except CompilerNotFoundError: pass diagnostics = None if cc is None: with tempfile.TemporaryDirectory() as raw_prober_dir: prober_dir = Path(raw_prober_dir) machine_file = prober_dir / "machine.txt" argv = [ "env2mfile", "-o", machine_file, "--native" if machine == build_machine else "--cross", ] if machine != build_machine: argv += [ "--system", machine.system, "--subsystem", machine.subsystem, "--kernel", machine.kernel, "--cpu-family", machine.cpu_family, "--cpu", machine.cpu, "--endian", machine.endian, ] process = call_selected_meson(argv, cwd=raw_prober_dir, env=environ, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, encoding=locale.getpreferredencoding()) if process.returncode == 0: mcfg = ConfigParser() mcfg.read(machine_file) for section in mcfg.sections(): copy = config[section] if section in config else OrderedDict() for key, val in mcfg.items(section): if section == "binaries": argv = eval(val.replace("\\", "\\\\")) if not Path(argv[0]).is_absolute(): path = shutil.which(argv[0]) if path is None: raise BinaryNotFoundError(f"unable to locate {argv[0]}") argv[0] = path val = strv_to_meson(argv) if key in {"c", "cpp"}: val += " + common_flags" if key in copy and section == "built-in options" and key.endswith("_args"): val = val + " + " + copy[key] copy[key] = val config[section] = copy raw_cc = binaries.get("c", None) if raw_cc is not None: cc = eval(raw_cc.replace("\\", "\\\\"), None, {"common_flags": []}) else: diagnostics = process.stdout linker_flavor = None if cc is not None \ and machine.os == "windows" \ and machine.toolchain_is_msvc: try: linker_flavor = detect_linker_flavor(cc) except LinkerDetectionError: pass detected_wrong_toolchain = linker_flavor != "msvc" if detected_wrong_toolchain: cc = None linker_flavor = None if cc is None: if machine.os == "windows": detect_tool_path = lambda name: winenv.detect_msvs_tool_path(machine, build_machine, name, toolchain_prefix) cc = [str(detect_tool_path("cl.exe"))] lib = [str(detect_tool_path("lib.exe"))] link = [str(detect_tool_path("link.exe"))] assembler_name = MSVC_ASSEMBLER_NAMES[machine.arch] assembler_tool = [str(detect_tool_path(assembler_name + ".exe"))] raw_cc = strv_to_meson(cc) + " + common_flags" binaries["c"] = raw_cc binaries["cpp"] = raw_cc binaries["lib"] = strv_to_meson(lib) + " + common_flags" binaries["link"] = strv_to_meson(link) + " + common_flags" binaries[assembler_name] = strv_to_meson(assembler_tool) + " + common_flags" runtime_dirs = winenv.detect_msvs_runtime_path(machine, build_machine, toolchain_prefix) outpath.extend(runtime_dirs) vs_dir = winenv.detect_msvs_installation_dir(toolchain_prefix) outenv["VSINSTALLDIR"] = str(vs_dir) + "\\" outenv["VCINSTALLDIR"] = str(vs_dir / "VC") + "\\" outenv["Platform"] = machine.msvc_platform outenv["INCLUDE"] = ";".join([str(path) for path in winenv.detect_msvs_include_path(toolchain_prefix)]) outenv["LIB"] = ";".join([str(path) for path in winenv.detect_msvs_library_path(machine, toolchain_prefix)]) elif machine != build_machine \ and "CC" not in environ \ and "CFLAGS" not in environ \ and machine.os == build_machine.os \ and machine.os == "linux" \ and machine.pointer_size == 4 \ and build_machine.pointer_size == 8: try: cc, gcc_binaries = resolve_gcc_binaries() binaries.update(gcc_binaries) common_flags += ["-m32"] except CompilerNotFoundError: pass if cc is None: suffix = ":\n" + diagnostics if diagnostics is not None else "" raise CompilerNotFoundError("no C compiler found" + suffix) if "cpp" not in binaries: raise CompilerNotFoundError("no C++ compiler found") if linker_flavor is None: linker_flavor = detect_linker_flavor(cc) strip_binary = binaries.get("strip", None) if strip_binary is not None: strip_arg = "-Sx" if linker_flavor == "apple" else "--strip-all" binaries["strip"] = strip_binary[:-1] + f", '{strip_arg}']" if linker_flavor == "msvc": for gnu_tool in ["ar", "as", "ld", "nm", "objcopy", "objdump", "ranlib", "readelf", "size", "strip", "windres"]: binaries.pop(gnu_tool, None) c_like_flags += [ "/GS-", "/Gy", "/Zc:inline", "/fp:fast", ] if machine.arch == "x86": c_like_flags += ["/arch:SSE2"] # Relax C++11 compliance for XP compatibility. cxx_like_flags += ["/Zc:threadSafeInit-"] else: if machine.os == "qnx": common_flags += ARCH_COMMON_FLAGS_QNX.get(machine.arch, []) else: common_flags += ARCH_COMMON_FLAGS_UNIX.get(machine.arch, []) c_like_flags += ARCH_C_LIKE_FLAGS_UNIX.get(machine.arch, []) c_like_flags += [ "-ffunction-sections", "-fdata-sections", ] if linker_flavor.startswith("gnu-"): linker_flags += ["-static-libgcc"] if machine.os != "windows": linker_flags += ["-Wl,-z,noexecstack"] if machine.os not in {"windows", "none"}: linker_flags += ["-Wl,-z,relro"] cxx_link_flags += ["-static-libstdc++"] if linker_flavor == "apple": linker_flags += ["-Wl,-dead_strip"] else: linker_flags += ["-Wl,--gc-sections"] if linker_flavor == "gnu-gold": linker_flags += ["-Wl,--icf=all"] if machine.os == "none": linker_flags += ["-specs=nosys.specs"] constants = config["constants"] constants["common_flags"] = strv_to_meson(common_flags) constants["c_like_flags"] = strv_to_meson(c_like_flags) constants["linker_flags"] = strv_to_meson(linker_flags) constants["cxx_like_flags"] = strv_to_meson(cxx_like_flags) constants["cxx_link_flags"] = strv_to_meson(cxx_link_flags) def resolve_gcc_binaries(toolprefix: str = "") -> Tuple[List[str], Dict[str, str]]: cc = None binaries = OrderedDict() for identifier in GCC_TOOL_IDS: name = GCC_TOOL_NAMES.get(identifier, identifier) full_name = toolprefix + name val = shutil.which(full_name) if val is None: raise CompilerNotFoundError(f"missing {full_name}") # QNX SDP 6.5 gcc-* tools are broken, erroring out with: # > sorry - this program has been built without plugin support # We detect this and use the tool without the gcc-* prefix. if name.startswith("gcc-"): p = subprocess.run([val, "--version"], capture_output=True) if p.returncode != 0: full_name = toolprefix + name[4:] val = shutil.which(full_name) if val is None: raise CompilerNotFoundError(f"missing {full_name}") if identifier == "c": cc = [val] extra = " + common_flags" if identifier in {"c", "cpp"} else "" binaries[identifier] = strv_to_meson([val]) + extra return (cc, binaries) def detect_linker_flavor(cc: List[str]) -> str: linker_version = subprocess.run(cc + ["-Wl,--version"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, encoding=locale.getpreferredencoding()).stdout if "Microsoft " in linker_version: return "msvc" if "GNU ld " in linker_version: return "gnu-ld" if "GNU gold " in linker_version: return "gnu-gold" if linker_version.startswith("LLD ") or "compatible with GNU linkers" in linker_version: return "lld" if linker_version.startswith("ld: "): return "apple" excerpt = linker_version.split("\n")[0].rstrip() raise LinkerDetectionError(f"unknown linker: '{excerpt}'") class CompilerNotFoundError(Exception): pass class BinaryNotFoundError(Exception): pass class LinkerDetectionError(Exception): pass ARCH_COMMON_FLAGS_UNIX = { "x86": [ "-march=pentium4", ], "arm": [ "-march=armv5t", "-mthumb", ], "armbe8": [ "-mcpu=cortex-a72", "-mthumb", ], "armhf": [ "-march=armv7-a", "-mtune=cortex-a7", "-mfpu=neon-vfpv4", "-mthumb", ], "armv6kz": [ "-march=armv6kz", "-mcpu=arm1176jzf-s", ], "arm64": [ "-march=armv8-a", ], "mips": [ "-march=mips1", "-mfp32", ], "mipsel": [ "-march=mips1", "-mfp32", ], "mips64": [ "-march=mips64r2", "-mabi=64", ], "mips64el": [ "-march=mips64r2", "-mabi=64", ], "s390x": [ "-march=z10", "-m64", ], } ARCH_COMMON_FLAGS_QNX = { "x86": [ "-march=i686", ], "arm": [ "-march=armv6", "-mno-unaligned-access", ], "armeabi": [ "-march=armv7-a", "-mno-unaligned-access", ], } ARCH_C_LIKE_FLAGS_UNIX = { "x86": [ "-mfpmath=sse", "-mstackrealign", ], } GCC_TOOL_IDS = [ "c", "cpp", "ar", "nm", "ranlib", "strip", "readelf", "objcopy", "objdump", ] GCC_TOOL_NAMES = { "c": "gcc", "cpp": "g++", "ar": "gcc-ar", "nm": "gcc-nm", "ranlib": "gcc-ranlib", } MSVC_ASSEMBLER_NAMES = { "x86": "ml", "x86_64": "ml64", "arm64": "armasm64", }