# Copyright 2017 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Recipe for building QEMU."""

import shlex

from PB.go.chromium.org.luci.common.proto.srcman.manifest import Manifest
from PB.recipes.fuchsia.qemu import InputProperties

DEPS = [
    "fuchsia/cas_util",
    "fuchsia/cipd_util",
    "fuchsia/cmake",
    "fuchsia/git_checkout",
    "fuchsia/goma",
    "fuchsia/linux_sdk",
    "fuchsia/macos_sdk",
    "fuchsia/ninja",
    "fuchsia/platform_util",
    "fuchsia/toolchain",
    "fuchsia/zlib",
    "recipe_engine/cipd",
    "recipe_engine/context",
    "recipe_engine/file",
    "recipe_engine/path",
    "recipe_engine/platform",
    "recipe_engine/properties",
    "recipe_engine/step",
]

PROPERTIES = InputProperties


def RunSteps(api, props):
    manifest = Manifest()

    checkout_dir, revision = api.git_checkout(
        props.remote,
        fallback_ref=props.ref or "refs/heads/master",
        submodules=True,
        config={
            "url.https://qemu.googlesource.com/.insteadOf": "https://gitlab.com/qemu-project/"
        },
    )
    qemu_version = api.file.read_text(
        "read qemu version", checkout_dir / "VERSION"
    ).strip()

    git_checkout = manifest.directories[str(checkout_dir)].git_checkout
    git_checkout.repo_url = props.remote
    git_checkout.revision = revision

    host_platform = api.platform_util.host
    target_platform = api.platform_util.platform(
        props.platform or host_platform.platform
    )

    with api.step.nest("ensure_packages"), api.context(infra_steps=True):
        cipd_dir = api.path.start_dir / "cipd"
        pkgs = api.cipd.EnsureFile()
        pkgs.add_package("fuchsia/third_party/clang/${platform}", "integration")
        pkgs.add_package("fuchsia/third_party/autoconf/${platform}", "version:2.69")
        pkgs.add_package("fuchsia/third_party/automake/${platform}", "version:1.16.2")
        pkgs.add_package("fuchsia/third_party/libtool/${platform}", "version:2.4.6")
        pkgs.add_package("fuchsia/third_party/m4/${platform}", "version:1.4.18")
        pkgs.add_package("fuchsia/third_party/make/${platform}", "version:4.3")
        pkgs.add_package("fuchsia/third_party/pkg-config/${platform}", "version:0.29.2")
        pkgs.add_package(
            "fuchsia/third_party/source/gettext",
            "version:0.19.8.1",
            "source/gettext",
        )
        api.cipd.ensure(cipd_dir, pkgs)

    pkg_dir = api.path.start_dir / "pkgconfig"
    api.file.ensure_directory("create pkg dir", pkg_dir)

    variables = {
        "PKG_CONFIG_PATH": "",
        # TODO: We should be using the following but that breaks the SDL dependency.
        # "PKG_CONFIG_SYSROOT_DIR": platform_sysroot(api, target_platform),
        "PKG_CONFIG_ALLOW_SYSTEM_CFLAGS": 0,
        "PKG_CONFIG_ALLOW_SYSTEM_LIBS": 0,
        "PKG_CONFIG_LIBDIR": ":".join(
            [
                str(pkg_dir.joinpath("share", "pkgconfig")),
                str(pkg_dir.joinpath("lib", "pkgconfig")),
                str(pkg_dir.joinpath("lib64", "pkgconfig")),
            ]
        ),
    }

    with api.linux_sdk(), api.macos_sdk(), api.context(
        env=variables,
        env_prefixes={"PATH": [cipd_dir.joinpath("bin"), pkg_dir.joinpath("bin")]},
    ):
        with api.step.nest("meson"):
            build_meson(api, pkg_dir)

        if target_platform.is_linux:
            with api.step.nest("sdl"):
                build_sdl(
                    api,
                    cipd_dir,
                    pkg_dir,
                    target_platform,
                    host_platform,
                    props.prod,
                    manifest,
                )

        with api.step.nest("zlib"):
            api.zlib.build(
                cmake_extra_args=cmake_args(api, cipd_dir, target_platform)
                + [
                    "-DCMAKE_INSTALL_PREFIX=%s" % pkg_dir,
                ],
                platform=target_platform,
            )

        with api.step.nest("bzip2"):
            build_bzip2(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        with api.step.nest("pixman"):
            build_pixman(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        with api.step.nest("libffi"):
            build_libffi(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        if target_platform.is_mac:
            with api.step.nest("gettext"):
                build_gettext(
                    api,
                    cipd_dir,
                    pkg_dir,
                    target_platform,
                    host_platform,
                    props.prod,
                    manifest,
                )

        with api.step.nest("pcre2"):
            build_pcre2(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        with api.step.nest("glib"):
            build_glib(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        with api.step.nest("libslirp"):
            build_libslirp(
                api,
                cipd_dir,
                pkg_dir,
                target_platform,
                host_platform,
                props.prod,
                manifest,
            )

        with api.step.nest("qemu"):
            install_dir = build_qemu(
                api,
                checkout_dir,
                pkg_dir,
                cipd_dir,
                target_platform,
                host_platform,
                props.prod,
            )

    api.file.write_proto(
        "source manifest", install_dir / "source_manifest.json", manifest, "JSONPB"
    )

    cas_digest = api.cas_util.upload(install_dir, output_property="isolated")
    if props.prod:
        api.cipd_util.upload_package(
            f"fuchsia/third_party/qemu/{target_platform.platform}",
            install_dir,
            search_tag={"git_revision": revision},
            repository=props.remote,
            metadata=[("version", qemu_version)],
        )

    if props.builders and target_platform.platform in props.builders:
        # Do a full integration build. This will use the just-built QEMU to
        # test against a representative set of Fuchsia builders to smoke test
        # for any regressions.
        api.toolchain.trigger_build(
            "qemu",
            props.remote,
            revision,
            cas_digest,
            builders=props.builders[target_platform.platform],
        )


def cmake_args(api, cipd_dir, platform):
    # TODO(b/270963251): Enable optimizations for cmake.
    args = [
        f"-DCMAKE_MAKE_PROGRAM={api.ninja.path}",
        f"-DCMAKE_C_COMPILER={cipd_dir.joinpath('bin', 'clang')}",
        f"-DCMAKE_C_COMPILER_TARGET={platform.triple}",
        f"-DCMAKE_CXX_COMPILER={cipd_dir.joinpath('bin', 'clang++')}",
        f"-DCMAKE_CXX_COMPILER_TARGET={platform.triple}",
        f"-DCMAKE_SYSROOT={platform_sysroot(api, platform)}",
        "-DCMAKE_INSTALL_PREFIX=",
        f"-DCMAKE_LINKER={'/usr/bin/ld' if platform.is_mac else cipd_dir.joinpath('bin', 'ld.lld')}",
        f"-DCMAKE_NM={cipd_dir.joinpath('bin', 'llvm-nm')}",
        f"-DCMAKE_OBJCOPY={cipd_dir.joinpath('bin', 'llvm-objcopy')}",
        f"-DCMAKE_OBJDUMP={cipd_dir.joinpath('bin', 'llvm-objdump')}",
        f"-DCMAKE_RANLIB={cipd_dir.joinpath('bin', 'llvm-ranlib')}",
        f"-DCMAKE_STRIP={cipd_dir.joinpath('bin', 'llvm-strip')}",
    ]
    return args


def platform_sysroot(api, platform):
    if platform.is_linux:
        return api.linux_sdk.sysroot
    if platform.is_mac:
        return api.macos_sdk.sysroot
    raise api.step.StepFailure("supported platform")  # pragma: no cover


def environment(
    api, cipd_dir, platform, host, optimize, cflags=(), cxxflags=(), ldflags=()
):
    sysroot = [f"--sysroot={str(platform_sysroot(api, platform)).replace('%', '%%')}"]
    target = (
        [f"--target={platform.triple}"] if platform.platform != host.platform else []
    )
    opt = []
    if optimize:
        opt = ["-O3"]
        # TODO: Enable LTO for Mac targets.
        #
        # On Mac this currently fails basic Make compile checks
        #  configure: error: in `/opt/s/w/ir/x/w/make':
        #  configure: error: C compiler cannot create executables
        if platform.is_linux:
            opt.extend(["-flto", "-fwhole-program-vtables"])
    variables = {
        "CC": cipd_dir.joinpath("bin", "clang"),
        "CXX": cipd_dir.joinpath("bin", "clang++"),
        "LD": cipd_dir.joinpath("bin", "ld.lld"),
        "CFLAGS": " ".join(sysroot + target + opt + list(cflags)),
        "CPPFLAGS": " ".join(sysroot + target + opt + list(cflags)),
        "CXXFLAGS": " ".join(sysroot + target + opt + list(cxxflags)),
        "LDFLAGS": " ".join(sysroot + target + opt + list(ldflags)),
        "AR": cipd_dir.joinpath("bin", "llvm-ar"),
        "RANLIB": cipd_dir.joinpath("bin", "llvm-ranlib"),
        "NM": cipd_dir.joinpath("bin", "llvm-nm"),
        "STRIP": cipd_dir.joinpath("bin", "llvm-strip"),
        "OBJCOPY": cipd_dir.joinpath("bin", "llvm-objcopy"),
        # The context API interprets bare percent signs as formatting
        # directives so they must be escaped.
        "NINJA": str(api.ninja.path).replace("%", "%%"),
    }

    return variables


def configure(
    api,
    cipd_dir,
    src_dir,
    platform,
    host,
    optimize,
    flags=(),
    cflags=(),
    cxxflags=(),
    ldflags=(),
    step_name="configure",
):
    variables = environment(
        api, cipd_dir, platform, host, optimize, cflags, cxxflags, ldflags
    )
    if platform.platform != host.platform:
        flags.extend(
            [
                # config.sub used by QEMU doesn't yet recognize arm64-apple-darwin which
                # is used by Clang, so replace it with aarch64-apple-darwin to make the
                # script not fail.
                f"--build={host.triple.replace('arm64-apple-darwin', 'aarch64-apple-darwin')}",
                f"--host={platform.triple.replace('arm64-apple-darwin', 'aarch64-apple-darwin')}",
            ]
        )
    return api.step(
        step_name,
        [src_dir / "configure"]
        + flags
        + sorted(f"{k}={v}" for k, v in variables.items()),
    )


def meson(
    api, cipd_dir, platform, _host, _optimize, cflags=(), cxxflags=(), ldflags=()
):
    cross_file = api.path.start_dir.joinpath("%s.txt" % platform.triple)
    api.file.write_text(
        "write cross-file",
        cross_file,
        f"""
[constants]
sysroot = '--sysroot=' + '{str(platform_sysroot(api, platform)).replace("%", "%%")}'
target = '--target={platform.triple}'

[built-in options]
buildtype = 'release'
c_args = [sysroot, target] + [{", ".join("'%s'" % f for f in cflags)}]
cpp_args = [sysroot, target] + [{", ".join("'%s'" % f for f in cxxflags)}]
c_link_args = c_args + [{", ".join("'%s'" % f for f in ldflags)}]
cpp_link_args = cpp_args + [{", ".join("'%s'" % f for f in ldflags)}]
default_library = 'static'
includedir = 'include'
libdir = 'lib'
# sys_root = /some/path
# pkg_config_libdir = /some/path

[binaries]
c = '{str(cipd_dir.joinpath("bin", "clang"))}'
c_ld = 'lld'
objc = '{str(cipd_dir.joinpath("bin", "clang"))}'
objc_ld = 'lld'
cpp = '{str(cipd_dir.joinpath("bin", "clang++"))}'
cpp_ld = 'lld'
ar = '{str(cipd_dir.joinpath("bin", "llvm-ar"))}'
strip = '{str(cipd_dir.joinpath("bin", "llvm-strip"))}'
pkgconfig = '{str(cipd_dir.joinpath("bin", "pkg-config"))}'
# exe_wrapper = 'qemu-aarch64'

[host_machine]
system = '{platform.os.replace('mac', 'darwin')}'
cpu_family = '{platform.arch.replace('amd64', 'x86_64').replace('arm64', 'aarch64')}'
cpu = cpu_family
endian = 'little'
""",
    )
    # Pass as `--native-file` when not cross-compiling
    return cross_file


def build_meson(api, pkg_dir):
    MESON_GIT = "https://qemu.googlesource.com/meson"
    src_dir, _ = api.git_checkout(MESON_GIT, revision="refs/tags/1.2.1")

    bin_dir = pkg_dir / "bin"
    api.file.ensure_directory("bin", bin_dir)
    outfile = bin_dir / "meson.pyz"

    api.step(
        "create zipapp",
        [
            "vpython3",
            src_dir.joinpath("packaging", "create_zipapp.py"),
            "--outfile",
            outfile,
            "--interpreter",
            "/usr/bin/env vpython3",
            src_dir,
        ],
    )

    return outfile


def build_sdl(api, cipd_dir, pkg_dir, platform, _host, _optimize, manifest):
    SDL_GIT = "https://fuchsia.googlesource.com/third_party/sdl"
    src_dir, revision = api.git_checkout(SDL_GIT, revision="refs/tags/release-2.26.5")
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = SDL_GIT
    git_checkout.revision = revision

    api.cmake.build_with_ninja(
        src_dir=src_dir,
        extra_args=cmake_args(api, cipd_dir, platform)
        + [
            "-DBUILD_SHARED_LIBS=OFF",
            "-DCMAKE_INSTALL_PREFIX=%s" % pkg_dir,
            "-DSDL_GCC_ATOMICS=ON",
            "-DSDL_STATIC_PIC=ON",
            "-DSDL_TEST=OFF",
            "-DSDL_WAYLAND=OFF",
        ],
    )


def build_bzip2(api, cipd_dir, pkg_dir, platform, host, optimize, manifest):
    BZIP2_GIT = "https://fuchsia.googlesource.com/third_party/bzip2"
    src_dir, revision = api.git_checkout(BZIP2_GIT, revision="refs/heads/main")
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = BZIP2_GIT
    git_checkout.revision = revision

    build_dir = api.path.start_dir / "bzip2"
    api.file.ensure_directory("bzip2", build_dir)

    with api.context(cwd=src_dir):
        # First build for host.
        env = environment(api, cipd_dir, host, host, optimize)
        var = ["%s=%s" % (k, v) for k, v in env.items()]
        api.step(
            "build (host)",
            ["make", f"-j{int(api.goma.jobs)}", "install", f"PREFIX={pkg_dir}", *var],
        )
        api.step("clean", ["make", "clean"])
        # Second build for target.
        env = environment(api, cipd_dir, platform, host, optimize)
        var = ["%s=%s" % (k, v) for k, v in env.items()]
        api.step(
            "build (target)",
            ["make", f"-j{int(api.goma.jobs)}", "install", f"PREFIX={build_dir}", *var],
        )
        api.file.copy(
            "copy libbz2.a",
            build_dir.joinpath("lib", "libbz2.a"),
            pkg_dir.joinpath("lib"),
        )


def build_pixman(api, cipd_dir, pkg_dir, platform, host, optimize, manifest):
    PIXMAN_GIT = "https://fuchsia.googlesource.com/third_party/pixman"
    src_dir, revision = api.git_checkout(
        PIXMAN_GIT, revision="593a970266042d702c1577fdec8c33449f60b628"
    )
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = PIXMAN_GIT
    git_checkout.revision = revision

    build_dir = api.path.start_dir / "pixman"
    api.file.ensure_directory("pixman", build_dir)

    with api.context(
        cwd=src_dir, env=environment(api, cipd_dir, platform, host, False)
    ):
        try:
            cross_file = meson(api, cipd_dir, platform, host, optimize)
            api.step(
                "setup",
                [
                    pkg_dir.joinpath("bin", "meson.pyz"),
                    "setup",
                    "--default-library=static",
                    "--prefix=%s" % pkg_dir,
                    "--includedir=include",
                    "--libdir=lib",
                    "--buildtype=release",
                    "--wrap-mode=nofallback",
                    "--cross-file=%s" % cross_file,
                ]
                + (["-Db_lto=true"] if optimize else [])
                + [
                    build_dir,
                ],
            )
        finally:
            try:
                api.file.read_text(
                    "meson-log.txt",
                    build_dir.joinpath("meson-logs", "meson-log.txt"),
                    test_data="The Meson build system\nVersion: 1.0.0",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass
        api.ninja("install", ["install", "-v"], build_dir=build_dir)


def build_libffi(api, cipd_dir, pkg_dir, platform, host, optimize, manifest):
    # TODO(phosek): Newer versions require autoconf >=2.71.
    LIBFFI_GIT = "https://fuchsia.googlesource.com/third_party/libffi"
    src_dir, revision = api.git_checkout(LIBFFI_GIT, revision="refs/tags/v3.4.2")
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = LIBFFI_GIT
    git_checkout.revision = revision

    build_dir = api.path.start_dir / "libffi"
    api.file.ensure_directory("libffi", build_dir)

    with api.context(cwd=src_dir, env={"M4": cipd_dir.joinpath("bin", "m4")}):
        api.step("autogen", [src_dir / "autogen.sh"])
    with api.context(cwd=build_dir):
        try:
            configure(
                api,
                cipd_dir,
                src_dir,
                platform,
                host,
                optimize,
                [
                    "--disable-debug",
                    "--disable-dependency-tracking",
                    "--disable-docs",
                    "--disable-shared",
                    "--enable-static",
                    "--prefix=%s" % pkg_dir,
                    "--target=%s"
                    # config.sub used by libffi doesn't yet recognize arm64-apple-darwin which
                    # is used by Clang, so replace it with aarch64-apple-darwin to make the
                    # script not fail.
                    % platform.triple.replace(
                        "arm64-apple-darwin", "aarch64-apple-darwin"
                    ),
                    "--with-pic",
                ],
            )
        finally:
            try:
                api.file.read_text(
                    "config.log",
                    build_dir / "config.log",
                    test_data="# libffi configure log",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass

        api.step("build", ["make", f"-j{int(api.goma.jobs)}"])
        api.step("install", ["make", "install"])  # , f"DESTDIR={pkg_dir}"])


def build_gettext(api, cipd_dir, pkg_dir, platform, host, optimize, _manifest):
    # Build gettext-{runtime,tools} separately, when cross-compiling we need to
    # always build `tools` for the host and the `runtime` for the target. This
    # is how the PACKAGING file recommends we split them.
    #
    # The order of tools, runtime is important here; the tools build will
    # overwrite the runtimes installation.
    for package in ["gettext-tools", "gettext-runtime"]:
        with api.step.nest(package):
            src_dir = cipd_dir.joinpath("source", "gettext", package)
            build_dir = api.path.start_dir.joinpath("gettext", package)
            api.file.ensure_directory("gettext", build_dir)

            with api.context(cwd=build_dir):
                configure(
                    api,
                    cipd_dir,
                    src_dir,
                    platform if package == "gettext-runtime" else host,
                    host,
                    optimize,
                    [
                        "--disable-curses",
                        "--disable-dependency-tracking",
                        "--disable-silent-rules",
                        "--disable-debug",
                        "--disable-shared",
                        "--disable-java",
                        "--disable-csharp",
                        "--disable-c++",
                        "--disable-openmp",
                        "--enable-static",
                        "--prefix=%s" % pkg_dir,
                        "--with-pic",
                        "--with-included-gettext",
                        "--with-included-glib",
                        "--with-included-libcroco",
                        "--with-included-libunistring",
                        "--with-included-libxml",
                        "--without-git",
                        "--without-cvs",
                        "--without-xz",
                    ],
                    ldflags=["-lm"],
                )
                api.step("build", ["make", f"-j{int(api.goma.jobs)}"])
                api.step("install", ["make", "install"])


def build_pcre2(api, cipd_dir, pkg_dir, platform, _host, _optimize, manifest):
    # TODO(phosek): We should be using our mirror.
    PCRE2_GIT = "https://github.com/PCRE2Project/pcre2"
    src_dir, revision = api.git_checkout(PCRE2_GIT, revision="refs/tags/pcre2-10.42")
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = PCRE2_GIT
    git_checkout.revision = revision

    api.cmake.build_with_ninja(
        src_dir=src_dir,
        extra_args=cmake_args(api, cipd_dir, platform)
        + [
            "-DBUILD_SHARED_LIBS=OFF",
            "-DCMAKE_INSTALL_PREFIX=%s" % pkg_dir,
        ],
    )


def build_glib(api, cipd_dir, pkg_dir, platform, host, optimize, manifest):
    GLIB_GIT = "https://fuchsia.googlesource.com/third_party/glib"
    src_dir, revision = api.git_checkout(
        GLIB_GIT,
        revision="refs/tags/2.77.0",
        submodules=True,
        config={
            # TODO(phosek): We should be using our mirror.
            "url.https://gitlab.gnome.org/GNOME/gvdb.insteadOf": "https://fuchsia.googlesource.com/GNOME/gvdb"
        },
    )
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = GLIB_GIT
    git_checkout.revision = revision

    build_dir = api.path.start_dir / "glib"
    api.file.ensure_directory("glib", build_dir)

    with api.context(
        cwd=src_dir,
        env=environment(
            api,
            cipd_dir,
            platform,
            host,
            optimize,
            cflags=["-I%s" % pkg_dir.joinpath("include")],
            ldflags=["-L%s" % pkg_dir.joinpath("lib")],
        ),
    ):
        try:
            cross_file = meson(api, cipd_dir, platform, host, optimize)
            api.step(
                "setup",
                [
                    pkg_dir.joinpath("bin", "meson.pyz"),
                    "setup",
                    "--default-library=static",
                    "--prefix=%s" % pkg_dir,
                    "--includedir=include",
                    "--libdir=lib",
                    "--buildtype=release",
                    # "--wrap-mode=nofallback",
                    "--cross-file=%s" % cross_file,
                    build_dir,
                ],
            )
        finally:
            try:
                api.file.read_text(
                    "meson-log.txt",
                    build_dir.joinpath("meson-logs", "meson-log.txt"),
                    test_data="The Meson build system\nVersion: 1.0.0",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass
        api.ninja("install", ["install"], build_dir=build_dir)


def build_libslirp(api, cipd_dir, pkg_dir, platform, host, optimize, manifest):
    LIBSLIRP_GIT = "https://qemu.googlesource.com/libslirp"
    src_dir, revision = api.git_checkout(LIBSLIRP_GIT, revision="refs/tags/v4.7.0")
    git_checkout = manifest.directories[str(src_dir)].git_checkout
    git_checkout.repo_url = LIBSLIRP_GIT
    git_checkout.revision = revision

    build_dir = api.path.start_dir / "libslirp"
    api.file.ensure_directory("libslirp", build_dir)

    with api.context(
        cwd=src_dir, env=environment(api, cipd_dir, platform, host, optimize)
    ):
        try:
            cross_file = meson(api, cipd_dir, platform, host, optimize)
            api.step(
                "setup",
                [
                    pkg_dir.joinpath("bin", "meson.pyz"),
                    "setup",
                    "--default-library=static",
                    "--prefix=%s" % pkg_dir,
                    "--includedir=include",
                    "--libdir=lib",
                    "--buildtype=release",
                    "--wrap-mode=nofallback",
                    "--cross-file=%s" % cross_file,
                    build_dir,
                ],
            )
        finally:
            try:
                api.file.read_text(
                    "meson-log.txt",
                    build_dir.joinpath("meson-logs", "meson-log.txt"),
                    test_data="The Meson build system\nVersion: 1.0.0",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass
        api.ninja("install", ["install"], build_dir=build_dir)


def build_qemu(
    api,
    checkout_dir,
    pkg_dir,
    cipd_dir,
    target_platform,
    host_platform,
    optimize,
):
    """
    Build QEMU.

    Args:
        checkout_dir (Path): Path to QEMU Git repository.
        cipd_dir (Path): Path to prepopulated CIPD package dependencies.
        target_platform (Platform): Target platform.
        host_platform (Platform): Host platform.

    Returns:
        Path: Path to install directory.
    """
    build_dir = api.path.start_dir.joinpath("qemu", "build")
    api.file.ensure_directory("qemu/build", build_dir)
    install_dir = api.path.start_dir.joinpath("qemu", "install")
    api.file.ensure_directory("qemu/install", install_dir)

    sysroot = [
        f"--sysroot={str(platform_sysroot(api, target_platform)).replace('%', '%%')}"
    ]
    target = (
        [f"--target={target_platform.triple}"]
        if target_platform.platform != host_platform.platform
        else []
    )
    # TODO: QEMU builds fails to find zlib headers without an explicit -I which
    # is a bug.
    includes = ["-I%s" % pkg_dir.joinpath("include")]
    opt = [
        # TODO: Remove these once we upgrade the host Linux sysroot.
        "-DHWCAP_ATOMICS=256",
        "-DHWCAP_USCAT=33554432",
    ]
    if target_platform.arch == "amd64":
        opt.append("-mcx16")
    variables = {
        "AR": cipd_dir.joinpath("bin", "llvm-ar"),
        "RANLIB": cipd_dir.joinpath("bin", "llvm-ranlib"),
        "NM": cipd_dir.joinpath("bin", "llvm-nm"),
        "STRIP": cipd_dir.joinpath("bin", "llvm-strip"),
        "OBJCOPY": cipd_dir.joinpath("bin", "llvm-objcopy"),
        "QEMU_PKG_CONFIG_FLAGS": "--static",
        "CFLAGS": " ".join(sysroot + opt + target + includes),
        "CXXFLAGS": " ".join(sysroot + opt + target + includes),
        "OBJCFLAGS": " ".join(sysroot + opt + target + includes),
        "NINJA": str(api.ninja.path).replace("%", "%%"),
    }
    if target_platform.is_linux:
        variables["LDFLAGS"] = " ".join(
            sysroot + target + opt + ["-ldl -static-libstdc++ -Qunused-arguments"]
        )
    if target_platform.is_mac:
        variables["LDFLAGS"] = " ".join(
            sysroot + target + ["-nostdlib++ %s" % cipd_dir.joinpath("lib", "libc++.a")]
        )

    # NOTE: We don't want to pass --static to configure since we still link libc
    # as a shared library, but we want everything else to use static linking.
    configure_options = []
    meson_options = []
    if target_platform.is_linux:
        configure_options.extend(
            [
                f"--build={host_platform.triple}",
                f"--host={target_platform.triple}",
                f"--extra-cflags={' '.join(sysroot + opt + target + includes)}",
                f"--extra-cxxflags={' '.join(sysroot + opt + target + includes)}",
                # Suppress warning about the unused arguments because QEMU ignores
                # --disable-werror at configure time which triggers an error because
                # -static-libstdc++ is unused when linking C code.
                f"--extra-ldflags={' '.join(sysroot + target + opt + ['-ldl -static-libstdc++ -Qunused-arguments'])}",
            ]
        )
        meson_options.extend(
            [
                "-Dkvm=enabled",
                "-Dgtk=disabled",
                "-Dsdl=enabled",
            ]
        )
    if target_platform.is_mac:
        configure_options.extend(
            [
                f"--objcc={cipd_dir.joinpath('bin', 'clang')}",
                "--enable-cocoa",
                f"--extra-cflags={' '.join(sysroot + opt + target + includes)}",
                f"--extra-cxxflags={' '.join(sysroot + opt + target + includes)}",
                f"--extra-objcflags={' '.join(sysroot + opt + target + includes)}",
                "--extra-ldflags=%s"
                % " ".join(
                    sysroot
                    + target
                    + ["-nostdlib++ %s" % cipd_dir.joinpath("lib", "libc++.a")]
                ),
            ]
        )
        meson_options.extend(
            [
                "-Dcocoa=enabled",
                "-Dhvf=enabled",
            ]
        )

    # TODO: Use `meson subprojects` to download all subprojects and override their URL
    # to point to https://qemu.googlesource.com/.

    with api.context(cwd=build_dir, env=variables):
        try:
            api.step(
                "configure qemu",
                [
                    checkout_dir / "configure",
                    f"--cc={cipd_dir.joinpath('bin', 'clang')}",
                    # See function docstring for justification and associated bug.
                    f"--cxx={wrap_clang(api, cipd_dir.joinpath('bin', 'clang++'))}",
                    f"--ninja={api.ninja.path}",
                    f"--prefix={install_dir}",
                    "--target-list=aarch64-softmmu,arm-softmmu,riscv64-softmmu,x86_64-softmmu",
                    "--skip-meson",
                ]
                + configure_options,
            )
        finally:
            try:
                api.file.read_text(
                    "config.log",
                    build_dir / "config.log",
                    test_data="# QEMU configure log",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass

    with api.context(cwd=checkout_dir, env=variables):
        try:
            cross_file = meson(
                api,
                cipd_dir,
                target_platform,
                host_platform,
                optimize,
                cflags=opt,
                cxxflags=opt,
            )
            api.step(
                "setup",
                [
                    pkg_dir.joinpath("bin", "meson.pyz"),
                    "setup",
                    "--default-library=static",
                    "--prefix=%s" % install_dir,
                    "--includedir=include",
                    "--libdir=lib",
                    "--buildtype=release",
                    "--wrap-mode=nofallback",
                    "--cross-file=%s" % cross_file,
                    "-Dattr=disabled",
                    "-Dauth_pam=disabled",
                    "-Dbochs=disabled",
                    "-Dbrlapi=disabled",
                    "-Dcap_ng=disabled",
                    "-Dcapstone=disabled",
                    "-Dcloop=disabled",
                    "-Dcrypto_afalg=disabled",
                    "-Dcurl=disabled",
                    "-Dcurses=disabled",
                    "-Ddbus_display=disabled",
                    "-Ddebug_graph_lock=false",
                    "-Ddebug_mutex=false",
                    "-Ddebug_stack_usage=false",
                    "-Ddmg=disabled",
                    "-Ddocs=disabled",
                    "-Dfdt=internal",
                    "-Dgcrypt=disabled",
                    "-Dglusterfs=disabled",
                    "-Dgnutls=disabled",
                    "-Dguest_agent=disabled",
                    "-Diconv=disabled",
                    "-Dlibdaxctl=disabled",
                    "-Dlibiscsi=disabled",
                    "-Dlibnfs=disabled",
                    "-Dlibpmem=disabled",
                    "-Dlibssh=disabled",
                    "-Dlibudev=disabled",
                    "-Dlibusb=disabled",
                    "-Dlinux_aio=disabled",
                    "-Dlinux_io_uring=disabled",
                    "-Dlzfse=disabled",
                    "-Dlzo=disabled",
                    "-Dmpath=disabled",
                    "-Dmultiprocess=disabled",
                    "-Dnetmap=disabled",
                    "-Dnettle=disabled",
                    "-Dnuma=disabled",
                    "-Dnvmm=disabled",
                    "-Dopengl=disabled",
                    "-Dparallels=disabled",
                    "-Dqcow1=disabled",
                    "-Dqed=disabled",
                    "-Dqga_vss=disabled",
                    "-Dqom_cast_debug=false",
                    "-Drbd=disabled",
                    "-Drdma=disabled",
                    "-Dreplication=disabled",
                    "-Dsdl_image=disabled",
                    "-Dseccomp=disabled",
                    "-Dsmartcard=disabled",
                    "-Dsnappy=disabled",
                    "-Dsparse=disabled",
                    "-Dspice=disabled",
                    "-Dtcg=enabled",
                    "-Dtcg_interpreter=false",
                    "-Dtpm=disabled",
                    "-Dusb_redir=disabled",
                    "-Dvde=disabled",
                    "-Dvdi=disabled",
                    "-Dvirglrenderer=disabled",
                    "-Dvirtfs=disabled",
                    "-Dvnc=disabled",
                    "-Dvte=disabled",
                    "-Dvvfat=enabled",
                    "-Dwhpx=disabled",
                    "-Dxen=disabled",
                    "-Dxkbcommon=disabled",
                ]
                + meson_options
                + (["-Db_lto=true"] if optimize else [])
                + [
                    build_dir,
                ],
            )
        finally:
            try:
                api.file.read_text(
                    "meson-log.txt",
                    build_dir.joinpath("meson-logs", "meson-log.txt"),
                    test_data="The Meson build system\nVersion: 1.0.0",
                )
            except api.step.StepFailure:  # pragma: no cover
                pass

        # config-host.h is a generated header consisting of #-defines detailing
        # configuration settings, including whether certain features are
        # enabled. It serves as an important diagnostic.
        config_host = build_dir / "config-host.h"
        config = api.file.read_text(
            "config-host.h",
            config_host,
            test_data="#pragma once\n#define CONFIG_FOO\n#undef CONFIG_BAR",
        )
        if target_platform.is_linux:
            # <sys/auxv.h> in glibc 2.27 doesn't define HWCAP_USCAT which breaks the
            # build, disable getauxval to force the use of <asm/hwcap.h>.
            api.file.write_text(
                "update config-host.h",
                config_host,
                config.replace("#define CONFIG_GETAUXVAL", "#undef CONFIG_GETAUXVAL"),
            )

        api.step(
            "compile",
            [
                pkg_dir.joinpath("bin", "meson.pyz"),
                "compile",
                "-C",
                build_dir,
            ],
        )
        api.step(
            "install",
            [
                pkg_dir.joinpath("bin", "meson.pyz"),
                "install",
                "-C",
                build_dir,
                "--skip-subprojects",
            ],
        )

        # TODO(fxbug.dev/106763): Re-enable tests when passing again.

    return install_dir


# TODO(https://github.com/mesonbuild/meson/issues/8592): Meson links against
# libstdc++ by default when using clang. We use libc++ and so need to filter
# that out.
def wrap_clang(api, clang):
    contents = (
        """#!/bin/sh
args=("$@")
args=("${args[@]/-lstdc++}")
exec %s "${args[@]}"
"""
        % clang
    )
    wrapper = api.path.tmp_base_dir / "clang-wrapper.sh"
    api.file.write_text(f"write {api.path.basename(wrapper)}", wrapper, contents)
    api.step(
        f"make {api.path.basename(wrapper)} executable",
        ["chmod", "+x", wrapper],
    )
    return wrapper


def GenTests(api):
    version = "8.0.50"

    def properties(platform, prod=True, builders=None):
        return api.properties(
            remote="https://fuchsia.googlesource.com/third_party/qemu",
            platform=platform,
            prod=prod,
            builders=builders,
        )

    yield (
        api.test("linux-amd64")
        + api.platform.name("linux")
        + properties(
            "linux-amd64",
            builders={
                "linux-amd64": ["fuchsia/linux-x64-builder"],
                "mac-amd64": ["fuchsia/mac-x64-builder"],
            },
        )
        + api.step_data("read qemu version", api.file.read_text(version))
    )

    yield (
        api.test("mac-amd64")
        + api.platform.name("mac")
        + properties("mac-amd64")
        + api.step_data("read qemu version", api.file.read_text(version))
    )

    yield (
        api.test("linux-arm64")
        + api.platform.name("linux")
        + properties("linux-arm64", prod=False)
        + api.step_data("read qemu version", api.file.read_text(version))
    )