| # 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.""" |
| |
| from recipe_engine.post_process import StatusSuccess |
| from recipe_engine.recipe_api import Property |
| |
| DEPS = [ |
| "fuchsia/archive", |
| "fuchsia/git", |
| "fuchsia/goma", |
| "fuchsia/macos_sdk", |
| "fuchsia/status_check", |
| "fuchsia/upload", |
| "recipe_engine/cipd", |
| "recipe_engine/context", |
| "recipe_engine/file", |
| "recipe_engine/path", |
| "recipe_engine/platform", |
| "recipe_engine/properties", |
| "recipe_engine/raw_io", |
| "recipe_engine/step", |
| ] |
| |
| PLATFORM_TO_TRIPLE = { |
| "linux-amd64": "x86_64-linux-gnu", |
| "linux-arm64": "aarch64-linux-gnu", |
| "mac-amd64": "x86_64-apple-darwin", |
| } |
| PLATFORMS = PLATFORM_TO_TRIPLE.keys() |
| |
| PROPERTIES = { |
| "repository": Property( |
| kind=str, |
| help="Git repository URL", |
| default="https://fuchsia.googlesource.com/third_party/qemu", |
| ), |
| "branch": Property(kind=str, help="Git branch", default="refs/heads/master"), |
| "revision": Property(kind=str, help="Revision", default=None), |
| "platform": Property(kind=str, help="CIPD platform for the target", default=None), |
| "prod": Property(kind=bool, help="Whether to do production build", default=True), |
| } |
| |
| |
| def platform_sysroot(api, cipd_dir, platform): |
| if platform.startswith("linux"): |
| return cipd_dir.join(platform) |
| elif platform.startswith("mac"): # pragma: no cover |
| # TODO(fxbug.dev/3043): Eventually use our own hermetic sysroot as for Linux. |
| step_result = api.step( |
| "xcrun", |
| ["xcrun", "--sdk", "macosx", "--show-sdk-path"], |
| stdout=api.raw_io.output(name="sdk-path", add_output_log=True), |
| step_test_data=lambda: api.raw_io.test_api.stream_output( |
| "/some/xcode/path" |
| ), |
| ) |
| return step_result.stdout.strip() |
| assert False, "unsupported platform" # pragma: no cover |
| return None # pragma: no cover |
| |
| |
| def environment(api, cipd_dir, platform, host, cflags=(), cxxflags=(), ldflags=()): |
| sysroot = ["--sysroot=%s" % platform_sysroot(api, cipd_dir, platform)] |
| target = ["--target=%s" % PLATFORM_TO_TRIPLE[platform]] if platform != host else [] |
| opt = ["-O3"] # TODO(phosek): also enable ["-flto", "-fwhole-program-vtables"] |
| variables = { |
| "CC": cipd_dir.join("bin", "clang"), |
| "CXX": cipd_dir.join("bin", "clang++"), |
| "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)), |
| } |
| if platform.startswith("linux"): |
| variables.update( |
| { |
| "AR": cipd_dir.join("bin", "llvm-ar"), |
| "RANLIB": cipd_dir.join("bin", "llvm-ranlib"), |
| "NM": cipd_dir.join("bin", "llvm-nm"), |
| "STRIP": cipd_dir.join("bin", "llvm-strip"), |
| "OBJCOPY": cipd_dir.join("bin", "llvm-objcopy"), |
| } |
| ) |
| |
| return variables |
| |
| |
| def configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| flags=(), |
| cflags=(), |
| cxxflags=(), |
| ldflags=(), |
| step_name="configure", |
| ): |
| target = PLATFORM_TO_TRIPLE[platform] |
| variables = environment(api, cipd_dir, platform, host, cflags, cxxflags, ldflags) |
| if platform != host: |
| flags.extend( |
| ["--build=%s" % PLATFORM_TO_TRIPLE[host], "--host=%s" % target,] |
| ) |
| return api.step( |
| step_name, |
| [src_dir.join("configure"),] |
| + flags |
| + ["%s=%s" % (k, v) for k, v in variables.iteritems()], |
| ) |
| |
| |
| def cmake(api, cipd_dir, src_dir, platform, options=None, step_name="cmake"): |
| options = options or [] |
| if platform.startswith("linux"): |
| options.extend( |
| [ |
| "-DCMAKE_LINKER=%s" % cipd_dir.join("bin", "ld.lld"), |
| "-DCMAKE_NM=%s" % cipd_dir.join("bin", "llvm-nm"), |
| "-DCMAKE_OBJCOPY=%s" % cipd_dir.join("bin", "llvm-objcopy"), |
| "-DCMAKE_OBJDUMP=%s" % cipd_dir.join("bin", "llvm-objdump"), |
| "-DCMAKE_RANLIB=%s" % cipd_dir.join("bin", "llvm-ranlib"), |
| "-DCMAKE_STRIP=%s" % cipd_dir.join("bin", "llvm-strip"), |
| ] |
| ) |
| |
| target = PLATFORM_TO_TRIPLE[platform] |
| return api.step( |
| step_name, |
| [ |
| cipd_dir.join("bin", "cmake"), |
| "-GNinja", |
| "-DCMAKE_MAKE_PROGRAM=%s" % cipd_dir.join("ninja"), |
| "-DCMAKE_C_COMPILER=%s" % cipd_dir.join("bin", "clang"), |
| "-DCMAKE_C_COMPILER_TARGET=%s" % target, |
| "-DCMAKE_CXX_COMPILER=%s" % cipd_dir.join("bin", "clang++"), |
| "-DCMAKE_CXX_COMPILER_TARGET=%s" % target, |
| "-DCMAKE_SYSROOT=%s" % platform_sysroot(api, cipd_dir, platform), |
| ] |
| + options |
| + [src_dir], |
| ) |
| |
| |
| def automake(api, name, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", name) |
| build_dir = api.path["start_dir"].join(name) |
| api.file.ensure_directory(name, build_dir) |
| |
| with api.context(cwd=build_dir): |
| configure(api, cipd_dir, src_dir, platform, host, ["--prefix=%s" % pkg_dir,]) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install"]) |
| |
| |
| def build_make(api, cipd_dir, pkg_dir, platform, host): |
| automake(api, "make", cipd_dir, pkg_dir, platform, host) |
| |
| |
| def build_m4(api, cipd_dir, pkg_dir, platform, host): |
| automake(api, "m4", cipd_dir, pkg_dir, platform, host) |
| |
| |
| def build_autoconf(api, cipd_dir, pkg_dir, platform, host): |
| automake(api, "autoconf", cipd_dir, pkg_dir, platform, host) |
| |
| |
| def build_automake(api, cipd_dir, pkg_dir, platform, host): |
| automake(api, "automake", cipd_dir, pkg_dir, platform, host) |
| |
| |
| def build_libtool(api, cipd_dir, pkg_dir, platform, host): |
| automake(api, "libtool", cipd_dir, pkg_dir, platform, host) |
| |
| |
| def build_pkg_config(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "pkg-config") |
| build_dir = api.path["start_dir"].join("pkg-config") |
| api.file.ensure_directory("pkg-config", build_dir) |
| |
| ldflags = () |
| if host.startswith("mac"): |
| ldflags = ("-framework CoreFoundation", "-framework CoreServices") |
| |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--prefix=%s" % pkg_dir, |
| "--with-internal-glib", |
| "--disable-host-tool", |
| "--disable-debug", |
| ], |
| ldflags=ldflags, |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install"]) |
| |
| |
| def build_zlib(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "zlib") |
| build_dir = api.path["start_dir"].join("zlib") |
| api.file.ensure_directory("zlib", build_dir) |
| |
| variables = environment(api, cipd_dir, platform, host, cflags=("-fPIC",)) |
| with api.context(cwd=build_dir, env=variables): |
| api.step("configure", [src_dir.join("configure"), "--prefix=", "--static",]) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_pixman(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "pixman") |
| build_dir = api.path["start_dir"].join("pixman") |
| api.file.ensure_directory("pixman", build_dir) |
| |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--disable-dependency-tracking", |
| "--disable-gtk", |
| "--disable-shared", |
| "--disable-silent-rules", |
| "--enable-static", |
| "--prefix=", |
| "--with-pic", |
| ], |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_sdl( |
| api, cipd_dir, pkg_dir, platform, host |
| ): # pylint: disable=unused-argument |
| # host isn't used, but keep it for symmetry with the other build_ functions. |
| src_dir = cipd_dir.join("source", "sdl") |
| build_dir = api.path["start_dir"].join("sdl") |
| api.file.ensure_directory("sdl", build_dir) |
| |
| with api.context(cwd=build_dir): |
| cmake( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| [ |
| "-DCMAKE_INSTALL_PREFIX=", |
| "-DVIDEO_WAYLAND=OFF", |
| "-DSDL_SHARED=OFF", |
| "-DSDL_STATIC_PIC=ON", |
| "-DGCC_ATOMICS=ON", |
| ], |
| ) |
| api.step("build", [cipd_dir.join("ninja")]) |
| with api.context(env={"DESTDIR": pkg_dir}): |
| api.step("install", [cipd_dir.join("ninja"), "install"]) |
| |
| |
| def build_libffi(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "libffi") |
| build_dir = api.path["start_dir"].join("libffi") |
| api.file.ensure_directory("libffi", build_dir) |
| |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--disable-debug", |
| "--disable-dependency-tracking", |
| "--disable-shared", |
| "--enable-static", |
| "--prefix=", |
| "--target=%s" % PLATFORM_TO_TRIPLE[platform], |
| "--with-pic", |
| ], |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_ncurses(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "ncurses") |
| build_dir = api.path["start_dir"].join("ncurses") |
| api.file.ensure_directory("ncurses", build_dir) |
| |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--disable-debug", |
| "--disable-dependency-tracking", |
| "--disable-shared", |
| "--enable-pc-files", |
| "--enable-sigwinch", |
| "--enable-widec", |
| "--without-gpm", |
| "--without-progs", |
| "--without-cxx-binding", |
| "--with-pic", |
| ], |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_gettext(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "gettext") |
| build_dir = api.path["start_dir"].join("gettext") |
| api.file.ensure_directory("gettext", build_dir) |
| |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--disable-dependency-tracking", |
| "--disable-silent-rules", |
| "--disable-debug", |
| "--disable-shared", |
| "--disable-java", |
| "--disable-csharp", |
| "--disable-c++", |
| "--disable-openmp", |
| "--enable-static", |
| "--prefix=", |
| "--with-pic", |
| "--with-included-gettext", |
| "--with-included-glib", |
| "--with-included-libcroco", |
| "--with-included-libunistring", |
| "--without-git", |
| "--without-cvs", |
| "--without-xz", |
| ], |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_glib(api, cipd_dir, pkg_dir, platform, host): |
| src_dir = cipd_dir.join("source", "glib") |
| build_dir = api.path["start_dir"].join("glib") |
| api.file.ensure_directory("glib", build_dir) |
| |
| extra_args = [] |
| if platform != host: |
| api.file.write_text( |
| "cache", |
| build_dir.join("%s.cache" % platform), |
| """ |
| glib_cv_long_long_format=ll |
| glib_cv_stack_grows=no |
| glib_cv_uscore=no |
| """, |
| ) |
| extra_args.append("--cache-file=%s.cache" % platform) |
| |
| with api.context(cwd=src_dir, env={"NOCONFIGURE": "1"}): |
| api.step("autogen", [src_dir.join("autogen.sh")]) |
| with api.context(cwd=build_dir): |
| configure( |
| api, |
| cipd_dir, |
| src_dir, |
| platform, |
| host, |
| [ |
| "--disable-dependency-tracking", |
| "--disable-silent-rules", |
| "--disable-dtrace", |
| "--disable-libelf", |
| "--disable-libmount", |
| "--disable-shared", |
| "--enable-static", |
| "--prefix=", |
| "--with-pic", |
| "--with-pcre=internal", |
| ] |
| + extra_args, |
| cflags=("-I%s" % pkg_dir.join("include"),), |
| cxxflags=("-I%s" % pkg_dir.join("include"),), |
| ldflags=("-L%s" % pkg_dir.join("lib"),), |
| ) |
| api.step("build", ["make", "-j%d" % api.goma.jobs]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % pkg_dir]) |
| |
| |
| def build_qemu(api, cipd_dir, platform, host, revision, prod): |
| src_dir = api.path["start_dir"].join("qemu", "src") |
| api.file.ensure_directory("qemu/src", src_dir) |
| repository = "https://fuchsia.googlesource.com/third_party/qemu" |
| revision = api.git.checkout(repository, src_dir, ref=revision, submodules=True) |
| build_dir = api.path["start_dir"].join("qemu", "build") |
| api.file.ensure_directory("qemu/build", build_dir) |
| install_dir = api.path["start_dir"].join("qemu", "install") |
| api.file.ensure_directory("qemu/install", install_dir) |
| |
| target = PLATFORM_TO_TRIPLE[platform] |
| |
| sysroot = ["--sysroot=%s" % platform_sysroot(api, cipd_dir, platform)] |
| target = ["--target=%s" % PLATFORM_TO_TRIPLE[platform]] if platform != host else [] |
| opt = ["-O3"] # TODO(phosek): also enable ["-flto", "-fwhole-program-vtables"] |
| |
| extra_options = { |
| "linux": [ |
| "--cc=%s" % cipd_dir.join("bin", "clang"), |
| "--cxx=%s" % cipd_dir.join("bin", "clang++"), |
| "--build=%s" % PLATFORM_TO_TRIPLE[host], |
| "--host=%s" % target, |
| "--extra-cflags=%s" % " ".join(sysroot + opt + target), |
| "--extra-cxxflags=%s" % " ".join(sysroot + opt + target), |
| # 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. |
| "--extra-ldflags=%s" |
| % " ".join( |
| sysroot + target + opt + ["-static-libstdc++ -Qunused-arguments"] |
| ), |
| "--disable-gtk", |
| "--disable-x11", |
| "--enable-sdl", |
| "--enable-kvm", |
| ], |
| "mac": [ |
| "--cc=%s" % cipd_dir.join("bin", "clang"), |
| "--cxx=%s" % cipd_dir.join("bin", "clang++"), |
| "--enable-cocoa", |
| "--extra-cflags=%s" % " ".join(sysroot + target), |
| "--extra-cxxflags=%s" % " ".join(sysroot + target), |
| "--extra-ldflags=%s" |
| % " ".join( |
| sysroot + target + ["-nostdlib++ %s" % cipd_dir.join("lib", "libc++.a")] |
| ), |
| ], |
| }[platform.split("-")[0]] |
| |
| # 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. |
| variables = {"QEMU_PKG_CONFIG_FLAGS": "--static"} |
| if platform.startswith("linux"): |
| variables.update( |
| { |
| "AR": cipd_dir.join("bin", "llvm-ar"), |
| "RANLIB": cipd_dir.join("bin", "llvm-ranlib"), |
| "NM": cipd_dir.join("bin", "llvm-nm"), |
| "STRIP": cipd_dir.join("bin", "llvm-strip"), |
| "OBJCOPY": cipd_dir.join("bin", "llvm-objcopy"), |
| } |
| ) |
| |
| with api.context(cwd=build_dir, env=variables): |
| api.step( |
| "configure qemu", |
| [ |
| src_dir.join("configure"), |
| "--disable-attr", |
| "--disable-auth-pam", |
| "--disable-bochs", |
| "--disable-brlapi", |
| "--disable-bzip2", |
| "--disable-cap-ng", |
| "--disable-cloop", |
| "--disable-curl", |
| "--disable-debug-info", |
| "--disable-debug-tcg", |
| "--disable-dmg", |
| "--disable-docs", |
| "--disable-gcrypt", |
| "--disable-glusterfs", |
| "--disable-gnutls", |
| "--disable-guest-agent", |
| "--disable-iconv", |
| "--disable-libiscsi", |
| "--disable-libnfs", |
| "--disable-libpmem", |
| "--disable-libusb", |
| "--disable-libxml2", |
| "--disable-linux-aio", |
| "--disable-lzo", |
| "--disable-nettle", |
| "--disable-opengl", |
| "--disable-parallels", |
| "--disable-plugins", |
| "--disable-qcow1", |
| "--disable-qed", |
| "--disable-qom-cast-debug", |
| "--disable-rbd", |
| "--disable-rdma", |
| "--disable-sdl-image", |
| "--disable-seccomp", |
| "--disable-sheepdog", |
| "--disable-smartcard", |
| "--disable-snappy", |
| "--disable-spice", |
| "--disable-tasn1", |
| "--disable-tcg-interpreter", |
| "--disable-tcmalloc", |
| "--disable-tpm", |
| "--disable-usb-redir", |
| "--disable-vdi", |
| "--disable-vhost-scsi", |
| "--disable-vhost-vsock", |
| "--disable-virtfs", |
| "--disable-vnc-jpeg", |
| "--disable-vnc-png", |
| "--disable-vnc-sasl", |
| "--disable-vte", |
| "--disable-vvfat", |
| "--disable-werror", |
| "--disable-xen", |
| "--enable-slirp=git", # Use slirp built from source, not system one |
| "--prefix=", |
| "--target-list=aarch64-softmmu,arm-softmmu,riscv64-softmmu,x86_64-softmmu", |
| "--without-system-fdt", |
| ] |
| + extra_options, |
| ) |
| api.step("build", ["make", "-j%d" % api.platform.cpu_count]) |
| api.step("install", ["make", "install", "DESTDIR=%s" % install_dir]) |
| |
| qemu_version = api.file.read_text( |
| "version", src_dir.join("VERSION"), test_data="2.10.1" |
| ) |
| assert qemu_version, "Cannot determine QEMU version" |
| |
| # Upload the installation to isolate. |
| isolated_hash = api.archive.upload(install_dir, output_property="isolated") |
| api.step.active_result.presentation.step_text = isolated_hash |
| |
| if prod: |
| # Upload the installation to CIPD for production builds. |
| api.upload.cipd_package( |
| "fuchsia/third_party/qemu/" + platform, |
| install_dir, |
| [api.upload.DirectoryPath(install_dir)], |
| {"git_revision": revision}, |
| repository=repository, |
| ) |
| |
| |
| def RunSteps(api, repository, branch, revision, platform, prod): |
| api.goma.ensure() |
| |
| if not revision: |
| revision = api.git.get_remote_branch_head(repository, branch) |
| |
| # TODO: factor this out into a host_build recipe module. |
| host_platform = "%s-%s" % ( |
| api.platform.name.replace("win", "windows"), |
| {"intel": {32: "386", 64: "amd64",}, "arm": {32: "armv6", 64: "arm64",},}[ |
| api.platform.arch |
| ][api.platform.bits], |
| ) |
| target_platform = platform or host_platform |
| |
| with api.step.nest("ensure_packages"): |
| with api.context(infra_steps=True): |
| cipd_dir = api.path["start_dir"].join("cipd") |
| pkgs = api.cipd.EnsureFile() |
| pkgs.add_package("infra/cmake/${platform}", "version:3.9.2") |
| pkgs.add_package("infra/ninja/${platform}", "version:1.8.2") |
| pkgs.add_package("fuchsia/third_party/clang/${platform}", "integration") |
| if target_platform.startswith("linux"): |
| pkgs.add_package( |
| "fuchsia/sysroot/linux-amd64", |
| "git_revision:a96053c799a0f1ad0b7e8ab8199edbfa18adcbb6", |
| "linux-amd64", |
| ) |
| pkgs.add_package( |
| "fuchsia/sysroot/linux-arm64", |
| "git_revision:a96053c799a0f1ad0b7e8ab8199edbfa18adcbb6", |
| "linux-arm64", |
| ) |
| |
| pkgs.add_package( |
| "fuchsia/third_party/source/m4", "version:1.4.18", "source/m4" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/autoconf", "version:2.69", "source/autoconf" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/automake", "version:1.16", "source/automake" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/libtool", "version:2.4.6", "source/libtool" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/make", "version:4.2.1", "source/make" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/pkg-config", |
| "version:0.29", |
| "source/pkg-config", |
| ) |
| |
| pkgs.add_package( |
| "fuchsia/third_party/source/ncurses", "version:6.1", "source/ncurses" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/gettext", |
| "version:0.19.8.1", |
| "source/gettext", |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/glib", "version:2.58.2", "source/glib" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/libffi", "version:3.3", "source/libffi" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/pixman", "version:0.36.0", "source/pixman" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/sdl", "version:2.0.12", "source/sdl" |
| ) |
| pkgs.add_package( |
| "fuchsia/third_party/source/zlib", "version:1.2.11", "source/zlib" |
| ) |
| |
| api.cipd.ensure(cipd_dir, pkgs) |
| |
| pkg_dir = api.path["start_dir"].join("pkgconfig") |
| api.file.ensure_directory("create pkg dir", pkg_dir) |
| |
| variables = { |
| "PKG_CONFIG_SYSROOT_DIR": pkg_dir, |
| "PKG_CONFIG_ALLOW_SYSTEM_CFLAGS": 1, |
| "PKG_CONFIG_ALLOW_SYSTEM_LIBS": 1, |
| "PKG_CONFIG_LIBDIR": ":".join( |
| [ |
| str(pkg_dir.join("share", "pkgconfig")), |
| str(pkg_dir.join("lib", "pkgconfig")), |
| ] |
| ), |
| } |
| |
| with api.macos_sdk(), api.context( |
| env=variables, env_prefixes={"PATH": [pkg_dir.join("bin")]} |
| ): |
| with api.step.nest("make"): |
| build_make(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| with api.step.nest("m4"): |
| build_m4(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| with api.step.nest("autoconf"): |
| build_autoconf(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| with api.step.nest("automake"): |
| build_automake(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| with api.step.nest("libtool"): |
| build_libtool(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| with api.step.nest("pkg-config"): |
| build_pkg_config(api, cipd_dir, pkg_dir, host_platform, host_platform) |
| |
| if target_platform.startswith("linux"): |
| with api.step.nest("sdl"): |
| build_sdl(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("zlib"): |
| build_zlib(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("pixman"): |
| build_pixman(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("libffi"): |
| build_libffi(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("ncurses"): |
| build_ncurses(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| if target_platform.startswith("mac"): |
| with api.step.nest("gettext"): |
| build_gettext(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("glib"): |
| build_glib(api, cipd_dir, pkg_dir, target_platform, host_platform) |
| |
| with api.step.nest("qemu"): |
| build_qemu(api, cipd_dir, target_platform, host_platform, revision, prod) |
| |
| |
| def GenTests(api): |
| revision = "75b05681239cb309a23fcb4f8864f177e5aa62da" |
| version = "QEMU emulator version 2.8.0 (v2.8.0-15-g28cd8b6577-dirty)" |
| for platform in ["linux", "mac"]: |
| yield ( |
| api.status_check.test(platform) |
| + api.platform.name(platform) |
| + api.git.get_remote_branch_head("git ls-remote", revision) |
| + api.properties( |
| manifest="qemu", |
| remote="https://fuchsia.googlesource.com/manifest", |
| platform=platform + "-amd64", |
| ) |
| + api.step_data("qemu.version", api.raw_io.stream_output(version)) |
| + api.post_process(StatusSuccess) |
| ) |
| yield ( |
| api.status_check.test(platform + "_new") |
| + api.platform.name(platform) |
| + api.git.get_remote_branch_head("git ls-remote", revision) |
| + api.properties( |
| manifest="qemu", |
| remote="https://fuchsia.googlesource.com/manifest", |
| platform=platform + "-amd64", |
| ) |
| + api.step_data("qemu.version", api.raw_io.stream_output(version)) |
| + api.step_data( |
| "qemu.cipd.cipd search fuchsia/third_party/qemu/" |
| + platform |
| + "-amd64 " |
| + "git_revision:deadbeef", |
| api.cipd.example_search("fuchsia/qemu/" + platform + "-amd64 ", []), |
| ) |
| + api.post_process(StatusSuccess) |
| ) |
| yield ( |
| api.status_check.test("linux_arm64") |
| + api.platform.name("linux") |
| + api.git.get_remote_branch_head("git ls-remote", revision) |
| + api.properties( |
| manifest="qemu", |
| remote="https://fuchsia.googlesource.com/manifest", |
| platform="linux-arm64", |
| ) |
| + api.step_data("qemu.version", api.raw_io.stream_output(version)) |
| + api.post_process(StatusSuccess) |
| ) |
