Source code
Revision control
Copy as Markdown
Other Tools
# -*- 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
include("util.configure")
include("checks.configure")
# Make `toolkit` available when toolkit/moz.configure is not included.
toolkit = dependable(None)
# Likewise with `bindgen_config_paths` when
# build/moz.configure/bindgen.configure is not included.
bindgen_config_paths = dependable(None)
@depends("--help")
def build_environment(_):
topobjdir = os.path.realpath(".")
topsrcdir = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
dist = os.path.join(topobjdir, "dist")
return namespace(
topsrcdir=topsrcdir,
topobjdir=topobjdir,
dist=dist,
)
@depends(build_environment)
@imports(_import="json")
@imports(_from="pathlib", _import="Path")
def configure_cache(build_environment):
"""
This cache is used to cache the results of compiler invocations
between different runs of configure and save them to the disk, which
results in a significant speed up of subsequent configure runs (15%-50%).
It is not currently thread safe because it is just a simple dictionary
wrapped in a dummy class (ConfigureCache). It could be improved to be
thread safe in the future, if we ever make configure parallelized, but
for now there is no advantage to doing so.
"""
class ConfigureCache(dict):
pass
cache_file = Path(build_environment.topobjdir) / "configure.cache"
if cache_file.exists():
with cache_file.open() as f:
cache_data = json.load(f)
else:
cache_data = {}
cache = ConfigureCache(cache_data)
cache.version_checked_compilers = set()
return cache
set_config("TOPSRCDIR", build_environment.topsrcdir)
set_config("TOPOBJDIR", build_environment.topobjdir)
set_config("DIST", build_environment.dist)
add_old_configure_assignment("_topsrcdir", build_environment.topsrcdir)
option(env="MOZ_AUTOMATION", help="Enable options for automated builds")
set_config("MOZ_AUTOMATION", depends_if("MOZ_AUTOMATION")(lambda x: True))
option(env="OLD_CONFIGURE", nargs=1, help="Path to the old configure script")
option(env="MOZCONFIG", nargs=1, help="Mozconfig location")
# Read user mozconfig
# ==============================================================
# Note: the dependency on --help is only there to always read the mozconfig,
# even when --help is passed. Without this dependency, the function wouldn't
# be called when --help is passed, and the mozconfig wouldn't be read.
@depends("MOZCONFIG", "OLD_CONFIGURE", build_environment, "--help")
@imports(_from="mozbuild.mozconfig", _import="MozconfigLoader")
@imports(_from="mozboot.mozconfig", _import="find_mozconfig")
@imports("os")
def mozconfig(mozconfig, old_configure, build_env, help):
# Don't read the mozconfig for the js configure (yay backwards
# compatibility)
# While the long term goal is that js and top-level use the same configure
# and the same overall setup, including the possibility to use mozconfigs,
# figuring out what we want to do wrt mozconfig vs. command line and
# environment variable is not a clear-cut case, and it's more important to
# fix the immediate problem mozconfig causes to js developers by
# "temporarily" returning to the previous behavior of not loading the
# mozconfig for the js configure.
# Separately to the immediate problem for js developers, there is also the
# need to not load a mozconfig when running js configure as a subconfigure.
# Unfortunately, there is no direct way to tell whether the running
# configure is the js configure. The indirect way is to look at the
# OLD_CONFIGURE path, which points to js/src/old-configure.
# I expect we'll have figured things out for mozconfigs well before
# old-configure dies.
if (
old_configure
and os.path.dirname(os.path.abspath(old_configure[0])).endswith("/js/src")
or (mozconfig and mozconfig[0] == os.devnull)
):
return {"path": None}
topsrcdir = build_env.topsrcdir
loader = MozconfigLoader(topsrcdir)
mozconfig = mozconfig[0] if mozconfig else None
mozconfig = find_mozconfig(topsrcdir, env={"MOZCONFIG": mozconfig})
mozconfig = loader.read_mozconfig(mozconfig)
return mozconfig
set_config("MOZCONFIG", depends(mozconfig)(lambda m: m["path"]))
# Mozilla-Build
# ==============================================================
option(env="MOZILLABUILD", nargs=1, help="Path to Mozilla Build (Windows-only)")
option(env="CONFIG_SHELL", nargs=1, help="Path to a POSIX shell")
# It feels dirty replicating this from python/mozbuild/mozbuild/mozconfig.py,
# but the end goal being that the configure script would go away...
@depends("CONFIG_SHELL", "MOZILLABUILD")
@checking("for a shell")
@imports("sys")
@imports(_from="pathlib", _import="Path")
def shell(value, mozillabuild):
if value:
return find_program(value[0])
shell = "sh"
if mozillabuild:
if (Path(mozillabuild[0]) / "msys2").exists():
shell = mozillabuild[0] + "/msys2/usr/bin/sh"
else:
shell = mozillabuild[0] + "/msys/bin/sh"
if sys.platform == "win32":
shell = shell + ".exe"
return find_program(shell)
# This defines a reasonable shell for when running with --help.
# If one was passed in the environment, though, fall back to that.
@depends("--help", "CONFIG_SHELL")
def help_shell(help, shell):
if help and not shell:
return "sh"
shell = help_shell | shell
# Python 3
# ========
@dependable
@checking("for Python 3", callback=lambda x: "%s (%s)" % (x.path, x.str_version))
@imports("sys")
@imports(_from="mach.site", _import="PythonVirtualenv")
@imports(_from="os.path", _import="realpath")
def virtualenv_python3():
return namespace(
# sys.executable is currently not updated for in-process activations. However,
# sys.prefix is, so we can calculate the python executable's path from there.
path=normalize_path(PythonVirtualenv(realpath(sys.prefix)).python_path),
str_version=".".join(str(i) for i in sys.version_info[0:3]),
)
set_config("PYTHON3", virtualenv_python3.path)
# Inject mozconfig options
# ==============================================================
# All options defined above this point can't be injected in mozconfig_options
# below, so collect them.
@template
def early_options():
@depends("--help")
@imports("__sandbox__")
def early_options(_):
return set(option.env for option in __sandbox__._options.values() if option.env)
return early_options
early_options = early_options()
@depends(mozconfig, early_options, "MOZ_AUTOMATION", "--help")
# This gives access to the sandbox. Don't copy this blindly.
@imports("__sandbox__")
@imports("os")
def mozconfig_options(mozconfig, early_options, automation, help):
if mozconfig["path"]:
if "MOZ_AUTOMATION_MOZCONFIG" in mozconfig["env"]["added"]:
if not automation:
log.error(
"%s directly or indirectly includes an in-tree " "mozconfig.",
mozconfig["path"],
)
log.error(
"In-tree mozconfigs make strong assumptions about "
"and are only meant to be used by Mozilla "
"automation."
)
die("Please don't use them.")
helper = __sandbox__._helper
log.info("Adding configure options from %s" % mozconfig["path"])
for arg in mozconfig["configure_args"]:
log.info(" %s" % arg)
# We could be using imply_option() here, but it has other
# contraints that don't really apply to the command-line
# emulation that mozconfig provides.
helper.add(arg, origin="mozconfig", args=helper._args)
def add(key, value):
if key.isupper():
arg = "%s=%s" % (key, value)
log.info(" %s" % arg)
if key not in early_options:
helper.add(arg, origin="mozconfig", args=helper._args)
for key, value in mozconfig["env"]["added"].items():
add(key, value)
os.environ[key] = value
for key, (_, value) in mozconfig["env"]["modified"].items():
add(key, value)
os.environ[key] = value
for key, value in mozconfig["vars"]["added"].items():
add(key, value)
for key, (_, value) in mozconfig["vars"]["modified"].items():
add(key, value)
@depends(build_environment, "--help")
@imports(_from="os.path", _import="exists")
def js_package(build_env, help):
return not exists(os.path.join(build_env.topsrcdir, "browser"))
# Source checkout and version control integration.
# ================================================
@depends(build_environment, "MOZ_AUTOMATION", js_package, "--help")
@checking("for vcs source checkout")
@imports("os")
def vcs_checkout_type(build_env, automation, js_package, help):
if os.path.exists(os.path.join(build_env.topsrcdir, ".hg")):
return "hg"
elif os.path.exists(os.path.join(build_env.topsrcdir, ".git")):
return "git"
elif automation and not js_package and not help:
raise FatalCheckError(
"unable to resolve VCS type; must run "
"from a source checkout when MOZ_AUTOMATION "
"is set"
)
# Resolve VCS binary for detected repository type.
hg = check_prog(
"HG",
(
"hg.exe",
"hg",
),
allow_missing=True,
when=depends(vcs_checkout_type)(lambda x: x == "hg"),
)
git = check_prog(
"GIT",
("git",),
allow_missing=True,
when=depends(vcs_checkout_type)(lambda x: x == "git"),
)
@depends_if(hg)
@checking("for Mercurial version")
@imports("os")
@imports("re")
def hg_version(hg):
# HGPLAIN in Mercurial 1.5+ forces stable output, regardless of set
# locale or encoding.
env = dict(os.environ)
env["HGPLAIN"] = "1"
out = check_cmd_output(hg, "--version", env=env)
match = re.search(r"Mercurial Distributed SCM \(version ([^\)]+)", out)
if not match:
raise FatalCheckError("unable to determine Mercurial version: %s" % out)
# The version string may be "unknown" for Mercurial run out of its own
# source checkout or for bad builds. But LooseVersion handles it.
return Version(match.group(1))
# Resolve Mercurial config items so other checks have easy access.
# Do NOT set this in the config because it may contain sensitive data
# like API keys.
@depends_all(build_environment, hg, hg_version)
@imports("os")
def hg_config(build_env, hg, version):
env = dict(os.environ)
env["HGPLAIN"] = "1"
# Warnings may get sent to stderr. But check_cmd_output() ignores
# stderr if exit code is 0. And the command should always succeed if
# `hg version` worked.
out = check_cmd_output(hg, "config", env=env, cwd=build_env.topsrcdir)
config = {}
for line in out.strip().splitlines():
key, value = [s.strip() for s in line.split("=", 1)]
config[key] = value
return config
@depends_if(git)
@checking("for Git version")
@imports("re")
def git_version(git):
out = check_cmd_output(git, "--version").rstrip()
match = re.search("git version (.*)$", out)
if not match:
raise FatalCheckError("unable to determine Git version: %s" % out)
return Version(match.group(1))
# Only set VCS_CHECKOUT_TYPE if we resolved the VCS binary.
# Require resolved VCS info when running in automation so automation's
# environment is more well-defined.
@depends(vcs_checkout_type, hg_version, git_version, "MOZ_AUTOMATION")
def exposed_vcs_checkout_type(vcs_checkout_type, hg, git, automation):
if vcs_checkout_type == "hg":
if hg:
return "hg"
if automation:
raise FatalCheckError("could not resolve Mercurial binary info")
elif vcs_checkout_type == "git":
if git:
return "git"
if automation:
raise FatalCheckError("could not resolve Git binary info")
elif vcs_checkout_type:
raise FatalCheckError("unhandled VCS type: %s" % vcs_checkout_type)
set_config("VCS_CHECKOUT_TYPE", exposed_vcs_checkout_type)
# The application/project to build
# ==============================================================
option(
"--enable-application",
nargs=1,
env="MOZ_BUILD_APP",
help="Application to build. Same as --enable-project",
)
@depends("--enable-application")
def application(app):
if app:
return app
imply_option("--enable-project", application)
@depends(build_environment, js_package)
def default_project(build_env, js_package):
if js_package or build_env.topobjdir.endswith("/js/src"):
return "js"
return "browser"
option("--enable-project", nargs=1, default=default_project, help="Project to build")
# Artifact builds
# ==============================================================
option(
"--enable-artifact-builds",
env="MOZ_ARTIFACT_BUILDS",
help="Download and use prebuilt binary artifacts",
)
@depends("--enable-artifact-builds")
def artifact_builds(value):
if value:
return True
set_config("MOZ_ARTIFACT_BUILDS", artifact_builds)
# Host and target systems
# ==============================================================
option("--host", nargs=1, help="Define the system type performing the build")
option(
"--target",
nargs=1,
help="Define the system type where the resulting executables will be " "used",
)
@imports(_from="mozbuild.configure.constants", _import="Abi")
@imports(_from="mozbuild.configure.constants", _import="CPU")
@imports(_from="mozbuild.configure.constants", _import="CPU_bitness")
@imports(_from="mozbuild.configure.constants", _import="Endianness")
@imports(_from="mozbuild.configure.constants", _import="Kernel")
@imports(_from="mozbuild.configure.constants", _import="OS")
@imports(_from="__builtin__", _import="ValueError")
def split_triplet(triplet, allow_wasi=False):
# The standard triplet is defined as
# CPU_TYPE-VENDOR-OPERATING_SYSTEM
# There is also a quartet form:
# CPU_TYPE-VENDOR-KERNEL-OPERATING_SYSTEM
# But we can consider the "KERNEL-OPERATING_SYSTEM" as one.
# Additionally, some may omit "unknown" when the vendor
# is not specified and emit
# CPU_TYPE-OPERATING_SYSTEM
vendor = "unknown"
parts = triplet.split("-", 2)
if len(parts) == 3:
cpu, vendor, os = parts
elif len(parts) == 2:
cpu, os = parts
else:
raise ValueError("Unexpected triplet string: %s" % triplet)
# Autoconf uses config.sub to validate and canonicalize those triplets,
# but the granularity of its results has never been satisfying to our
# use, so we've had our own, different, canonicalization. We've also
# historically not been very consistent with how we use the canonicalized
# values. Hopefully, this will help us make things better.
# The tests are inherited from our decades-old autoconf-based configure,
# which can probably be improved/cleaned up because they are based on a
# mix of uname and config.guess output, while we now only use the latter,
# which presumably has a cleaner and leaner output. Let's refine later.
raw_os = os = os.replace("/", "_")
abi = None
sub_configure_alias = triplet
if "android" in os:
canonical_os = "Android"
canonical_kernel = "Linux"
elif os.startswith("linux"):
canonical_os = "GNU"
canonical_kernel = "Linux"
elif os.startswith("kfreebsd") and os.endswith("-gnu"):
canonical_os = "GNU"
canonical_kernel = "kFreeBSD"
elif os.startswith("gnu"):
canonical_os = canonical_kernel = "GNU"
elif os.startswith("mingw") or os in ("windows-msvc", "windows-gnu"):
canonical_os = canonical_kernel = "WINNT"
if not os.startswith("mingw"):
if os == "windows-msvc":
abi = "msvc"
elif os == "windows-gnu":
abi = "mingw"
# Many things down the line are looking for the string "mingw32"
# until they are all fixed, we pretend that's the raw os we had
# in the first place, even when we didn't.
sub_configure_alias = sub_configure_alias[: -len(os)] + "mingw32"
raw_os = "mingw32"
elif os.startswith("darwin"):
canonical_kernel = "Darwin"
canonical_os = "OSX"
elif os.startswith("ios"):
canonical_kernel = "Darwin"
canonical_os = "iOS"
# old-configure does plenty of tests against $target and $target_os
# and expects darwin for iOS, so make it happy.
sub_configure_alias = sub_configure_alias[: -len(os)] + "darwin"
# rust knows ios-sim, clang knows ios-simulator. We only take the
# former as --target, but we need to make clang happy.
if os == "ios-sim":
os = "ios-simulator"
elif os.startswith("dragonfly"):
canonical_os = canonical_kernel = "DragonFly"
elif os.startswith("freebsd"):
canonical_os = canonical_kernel = "FreeBSD"
elif os.startswith("netbsd"):
canonical_os = canonical_kernel = "NetBSD"
elif os.startswith("openbsd"):
canonical_os = canonical_kernel = "OpenBSD"
elif os.startswith("solaris"):
canonical_os = canonical_kernel = "SunOS"
elif os.startswith("wasi") and allow_wasi:
canonical_os = canonical_kernel = "WASI"
else:
raise ValueError("Unknown OS: %s" % os)
# The CPU granularity is probably not enough. Moving more things from
# old-configure will tell us if we need more
if cpu.endswith("86") or (cpu.startswith("i") and "86" in cpu):
canonical_cpu = "x86"
endianness = "little"
elif cpu in ("x86_64", "ia64"):
canonical_cpu = cpu
endianness = "little"
elif cpu in ("s390", "s390x"):
canonical_cpu = cpu
endianness = "big"
elif cpu in ("powerpc64", "ppc64", "powerpc64le", "ppc64le"):
canonical_cpu = "ppc64"
endianness = "little" if "le" in cpu else "big"
elif cpu in ("powerpc", "ppc", "rs6000") or cpu.startswith("powerpc"):
canonical_cpu = "ppc"
endianness = "big"
elif cpu in ("Alpha", "alpha", "ALPHA"):
canonical_cpu = "Alpha"
endianness = "little"
elif cpu.startswith("hppa") or cpu == "parisc":
canonical_cpu = "hppa"
endianness = "big"
elif cpu.startswith("sparc64") or cpu.startswith("sparcv9"):
canonical_cpu = "sparc64"
endianness = "big"
elif cpu.startswith("sparc") or cpu == "sun4u":
canonical_cpu = "sparc"
endianness = "big"
elif cpu.startswith("arm"):
canonical_cpu = "arm"
endianness = "big" if cpu.startswith(("armeb", "armbe")) else "little"
elif cpu in ("m68k"):
canonical_cpu = "m68k"
endianness = "big"
elif cpu in ("mips", "mipsel"):
canonical_cpu = "mips32"
endianness = "little" if "el" in cpu else "big"
elif cpu in ("mips64", "mips64el"):
canonical_cpu = "mips64"
endianness = "little" if "el" in cpu else "big"
elif cpu.startswith("aarch64"):
canonical_cpu = "aarch64"
endianness = "little"
elif cpu in ("riscv64", "riscv64gc"):
canonical_cpu = "riscv64"
endianness = "little"
elif cpu.startswith("loongarch64"):
canonical_cpu = "loongarch64"
endianness = "little"
elif cpu == "sh4":
canonical_cpu = "sh4"
endianness = "little"
elif cpu == "wasm32" and allow_wasi:
canonical_cpu = "wasm32"
endianness = "little"
else:
raise ValueError("Unknown CPU type: %s" % cpu)
# Toolchains, most notably for cross compilation may use cpu-os
# prefixes. We need to be more specific about the LLVM target on Mac
# so cross-language LTO will work correctly.
if os.startswith(("darwin", "ios")):
toolchain = "%s-apple-%s" % (cpu, os)
else:
toolchain = "%s-%s" % (cpu, os)
return namespace(
alias=triplet,
cpu=CPU(canonical_cpu),
bitness=CPU_bitness[canonical_cpu],
kernel=Kernel(canonical_kernel),
os=OS(canonical_os),
endianness=Endianness(endianness),
# For now, only report the Windows ABI.
abi=abi and Abi(abi),
raw_cpu=cpu,
raw_os=raw_os,
toolchain=toolchain,
vendor=vendor,
sub_configure_alias=sub_configure_alias,
)
# This defines a fake target/host namespace for when running with --help
# If either --host or --target is passed on the command line, then fall
# back to the real deal.
@depends("--help", "--host", "--target")
def help_host_target(help, host, target):
if help and not host and not target:
return namespace(
alias="unknown-unknown-unknown",
cpu="unknown",
bitness="unknown",
kernel="unknown",
os="unknown",
endianness="unknown",
abi="unknown",
raw_cpu="unknown",
raw_os="unknown",
toolchain="unknown-unknown",
)
def config_sub(shell, triplet):
config_sub = os.path.join(os.path.dirname(__file__), "..", "autoconf", "config.sub")
# Config.sub doesn't like the *-windows-msvc/*-windows-gnu/*-ios-sim triplets, so
# munge those before and after calling config.sub.
suffix = None
munging = {
"-windows-msvc": "-mingw32",
"-windows-gnu": "-mingw32",
"-ios-sim": "-ios",
}
for check_suffix, replacement in munging.items():
if triplet.endswith(check_suffix):
suffix = check_suffix
triplet = triplet[: -len(suffix)] + replacement
break
result = check_cmd_output(shell, config_sub, triplet).strip()
if suffix:
assert result.endswith(replacement)
result = result[: -len(replacement)] + suffix
return result
@depends("--host", shell)
@checking("for host system type", lambda h: h.alias)
@imports("os")
@imports("sys")
@imports(_from="__builtin__", _import="ValueError")
def real_host(value, shell):
if not value and sys.platform == "win32":
arch = os.environ.get("PROCESSOR_ARCHITEW6432") or os.environ.get(
"PROCESSOR_ARCHITECTURE"
)
if arch == "AMD64":
return split_triplet("x86_64-pc-windows-msvc")
elif arch == "x86":
return split_triplet("i686-pc-windows-msvc")
elif arch == "ARM64":
return split_triplet("aarch64-pc-windows-msvc")
if not value:
config_guess = os.path.join(
os.path.dirname(__file__), "..", "autoconf", "config.guess"
)
# Ensure that config.guess is determining the host triplet, not the target
# triplet
env = os.environ.copy()
env.pop("CC_FOR_BUILD", None)
env.pop("HOST_CC", None)
env.pop("CC", None)
host = check_cmd_output(shell, config_guess, env=env).strip()
try:
return split_triplet(host)
except ValueError:
pass
else:
host = value[0]
host = config_sub(shell, host)
try:
return split_triplet(host)
except ValueError as e:
die(e)
host = help_host_target | real_host
@depends("--target", real_host, shell, "--enable-project", "--enable-application")
@checking("for target system type", lambda t: t.alias)
@imports(_from="__builtin__", _import="ValueError")
def real_target(value, host, shell, project, application):
# Because --enable-project is implied by --enable-application, and
# implied options are not currently handled during --help, which is
# used get the build target in mozbuild.base, we manually check
# whether --enable-application was given, and fall back to
# --enable-project if not. Both can't be given contradictory values
# under normal circumstances, so it's fine.
if application:
project = application[0]
elif project:
project = project[0]
if not value:
if project == "mobile/android":
target_cpu, target_system = {
"aarch64": ("aarch64", "android"),
"x86_64": ("x86_64", "android"),
}.get(host.cpu, ("arm", "androideabi"))
return split_triplet(f"{target_cpu}-unknown-linux-{target_system}")
if project == "mobile/ios":
if (host.cpu, host.os) == ("x86_64", "OSX"):
return split_triplet(f"x86_64-apple-ios")
return split_triplet(f"aarch64-apple-ios-sim")
return host
# If --target was only given a cpu arch, expand it with the
# non-cpu part of the host. For mobile/android, expand it with
# unknown-linux-android.
target = value[0]
if "-" not in target:
if project == "mobile/android":
rest = "unknown-linux-android"
if target.startswith("arm"):
rest += "eabi"
elif project == "mobile/ios":
sim_suffix = "" if target == "x86_64" else "-sim"
rest = f"apple-ios{sim_suffix}"
else:
cpu, rest = host.alias.split("-", 1)
target = "-".join((target, rest))
try:
return split_triplet(target)
except ValueError:
pass
try:
return split_triplet(config_sub(shell, target), allow_wasi=(project == "js"))
except ValueError as e:
die(e)
target = help_host_target | real_target
@depends(host, target)
@checking("whether cross compiling")
def cross_compiling(host, target):
return host != target
set_config("CROSS_COMPILE", cross_compiling)
set_define("CROSS_COMPILE", cross_compiling)
@depends(target)
def have_64_bit(target):
if target.bitness == 64:
return True
set_config("HAVE_64BIT_BUILD", have_64_bit)
set_define("HAVE_64BIT_BUILD", have_64_bit)
# Some third-party code bases depend on this being set for big-endians.
set_define(
"WORDS_BIGENDIAN", True, when=depends(target.endianness)(lambda e: e == "big")
)
set_config("host", host.sub_configure_alias)
set_config("target", target.sub_configure_alias)
# These variables are for compatibility with the current moz.builds and
# old-configure. Eventually, we'll want to canonicalize better.
@depends(target)
def target_variables(target):
if target.kernel == "kFreeBSD":
os_target = "GNU/kFreeBSD"
os_arch = "GNU_kFreeBSD"
elif target.kernel == "Darwin" or (target.kernel == "Linux" and target.os == "GNU"):
os_target = target.kernel
os_arch = target.kernel
else:
os_target = target.os
os_arch = target.kernel
return namespace(
OS_TARGET=str(os_target),
OS_ARCH=str(os_arch),
INTEL_ARCHITECTURE=target.cpu in ("x86", "x86_64") or None,
)
set_config("OS_TARGET", target_variables.OS_TARGET)
set_config("OS_ARCH", target_variables.OS_ARCH)
obsolete_config("CPU_ARCH", replacement="TARGET_CPU")
set_config("INTEL_ARCHITECTURE", target_variables.INTEL_ARCHITECTURE)
set_config("TARGET_CPU", target.cpu)
set_config("TARGET_RAW_CPU", target.raw_cpu)
set_config("TARGET_OS", target.os)
set_config("TARGET_RAW_OS", target.raw_os)
set_config("TARGET_KERNEL", target.kernel)
set_config("TARGET_ENDIANNESS", target.endianness)
@depends(host)
def host_variables(host):
if host.kernel == "kFreeBSD":
os_arch = "GNU_kFreeBSD"
else:
os_arch = host.kernel
return namespace(
HOST_OS_ARCH=os_arch,
)
set_config("HOST_CPU_ARCH", host.cpu)
set_config("HOST_OS_ARCH", host_variables.HOST_OS_ARCH)
set_config("HOST_ALIAS", host.alias)
@depends(target)
def target_is_windows(target):
if target.kernel == "WINNT":
return True
@depends(host)
def host_is_windows(host):
if host.kernel == "WINNT":
return True
set_define("_WINDOWS", target_is_windows)
set_define("WIN32", target_is_windows)
set_define("XP_WIN", target_is_windows)
@depends(target)
def target_is_unix(target):
if target.kernel != "WINNT":
return True
set_define("XP_UNIX", target_is_unix)
@depends(target)
def target_is_darwin(target):
if target.kernel == "Darwin":
return True
set_define("XP_DARWIN", target_is_darwin)
@depends(target)
def target_is_osx(target):
if target.kernel == "Darwin" and target.os == "OSX":
return True
@depends(host)
def host_is_osx(host):
if host.os == "OSX":
return True
set_define("XP_MACOSX", target_is_osx)
@depends(target)
def target_is_ios(target):
if target.kernel == "Darwin" and target.os == "iOS":
return True
set_define("XP_IOS", target_is_ios)
@depends(target)
def target_has_linux_kernel(target):
if target.kernel == "Linux":
return True
set_define("XP_LINUX", target_has_linux_kernel)
@depends(target)
def target_is_linux_or_wasi(target):
if (target.kernel == "Linux" and target.os == "GNU") or target.kernel == "WASI":
return True
@depends(target)
def target_is_android(target):
if target.os == "Android":
return True
set_define("ANDROID", target_is_android)
@depends(target)
def target_is_openbsd(target):
if target.kernel == "OpenBSD":
return True
set_define("XP_OPENBSD", target_is_openbsd)
@depends(target)
def target_is_netbsd(target):
if target.kernel == "NetBSD":
return True
set_define("XP_NETBSD", target_is_netbsd)
@depends(target)
def target_is_freebsd(target):
if target.kernel == "FreeBSD":
return True
set_define("XP_FREEBSD", target_is_freebsd)
@depends(target)
def target_is_solaris(target):
if target.kernel == "SunOS":
return True
set_define("XP_SOLARIS", target_is_solaris)
@depends(target)
def target_is_sparc(target):
if target.cpu == "sparc64":
return True
set_define("SPARC64", target_is_sparc)
@depends(target, when=target_is_android)
def android_cpu_arch(target):
d = {
"aarch64": "arm64-v8a",
"arm": "armeabi-v7a",
"x86": "x86",
"x86_64": "x86_64",
}
if target.cpu not in d:
die(f"Cannot determine android_cpu_arch: unknown target.cpu: {target.cpu}")
return d[target.cpu]
set_config("ANDROID_CPU_ARCH", android_cpu_arch)
@depends("--enable-project", build_environment, "--help")
@imports(_from="os.path", _import="exists")
def include_project_configure(project, build_env, help):
if not project:
die("--enable-project is required.")
base_dir = build_env.topsrcdir
path = os.path.join(base_dir, project[0], "moz.configure")
if not exists(path):
die("Cannot find project %s", project[0])
return path
@depends("--enable-project")
def build_project(project):
return project[0]
set_config("MOZ_BUILD_APP", build_project)
set_define("MOZ_BUILD_APP", build_project)
add_old_configure_assignment("MOZ_BUILD_APP", build_project)
option(env="MOZILLA_OFFICIAL", help="Build an official release")
@depends("MOZILLA_OFFICIAL")
def mozilla_official(official):
if official:
return True
set_config("MOZILLA_OFFICIAL", mozilla_official)
set_define("MOZILLA_OFFICIAL", mozilla_official)
# Allow specifying custom paths to the version files used by the milestone() function below.
option(
"--with-version-file-path",
nargs=1,
help="Specify a custom path to app version files instead of auto-detecting",
default=None,
)
@depends("--with-version-file-path")
def version_path(path):
return path
# Allow to easily build nightly with a release / beta configuration so that we
# can have the same options we'd have on a release version.
# This is useful for performance profiling, as there are things that we don't
# enable in release (like the background hang monitor) that can affect
# performance.
option(
"--as-milestone",
help="Build with another milestone configuration (e.g., as release)",
choices=("early-beta", "late-beta", "release"),
default=None,
)
# set RELEASE_OR_BETA and NIGHTLY_BUILD variables depending on the cycle we're in
# The logic works like this:
# - if we have "a1" in GRE_MILESTONE, we're building Nightly (define NIGHTLY_BUILD)
# - otherwise, we're building Release/Beta (define RELEASE_OR_BETA)
@depends(
build_environment,
build_project,
version_path,
"--as-milestone",
"--help",
)
@imports(_from="__builtin__", _import="open")
@imports("os")
@imports("re")
def milestone(build_env, build_project, version_path, as_milestone, _):
versions = []
paths = ["config/milestone.txt"]
if build_project == "js":
paths = paths * 3
else:
paths += [
"browser/config/version.txt",
"browser/config/version_display.txt",
]
if version_path:
version_path = version_path[0]
else:
version_path = os.path.join(build_project, "config")
for f in ("version.txt", "version_display.txt"):
f = os.path.join(version_path, f)
if not os.path.exists(os.path.join(build_env.topsrcdir, f)):
break
paths.append(f)
for p in paths:
with open(os.path.join(build_env.topsrcdir, p), "r") as fh:
content = fh.read().splitlines()
if not content:
die("Could not find a version number in {}".format(p))
versions.append(content[-1])
is_early_beta_or_earlier = None
if as_milestone:
if "a1" not in versions[0]:
# We could make this work with some effort
die("--as-milestone only works on nightly builds")
as_milestone = as_milestone[0]
as_milestone_flag = "" if as_milestone == "release" else "b1"
versions = [v.replace("a1", as_milestone_flag) for v in versions]
if as_milestone == "early-beta":
is_early_beta_or_earlier = True
milestone, firefox_version, firefox_version_display = versions[:3]
# version.txt content from the project directory if there is one, otherwise
# the firefox version.
app_version = versions[3] if len(versions) > 3 else firefox_version
# version_display.txt content from the project directory if there is one,
# otherwise version.txt content from the project directory, otherwise the
# firefox version for display.
app_version_display = versions[-1] if len(versions) > 3 else firefox_version_display
is_nightly = is_release_or_beta = None
if "a1" in milestone:
is_nightly = True
elif "a" not in milestone:
is_release_or_beta = True
major_version = milestone.split(".")[0]
m = re.search(r"([ab]\d+)", milestone)
ab_patch = m.group(1) if m else ""
if not as_milestone:
defines = os.path.join(build_env.topsrcdir, "build", "defines.sh")
with open(defines, "r") as fh:
for line in fh.read().splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
name, _, value = line.partition("=")
name = name.strip()
value = value.strip()
if name != "EARLY_BETA_OR_EARLIER":
die(
"Only the EARLY_BETA_OR_EARLIER variable can be set in build/defines.sh"
)
if value and any(x in app_version_display for x in "ab"):
is_early_beta_or_earlier = True
# Only expose the major version milestone in the UA string and hide the
# patch leve (bugs 572659 and 870868).
#
# Only expose major milestone and alpha version in the symbolversion
# string; as the name suggests, we use it for symbol versioning on Linux.
return namespace(
version=milestone,
uaversion="%s.0" % major_version,
symbolversion="%s%s" % (major_version, ab_patch),
is_nightly=is_nightly,
is_release_or_beta=is_release_or_beta,
is_early_beta_or_earlier=is_early_beta_or_earlier,
is_esr=app_version_display.endswith("esr") or None,
app_version=app_version,
app_version_display=app_version_display,
)
# For extensions and langpacks, we require a max version that is compatible
# across security releases. MOZ_APP_MAXVERSION is our method for doing that.
# 24.0a1 and 24.0a2 aren't affected
# 24.0 becomes 24.*
# 24.1.1 becomes 24.*
@depends(milestone.app_version, build_project)
def moz_app_maxversion(app_version, build_project):
if "a" not in app_version:
version = Version(app_version)
if build_project == "suite":
return f"{version.major}.{version.minor}.*"
else:
return f"{version.major}.*"
else:
return app_version
set_config("GRE_MILESTONE", milestone.version)
set_config("NIGHTLY_BUILD", milestone.is_nightly)
set_define("NIGHTLY_BUILD", milestone.is_nightly)
set_config("RELEASE_OR_BETA", milestone.is_release_or_beta)
set_define("RELEASE_OR_BETA", milestone.is_release_or_beta)
set_config("MOZ_ESR", milestone.is_esr)
set_define("MOZ_ESR", milestone.is_esr)
set_config("EARLY_BETA_OR_EARLIER", milestone.is_early_beta_or_earlier)
set_define("EARLY_BETA_OR_EARLIER", milestone.is_early_beta_or_earlier)
set_define("MOZILLA_VERSION", depends(milestone)(lambda m: '"%s"' % m.version))
set_config("MOZILLA_VERSION", milestone.version)
set_define("MOZILLA_UAVERSION", depends(milestone)(lambda m: '"%s"' % m.uaversion))
set_config("MOZ_APP_VERSION", milestone.app_version)
set_config("MOZ_APP_VERSION_DISPLAY", milestone.app_version_display)
set_config("MOZ_APP_MAXVERSION", moz_app_maxversion)
add_old_configure_assignment("MOZ_APP_VERSION", milestone.app_version)
# The app update channel is 'default' when not supplied. The value is used in
# the application's confvars.sh (and is made available to a project specific
# moz.configure).
option(
"--enable-update-channel",
nargs=1,
help="Select application update channel",
default="default",
)
@depends("--enable-update-channel")
def update_channel(channel):
if not channel or channel[0] == "":
return "default"
return channel[0].lower()
set_config("MOZ_UPDATE_CHANNEL", update_channel)
set_define("MOZ_UPDATE_CHANNEL", update_channel)
option(
env="MOZBUILD_STATE_PATH",
nargs=1,
help="Path to a persistent state directory for the build system "
"and related tools",
)
@depends("MOZBUILD_STATE_PATH", "--help")
@imports("os")
def mozbuild_state_path(path, _):
if path:
return normalize_path(path[0])
return normalize_path(os.path.expanduser(os.path.join("~", ".mozbuild")))
@depends("MOZILLABUILD", shell, host_is_windows)
@imports(_from="pathlib", _import="Path")
def mozillabuild_bin_paths(mozillabuild, shell, host_is_windows):
paths = []
if not mozillabuild or not host_is_windows:
return paths
paths.append(os.path.dirname(shell))
paths.append(str(Path(mozillabuild[0]) / "bin"))
return paths
@depends(mozillabuild_bin_paths)
@imports("os")
def prefer_mozillabuild_path(mozillabuild_bin_paths):
return mozillabuild_bin_paths + os.environ["PATH"].split(os.pathsep)
# milestone.is_nightly corresponds to cases NIGHTLY_BUILD is set.
@depends(milestone)
def enabled_in_nightly(milestone):
return milestone.is_nightly
# Check if we need the 32-bit Linux SSE2 error dialog
# ===================================================
option(
env="MOZ_LINUX_32_SSE2_STARTUP_ERROR",
help="Add code to perform startup checks to warn if SSE2 is not available",
default=depends("MOZ_AUTOMATION")(lambda x: bool(x)),
when=target_is_unix & depends(target)(lambda target: target.cpu == "x86"),
)
set_config(
"MOZ_LINUX_32_SSE2_STARTUP_ERROR", True, when="MOZ_LINUX_32_SSE2_STARTUP_ERROR"
)
# Branding
# ==============================================================
option(
"--with-app-basename",
env="MOZ_APP_BASENAME",
nargs=1,
help="Typically stays consistent for multiple branded versions of a "
'given application (e.g. Aurora and Firefox both use "Firefox"), but '
"may vary for full rebrandings (e.g. Iceweasel). Used for "
'application.ini\'s "Name" field, which controls profile location in '
'the absence of a "Profile" field (see below), and various system '
"integration hooks (Unix remoting, Windows MessageWindow name, etc",
)
@depends("--with-app-basename", target_is_android)
def moz_app_basename(value, target_is_android):
if value:
return value[0]
if target_is_android:
return "Fennec"
return "Firefox"
set_config(
"MOZ_APP_BASENAME",
moz_app_basename,
when=depends(build_project)(lambda p: p != "js"),
)
@depends("MOZILLABUILD", when=host_is_windows)
@checking("for MozillaBuild directory")
@imports("os")
def mozillabuild_dir(mozillabuild):
if mozillabuild and os.path.exists(mozillabuild[0]):
return mozillabuild[0]
@depends_if(mozillabuild_dir)
@checking("for MozillaBuild version")
@imports(_from="__builtin__", _import="Exception")
@imports(_from="__builtin__", _import="open")
def mozillabuild_version(mozillabuild_dir):
try:
with open(os.path.join(mozillabuild_dir, "VERSION"), "r") as fh:
return Version(fh.readline().strip())
except Exception as e:
die(e)
@depends_if(mozillabuild_version)
def valid_mozillabuild_version(mozillabuild_version):
if mozillabuild_version < Version("4.0"):
die(
f"Please upgrade MozillaBuild. You can find a recent version at: https://wiki.mozilla.org/MozillaBuild"
)
# old-school options for controlling install step
# ==============================================================
option(
"--prefix",
nargs=1,
metavar="PREFIX",
default="/usr/local",
help="Install files using PREFIX as root directory",
)
set_config("prefix", depends("--prefix")(lambda prefix: prefix[0]))
# Unlike autoconf, we don't offer these as a customisation point.
set_config("exec_prefix", depends("--prefix")(lambda prefix: prefix[0]))
set_config("datadir", depends("--prefix")(lambda prefix: f"{prefix[0]}/share"))
option(
"--includedir",
nargs=1,
metavar="DIR",
default=depends("--prefix")(lambda prefix: f"{prefix[0]}/include"),
help="C header files in DIR",
)
set_config("includedir", depends("--includedir")(lambda idir: idir[0]))
option(
"--libdir",
nargs=1,
metavar="DIR",
default=depends("--prefix")(lambda prefix: f"{prefix[0]}/lib"),
help="Object code libraries in DIR",
)
set_config("libdir", depends("--libdir")(lambda ldir: ldir[0]))