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() if machine.config == "softfloat": options["b_staticpic"] = "false" 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 include_paths = winenv.detect_msvs_include_path(toolchain_prefix) library_paths = winenv.detect_msvs_library_path(machine, toolchain_prefix) # The flags scope the paths per-machine, which cross builds need as # the build and host toolchains differ. The environment additionally # reaches the build-machine compiler in a native build, whose native # targets don't pick up the host machine's compiler flags. for path in include_paths: c_like_flags += [f"/I{path}"] for path in library_paths: linker_flags += [f"/LIBPATH:{path}"] outenv["INCLUDE"] = ";".join([str(path) for path in include_paths]) outenv["LIB"] = ";".join([str(path) for path in library_paths]) 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, []) bare_softfloat = machine.os == "none" and machine.config == "softfloat" if machine.config == "softfloat": common_flags += ARCH_SOFTFLOAT_FLAGS_UNIX.get(machine.arch, []) if bare_softfloat: common_flags += [f"--target={machine.cpu_family}-none-elf"] # picolibc is a package like any other here, so the libc lives in the # SDK rather than beside the compiler. While rolling there is no SDK # yet, and the prefix being filled is what to compile against. Not # -resource-dir: that is where the compiler keeps its own float.h, and # aiming it at either of those loses it. sysroot = sdk_prefix if sdk_prefix is not None else environ.get("FRIDA_HOST_SYSROOT") if sysroot is not None: common_flags += [f"--sysroot={sysroot}"] c_like_flags += [ "-ffunction-sections", "-fdata-sections", ] if bare_softfloat: # The host's GNU ld cannot be told to target this. Name the runtime # ourselves too: clang would look for its own copy beside the compiler, # and the one that matches this ABI is the one in the sysroot. linker_flags += [ "-fuse-ld=lld", "-nostdlib", "-lc", "-lclang_rt.builtins", # Nothing here ends up in an executable, but configure checks do, and # the C library leaves its console and heap bounds to whatever # environment it lands in. Lend them picolibc's own stub host and an # empty heap, so those links fail only over the symbol being checked. "-ldummyhost", "-Wl,--defsym=__heap_start=0", "-Wl,--defsym=__heap_end=0", ] elif 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"] elif not bare_softfloat: # Would leave a link with no entry point holding on to nothing at all, # and every configure check that links would then trivially pass. linker_flags += ["-Wl,--gc-sections"] if linker_flavor == "gnu-gold": linker_flags += ["-Wl,--icf=all"] # newlib's syscall stubs; the soft-float flavour brings picolibc instead. if machine.os == "none" and machine.config != "softfloat": 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", ], } # AAPCS64 mandates hardware FP, so only clang can pass doubles in general-purpose # registers. x18 and -fno-pic travel with it because the first host needing this is # the Linux arm64 kernel, which reserves the former and whose module loader rejects # GOT relocations. ARCH_SOFTFLOAT_FLAGS_UNIX = { "arm64": [ "-mabi=aapcs-soft", "-mgeneral-regs-only", "-ffixed-x18", "-fno-pic", ], } 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", }