import argparse import os from pathlib import Path import pickle import platform import re import shlex import shutil import subprocess import sys from typing import Any, Callable, Dict, List, Optional, Set, Tuple RELENG_DIR = Path(__file__).resolve().parent SCRIPTS_DIR = RELENG_DIR / "meson-scripts" sys.path.insert(0, str(RELENG_DIR / "meson")) import mesonbuild.interpreter from mesonbuild.coredata import UserArrayOption, UserBooleanOption, \ UserComboOption, UserFeatureOption, UserOption, UserStringOption from . import deps, env, env_apple from .machine_spec import MachineSpec from .progress import ProgressCallback, print_progress def main(): default_sourcedir = Path(sys.argv.pop(1)) sourcedir = Path(os.environ.get("MESON_SOURCE_ROOT", default_sourcedir)).resolve() workdir = Path(os.getcwd()) if workdir == sourcedir: default_builddir = sourcedir / "build" else: default_builddir = workdir builddir = Path(os.environ.get("MESON_BUILD_ROOT", default_builddir)).resolve() parser = argparse.ArgumentParser(prog="configure", add_help=False, formatter_class=argparse.RawTextHelpFormatter) opts = parser.add_argument_group(title="generic options") opts.add_argument("-h", "--help", help="show this help message and exit", action="help") opts.add_argument("--prefix", help="install files in PREFIX", metavar="PREFIX", type=parse_prefix) opts.add_argument("--build", help="configure for building on BUILD", metavar="BUILD", type=MachineSpec.parse) opts.add_argument("--host", help="cross-compile to build binaries to run on HOST", metavar="HOST", type=MachineSpec.parse) opts.add_argument("--enable-symbols", help="build binaries with debug symbols included (default: disabled)", action="store_true") opts.add_argument("--enable-shared", help="enable building shared libraries (default: disabled)", action="store_true") opts.add_argument("--with-meson", help="which Meson implementation to use (default: internal)", choices=["internal", "system"], dest="meson", default="internal") opts.add_argument(f"--without-prebuilds", help="do not make use of prebuilt bundles", metavar="{" + ",".join(query_supported_bundle_types(include_wildcards=True)) + "}", type=parse_bundle_type_set, default=set()) opts.add_argument("--with-apple-min-os", help="override Apple deployment target floor for one platform;\n" "may be given multiple times. Defaults:\n" " " + ", ".join(f"{k}={v}" for k, v in env_apple.APPLE_MINIMUM_OS_VERSIONS.items()), metavar="PLATFORM=VERSION", type=parse_apple_min_os_override, action="append", default=[]) opts.add_argument("extra_meson_options", nargs="*", help=argparse.SUPPRESS) meson_options_file = sourcedir / "meson.options" if not meson_options_file.exists(): meson_options_file = sourcedir / "meson_options.txt" if meson_options_file.exists(): meson_group = parser.add_argument_group(title="project-specific options") meson_opts = register_meson_options(meson_options_file, meson_group) options = parser.parse_args() if builddir.exists(): if (builddir / "build.ninja").exists(): print(f"Already configured. Wipe .{os.sep}{builddir.relative_to(workdir)} to reconfigure.", file=sys.stderr) sys.exit(1) default_library = "shared" if options.enable_shared else "static" allowed_prebuilds = set(query_supported_bundle_types(include_wildcards=False)) - options.without_prebuilds try: configure(sourcedir, builddir, options.prefix, options.build, options.host, os.environ, "included" if options.enable_symbols else "stripped", default_library, allowed_prebuilds, options.meson, collect_meson_options(options), apple_min_os=dict(options.with_apple_min_os)) except Exception as e: print(e, file=sys.stderr) if isinstance(e, subprocess.CalledProcessError): for label, data in [("Output", e.output), ("Stderr", e.stderr)]: if data: print(f"{label}:\n\t| " + "\n\t| ".join(data.strip().split("\n")), file=sys.stderr) sys.exit(1) def configure(sourcedir: Path, builddir: Path, prefix: Optional[str] = None, build_machine: Optional[MachineSpec] = None, host_machine: Optional[MachineSpec] = None, environ: Dict[str, str] = os.environ, debug_symbols: str = "stripped", default_library: str = "static", allowed_prebuilds: Set[str] = None, meson: str = "internal", extra_meson_options: List[str] = [], call_meson: Callable = env.call_meson, on_progress: ProgressCallback = print_progress, apple_min_os: Optional[Dict[str, str]] = None): if prefix is None: prefix = env.detect_default_prefix() project_vscrt = detect_project_vscrt(sourcedir) if build_machine is None: build_machine = MachineSpec.make_from_local_system() build_machine = build_machine.default_missing(recommended_vscrt=project_vscrt) if host_machine is None: host_machine = build_machine else: host_machine = host_machine.default_missing(recommended_vscrt=project_vscrt) if host_machine.os == "windows": vs_arch = environ.get("VSCMD_ARG_TGT_ARCH") if vs_arch == "x86": host_machine = host_machine.evolve(arch=vs_arch) build_machine = build_machine.maybe_adapt_to_host(host_machine) if allowed_prebuilds is None: allowed_prebuilds = set(query_supported_bundle_types(include_wildcards=False)) call_selected_meson = lambda argv, *args, **kwargs: call_meson(argv, use_submodule=meson == "internal", *args, **kwargs) meson_options = [ f"-Dprefix={prefix}", f"-Ddefault_library={default_library}", *host_machine.meson_optimization_options, ] if debug_symbols == "stripped" and host_machine.toolchain_can_strip: meson_options += ["-Dstrip=true"] deps_dir = deps.detect_cache_dir(sourcedir) allow_prebuilt_toolchain = "toolchain" in allowed_prebuilds if allow_prebuilt_toolchain: try: toolchain_prefix, _ = deps.ensure_toolchain(build_machine, deps_dir, on_progress=on_progress) except deps.BundleNotFoundError as e: raise_toolchain_not_found(e) else: if project_depends_on_vala_compiler(sourcedir): toolchain_prefix = deps.query_toolchain_prefix(build_machine, deps_dir) vala_compiler = env.detect_toolchain_vala_compiler(toolchain_prefix, build_machine) if vala_compiler is None: build_vala_compiler(toolchain_prefix, deps_dir, call_selected_meson) else: toolchain_prefix = None is_cross_build = host_machine != build_machine build_sdk_prefix = None required = {"sdk:build"} if not is_cross_build: required.add("sdk:host") if allowed_prebuilds.issuperset(required): try: build_sdk_prefix, _ = deps.ensure_sdk(build_machine, deps_dir, on_progress=on_progress) except deps.BundleNotFoundError as e: raise_sdk_not_found(e, "build", build_machine) host_sdk_prefix = None if is_cross_build and "sdk:host" in allowed_prebuilds: try: host_sdk_prefix, _ = deps.ensure_sdk(host_machine, deps_dir, on_progress=on_progress) except deps.BundleNotFoundError as e: raise_sdk_not_found(e, "host", host_machine) build_config, host_config = \ env.generate_machine_configs(build_machine, host_machine, environ, toolchain_prefix, build_sdk_prefix, host_sdk_prefix, call_selected_meson, default_library, builddir, apple_min_os) meson_options += [f"--native-file={build_config.machine_file}"] if host_config is not build_config: meson_options += [f"--cross-file={host_config.machine_file}"] setup_env = host_config.make_merged_environment(environ) setup_env["FRIDA_ALLOWED_PREBUILDS"] = ",".join(allowed_prebuilds) call_selected_meson(["setup"] + meson_options + extra_meson_options + [builddir], cwd=sourcedir, env=setup_env, check=True) shutil.copy(SCRIPTS_DIR / "BSDmakefile", builddir) (builddir / "Makefile").write_text(generate_out_of_tree_makefile(sourcedir), encoding="utf-8") if platform.system() == "Windows": (builddir / "make.bat").write_text(generate_out_of_tree_make_bat(sourcedir), encoding="utf-8") (builddir / "frida-env.dat").write_bytes(pickle.dumps({ "meson": meson, "build": build_config, "host": host_config if host_config is not build_config else None, "default_library": default_library, "allowed_prebuilds": allowed_prebuilds, "deps": deps_dir, })) def parse_prefix(raw_prefix: str) -> Path: prefix = Path(raw_prefix) if not prefix.is_absolute(): prefix = Path(os.getcwd()) / prefix return prefix def query_supported_bundle_types(include_wildcards: bool) -> List[str]: for e in deps.Bundle: identifier = e.name.lower() if e == deps.Bundle.SDK: if include_wildcards: yield identifier yield identifier + ":build" yield identifier + ":host" else: yield identifier def query_supported_bundle_type_values() -> List[deps.Bundle]: return [e for e in deps.Bundle] def parse_bundle_type_set(raw_array: str) -> List[str]: supported_types = list(query_supported_bundle_types(include_wildcards=True)) result = set() for element in raw_array.split(","): bundle_type = element.strip() if bundle_type not in supported_types: pretty_choices = "', '".join(supported_types) raise argparse.ArgumentTypeError(f"invalid bundle type: '{bundle_type}' (choose from '{pretty_choices}')") if bundle_type == "sdk": result.add("sdk:build") result.add("sdk:host") else: result.add(bundle_type) return result def parse_apple_min_os_override(raw_value: str) -> Tuple[str, str]: platform, _, version = raw_value.partition("=") if not version: raise argparse.ArgumentTypeError( f"invalid Apple min OS override: '{raw_value}' (expected PLATFORM=VERSION)") valid_platforms = list(env_apple.APPLE_MINIMUM_OS_VERSIONS.keys()) if platform not in valid_platforms: pretty_choices = "', '".join(valid_platforms) raise argparse.ArgumentTypeError( f"invalid Apple platform: '{platform}' (choose from '{pretty_choices}')") return (platform, version) def raise_toolchain_not_found(e: Exception): raise ToolchainNotFoundError("\n".join([ f"Unable to download toolchain: {e}", "", "Specify --without-prebuilds=toolchain to only use tools on your PATH.", "", "Another option is to do what Frida's CI does:", "", " ./releng/deps.py build --bundle=toolchain", "", "This produces a tarball in ./deps which gets picked up if you retry `./configure`.", "You may also want to make a backup of it for future reuse.", ])) def raise_sdk_not_found(e: Exception, kind: str, machine: MachineSpec): raise SDKNotFoundError("\n".join([ f"Unable to download SDK: {e}", "", f"Specify --without-prebuilds=sdk:{kind} to build dependencies from source code.", "", "Another option is to do what Frida's CI does:", "", f" ./releng/deps.py build --bundle=sdk --host={machine.identifier}", "", "This produces a tarball in ./deps which gets picked up if you retry `./configure`.", "You may also want to make a backup of it for future reuse.", ])) def generate_out_of_tree_makefile(sourcedir: Path) -> str: m = ((SCRIPTS_DIR / "Makefile").read_text(encoding="utf-8") .replace("sys.argv[1]", "r'" + str(RELENG_DIR.parent) + "'") .replace('"$(shell pwd)"', shlex.quote(str(sourcedir))) .replace("./build", ".")) return re.sub(r"git-submodules:.+?(?=\.PHONY:)", "", m, flags=re.MULTILINE | re.DOTALL) def generate_out_of_tree_make_bat(sourcedir: Path) -> str: m = ((SCRIPTS_DIR / "make.bat").read_text(encoding="utf-8") .replace("sys.argv[1]", "r'" + str(RELENG_DIR.parent) + "'") .replace('"%dp0%"', '"' + str(sourcedir) + '"') .replace('.\\build', "\"%dp0%\"")) return re.sub(r"if not exist .+?(?=endlocal)", "", m, flags=re.MULTILINE | re.DOTALL) def register_meson_options(meson_option_file: Path, group: argparse._ArgumentGroup): interpreter = mesonbuild.optinterpreter.OptionInterpreter(subproject="") interpreter.process(meson_option_file) for key, opt in interpreter.options.items(): name = key.name pretty_name = name.replace("_", "-") if isinstance(opt, UserFeatureOption): if opt.value != "enabled": action = "enable" value_to_set = "enabled" else: action = "disable" value_to_set = "disabled" group.add_argument(f"--{action}-{pretty_name}", action="append_const", const=f"-D{name}={value_to_set}", dest="main_meson_options", **parse_option_meta(name, action, opt)) if opt.value == "auto": group.add_argument(f"--disable-{pretty_name}", action="append_const", const=f"-D{name}=disabled", dest="main_meson_options", **parse_option_meta(name, "disable", opt)) elif isinstance(opt, UserBooleanOption): if not opt.value: action = "enable" value_to_set = "true" else: action = "disable" value_to_set = "false" group.add_argument(f"--{action}-{pretty_name}", action="append_const", const=f"-D{name}={value_to_set}", dest="main_meson_options", **parse_option_meta(name, action, opt)) elif isinstance(opt, UserComboOption): group.add_argument(f"--with-{pretty_name}", choices=opt.choices, dest="meson_option:" + name, **parse_option_meta(name, "with", opt)) elif isinstance(opt, UserArrayOption): group.add_argument(f"--with-{pretty_name}", dest="meson_option:" + name, type=make_array_option_value_parser(opt), **parse_option_meta(name, "with", opt)) else: group.add_argument(f"--with-{pretty_name}", dest="meson_option:" + name, **parse_option_meta(name, "with", opt)) def parse_option_meta(name: str, action: str, opt: UserOption[Any]): params = {} if isinstance(opt, UserStringOption): default_value = repr(opt.value) metavar = name.upper() elif isinstance(opt, UserArrayOption): default_value = ",".join(opt.value) metavar = "{" + ",".join(opt.choices) + "}" elif isinstance(opt, UserComboOption): default_value = opt.value metavar = "{" + "|".join(opt.choices) + "}" else: default_value = str(opt.value).lower() metavar = name.upper() if not (isinstance(opt, UserFeatureOption) \ and opt.value == "auto" \ and action == "disable"): text = f"{help_text_from_meson(opt.description)} (default: {default_value})" if action == "disable": text = "do not " + text params["help"] = text params["metavar"] = metavar return params def help_text_from_meson(description: str) -> str: if description: return description[0].lower() + description[1:] return description def collect_meson_options(options: argparse.Namespace) -> List[str]: result = [] for raw_name, raw_val in vars(options).items(): if raw_val is None: continue if raw_name == "main_meson_options": result += raw_val if raw_name.startswith("meson_option:"): name = raw_name[13:] val = raw_val if isinstance(raw_val, str) else ",".join(raw_val) result += [f"-D{name}={val}"] result += options.extra_meson_options return result def make_array_option_value_parser(opt: UserOption[Any]) -> Callable[[str], List[str]]: return lambda v: parse_array_option_value(v, opt) def parse_array_option_value(v: str, opt: UserArrayOption) -> List[str]: vals = [v.strip() for v in v.split(",")] choices = opt.choices for v in vals: if v not in choices: pretty_choices = "', '".join(choices) raise argparse.ArgumentTypeError(f"invalid array value: '{v}' (choose from '{pretty_choices}')") return vals def detect_project_vscrt(sourcedir: Path) -> Optional[str]: m = next(re.finditer(r"project\(([^)]+\))", read_meson_build(sourcedir)), None) if m is not None: project_args = m.group(1) m = next(re.finditer("'b_vscrt=([^']+)'", project_args), None) if m is not None: return m.group(1) return None def project_depends_on_vala_compiler(sourcedir: Path) -> bool: return "'vala'" in read_meson_build(sourcedir) def read_meson_build(sourcedir: Path) -> str: return (sourcedir / "meson.build").read_text(encoding="utf-8") def build_vala_compiler(toolchain_prefix: Path, deps_dir: Path, call_selected_meson: Callable): print("Building Vala compiler...", flush=True) workdir = deps_dir / "src" workdir.mkdir(parents=True, exist_ok=True) git = lambda *args, **kwargs: subprocess.run(["git", *args], **kwargs, capture_output=True, encoding="utf-8") vala_checkout = workdir / "vala" if vala_checkout.exists(): shutil.rmtree(vala_checkout) vala_pkg = deps.load_dependency_parameters().packages["vala"] deps.clone_shallow(vala_pkg, vala_checkout, git) run_kwargs = { "stdout": subprocess.PIPE, "stderr": subprocess.STDOUT, "encoding": "utf-8", "check": True, } call_selected_meson([ "setup", f"--prefix={toolchain_prefix}", "-Doptimization=2", "build", ], cwd=vala_checkout, **run_kwargs) call_selected_meson(["install"], cwd=vala_checkout / "build", **run_kwargs) class ToolchainNotFoundError(Exception): pass class SDKNotFoundError(Exception): pass