diff options
Diffstat (limited to 'moz.configure')
| -rwxr-xr-x | moz.configure | 1067 |
1 files changed, 1067 insertions, 0 deletions
diff --git a/moz.configure b/moz.configure new file mode 100755 index 0000000000..9ca101e0b3 --- /dev/null +++ b/moz.configure @@ -0,0 +1,1067 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +include("build/moz.configure/init.configure") + +# Note: +# - Gecko-specific options and rules should go in toolkit/moz.configure. +# - Firefox-specific options and rules should go in browser/moz.configure. +# - Fennec-specific options and rules should go in +# mobile/android/moz.configure. +# - Spidermonkey-specific options and rules should go in js/moz.configure. +# - etc. + +imply_option( + "--enable-artifact-build-symbols", + depends(artifact_builds)(lambda v: False if v is None else None), + reason="--disable-artifact-builds", +) + +option( + "--enable-artifact-build-symbols", + nargs="?", + choices=("full",), + help="Download symbols when artifact builds are enabled.", +) + + +@depends("--enable-artifact-build-symbols", "MOZ_AUTOMATION", target) +def enable_artifact_build_symbols(value, automation, target): + if len(value): + return value[0] + if bool(value): + if target.os == "Android" and not automation: + return "full" + return True + return None + + +set_config("MOZ_ARTIFACT_BUILD_SYMBOLS", enable_artifact_build_symbols) + + +@depends("--enable-artifact-builds") +def imply_disable_compile_environment(value): + if value: + return False + + +option( + env="MOZ_COPY_PDBS", + help="For builds that do not support symbols in the normal fashion," + " generate and copy them into the resulting build archive.", +) + +set_config("MOZ_COPY_PDBS", depends_if("MOZ_COPY_PDBS")(lambda _: True)) + +imply_option("--enable-compile-environment", imply_disable_compile_environment) + +option("--disable-compile-environment", help="Disable compiler/library checks") + + +@depends("--disable-compile-environment") +def compile_environment(compile_env): + if compile_env: + return True + + +set_config("COMPILE_ENVIRONMENT", compile_environment) +add_old_configure_assignment("COMPILE_ENVIRONMENT", compile_environment) + +option("--disable-tests", help="Do not build test libraries & programs") + + +@depends("--disable-tests") +def enable_tests(value): + if value: + return True + + +set_config("ENABLE_TESTS", enable_tests) +set_define("ENABLE_TESTS", enable_tests) + + +@depends(enable_tests) +def gtest_has_rtti(value): + if value: + return "0" + + +set_define("GTEST_HAS_RTTI", gtest_has_rtti) + + +@depends(target, enable_tests) +def linux_gtest_defines(target, enable_tests): + if enable_tests and target.os == "Android": + return namespace(os_linux_android=True, use_own_tr1_tuple=True, has_clone="0") + + +set_define("GTEST_OS_LINUX_ANDROID", linux_gtest_defines.os_linux_android) +set_define("GTEST_USE_OWN_TR1_TUPLE", linux_gtest_defines.use_own_tr1_tuple) +set_define("GTEST_HAS_CLONE", linux_gtest_defines.has_clone) + +option( + "--enable-debug", + nargs="?", + help="Enable building with developer debug info " + "(using the given compiler flags).", +) + + +@depends("--enable-debug") +def moz_debug(debug): + if debug: + return bool(debug) + + +set_config("MOZ_DEBUG", moz_debug) +set_define("MOZ_DEBUG", moz_debug) +# Override any value MOZ_DEBUG may have from the environment when passing it +# down to old-configure. +add_old_configure_assignment("MOZ_DEBUG", depends("--enable-debug")(lambda x: bool(x))) + +set_config( + "MOZ_DIAGNOSTIC_ASSERT_ENABLED", + True, + when=moz_debug | milestone.is_early_beta_or_earlier, +) +set_define( + "MOZ_DIAGNOSTIC_ASSERT_ENABLED", + True, + when=moz_debug | milestone.is_early_beta_or_earlier, +) + +option( + "--with-debug-label", + nargs="+", + help="Debug DEBUG_<value> for each comma-separated value given", +) + + +@depends(moz_debug, "--with-debug-label") +def debug_defines(debug, labels): + if debug: + return ["DEBUG"] + ["DEBUG_%s" % label for label in labels] + return ["NDEBUG", "TRIMMED"] + + +set_config("MOZ_DEBUG_DEFINES", debug_defines) + +option(env="MOZ_PGO", help="Build with profile guided optimizations") + +set_config("MOZ_PGO", depends("MOZ_PGO")(lambda x: bool(x))) + + +# Imply --enable-release when MOZILLA_OFFICIAL is set rather than adjusting the +# default so that we can't have both MOZILLA_OFFICIAL and --disable-release set. +imply_option("--enable-release", mozilla_official) + +option( + "--enable-release", + default=milestone.is_release_or_beta | depends("MOZ_AUTOMATION")(lambda x: bool(x)), + help="{Build|Do not build} with more conservative, release " + "engineering-oriented options.{ This may slow down builds.|}", +) + + +@depends("--enable-release") +def developer_options(value): + if not value: + return True + + +add_old_configure_assignment("DEVELOPER_OPTIONS", developer_options) +set_config("DEVELOPER_OPTIONS", developer_options) + + +# hybrid build handling +# ============================================================== + +option( + "--disable-unified-build", + help="Enable building modules that are not marked with `REQUIRES_UNIFIED_BUILD` in non unified context", +) + +set_config("ENABLE_UNIFIED_BUILD", True, when="--disable-unified-build") + + +include("build/moz.configure/bootstrap.configure") + + +# The execution model of the configure sandbox doesn't allow for +# check_prog to use bootstrap_search_path directly because check_prog +# comes first, so we use a trick to allow it. Uses of check_prog +# happening before here won't allow bootstrap. +@template +def check_prog(*args, **kwargs): + kwargs["bootstrap_search_path"] = bootstrap_search_path + return check_prog(*args, **kwargs) + + +check_prog("WGET", ("wget",), allow_missing=True) + + +include("build/moz.configure/toolchain.configure", when="--enable-compile-environment") + +include("build/moz.configure/pkg.configure") +# Make this assignment here rather than in pkg.configure to avoid +# requiring this file in unit tests. +add_old_configure_assignment("PKG_CONFIG", pkg_config) + +include("build/moz.configure/memory.configure", when="--enable-compile-environment") +include("build/moz.configure/headers.configure", when="--enable-compile-environment") +include("build/moz.configure/warnings.configure", when="--enable-compile-environment") +include("build/moz.configure/flags.configure", when="--enable-compile-environment") +include("build/moz.configure/lto-pgo.configure", when="--enable-compile-environment") +# rust.configure is included by js/moz.configure. + +option("--enable-valgrind", help="Enable Valgrind integration hooks") + +valgrind_h = check_header("valgrind/valgrind.h", when="--enable-valgrind") + + +@depends("--enable-valgrind", valgrind_h) +def check_valgrind(valgrind, valgrind_h): + if valgrind: + if not valgrind_h: + die("--enable-valgrind specified but Valgrind is not installed") + return True + + +set_define("MOZ_VALGRIND", check_valgrind) +set_config("MOZ_VALGRIND", check_valgrind) + + +@depends(target, host) +def is_openbsd(target, host): + return target.kernel == "OpenBSD" or host.kernel == "OpenBSD" + + +option( + env="SO_VERSION", + nargs=1, + default="1.0", + when=is_openbsd, + help="Shared library version for OpenBSD systems", +) + + +@depends("SO_VERSION", when=is_openbsd) +def so_version(value): + return value + + +@template +def library_name_info_template(host_or_target): + assert host_or_target in {host, target} + compiler = { + host: host_c_compiler, + target: c_compiler, + }[host_or_target] + + @depends(host_or_target, compiler, so_version) + def library_name_info_impl(host_or_target, compiler, so_version): + if host_or_target.kernel == "WINNT": + # There aren't artifacts for mingw builds, so it's OK that the + # results are inaccurate in that case. + if compiler and compiler.type != "clang-cl": + return namespace( + dll=namespace(prefix="", suffix=".dll"), + lib=namespace(prefix="lib", suffix="a"), + import_lib=namespace(prefix="lib", suffix="a"), + obj=namespace(prefix="", suffix="o"), + ) + + return namespace( + dll=namespace(prefix="", suffix=".dll"), + lib=namespace(prefix="", suffix="lib"), + import_lib=namespace(prefix="", suffix="lib"), + obj=namespace(prefix="", suffix="obj"), + ) + + elif host_or_target.kernel == "Darwin": + return namespace( + dll=namespace(prefix="lib", suffix=".dylib"), + lib=namespace(prefix="lib", suffix="a"), + import_lib=namespace(prefix=None, suffix=""), + obj=namespace(prefix="", suffix="o"), + ) + elif so_version: + so = ".so.%s" % so_version + else: + so = ".so" + + return namespace( + dll=namespace(prefix="lib", suffix=so), + lib=namespace(prefix="lib", suffix="a"), + import_lib=namespace(prefix=None, suffix=""), + obj=namespace(prefix="", suffix="o"), + ) + + return library_name_info_impl + + +host_library_name_info = library_name_info_template(host) +library_name_info = library_name_info_template(target) + +set_config("DLL_PREFIX", library_name_info.dll.prefix) +set_config("DLL_SUFFIX", library_name_info.dll.suffix) +set_config("HOST_DLL_PREFIX", host_library_name_info.dll.prefix) +set_config("HOST_DLL_SUFFIX", host_library_name_info.dll.suffix) +set_config("LIB_PREFIX", library_name_info.lib.prefix) +set_config("LIB_SUFFIX", library_name_info.lib.suffix) +set_config("OBJ_SUFFIX", library_name_info.obj.suffix) +# Lots of compilation tests depend on this variable being present. +add_old_configure_assignment("OBJ_SUFFIX", library_name_info.obj.suffix) +set_config("IMPORT_LIB_SUFFIX", library_name_info.import_lib.suffix) +set_define( + "MOZ_DLL_PREFIX", depends(library_name_info.dll.prefix)(lambda s: '"%s"' % s) +) +set_define( + "MOZ_DLL_SUFFIX", depends(library_name_info.dll.suffix)(lambda s: '"%s"' % s) +) +set_config("HOST_LIB_PREFIX", host_library_name_info.lib.prefix) +set_config("HOST_IMPORT_LIB_SUFFIX", host_library_name_info.import_lib.suffix) +set_config("WASM_OBJ_SUFFIX", "wasm") + +# Make `profiling` available to this file even when js/moz.configure +# doesn't end up included. +profiling = dependable(False) +# Same for js_standalone +js_standalone = dependable(False) +js_shared = dependable(False) +moz_linker = dependable(False) +# Same for fold_libs +fold_libs = dependable(False) +# And dmd +dmd = dependable(False) + +include(include_project_configure) + + +@depends("--help") +@imports(_from="mozbuild.backend", _import="backends") +def build_backends_choices(_): + return tuple(backends) + + +@deprecated_option("--enable-build-backend", nargs="+", choices=build_backends_choices) +def build_backend(backends): + if backends: + return tuple("+%s" % b for b in backends) + + +imply_option("--build-backends", build_backend) + + +@depends( + host, + target, + "--enable-artifact-builds", + "--disable-compile-environment", + "--enable-build-backend", + "--enable-project", + "--enable-application", + "--help", +) +@imports("sys") +@imports(_from="mozbuild.backend.clangd", _import="find_vscode_cmd") +def build_backend_defaults( + host, + target, + artifact_builds, + compile_environment, + requested_backends, + project, + application, + _, +): + if application: + project = application[0] + elif project: + project = project[0] + + if "Tup" in requested_backends: + # As a special case, if Tup was requested, do not combine it with any + # Make based backend by default. + all_backends = [] + elif artifact_builds: + all_backends = ["FasterMake+RecursiveMake"] + else: + all_backends = ["RecursiveMake", "FasterMake"] + if ( + host.os == "WINNT" + and target.os == "WINNT" + and compile_environment + and project not in ("mobile/android", "memory", "tools/update-programs") + ): + all_backends.append("VisualStudio") + if ( + compile_environment + and find_vscode_cmd() + and project not in ("mobile/android", "memory", "tools/update-programs") + ): + all_backends.append("Clangd") + return tuple(all_backends) or None + + +option( + "--build-backends", + nargs="+", + default=build_backend_defaults, + choices=build_backends_choices, + help="Build backends to generate", +) + + +@depends("--build-backends") +def build_backends(backends): + return backends + + +set_config("BUILD_BACKENDS", build_backends) + + +@depends(build_environment, build_backends) +@imports("glob") +def check_objdir_backend_reuse(build_env, backends): + # "Make based" might be RecursiveMake or a hybrid backend, so "Make" is + # intentionally vague for use with the substring match below. + incompatible_backends = (("Tup", "Make"), ("Make", "Tup")) + for backend_file in glob.iglob( + os.path.join(build_env.topobjdir, "backend.*Backend") + ): + for prev, curr in incompatible_backends: + if prev in backend_file and any(curr in b for b in backends): + die( + "The active objdir, %s, was previously " + "used to build with a %s based backend. " + "Change objdirs (by setting MOZ_OBJDIR in " + "your mozconfig) or clobber to continue.\n", + build_env.topobjdir, + prev, + ) + + +# Determine whether to build the gtest xul. This happens in automation +# on Android and Desktop platforms with the exception of: +# - Windows PGO, where linking xul-gtest.dll takes too long; +# - Android other than x86_64, where gtest is not required. +@depends( + build_project, + target, + "MOZ_AUTOMATION", + enable_tests, + when="--enable-compile-environment", +) +def build_gtest(build_project, target, automation, enable_tests): + return bool( + enable_tests + and automation + and build_project in ("browser", "comm/mail", "mobile/android") + and not (target.os == "Android" and target.cpu != "x86_64") + ) + + +option( + "--enable-gtest-in-build", + default=build_gtest, + help="{Enable|Force disable} building the gtest libxul during the build.", + when="--enable-compile-environment", +) + +set_config("LINK_GTEST_DURING_COMPILE", True, when="--enable-gtest-in-build") + +# Localization +# ============================================================== +option( + "--enable-ui-locale", + default="en-US", + help="Select the user interface locale (default: en-US)", +) + +set_config("MOZ_UI_LOCALE", depends("--enable-ui-locale")(lambda x: x)) + +option( + "--enable-icu4x", + help="An experiment to use ICU4X instead of ICU4C. See intl/ICU4X.md", +) + +set_config("MOZ_ICU4X", True, when="--enable-icu4x") + +# clang-plugin location +# ============================================================== + + +@depends(host_library_name_info, build_environment, when="--enable-clang-plugin") +def clang_plugin_path(library_name_info, build_env): + topobjdir = build_env.topobjdir + if topobjdir.endswith("/js/src"): + topobjdir = topobjdir[:-7] + return os.path.abspath( + os.path.join( + topobjdir, + "build", + "clang-plugin", + "%sclang-plugin%s" + % (library_name_info.dll.prefix, library_name_info.dll.suffix), + ) + ) + + +set_config("CLANG_PLUGIN", clang_plugin_path) +add_old_configure_assignment("CLANG_PLUGIN", clang_plugin_path) + + +# Awk detection +# ============================================================== +awk = check_prog("AWK", ("gawk", "mawk", "nawk", "awk"), paths=prefer_mozillabuild_path) + +# Until the AWK variable is not necessary in old-configure + + +@depends(awk) +def awk_for_old_configure(value): + return value + + +add_old_configure_assignment("AWK", awk_for_old_configure) + + +# Perl detection +# ============================================================== +perl = check_prog("PERL", ("perl5", "perl")) + +# Until the PERL variable is not necessary in old-configure + + +@depends(perl) +def perl_for_old_configure(value): + return value + + +add_old_configure_assignment("PERL", perl_for_old_configure) + + +@template +def perl_version_check(min_version): + @depends(perl) + @checking("for minimum required perl version >= %s" % min_version) + def get_perl_version(perl): + return Version( + check_cmd_output( + perl, + "-e", + "print $]", + onerror=lambda: die("Failed to get perl version."), + ) + ) + + @depends(get_perl_version) + def check_perl_version(version): + if version < min_version: + die("Perl %s or higher is required.", min_version) + + @depends(perl) + @checking("for full perl installation") + @imports("subprocess") + def has_full_perl_installation(perl): + ret = subprocess.call([perl, "-e", "use Config; exit(!-d $Config{archlib})"]) + return ret == 0 + + @depends(has_full_perl_installation) + def require_full_perl_installation(has_full_perl_installation): + if not has_full_perl_installation: + die( + "Cannot find Config.pm or $Config{archlib}. " + "A full perl installation is required." + ) + + +perl_version_check("5.006") + + +# GNU make detection +# ============================================================== +option(env="MAKE", nargs=1, help="Path to GNU make") + + +@depends("MAKE", host) +def possible_makes(make, host): + candidates = [] + if make: + candidates.append(make[0]) + if host.kernel == "WINNT": + candidates.extend(("mozmake", "mingw32-make", "make", "gmake")) + else: + candidates.extend(("gmake", "make")) + return candidates + + +check_prog("GMAKE", possible_makes, bootstrap="mozmake") + +# watchman detection +# ============================================================== + +option(env="WATCHMAN", nargs=1, help="Path to the watchman program") + + +@depends(host, "WATCHMAN") +@checking("for watchman", callback=lambda w: w.path if w else "not found") +def watchman(host, prog): + # On Windows, `watchman` is only supported on 64-bit hosts. + if host.os == "WINNT" and host.cpu != "x86_64": + return + + if not prog: + prog = find_program("watchman") + + if not prog: + return + + # `watchman version` will talk to the Watchman daemon service. + # This can hang due to permissions problems. e.g. + # https://github.com/facebook/watchman/issues/376. So use + # `watchman --version` to prevent a class of failures. + out = check_cmd_output(prog, "--version", onerror=lambda: None) + if out is None: + return + + return namespace(path=prog, version=Version(out.strip())) + + +@depends_if(watchman) +@checking("for watchman version") +def watchman_version(w): + return w.version + + +set_config("WATCHMAN", watchman.path) + + +@depends_all(hg_version, hg_config, watchman) +@checking("for watchman Mercurial integration") +@imports("os") +def watchman_hg(hg_version, hg_config, watchman): + if hg_version < Version("3.8"): + return "no (Mercurial 3.8+ required)" + + ext_enabled = False + mode_disabled = False + + for k in ("extensions.fsmonitor", "extensions.hgext.fsmonitor"): + if k in hg_config and hg_config[k] != "!": + ext_enabled = True + + mode_disabled = hg_config.get("fsmonitor.mode") == "off" + + if not ext_enabled: + return "no (fsmonitor extension not enabled)" + if mode_disabled: + return "no (fsmonitor.mode=off disables fsmonitor)" + + return True + + +# Miscellaneous programs +# ============================================================== +check_prog("XARGS", ("xargs",)) + + +@depends(target) +def extra_programs(target): + if target.kernel == "Darwin": + return namespace( + DSYMUTIL=("dsymutil", "llvm-dsymutil"), + MKFSHFS=("newfs_hfs", "mkfs.hfsplus"), + HFS_TOOL=("hfsplus",), + ) + if target.os == "GNU" and target.kernel == "Linux": + return namespace(RPMBUILD=("rpmbuild",)) + + +check_prog("DSYMUTIL", extra_programs.DSYMUTIL, allow_missing=True) +check_prog("MKFSHFS", extra_programs.MKFSHFS, allow_missing=True) +check_prog("HFS_TOOL", extra_programs.HFS_TOOL, allow_missing=True) +check_prog("RPMBUILD", extra_programs.RPMBUILD, allow_missing=True) + + +nsis = check_prog( + "MAKENSISU", + ("makensis",), + bootstrap="nsis/bin", + allow_missing=True, + when=target_is_windows, +) + +# Make sure the version of makensis is up to date. + + +@depends_if(nsis) +@checking("for NSIS version") +@imports("re") +def nsis_version(nsis): + nsis_min_version = "3.0b1" + + def onerror(): + return die("Failed to get nsis version.") + + out = check_cmd_output(nsis, "-version", onerror=onerror) + + m = re.search(r"(?<=v)[0-9]+\.[0-9]+((a|b|rc)[0-9]+)?", out) + + if not m: + raise FatalCheckError("Unknown version of makensis") + ver = Version(m.group(0)) + + # Versions comparisons don't quite work well with beta versions, so ensure + # it works for the non-beta version. + if ver < nsis_min_version and (ver >= "3.0a" or ver < "3"): + raise FatalCheckError( + "To build the installer you must have NSIS" + " version %s or greater in your path" % nsis_min_version + ) + + return ver + + +# And that makensis is 32-bit (but only on Windows). +@depends_if(nsis, when=depends(host)(lambda h: h.kernel == "WINNT")) +@checking("for 32-bit NSIS") +def nsis_binary_type(nsis): + bin_type = windows_binary_type(nsis) + if bin_type != "win32": + raise FatalCheckError("%s is not a 32-bit Windows application" % nsis) + + return "yes" + + +# And any flags we have to give to makensis +@depends(host) +def nsis_flags(host): + if host.kernel != "WINNT": + return "-nocd" + return "" + + +set_config("MAKENSISU_FLAGS", nsis_flags) + +check_prog("7Z", ("7z", "7za"), allow_missing=True, when=target_is_windows) +check_prog("UPX", ("upx",), allow_missing=True, when=target_is_windows) + + +@template +def llvm_tool(name): + @depends(host_c_compiler, c_compiler, bindgen_config_paths) + def llvm_tool(host_c_compiler, c_compiler, bindgen_config_paths): + clang = None + for compiler in (host_c_compiler, c_compiler): + if compiler and compiler.type == "clang": + clang = compiler.compiler + break + elif compiler and compiler.type == "clang-cl": + clang = os.path.join(os.path.dirname(compiler.compiler), "clang") + break + + if not clang and bindgen_config_paths: + clang = bindgen_config_paths.clang_path + tool = name + if clang: + out = check_cmd_output( + clang, "--print-prog-name=%s" % tool, onerror=lambda: None + ) + if out: + tool = out.rstrip() + return (tool,) + + return llvm_tool + + +llvm_objdump = check_prog( + "LLVM_OBJDUMP", + llvm_tool("llvm-objdump"), + what="llvm-objdump", + when="--enable-compile-environment", + paths=clang_search_path, +) + +add_old_configure_assignment("LLVM_OBJDUMP", llvm_objdump) + + +@depends(llvm_tool("llvm-readelf"), toolchain_prefix) +def readelf(llvm_readelf, toolchain_prefix): + commands = [llvm_readelf[0], "readelf"] + for prefix in toolchain_prefix or (): + commands.insert(1, "%sreadelf" % prefix) + return tuple(commands) + + +def validate_readelf(path): + # llvm-readelf from llvm < 8 doesn't support the GNU binutils-compatible `-d` + # flag. We could try running `$path -d $some_binary` but we might be cross + # compiling and not have a binary at hand to run that against. `$path -d` alone + # would fail whether the flag is supported or not. So we resort to look for the + # option in the `--help` output, which fortunately, s compatible between + # llvm-readelf and readelf. + retcode, stdout, stderr = get_cmd_output(path, "--help") + return retcode == 0 and any(l.startswith(" -d ") for l in stdout.splitlines()) + + +@depends("--enable-compile-environment", target, host) +def readelf_when(compile_env, target, host): + return compile_env and any( + x.kernel not in ("Darwin", "WINNT") for x in (target, host) + ) + + +check_prog( + "READELF", + readelf, + when=readelf_when, + paths=clang_search_path, + validate=validate_readelf, +) + + +@depends(llvm_tool("llvm-objcopy"), toolchain_prefix) +def objcopy(llvm_objcopy, toolchain_prefix): + commands = [llvm_objcopy[0], "objcopy"] + for prefix in toolchain_prefix or (): + commands.insert(1, "%sreadelf" % prefix) + return tuple(commands) + + +def validate_objcopy(path): + if "llvm-objcopy" not in path: + return True + # llvm-objcopy doesn't support --only-keep-debug before llvm 9.0. + retcode, stdout, stderr = get_cmd_output(path, "--help") + return retcode == 0 and any( + l.startswith(" --only-keep-debug ") for l in stdout.splitlines() + ) + + +check_prog( + "OBJCOPY", + objcopy, + when=readelf_when, + paths=clang_search_path, + validate=validate_objcopy, +) + +option("--enable-dtrace", help="Build with dtrace support") + +dtrace = check_header( + "sys/sdt.h", + when="--enable-dtrace", + onerror=lambda: die("dtrace enabled but sys/sdt.h not found"), +) + +set_config("HAVE_DTRACE", True, when=dtrace) +set_define("INCLUDE_MOZILLA_DTRACE", True, when=dtrace) +add_old_configure_assignment("enable_dtrace", "yes", when=dtrace) + + +option("--disable-icf", help="Disable Identical Code Folding") + +add_old_configure_assignment( + "MOZ_DISABLE_ICF", "1", when=depends("--enable-icf")(lambda x: not x) +) + + +option( + "--enable-strip", + when=compile_environment, + help="Enable stripping of libs & executables", +) + +# This should be handled as a `when` once bug 1617793 is fixed. + + +@depends("--enable-strip", c_compiler, when=compile_environment) +def enable_strip(strip, c_compiler): + if strip and c_compiler.type != "clang-cl": + return True + + +set_config("ENABLE_STRIP", enable_strip) + +option( + "--disable-install-strip", + when=compile_environment, + help="Enable stripping of libs & executables when packaging", +) + +# This should be handled as a `when` once bug 1617793 is fixed. + + +@depends("--enable-install-strip", c_compiler, when=compile_environment) +def enable_install_strip(strip, c_compiler): + if strip and c_compiler.type != "clang-cl": + return True + + +set_config("PKG_STRIP", enable_install_strip) + + +@depends("--enable-strip", "--enable-install-strip", when=compile_environment) +def strip(strip, install_strip): + return strip or install_strip + + +option(env="STRIP_FLAGS", nargs=1, when=strip, help="Flags for the strip command") + + +@depends("STRIP_FLAGS", profiling, target, when=strip) +def strip_flags(flags, profiling, target): + if flags: + return flags[0].split() + if profiling: + # Only strip debug info and symbols when profiling is enabled, keeping + # local symbols. + if target.kernel == "Darwin": + return ["-S"] + elif target.os == "Android": + # The tooling we use with Android supports detached symbols, and the + # size increase caused by local symbols are too much for mobile. So, + # don't restrict the amount of stripping with a flag. + return + else: + return ["--strip-debug"] + # Otherwise strip everything we can, which happens without flags on non-Darwin. + # On Darwin, it tries to strip things it can't, so we need to limit its scope. + elif target.kernel == "Darwin": + return ["-x", "-S"] + + +set_config("STRIP_FLAGS", strip_flags) + + +@depends(llvm_tool("llvm-strip"), toolchain_prefix, target) +def strip(llvm_strip, toolchain_prefix, target): + commands = ["strip"] + for prefix in toolchain_prefix or (): + commands.insert(0, "%sstrip" % prefix) + # llvm-strip causes some problems on macos targets. + if target.kernel == "Darwin": + commands.append(llvm_strip[0]) + else: + commands.insert(0, llvm_strip[0]) + return tuple(commands) + + +def validate_strip(path): + if "llvm-strip" not in path: + return True + # llvm-strip doesn't support -S before llvm 8.0. + retcode, stdout, stderr = get_cmd_output(path, "--help") + return retcode == 0 and any(l.startswith(" -S ") for l in stdout.splitlines()) + + +@depends("--enable-compile-environment", target, host) +def strip_when(compile_env, target, host): + return compile_env and any(x.kernel != "WINNT" for x in (target, host)) + + +check_prog( + "STRIP", + strip, + when=strip_when, + paths=clang_search_path, + validate=validate_strip, +) + + +@depends(js_standalone, target) +def system_zlib_default(js_standalone, target): + return js_standalone and target.kernel not in ("WINNT", "Darwin") + + +option( + "--with-system-zlib", + nargs="?", + default=system_zlib_default, + help="{Use|Do not use} system libz", +) + + +@depends("--with-system-zlib") +def deprecated_system_zlib_path(value): + if len(value) == 1: + die( + "--with-system-zlib=PATH is not supported anymore. Please use " + "--with-system-zlib and set any necessary pkg-config environment variable." + ) + + +pkg_check_modules("MOZ_ZLIB", "zlib >= 1.2.3", when="--with-system-zlib") + +set_config("MOZ_SYSTEM_ZLIB", True, when="--with-system-zlib") + + +@depends("--with-system-zlib", js_shared, moz_linker, target.os) +def zlib_in_mozglue(system_zlib, js_shared, linker, os): + if not system_zlib and (js_shared or linker or os == "Android"): + return True + + +set_config("ZLIB_IN_MOZGLUE", zlib_in_mozglue) +set_define("ZLIB_IN_MOZGLUE", zlib_in_mozglue) + + +# Please do not add configure checks from here on. + +# Fallthrough to autoconf-based configure +include("build/moz.configure/old.configure") + +# JS Subconfigure. +include("js/sub.configure", when=compile_environment & toolkit) + + +@depends(build_environment, build_project) +@imports("__sandbox__") +@imports("glob") +@imports(_from="os.path", _import="exists") +def config_status_deps(build_env, build_project): + + topsrcdir = build_env.topsrcdir + topobjdir = build_env.topobjdir + + if not topobjdir.endswith("js/src"): + extra_deps = [os.path.join(topobjdir, ".mozconfig.json")] + else: + # mozconfig changes may impact js configure. + extra_deps = [os.path.join(topobjdir[:-7], ".mozconfig.json")] + + confvars = os.path.join(topsrcdir, build_project, "confvars.sh") + if exists(confvars): + extra_deps.append(confvars) + + return ( + list(__sandbox__._all_paths) + + extra_deps + + [ + os.path.join(topsrcdir, "CLOBBER"), + os.path.join(topsrcdir, "configure"), + os.path.join(topsrcdir, "js", "src", "configure"), + os.path.join(topsrcdir, "nsprpub", "configure"), + os.path.join(topsrcdir, "config", "milestone.txt"), + os.path.join(topsrcdir, "browser", "config", "version.txt"), + os.path.join(topsrcdir, "browser", "config", "version_display.txt"), + os.path.join(topsrcdir, "python", "sites", "build.txt"), + os.path.join(topsrcdir, "python", "sites", "common.txt"), + os.path.join(topsrcdir, "python", "sites", "mach.txt"), + os.path.join(topsrcdir, "python", "mach", "mach", "site.py"), + os.path.join(topsrcdir, "aclocal.m4"), + os.path.join(topsrcdir, "old-configure.in"), + os.path.join(topsrcdir, "js", "src", "aclocal.m4"), + os.path.join(topsrcdir, "js", "src", "old-configure.in"), + ] + + glob.glob(os.path.join(topsrcdir, "build", "autoconf", "*.m4")) + ) + + +set_config("CONFIG_STATUS_DEPS", config_status_deps) +# Please do not add anything after setting config_dep_paths. |