Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

26 files changed, 11104 insertions, 0 deletions

diff --git a/build/moz.configure/android-ndk.configure b/build/moz.configure/android-ndk.configure
new file mode 100644
index 0000000000..c19023a1ea
--- /dev/null
+++ b/build/moz.configure/android-ndk.configure
@@ -0,0 +1,305 @@
+# -*- 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/.
+
+
+@depends(toolchains_base_dir, "--help")
+@imports(_from="os.path", _import="isdir")
+@imports(_from="mozboot.android", _import="NDK_VERSION")
+def default_android_ndk_root(toolchains_base_dir, _):
+    for ndk in ("android-ndk-%s" % NDK_VERSION, "android-ndk"):
+        path = os.path.join(toolchains_base_dir, ndk)
+        if isdir(path):
+            return path
+
+
+option(
+    "--with-android-ndk",
+    nargs=1,
+    default=default_android_ndk_root,
+    help="location where the Android NDK can be found{|}",
+)
+
+option("--with-android-toolchain", nargs=1, help="location of the Android toolchain")
+
+option(
+    "--with-android-lldb-server", nargs=1, help="location of the Android LLDB server"
+)
+
+option(
+    "--with-android-googlevr-sdk", nargs=1, help="location of the Android GoogleVR SDK"
+)
+
+
+@dependable
+def min_android_version():
+    # Sync with android_sdk_version
+    return "21"
+
+
+option(
+    "--with-android-version",
+    nargs=1,
+    help="android platform version{|}",
+    default=min_android_version,
+)
+
+
+@depends("--with-android-version", min_android_version)
+@imports(_from="__builtin__", _import="ValueError")
+def android_version(value, min_version):
+    if not value:
+        # Someone has passed --without-android-version.
+        die("--with-android-version cannot be disabled.")
+
+    try:
+        version = int(value[0])
+    except ValueError:
+        die("--with-android-version expects an integer value")
+
+    if version < int(min_version):
+        die(
+            "--with-android-version must be at least %s (got %s)", min_version, value[0]
+        )
+
+    return version
+
+
+@depends("--with-android-ndk")
+@imports(_from="os.path", _import="isdir")
+def ndk(value):
+    if value:
+        if not isdir(value[0]):
+            die(
+                "The path you specified with --with-android-ndk (%s) is not "
+                "a directory" % value[0]
+            )
+        return value[0]
+
+    die(
+        "You must specify --with-android-ndk=/path/to/ndk when targeting Android, "
+        "or try |mach bootstrap|."
+    )
+
+
+set_config("ANDROID_NDK", ndk)
+
+
+@depends(ndk)
+@checking("for android ndk version")
+@imports(_from="__builtin__", _import="open")
+@imports(_from="mozboot.android", _import="NDK_VERSION")
+@imports(_from="mozboot.android", _import="get_ndk_version")
+@imports(_from="mozboot.android", _import="GetNdkVersionError")
+def ndk_version(ndk):
+    if not ndk:
+        # Building 'js/src' for non-Android.
+        return
+
+    try:
+        major, minor, human = get_ndk_version(ndk)
+    except GetNdkVersionError as e:
+        die(str(e))
+
+    if NDK_VERSION != human:
+        die(
+            "The only supported version of the NDK is %s (have %s)\n"
+            "Please run |mach bootstrap| "
+            "to install the correct NDK." % (NDK_VERSION, human)
+        )
+    return namespace(
+        major=major,
+        minor=minor,
+    )
+
+
+set_config("ANDROID_NDK_MAJOR_VERSION", ndk_version.major)
+set_config("ANDROID_NDK_MINOR_VERSION", ndk_version.minor)
+
+
+@imports(_from="os.path", _import="isdir")
+@imports(_from="mozbuild.shellutil", _import="quote")
+def host_dir(host, base_dir):
+    dir_format = "%s/%s-%s"
+    host_kernel = "windows" if host.kernel == "WINNT" else host.kernel.lower()
+
+    dir = dir_format % (base_dir, host_kernel, host.cpu)
+    log.debug("Trying %s" % quote(dir))
+    if not isdir(dir) and host.cpu == "x86_64":
+        dir = dir_format % (base_dir, host_kernel, "x86")
+        log.debug("Trying %s" % quote(dir))
+    if not isdir(dir) and host.kernel == "Darwin" and host.cpu == "aarch64":
+        dir = dir_format % (base_dir, host_kernel, "x86_64")
+        log.debug("Trying %s" % quote(dir))
+    if isdir(dir):
+        return dir
+
+
+@depends(host, ndk, "--with-android-toolchain")
+@checking("for the Android toolchain directory", lambda x: x or "not found")
+def android_toolchain(host, ndk, toolchain):
+    if not ndk:
+        return
+    if toolchain:
+        return toolchain[0]
+
+    toolchain = host_dir(host, os.path.join(ndk, "toolchains", "llvm", "prebuilt"))
+    if toolchain:
+        return toolchain
+    die("You have to specify --with-android-toolchain=" "/path/to/ndk/toolchain.")
+
+
+@depends(target, android_toolchain)
+@checking("for android sysroot directory")
+@imports(_from="os.path", _import="isdir")
+def android_sysroot(target, android_toolchain):
+    if target.os != "Android":
+        return
+
+    search_dirs = [
+        os.path.join(android_toolchain, "sysroot"),
+    ]
+
+    for sysroot_dir in search_dirs:
+        if isdir(sysroot_dir):
+            return sysroot_dir
+
+    die(
+        "Android sysroot directory not found in %s."
+        % str([sysroot_dir for sysroot_dir in search_dirs])
+    )
+
+
+@depends(target, host, ndk, "--with-android-lldb-server")
+@checking("for the Android LLDB server", lambda x: x or "not found")
+@imports(_from="os", _import="listdir")
+@imports(_from="os.path", _import="isdir")
+@imports(_from="os.path", _import="isfile")
+@imports(_from="mozbuild.shellutil", _import="quote")
+def android_lldb_server(target, host, ndk, lldb):
+    if not ndk:
+        return
+    if lldb:
+        return lldb[0]
+    else:
+        clang_format = "toolchains/llvm/prebuilt/%s-%s/lib64/clang"
+        llvm_lib = "lib/linux"
+
+        host_kernel = "windows" if host.kernel == "WINNT" else host.kernel.lower()
+        clang_path = os.path.join(ndk, clang_format % (host_kernel, host.cpu))
+        if not isdir(clang_path) and host.kernel == "Darwin" and host.cpu == "aarch64":
+            clang_path = os.path.join(ndk, clang_format % (host_kernel, "x86_64"))
+        log.debug("Listing subdirectories of %s" % quote(clang_path))
+        clang_subdirs = [
+            x for x in listdir(clang_path) if isdir(os.path.join(clang_path, x))
+        ]
+        log.debug("Got %r" % clang_subdirs)
+        if len(clang_subdirs) != 1:
+            die(
+                "Could not resolve lldb-server in %s. Please specify --with-android-lldb-server=/path/to/android/lldb-server"
+                % quote(clang_path)
+            )
+        log.debug("Found version %s" % quote(clang_subdirs[0]))
+
+        if target.cpu == "x86":
+            target_cpu = "i386"
+        else:
+            target_cpu = target.cpu
+
+        full_path = os.path.join(
+            clang_path, clang_subdirs[0], llvm_lib, target_cpu, "lldb-server"
+        )
+        log.debug("Trying %s" % quote(full_path))
+
+        if isfile(full_path):
+            return full_path
+        die("Please specify --with-android-lldb-server=/path/to/android/lldb-server")
+
+
+set_config("ANDROID_LLDB_SERVER", android_lldb_server)
+
+
+option(
+    env="STLPORT_LIBS",
+    nargs=1,
+    help="Options linker should pass for standard C++ library",
+)
+
+
+@depends("STLPORT_LIBS", ndk)
+@imports(_from="os.path", _import="isfile")
+def stlport_libs(value, ndk):
+    if value and len(value):
+        return value.split()
+    if not ndk:
+        return
+
+    return ["-static-libstdc++"]
+
+
+set_config("STLPORT_LIBS", stlport_libs)
+
+
+@depends(android_sysroot, android_toolchain)
+def extra_toolchain_flags(android_sysroot, toolchain_dir):
+    if not android_sysroot:
+        return []
+    flags = [
+        "--sysroot={}".format(android_sysroot),
+        "--gcc-toolchain={}".format(toolchain_dir),
+    ]
+    return flags
+
+
+add_old_configure_assignment("extra_android_flags", extra_toolchain_flags)
+
+
+@depends(extra_toolchain_flags)
+def bindgen_cflags_android(toolchain_flags):
+    return toolchain_flags
+
+
+@depends("--with-android-googlevr-sdk", target)
+@checking("for GoogleVR SDK", lambda x: x.result)
+@imports(_from="os.path", _import="exists")
+@imports(_from="os.path", _import="abspath")
+def googlevr_sdk(value, target):
+    if not value:
+        return namespace(result="Not specified")
+    path = abspath(value[0])
+    if not exists(path):
+        die("Could not find GoogleVR SDK %s", path)
+    include = "%s/libraries/headers/" % path
+    if "arm" == target.cpu:
+        arch = "armeabi-v7a"
+    elif "aarch64" == target.cpu:
+        arch = "arm64-v8a"
+    elif "x86" == target.cpu:
+        arch = "x86"
+    else:
+        die("Unsupported GoogleVR cpu architecture %s" % target.cpu)
+
+    libs = "{0}/libraries/jni/{1}/".format(path, arch)
+
+    if not exists(libs):
+        die(
+            "Could not find GoogleVR NDK at %s. Did you try running "
+            "'./gradlew :extractNdk' in %s?",
+            libs,
+            path,
+        )
+
+    return namespace(
+        result=path,
+        include=include,
+        libs=libs,
+        enabled=True,
+    )
+
+
+set_define("MOZ_ANDROID_GOOGLE_VR", googlevr_sdk.enabled)
+set_config("MOZ_ANDROID_GOOGLE_VR", googlevr_sdk.enabled)
+set_config("MOZ_ANDROID_GOOGLE_VR_INCLUDE", googlevr_sdk.include)
+set_config("MOZ_ANDROID_GOOGLE_VR_LIBS", googlevr_sdk.libs)
diff --git a/build/moz.configure/android-sdk.configure b/build/moz.configure/android-sdk.configure
new file mode 100644
index 0000000000..7607ed2135
--- /dev/null
+++ b/build/moz.configure/android-sdk.configure
@@ -0,0 +1,157 @@
+# -*- 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/.
+
+# Ensure Android SDK and build-tools versions depending on mobile target.
+
+
+@depends(host, toolchains_base_dir, "--help")
+@imports(_from="os.path", _import="isdir")
+def default_android_sdk_root(host, toolchains_base_dir, _):
+    sdk_basename = {
+        "Darwin": "android-sdk-macosx",
+        "Linux": "android-sdk-linux",
+        "WINNT": "android-sdk-windows",
+    }.get(host.kernel, "android-sdk")
+    for sdk_basename in (sdk_basename, "android-sdk"):
+        path = os.path.join(toolchains_base_dir, sdk_basename)
+        if isdir(path):
+            return path
+
+
+option(
+    "--with-android-sdk",
+    nargs=1,
+    default=default_android_sdk_root,
+    help="location where the Android SDK can be found (like ~/.mozbuild/android-sdk-linux){|}",
+)
+
+
+@depends("--with-android-sdk")
+@imports(_from="os.path", _import="isdir")
+def android_sdk_root(value):
+    if value:
+        if not isdir(value[0]):
+            die(
+                "The path you specified with --with-android-sdk (%s) is not "
+                "a directory" % value[0]
+            )
+        return value[0]
+
+    die(
+        "You must specify --with-android-sdk=/path/to/sdk when targeting Android, "
+        "or try |mach bootstrap|."
+    )
+
+
+@dependable
+def android_sdk_version():
+    # We support Android SDK version 21 and up by default.
+    # See the --enable-android-min-sdk option below.
+    #
+    # Warning: Before increasing the with-android-min-sdk value, please note several places in
+    # and out of tree have to be changed. Otherwise, places like Treeherder or archive.mozilla.org
+    # will advertise a bad API level. This may confuse people. As an example, please look at
+    # bug 1384482.
+    # If you think you can't handle the whole set of changes, please reach out to the Release
+    # Engineering team.
+    return namespace(
+        build_tools_version="34.0.0",
+        target_sdk_version="34",
+        min_sdk_version="21",
+    )
+
+
+option(
+    "--with-android-min-sdk",
+    default=android_sdk_version.min_sdk_version,
+    help="Impose a minimum Firefox for Android SDK version",
+)
+
+
+@depends("--with-android-min-sdk", android_sdk_version.target_sdk_version)
+@imports(_from="__builtin__", _import="ValueError")
+def valid_android_min_sdk(min_sdk_version, target_sdk_version):
+    if not min_sdk_version:
+        die("--without-android-min-sdk is not a valid option")
+    try:
+        if int(min_sdk_version[0]) > int(target_sdk_version):
+            die(
+                "--with-android-min-sdk is expected to be less than {}".format(
+                    target_sdk_version
+                )
+            )
+    except ValueError:
+        die("--with-android-min-sdk takes a numerical value")
+    return min_sdk_version[0]
+
+
+set_config("MOZ_ANDROID_MIN_SDK_VERSION", valid_android_min_sdk)
+
+
+@depends(android_sdk_root, android_sdk_version)
+@checking("for Android build-tools")
+@imports(_from="os.path", _import="exists")
+@imports(_from="os.path", _import="isdir")
+def android_build_tools(sdk_root, sdk_version):
+    android_build_tools_base = os.path.join(sdk_root, "build-tools")
+    version = sdk_version.build_tools_version
+    if isdir(os.path.join(android_build_tools_base, version)):
+        tools = os.path.join(android_build_tools_base, version)
+        for zipalign in ("zipalign", "zipalign.exe"):
+            if exists(os.path.join(tools, zipalign)):
+                return [tools]
+
+    die(
+        "You must install the Android build-tools version %s.  "
+        "Try |mach bootstrap|.  (Looked for %s/%s)"
+        % (version, android_build_tools_base, version)
+    )
+
+
+@depends(android_sdk_root)
+@checking("for Android platform-tools")
+@imports(_from="os.path", _import="exists")
+@imports(_from="os.path", _import="isdir")
+def android_platform_tools(sdk_root):
+    tools = os.path.join(sdk_root, "platform-tools")
+    for adb in ("adb", "adb.exe"):
+        if exists(os.path.join(tools, adb)):
+            return [tools]
+
+    die(
+        "You must install the Android platform-tools.  Try |mach bootstrap|.  (Looked for %s)"
+        % tools
+    )
+
+
+@depends(android_sdk_root)
+def android_emulator_path(sdk_root):
+    return [os.path.join(sdk_root, "emulator")]
+
+
+@template
+def check_android_tools(tool, tool_dir):
+    check = check_prog(
+        tool.upper(), (tool, tool + ".exe"), paths=tool_dir, allow_missing=True
+    )
+
+    @depends(check)
+    def require_tool(result):
+        if result is None:
+            die("The program %s was not found.  Try |mach bootstrap|" % tool)
+        return result
+
+    return require_tool
+
+
+check_android_tools("zipalign", android_build_tools)
+check_android_tools("adb", android_platform_tools)
+check_android_tools("emulator", android_emulator_path)
+
+set_config("ANDROID_SDK_ROOT", android_sdk_root)
+
+set_config("ANDROID_BUILD_TOOLS_VERSION", android_sdk_version.build_tools_version)
+set_config("ANDROID_TARGET_SDK", android_sdk_version.target_sdk_version)
diff --git a/build/moz.configure/arm.configure b/build/moz.configure/arm.configure
new file mode 100644
index 0000000000..5d26f4d732
--- /dev/null
+++ b/build/moz.configure/arm.configure
@@ -0,0 +1,305 @@
+# -*- 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/.
+
+
+@depends(target.os)
+def arm_option_defaults(os):
+    if os == "Android":
+        arch = "armv7-a"
+        thumb = "yes"
+        fpu = "neon"
+        float_abi = "softfp"
+    else:
+        arch = thumb = fpu = float_abi = "toolchain-default"
+    return namespace(
+        arch=arch,
+        thumb=thumb,
+        fpu=fpu,
+        float_abi=float_abi,
+    )
+
+
+# Note: '{...|}' in the help of all options with a non-constant default to
+# make the lint happy. The first arm is always going to be used, because a
+# default is always returned. The lint is fooled by this file being
+# conditional. If it weren't conditional, the lint wouldn't ask for '{|}' to
+# be there.
+option(
+    "--with-arch",
+    nargs=1,
+    default=arm_option_defaults.arch,
+    help="{Use specific CPU features (-march=type). Resets thumb, fpu, "
+    "float-abi, etc. defaults when set|}",
+)
+
+
+@depends("--with-arch")
+def arch_option(value):
+    if value:
+        if value[0] != "toolchain-default":
+            return ["-march={}".format(value[0])]
+    return []
+
+
+option(
+    "--with-thumb",
+    choices=("yes", "no", "toolchain-default"),
+    default=arm_option_defaults.thumb,
+    nargs="?",
+    help="{Use Thumb instruction set (-mthumb)|}",
+)
+
+
+def normalize_arm_option(value):
+    if value:
+        if len(value):
+            if value[0] == "yes":
+                return True
+            elif value[0] == "no":
+                return False
+            else:
+                return value[0]
+        return True
+    return False
+
+
+@depends("--with-thumb")
+def thumb_option(value):
+    value = normalize_arm_option(value)
+    if value is True:
+        return ["-mthumb"]
+    if value is False:
+        return ["-marm"]
+    return []
+
+
+option(
+    "--with-thumb-interwork",
+    choices=("yes", "no", "toolchain-default"),
+    default="toolchain-default",
+    nargs="?",
+    help="Use Thumb/ARM instuctions interwork (-mthumb-interwork)",
+)
+
+
+@depends("--with-thumb-interwork")
+def thumb_interwork_option(value):
+    value = normalize_arm_option(value)
+    if value is True:
+        return ["-mthumb-interwork"]
+    if value is False:
+        return ["-mno-thumb-interwork"]
+    return []
+
+
+option(
+    "--with-fpu",
+    nargs=1,
+    default=arm_option_defaults.fpu,
+    help="{Use specific FPU type (-mfpu=type)|}",
+)
+
+
+@depends("--with-fpu")
+def fpu_option(value):
+    if value:
+        if value[0] != "toolchain-default":
+            return ["-mfpu={}".format(value[0])]
+    return []
+
+
+option(
+    "--with-float-abi",
+    nargs=1,
+    default=arm_option_defaults.float_abi,
+    help="{Use specific arm float ABI (-mfloat-abi=type)|}",
+)
+
+
+@depends("--with-float-abi")
+def float_abi_option(value):
+    if value:
+        if value[0] != "toolchain-default":
+            return ["-mfloat-abi={}".format(value[0])]
+    return []
+
+
+option(
+    "--with-soft-float",
+    choices=("yes", "no", "toolchain-default"),
+    default="toolchain-default",
+    nargs="?",
+    help="Use soft float library (-msoft-float)",
+)
+
+
+@depends("--with-soft-float")
+def soft_float_option(value):
+    value = normalize_arm_option(value)
+    if value is True:
+        return ["-msoft-float"]
+    if value is False:
+        return ["-mno-soft-float"]
+    return []
+
+
+check_and_add_flag(
+    "-mno-unaligned-access", when=depends(target.os)(lambda os: os == "Android")
+)
+
+
+# The set of flags that clang understands
+@depends(
+    arch_option,
+    thumb_option,
+    fpu_option,
+    float_abi_option,
+    soft_float_option,
+)
+def all_clang_arm_flags(arch, thumb, fpu, float_abi, soft_float):
+    return arch + thumb + fpu + float_abi + soft_float
+
+
+# All the flags the compiler understands. When the compiler is clang, this
+# still includes unsupported flags, but we live it to configure to fail
+# during a compiler check. These checks aren't available for clang as used
+# by bindgen, so we keep the separate set of flags for clang for bindgen.
+@depends(all_clang_arm_flags, thumb_interwork_option)
+def all_arm_flags(flags, interwork):
+    return flags + interwork
+
+
+add_old_configure_assignment("_ARM_FLAGS", all_arm_flags)
+add_old_configure_assignment("_THUMB_FLAGS", thumb_option)
+
+
+@depends(configure_cache, c_compiler, all_arm_flags)
+@checking("ARM version support in compiler", lambda x: x.arm_arch)
+@imports(_from="textwrap", _import="dedent")
+def arm_target(configure_cache, compiler, all_arm_flags):
+    # We're going to preprocess the following source to figure out some details
+    # about the arm target options we have enabled.
+    source = dedent(
+        """\
+        %ARM_ARCH __ARM_ARCH
+        #if __thumb2__
+        %THUMB2 yes
+        #else
+        %THUMB2 no
+        #endif
+        // Confusingly, the __SOFTFP__ preprocessor variable indicates the
+        // "softfloat" ABI, not the "softfp" ABI.
+        #if __SOFTFP__
+        %FLOAT_ABI soft
+        #elif __ARM_PCS_VFP
+        %FLOAT_ABI hard
+        #else
+        %FLOAT_ABI softfp
+        #endif
+        // There is more subtlety to it than this preprocessor test, but MOZ_FPU doesn't
+        // need to be too fine-grained.
+        #if __ARM_NEON
+        %FPU neon
+        #elif __ARM_VFPV2__ || __ARM_FP == 12
+        %FPU vfpv2
+        #elif __ARM_VFPV3__
+        %FPU vfpv3
+        #elif __ARM_VFPV4__ || __ARM_FP == 14
+        %FPU vfpv4
+        #elif __ARM_FPV5__
+        %FPU fp-armv8
+        #endif
+    """
+    )
+    result = try_invoke_compiler(
+        configure_cache,
+        [compiler.compiler] + compiler.flags,
+        compiler.language,
+        source,
+        ["-E"] + all_arm_flags,
+        wrapper=compiler.wrapper,
+    )
+    # Metadata emitted by preprocessors such as GCC with LANG=ja_JP.utf-8 may
+    # have non-ASCII characters. Treat the output as bytearray.
+    data = {"fpu": None}  # fpu may not get a value from the preprocessor.
+    for line in result.splitlines():
+        if line.startswith("%"):
+            k, _, v = line.partition(" ")
+            k = k.lstrip("%").lower()
+            if k == "arm_arch":
+                data[k] = int(v)
+            else:
+                data[k] = {
+                    "yes": True,
+                    "no": False,
+                }.get(v, v)
+            log.debug("%s = %s", k, data[k])
+
+    return namespace(**data)
+
+
+@depends(arm_target.arm_arch, when=depends(target.os)(lambda os: os == "Android"))
+def armv7(arch):
+    if arch < 7:
+        die("Android/armv6 and earlier are not supported")
+
+
+set_config("MOZ_THUMB2", True, when=arm_target.thumb2)
+set_define("MOZ_THUMB2", True, when=arm_target.thumb2)
+
+
+have_arm_simd = c_compiler.try_compile(
+    body='asm("uqadd8 r1, r1, r2");', check_msg="for ARM SIMD support in compiler"
+)
+
+set_config("HAVE_ARM_SIMD", have_arm_simd)
+set_define("HAVE_ARM_SIMD", have_arm_simd)
+
+have_arm_neon = c_compiler.try_compile(
+    body='asm(".fpu neon\\n vadd.i8 d0, d0, d0");',
+    check_msg="for ARM NEON support in compiler",
+)
+
+set_config("HAVE_ARM_NEON", have_arm_neon)
+set_define("HAVE_ARM_NEON", have_arm_neon)
+
+
+# We don't need to build NEON support if we're targetting a non-NEON device.
+# This matches media/webrtc/trunk/webrtc/build/common.gypi.
+@depends(arm_target.arm_arch, when=have_arm_neon)
+def build_arm_neon(arm_arch):
+    return arm_arch >= 7
+
+
+set_config("BUILD_ARM_NEON", True, when=build_arm_neon)
+set_define("BUILD_ARM_NEON", True, when=build_arm_neon)
+
+
+set_config("ARM_ARCH", depends(arm_target.arm_arch)(lambda x: str(x)))
+set_config("MOZ_FPU", arm_target.fpu)
+
+
+@depends(arm_target)
+def neon_flags(arm_target):
+    # Building with -mfpu=neon requires either the "softfp" or the
+    # "hardfp" ABI. Depending on the compiler's default target, and the
+    # CFLAGS, the default ABI might be neither, in which case it is the
+    # "softfloat" ABI.
+    # The "softfloat" ABI is binary-compatible with the "softfp" ABI, so
+    # we can safely mix code built with both ABIs. So, if we detect
+    # that compiling uses the "softfloat" ABI, force the use of the
+    # "softfp" ABI instead.
+    flags = ["-mfpu=neon"]
+    if arm_target.float_abi == "soft":
+        flags.append("-mfloat-abi=softfp")
+    if arm_target.arm_arch < 7:
+        # clang needs to be forced to at least armv7 for -mfpu=neon to do
+        # something.
+        flags.append("-march=armv7-a")
+    return tuple(flags)
+
+
+set_config("NEON_FLAGS", neon_flags)
diff --git a/build/moz.configure/bindgen.configure b/build/moz.configure/bindgen.configure
new file mode 100644
index 0000000000..72f4d4173b
--- /dev/null
+++ b/build/moz.configure/bindgen.configure
@@ -0,0 +1,377 @@
+# -*- 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/.
+
+
+option(env="CBINDGEN", nargs=1, help="Path to cbindgen")
+
+
+@imports(_from="textwrap", _import="dedent")
+def check_cbindgen_version(cbindgen, fatal=False):
+    log.debug("trying cbindgen: %s" % cbindgen)
+
+    cbindgen_min_version = Version("0.26.0")
+
+    # cbindgen x.y.z
+    version = Version(check_cmd_output(cbindgen, "--version").strip().split(" ")[1])
+    log.debug("%s has version %s" % (cbindgen, version))
+    if version >= cbindgen_min_version:
+        return True
+    if not fatal:
+        return False
+
+    die(
+        dedent(
+            """\
+    cbindgen version {} is too old. At least version {} is required.
+
+    Please update using 'cargo install cbindgen --force' or running
+    './mach bootstrap', after removing the existing executable located at
+    {}.
+    """.format(
+                version, cbindgen_min_version, cbindgen
+            )
+        )
+    )
+
+
+# Similar behavior to what check_prog does.
+has_cbindgen_input = depends("CBINDGEN")(lambda x: x)
+bootstrap_cbindgen = depends(has_cbindgen_input)(lambda i: not i)
+
+
+@depends_if(
+    "CBINDGEN",
+    bootstrap_search_path("cbindgen", when=bootstrap_cbindgen),
+    rust_search_path,
+)
+@checking("for cbindgen")
+@imports(_from="textwrap", _import="dedent")
+def cbindgen(cbindgen_override, bootstrap_search_path, rust_search_path):
+    if cbindgen_override:
+        check_cbindgen_version(cbindgen_override[0], fatal=True)
+        return cbindgen_override[0]
+
+    candidates = []
+    for path in bootstrap_search_path + rust_search_path:
+        candidate = find_program("cbindgen", [path])
+        if not candidate:
+            continue
+        if check_cbindgen_version(candidate):
+            return candidate
+        candidates.append(candidate)
+
+    if not candidates:
+        raise FatalCheckError(
+            dedent(
+                """\
+        Cannot find cbindgen. Please run `mach bootstrap`,
+        `cargo install cbindgen`, ensure that `cbindgen` is on your PATH,
+        or point at an executable with `CBINDGEN`.
+        """
+            )
+        )
+    check_cbindgen_version(candidates[0], fatal=True)
+
+
+set_config("CBINDGEN", cbindgen)
+
+# Bindgen can use rustfmt to format Rust file, but it's not required.
+option(env="RUSTFMT", nargs=1, help="Path to the rustfmt program")
+
+rustfmt = check_prog(
+    "RUSTFMT",
+    ["rustfmt"],
+    paths=rust_search_path,
+    input="RUSTFMT",
+    allow_missing=True,
+)
+
+
+option(
+    "--with-libclang-path",
+    nargs=1,
+    help="Absolute path to a directory containing Clang/LLVM libraries for bindgen (version 3.9.x or above)",
+)
+option(
+    "--with-clang-path",
+    nargs=1,
+    help="Absolute path to a Clang binary for bindgen (version 3.9.x or above)",
+)
+
+
+@depends(
+    "--with-clang-path",
+    configure_cache,
+    c_compiler,
+    cxx_compiler,
+    clang_search_path,
+    target,
+    target_sysroot.path,
+    android_version,
+)
+@checking("for clang for bindgen", lambda x: x.path if x else "not found")
+def bindgen_clang_compiler(
+    clang_path,
+    configure_cache,
+    c_compiler,
+    cxx_compiler,
+    clang_search_path,
+    target,
+    sysroot_path,
+    android_version,
+):
+    # When the target compiler is clang, use that, including flags.
+    if cxx_compiler.type == "clang":
+        if clang_path and clang_path[0] not in (
+            c_compiler.compiler,
+            cxx_compiler.compiler,
+        ):
+            die(
+                "--with-clang-path is not valid when the target compiler is %s",
+                cxx_compiler.type,
+            )
+        return namespace(
+            path=cxx_compiler.compiler,
+            flags=cxx_compiler.flags,
+        )
+    # When the target compiler is clang-cl, use clang in the same directory,
+    # and figure the right flags to use.
+    if cxx_compiler.type == "clang-cl":
+        if clang_path and os.path.dirname(clang_path[0]) != os.path.dirname(
+            cxx_compiler.compiler
+        ):
+            die(
+                "--with-clang-path must point to clang in the same directory "
+                "as the target compiler"
+            )
+        if not clang_path:
+            clang_path = [os.path.join(os.path.dirname(cxx_compiler.compiler), "clang")]
+
+    clang_path = find_program(
+        clang_path[0] if clang_path else "clang++", clang_search_path
+    )
+    if not clang_path:
+        return
+    # Hack before bug 1617793: if the compiler is clang-cl, hack the target
+    if cxx_compiler.type == "clang-cl":
+        target = split_triplet("%s-pc-windows-msvc" % target.raw_cpu)
+    flags = []
+    if sysroot_path:
+        flags.extend(("--sysroot", sysroot_path))
+    info = check_compiler(
+        configure_cache, [clang_path] + flags, "C++", target, android_version
+    )
+    # Usually, one check_compiler pass would be enough, but when cross-compiling
+    # and the host and target don't use the same default C++ standard, we don't
+    # get the --std flag, so try again. This is the same thing as valid_compiler()
+    # does in toolchain.configure.
+    if info.flags:
+        flags += info.flags
+        info = check_compiler(
+            configure_cache, [clang_path] + flags, "C++", target, android_version
+        )
+    return namespace(
+        path=clang_path,
+        flags=flags + info.flags,
+    )
+
+
+@depends("--with-libclang-path", bindgen_clang_compiler, host_library_name_info, host)
+@checking("for libclang for bindgen", lambda x: x if x else "not found")
+@imports("glob")
+@imports(_from="os", _import="pathsep")
+@imports(_from="os.path", _import="split", _as="pathsplit")
+@imports("re")
+def bindgen_libclang_path(libclang_path, clang, library_name_info, host):
+    if not clang:
+        if libclang_path:
+            die(
+                "--with-libclang-path is not valid without a clang compiler "
+                "for bindgen"
+            )
+        return
+
+    # Try to ensure that the clang shared library that bindgen is going
+    # to look for is actually present.  The files that we search for
+    # mirror the logic in clang-sys/build.rs.
+    libclang_choices = []
+    if host.os == "WINNT":
+        libclang_choices.append("libclang.dll")
+    libclang_choices.append(
+        "%sclang%s" % (library_name_info.dll.prefix, library_name_info.dll.suffix)
+    )
+    if host.kernel == "Linux":
+        libclang_choices.append("libclang.so.*")
+
+    if host.os == "OpenBSD":
+        libclang_choices.append("libclang.so.*.*")
+
+    candidates = []
+    if not libclang_path:
+        # Try to find libclang_path based on clang search dirs.
+        clang_search_dirs = check_cmd_output(clang.path, "-print-search-dirs")
+        for line in clang_search_dirs.splitlines():
+            name, _, value = line.partition(": =")
+            if host.os == "WINNT" and name == "programs":
+                # On Windows, libclang.dll is in bin/ rather than lib/,
+                # so scan the programs search dirs.
+                # To make matters complicated, clang before version 9 uses `:`
+                # separate between paths (and `;` in newer versions)
+                if pathsep in value:
+                    candidates.extend(value.split(pathsep))
+                else:
+                    for part in value.split(":"):
+                        # Assume that if previous "candidate" was of length 1,
+                        # it's a drive letter and the current part is the rest of
+                        # the corresponding full path.
+                        if candidates and len(candidates[-1]) == 1:
+                            candidates[-1] += ":" + part
+                        else:
+                            candidates.append(part)
+            elif host.os != "WINNT" and name == "libraries":
+                # On other platforms, use the directories from the libraries
+                # search dirs that looks like $something/clang/$version.
+                for dir in value.split(pathsep):
+                    dir, version = pathsplit(dir)
+                    if re.match(r"[0-9.]+", version):
+                        dir, name = pathsplit(dir)
+                        if name == "clang":
+                            candidates.append(dir)
+    else:
+        candidates.append(libclang_path[0])
+
+    for dir in candidates:
+        for pattern in libclang_choices:
+            log.debug('Trying "%s" in "%s"', pattern, dir)
+            libs = glob.glob(os.path.join(dir, pattern))
+            if libs:
+                return libs[0]
+
+
+@depends(bindgen_clang_compiler, bindgen_libclang_path, build_project)
+def bindgen_config_paths(clang, libclang, build_project):
+    # XXX: we want this code to be run for both Gecko and JS, but we don't
+    # necessarily want to force a bindgen/Rust dependency on JS just yet.
+    # Actually, we don't want to force an error if we're not building the
+    # browser generally.  We therefore whitelist the projects that require
+    # bindgen facilities at this point and leave it at that.
+    if build_project in ("browser", "mobile/android"):
+        if not clang:
+            die(
+                "Could not find clang to generate run bindings for C/C++. "
+                "Please install the necessary packages, run `mach bootstrap`, "
+                "or use --with-clang-path to give the location of clang."
+            )
+
+        if not libclang:
+            die(
+                "Could not find libclang to generate rust bindings for C/C++. "
+                "Please install the necessary packages, run `mach bootstrap`, "
+                "or use --with-libclang-path to give the path containing it."
+            )
+
+    if clang and libclang:
+        return namespace(
+            libclang=libclang,
+            libclang_path=os.path.dirname(libclang),
+            clang_path=clang.path,
+            clang_flags=clang.flags,
+        )
+
+
+@depends(bindgen_config_paths.libclang, when=bindgen_config_paths)
+@checking("that libclang is new enough", lambda s: "yes" if s else "no")
+@imports(_from="ctypes", _import="CDLL")
+@imports(_from="textwrap", _import="dedent")
+def min_libclang_version(libclang):
+    try:
+        lib = CDLL(libclang)
+        # We want at least 5.0. The API we test below is enough for that.
+        # Just accessing it should throw if not found.
+        fun = lib.clang_getAddressSpace
+        return True
+    except:
+        die(
+            dedent(
+                """\
+        The libclang located at {} is too old (need at least 5.0).
+
+        Please make sure to update it or point to a newer libclang using
+        --with-libclang-path.
+        """.format(
+                    libclang
+                )
+            )
+        )
+        return False
+
+
+set_config("MOZ_LIBCLANG_PATH", bindgen_config_paths.libclang_path)
+set_config("MOZ_CLANG_PATH", bindgen_config_paths.clang_path)
+
+
+@depends(
+    target,
+    cxx_compiler,
+    bindgen_cflags_android,
+    bindgen_config_paths.clang_flags,
+    all_clang_arm_flags,
+)
+def basic_bindgen_cflags(
+    target, compiler_info, android_cflags, clang_flags, all_arm_flags
+):
+    args = [
+        "-x",
+        "c++",
+        "-fno-sized-deallocation",
+        "-fno-aligned-new",
+        "-DTRACING=1",
+        "-DIMPL_LIBXUL",
+        "-DMOZILLA_INTERNAL_API",
+        "-DRUST_BINDGEN",
+    ]
+
+    if target.os == "Android":
+        args += android_cflags
+
+    args += {
+        "WINNT": [
+            "-DWIN32=1",
+        ],
+    }.get(target.os, [])
+
+    if compiler_info.type == "clang-cl":
+        args += [
+            # To enable the builtin __builtin_offsetof so that CRT wouldn't
+            # use reinterpret_cast in offsetof() which is not allowed inside
+            # static_assert().
+            "-D_CRT_USE_BUILTIN_OFFSETOF",
+            # Enable hidden attribute (which is not supported by MSVC and
+            # thus not enabled by default with a MSVC-compatibile build)
+            # to exclude hidden symbols from the generated file.
+            "-DHAVE_VISIBILITY_HIDDEN_ATTRIBUTE=1",
+        ]
+
+    return args + (clang_flags or []) + (all_arm_flags or [])
+
+
+option(
+    env="BINDGEN_CFLAGS",
+    nargs=1,
+    help="Options bindgen should pass to the C/C++ parser",
+)
+
+
+@depends(basic_bindgen_cflags, "BINDGEN_CFLAGS")
+@checking("bindgen cflags", lambda s: s if s else "no")
+def bindgen_cflags(base_flags, extra_flags):
+    flags = base_flags
+    if extra_flags and len(extra_flags):
+        flags += extra_flags[0].split()
+    return " ".join(flags)
+
+
+set_config("BINDGEN_SYSTEM_FLAGS", bindgen_cflags)
diff --git a/build/moz.configure/bootstrap.configure b/build/moz.configure/bootstrap.configure
new file mode 100644
index 0000000000..daaff7cdaa
--- /dev/null
+++ b/build/moz.configure/bootstrap.configure
@@ -0,0 +1,341 @@
+# -*- 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/.
+
+option(
+    env="MOZ_FETCHES_DIR",
+    nargs=1,
+    when="MOZ_AUTOMATION",
+    help="Directory containing fetched artifacts",
+)
+
+
+@depends("MOZ_FETCHES_DIR", when="MOZ_AUTOMATION")
+def moz_fetches_dir(value):
+    if value:
+        return value[0]
+
+
+@depends(vcs_checkout_type, milestone.is_nightly, "MOZ_AUTOMATION")
+def bootstrap_default(vcs_checkout_type, is_nightly, automation):
+    if automation:
+        return False
+    # We only enable if building off a VCS checkout of central.
+    if is_nightly and vcs_checkout_type:
+        return True
+
+
+option(
+    "--enable-bootstrap",
+    nargs="*",
+    default=bootstrap_default,
+    help="{Automatically bootstrap or update some toolchains|Disable bootstrap or update of toolchains}",
+)
+
+
+@depends_if("--enable-bootstrap")
+def enable_bootstrap(bootstrap):
+    include = set()
+    exclude = set()
+    for item in bootstrap:
+        if item.startswith("-"):
+            exclude.add(item.lstrip("-"))
+        else:
+            include.add(item)
+
+    def match(name):
+        if name in exclude:
+            return False
+        if include and name in include:
+            return True
+        return not bool(include)
+
+    return match
+
+
+@depends(developer_options, "--enable-bootstrap", moz_fetches_dir)
+def bootstrap_search_path_order(developer_options, bootstrap, moz_fetches_dir):
+    if moz_fetches_dir:
+        log.debug("Prioritizing MOZ_FETCHES_DIR in toolchain path.")
+        return "prepend"
+
+    if bootstrap:
+        log.debug(
+            "Prioritizing mozbuild state dir in toolchain paths because "
+            "bootstrap mode is enabled."
+        )
+        return "maybe-prepend"
+
+    if developer_options:
+        log.debug(
+            "Prioritizing mozbuild state dir in toolchain paths because "
+            "you are not building in release mode."
+        )
+        return "prepend"
+
+    log.debug(
+        "Prioritizing system over mozbuild state dir in "
+        "toolchain paths because you are building in "
+        "release mode."
+    )
+    return "append"
+
+
+toolchains_base_dir = moz_fetches_dir | mozbuild_state_path
+
+
+@dependable
+@imports("os")
+@imports(_from="os", _import="environ")
+def original_path():
+    return environ["PATH"].split(os.pathsep)
+
+
+@depends(host, when="--enable-bootstrap")
+@imports("os")
+@imports("traceback")
+@imports(_from="mozbuild.toolchains", _import="toolchain_task_definitions")
+@imports(_from="__builtin__", _import="Exception")
+def bootstrap_toolchain_tasks(host):
+    prefix = {
+        ("x86_64", "GNU", "Linux"): "linux64",
+        ("x86_64", "OSX", "Darwin"): "macosx64",
+        ("aarch64", "OSX", "Darwin"): "macosx64-aarch64",
+        ("x86_64", "WINNT", "WINNT"): "win64",
+        ("aarch64", "WINNT", "WINNT"): "win64-aarch64",
+    }.get((host.cpu, host.os, host.kernel))
+    try:
+        tasks = toolchain_task_definitions()
+    except Exception as e:
+        message = traceback.format_exc()
+        log.warning(str(e))
+        log.debug(message)
+        return None
+
+    def task_data(t):
+        result = {
+            "index": t.optimization["index-search"],
+            "artifact": t.attributes["toolchain-artifact"],
+        }
+        command = t.attributes.get("toolchain-command")
+        if command:
+            result["command"] = command
+        return result
+
+    # We only want to use toolchains annotated with "local-toolchain". We also limit the
+    # amount of data to what we use, so that trace logs can be more useful.
+    tasks = {
+        k: task_data(t)
+        for k, t in tasks.items()
+        if t.attributes.get("local-toolchain") and "index-search" in t.optimization
+    }
+
+    return namespace(prefix=prefix, tasks=tasks)
+
+
+@template
+def bootstrap_path(path, **kwargs):
+    when = kwargs.pop("when", None)
+    allow_failure = kwargs.pop("allow_failure", None)
+    if kwargs:
+        configure_error(
+            "bootstrap_path only takes `when` and `allow_failure` as a keyword argument"
+        )
+
+    @depends(
+        enable_bootstrap,
+        toolchains_base_dir,
+        moz_fetches_dir,
+        bootstrap_toolchain_tasks,
+        build_environment,
+        dependable(path),
+        dependable(allow_failure),
+        when=when,
+    )
+    @imports("os")
+    @imports("subprocess")
+    @imports("sys")
+    @imports(_from="mozbuild.util", _import="ensureParentDir")
+    @imports(_from="importlib", _import="import_module")
+    @imports(_from="shutil", _import="rmtree")
+    @imports(_from="__builtin__", _import="open")
+    @imports(_from="__builtin__", _import="Exception")
+    def bootstrap_path(
+        bootstrap,
+        toolchains_base_dir,
+        moz_fetches_dir,
+        tasks,
+        build_env,
+        path,
+        allow_failure,
+    ):
+        if not path:
+            return
+        path_parts = path.split("/")
+        path_prefix = ""
+        # Small hack until clang-tidy stops being a separate toolchain in a
+        # weird location.
+        if path_parts[0] == "clang-tools":
+            path_prefix = path_parts.pop(0)
+
+        def try_bootstrap(exists):
+            if not tasks:
+                return False
+            prefixes = [""]
+            if tasks.prefix:
+                prefixes.insert(0, "{}-".format(tasks.prefix))
+            for prefix in prefixes:
+                label = "toolchain-{}{}".format(prefix, path_parts[0])
+                task = tasks.tasks.get(label)
+                if task:
+                    break
+            log.debug("Trying to bootstrap %s", label)
+            if not task:
+                return False
+            task_index = task["index"]
+            log.debug("Resolved %s to %s", label, task_index[0])
+            task_index = task_index[0].split(".")[-1]
+            artifact = task["artifact"]
+            # `mach artifact toolchain` doesn't support authentication for
+            # private artifacts. Some toolchains may provide a command that can be
+            # used for local production of the artifact.
+            command = None
+            if not artifact.startswith("public/"):
+                command = task.get("command")
+                if not command:
+                    log.debug("Cannot bootstrap %s: not a public artifact", label)
+                    return False
+            index_file = os.path.join(toolchains_base_dir, "indices", path_parts[0])
+            try:
+                with open(index_file) as fh:
+                    index = fh.read().strip()
+            except Exception:
+                # On automation, if there's an artifact in MOZ_FETCHES_DIR, we assume it's
+                # up-to-date.
+                index = task_index if moz_fetches_dir else None
+            if index == task_index and exists:
+                log.debug("%s is up-to-date", label)
+                return True
+            # Manually import with import_module so that we can gracefully disable bootstrap
+            # when e.g. building from a js standalone tarball, that doesn't contain the
+            # taskgraph code. In those cases, `mach artifact toolchain --from-build` would
+            # also fail.
+            task_id = None
+            if not command:
+                try:
+                    IndexSearch = import_module(
+                        "taskgraph.optimize.strategies"
+                    ).IndexSearch
+                except Exception:
+                    log.debug("Cannot bootstrap %s: missing taskgraph module", label)
+                    return False
+                task_id = IndexSearch().should_replace_task(
+                    task, {}, None, task["index"]
+                )
+            if task_id:
+                # If we found the task in the index, use the `mach artifact toolchain`
+                # fast path.
+                command = [
+                    "artifact",
+                    "toolchain",
+                    "--from-task",
+                    f"{task_id}:{artifact}",
+                ]
+            elif command:
+                # For private local toolchains, run the associated command.
+                command = (
+                    [
+                        "python",
+                        "--virtualenv",
+                        "build",
+                        os.path.join(
+                            build_env.topsrcdir,
+                            "taskcluster/scripts/misc",
+                            command["script"],
+                        ),
+                    ]
+                    + command["arguments"]
+                    + [path_parts[0]]
+                )
+                # Clean up anything that was bootstrapped previously before going
+                # forward. In other cases, that's taken care of by mach artifact toolchain.
+                rmtree(
+                    os.path.join(toolchains_base_dir, path_prefix, path_parts[0]),
+                    ignore_errors=True,
+                )
+            else:
+                # Otherwise, use the slower path, which will print a better error than
+                # we would be able to.
+                command = ["artifact", "toolchain", "--from-build", label]
+
+            log.info(
+                "%s bootstrapped toolchain in %s",
+                "Updating" if exists else "Installing",
+                os.path.join(toolchains_base_dir, path_prefix, path_parts[0]),
+            )
+            os.makedirs(os.path.join(toolchains_base_dir, path_prefix), exist_ok=True)
+            proc = subprocess.run(
+                [
+                    sys.executable,
+                    os.path.join(build_env.topsrcdir, "mach"),
+                    "--log-no-times",
+                ]
+                + command,
+                cwd=os.path.join(toolchains_base_dir, path_prefix),
+                check=not allow_failure,
+            )
+            if proc.returncode != 0 and allow_failure:
+                return False
+            ensureParentDir(index_file)
+            with open(index_file, "w") as fh:
+                fh.write(task_index)
+            return True
+
+        path = os.path.join(toolchains_base_dir, path_prefix, *path_parts)
+        if bootstrap and bootstrap(path_parts[0]):
+            try:
+                if not try_bootstrap(os.path.exists(path)):
+                    # If there aren't toolchain artifacts to use for this build,
+                    # don't return a path.
+                    return None
+            except Exception as e:
+                log.error("%s", e)
+                die("If you can't fix the above, retry with --disable-bootstrap.")
+        # We re-test whether the path exists because it may have been created by
+        # try_bootstrap. Automation will not have gone through the bootstrap
+        # process, but we want to return the path if it exists.
+        if os.path.exists(path):
+            return path
+
+    return bootstrap_path
+
+
+@template
+def bootstrap_search_path(path, paths=original_path, **kwargs):
+    @depends(
+        enable_bootstrap,
+        dependable(path),
+        bootstrap_path(path, **kwargs),
+        bootstrap_search_path_order,
+        paths,
+        original_path,
+    )
+    def bootstrap_search_path(
+        bootstrap, path, bootstrap_path, order, paths, original_path
+    ):
+        if paths is None:
+            paths = original_path
+        if not bootstrap_path:
+            return paths
+        if order == "maybe-prepend":
+            if bootstrap(path.split("/")[0]):
+                order = "prepend"
+            else:
+                order = "append"
+        if order == "prepend":
+            return [bootstrap_path] + paths
+        return paths + [bootstrap_path]
+
+    return bootstrap_search_path
diff --git a/build/moz.configure/checks.configure b/build/moz.configure/checks.configure
new file mode 100644
index 0000000000..73e8b0a886
--- /dev/null
+++ b/build/moz.configure/checks.configure
@@ -0,0 +1,206 @@
+# -*- 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/.
+
+# Templates implementing some generic checks.
+# ==============================================================
+
+# Declare some exceptions. This is cumbersome, but since we shouldn't need a
+# lot of them, let's stack them all here. When adding a new one, put it in the
+# _declare_exceptions template, and add it to the return statement. Then
+# destructure in the assignment below the function declaration.
+
+
+@template
+@imports(_from="__builtin__", _import="Exception")
+def _declare_exceptions():
+    class FatalCheckError(Exception):
+        """An exception to throw from a function decorated with @checking.
+        It will result in calling die() with the given message.
+        Debugging messages emitted from the decorated function will also be
+        printed out."""
+
+    return (FatalCheckError,)
+
+
+(FatalCheckError,) = _declare_exceptions()
+
+del _declare_exceptions
+
+# Helper to display "checking" messages
+#   @checking('for foo')
+#   def foo():
+#       return 'foo'
+# is equivalent to:
+#   def foo():
+#       log.info('checking for foo... ')
+#       ret = foo
+#       log.info(ret)
+#       return ret
+# This can be combined with e.g. @depends:
+#   @depends(some_option)
+#   @checking('for something')
+#   def check(value):
+#       ...
+# An optional callback can be given, that will be used to format the returned
+# value when displaying it.
+
+
+@template
+def checking(what, callback=None):
+    def decorator(func):
+        def wrapped(*args, **kwargs):
+            log.info("checking %s... ", what)
+            with log.queue_debug():
+                error, ret = None, None
+                try:
+                    ret = func(*args, **kwargs)
+                except FatalCheckError as e:
+                    error = str(e)
+                display_ret = callback(ret) if callback else ret
+                if display_ret is True:
+                    log.info("yes")
+                elif display_ret is False or display_ret is None:
+                    log.info("no")
+                else:
+                    log.info(display_ret)
+                if error is not None:
+                    die(error)
+            return ret
+
+        return wrapped
+
+    return decorator
+
+
+# Template to check for programs in $PATH.
+# - `var` is the name of the variable that will be set with `set_config` when
+#   the program is found.
+# - `progs` is a list (or tuple) of program names that will be searched for.
+#   It can also be a reference to a @depends function that returns such a
+#   list. If the list is empty and there is no input, the check is skipped.
+# - `what` is a human readable description of what is being looked for. It
+#   defaults to the lowercase version of `var`.
+# - `input` is a string reference to an existing option or a reference to a
+#   @depends function resolving to explicit input for the program check.
+#   The default is to create an option for the environment variable `var`.
+#   This argument allows to use a different kind of option (possibly using a
+#   configure flag), or doing some pre-processing with a @depends function.
+# - `allow_missing` indicates whether not finding the program is an error.
+# - `paths` is a list of paths or @depends function returning a list of paths
+#   that will cause the given path(s) to be searched rather than $PATH. Input
+#   paths may either be individual paths or delimited by os.pathsep, to allow
+#   passing $PATH (for example) as an element.
+# - `bootstrap` is a path relative to the bootstrap root path (e.g ~/.mozbuild)
+#   where to find the program if it's bootstrapped.
+# - `validate` is a callback function that takes a path and returns True if
+#   the program at that location is appropriate or not, or False if not.
+#   when the callback returns False, check_prog ignores the program and goes
+#   on to the next from the `progs` list.
+#
+# - `bootstrap_search_path` is not an argument that users of the template are
+#   supposed to pass. See the override of check_prog in top-level moz.configure.
+#
+# The simplest form is:
+#   check_prog('PROG', ('a', 'b'))
+# This will look for 'a' or 'b' in $PATH, and set_config PROG to the one
+# it can find. If PROG is already set from the environment or command line,
+# use that value instead.
+@template
+@imports(_from="mozbuild.shellutil", _import="quote")
+def check_prog(
+    var,
+    progs,
+    what=None,
+    input=None,
+    allow_missing=False,
+    paths=None,
+    allow_spaces=False,
+    bootstrap=None,
+    when=None,
+    validate=None,
+    bootstrap_search_path=None,
+):
+    if input is not None:
+        # Wrap input with type checking and normalization.
+        @depends(input, when=when)
+        def input(value):
+            if not value:
+                return
+            if isinstance(value, str):
+                return (value,)
+            if isinstance(value, (tuple, list)) and len(value) == 1:
+                return value
+            configure_error(
+                "input must resolve to a tuple or a list with a "
+                "single element, or a string"
+            )
+
+    else:
+        option(
+            env=var,
+            nargs=1,
+            when=when,
+            help="Path to %s" % (what or "the %s program" % var.lower()),
+        )
+        input = var
+    what = what or var.lower()
+
+    # Trick to make a @depends function out of an immediate value.
+    progs = dependable(progs)
+    paths = dependable(paths)
+    allow_missing = dependable(allow_missing)
+
+    if bootstrap:
+        if input is var:
+            # A when is needed when depending on an option, so normalize
+            # to a function that can used without.
+            has_input = depends(input, when=when)(lambda x: x)
+        else:
+            has_input = input
+        # We don't want to bootstrap when an explicit value was given as input.
+        if when:
+            bootstrap_when = depends(when, has_input)(lambda w, i: w and not i)
+        else:
+            bootstrap_when = depends(has_input)(lambda i: not i)
+        paths = bootstrap_search_path(bootstrap, paths, when=bootstrap_when)
+
+    # Avoid displaying the "Checking for" message when the inputs are such
+    # that we don't actually want anything to be checked. It is a bit
+    # convoluted because of how `when` works.
+    # We first wrap all the inputs except allow_missing (which doesn't count
+    # for whether to display the "Checking for" message).
+    @depends_if(input, progs, paths, when=when)
+    def inputs(input, progs, paths):
+        if progs is None:
+            progs = ()
+
+        if not isinstance(progs, (tuple, list)):
+            configure_error("progs must resolve to a list or tuple!")
+
+        return namespace(value=input, progs=progs, paths=paths)
+
+    @depends(inputs, allow_missing, when=inputs)
+    @checking("for %s" % what, lambda x: quote(x) if x else "not found")
+    def check(inputs, allow_missing):
+        value = inputs.value
+        progs = inputs.progs
+        paths = inputs.paths
+
+        for prog in value or progs:
+            log.debug("%s: Looking for %s", var.lower(), quote(prog))
+            result = find_program(prog, paths, allow_spaces)
+            if validate and result and not validate(result):
+                log.debug("%s: %s found but didn't work", var.lower(), quote(result))
+                continue
+            if result:
+                return result
+
+        if not allow_missing or value:
+            raise FatalCheckError("Cannot find %s" % what)
+
+    set_config(var, check)
+
+    return check
diff --git a/build/moz.configure/compile-checks.configure b/build/moz.configure/compile-checks.configure
new file mode 100644
index 0000000000..a639a012f1
--- /dev/null
+++ b/build/moz.configure/compile-checks.configure
@@ -0,0 +1,445 @@
+# -*- Mode: python; c-basic-offset: 4; 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/.
+
+
+# Generates a test program and attempts to compile it. In case of failure, the
+# resulting check will return None. If the test program succeeds, it will return
+# the output of the test program.
+# - `includes` are the includes (as file names) that will appear at the top of
+#   the generated test program.
+# - `body` is the code that will appear in the main function of the generated
+#   test program. `return 0;` is appended to the function body automatically.
+# - `language` is the language selection, so that the appropriate compiler is
+#   used.
+# - `flags` are the flags to be passed to the compiler, in addition to `-c`.
+# - `check_msg` is the message to be printed to accompany compiling the test
+#   program.
+@template
+def try_compile(
+    includes=None,
+    body="",
+    language="C++",
+    flags=None,
+    check_msg=None,
+    when=None,
+    onerror=lambda: None,
+):
+    compiler = {
+        "C": c_compiler,
+        "C++": cxx_compiler,
+    }[language]
+
+    return compiler.try_compile(
+        includes, body, flags, check_msg, when=when, onerror=onerror
+    )
+
+
+# Generates a test program and attempts to link it. In case of failure, the
+# resulting check will return None. If the link succeeds, it will return
+# True
+# - `includes` are the includes (as file names) that will appear at the top of
+#   the generated test program.
+# - `body` is the code that will appear in the main function of the generated
+#   test program. `return 0;` is appended to the function body automatically.
+# - `language` is the language selection, so that the appropriate compiler is
+#   used.
+# - `flags` are the flags to be passed to the compiler.
+# - `check_msg` is the message to be printed to accompany compiling the test
+#   program.
+@template
+def try_link(
+    includes=None,
+    body="",
+    language="C++",
+    flags=None,
+    check_msg=None,
+    when=None,
+    onerror=lambda: None,
+):
+    compiler = {
+        "C": c_compiler,
+        "C++": cxx_compiler,
+    }[language]
+
+    return compiler.try_link(
+        linker_ldflags,
+        includes,
+        body,
+        flags,
+        check_msg,
+        when=when,
+        onerror=onerror,
+    )
+
+
+# Checks for the presence of the given header on the target system by compiling
+# a test program including that header. The return value of the template is a
+# check function returning True if the header is present, and None if it is not.
+# The value of this check function is also used to set a variable (with set_define)
+# corresponding to the checked header. For instance, HAVE_MALLOC_H will be set in
+# defines if check_header if called with 'malloc.h' as input and malloc.h is
+# present on the target.
+# - `header` is the header, as a file name, to check for.
+# - `language` is the language selection, so that the appropriate compiler is
+#   used.
+# - `flags` are the flags to be passed to the compiler, in addition to `-c`.
+# - `includes` are additional includes, as file names, to appear before the
+#   header checked for.
+# - `when` is a depends function that if present will make performing the check
+#   conditional on the value of that function.
+@template
+def check_header(
+    header, language="C++", flags=None, includes=None, when=None, onerror=lambda: None
+):
+    if when is None:
+        when = always
+
+    if includes:
+        includes = includes[:]
+    else:
+        includes = []
+    includes.append(header)
+
+    have_header = try_compile(
+        includes=includes,
+        language=language,
+        flags=flags,
+        check_msg="for %s" % header,
+        when=when,
+        onerror=onerror,
+    )
+    header_var = "HAVE_%s" % (
+        header.upper().replace("-", "_").replace("/", "_").replace(".", "_")
+    )
+    set_define(header_var, have_header)
+    return have_header
+
+
+# A convenience wrapper for check_header for checking multiple headers.
+# returns an array of the resulting checks in order corresponding to the
+# provided headers.
+# - `headers` are the headers to be checked.
+# - `kwargs` are keyword arguments passed verbatim to check_header.
+
+
+@template
+def check_headers(*headers, **kwargs):
+    checks = []
+    for header in headers:
+        checks.append(check_header(header, **kwargs))
+    return checks
+
+
+@depends(linker_ldflags, target.kernel)
+def check_symbol_flags(linker_ldflags, kernel):
+    if kernel == "WINNT":
+        # The build doesn't use the compiler to link things as of writing,
+        # but some compilation checks do. When using clang-cl, the only
+        # linker we really support is lld.link, but clang-cl defaults to
+        # link.exe (even when cross-compiling). So we force the use of
+        # lld.link for the linkage checks.
+        return ["-fuse-ld=lld"]
+    return linker_ldflags
+
+
+# Checks for the presence of the given symbol on the target system by compiling
+# a test program. The return value of the template is a check function
+# returning True if the symbol can be found, and None if it is not.
+@template
+def check_symbol(symbol, language="C", flags=None, when=None, onerror=lambda: None):
+    if when is None:
+        when = always
+
+    compiler, extern_c = {
+        "C": (c_compiler, ""),
+        "C++": (cxx_compiler, 'extern "C" '),
+    }[language]
+
+    # Stolen from autoconf 2.13 ; might be irrelevant now, but it doesn't hurt to
+    # keep using a char return type.
+    comment = [
+        "/* Override any gcc2 internal prototype to avoid an error.  */",
+        "/* We use char because int might match the return type of a gcc2",
+        "    builtin and then its argument prototype would still apply.  */",
+    ]
+
+    if flags:
+
+        @depends(check_symbol_flags, dependable(flags))
+        def flags(base_flags, extra_flags):
+            if base_flags and extra_flags:
+                return base_flags + list(extra_flags)
+            if extra_flags:
+                return extra_flags
+            return base_flags
+
+    else:
+        flags = check_symbol_flags
+
+    return compiler.try_run(
+        header=comment + ["%schar %s();" % (extern_c, symbol)],
+        body="%s();" % symbol,
+        flags=flags,
+        check_msg="for %s" % symbol,
+        when=when,
+        onerror=onerror,
+    )
+
+
+# Determine whether to add a given flag to the given lists of flags for C or
+# C++ compilation.
+# - `flag` is the flag to test
+# - `flags_collection` is a @depends function for a namespace of lists of
+#    C/C++ compiler flags to add to.
+# - `test_flags` is a list of flags to pass to the compiler instead of merely
+#   passing `flag`. This is especially useful for checking warning flags. If
+#   this list is empty, `flag` will be passed on its own.
+# - `compiler` (optional) is the compiler to test against (c_compiler or
+#   cxx_compiler, from toolchain.configure). When omitted, both compilers
+#   are tested; the list of flags added to is dependent on the compiler tested.
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+#   adds it to the list of flags unconditionally.
+# - `mode`, can be "compile", "link" or "assemble"
+@template
+def check_and_add_flags(
+    flag,
+    flags_collection,
+    test_flags=(),
+    compiler=None,
+    when=None,
+    check=True,
+    mode="compile",
+):
+    assert mode in ("compile", "link", "assemble")
+
+    if compiler is not None:
+        compilers = (compiler,)
+    elif mode in ("link", "assemble"):
+        compilers = (c_compiler,)
+    else:
+        compilers = (c_compiler, cxx_compiler)
+
+    if when is None:
+        when = always
+
+    results = []
+
+    if test_flags:
+        flags = test_flags
+    else:
+        flags = [flag]
+
+    for c in compilers:
+        assert c in {c_compiler, cxx_compiler, host_c_compiler, host_cxx_compiler}
+        if mode == "compile":
+            lang, list_of_flags = {
+                c_compiler: ("C", flags_collection.cflags),
+                cxx_compiler: ("C++", flags_collection.cxxflags),
+                host_c_compiler: ("host C", flags_collection.host_cflags),
+                host_cxx_compiler: ("host C++", flags_collection.host_cxxflags),
+            }[c]
+        elif mode == "assemble":
+            lang, list_of_flags = {
+                c_compiler: ("C", flags_collection.asflags),
+                host_c_compiler: ("host C", flags_collection.host_asflags),
+            }[c]
+        elif mode == "link":
+            lang, list_of_flags = {
+                c_compiler: ("C", flags_collection.ldflags),
+                cxx_compiler: ("C++", flags_collection.ldflags),
+                host_c_compiler: ("host C", flags_collection.host_ldflags),
+                host_cxx_compiler: ("host C++", flags_collection.host_ldflags),
+            }[c]
+
+        result = when
+
+        if check:
+
+            @depends(c, dependable(flags))
+            def flags(c, flags):
+                # Don't error out just because clang complains about other things.
+                if c.type in ("clang", "clang-cl"):
+                    flags += ["-Wno-error=unused-command-line-argument"]
+
+                return flags
+
+            if mode == "link":
+
+                def runner(*args, **kwargs):
+                    if c in (c_compiler, cxx_compiler):
+                        return c.try_link(linker_ldflags, *args, **kwargs)
+                    else:
+                        return c.try_link(host_linker_ldflags, *args, **kwargs)
+
+                tool = "linker"
+            else:
+                runner = c.try_compile
+                tool = "compiler"
+
+            result = runner(
+                flags=flags,
+                when=result,
+                check_msg="whether the %s %s supports %s" % (lang, tool, flag),
+            )
+
+        @depends(result, list_of_flags)
+        def maybe_add_flag(result, list_of_flags):
+            if result:
+                list_of_flags.append(flag)
+
+        results.append(result)
+
+    return tuple(results)
+
+
+@dependable
+def warnings_flags():
+    return namespace(cflags=[], cxxflags=[], host_cflags=[], host_cxxflags=[])
+
+
+# Tests whether GCC or clang support the given warning flag, and if it is,
+# add it to the list of warning flags for the build.
+# - `warning` is the warning flag (e.g. -Wfoo)
+# - `compiler` (optional) is the compiler to test against (c_compiler or
+#   cxx_compiler, from toolchain.configure). When omitted, both compilers
+#   are tested.
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+#   adds it to the list of warning flags unconditionally. This is only meant
+#   for add_warning().
+@template
+def check_and_add_warning(warning, compiler=None, when=None, check=True):
+    # GCC and clang will fail if given an unknown warning option like
+    # -Wfoobar. But later versions won't fail if given an unknown negated
+    # warning option like -Wno-foobar. So when we are checking for support
+    # of a negated warning option, we actually test the positive form, but
+    # add the negated form to the flags variable.
+    if warning.startswith("-Wno-") and not warning.startswith("-Wno-error="):
+        flags = ["-Werror", "-W" + warning[5:]]
+    elif warning.startswith("-Werror="):
+        flags = [warning]
+    else:
+        flags = ["-Werror", warning]
+
+    return check_and_add_flags(
+        warning, warnings_flags, flags, compiler=compiler, when=when, check=check
+    )
+
+
+# Add the given warning to the list of warning flags for the build.
+# - `warning` is the warning flag (e.g. -Wfoo)
+# - `compiler` (optional) is the compiler to add the flag for (c_compiler or
+#   cxx_compiler, from toolchain.configure). When omitted, the warning flag
+#   is added for both compilers.
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+
+
+@template
+def add_warning(warning, compiler=None, when=None):
+    check_and_add_warning(warning, compiler, when, check=False)
+
+
+# Like the warning checks above, but for general compilation flags.
+@dependable
+def compilation_flags():
+    return namespace(cflags=[], cxxflags=[], host_cflags=[], host_cxxflags=[])
+
+
+# Tests whether GCC or clang support the given compilation flag; if the flag
+# is supported, add it to the list of compilation flags for the build.
+# - `flag` is the flag to test
+# - `compiler` (optional) is the compiler to test against (c_compiler or
+#   cxx_compiler, from toolchain.configure). When omitted, both compilers
+#   are tested.
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+#   adds it to the list of flags unconditionally. This is only meant for
+#   add_flag().
+@template
+def check_and_add_flag(flag, compiler=None, when=None, check=True):
+    flags = ["-Werror", flag]
+
+    return check_and_add_flags(
+        flag, compilation_flags, flags, compiler=compiler, when=when, check=check
+    )
+
+
+# Add the given flag to the list of flags for the build.
+# - `flag` is the flag (e.g. -fno-sized-deallocation)
+# - `compiler` (optional) is the compiler to add the flag for (c_compiler or
+#   cxx_compiler, from toolchain.configure). When omitted, the flag is added
+#   for both compilers.
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the flag is wanted.
+@template
+def add_flag(warning, compiler=None, when=None):
+    check_and_add_flag(warning, compiler, when, check=False)
+
+
+# Like the compilation checks above, but for asm flags.
+@dependable
+def asm_flags():
+    return namespace(asflags=[], host_asflags=[])
+
+
+# Tests the given assembler flag is supported; if the flag
+# is supported, add it to the list of compilation flags for the build.
+# - `flag` is the flag to test
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+#   adds it to the list of flags unconditionally. This is only meant for
+#   add_flag().
+@template
+def check_and_add_asm_flag(flag, when=None, check=True):
+    return check_and_add_flags(
+        flag,
+        asm_flags,
+        [flag],
+        when=when,
+        check=check,
+        mode="assemble",
+    )
+
+
+# Like the compilation checks above, but for linker flags.
+@dependable
+def linker_flags():
+    return namespace(ldflags=[], host_ldflags=[])
+
+
+# Tests the given linker flag is supported; if the flag
+# is supported, add it to the list of compilation flags for the build.
+# - `flag` is the flag to test
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+#   adds it to the list of flags unconditionally. This is only meant for
+#   add_flag().
+@template
+def check_and_add_linker_flag(flag, compiler=None, when=None, check=True):
+    return check_and_add_flags(
+        flag,
+        linker_flags,
+        [flag],
+        when=when,
+        check=check,
+        mode="link",
+    )
+
+
+# Add the given flag to the list of linker flags for the build.
+# - `flag` is the flag (e.g. -fno-sized-deallocation)
+# - `when` (optional) is a @depends function or option name conditioning
+#   when the flag is wanted.
+@template
+def add_linker_flag(flag, compiler=None, when=None):
+    check_and_add_linker_flag(flag, compiler, when, check=False)
diff --git a/build/moz.configure/compilers-util.configure b/build/moz.configure/compilers-util.configure
new file mode 100644
index 0000000000..598de3dc80
--- /dev/null
+++ b/build/moz.configure/compilers-util.configure
@@ -0,0 +1,204 @@
+# -*- 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/.
+
+
+@template
+@imports("textwrap")
+@imports(_from="mozbuild.configure", _import="SandboxDependsFunction")
+def compiler_class(compiler, host_or_target):
+    is_target = host_or_target is target
+
+    class Compiler(SandboxDependsFunction):
+        def _try_compile_or_link(
+            self,
+            includes,
+            body,
+            flags,
+            ldflags,
+            check_msg,
+            when,
+            onerror,
+        ):
+            if ldflags is None:
+
+                @depends(dependable(flags))
+                def flags(flags):
+                    flags = list(flags or [])
+                    flags.append("-c")
+                    return flags
+
+            else:
+
+                @depends(compiler, dependable(ldflags), dependable(flags), when=when)
+                def flags(compiler, ldflags, flags):
+                    if compiler.type == "clang-cl":
+                        configure_error(
+                            "checking linker flags for clang-cl is not supported yet"
+                        )
+
+                    flags = list(flags or [])
+                    flags.extend(ldflags)
+                    return flags
+
+            @depends(dependable(includes))
+            def header(includes):
+                includes = includes or []
+                return ["#include <%s>" % f for f in includes]
+
+            return self.try_run(
+                header=header,
+                body=body,
+                flags=flags,
+                check_msg=check_msg,
+                when=when,
+                onerror=onerror,
+            )
+
+        # Generates a test program and attempts to compile it. In case of
+        # failure, the resulting check will return None. If the test program
+        # succeeds, it will return the output of the test program.
+        # - `includes` are the includes (as file names) that will appear at the
+        #   top of the generated test program.
+        # - `body` is the code that will appear in the main function of the
+        #   generated test program. `return 0;` is appended to the function
+        #   body automatically.
+        # - `flags` are the flags to be passed to the compiler, in addition to
+        #   `-c`.
+        # - `check_msg` is the message to be printed to accompany compiling the
+        #   test program.
+        def try_compile(
+            self,
+            includes=None,
+            body="",
+            flags=None,
+            check_msg=None,
+            when=None,
+            onerror=lambda: None,
+        ):
+            return self._try_compile_or_link(
+                includes=includes,
+                body=body,
+                flags=flags,
+                ldflags=None,
+                check_msg=check_msg,
+                when=when,
+                onerror=onerror,
+            )
+
+        # Same steps as try_compile but doesn't add "-c"
+        def try_link(
+            self,
+            ldflags,
+            includes=None,
+            body="",
+            flags=None,
+            check_msg=None,
+            when=None,
+            onerror=lambda: None,
+        ):
+            return self._try_compile_or_link(
+                includes=includes,
+                body=body,
+                flags=flags,
+                ldflags=ldflags,
+                check_msg=check_msg,
+                when=when,
+                onerror=onerror,
+            )
+
+        # Generates a test program and run the compiler against it. In case of
+        # failure, the resulting check will return None.
+        # - `header` is code that will appear at the top of the generated test
+        #   program.
+        # - `body` is the code that will appear in the main function of the
+        #   generated test program. `return 0;` is appended to the function
+        #   body automatically.
+        # - `flags` are the flags to be passed to the compiler.
+        # - `check_msg` is the message to be printed to accompany compiling the
+        #   test program.
+        # - `onerror` is a function called when the check fails.
+        def try_run(
+            self,
+            header=None,
+            body="",
+            flags=None,
+            check_msg=None,
+            when=None,
+            onerror=lambda: None,
+        ):
+            source = textwrap.dedent(
+                """\
+                int
+                main(void)
+                {
+                %s
+                  ;
+                  return 0;
+                }
+            """
+                % body
+            )
+
+            if check_msg:
+
+                def checking_fn(fn):
+                    return checking(check_msg)(fn)
+
+            else:
+
+                def checking_fn(fn):
+                    return fn
+
+            # We accept onerror being a @depends function that returns a callable.
+            # So, create a similar @depends function when it's not already one.
+            if not isinstance(onerror, SandboxDependsFunction):
+                onerror = dependable(lambda: onerror)
+
+            @depends(
+                self,
+                dependable(flags),
+                extra_toolchain_flags,
+                dependable(header),
+                onerror,
+                configure_cache,
+                when=when,
+            )
+            @checking_fn
+            def func(
+                compiler,
+                flags,
+                extra_flags,
+                header,
+                onerror,
+                configure_cache,
+            ):
+                flags = list(flags or [])
+                if is_target:
+                    flags += extra_flags or []
+                header = header or ""
+                if isinstance(header, (list, tuple)):
+                    header = "\n".join(header)
+                if header:
+                    header += "\n"
+
+                if (
+                    try_invoke_compiler(
+                        configure_cache,
+                        [compiler.compiler] + compiler.flags,
+                        compiler.language,
+                        header + source,
+                        flags,
+                        onerror=onerror,
+                        wrapper=compiler.wrapper,
+                    )
+                    is not None
+                ):
+                    return True
+
+            return func
+
+    compiler.__class__ = Compiler
+    return compiler
diff --git a/build/moz.configure/flags.configure b/build/moz.configure/flags.configure
new file mode 100644
index 0000000000..8354b9af34
--- /dev/null
+++ b/build/moz.configure/flags.configure
@@ -0,0 +1,198 @@
+# -*- Mode: python; c-basic-offset: 4; 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/.
+
+# We support C++14, but we don't want to enable the sized deallocation
+# facilities in C++14 yet.
+check_and_add_flag("-fno-sized-deallocation", compiler=cxx_compiler)
+# Likewise for C++17 and aligned allocation.  It's not immediately obvious
+# from the clang and GCC documentation, but they both support this.
+check_and_add_flag("-fno-aligned-new", compiler=cxx_compiler)
+
+# Please keep these last in this file.
+add_old_configure_assignment("_COMPILATION_CFLAGS", compilation_flags.cflags)
+add_old_configure_assignment("_COMPILATION_CXXFLAGS", compilation_flags.cxxflags)
+add_old_configure_assignment("_COMPILATION_HOST_CFLAGS", compilation_flags.host_cflags)
+add_old_configure_assignment(
+    "_COMPILATION_HOST_CXXFLAGS", compilation_flags.host_cxxflags
+)
+
+
+option(
+    "--disable-new-pass-manager",
+    help="Use the legacy LLVM pass manager in clang builds",
+)
+
+
+@depends(
+    "--enable-new-pass-manager",
+    c_compiler,
+    host,
+    target,
+    "MOZ_PGO",
+    enable_fuzzing,
+    ubsan,
+)
+def pass_manager(enabled, compiler, host, target, pgo, enable_fuzzing, ubsan):
+    if compiler.type not in ("clang", "clang-cl"):
+        return None
+
+    # As of clang 13, the default pass manager is the new one.
+    if compiler.version >= "13.0.0":
+        if enabled:
+            return namespace(flags=None, enabled=True)
+        if compiler.type == "clang":
+            return namespace(flags=["-flegacy-pass-manager"], enabled=False)
+        if compiler.type == "clang-cl":
+            return namespace(flags=["-Xclang", "-flegacy-pass-manager"], enabled=False)
+
+    if not enabled:
+        if compiler.version >= "15.0.0":
+            die("--disable-new-pass-manager is only supported with clang < 15")
+        return None
+    if compiler.version < "9.0.0":
+        if enabled.origin != "default":
+            die("--enable-new-pass-manager is only supported with clang >= 9")
+        return None
+
+    if host.os == "OSX":
+        # Some native Mac builds hang with the new pass manager. Given the
+        # inability to test in CI, don't take the risk of further breakage.
+        if enabled.origin != "default":
+            die(
+                "--enable-new-pass-manager causes problems on mac hosts with clang < 13"
+            )
+        return None
+    if target.os == "OSX" and not pgo:
+        # Also disable when cross-compiling to Mac, because plain-ish opt
+        # builds hang. Variants like asan and ccov work fine, but it would be
+        # too tedious to test them all here. PGO is the only thing that matters
+        # enough to make an exception for.
+        if enabled.origin != "default":
+            die(
+                "--enable-new-pass-manager causes problems on mac builds with clang < 13"
+            )
+        return None
+    if enable_fuzzing and compiler.version < "10.0.0":
+        # Clang 9 does not seem to play well with libFuzzer
+        if enabled.origin != "default":
+            die(
+                "--enable-new-pass-manager causes problems on fuzzing builds with clang < 10"
+            )
+        return None
+    if ubsan and compiler.version == "10.0.0":
+        # Clang 10.0.0 hangs with some ubsan-inserted code constructs.
+        # This was fixed in 10.0.1 (https://llvm.org/pr45835)
+        if enabled.origin != "default":
+            die(
+                "--enable-new-pass-manager causes problems with ubsan builds with clang 10.0.0"
+            )
+        return None
+    if compiler.type == "clang":
+        return namespace(flags=["-fexperimental-new-pass-manager"], enabled=True)
+    elif compiler.type == "clang-cl":
+        return namespace(
+            flags=["-Xclang", "-fexperimental-new-pass-manager"], enabled=True
+        )
+
+
+set_config("MOZ_PASS_MANAGER_FLAGS", pass_manager.flags)
+
+
+# Try to make builds more reproducible and allow sharing built artifacts across
+# source and object directories by using -ffile-prefix-map and friends.  To
+# "unwind" the prefix maps, use:
+#
+# (gdb) set substitute-path /topsrcdir/ $topsrcdir/
+#
+# (lldb) settings set target.source-map /topobjdir/ $topobjdir/
+#
+# See, for example, https://lldb.llvm.org/use/map.html.
+@depends(
+    path_remapping,
+    path_remappings,
+    c_compiler,
+)
+@imports(_from="os", _import="sep")
+def file_prefix_map_flags(path_remapping, path_remappings, compiler):
+    if "c" not in path_remapping:
+        return []
+
+    if (compiler.type == "gcc" and compiler.version < "8.1") or (
+        compiler.type in ("clang", "clang-cl") and compiler.version < "10.0.0"
+    ):
+        die(
+            f"Compiler of type {compiler.type} and version {compiler.version} "
+            "does not support --enable-path-remapping."
+        )
+
+    flags = []
+    for old, new in path_remappings:
+        # We would prefer to use just -ffile-prefix-map, but clang-cl doesn't
+        # seem to recognize it.
+        for flag in ("-fdebug-prefix-map", "-fmacro-prefix-map"):
+            flag = f"{flag}={old}={new}"
+            if compiler.type in ("gcc", "clang"):
+                flags.append(flag)
+            elif compiler.type == "clang-cl":
+                flags.extend(["-Xclang", flag])
+
+    return flags
+
+
+set_config("MOZ_FILE_PREFIX_MAP_FLAGS", file_prefix_map_flags)
+
+
+@depends(c_compiler)
+def is_gcc(c_compiler):
+    return c_compiler.type == "gcc"
+
+
+@depends(c_compiler)
+def is_gnu_cc(c_compiler):
+    return c_compiler.type != "clang-cl"
+
+
+@depends(developer_options, when=is_gnu_cc)
+def check_build_id_uuid(developer_options):
+    return developer_options
+
+
+@depends(developer_options, when=is_gnu_cc)
+def check_build_id_sha1(developer_options):
+    return not developer_options
+
+
+check_and_add_flag("-pipe", when=is_gcc)
+
+check_and_add_linker_flag("-Wl,--build-id=uuid", when=check_build_id_uuid)
+check_and_add_linker_flag("-Wl,--build-id=sha1", when=check_build_id_sha1)
+
+check_and_add_asm_flag("-Wa,--noexecstack", when=is_gnu_cc)
+check_and_add_linker_flag("-Wl,-z,noexecstack", when=is_gnu_cc)
+check_and_add_linker_flag("-Wl,-z,text", when=is_gnu_cc)
+check_and_add_linker_flag("-Wl,-z,relro", when=is_gnu_cc)
+check_and_add_linker_flag("-Wl,-z,now", when=is_gnu_cc)
+check_and_add_linker_flag("-Wl,-z,nocopyreloc", when=is_gnu_cc)
+
+
+@depends("--enable-address-sanitizer", is_gnu_cc)
+def check_Bsymbolic(enable_asan, is_gnu_cc):
+    return enable_asan and is_gnu_cc
+
+
+# ASan assumes no symbols are being interposed, and when that happens,
+# it's not happy with it. Inconveniently, since Firefox is exporting
+# libffi symbols and Gtk+3 pulls system libffi via libwayland-client,
+# system libffi interposes libffi symbols that ASan assumes are in
+# libxul, so it barfs about buffer overflows.
+# Using -Wl,-Bsymbolic ensures no exported symbol can be interposed.
+check_and_add_linker_flag("-Wl,-Bsymbolic", when=check_Bsymbolic)
+
+# Please keep these last in this file.
+add_old_configure_assignment("_COMPILATION_ASFLAGS", asm_flags.asflags)
+add_old_configure_assignment("_COMPILATION_HOST_ASFLAGS", asm_flags.host_asflags)
+add_old_configure_assignment("_COMPILATION_LDFLAGS", linker_flags.ldflags)
+add_old_configure_assignment("_COMPILATION_HOST_LDFLAGS", linker_flags.host_ldflags)
diff --git a/build/moz.configure/headers.configure b/build/moz.configure/headers.configure
new file mode 100644
index 0000000000..5332c7365f
--- /dev/null
+++ b/build/moz.configure/headers.configure
@@ -0,0 +1,119 @@
+# -*- Mode: python; c-basic-offset: 4; 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/.
+
+# Check for headers defining standard int types.
+check_header("stdint.h")
+have_inttypes = check_header("inttypes.h")
+
+# Assume we have ansi C header files available.
+set_define("STDC_HEADERS", True)
+
+set_config("HAVE_INTTYPES_H", have_inttypes)
+
+building_linux = depends(target)(lambda target: target.kernel == "Linux")
+
+have_malloc = check_header("malloc.h")
+
+check_header("alloca.h")
+
+add_old_configure_assignment("HAVE_MALLOC_H", have_malloc)
+
+check_headers(
+    "sys/byteorder.h",
+    "getopt.h",
+    "unistd.h",
+    "nl_types.h",
+    "cpuid.h",
+    "fts.h",
+)
+
+# These are all the places some variant of statfs can be hiding.
+check_headers(
+    "sys/statvfs.h",
+    "sys/statfs.h",
+    "sys/vfs.h",
+    "sys/mount.h",
+)
+
+# Quota support
+# Check for both the header and quotactl() because Android headers can have the
+# header but not quotactl().
+set_define(
+    "HAVE_SYS_QUOTA_H",
+    try_compile(
+        includes=["sys/quota.h"],
+        body="quotactl(0, nullptr, 0, (caddr_t)nullptr);",
+        check_msg="for sys/quota.h",
+    ),
+)
+check_header("linux/quota.h", includes=["sys/socket.h"], when=building_linux)
+
+# SCTP support - needs various network include headers
+check_headers(
+    "linux/if_addr.h",
+    "linux/rtnetlink.h",
+    includes=["sys/socket.h"],
+    when=building_linux,
+)
+
+check_header("sys/queue.h")
+
+check_headers(
+    "sys/types.h",
+    "netinet/in.h",
+    "byteswap.h",
+)
+
+# memfd_create(2) -- Note that older versions of the Linux man-pages
+# project incorrectly cite <sys/memfd.h>, which doesn't exist; this
+# was fixed in the man-pages-5.00 release.
+set_define(
+    "HAVE_MEMFD_CREATE",
+    try_compile(
+        includes=["sys/mman.h"],
+        body='memfd_create("", 0);',
+        check_msg="for memfd_create in sys/mman.h",
+    ),
+)
+
+# TODO: Move these checks to file specific to --enable-project=js.
+have_perf_event_h = check_header("linux/perf_event.h", when=building_linux)
+
+option(
+    "--with-linux-headers",
+    help="location where the Linux kernel headers can be found",
+    nargs=1,
+)
+
+passed_linux_header_flags = depends_if("--with-linux-headers")(
+    lambda v: ["-I%s" % v[0]]
+)
+
+
+@depends(
+    try_compile(
+        includes=["asm/unistd.h"],
+        body="return sizeof(__NR_perf_event_open);",
+        flags=passed_linux_header_flags,
+        check_msg="for perf_event_open system call",
+    ),
+    when=have_perf_event_h,
+)
+def have_perf_event_open(have_perf_event_open):
+    if have_perf_event_open:
+        return True
+
+
+set_config("HAVE_LINUX_PERF_EVENT_H", have_perf_event_open)
+
+
+@depends(passed_linux_header_flags, have_perf_event_open)
+def linux_headers_includes(passed_linux_header_flags, have_perf_event_open):
+    if have_perf_event_open and passed_linux_header_flags:
+        return passed_linux_header_flags[0]
+
+
+set_config("LINUX_HEADERS_INCLUDES", linux_headers_includes)
diff --git a/build/moz.configure/init.configure b/build/moz.configure/init.configure
new file mode 100644
index 0000000000..11e22ee536
--- /dev/null
+++ b/build/moz.configure/init.configure
@@ -0,0 +1,1278 @@
+# -*- 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("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)
+add_old_configure_assignment("_objdir", build_environment.topobjdir)
+add_old_configure_assignment("DIST", build_environment.dist)
+
+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)
+set_config("PYTHON3_VERSION", virtualenv_python3.str_version)
+add_old_configure_assignment("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.
+
+
+# TODO remove hg.exe once bug 1382940 addresses ambiguous executables case.
+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)
+
+# Obtain a Repository interface for the current VCS repository.
+
+
+@depends(build_environment, exposed_vcs_checkout_type, hg, git)
+@imports(_from="mozversioncontrol", _import="get_repository_object")
+def vcs_repository(build_env, vcs_checkout_type, hg, git):
+    if vcs_checkout_type == "hg":
+        return get_repository_object(build_env.topsrcdir, hg=hg)
+    elif vcs_checkout_type == "git":
+        return get_repository_object(build_env.topsrcdir, git=git)
+    elif vcs_checkout_type:
+        raise FatalCheckError("unhandled VCS type: %s" % vcs_checkout_type)
+
+
+@depends_if(vcs_repository)
+@checking("for sparse checkout")
+def vcs_sparse_checkout(repo):
+    return repo.sparse_checkout_present()
+
+
+set_config("VCS_SPARSE_CHECKOUT", vcs_sparse_checkout)
+
+# 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("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"):
+        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 triplets, so
+    # munge those before and after calling config.sub.
+    suffix = None
+    munging = {
+        "-windows-msvc": "-mingw32",
+        "-windows-gnu": "-mingw32",
+    }
+    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")
+
+    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", "android")
+                if host.cpu == "aarch64"
+                else ("arm", "androideabi")
+            )
+            return split_triplet(f"{target_cpu}-unknown-linux-{target_system}")
+        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"
+        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)
+add_old_configure_assignment("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")
+)
+
+
+# Autoconf needs these set
+
+
+@depends(host)
+def host_for_sub_configure(host):
+    return "--host=%s" % host.sub_configure_alias
+
+
+@depends(target)
+def target_for_sub_configure(target):
+    return "--target=%s" % 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)
+add_old_configure_assignment("OS_TARGET", target_variables.OS_TARGET)
+set_config("OS_ARCH", target_variables.OS_ARCH)
+add_old_configure_assignment("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)
+add_old_configure_assignment("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_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)
+add_old_configure_assignment("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_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)
+add_old_configure_assignment("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, if we have "a" in GRE_MILESTONE, we're building Nightly or Aurora
+# - 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,
+    )
+
+
+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_VERSION_U", milestone.version)
+set_define("MOZILLA_UAVERSION", depends(milestone)(lambda m: '"%s"' % m.uaversion))
+set_config("MOZILLA_SYMBOLVERSION", milestone.symbolversion)
+# JS configure still want to look at this one.
+add_old_configure_assignment("MOZILLA_SYMBOLVERSION", milestone.symbolversion)
+
+set_config("MOZ_APP_VERSION", milestone.app_version)
+set_config("MOZ_APP_VERSION_DISPLAY", milestone.app_version_display)
+add_old_configure_assignment("MOZ_APP_VERSION", milestone.app_version)
+
+add_old_configure_assignment("NIGHTLY_BUILD", milestone.is_nightly)
+
+# 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)
+add_old_configure_assignment("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
+
+
+# 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"),
+)
diff --git a/build/moz.configure/java.configure b/build/moz.configure/java.configure
new file mode 100644
index 0000000000..0bb0a22c71
--- /dev/null
+++ b/build/moz.configure/java.configure
@@ -0,0 +1,76 @@
+# -*- 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/.
+
+
+# Java detection
+# ========================================================
+option(
+    "--with-java-bin-path",
+    nargs=1,
+    help="Location of Java binaries",
+)
+
+
+@depends("--with-java-bin-path", host, toolchains_base_dir)
+@imports(_from="mozboot.android", _import="JavaLocationFailedException")
+@imports(_from="mozboot.android", _import="locate_java_bin_path")
+@imports(_from="os", _import="environ")
+@imports(_from="os.path", _import="dirname")
+def java_search_paths(path, host, toolchains_base_dir):
+    if path:
+        # Look for javac and jar in the specified path.
+        return path
+
+    try:
+        path = locate_java_bin_path(host.kernel, toolchains_base_dir)
+
+        java_home = environ.get("JAVA_HOME")
+        if java_home and java_home != dirname(path):
+            log.info(
+                "Ignoring JAVA_HOME value. Use --with-java-bin-path "
+                "to override the default Java location."
+            )
+        return [path]
+    except JavaLocationFailedException as e:
+        die(str(e))
+
+
+# Finds the given java tool, failing with a custom error message if we can't
+# find it.
+
+
+@template
+def check_java_tool(tool):
+    check = check_prog(
+        tool.upper(), (tool,), paths=java_search_paths, allow_missing=True
+    )
+
+    @depends(check)
+    def require_tool(result):
+        if result is None:
+            die(
+                "The program %s was not found. Use '--with-java-bin-path={java-bin-dir}'"
+                % tool
+            )
+        return result
+
+    return require_tool
+
+
+check_java_tool("java")
+
+
+# Java Code Coverage
+# ========================================================
+option(
+    "--enable-java-coverage",
+    env="MOZ_JAVA_CODE_COVERAGE",
+    help="Enable Java code coverage",
+)
+
+set_config(
+    "MOZ_JAVA_CODE_COVERAGE", depends("--enable-java-coverage")(lambda v: bool(v))
+)
diff --git a/build/moz.configure/keyfiles.configure b/build/moz.configure/keyfiles.configure
new file mode 100644
index 0000000000..242a773aac
--- /dev/null
+++ b/build/moz.configure/keyfiles.configure
@@ -0,0 +1,68 @@
+# -*- 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/.
+
+
+@template
+def keyfile(desc, default=None, help=None, callback=lambda x: x):
+    help = help or (
+        "Use the secret key contained in the given keyfile " "for %s requests" % desc
+    )
+    name = desc.lower().replace(" ", "-")
+    no_key = callback("no-%s-key" % name)
+
+    option("--with-%s-keyfile" % name, nargs=1, default=default, help=help)
+
+    @depends("--with-%s-keyfile" % name)
+    @checking("for the %s key" % desc, lambda x: x and x is not no_key)
+    @imports(_from="__builtin__", _import="open")
+    @imports(_from="__builtin__", _import="IOError")
+    def keyfile(value):
+        if value:
+            try:
+                with open(value[0]) as fh:
+                    result = fh.read().strip()
+                    if result:
+                        return callback(result)
+                    raise FatalCheckError("'%s' is empty." % value[0])
+            except IOError as e:
+                raise FatalCheckError("'%s': %s." % (value[0], e.strerror))
+        return no_key
+
+    return keyfile
+
+
+@template
+def simple_keyfile(desc, default=None):
+    value = keyfile(desc, default=default)
+    set_config("MOZ_%s_KEY" % desc.upper().replace(" ", "_"), value)
+
+
+@template
+def id_and_secret_keyfile(desc, default=None):
+    def id_and_secret(value):
+        if value.startswith("no-") and value.endswith("-key"):
+            id = value[:-3] + "clientid"
+            secret = value
+        elif " " in value:
+            id, secret = value.split(" ", 1)
+        else:
+            raise FatalCheckError("%s key file has an invalid format." % desc)
+        return namespace(
+            id=id,
+            secret=secret,
+        )
+
+    content = keyfile(
+        desc,
+        help="Use the client id and secret key contained "
+        "in the given keyfile for %s requests" % desc,
+        default=default,
+        callback=id_and_secret,
+    )
+
+    name = desc.upper().replace(" ", "_")
+    set_config("MOZ_%s_CLIENTID" % name, content.id)
+    set_config("MOZ_%s_KEY" % name, content.secret)
diff --git a/build/moz.configure/lto-pgo.configure b/build/moz.configure/lto-pgo.configure
new file mode 100644
index 0000000000..ab6a527fe4
--- /dev/null
+++ b/build/moz.configure/lto-pgo.configure
@@ -0,0 +1,437 @@
+# -*- 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/.
+
+# PGO
+# ==============================================================
+llvm_profdata = check_prog(
+    "LLVM_PROFDATA", ["llvm-profdata"], allow_missing=True, paths=clang_search_path
+)
+
+
+@depends_if(llvm_profdata)
+@checking("whether llvm-profdata supports 'order' subcommand")
+def llvm_profdata_order(profdata):
+    retcode, _, _ = get_cmd_output(profdata, "order", "--help")
+    return retcode == 0
+
+
+option(
+    "--enable-profile-generate",
+    env="MOZ_PROFILE_GENERATE",
+    nargs="?",
+    choices=("cross",),
+    help="Build a PGO instrumented binary",
+)
+
+imply_option("MOZ_PGO", depends_if("--enable-profile-generate")(lambda _: True))
+
+set_config(
+    "MOZ_PROFILE_GENERATE", depends_if("--enable-profile-generate")(lambda _: True)
+)
+
+set_define(
+    "MOZ_PROFILE_GENERATE", depends_if("--enable-profile-generate")(lambda _: True)
+)
+
+add_old_configure_assignment(
+    "MOZ_PROFILE_GENERATE", 1, when="--enable-profile-generate"
+)
+
+option(
+    "--enable-profile-use",
+    env="MOZ_PROFILE_USE",
+    nargs="?",
+    choices=("cross",),
+    help="Use a generated profile during the build",
+)
+
+option(
+    "--with-pgo-profile-path",
+    help="Path to the directory with unmerged profile data to use during the build"
+    ", or to a merged profdata file",
+    nargs=1,
+)
+
+imply_option("MOZ_PGO", depends_if("--enable-profile-use")(lambda _: True))
+
+set_config("MOZ_PROFILE_USE", depends_if("--enable-profile-use")(lambda _: True))
+
+
+@depends(
+    "--with-pgo-profile-path",
+    "--enable-profile-use",
+    llvm_profdata,
+    build_environment,
+)
+@imports("os")
+def pgo_profile_path(path, pgo_use, profdata, build_env):
+    topobjdir = build_env.topobjdir
+    if topobjdir.endswith("/js/src"):
+        topobjdir = topobjdir[:-7]
+
+    if not path:
+        return os.path.join(topobjdir, "instrumented", "merged.profdata")
+    if path and not pgo_use:
+        die("Pass --enable-profile-use to use --with-pgo-profile-path.")
+    if path and not profdata:
+        die("LLVM_PROFDATA must be set to process the pgo profile.")
+    if not os.path.isfile(path[0]):
+        die("Argument to --with-pgo-profile-path must be a file.")
+    if not os.path.isabs(path[0]):
+        die("Argument to --with-pgo-profile-path must be an absolute path.")
+    return path[0]
+
+
+set_config("PGO_PROFILE_PATH", pgo_profile_path)
+
+
+@depends(
+    "--enable-profile-use",
+    pgo_profile_path,
+    llvm_profdata,
+    llvm_profdata_order,
+    build_environment,
+)
+def orderfile_path(profile_use, path, profdata, profdata_order, build_env):
+    if not profile_use:
+        return None
+
+    if not profdata_order:
+        return None
+
+    topobjdir = build_env.topobjdir
+
+    orderfile = os.path.join(topobjdir, "orderfile.txt")
+    check_cmd_output(profdata, "order", path, "-o", orderfile)
+    return orderfile
+
+
+pgo_temporal = c_compiler.try_compile(
+    flags=["-fprofile-generate", "-mllvm", "-pgo-temporal-instrumentation"],
+    check_msg="whether the C compiler supports temporal instrumentation",
+    when="--enable-profile-generate",
+)
+
+
+@depends(
+    c_compiler,
+    select_linker,
+    target,
+    pgo_profile_path,
+    orderfile_path,
+    target_is_windows,
+    pgo_temporal,
+)
+@imports("multiprocessing")
+def pgo_flags(
+    compiler, linker, target, profdata, orderfile, target_is_windows, pgo_temporal
+):
+    if compiler.type == "gcc":
+        return namespace(
+            gen_cflags=["-fprofile-generate"],
+            gen_ldflags=["-fprofile-generate"],
+            use_cflags=["-fprofile-use", "-fprofile-correction", "-Wcoverage-mismatch"],
+            use_ldflags=["-fprofile-use"],
+        )
+
+    if compiler.type in ("clang-cl", "clang"):
+        prefix = ""
+        if compiler.type == "clang-cl":
+            prefix = "/clang:"
+            gen_ldflags = None
+        else:
+            gen_ldflags = ["-fprofile-generate"]
+
+        use_ldflags = []
+        if orderfile:
+            if compiler.type == "clang-cl":
+                use_ldflags += ["-ORDER:@" + orderfile]
+            elif linker.KIND == "ld64" or (linker.KIND == "lld" and target.os == "OSX"):
+                use_ldflags += ["-Wl,-order_file", orderfile]
+            elif linker.KIND == "lld":
+                use_ldflags += [
+                    "-Wl,--symbol-ordering-file",
+                    orderfile,
+                    "-Wl,--no-warn-symbol-ordering",
+                ]
+
+        if use_ldflags:
+            log.info("Activating PGO-based orderfile")
+
+        gen_cflags = [prefix + "-fprofile-generate"]
+
+        if pgo_temporal:
+            gen_cflags += ["-mllvm", "-pgo-temporal-instrumentation"]
+
+        if target_is_windows:
+            # native llvm-profdata.exe on Windows can't read profile data
+            # if name compression is enabled (which cross-compiling enables
+            # by default)
+            gen_cflags += ["-mllvm", "-enable-name-compression=false"]
+
+        return namespace(
+            gen_cflags=gen_cflags,
+            gen_ldflags=gen_ldflags,
+            use_cflags=[
+                prefix + "-fprofile-use=%s" % profdata,
+                # Some error messages about mismatched profile data
+                # come in via -Wbackend-plugin, so disable those too.
+                "-Wno-error=backend-plugin",
+            ],
+            use_ldflags=use_ldflags,
+        )
+
+
+set_config("PROFILE_GEN_CFLAGS", pgo_flags.gen_cflags)
+set_config("PROFILE_GEN_LDFLAGS", pgo_flags.gen_ldflags)
+set_config("PROFILE_USE_CFLAGS", pgo_flags.use_cflags)
+set_config("PROFILE_USE_LDFLAGS", pgo_flags.use_ldflags)
+
+option(
+    "--with-pgo-jarlog",
+    help="Use the provided jarlog file when packaging during a profile-use " "build",
+    nargs=1,
+)
+
+set_config("PGO_JARLOG_PATH", depends_if("--with-pgo-jarlog")(lambda p: p))
+
+
+@depends("MOZ_PGO", "--enable-profile-use", "--enable-profile-generate", c_compiler)
+def moz_pgo_rust(pgo, profile_use, profile_generate, c_compiler):
+    if not pgo:
+        return
+
+    # Enabling PGO through MOZ_PGO only and not --enable* flags.
+    if not profile_use and not profile_generate:
+        return
+
+    if profile_use and profile_generate:
+        die("Cannot build with --enable-profile-use and --enable-profile-generate.")
+
+    want_cross = (len(profile_use) and profile_use[0] == "cross") or (
+        len(profile_generate) and profile_generate[0] == "cross"
+    )
+
+    if not want_cross:
+        return
+
+    if c_compiler.type == "gcc":
+        die("Cannot use cross-language PGO with GCC.")
+
+    return True
+
+
+set_config("MOZ_PGO_RUST", moz_pgo_rust)
+
+# LTO
+# ==============================================================
+
+option(
+    "--enable-lto",
+    env="MOZ_LTO",
+    nargs="*",
+    choices=("full", "thin", "cross"),
+    help="Enable LTO",
+)
+
+option(
+    env="MOZ_LD64_KNOWN_GOOD",
+    nargs=1,
+    help="Indicate that ld64 is free of symbol aliasing bugs.",
+)
+
+imply_option("MOZ_LD64_KNOWN_GOOD", depends_if("MOZ_AUTOMATION")(lambda _: True))
+
+
+@depends(
+    "--enable-lto",
+    c_compiler,
+    select_linker,
+    "MOZ_LD64_KNOWN_GOOD",
+    target,
+    "--enable-profile-generate",
+    pass_manager.enabled,
+    "--enable-profile-use",
+    "MOZ_AUTOMATION",
+)
+@imports("multiprocessing")
+def lto(
+    values,
+    c_compiler,
+    select_linker,
+    ld64_known_good,
+    target,
+    instrumented_build,
+    pass_manager,
+    pgo_build,
+    moz_automation,
+):
+    cflags = []
+    ldflags = []
+    enabled = None
+    rust_lto = False
+
+    if not values:
+        return
+
+    # Sanitize LTO modes.
+    if "full" in values and "thin" in values:
+        die("incompatible --enable-lto choices 'full' and 'thin'")
+
+    # If a value was given to --enable-lto, use that.  Otherwise, make the lto
+    # mode explicit, using full with gcc, and full or thin with clang depending
+    # on the performance benefit.
+    # Defaulting to full LTO is costly in terms of compilation time, so we only
+    # default to it if MOZ_AUTOMATION and PGO are on, and for some platforms.
+    # Based on speedometer3 scores, full lto + pgo is beneficial for Linux and
+    # Windows for x86_64 targets.
+    if values == () or values == ("cross",):
+        if c_compiler.type == "gcc":
+            values += ("full",)
+        elif (
+            pgo_build
+            and moz_automation
+            and target.os in ("WINNT", "GNU")
+            and target.cpu == "x86_64"
+        ):
+            values += ("full",)
+        else:
+            values += ("thin",)
+
+    if instrumented_build:
+        log.warning("Disabling LTO because --enable-profile-generate is specified")
+        return
+
+    if c_compiler.type == "gcc":
+        if "cross" in values:
+            die("Cross-language LTO is not supported with GCC.")
+        if "thin" in values:
+            die(
+                "gcc does not support thin LTO. Use `--enable-lto` "
+                "to enable full LTO for gcc."
+            )
+
+    if (
+        target.kernel == "Darwin"
+        and target.os == "OSX"
+        and "cross" in values
+        and select_linker.KIND == "ld64"
+        and not ld64_known_good
+    ):
+        die(
+            "The Mac linker is known to have a bug that affects cross-language "
+            "LTO.  If you know that your linker is free from this bug, please "
+            "set the environment variable `MOZ_LD64_KNOWN_GOOD=1` and re-run "
+            "configure."
+        )
+
+    if c_compiler.type == "clang":
+        if "full" in values:
+            cflags.append("-flto")
+            ldflags.append("-flto")
+        else:
+            cflags.append("-flto=thin")
+            ldflags.append("-flto=thin")
+
+        if target.os == "Android" and "cross" in values:
+            # Work around https://github.com/rust-lang/rust/issues/90088
+            # by enabling the highest level of SSE the rust targets default
+            # to.
+            # https://github.com/rust-lang/rust/blob/bdfcb88e8b6203ccb46a2fb6649979b773efc8ac/compiler/rustc_target/src/spec/i686_linux_android.rs#L13
+            # https://github.com/rust-lang/rust/blob/8d1083e319841624f64400e1524805a40d725439/compiler/rustc_target/src/spec/x86_64_linux_android.rs#L7
+            if target.cpu == "x86":
+                ldflags.append("-Wl,-plugin-opt=-mattr=+ssse3")
+            elif target.cpu == "x86_64":
+                ldflags.append("-Wl,-plugin-opt=-mattr=+sse4.2")
+    elif c_compiler.type == "clang-cl":
+        if "full" in values:
+            cflags.append("-flto")
+        else:
+            cflags.append("-flto=thin")
+        # With clang-cl, -flto can only be used with -c or -fuse-ld=lld.
+        # AC_TRY_LINKs during configure don't have -c, so pass -fuse-ld=lld.
+        cflags.append("-fuse-ld=lld")
+
+        # Explicitly set the CPU to optimize for so the linker doesn't
+        # choose a poor default.  Rust compilation by default uses the
+        # pentium4 CPU on x86:
+        #
+        # https://github.com/rust-lang/rust/blob/049a49b91151a88c95fa0d62a53fd0a0ac2c3af9/compiler/rustc_target/src/spec/i686_pc_windows_msvc.rs#L5
+        #
+        # which specifically supports "long" (multi-byte) nops.  See
+        # https://bugzilla.mozilla.org/show_bug.cgi?id=1568450#c8 for details.
+        #
+        # The pentium4 seems like kind of a weird CPU to optimize for, but
+        # it seems to have worked out OK thus far.  LLVM does not seem to
+        # specifically schedule code for the pentium4's deep pipeline, so
+        # that probably contributes to it being an OK default for our
+        # purposes.
+        if target.cpu == "x86":
+            ldflags.append("-mllvm:-mcpu=pentium4")
+        # This is also the CPU that Rust uses.  The LLVM source code
+        # recommends this as the "generic 64-bit specific x86 processor model":
+        #
+        # https://github.com/llvm/llvm-project/blob/e7694f34ab6a12b8bb480cbfcb396d0a64fe965f/llvm/lib/Target/X86/X86.td#L1165-L1187
+        if target.cpu == "x86_64":
+            ldflags.append("-mllvm:-mcpu=x86-64")
+        # We do not need special flags for arm64.  Hooray for fixed-length
+        # instruction sets.
+    else:
+        num_cores = multiprocessing.cpu_count()
+        cflags.append("-flto")
+        cflags.append("-flifetime-dse=1")
+
+        ldflags.append("-flto=%s" % num_cores)
+        ldflags.append("-flifetime-dse=1")
+
+    # Tell LTO not to inline functions above a certain size, to mitigate
+    # binary size growth while still getting good performance.
+    # (For hot functions, PGO will put a multiplier on this limit.)
+    if target.os == "WINNT":
+        ldflags.append("-mllvm:-import-instr-limit=10")
+    elif target.os == "OSX":
+        ldflags.append("-Wl,-mllvm,-import-instr-limit=10")
+    elif c_compiler.type == "clang":
+        ldflags.append("-Wl,-plugin-opt=-import-instr-limit=10")
+
+    # If we're using the new pass manager, we can also enable the new PM
+    # during LTO. Further we can use the resulting size savings to increase
+    # the import limit in hot functions.
+    if pass_manager:
+        if target.os == "WINNT":
+            if c_compiler.version >= "12.0.0" and c_compiler.version < "13.0.0":
+                ldflags.append("-opt:ltonewpassmanager")
+            if c_compiler.version >= "12.0.0":
+                ldflags.append("-mllvm:-import-hot-multiplier=30")
+        elif target.os == "OSX":
+            ldflags.append("-Wl,-mllvm,-import-hot-multiplier=30")
+        else:
+            if c_compiler.version < "13.0.0":
+                ldflags.append("-Wl,-plugin-opt=new-pass-manager")
+            ldflags.append("-Wl,-plugin-opt=-import-hot-multiplier=30")
+
+    # Pick Rust LTO mode in case of cross lTO. Thin is the default.
+    if "cross" in values:
+        rust_lto = "full" if "full" in values else "thin"
+    else:
+        rust_lto = ""
+
+    return namespace(
+        enabled=True,
+        cflags=cflags,
+        ldflags=ldflags,
+        rust_lto=rust_lto,
+    )
+
+
+add_old_configure_assignment("MOZ_LTO", lto.enabled)
+set_config("MOZ_LTO", lto.enabled)
+set_define("MOZ_LTO", lto.enabled)
+set_config("MOZ_LTO_CFLAGS", lto.cflags)
+set_config("MOZ_LTO_LDFLAGS", lto.ldflags)
+set_config("MOZ_LTO_RUST_CROSS", lto.rust_lto)
+add_old_configure_assignment("MOZ_LTO_CFLAGS", lto.cflags)
+add_old_configure_assignment("MOZ_LTO_LDFLAGS", lto.ldflags)
diff --git a/build/moz.configure/memory.configure b/build/moz.configure/memory.configure
new file mode 100644
index 0000000000..4368ad8c86
--- /dev/null
+++ b/build/moz.configure/memory.configure
@@ -0,0 +1,120 @@
+# -*- 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/.
+
+
+@depends(target, js_package)
+def jemalloc_default(target, js_package):
+    if js_package:
+        return False
+    return target.kernel in ("Darwin", "Linux", "WINNT")
+
+
+option(
+    "--enable-jemalloc",
+    env="MOZ_MEMORY",
+    default=jemalloc_default,
+    help="{Replace|Do not replace} memory allocator with jemalloc",
+)
+
+
+set_config("MOZ_MEMORY", True, when="--enable-jemalloc")
+set_define("MOZ_MEMORY", True, when="--enable-jemalloc")
+add_old_configure_assignment("MOZ_MEMORY", True, when="--enable-jemalloc")
+
+
+@depends(milestone, build_project)
+def replace_malloc_default(milestone, build_project):
+    if build_project == "memory":
+        return True
+    if milestone.is_early_beta_or_earlier and build_project != "js":
+        return True
+
+
+option(
+    "--enable-replace-malloc",
+    default=replace_malloc_default,
+    when="--enable-jemalloc",
+    help="{Enable|Disable} ability to dynamically replace the malloc implementation",
+)
+
+
+set_config("MOZ_REPLACE_MALLOC", True, when="--enable-replace-malloc")
+set_define("MOZ_REPLACE_MALLOC", True, when="--enable-replace-malloc")
+
+
+@depends(build_project, when="--enable-replace-malloc")
+def replace_malloc_static(build_project):
+    # Default to statically linking replace-malloc libraries that can be
+    # statically linked, except when building with --enable-project=memory.
+    if build_project != "memory":
+        return True
+
+
+set_config("MOZ_REPLACE_MALLOC_STATIC", replace_malloc_static)
+
+# PHC (Probabilistic Heap Checker)
+# ==============================================================
+
+
+# In general, it only makes sense for PHC to run on the platforms that have a
+# crash reporter.
+@depends(
+    build_project,
+    target,
+    when="--enable-jemalloc",
+)
+def phc_default(build_project, target):
+    if build_project == "js":
+        return False
+
+    # Both Linux32 and Win32 have frequent crashes when stack tracing (for
+    # unclear reasons), so PHC is enabled only on 64-bit only in both cases.
+    return (target.cpu in ("x86_64", "aarch64")) and (
+        (target.os == "GNU" and target.kernel == "Linux")
+        or (target.kernel == "WINNT")
+        or (target.os == "OSX")
+    )
+
+
+option(
+    "--enable-phc",
+    env="MOZ_PHC",
+    default=phc_default,
+    when="--enable-jemalloc",
+    help="{Enable|Disable} PHC (Probabilistic Memory Checker). "
+    "Also enables frame pointers when needed",
+)
+
+set_config("MOZ_PHC", True, when="--enable-phc")
+
+
+# PHC parses stacks using frame pointers on these systems.
+@depends("--enable-phc", target, have_unwind, when="--enable-jemalloc")
+def phc_implies_frame_pointers(phc, target, have_unwind):
+    if not phc:
+        return False
+
+    # This should be kept in sync with the ifdefs in memory/build/PHC.cpp
+    # that control stack walking.
+    # This is true for the first two options in PHC.cpp
+    if (target.os == "WINNT" and target.cpu == "x86") or target.kernel == "Darwin":
+        return True
+
+    # This should match the #defines in mozglue/misc/StackWalk.cpp
+    if (target.cpu in ("x86", "ppc")) and (target.kernel in ("Darwin", "Linux")):
+        return not have_unwind
+
+    return False
+
+
+imply_option("--enable-frame-pointers", True, when=phc_implies_frame_pointers)
+
+
+with only_when(depends(target.os)(lambda os: os != "WINNT")):
+    set_define("HAVE_STRNDUP", check_symbol("strndup"))
+    set_define("HAVE_POSIX_MEMALIGN", check_symbol("posix_memalign"))
+    set_define("HAVE_MEMALIGN", check_symbol("memalign"))
+    set_define("HAVE_MALLOC_USABLE_SIZE", check_symbol("malloc_usable_size"))
diff --git a/build/moz.configure/node.configure b/build/moz.configure/node.configure
new file mode 100644
index 0000000000..66668e7861
--- /dev/null
+++ b/build/moz.configure/node.configure
@@ -0,0 +1,90 @@
+# -*- 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/.
+
+option("--disable-nodejs", help="Require Node.js to build")
+option(env="NODEJS", nargs=1, help="Path to nodejs")
+
+
+@depends(
+    "--enable-nodejs",
+    "NODEJS",
+    bootstrap_search_path("node", when=depends("NODEJS")(lambda x: not x)),
+    host,
+)
+@checking(
+    "for nodejs", callback=lambda x: "%s (%s)" % (x.path, x.str_version) if x else "no"
+)
+@imports(_from="mozbuild.nodeutil", _import="find_node_executable")
+@imports(_from="mozbuild.nodeutil", _import="NODE_MIN_VERSION")
+@imports(_from="__builtin__", _import="OSError")
+@imports("errno")
+def nodejs(require, env_node, search_path, host):
+    # We don't use the dependency directly, but having it ensures the
+    # auto-upgrade code in bootstrap_search_path is triggered, while
+    # find_node_executable will use more or less the same search path.
+    # We do however need to use the variable for the configure lint
+    # not to fail.
+    search_path
+
+    node_exe = env_node[0] if env_node else None
+
+    try:
+        nodejs, version = find_node_executable(node_exe)
+    except OSError as e:
+        if host.cpu == "aarch64" and host.os == "OSX" and e.errno == errno.EBADARCH:
+            # Ideally we'd do it when --enable-bootstrap is set, but when we're wrapped in
+            # mach build or mach configure, running the command doesn't print anything and
+            # waits on input (for license agreement) that it can't actually get.
+            # mach bootstrap should have taken care of it anyways, but in case it hasn't,
+            # it's simpler to ask to run the rosetta install than the whole mach bootstrap.
+            die(
+                "Rosetta is needed to run node. Please run `softwareupdate --install-rosetta`"
+            )
+        raise
+
+    MAYBE_FILE_A_BUG = """
+
+    Executing `mach bootstrap --no-system-changes` should
+    install a compatible version in ~/.mozbuild on most platforms.
+    If you believe this is a bug, <https://mzl.la/2vLbXAv> is a good way
+    to file.  More details: <https://bit.ly/2BbyD1E>
+    """
+
+    if not nodejs:
+        msg = (
+            "could not find Node.js executable later than %s; ensure "
+            "`node` or `nodejs` is in PATH or set NODEJS in environment "
+            "to point to an executable.%s" % (NODE_MIN_VERSION, MAYBE_FILE_A_BUG)
+        )
+
+        if require:
+            raise FatalCheckError(msg)
+        else:
+            log.warning(msg)
+            log.warning("(This will become an error in the near future.)")
+            return
+
+    if not version:
+        msg = "NODEJS must point to node %s or newer; found node location: %s. %s" % (
+            NODE_MIN_VERSION,
+            nodejs,
+            MAYBE_FILE_A_BUG,
+        )
+
+        if require:
+            raise FatalCheckError(msg)
+        else:
+            log.warning(msg)
+            return
+
+    return namespace(
+        path=nodejs,
+        version=version,
+        str_version=".".join(str(v) for v in version),
+    )
+
+
+set_config("NODEJS", depends_if(nodejs)(lambda p: p.path))
diff --git a/build/moz.configure/nspr.configure b/build/moz.configure/nspr.configure
new file mode 100644
index 0000000000..182a508b73
--- /dev/null
+++ b/build/moz.configure/nspr.configure
@@ -0,0 +1,116 @@
+# -*- 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/.
+
+# Top-level configure defaults to building NSPR from source. Standalone JS
+# doesn't.
+option(
+    "--enable-nspr-build",
+    when=js_standalone,
+    help="{Build|Do not build} NSPR from source tree",
+)
+
+
+@depends("--enable-nspr-build", when=js_standalone)
+def enable_nspr_build(enable):
+    if enable:
+        return enable
+
+
+system_lib_option("--with-system-nspr", help="Use system NSPR")
+
+
+@depends(enable_nspr_build, "--with-system-nspr", js_standalone)
+def build_nspr(nspr_build, system_nspr, js_standalone):
+    if nspr_build is not None and nspr_build.origin != "default":
+        if nspr_build and system_nspr:
+            die("Cannot use both --enable-nspr-build and --with-system-nspr")
+    if js_standalone:
+        return nspr_build
+    return not system_nspr
+
+
+set_config("MOZ_BUILD_NSPR", True, when=build_nspr)
+set_config("MOZ_SYSTEM_NSPR", True, when="--with-system-nspr")
+
+
+@depends(build_nspr, "--with-system-nspr", js_standalone)
+def js_without_nspr(build_nspr, system_nspr, js_standalone):
+    if js_standalone:
+        return not build_nspr and not system_nspr
+
+
+set_config("JS_WITHOUT_NSPR", True, when=js_without_nspr)
+set_define("JS_WITHOUT_NSPR", True, when=js_without_nspr)
+
+
+@depends(js_standalone)
+def nspr_minver(js_standalone):
+    if js_standalone:
+        return "nspr >= 4.10"
+    return "nspr >= 4.32"
+
+
+nspr_pkg = pkg_check_modules("NSPR", nspr_minver, when="--with-system-nspr")
+
+
+@depends_if(nspr_pkg)
+def nspr_pkg(nspr_pkg):
+    def extract(prefix, list):
+        for item in list:
+            if item.startswith(prefix):
+                return item[len(prefix) :]
+        return ""
+
+    include_dir = extract("-I", nspr_pkg.cflags)
+    lib_dir = extract("-L", nspr_pkg.libs)
+    return namespace(
+        cflags=nspr_pkg.cflags,
+        include_dir=include_dir,
+        libs=nspr_pkg.libs,
+        lib_dir=lib_dir,
+    )
+
+
+@depends("--with-system-nspr", nspr_minver)
+def pkgconf_requires_private(system_nspr, nspr_minver):
+    if not system_nspr:
+        return ""
+    return "Requires.private: %s" % nspr_minver
+
+
+set_config("PKGCONF_REQUIRES_PRIVATE", pkgconf_requires_private)
+
+
+# pkg_check_modules takes care of NSPR_CFLAGS and NSPR_LIBS when using --with-system-nspr.
+@depends(build_environment, c_compiler, fold_libs, when=build_nspr)
+def nspr_config(build_env, c_compiler, fold_libs):
+    libs = ["nspr4", "plc4", "plds4"]
+    if c_compiler.type == "clang-cl":
+        lib_dir = os.path.join(build_env.dist, "lib")
+        libs = [os.path.join(lib_dir, "%s.lib" % lib) for lib in libs]
+    else:
+        lib_dir = os.path.join(build_env.dist, "lib" if fold_libs else "bin")
+        libs = ["-L%s" % lib_dir] + ["-l%s" % lib for lib in libs]
+
+    include_dir = os.path.join(build_env.dist, "include", "nspr")
+    return namespace(
+        cflags=["-I%s" % include_dir],
+        include_dir=include_dir,
+        libs=libs,
+        lib_dir=lib_dir,
+    )
+
+
+set_config("NSPR_CFLAGS", nspr_config.cflags, when=nspr_config)
+set_config("NSPR_LIBS", nspr_config.libs, when=nspr_config)
+
+set_config("NSPR_INCLUDE_DIR", nspr_config.include_dir, when=nspr_config)
+set_config("NSPR_LIB_DIR", nspr_config.lib_dir, when=nspr_config)
+set_config("NSPR_INCLUDE_DIR", nspr_pkg.include_dir, when=nspr_pkg)
+set_config("NSPR_LIB_DIR", nspr_pkg.lib_dir, when=nspr_pkg)
+
+add_old_configure_assignment("NSPR_LIBS", nspr_config.libs, when=nspr_config)
+add_old_configure_assignment("NSPR_LIBS", nspr_pkg.libs, when=nspr_pkg)
diff --git a/build/moz.configure/nss.configure b/build/moz.configure/nss.configure
new file mode 100644
index 0000000000..9e4802774a
--- /dev/null
+++ b/build/moz.configure/nss.configure
@@ -0,0 +1,29 @@
+# -*- 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/.
+
+system_lib_option("--with-system-nss", help="Use system NSS")
+
+imply_option("--with-system-nspr", True, when="--with-system-nss")
+
+nss_pkg = pkg_check_modules(
+    "NSS", "nss >= 3.98", when="--with-system-nss", config=False
+)
+
+set_config("MOZ_SYSTEM_NSS", True, when="--with-system-nss")
+
+
+@depends(nss_pkg, build_environment)
+def nss_config(nss_pkg, build_env):
+    cflags = ["-I%s" % os.path.join(build_env.dist, "include", "nss")]
+    libs = None
+    if nss_pkg:
+        cflags = list(nss_pkg.cflags) + cflags
+        libs = nss_pkg.libs
+    return namespace(cflags=cflags, libs=libs)
+
+
+set_config("NSS_CFLAGS", nss_config.cflags)
+set_config("NSS_LIBS", nss_config.libs)
diff --git a/build/moz.configure/old.configure b/build/moz.configure/old.configure
new file mode 100644
index 0000000000..a37fd265a2
--- /dev/null
+++ b/build/moz.configure/old.configure
@@ -0,0 +1,394 @@
+# -*- 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/.
+
+
+m4 = check_prog(
+    "M4",
+    (
+        "gm4",
+        "m4",
+    ),
+    paths=prefer_mozillabuild_path,
+)
+
+
+@depends(mozconfig)
+def prepare_mozconfig(mozconfig):
+    if mozconfig["path"]:
+        items = {}
+        for key, value in mozconfig["vars"]["added"].items():
+            items[key] = (value, "added")
+        for key, (old, value) in mozconfig["vars"]["modified"].items():
+            items[key] = (value, "modified")
+        for t in ("env", "vars"):
+            for key in mozconfig[t]["removed"].keys():
+                items[key] = (None, "removed " + t)
+        return items
+
+
+@depends("OLD_CONFIGURE", build_project)
+def old_configure(old_configure, build_project):
+    if not old_configure:
+        die("The OLD_CONFIGURE environment variable must be set")
+
+    # os.path.abspath in the sandbox will ensure forward slashes on Windows,
+    # which is actually necessary because this path actually ends up literally
+    # as $0, and backslashes there breaks autoconf's detection of the source
+    # directory.
+    old_configure = os.path.abspath(old_configure[0])
+    if build_project == "js":
+        old_configure_dir = os.path.dirname(old_configure)
+        if not old_configure_dir.endswith("/js/src"):
+            old_configure = os.path.join(
+                old_configure_dir, "js", "src", os.path.basename(old_configure)
+            )
+    return old_configure
+
+
+@depends(prepare_mozconfig, old_configure_assignments)
+@imports(_from="__builtin__", _import="open")
+@imports(_from="__builtin__", _import="print")
+@imports(_from="mozbuild.shellutil", _import="quote")
+def prepare_configure(mozconfig, old_configure_assignments):
+    assignments = {}
+
+    with open("old-configure.vars", "w") as out:
+        log.debug("Injecting the following to old-configure:")
+
+        def inject(command):
+            print(command, file=out)  # noqa Python 2vs3
+            log.debug("| %s", command)
+
+        if mozconfig:
+            inject("# start of mozconfig values")
+            for key, (value, action) in sorted(mozconfig.items()):
+                if action.startswith("removed "):
+                    inject("unset %s # from %s" % (key, action[len("removed ") :]))
+                else:
+                    inject("%s=%s # %s" % (key, quote(value), action))
+                    assignments[key] = value
+
+            inject("# end of mozconfig values")
+
+        for k, v in old_configure_assignments:
+            inject("%s=%s" % (k, quote(v)))
+            assignments[k] = v
+
+    return namespace(assignments=assignments)
+
+
+@template
+def old_configure_options(*options):
+    for opt in options:
+        option(opt, nargs="*", help="Help missing for old configure options")
+
+    @dependable
+    def all_options():
+        return list(options)
+
+    return depends(
+        host_for_sub_configure, target_for_sub_configure, all_options, *options
+    )
+
+
+@old_configure_options(
+    "--cache-file",
+    "--datadir",
+    "--enable-official-branding",
+    "--includedir",
+    "--libdir",
+    "--prefix",
+    "--with-branding",
+    "--with-distribution-id",
+    "--with-macbundlename-prefix",
+    "--x-includes",
+    "--x-libraries",
+)
+def prepare_configure_options(host, target, all_options, *options):
+    # old-configure only supports the options listed in @old_configure_options
+    # so we don't need to pass it every single option we've been passed. Only
+    # the ones that are not supported by python configure need to.
+    options = [
+        value.format(name)
+        for name, value in zip(all_options, options)
+        if value.origin != "default"
+    ] + [host, target]
+
+    return namespace(options=options, all_options=all_options)
+
+
+@template
+def old_configure_for(old_configure_path, extra_env=None):
+    if extra_env is None:
+        extra_env = dependable(None)
+
+    @depends(
+        prepare_configure,
+        prepare_configure_options,
+        prefer_mozillabuild_path,
+        altered_path,
+        extra_env,
+        build_environment,
+        old_configure_path,
+        awk,
+        m4,
+        shell,
+        "--cache-file",
+    )
+    @imports(_from="__builtin__", _import="compile")
+    @imports(_from="__builtin__", _import="open")
+    @imports(_from="__builtin__", _import="OSError")
+    @imports("glob")
+    @imports("itertools")
+    @imports("logging")
+    @imports("os")
+    @imports("re")
+    @imports("subprocess")
+    @imports("sys")
+    @imports(_from="mozbuild.shellutil", _import="quote")
+    @imports(_from="mozbuild.shellutil", _import="split")
+    @imports(_from="tempfile", _import="NamedTemporaryFile")
+    @imports(_from="subprocess", _import="CalledProcessError")
+    @imports(_from="__builtin__", _import="exec")
+    def old_configure(
+        prepare_configure,
+        prepare_configure_options,
+        prefer_mozillabuild_path,
+        altered_path,
+        extra_env,
+        build_env,
+        old_configure,
+        awk,
+        m4,
+        shell,
+        cache_file_option,
+    ):
+        if altered_path:
+            path = altered_path
+        else:
+            path = os.pathsep.join(prefer_mozillabuild_path)
+
+        cxx = prepare_configure.assignments.get("CXX")
+        cc = prepare_configure.assignments.get("CC")
+
+        if cc and cxx:
+            if cache_file_option:
+                config_cache = cache_file_option[0]
+            else:
+                config_cache = "config.cache"
+
+            if os.path.exists(config_cache):
+                remove = False
+                with open(config_cache, "r") as cfg_cache:
+                    cxx_pattern = re.compile(
+                        r"^ac_cv_prog_CXX=\${ac_cv_prog_CXX='(.*)'}$"
+                    )
+                    cc_pattern = re.compile(r"^ac_cv_prog_CC=\${ac_cv_prog_CC='(.*)'}$")
+                    for line in cfg_cache:
+                        m = cc_pattern.match(line)
+                        if m and m.group(1) != cc:
+                            remove = True
+                            break
+                        m = cxx_pattern.match(line)
+                        if m and m.group(1) != cxx:
+                            remove = True
+                            break
+
+                if remove:
+                    log.info("invalidating config.cache")
+                    os.remove(config_cache)
+
+        refresh = True
+        if os.path.exists(old_configure):
+            mtime = os.path.getmtime(old_configure)
+            aclocal = os.path.join(build_env.topsrcdir, "build", "autoconf", "*.m4")
+            for input in itertools.chain(
+                (
+                    old_configure + ".in",
+                    os.path.join(os.path.dirname(old_configure), "aclocal.m4"),
+                ),
+                glob.iglob(aclocal),
+            ):
+                if os.path.getmtime(input) > mtime:
+                    break
+            else:
+                refresh = False
+
+        if refresh:
+            autoconf = os.path.join(
+                build_env.topsrcdir, "build", "autoconf", "autoconf.sh"
+            )
+            log.info("Refreshing %s with %s", old_configure, autoconf)
+            env = dict(os.environ)
+            env["M4"] = m4
+            env["AWK"] = awk
+            env["AC_MACRODIR"] = os.path.join(build_env.topsrcdir, "build", "autoconf")
+            env["PATH"] = path
+
+            try:
+                script = subprocess.check_output(
+                    [
+                        shell,
+                        autoconf,
+                        "--localdir=%s" % os.path.dirname(old_configure),
+                        old_configure + ".in",
+                    ],
+                    # Fix the working directory, so that when m4 is called, that
+                    # includes of relative paths are deterministically resolved
+                    # relative to the directory containing old-configure.
+                    cwd=os.path.dirname(old_configure),
+                    env=env,
+                )
+            except CalledProcessError as exc:
+                die("autoconf exited with return code {}".format(exc.returncode))
+
+            if not script:
+                die(
+                    "Generated old-configure is empty! Check that your autoconf 2.13 program works!"
+                )
+
+            # Make old-configure append to config.log, where we put our own log.
+            # This could be done with a m4 macro, but it's way easier this way
+            script = script.replace(b">./config.log", b">>${CONFIG_LOG=./config.log}")
+
+            with NamedTemporaryFile(
+                mode="wb",
+                prefix=os.path.basename(old_configure),
+                dir=os.path.dirname(old_configure),
+                delete=False,
+            ) as fh:
+                fh.write(script)
+
+            try:
+                os.rename(fh.name, old_configure)
+            except OSError:
+                try:
+                    # Likely the file already existed (on Windows). Retry after removing it.
+                    os.remove(old_configure)
+                    os.rename(fh.name, old_configure)
+                except OSError as e:
+                    die("Failed re-creating old-configure: %s" % e.message)
+
+        cmd = [shell, old_configure] + prepare_configure_options.options
+
+        env = dict(os.environ)
+
+        # For debugging purpose, in case it's not what we'd expect.
+        log.debug("Running %s", quote(*cmd))
+
+        # Our logging goes to config.log, the same file old.configure uses.
+        # We can't share the handle on the file, so close it.
+        logger = logging.getLogger("moz.configure")
+        config_log = None
+        for handler in logger.handlers:
+            if isinstance(handler, logging.FileHandler):
+                config_log = handler
+                config_log.close()
+                logger.removeHandler(config_log)
+                env["CONFIG_LOG"] = config_log.baseFilename
+                log_size = os.path.getsize(config_log.baseFilename)
+                break
+
+        env["PATH"] = path
+
+        if extra_env:
+            env.update(extra_env)
+
+        env["OLD_CONFIGURE_VARS"] = os.path.join(
+            build_env.topobjdir, "old-configure.vars"
+        )
+        proc = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env
+        )
+        while True:
+            line = proc.stdout.readline()
+            if not line:
+                break
+            log.info(line.rstrip())
+
+        ret = proc.wait()
+        if ret:
+            with log.queue_debug():
+                if config_log:
+                    with open(config_log.baseFilename, "r") as fh:
+                        fh.seek(log_size)
+                        for line in fh:
+                            log.debug(line.rstrip())
+                log.error("old-configure failed")
+            sys.exit(ret)
+
+        if config_log:
+            # Create a new handler in append mode
+            handler = logging.FileHandler(config_log.baseFilename, mode="a", delay=True)
+            handler.setFormatter(config_log.formatter)
+            logger.addHandler(handler)
+
+        raw_config = {
+            "split": split,
+            "unique_list": unique_list,
+        }
+        with open("config.data", "r") as fh:
+            code = compile(fh.read(), "config.data", "exec")
+            exec(code, raw_config)
+
+        # Ensure all the flags known to old-configure appear in the
+        # @old_configure_options above.
+        all_options = set(prepare_configure_options.all_options)
+        for flag in raw_config["flags"]:
+            if flag not in all_options:
+                die(
+                    "Missing option in `@old_configure_options` in %s: %s",
+                    __file__,
+                    flag,
+                )
+
+        # If the code execution above fails, we want to keep the file around for
+        # debugging.
+        os.remove("config.data")
+
+        return namespace(
+            **{
+                c: [
+                    (k[1:-1], v[1:-1] if isinstance(v, str) else v)
+                    for k, v in raw_config[c]
+                    # Eventually we'll want to filter out all lowercase keys. (bug 1869127)
+                    # For now, we only filter out the most problematic one that
+                    # we know is unused.
+                    if k != " target_cpu "
+                ]
+                for c in ("substs", "defines")
+            }
+        )
+
+    return old_configure
+
+
+old_configure = old_configure_for(old_configure)
+set_config("OLD_CONFIGURE_SUBSTS", old_configure.substs)
+set_config("OLD_CONFIGURE_DEFINES", old_configure.defines)
+
+
+# Assuming no other option is declared after this function, handle the
+# env options that were injected by mozconfig_options by creating dummy
+# Option instances and having the sandbox's CommandLineHelper handle
+# them. We only do so for options that haven't been declared so far,
+# which should be a proxy for the options that old-configure handles
+# and that we don't know anything about.
+@depends("--help")
+@imports("__sandbox__")
+@imports(_from="mozbuild.configure.options", _import="Option")
+def remaining_mozconfig_options(_):
+    helper = __sandbox__._helper
+    for arg in list(helper):
+        if helper._origins[arg] != "mozconfig":
+            continue
+        name = arg.split("=", 1)[0]
+        if name.isupper() and name not in __sandbox__._options:
+            option = Option(env=name, nargs="*", help=name)
+            helper.handle(option)
+
+
+# Please do not add anything after remaining_mozconfig_options()
diff --git a/build/moz.configure/pkg.configure b/build/moz.configure/pkg.configure
new file mode 100644
index 0000000000..6beed205f1
--- /dev/null
+++ b/build/moz.configure/pkg.configure
@@ -0,0 +1,210 @@
+# -*- 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/.
+
+
+@depends(toolchain_prefix, when=compile_environment)
+def pkg_config(prefixes):
+    return tuple("{}pkg-config".format(p) for p in (prefixes or ()) + ("",))
+
+
+pkg_config = check_prog(
+    "PKG_CONFIG",
+    pkg_config,
+    bootstrap=depends(when=target_sysroot.bootstrapped)(lambda: "pkgconf"),
+    allow_missing=True,
+    when=compile_environment
+    & depends(target.os)(lambda os: os not in ("WINNT", "OSX", "Android")),
+)
+
+
+@depends_if(pkg_config)
+@checking("for pkg-config version")
+def pkg_config_version(pkg_config):
+    return Version(check_cmd_output(pkg_config, "--version").rstrip())
+
+
+@depends_if(pkg_config)
+@checking("whether pkg-config is pkgconf")
+def is_pkgconf(pkg_config):
+    return "pkgconf " in check_cmd_output(pkg_config, "--about", onerror=lambda: "")
+
+
+@depends(is_pkgconf, pkg_config_version, target_sysroot.bootstrapped, when=pkg_config)
+def pkg_config_base_flags(is_pkgconf, pkg_config_version, target_sysroot_bootstrapped):
+    # pkgconf 1.7.4 changed the default on Windows to use --static, but
+    # that doesn't work for us.
+    # Note: the --shared flag is not available before pkgconf 1.7
+    flags = []
+    if is_pkgconf and pkg_config_version >= "1.7.4":
+        flags.append("--shared")
+    # When pkg-config is in /usr things work fine by default, but when
+    # it is not, it defines prefix to be something else than /usr, which
+    # won't match what the .pc files actually say, and won't work in
+    # sysroots.
+    if target_sysroot_bootstrapped and (
+        (is_pkgconf and pkg_config_version >= "1.2.0")
+        or (not is_pkgconf and pkg_config_version >= "0.29.0")
+    ):
+        flags.append("--dont-define-prefix")
+    return tuple(flags)
+
+
+@depends(target, target_sysroot.path, target_multiarch_dir, when=pkg_config)
+@imports(_from="os", _import="environ")
+@imports(_from="os", _import="pathsep")
+def pkg_config_vars(target, sysroot_path, multiarch_dir):
+    if sysroot_path and target.kernel != "Darwin":
+        pkgconfig_dirs = [
+            "usr/lib/pkgconfig",
+            "usr/lib/{}/pkgconfig".format(multiarch_dir),
+            "usr/share/pkgconfig",
+        ]
+        if target.bitness == 64:
+            pkgconfig_dirs.insert(0, "usr/lib64/pkgconfig")
+        return namespace(
+            PKG_CONFIG_PATH="",
+            PKG_CONFIG_SYSROOT_DIR=sysroot_path,
+            PKG_CONFIG_LIBDIR=pathsep.join(
+                os.path.join(sysroot_path, d) for d in pkgconfig_dirs
+            ),
+        )
+
+
+@depends(pkg_config_vars)
+@imports(_from="os", _import="environ")
+def pkg_config_env(vars):
+    if vars:
+        env = dict(environ)
+        env["PKG_CONFIG_PATH"] = vars.PKG_CONFIG_PATH
+        env["PKG_CONFIG_SYSROOT_DIR"] = vars.PKG_CONFIG_SYSROOT_DIR
+        env["PKG_CONFIG_LIBDIR"] = vars.PKG_CONFIG_LIBDIR
+        return env
+
+
+set_config("PKG_CONFIG_PATH", pkg_config_vars.PKG_CONFIG_PATH)
+set_config("PKG_CONFIG_SYSROOT_DIR", pkg_config_vars.PKG_CONFIG_SYSROOT_DIR)
+set_config("PKG_CONFIG_LIBDIR", pkg_config_vars.PKG_CONFIG_LIBDIR)
+
+
+# Locates the given module using pkg-config.
+# - `var` determines the name of variables to set when the package is found.
+#   <var>_CFLAGS and <var>_LIBS are set with corresponding values.
+# - `package_desc` package name and version requirement string, list of
+#   strings describing packages to locate, or depends function that will
+#   resolve to such a string or list of strings.
+# - `when` a depends function that will determine whether to perform
+#   any checks (default is to always perform checks).
+# - `allow_missing` If set, failure to fulfill the package description
+#   will not result in an error or logged message, and any error message
+#   will be returned to the caller.
+#   Returns `True` when the package description is fulfilled.
+@template
+def pkg_check_modules(
+    var, package_desc, when=always, allow_missing=False, config=True, cflags_only=False
+):
+    @depends(dependable(package_desc), when=when)
+    def package_desc(desc):
+        if isinstance(desc, str):
+            desc = [desc]
+        if not isinstance(desc, (tuple, list)):
+            configure_error(
+                "package_desc must be a string or a tuple or list of strings"
+            )
+
+        return " ".join(desc)
+
+    allow_missing = dependable(allow_missing)
+
+    @depends(when, "--enable-compile-environment")
+    def when_and_compile_environment(when, compile_environment):
+        return when and compile_environment
+
+    @depends(pkg_config, pkg_config_version, when=when_and_compile_environment)
+    def check_pkg_config(pkg_config, version):
+        min_version = "0.9.0"
+        if pkg_config is None:
+            die(
+                "*** The pkg-config script could not be found. Make sure it is\n"
+                "*** in your path, or set the PKG_CONFIG environment variable\n"
+                "*** to the full path to pkg-config."
+            )
+        if version < min_version:
+            die(
+                "*** Your version of pkg-config is too old. You need version %s or newer.",
+                min_version,
+            )
+
+    @depends(
+        pkg_config,
+        pkg_config_env,
+        package_desc,
+        allow_missing,
+        when=when_and_compile_environment,
+    )
+    @imports("sys")
+    @imports(_from="mozbuild.configure.util", _import="LineIO")
+    def package(pkg_config, env, package_desc, allow_missing):
+        # package_desc may start as a depends function, so we can't use
+        # @checking here.
+        log.info("checking for %s... " % package_desc)
+        retcode, stdout, stderr = get_cmd_output(
+            pkg_config,
+            "--errors-to-stdout",
+            "--print-errors",
+            package_desc,
+            env=env,
+        )
+        if retcode == 0:
+            log.info("yes")
+            return True
+        log.info("no")
+        log_writer = log.warning if allow_missing else log.error
+        with LineIO(lambda l: log_writer(l)) as o:
+            o.write(stdout)
+        if not allow_missing:
+            sys.exit(1)
+
+    @depends(
+        pkg_config, pkg_config_env, package_desc, pkg_config_base_flags, when=package
+    )
+    @checking("%s_CFLAGS" % var, callback=lambda t: " ".join(t))
+    def pkg_cflags(pkg_config, env, package_desc, base_flags):
+        args = list(base_flags) + ["--cflags", package_desc]
+        flags = check_cmd_output(pkg_config, *args, env=env)
+        return tuple(flags.split())
+
+    if cflags_only:
+
+        @depends(pkg_cflags, when=package)
+        def pkg_info(cflags):
+            return namespace(cflags=cflags)
+
+    else:
+
+        @depends(
+            pkg_config,
+            pkg_config_env,
+            package_desc,
+            pkg_config_base_flags,
+            when=package,
+        )
+        @checking("%s_LIBS" % var, callback=lambda t: " ".join(t))
+        def pkg_libs(pkg_config, env, package_desc, base_flags):
+            args = list(base_flags) + ["--libs", package_desc]
+            libs = check_cmd_output(pkg_config, *args, env=env)
+            # Remove evil flags like -Wl,--export-dynamic
+            return tuple(libs.replace("-Wl,--export-dynamic", "").split())
+
+        @depends(pkg_cflags, pkg_libs, when=package)
+        def pkg_info(cflags, libs):
+            return namespace(cflags=cflags, libs=libs)
+
+    if config:
+        set_config("%s_CFLAGS" % var, pkg_cflags)
+        if not cflags_only:
+            set_config("%s_LIBS" % var, pkg_libs)
+
+    return pkg_info
diff --git a/build/moz.configure/rust.configure b/build/moz.configure/rust.configure
new file mode 100644
index 0000000000..7a2fd1ae70
--- /dev/null
+++ b/build/moz.configure/rust.configure
@@ -0,0 +1,786 @@
+# -*- 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/.
+
+
+# Rust is required by `rust_compiler` below. We allow_missing here
+# to propagate failures to the better error message there.
+option(env="RUSTC", nargs=1, help="Path to the rust compiler")
+option(env="CARGO", nargs=1, help="Path to the Cargo package manager")
+
+rustc = check_prog(
+    "_RUSTC",
+    ["rustc"],
+    what="rustc",
+    paths=rust_search_path,
+    input="RUSTC",
+    allow_missing=True,
+)
+cargo = check_prog(
+    "_CARGO",
+    ["cargo"],
+    what="cargo",
+    paths=rust_search_path,
+    input="CARGO",
+    allow_missing=True,
+)
+
+
+@template
+def unwrap_rustup(prog, name):
+    # rustc and cargo can either be rustup wrappers, or they can be the actual,
+    # plain executables. For cargo, on OSX, rustup sets DYLD_LIBRARY_PATH (at
+    # least until https://github.com/rust-lang/rustup.rs/pull/1752 is merged
+    # and shipped) and that can wreak havoc (see bug 1536486). Similarly, for
+    # rustc, rustup silently honors toolchain overrides set by vendored crates
+    # (see bug 1547196).
+    #
+    # In either case, we need to find the plain executables.
+    #
+    # To achieve that, try to run `PROG +stable`. When the rustup wrapper is in
+    # use, it either prints PROG's help and exits with status 0, or prints
+    # an error message (error: toolchain 'stable' is not installed) and exits
+    # with status 1. In the cargo case, when plain cargo is in use, it exits
+    # with a different error message (e.g. "error: no such subcommand:
+    # `+stable`"), and exits with status 101.
+    #
+    # Unfortunately, in the rustc case, when plain rustc is in use,
+    # `rustc +stable` will exit with status 1, complaining about a missing
+    # "+stable" file. We'll examine the error output to try and distinguish
+    # between failing rustup and failing rustc.
+    @depends(prog, dependable(name))
+    @imports(_from="__builtin__", _import="open")
+    @imports("os")
+    def unwrap(prog, name):
+        if not prog:
+            return
+
+        def from_rustup_which():
+            out = check_cmd_output("rustup", "which", name, executable=prog).rstrip()
+            # If for some reason the above failed to return something, keep the
+            # PROG we found originally.
+            if out:
+                log.info("Actually using '%s'", out)
+                return out
+
+            log.info("No `rustup which` output, using '%s'", prog)
+            return prog
+
+        (retcode, stdout, stderr) = get_cmd_output(prog, "+stable")
+
+        if name == "cargo" and retcode != 101:
+            prog = from_rustup_which()
+        elif name == "rustc":
+            if retcode == 0:
+                prog = from_rustup_which()
+            elif "+stable" in stderr:
+                # PROG looks like plain `rustc`.
+                pass
+            else:
+                # Assume PROG looks like `rustup`. This case is a little weird,
+                # insofar as the user doesn't have the "stable" toolchain
+                # installed, but go ahead and unwrap anyway: the user might
+                # have only certain versions, beta, or nightly installed, and
+                # we'll catch invalid versions later.
+                prog = from_rustup_which()
+
+        return normalize_path(prog)
+
+    return unwrap
+
+
+rustc = unwrap_rustup(rustc, "rustc")
+cargo = unwrap_rustup(cargo, "cargo")
+
+
+set_config("CARGO", cargo)
+set_config("RUSTC", rustc)
+
+
+@depends_if(rustc)
+@checking("rustc version", lambda info: info.version)
+def rustc_info(rustc):
+    if not rustc:
+        return
+    out = check_cmd_output(rustc, "--version", "--verbose").splitlines()
+    info = dict((s.strip() for s in line.split(":", 1)) for line in out[1:])
+    return namespace(
+        version=Version(info.get("release", "0")),
+        commit=info.get("commit-hash", "unknown"),
+        host=info["host"],
+        llvm_version=Version(info.get("LLVM version", "0")),
+    )
+
+
+set_config(
+    "RUSTC_VERSION",
+    depends(rustc_info)(lambda info: str(info.version) if info else None),
+)
+
+
+set_config(
+    "RUSTC_LLVM_VERSION",
+    depends(rustc_info)(lambda info: str(info.llvm_version) if info else None),
+)
+
+set_config(
+    "MOZ_CLANG_NEWER_THAN_RUSTC_LLVM",
+    depends(c_compiler, rustc_info)(
+        lambda c_compiler, rustc_info: rustc_info
+        and c_compiler.type == "clang"
+        and c_compiler.version.major > rustc_info.llvm_version.major
+    ),
+)
+
+
+@depends_if(cargo)
+@checking("cargo version", lambda info: info.version)
+@imports("re")
+def cargo_info(cargo):
+    if not cargo:
+        return
+    out = check_cmd_output(cargo, "--version", "--verbose").splitlines()
+    info = dict((s.strip() for s in line.split(":", 1)) for line in out[1:])
+    version = info.get("release")
+    # Older versions of cargo didn't support --verbose, in which case, they
+    # only output a not-really-pleasant-to-parse output. Fortunately, they
+    # don't error out, so we can just try some regexp matching on the output
+    # we already got.
+    if version is None:
+        VERSION_FORMAT = r"^cargo (\d\.\d+\.\d+).*"
+
+        m = re.search(VERSION_FORMAT, out[0])
+        # Fail fast if cargo changes its output on us.
+        if not m:
+            die("Could not determine cargo version from output: %s", out)
+        version = m.group(1)
+
+    return namespace(
+        version=Version(version),
+    )
+
+
+@depends(rustc_info, cargo_info, target)
+@imports(_from="mozboot.util", _import="MINIMUM_RUST_VERSION")
+@imports(_from="textwrap", _import="dedent")
+def rust_compiler(rustc_info, cargo_info, target):
+    if not rustc_info:
+        die(
+            dedent(
+                """\
+        Rust compiler not found.
+        To compile rust language sources, you must have 'rustc' in your path.
+        See https://www.rust-lang.org/ for more information.
+
+        You can install rust by running './mach bootstrap'
+        or by directly running the installer from https://rustup.rs/
+        """
+            )
+        )
+    rustc_min_version = Version(MINIMUM_RUST_VERSION)
+    cargo_min_version = rustc_min_version
+
+    version = rustc_info.version
+    is_nightly = "nightly" in version.version
+    is_version_number_match = (
+        version.major == rustc_min_version.major
+        and version.minor == rustc_min_version.minor
+        and version.patch == rustc_min_version.patch
+    )
+
+    if version < rustc_min_version or (is_version_number_match and is_nightly):
+        die(
+            dedent(
+                """\
+        Rust compiler {} is too old.
+
+        To compile Rust language sources please install at least
+        version {} of the 'rustc' toolchain (or, if using nightly,
+        at least one version newer than {}) and make sure it is
+        first in your path.
+
+        You can verify this by typing 'rustc --version'.
+
+        If you have the 'rustup' tool installed you can upgrade
+        to the latest release by typing 'rustup update'. The
+        installer is available from https://rustup.rs/
+        """.format(
+                    version, rustc_min_version, rustc_min_version
+                )
+            )
+        )
+
+    if target.kernel == "WINNT" and (version.major, version.minor) == (1, 56):
+        die(
+            dedent(
+                """\
+        Rust compiler 1.56.* is not supported for Windows builds.
+
+        Use a newer or an older version.
+
+        See https://github.com/rust-lang/rust/issues/88576.
+        """
+            )
+        )
+
+    if not cargo_info:
+        die(
+            dedent(
+                """\
+        Cargo package manager not found.
+        To compile Rust language sources, you must have 'cargo' in your path.
+        See https://www.rust-lang.org/ for more information.
+
+        You can install cargo by running './mach bootstrap'
+        or by directly running the installer from https://rustup.rs/
+        """
+            )
+        )
+
+    version = cargo_info.version
+    if version < cargo_min_version:
+        die(
+            dedent(
+                """\
+        Cargo package manager {} is too old.
+
+        To compile Rust language sources please install at least
+        version {} of 'cargo' and make sure it is first in your path.
+
+        You can verify this by typing 'cargo --version'.
+        """
+            ).format(version, cargo_min_version)
+        )
+
+    return True
+
+
+@depends(rustc, when=rust_compiler)
+@imports(_from="__builtin__", _import="ValueError")
+def rust_supported_targets(rustc):
+    out = check_cmd_output(rustc, "--print", "target-list").splitlines()
+    data = {}
+    for t in out:
+        try:
+            info = split_triplet(t, allow_wasi=True)
+        except ValueError:
+            if t.startswith("thumb"):
+                cpu, rest = t.split("-", 1)
+                retry = "-".join(("arm", rest))
+            else:
+                continue
+            try:
+                info = split_triplet(retry, allow_wasi=True)
+            except ValueError:
+                continue
+        key = (info.cpu, info.endianness, info.os)
+        data.setdefault(key, []).append(namespace(rust_target=t, target=info))
+    return data
+
+
+def detect_rustc_target(
+    host_or_target, compiler_info, arm_target, rust_supported_targets
+):
+    # Rust's --target options are similar to, but not exactly the same
+    # as, the autoconf-derived targets we use.  An example would be that
+    # Rust uses distinct target triples for targetting the GNU C++ ABI
+    # and the MSVC C++ ABI on Win32, whereas autoconf has a single
+    # triple and relies on the user to ensure that everything is
+    # compiled for the appropriate ABI.  We need to perform appropriate
+    # munging to get the correct option to rustc.
+    # We correlate the autoconf-derived targets with the list of targets
+    # rustc gives us with --print target-list.
+    candidates = rust_supported_targets.get(
+        (host_or_target.cpu, host_or_target.endianness, host_or_target.os), []
+    )
+
+    def find_candidate(candidates):
+        if len(candidates) == 1:
+            return candidates[0].rust_target
+        elif not candidates:
+            return None
+
+        # We have multiple candidates. There are two cases where we can try to
+        # narrow further down using extra information from the build system.
+        # - For windows targets, correlate with the C compiler type
+        if host_or_target.kernel == "WINNT":
+            if host_or_target.abi:
+                if host_or_target.abi == "msvc":
+                    suffix = "windows-msvc"
+                elif host_or_target.abi == "mingw":
+                    suffix = "windows-gnu"
+            elif compiler_info.type in ("gcc", "clang"):
+                suffix = "windows-gnu"
+            else:
+                suffix = "windows-msvc"
+            narrowed = [
+                c for c in candidates if c.rust_target.endswith("-{}".format(suffix))
+            ]
+            if len(narrowed) == 1:
+                return narrowed[0].rust_target
+            elif narrowed:
+                candidates = narrowed
+
+            vendor_aliases = {"pc": ("w64", "windows")}
+            narrowed = [
+                c
+                for c in candidates
+                if host_or_target.vendor in vendor_aliases.get(c.target.vendor, ())
+            ]
+
+            if len(narrowed) == 1:
+                return narrowed[0].rust_target
+
+        # - For arm targets, correlate with arm_target
+        #   we could be more thorough with the supported rust targets, but they
+        #   don't support OSes that are supported to build Gecko anyways.
+        #   Also, sadly, the only interface to check the rust target cpu features
+        #   is --print target-spec-json, and it's unstable, so we have to rely on
+        #   our own knowledge of what each arm target means.
+        if host_or_target.cpu == "arm" and host_or_target.endianness == "little":
+            prefixes = []
+            if arm_target.arm_arch >= 7:
+                if arm_target.thumb2 and arm_target.fpu == "neon":
+                    prefixes.append("thumbv7neon")
+                if arm_target.thumb2:
+                    prefixes.append("thumbv7a")
+                prefixes.append("armv7")
+            if arm_target.arm_arch >= 6:
+                prefixes.append("armv6")
+                if host_or_target.os != "Android":
+                    # arm-* rust targets are armv6... except arm-linux-androideabi
+                    prefixes.append("arm")
+            if arm_target.arm_arch >= 5:
+                prefixes.append("armv5te")
+                if host_or_target.os == "Android":
+                    # arm-* rust targets are armv6... except arm-linux-androideabi
+                    prefixes.append("arm")
+            if arm_target.arm_arch >= 4:
+                prefixes.append("armv4t")
+            # rust freebsd targets are the only ones that don't have a 'hf' suffix
+            # for hard-float. Technically, that means if the float abi ever is not
+            # hard-float, this will pick a wrong target, but since rust only
+            # supports hard-float, let's assume that means freebsd only support
+            # hard-float.
+            if arm_target.float_abi == "hard" and host_or_target.os != "FreeBSD":
+                suffix = "hf"
+            else:
+                suffix = ""
+            for p in prefixes:
+                for c in candidates:
+                    if c.rust_target.startswith(
+                        "{}-".format(p)
+                    ) and c.rust_target.endswith(suffix):
+                        return c.rust_target
+
+        # See if we can narrow down on the exact alias.
+        # We use the sub_configure_alias to keep support mingw32 triplets as input.
+        narrowed = [
+            c
+            for c in candidates
+            if c.target.sub_configure_alias == host_or_target.sub_configure_alias
+        ]
+        if len(narrowed) == 1:
+            return narrowed[0].rust_target
+        elif narrowed:
+            candidates = narrowed
+
+        # See if we can narrow down with the raw OS
+        narrowed = [c for c in candidates if c.target.raw_os == host_or_target.raw_os]
+        if len(narrowed) == 1:
+            return narrowed[0].rust_target
+        elif narrowed:
+            candidates = narrowed
+
+        # See if we can narrow down with the raw OS and raw CPU
+        narrowed = [
+            c
+            for c in candidates
+            if c.target.raw_os == host_or_target.raw_os
+            and c.target.raw_cpu == host_or_target.raw_cpu
+        ]
+        if len(narrowed) == 1:
+            return narrowed[0].rust_target
+
+        # Finally, see if the vendor can be used to disambiguate.
+        narrowed = [c for c in candidates if c.target.vendor == host_or_target.vendor]
+        if len(narrowed) == 1:
+            return narrowed[0].rust_target
+
+        return None
+
+    rustc_target = find_candidate(candidates)
+
+    if rustc_target is None:
+        die("Don't know how to translate {} for rustc".format(host_or_target.alias))
+
+    return rustc_target
+
+
+@imports("os")
+@imports(_from="tempfile", _import="mkstemp")
+@imports(_from="textwrap", _import="dedent")
+@imports(_from="mozbuild.configure.util", _import="LineIO")
+def assert_rust_compile(host_or_target, rustc_target, rustc):
+    # Check to see whether our rustc has a reasonably functional stdlib
+    # for our chosen target.
+    target_arg = "--target=" + rustc_target
+    in_fd, in_path = mkstemp(prefix="conftest", suffix=".rs", text=True)
+    out_fd, out_path = mkstemp(prefix="conftest", suffix=".rlib")
+    os.close(out_fd)
+    try:
+        source = b'pub extern fn hello() { println!("Hello world"); }'
+        log.debug("Creating `%s` with content:", in_path)
+        with LineIO(lambda l: log.debug("| %s", l)) as out:
+            out.write(source)
+
+        os.write(in_fd, source)
+        os.close(in_fd)
+
+        cmd = [
+            rustc,
+            "--crate-type",
+            "staticlib",
+            target_arg,
+            "-o",
+            out_path,
+            in_path,
+        ]
+
+        def failed():
+            die(
+                dedent(
+                    """\
+            Cannot compile for {} with {}
+            The target may be unsupported, or you may not have
+            a rust std library for that target installed. Try:
+
+              rustup target add {}
+            """.format(
+                        host_or_target.alias, rustc, rustc_target
+                    )
+                )
+            )
+
+        check_cmd_output(*cmd, onerror=failed)
+        if not os.path.exists(out_path) or os.path.getsize(out_path) == 0:
+            failed()
+    finally:
+        os.remove(in_path)
+        os.remove(out_path)
+
+
+@depends(
+    rustc,
+    host,
+    host_c_compiler,
+    rustc_info.host,
+    rust_supported_targets,
+    arm_target,
+    when=rust_compiler,
+)
+@checking("for rust host triplet")
+@imports(_from="textwrap", _import="dedent")
+def rust_host_triple(
+    rustc, host, compiler_info, rustc_host, rust_supported_targets, arm_target
+):
+    rustc_target = detect_rustc_target(
+        host, compiler_info, arm_target, rust_supported_targets
+    )
+    if rustc_target != rustc_host:
+        if host.alias == rustc_target:
+            configure_host = host.alias
+        else:
+            configure_host = "{}/{}".format(host.alias, rustc_target)
+        die(
+            dedent(
+                """\
+        The rust compiler host ({rustc}) is not suitable for the configure host ({configure}).
+
+        You can solve this by:
+        * Set your configure host to match the rust compiler host by editing your
+        mozconfig and adding "ac_add_options --host={rustc}".
+        * Or, install the rust toolchain for {configure}, if supported, by running
+        "rustup default stable-{rustc_target}"
+        """.format(
+                    rustc=rustc_host,
+                    configure=configure_host,
+                    rustc_target=rustc_target,
+                )
+            )
+        )
+    assert_rust_compile(host, rustc_target, rustc)
+    return rustc_target
+
+
+@depends(
+    rustc, target, c_compiler, rust_supported_targets, arm_target, when=rust_compiler
+)
+@checking("for rust target triplet")
+def rust_target_triple(
+    rustc, target, compiler_info, rust_supported_targets, arm_target
+):
+    rustc_target = detect_rustc_target(
+        target, compiler_info, arm_target, rust_supported_targets
+    )
+    assert_rust_compile(target, rustc_target, rustc)
+    return rustc_target
+
+
+set_config("RUST_TARGET", rust_target_triple)
+set_config("RUST_HOST_TARGET", rust_host_triple)
+
+
+# This is used for putting source info into symbol files.
+set_config("RUSTC_COMMIT", depends(rustc_info)(lambda i: i.commit))
+
+# Rustdoc is required by Rust tests below.
+option(env="RUSTDOC", nargs=1, help="Path to the rustdoc program")
+
+rustdoc = check_prog(
+    "RUSTDOC",
+    ["rustdoc"],
+    paths=rust_search_path,
+    input="RUSTDOC",
+    allow_missing=True,
+)
+
+# This option is separate from --enable-tests because Rust tests are particularly
+# expensive in terms of compile time (especially for code in libxul).
+option(
+    "--enable-rust-tests",
+    help="Enable building and running of Rust tests during `make check`",
+)
+
+
+@depends("--enable-rust-tests", rustdoc)
+def rust_tests(enable_rust_tests, rustdoc):
+    if enable_rust_tests and not rustdoc:
+        die("--enable-rust-tests requires rustdoc")
+    return bool(enable_rust_tests)
+
+
+set_config("MOZ_RUST_TESTS", rust_tests)
+
+
+@depends(target, c_compiler, rustc)
+@imports("os")
+def rustc_natvis_ldflags(target, compiler_info, rustc):
+    if target.kernel == "WINNT" and compiler_info.type == "clang-cl":
+        sysroot = check_cmd_output(rustc, "--print", "sysroot").strip()
+        etc = os.path.join(sysroot, "lib/rustlib/etc")
+        ldflags = []
+        if os.path.isdir(etc):
+            for f in os.listdir(etc):
+                if f.endswith(".natvis"):
+                    ldflags.append("-NATVIS:" + normsep(os.path.join(etc, f)))
+        return ldflags
+
+
+set_config("RUSTC_NATVIS_LDFLAGS", rustc_natvis_ldflags)
+
+
+option(
+    "--enable-rust-debug",
+    default=depends(when="--enable-debug")(lambda: True),
+    help="{Build|Do not build} Rust code with debug assertions turned " "on.",
+)
+
+
+@depends(when="--enable-rust-debug")
+def debug_rust():
+    return True
+
+
+set_config("MOZ_DEBUG_RUST", debug_rust)
+set_define("MOZ_DEBUG_RUST", debug_rust)
+
+# ==============================================================
+
+option(env="RUSTFLAGS", nargs=1, help="Rust compiler flags")
+set_config("RUSTFLAGS", depends("RUSTFLAGS")(lambda flags: flags))
+
+
+# Rust compiler flags
+# ==============================================================
+
+
+@depends(moz_optimize)
+def rustc_opt_level_default(moz_optimize):
+    return "2" if moz_optimize.optimize else "0"
+
+
+option(
+    env="RUSTC_OPT_LEVEL",
+    default=rustc_opt_level_default,
+    nargs=1,
+    help="Rust compiler optimization level (-C opt-level=%s)",
+)
+
+
+@depends("RUSTC_OPT_LEVEL")
+def rustc_opt_level(opt_level_option):
+    return opt_level_option[0]
+
+
+set_config("CARGO_PROFILE_RELEASE_OPT_LEVEL", rustc_opt_level)
+set_config("CARGO_PROFILE_DEV_OPT_LEVEL", rustc_opt_level)
+
+
+@depends(
+    rustc_opt_level,
+    debug_rust,
+    target,
+    "--enable-debug-symbols",
+    "--enable-frame-pointers",
+    path_remapping,
+    path_remappings,
+)
+def rust_compile_flags(
+    opt_level,
+    debug_rust,
+    target,
+    debug_symbols,
+    frame_pointers,
+    path_remapping,
+    path_remappings,
+):
+    # Cargo currently supports only two interesting profiles for building:
+    # development and release. Those map (roughly) to --enable-debug and
+    # --disable-debug in Gecko, respectively.
+    #
+    # But we'd also like to support an additional axis of control for
+    # optimization level. Since Cargo only supports 2 profiles, we're in
+    # a bit of a bind.
+    #
+    # Code here derives various compiler options given other configure options.
+    # The options defined here effectively override defaults specified in
+    # Cargo.toml files.
+
+    debug_assertions = None
+    debug_info = None
+
+    # opt-level=0 implies -C debug-assertions, which may not be desired
+    # unless Rust debugging is enabled.
+    if opt_level == "0" and not debug_rust:
+        debug_assertions = False
+
+    if debug_symbols:
+        debug_info = "2"
+
+    opts = []
+
+    if debug_assertions is not None:
+        opts.append("debug-assertions=%s" % ("yes" if debug_assertions else "no"))
+    if debug_info is not None:
+        opts.append("debuginfo=%s" % debug_info)
+    if frame_pointers:
+        opts.append("force-frame-pointers=yes")
+    # CFG for arm64 is crashy, see `def security_hardening_cflags`.
+    if target.kernel == "WINNT" and target.cpu != "aarch64":
+        opts.append("control-flow-guard=yes")
+
+    flags = []
+    for opt in opts:
+        flags.extend(["-C", opt])
+
+    if "rust" in path_remapping:
+        # rustc has supported --remap-path-prefix since version 1.26, well
+        # before our required minimum Rust version, so there's no need to
+        # feature-detect or gate on versions.
+        for old, new in path_remappings:
+            flags.append(f"--remap-path-prefix={old}={new}")
+
+    return flags
+
+
+# Rust incremental compilation
+# ==============================================================
+
+
+option("--disable-cargo-incremental", help="Disable incremental rust compilation.")
+
+
+@depends(
+    developer_options,
+    debug_rust,
+    "MOZ_AUTOMATION",
+    code_coverage,
+    "--disable-cargo-incremental",
+    using_sccache,
+    "RUSTC_WRAPPER",
+)
+@imports("os")
+def cargo_incremental(
+    developer_options,
+    debug_rust,
+    automation,
+    code_coverage,
+    enabled,
+    using_sccache,
+    rustc_wrapper,
+):
+    """Return a value for the CARGO_INCREMENTAL environment variable."""
+
+    if not enabled:
+        return "0"
+    elif enabled.origin != "default":
+        return "1"
+
+    # We never want to use incremental compilation in automation.  sccache
+    # handles our automation use case much better than incremental compilation
+    # would.
+    if automation:
+        return "0"
+
+    # Coverage instrumentation doesn't play well with incremental compilation
+    # https://github.com/rust-lang/rust/issues/50203.
+    if code_coverage:
+        return "0"
+
+    # Incremental compilation doesn't work as well as it should, and if we're
+    # using sccache, it's better to use sccache than incremental compilation.
+    if not using_sccache and rustc_wrapper:
+        rustc_wrapper = os.path.basename(rustc_wrapper[0])
+        if os.path.splitext(rustc_wrapper)[0].lower() == "sccache":
+            using_sccache = True
+    if using_sccache:
+        return "0"
+
+    # Incremental compilation is automatically turned on for debug builds, so
+    # we don't need to do anything special here.
+    if debug_rust:
+        return
+
+    # Don't enable on --enable-release builds, because of the runtime
+    # performance cost.
+    if not developer_options:
+        return
+
+    # We're clear to use incremental compilation!
+    return "1"
+
+
+set_config("CARGO_INCREMENTAL", cargo_incremental)
+
+
+@depends(rust_compile_flags, "--enable-warnings-as-errors", rustc_info)
+def rust_flags(compile_flags, warnings_as_errors, rustc_info):
+    warning_flags = []
+
+    # Note that cargo passes --cap-lints warn to rustc for third-party code, so
+    # we don't need a very complicated setup.
+    if warnings_as_errors:
+        warning_flags.append("-Dwarnings")
+        # Work around https://github.com/rust-lang/rust/issues/84428
+        if rustc_info.version >= "1.52":
+            warning_flags.append("-Aproc-macro-back-compat")
+    else:
+        warning_flags.extend(("--cap-lints", "warn"))
+
+    return compile_flags + warning_flags
+
+
+set_config("MOZ_RUST_DEFAULT_FLAGS", rust_flags)
diff --git a/build/moz.configure/toolchain.configure b/build/moz.configure/toolchain.configure
new file mode 100644
index 0000000000..a8ab8bd698
--- /dev/null
+++ b/build/moz.configure/toolchain.configure
@@ -0,0 +1,3290 @@
+# -*- 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/.
+
+# Code optimization
+# ==============================================================
+
+option("--disable-optimize", nargs="?", help="Disable optimizations via compiler flags")
+
+
+@depends("--enable-optimize")
+def moz_optimize(option):
+    flags = None
+
+    if len(option):
+        flags = option[0]
+        if "-O0" in flags:
+            val = None
+        else:
+            val = "2"
+    elif option:
+        val = "1"
+    else:
+        val = None
+
+    return namespace(
+        optimize=val,
+        flags=flags,
+    )
+
+
+set_config("MOZ_OPTIMIZE", moz_optimize.optimize)
+add_old_configure_assignment("MOZ_OPTIMIZE", moz_optimize.optimize)
+add_old_configure_assignment("MOZ_CONFIGURE_OPTIMIZE_FLAGS", moz_optimize.flags)
+
+# Android NDK
+# ==============================================================
+
+
+@depends("--disable-compile-environment", target)
+def compiling_android(compile_env, target):
+    return compile_env and target.os == "Android"
+
+
+include("android-ndk.configure", when=compiling_android)
+
+with only_when(target_is_osx):
+    # MacOS deployment target version
+    # ==============================================================
+    # This needs to happen before any compilation test is done.
+
+    option(
+        "--enable-macos-target",
+        env="MACOSX_DEPLOYMENT_TARGET",
+        nargs=1,
+        default=depends(target, developer_options)
+        # We continue to target 10.15 on Intel, but can target 11.0 for
+        # aarch64 since the earliest hardware was released alongside 11.0.
+        # For local builds, we want to target 10.15 regardless of the
+        # underlying platform to catch any errors or warnings that wouldn't
+        # show up when targeting 11.0, since these would later show up on
+        # CI for Intel builds.
+        (lambda t, d: "11.0" if (t.cpu == "aarch64" and not d) else "10.15"),
+        help="Set the minimum MacOS version needed at runtime{|}",
+    )
+
+    @depends_if("--enable-macos-target", developer_options)
+    def macos_target(value, _):
+        return value[0]
+
+
+with only_when(host_is_osx | target_is_osx):
+    # MacOS SDK
+    # =========
+    option(
+        "--with-macos-sdk",
+        env="MACOS_SDK_DIR",
+        nargs=1,
+        help="Location of platform SDK to use",
+    )
+
+    @imports("plistlib")
+    @imports(_from="__builtin__", _import="open")
+    @imports(_from="__builtin__", _import="Exception")
+    def get_sdk_version(sdk):
+        with open(os.path.join(sdk, "SDKSettings.plist"), "rb") as plist:
+            obj = plistlib.load(plist)
+        if not obj:
+            raise Exception(
+                "Error parsing SDKSettings.plist in the SDK directory: %s" % sdk
+            )
+        if "Version" not in obj:
+            raise Exception(
+                "Error finding Version information in SDKSettings.plist from the SDK: %s"
+                % sdk
+            )
+        return Version(obj["Version"])
+
+    def sdk_min_version():
+        return "14.2"
+
+    @depends(
+        "--with-macos-sdk",
+        host,
+        bootstrap_path(
+            "MacOSX{}.sdk".format(sdk_min_version()),
+            when=depends("--with-macos-sdk")(lambda x: not x),
+            allow_failure=True,
+        ),
+    )
+    @imports(_from="__builtin__", _import="Exception")
+    @imports(_from="os.path", _import="isdir")
+    @imports(_from="os", _import="listdir")
+    def macos_sdk(sdk, host, bootstrapped):
+        if bootstrapped:
+            sdk = [bootstrapped]
+        if sdk:
+            sdk = sdk[0]
+            try:
+                version = get_sdk_version(sdk)
+            except Exception as e:
+                die(e)
+        elif host.os == "OSX":
+            sdk = check_cmd_output(
+                "xcrun", "--show-sdk-path", onerror=lambda: ""
+            ).rstrip()
+            if not sdk:
+                die(
+                    "Could not find the macOS SDK. Please use --with-macos-sdk to give "
+                    "the path to a macOS SDK."
+                )
+            # Scan the parent directory xcrun returns for the most recent SDK.
+            sdk_dir = os.path.dirname(sdk)
+            versions = []
+            for d in listdir(sdk_dir):
+                if d.lower().startswith("macos"):
+                    try:
+                        sdk = os.path.join(sdk_dir, d)
+                        versions.append((get_sdk_version(sdk), sdk))
+                    except Exception:
+                        pass
+            version, sdk = max(versions)
+        else:
+            die(
+                "Need a macOS SDK when targeting macOS. Please use --with-macos-sdk "
+                "to give the path to a macOS SDK."
+            )
+
+        if not isdir(sdk):
+            die(
+                "SDK not found in %s. When using --with-macos-sdk, you must specify a "
+                "valid SDK. SDKs are installed when the optional cross-development "
+                "tools are selected during the Xcode/Developer Tools installation."
+                % sdk
+            )
+        if version < Version(sdk_min_version()):
+            die(
+                'SDK version "%s" is too old. Please upgrade to at least %s. Try '
+                "updating your system Xcode." % (version, sdk_min_version())
+            )
+        return sdk
+
+    set_config("MACOS_SDK_DIR", macos_sdk)
+
+
+with only_when(target_is_osx):
+    with only_when(cross_compiling):
+        option(
+            "--with-macos-private-frameworks",
+            env="MACOS_PRIVATE_FRAMEWORKS_DIR",
+            nargs=1,
+            help="Location of private frameworks to use",
+        )
+
+        @depends_if("--with-macos-private-frameworks")
+        @imports(_from="os.path", _import="isdir")
+        def macos_private_frameworks(value):
+            if value and not isdir(value[0]):
+                die(
+                    "PrivateFrameworks not found not found in %s. When using "
+                    "--with-macos-private-frameworks, you must specify a valid "
+                    "directory",
+                    value[0],
+                )
+            return value[0]
+
+    @depends(macos_private_frameworks, macos_sdk)
+    def macos_private_frameworks(value, sdk):
+        if value:
+            return value
+        return os.path.join(sdk or "/", "System/Library/PrivateFrameworks")
+
+    set_config("MACOS_PRIVATE_FRAMEWORKS_DIR", macos_private_frameworks)
+
+
+# GC rooting and hazard analysis.
+# ==============================================================
+option(env="MOZ_HAZARD", help="Build for the GC rooting hazard analysis")
+
+
+@depends("MOZ_HAZARD")
+def hazard_analysis(value):
+    if value:
+        return True
+
+
+set_config("MOZ_HAZARD", hazard_analysis)
+
+
+# Cross-compilation related things.
+# ==============================================================
+option(
+    "--with-toolchain-prefix",
+    env="TOOLCHAIN_PREFIX",
+    nargs=1,
+    help="Prefix for the target toolchain",
+)
+
+
+@depends("--with-toolchain-prefix", host, target, cross_compiling)
+def toolchain_prefix(value, host, target, cross_compiling):
+    if value:
+        return tuple(value)
+    # We don't want a toolchain prefix by default when building on mac for mac.
+    if cross_compiling and not (target.os == "OSX" and host.os == "OSX"):
+        return ("%s-" % target.toolchain, "%s-" % target.alias)
+
+
+@depends(toolchain_prefix, target)
+def first_toolchain_prefix(toolchain_prefix, target):
+    # Pass TOOLCHAIN_PREFIX down to the build system if it was given from the
+    # command line/environment (in which case there's only one value in the tuple),
+    # or when cross-compiling for Android or OSX.
+    if toolchain_prefix and (
+        target.os in ("Android", "OSX") or len(toolchain_prefix) == 1
+    ):
+        return toolchain_prefix[0]
+
+
+set_config("TOOLCHAIN_PREFIX", first_toolchain_prefix)
+add_old_configure_assignment("TOOLCHAIN_PREFIX", first_toolchain_prefix)
+
+
+# Compilers
+# ==============================================================
+include("compilers-util.configure")
+
+
+def try_preprocess(
+    configure_cache, compiler, language, source, onerror=None, wrapper=[]
+):
+    return try_invoke_compiler(
+        configure_cache, compiler, language, source, ["-E"], onerror, wrapper
+    )
+
+
+@imports(_from="mozbuild.configure.constants", _import="CompilerType")
+@imports(_from="mozbuild.configure.constants", _import="CPU_preprocessor_checks")
+@imports(_from="mozbuild.configure.constants", _import="kernel_preprocessor_checks")
+@imports(_from="mozbuild.configure.constants", _import="OS_preprocessor_checks")
+@imports(_from="textwrap", _import="dedent")
+@imports(_from="__builtin__", _import="Exception")
+def get_compiler_info(configure_cache, compiler, language):
+    """Returns information about the given `compiler` (command line in the
+    form of a list or tuple), in the given `language`.
+
+    The returned information includes:
+    - the compiler type (clang-cl, clang or gcc)
+    - the compiler version
+    - the compiler supported language
+    - the compiler supported language version
+    """
+    # Xcode clang versions are different from the underlying llvm version (they
+    # instead are aligned with the Xcode version). Fortunately, we can tell
+    # apart plain clang from Xcode clang, and convert the Xcode clang version
+    # into the more or less corresponding plain clang version.
+    check = dedent(
+        """\
+        #if defined(_MSC_VER) && defined(__clang__) && defined(_MT)
+        %COMPILER "clang-cl"
+        %VERSION __clang_major__.__clang_minor__.__clang_patchlevel__
+        #elif defined(__clang__)
+        %COMPILER "clang"
+        %VERSION __clang_major__.__clang_minor__.__clang_patchlevel__
+        #  ifdef __apple_build_version__
+        %XCODE 1
+        #  endif
+        #elif defined(__GNUC__) && !defined(__MINGW32__)
+        %COMPILER "gcc"
+        %VERSION __GNUC__.__GNUC_MINOR__.__GNUC_PATCHLEVEL__
+        #endif
+
+        #if __cplusplus
+        %cplusplus __cplusplus
+        #elif __STDC_VERSION__
+        %STDC_VERSION __STDC_VERSION__
+        #endif
+    """
+    )
+
+    # While we're doing some preprocessing, we might as well do some more
+    # preprocessor-based tests at the same time, to check the toolchain
+    # matches what we want.
+    for name, preprocessor_checks in (
+        ("CPU", CPU_preprocessor_checks),
+        ("KERNEL", kernel_preprocessor_checks),
+        ("OS", OS_preprocessor_checks),
+    ):
+        for n, (value, condition) in enumerate(preprocessor_checks.items()):
+            check += dedent(
+                """\
+                #%(if)s %(condition)s
+                %%%(name)s "%(value)s"
+            """
+                % {
+                    "if": "elif" if n else "if",
+                    "condition": condition,
+                    "name": name,
+                    "value": value,
+                }
+            )
+        check += "#endif\n"
+
+    # Also check for endianness. The advantage of living in modern times is
+    # that all the modern compilers we support now have __BYTE_ORDER__ defined
+    # by the preprocessor.
+    check += dedent(
+        """\
+        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+        %ENDIANNESS "little"
+        #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+        %ENDIANNESS "big"
+        #endif
+    """
+    )
+
+    result = try_preprocess(configure_cache, compiler, language, check)
+
+    if not result:
+        raise FatalCheckError("Unknown compiler or compiler not supported.")
+
+    # Metadata emitted by preprocessors such as GCC with LANG=ja_JP.utf-8 may
+    # have non-ASCII characters. Treat the output as bytearray.
+    data = {}
+    for line in result.splitlines():
+        if line.startswith("%"):
+            k, _, v = line.partition(" ")
+            k = k.lstrip("%")
+            data[k] = v.replace(" ", "").lstrip('"').rstrip('"')
+            log.debug("%s = %s", k, data[k])
+
+    try:
+        type = CompilerType(data["COMPILER"])
+    except Exception:
+        raise FatalCheckError("Unknown compiler or compiler not supported.")
+
+    cplusplus = int(data.get("cplusplus", "0L").rstrip("L"))
+    stdc_version = int(data.get("STDC_VERSION", "0L").rstrip("L"))
+
+    version = data.get("VERSION")
+    if version:
+        version = Version(version)
+        if data.get("XCODE"):
+            # Derived from https://en.wikipedia.org/wiki/Xcode#Toolchain_versions
+            # with enough granularity for major.minor version checks further
+            # down the line
+            if version < "9.1":
+                version = Version("4.0.0.or.less")
+            elif version < "10.0":
+                version = Version("5.0.2")
+            elif version < "10.0.1":
+                version = Version("6.0.1")
+            elif version < "11.0":
+                version = Version("7.0.0")
+            elif version < "11.0.3":
+                version = Version("8.0.0")
+            elif version < "12.0":
+                version = Version("9.0.0")
+            elif version < "12.0.5":
+                version = Version("10.0.0")
+            elif version < "13.0":
+                version = Version("11.1.0")
+            elif version < "13.0.1":
+                version = Version("12.0.0")
+            elif version < "14.0":
+                version = Version("13.0.0")
+            elif version < "15.0":
+                version = Version("14.0.0")
+            else:
+                version = Version("14.0.0.or.more")
+
+    return namespace(
+        type=type,
+        version=version,
+        cpu=data.get("CPU"),
+        kernel=data.get("KERNEL"),
+        endianness=data.get("ENDIANNESS"),
+        os=data.get("OS"),
+        language="C++" if cplusplus else "C",
+        language_version=cplusplus if cplusplus else stdc_version,
+        xcode=bool(data.get("XCODE")),
+    )
+
+
+def same_arch_different_bits():
+    return (
+        ("x86", "x86_64"),
+        ("ppc", "ppc64"),
+        ("sparc", "sparc64"),
+    )
+
+
+@imports(_from="mozbuild.shellutil", _import="quote")
+@imports(_from="mozbuild.configure.constants", _import="OS_preprocessor_checks")
+def check_compiler(configure_cache, compiler, language, target, android_version):
+    info = get_compiler_info(configure_cache, compiler, language)
+
+    flags = []
+
+    # Check language standards
+    # --------------------------------------------------------------------
+    if language != info.language:
+        raise FatalCheckError(
+            "`%s` is not a %s compiler." % (quote(*compiler), language)
+        )
+
+    # Note: We do a strict version check because there sometimes are backwards
+    # incompatible changes in the standard, and not all code that compiles as
+    # C99 compiles as e.g. C11 (as of writing, this is true of libnestegg, for
+    # example)
+    if info.language == "C" and info.language_version != 199901:
+        if info.type == "clang-cl":
+            flags.append("-Xclang")
+        flags.append("-std=gnu99")
+
+    cxx17_version = 201703
+    if info.language == "C++":
+        if info.language_version != cxx17_version:
+            # MSVC headers include C++17 features, but don't guard them
+            # with appropriate checks.
+            if info.type == "clang-cl":
+                flags.append("-Xclang")
+                flags.append("-std=c++17")
+            else:
+                flags.append("-std=gnu++17")
+
+    # Check compiler target
+    # --------------------------------------------------------------------
+    has_target = False
+    if target.os == "Android" and android_version:
+        # This makes clang define __ANDROID_API__ and use versioned library
+        # directories from the NDK.
+        toolchain = "%s%d" % (target.toolchain, android_version)
+    else:
+        toolchain = target.toolchain
+
+    if info.type == "clang":
+        # Add the target explicitly when the target is aarch64 macosx, because
+        # the Xcode clang target is named differently, and we need to work around
+        # https://github.com/rust-lang/rust-bindgen/issues/1871 and
+        # https://github.com/alexcrichton/cc-rs/issues/542 so we always want
+        # the target on the command line, even if the compiler would default to
+        # that.
+        if info.xcode and target.os == "OSX" and target.cpu == "aarch64":
+            if "--target=arm64-apple-darwin" not in compiler:
+                flags.append("--target=arm64-apple-darwin")
+            has_target = True
+
+        elif (
+            not info.kernel
+            or info.kernel != target.kernel
+            or not info.endianness
+            or info.endianness != target.endianness
+        ):
+            flags.append("--target=%s" % toolchain)
+            has_target = True
+
+        # Add target flag when there is an OS mismatch (e.g. building for Android on
+        # Linux). However, only do this if the target OS is in our whitelist, to
+        # keep things the same on other platforms.
+        elif target.os in OS_preprocessor_checks and (
+            not info.os or info.os != target.os
+        ):
+            flags.append("--target=%s" % toolchain)
+            has_target = True
+
+    if not has_target and (not info.cpu or info.cpu != target.cpu):
+        same_arch = same_arch_different_bits()
+        if (target.cpu, info.cpu) in same_arch:
+            flags.append("-m32")
+        elif (info.cpu, target.cpu) in same_arch:
+            flags.append("-m64")
+        elif info.type == "clang-cl" and target.cpu == "aarch64":
+            flags.append("--target=%s" % toolchain)
+        elif info.type == "clang":
+            flags.append("--target=%s" % toolchain)
+
+    return namespace(
+        type=info.type,
+        version=info.version,
+        target_cpu=info.cpu,
+        target_kernel=info.kernel,
+        target_endianness=info.endianness,
+        target_os=info.os,
+        flags=flags,
+    )
+
+
+@imports(_from="__builtin__", _import="open")
+@imports("json")
+@imports("os")
+def get_vc_paths(topsrcdir):
+    def vswhere(args):
+        program_files = os.environ.get("PROGRAMFILES(X86)") or os.environ.get(
+            "PROGRAMFILES"
+        )
+        if not program_files:
+            return []
+        vswhere = os.path.join(
+            program_files, "Microsoft Visual Studio", "Installer", "vswhere.exe"
+        )
+        if not os.path.exists(vswhere):
+            return []
+        return json.loads(check_cmd_output(vswhere, "-format", "json", *args))
+
+    for install in vswhere(
+        [
+            "-products",
+            "*",
+            "-requires",
+            "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+        ]
+    ):
+        path = install["installationPath"]
+        tools_version = (
+            open(
+                os.path.join(
+                    path, r"VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt"
+                ),
+                "r",
+            )
+            .read()
+            .strip()
+        )
+        tools_path = os.path.join(path, r"VC\Tools\MSVC", tools_version)
+        yield (Version(install["installationVersion"]), tools_path)
+
+
+@depends(target, host)
+def is_windows(target, host):
+    return host.kernel == "WINNT" or target.kernel == "WINNT"
+
+
+# Calling this a sysroot is a little weird, but it's the terminology clang went
+# with with its -winsysroot flag.
+option(
+    env="WINSYSROOT",
+    nargs=1,
+    when=is_windows,
+    help='Path to a Windows "sysroot" (directory containing MSVC, SDKs)',
+)
+
+
+@depends(
+    "WINSYSROOT",
+    bootstrap_path(
+        "vs",
+        when=depends("WINSYSROOT", when=is_windows)(lambda x: not x),
+    ),
+    when=is_windows,
+)
+def winsysroot(winsysroot, bootstrapped):
+    if bootstrapped:
+        return bootstrapped
+    if winsysroot:
+        return winsysroot[0]
+
+
+option(
+    env="VC_PATH",
+    nargs=1,
+    when=is_windows,
+    help="Path to the Microsoft Visual C/C++ compiler",
+)
+
+
+@depends(
+    host,
+    build_environment,
+    "VC_PATH",
+    winsysroot,
+    when=is_windows,
+)
+@imports("os")
+@imports(_from="operator", _import="itemgetter")
+def vc_compiler_paths_for_version(host, env, vc_path, winsysroot):
+    if winsysroot:
+        if vc_path:
+            die("WINSYSROOT and VC_PATH cannot be set together.")
+        base_vc_path = os.path.join(winsysroot, "VC", "Tools", "MSVC")
+        versions = os.listdir(base_vc_path)
+        vc_path = [os.path.join(base_vc_path, str(max(Version(v) for v in versions)))]
+    if vc_path:
+        # Use an arbitrary version, it doesn't matter.
+        all_versions = [(Version("15"), vc_path[0])]
+    elif host.kernel != "WINNT":
+        # Don't try to do anything when VC_PATH is not set on cross-compiles.
+        return
+    else:
+        all_versions = sorted(get_vc_paths(env.topsrcdir), key=itemgetter(0))
+    if not all_versions:
+        return
+    # Choose the newest version.
+    path = all_versions[-1][1]
+    host_dir = {
+        "x86_64": "Hostx64",
+        "x86": "Hostx86",
+    }.get(host.cpu)
+    if host_dir:
+        path = os.path.join(path, "bin", host_dir)
+        return {
+            "x64": [os.path.join(path, "x64")],
+            # The cross toolchains require DLLs from the native x64 toolchain.
+            "x86": [os.path.join(path, "x86"), os.path.join(path, "x64")],
+            "arm64": [os.path.join(path, "arm64"), os.path.join(path, "x64")],
+        }
+
+
+@depends(target, host, vc_compiler_paths_for_version, when=is_windows)
+def vc_compiler_path(target, host, paths):
+    cpu = target.cpu if target.os == "WINNT" else host.cpu
+    vc_target = {
+        "x86": "x86",
+        "x86_64": "x64",
+        "arm": "arm",
+        "aarch64": "arm64",
+    }.get(cpu)
+    if not paths:
+        return
+    return paths.get(vc_target)
+
+
+@depends(vc_compiler_path, original_path)
+@imports("os")
+@imports(_from="os", _import="environ")
+def vc_toolchain_search_path(vc_compiler_path, original_path):
+    result = list(original_path)
+
+    if vc_compiler_path:
+        # The second item, if there is one, is necessary to have in $PATH for
+        # Windows to load the required DLLs from there.
+        if len(vc_compiler_path) > 1:
+            environ["PATH"] = os.pathsep.join(result + vc_compiler_path[1:])
+
+        # The first item is where the programs are going to be
+        result.append(vc_compiler_path[0])
+
+    return result
+
+
+@depends_if(vc_compiler_path, when=is_windows)
+def vc_compiler_version(vc_compiler_path):
+    version = Version(
+        os.path.basename(
+            os.path.dirname(os.path.dirname(os.path.dirname(vc_compiler_path[0])))
+        )
+    )
+    # MSVC path with version 14.x is actually version 19.x
+    if version.major == 14:
+        return Version(f"19.{version.minor}")
+
+
+@depends_if(vc_compiler_version)
+def is_vs2019_or_more(vc_compiler_version):
+    return vc_compiler_version >= Version("19.20")
+
+
+add_old_configure_assignment("IS_VS2019_OR_MORE", is_vs2019_or_more)
+
+
+@depends_if(vc_compiler_version)
+def msvs_version(vc_compiler_version):
+    # clang-cl emulates the same version scheme as cl. And MSVS_VERSION needs to
+    # be set for GYP on Windows.
+    if vc_compiler_version >= Version("19.30"):
+        return "2022"
+    if vc_compiler_version >= Version("19.20"):
+        return "2019"
+    if vc_compiler_version >= Version("19.10"):
+        return "2017"
+
+    return ""
+
+
+set_config("MSVS_VERSION", msvs_version)
+
+
+clang_search_path = bootstrap_search_path("clang/bin")
+
+
+@depends(
+    bootstrap_search_path("rustc/bin", when="MOZ_AUTOMATION"),
+    bootstrap_search_path_order,
+    original_path,
+)
+@imports("os")
+@imports(_from="os", _import="environ")
+def rust_search_path(rust_path, search_order, original_path):
+    result = list(rust_path or original_path)
+    # Also add the rustup install directory for cargo/rustc.
+    cargo_home = environ.get("CARGO_HOME", "")
+    if cargo_home:
+        cargo_home = os.path.abspath(cargo_home)
+    else:
+        cargo_home = os.path.expanduser(os.path.join("~", ".cargo"))
+    rustup_path = os.path.join(cargo_home, "bin")
+    if search_order == "prepend":
+        result.insert(0, rustup_path)
+    else:
+        result.append(rustup_path)
+    return result
+
+
+# Prepend the mozilla-build msys2 path, since otherwise we can get mismatched
+# cygwin dll errors during configure if we get called from another msys2
+# environment, see bug 1801826.
+@depends(
+    mozillabuild_bin_paths, clang_search_path, rust_search_path, target, original_path
+)
+@imports("os")
+def altered_path(
+    mozillabuild_bin_paths, clang_search_path, rust_search_path, target, original_path
+):
+    altered_path = mozillabuild_bin_paths
+    if target.kernel == "Darwin":
+        # The rust compiler wants to execute dsymutil, but it does so in a
+        # non-configurable way (https://github.com/rust-lang/rust/issues/52728)
+        # so we add the clang path.
+        path = clang_search_path
+    else:
+        path = original_path
+    # cargo needs the rust search path to find cargo-$subcommand.
+    path += rust_search_path
+    for p in path:
+        if p not in altered_path:
+            altered_path.append(p)
+    return os.pathsep.join(altered_path)
+
+
+set_config("PATH", altered_path)
+
+
+# Compiler wrappers
+# ==============================================================
+option(
+    "--with-compiler-wrapper",
+    env="COMPILER_WRAPPER",
+    nargs=1,
+    help="Enable compiling with wrappers such as distcc and ccache",
+)
+
+option("--with-ccache", env="CCACHE", nargs="?", help="Enable compiling with ccache")
+
+
+@depends_if("--with-ccache")
+def ccache(value):
+    if len(value):
+        return value
+    # If --with-ccache was given without an explicit value, we default to
+    # 'ccache'.
+    return "ccache"
+
+
+ccache = check_prog(
+    "CCACHE",
+    progs=(),
+    input=ccache,
+    paths=bootstrap_search_path(
+        "sccache", when=depends("CCACHE")(lambda c: len(c) and c[0] == "sccache")
+    ),
+    allow_missing=True,
+)
+
+option(env="CCACHE_PREFIX", nargs=1, help="Compiler prefix to use when using ccache")
+
+ccache_prefix = depends_if("CCACHE_PREFIX")(lambda prefix: prefix[0])
+set_config("CCACHE_PREFIX", ccache_prefix)
+
+# Distinguish ccache from sccache.
+
+
+@depends_if(ccache)
+def ccache_is_sccache(ccache):
+    return check_cmd_output(ccache, "--version").startswith("sccache")
+
+
+@depends(ccache, ccache_is_sccache)
+def using_ccache(ccache, ccache_is_sccache):
+    return ccache and not ccache_is_sccache
+
+
+@depends_if(ccache, ccache_is_sccache)
+def using_sccache(ccache, ccache_is_sccache):
+    return ccache and ccache_is_sccache
+
+
+option(env="RUSTC_WRAPPER", nargs=1, help="Wrap rust compilation with given tool")
+
+
+@depends(ccache, ccache_is_sccache, "RUSTC_WRAPPER")
+@imports(_from="textwrap", _import="dedent")
+@imports("os")
+def check_sccache_version(ccache, ccache_is_sccache, rustc_wrapper):
+    sccache_min_version = Version("0.2.13")
+
+    def check_version(path):
+        out = check_cmd_output(path, "--version")
+        version = Version(out.rstrip().split()[-1])
+        if version < sccache_min_version:
+            die(
+                dedent(
+                    """\
+            sccache %s or later is required. sccache in use at %s has
+            version %s.
+
+            Please upgrade or acquire a new version with |./mach bootstrap|.
+            """
+                ),
+                sccache_min_version,
+                path,
+                version,
+            )
+
+    if ccache and ccache_is_sccache:
+        check_version(ccache)
+
+    if rustc_wrapper and (
+        os.path.splitext(os.path.basename(rustc_wrapper[0]))[0].lower() == "sccache"
+    ):
+        check_version(rustc_wrapper[0])
+
+
+set_config("MOZ_USING_CCACHE", using_ccache)
+set_config("MOZ_USING_SCCACHE", using_sccache)
+
+option(env="SCCACHE_VERBOSE_STATS", help="Print verbose sccache stats after build")
+
+
+@depends(using_sccache, "SCCACHE_VERBOSE_STATS")
+def sccache_verbose_stats(using_sccache, verbose_stats):
+    return using_sccache and bool(verbose_stats)
+
+
+set_config("SCCACHE_VERBOSE_STATS", sccache_verbose_stats)
+
+
+@depends("--with-compiler-wrapper", ccache)
+@imports(_from="mozbuild.shellutil", _import="split", _as="shell_split")
+def compiler_wrapper(wrapper, ccache):
+    if wrapper:
+        raw_wrapper = wrapper[0]
+        wrapper = shell_split(raw_wrapper)
+        wrapper_program = find_program(wrapper[0])
+        if not wrapper_program:
+            die(
+                "Cannot find `%s` from the given compiler wrapper `%s`",
+                wrapper[0],
+                raw_wrapper,
+            )
+        wrapper[0] = wrapper_program
+
+    if ccache:
+        if wrapper:
+            return tuple([ccache] + wrapper)
+        else:
+            return (ccache,)
+    elif wrapper:
+        return tuple(wrapper)
+
+
+@depends_if(compiler_wrapper)
+def using_compiler_wrapper(compiler_wrapper):
+    return True
+
+
+set_config("MOZ_USING_COMPILER_WRAPPER", using_compiler_wrapper)
+
+
+@dependable
+def wasm():
+    return split_triplet("wasm32-wasi", allow_wasi=True)
+
+
+@template
+def default_c_compilers(host_or_target, other_c_compiler=None):
+    """Template defining the set of default C compilers for the host and
+    target platforms.
+    `host_or_target` is either `host` or `target` (the @depends functions
+    from init.configure.
+    `other_c_compiler` is the `target` C compiler when `host_or_target` is `host`.
+    """
+    assert host_or_target in {host, target, wasm}
+
+    other_c_compiler = () if other_c_compiler is None else (other_c_compiler,)
+
+    @depends(host_or_target, target, toolchain_prefix, *other_c_compiler)
+    def default_c_compilers(
+        host_or_target, target, toolchain_prefix, *other_c_compiler
+    ):
+        if host_or_target.kernel == "WINNT":
+            if host_or_target.abi:
+                if host_or_target.abi == "msvc":
+                    supported = types = ("clang-cl",)
+                elif host_or_target.abi == "mingw":
+                    supported = types = ("clang",)
+            else:
+                supported = types = ("clang-cl", "clang")
+        elif host_or_target.kernel == "Darwin":
+            types = ("clang",)
+            supported = ("clang", "gcc")
+        elif host_or_target.kernel == "WASI":
+            supported = types = ("clang",)
+        else:
+            supported = types = ("clang", "gcc")
+
+        info = other_c_compiler[0] if other_c_compiler else None
+        if info and info.type in supported:
+            # When getting default C compilers for the host, we prioritize the
+            # same compiler as the target C compiler.
+            prioritized = info.compiler
+            if info.type == "gcc":
+                same_arch = same_arch_different_bits()
+                if (
+                    target.cpu != host_or_target.cpu
+                    and (target.cpu, host_or_target.cpu) not in same_arch
+                    and (host_or_target.cpu, target.cpu) not in same_arch
+                ):
+                    # If the target C compiler is GCC, and it can't be used with
+                    # -m32/-m64 for the host, it's probably toolchain-prefixed,
+                    # so we prioritize a raw 'gcc' instead.
+                    prioritized = info.type
+            if target.os != "WINNT" and host_or_target.os == "WINNT":
+                # When cross-compiling on Windows, don't prioritize. We'll fallback
+                # to checking for clang-cl first.
+                pass
+            else:
+                types = [prioritized] + [t for t in types if t != info.type]
+
+        gcc = ("gcc",)
+        if toolchain_prefix and host_or_target is target:
+            gcc = tuple("%sgcc" % p for p in toolchain_prefix) + gcc
+
+        result = []
+        for type in types:
+            if type == "gcc":
+                result.extend(gcc)
+            else:
+                result.append(type)
+
+        return tuple(result)
+
+    return default_c_compilers
+
+
+@template
+def default_cxx_compilers(c_compiler, other_c_compiler=None, other_cxx_compiler=None):
+    """Template defining the set of default C++ compilers for the host and
+    target platforms.
+    `c_compiler` is the @depends function returning a Compiler instance for
+    the desired platform.
+
+    Because the build system expects the C and C++ compilers to be from the
+    same compiler suite, we derive the default C++ compilers from the C
+    compiler that was found if none was provided.
+
+    We also factor in the target C++ compiler when getting the default host
+    C++ compiler, using the target C++ compiler if the host and target C
+    compilers are the same.
+    """
+
+    assert (other_c_compiler is None) == (other_cxx_compiler is None)
+    if other_c_compiler is not None:
+        other_compilers = (other_c_compiler, other_cxx_compiler)
+    else:
+        other_compilers = ()
+
+    @depends(c_compiler, *other_compilers)
+    def default_cxx_compilers(c_compiler, *other_compilers):
+        if other_compilers:
+            other_c_compiler, other_cxx_compiler = other_compilers
+            if other_c_compiler.compiler == c_compiler.compiler:
+                return (other_cxx_compiler.compiler,)
+
+        dir = os.path.dirname(c_compiler.compiler)
+        file = os.path.basename(c_compiler.compiler)
+
+        if c_compiler.type == "gcc":
+            return (os.path.join(dir, file.replace("gcc", "g++")),)
+
+        if c_compiler.type == "clang":
+            return (os.path.join(dir, file.replace("clang", "clang++")),)
+
+        return (c_compiler.compiler,)
+
+    return default_cxx_compilers
+
+
+@template
+def provided_program(env_var, when=None):
+    """Template handling cases where a program can be specified either as a
+    path or as a path with applicable arguments.
+    """
+
+    @depends_if(env_var, when=when)
+    @imports(_from="itertools", _import="takewhile")
+    @imports(_from="mozbuild.shellutil", _import="split", _as="shell_split")
+    def provided(cmd):
+        # Assume the first dash-prefixed item (and any subsequent items) are
+        # command-line options, the item before the dash-prefixed item is
+        # the program we're looking for, and anything before that is a wrapper
+        # of some kind (e.g. sccache).
+        cmd = shell_split(cmd[0])
+
+        without_flags = list(takewhile(lambda x: not x.startswith("-"), cmd))
+
+        return namespace(
+            wrapper=without_flags[:-1],
+            program=without_flags[-1],
+            flags=cmd[len(without_flags) :],
+        )
+
+    return provided
+
+
+@template
+def sysroot(host_or_target, target_sysroot=None):
+    assert target_sysroot or host_or_target is target
+    bootstrap_target_when = target_is_linux_or_wasi
+    if host_or_target is host:
+        host_or_target_str = "host"
+        opt = "--with-host-sysroot"
+        env = "HOST_SYSROOT"
+        when = depends(host)(lambda h: h.kernel == "Linux")
+
+        # Only bootstrap a host sysroot when using a bootstrapped target sysroot
+        # or when the target doesn't use a bootstrapped sysroot in the first place.
+        @depends(when, bootstrap_target_when, target_sysroot.bootstrapped)
+        def bootstrap_when(when, bootstrap_target_when, bootstrapped):
+            return when and (bootstrapped or not bootstrap_target_when)
+
+    else:
+        assert host_or_target is target
+        host_or_target_str = "target"
+        opt = "--with-sysroot"
+        env = "SYSROOT"
+        when = target_is_linux_or_wasi
+        bootstrap_when = bootstrap_target_when
+
+    option(
+        opt,
+        env=env,
+        nargs=1,
+        when=when,
+        help="Use the given sysroot directory for %s build" % host_or_target_str,
+    )
+
+    sysroot_input = depends(opt, when=when)(lambda x: x)
+    bootstrap_sysroot = depends(bootstrap_when, sysroot_input)(
+        # Only bootstrap when no flag was explicitly given (either --with or --without)
+        lambda bootstrap, input: bootstrap
+        and not input
+        and input.origin == "default"
+    )
+
+    @depends(
+        sysroot_input,
+        host_or_target,
+        macos_sdk,
+        bootstrap_path(
+            depends(host_or_target)(lambda t: "sysroot-{}".format(t.toolchain)),
+            when=bootstrap_sysroot,
+        ),
+    )
+    @imports("os")
+    def sysroot(sysroot_input, host_or_target, macos_sdk, path):
+        version = None
+        if sysroot_input:
+            path = sysroot_input[0]
+        elif host_or_target.kernel == "Darwin" and macos_sdk:
+            path = macos_sdk
+        if path:
+            # Find the version of libstdc++ headears in the sysroot
+            include = os.path.join(path, "usr/include/c++")
+            if os.path.isdir(include):
+                with os.scandir(include) as d:
+                    version = max(Version(e.name) for e in d if e.is_dir())
+            log.info("Using %s sysroot in %s", host_or_target_str, path)
+        return namespace(
+            path=path,
+            bootstrapped=bool(path and not sysroot_input),
+            stdcxx_version=version,
+        )
+
+    return sysroot
+
+
+target_sysroot = sysroot(target)
+
+
+# Use `system_lib_option` instead of `option` for options that enable building
+# with a system library for which the development headers are not available in
+# the bootstrapped sysroots.
+@template
+def system_lib_option(name, *args, **kwargs):
+    option(name, *args, **kwargs)
+
+    @depends(name, target_sysroot.bootstrapped)
+    def no_system_lib_in_sysroot(value, bootstrapped):
+        if bootstrapped and value:
+            die(
+                "%s is not supported with bootstrapped sysroot. "
+                "Drop the option, or use --without-sysroot or --disable-bootstrap",
+                value.format(name),
+            )
+
+
+host_sysroot = sysroot(host, target_sysroot)
+
+
+@template
+def multiarch_dir(host_or_target):
+    sysroot = {
+        host: host_sysroot,
+        target: target_sysroot,
+    }[host_or_target]
+
+    @depends(host_or_target, when=sysroot.path)
+    def multiarch_dir(target):
+        if target.cpu == "x86":
+            # Turn e.g. i686-linux-gnu into i386-linux-gnu
+            return target.toolchain.replace(target.raw_cpu, "i386")
+        return target.toolchain
+
+    return multiarch_dir
+
+
+target_multiarch_dir = multiarch_dir(target)
+host_multiarch_dir = multiarch_dir(host)
+
+
+def minimum_gcc_version():
+    return Version("8.1.0")
+
+
+@template
+def compiler(
+    language,
+    host_or_target,
+    c_compiler=None,
+    other_compiler=None,
+    other_c_compiler=None,
+):
+    """Template handling the generic base checks for the compiler for the
+    given `language` on the given platform (`host_or_target`).
+    `host_or_target` is either `host` or `target` (the @depends functions
+    from init.configure.
+    When the language is 'C++', `c_compiler` is the result of the `compiler`
+    template for the language 'C' for the same `host_or_target`.
+    When `host_or_target` is `host`, `other_compiler` is the result of the
+    `compiler` template for the same `language` for `target`.
+    When `host_or_target` is `host` and the language is 'C++',
+    `other_c_compiler` is the result of the `compiler` template for the
+    language 'C' for `target`.
+    """
+    assert host_or_target in {host, target, wasm}
+    assert language in ("C", "C++")
+    assert language == "C" or c_compiler is not None
+    assert host_or_target is target or other_compiler is not None
+    assert language == "C" or host_or_target is target or other_c_compiler is not None
+
+    host_or_target_str = {
+        host: "host",
+        target: "target",
+        wasm: "wasm",
+    }[host_or_target]
+
+    sysroot = {
+        host: host_sysroot,
+        target: target_sysroot,
+        wasm: dependable(lambda: namespace(path=None)),
+    }[host_or_target]
+
+    multiarch_dir = {
+        host: host_multiarch_dir,
+        target: target_multiarch_dir,
+        wasm: never,
+    }[host_or_target]
+
+    var = {
+        ("C", target): "CC",
+        ("C++", target): "CXX",
+        ("C", host): "HOST_CC",
+        ("C++", host): "HOST_CXX",
+        ("C", wasm): "WASM_CC",
+        ("C++", wasm): "WASM_CXX",
+    }[language, host_or_target]
+
+    default_compilers = {
+        "C": lambda: default_c_compilers(host_or_target, other_compiler),
+        "C++": lambda: default_cxx_compilers(
+            c_compiler, other_c_compiler, other_compiler
+        ),
+    }[language]()
+
+    what = "the %s %s compiler" % (host_or_target_str, language)
+
+    option(env=var, nargs=1, help="Path to %s" % what)
+
+    # Handle the compiler given by the user through one of the CC/CXX/HOST_CC/
+    # HOST_CXX variables.
+    provided_compiler = provided_program(var)
+
+    # Normally, we'd use `var` instead of `_var`, but the interaction with
+    # old-configure complicates things, and for now, we a) can't take the plain
+    # result from check_prog as CC/CXX/HOST_CC/HOST_CXX and b) have to let
+    # old-configure AC_SUBST it (because it's autoconf doing it, not us)
+    compiler = check_prog(
+        "_%s" % var,
+        what=what,
+        progs=default_compilers,
+        input=provided_compiler.program,
+        paths=clang_search_path,
+    )
+
+    @depends(
+        configure_cache,
+        compiler,
+        provided_compiler,
+        compiler_wrapper,
+        host_or_target,
+        sysroot,
+        macos_target,
+        android_version,
+        vc_compiler_version,
+        multiarch_dir,
+        winsysroot,
+        host,
+    )
+    @checking("whether %s can be used" % what, lambda x: bool(x))
+    @imports(_from="mozbuild.shellutil", _import="quote")
+    @imports("os")
+    def valid_compiler(
+        configure_cache,
+        compiler,
+        provided_compiler,
+        compiler_wrapper,
+        host_or_target,
+        sysroot,
+        macos_target,
+        android_version,
+        vc_compiler_version,
+        multiarch_dir,
+        winsysroot,
+        host,
+    ):
+        wrapper = list(compiler_wrapper or ())
+        flags = []
+        if sysroot.path:
+            if host_or_target.kernel == "Darwin":
+                # While --sysroot and -isysroot are roughly equivalent, when not using
+                # -isysroot on mac, clang takes the SDKROOT environment variable into
+                # consideration, which may be set by python and break things.
+                flags.extend(("-isysroot", sysroot.path))
+            else:
+                flags.extend(("--sysroot", sysroot.path))
+        if provided_compiler:
+            wrapper.extend(provided_compiler.wrapper)
+            flags.extend(provided_compiler.flags)
+
+        info = check_compiler(
+            configure_cache,
+            wrapper + [compiler] + flags,
+            language,
+            host_or_target,
+            android_version,
+        )
+
+        if host_or_target.os == "OSX" and macos_target:
+            flags.append("-mmacosx-version-min=%s" % macos_target)
+
+        # When not given an explicit compatibility version, clang-cl tries
+        # to get one from MSVC, which might not even be the one used by the
+        # build. And when it can't find one, its default might also not match
+        # what the build is using. So if we were able to figure out the version
+        # we're building with, explicitly use that.
+        # This also means that, as a side effect, clang-cl will not try to find
+        # MSVC, which saves a little overhead.
+        if info.type == "clang-cl" and vc_compiler_version:
+            flags.append(f"-fms-compatibility-version={vc_compiler_version}")
+
+        if info.type == "clang" and language == "C++" and host_or_target.os == "OSX":
+            flags.append("-stdlib=libc++")
+
+        # Check that the additional flags we got are enough to not require any
+        # more flags. If we get an exception, just ignore it; it's liable to be
+        # invalid command-line flags, which means the compiler we're checking
+        # doesn't support those command-line flags and will fail one or more of
+        # the checks below.
+        try:
+            if info.flags:
+                flags += info.flags
+                info = check_compiler(
+                    configure_cache,
+                    wrapper + [compiler] + flags,
+                    language,
+                    host_or_target,
+                    android_version,
+                )
+        except FatalCheckError:
+            pass
+
+        if not info.target_cpu or info.target_cpu != host_or_target.cpu:
+            raise FatalCheckError(
+                "%s %s compiler target CPU (%s) does not match --%s CPU (%s)"
+                % (
+                    host_or_target_str.capitalize(),
+                    language,
+                    info.target_cpu or "unknown",
+                    host_or_target_str,
+                    host_or_target.raw_cpu,
+                )
+            )
+
+        if not info.target_kernel or (info.target_kernel != host_or_target.kernel):
+            raise FatalCheckError(
+                "%s %s compiler target kernel (%s) does not match --%s kernel (%s)"
+                % (
+                    host_or_target_str.capitalize(),
+                    language,
+                    info.target_kernel or "unknown",
+                    host_or_target_str,
+                    host_or_target.kernel,
+                )
+            )
+
+        if not info.target_endianness or (
+            info.target_endianness != host_or_target.endianness
+        ):
+            raise FatalCheckError(
+                "%s %s compiler target endianness (%s) does not match --%s "
+                "endianness (%s)"
+                % (
+                    host_or_target_str.capitalize(),
+                    language,
+                    info.target_endianness or "unknown",
+                    host_or_target_str,
+                    host_or_target.endianness,
+                )
+            )
+
+        # Compiler version checks
+        # ===================================================
+        # Check the compiler version here instead of in `compiler_version` so
+        # that the `checking` message doesn't pretend the compiler can be used
+        # to then bail out one line later.
+        if info.type == "gcc":
+            if host_or_target.os == "Android":
+                raise FatalCheckError(
+                    "GCC is not supported on Android.\n"
+                    "Please use clang from the Android NDK instead."
+                )
+            gcc_version = minimum_gcc_version()
+            if info.version < gcc_version:
+                raise FatalCheckError(
+                    "Only GCC %d.%d or newer is supported (found version %s)."
+                    % (gcc_version.major, gcc_version.minor, info.version)
+                )
+
+            # Force GCC to use the C++ headers from the sysroot, and to prefer the
+            # sysroot system headers to /usr/include.
+            # Non-Debian GCC also doesn't look at headers in multiarch directory.
+            if sysroot.bootstrapped and sysroot.stdcxx_version:
+                version = sysroot.stdcxx_version
+                for path in (
+                    "usr/include/c++/{}".format(version),
+                    "usr/include/{}/c++/{}".format(multiarch_dir, version),
+                    "usr/include/{}".format(multiarch_dir),
+                    "usr/include",
+                ):
+                    flags.extend(("-isystem", os.path.join(sysroot.path, path)))
+
+        if info.type == "clang-cl":
+            if info.version < "9.0.0":
+                raise FatalCheckError(
+                    "Only clang-cl 9.0 or newer is supported (found version %s)"
+                    % info.version
+                )
+            if winsysroot and host.os != "WINNT":
+                overlay = os.path.join(winsysroot, "overlay.yaml")
+                if os.path.exists(overlay):
+                    overlay_flags = ["-Xclang", "-ivfsoverlay", "-Xclang", overlay]
+                    if info.version >= "16.0" or (
+                        # clang-cl 15 normally doesn't support the root-relative
+                        # overlay we use, but the bootstrapped clang-cl 15 is patched
+                        # to support it, so check we're using a patched version.
+                        info.version >= "15.0"
+                        and try_preprocess(
+                            configure_cache,
+                            [compiler] + flags + overlay_flags,
+                            language,
+                            "",
+                            onerror=lambda: False,
+                            wrapper=wrapper,
+                        )
+                    ):
+                        flags.extend(overlay_flags)
+
+        if (info.type, host_or_target.abi) in (
+            ("clang", "msvc"),
+            ("clang-cl", "mingw"),
+        ):
+            raise FatalCheckError("Unknown compiler or compiler not supported.")
+
+        # If you want to bump the version check here ensure the version
+        # is known for Xcode in get_compiler_info.
+        if info.type == "clang" and info.version < "8.0":
+            raise FatalCheckError(
+                "Only clang/llvm 8.0 or newer is supported (found version %s)."
+                % info.version
+            )
+
+        if host_or_target.kernel == "WASI":
+            if info.type != "clang":
+                raise FatalCheckError(
+                    "Only clang is supported for %s" % host_or_target.alias
+                )
+            if info.version < "8.0":
+                raise FatalCheckError(
+                    "Only clang/llvm 8.0 or newer is supported for %s (found version %s)."
+                    % (host_or_target.alias, info.version)
+                )
+
+        if host_or_target.os == "Android":
+            # Need at least clang 13 for compiler-rt/libunwind being the default.
+            if info.type == "clang" and info.version < "13.0":
+                raise FatalCheckError(
+                    "Only clang/llvm 13.0 or newer is supported for %s (found version %s)."
+                    % (host_or_target.alias, info.version)
+                )
+
+        if info.flags:
+            raise FatalCheckError("Unknown compiler or compiler not supported.")
+
+        return namespace(
+            wrapper=wrapper,
+            compiler=compiler,
+            flags=flags,
+            type=info.type,
+            version=info.version,
+            language=language,
+        )
+
+    @depends(valid_compiler)
+    @checking("%s version" % what)
+    def compiler_version(compiler):
+        return compiler.version
+
+    if language == "C++":
+
+        @depends(valid_compiler, c_compiler)
+        def valid_compiler(compiler, c_compiler):
+            if compiler.type != c_compiler.type:
+                die(
+                    "The %s C compiler is %s, while the %s C++ compiler is "
+                    "%s. Need to use the same compiler suite.",
+                    host_or_target_str,
+                    c_compiler.type,
+                    host_or_target_str,
+                    compiler.type,
+                )
+
+            if compiler.version != c_compiler.version:
+                die(
+                    "The %s C compiler is version %s, while the %s C++ "
+                    "compiler is version %s. Need to use the same compiler "
+                    "version.",
+                    host_or_target_str,
+                    c_compiler.version,
+                    host_or_target_str,
+                    compiler.version,
+                )
+            return compiler
+
+    # Set CC/CXX/HOST_CC/HOST_CXX for old-configure, which needs the wrapper
+    # and the flags that were part of the user input for those variables to
+    # be provided.
+    add_old_configure_assignment(
+        var,
+        depends_if(valid_compiler)(
+            lambda x: list(x.wrapper) + [x.compiler] + list(x.flags)
+        ),
+    )
+
+    if host_or_target is target:
+        add_old_configure_assignment(
+            "ac_cv_prog_%s" % var,
+            depends_if(valid_compiler)(
+                lambda x: list(x.wrapper) + [x.compiler] + list(x.flags)
+            ),
+        )
+        # We check that it works in python configure already.
+        add_old_configure_assignment("ac_cv_prog_%s_works" % var.lower(), "yes")
+        add_old_configure_assignment(
+            "ac_cv_prog_%s_cross" % var.lower(),
+            depends(cross_compiling)(lambda x: "yes" if x else "no"),
+        )
+        gcc_like = depends(valid_compiler.type)(
+            lambda x: "yes" if x in ("gcc", "clang") else "no"
+        )
+        add_old_configure_assignment("ac_cv_prog_%s_g" % var.lower(), gcc_like)
+        if language == "C":
+            add_old_configure_assignment("ac_cv_prog_gcc", gcc_like)
+        if language == "C++":
+            add_old_configure_assignment("ac_cv_prog_gxx", gcc_like)
+
+    # Set CC_TYPE/CC_VERSION/HOST_CC_TYPE/HOST_CC_VERSION to allow
+    # old-configure to do some of its still existing checks.
+    if language == "C":
+        set_config("%s_TYPE" % var, valid_compiler.type)
+        add_old_configure_assignment("%s_TYPE" % var, valid_compiler.type)
+        set_config(
+            "%s_VERSION" % var, depends(valid_compiler.version)(lambda v: str(v))
+        )
+
+    valid_compiler = compiler_class(valid_compiler, host_or_target)
+
+    def compiler_error():
+        raise FatalCheckError(
+            "Failed compiling a simple %s source with %s" % (language, what)
+        )
+
+    valid_compiler.try_compile(check_msg="%s works" % what, onerror=compiler_error)
+
+    set_config("%s_BASE_FLAGS" % var, valid_compiler.flags)
+
+    # Set CPP/CXXCPP for both the build system and old-configure. We don't
+    # need to check this works for preprocessing, because we already relied
+    # on $CC -E/$CXX -E doing preprocessing work to validate the compiler
+    # in the first place.
+    if host_or_target is target:
+        pp_var = {
+            "C": "CPP",
+            "C++": "CXXCPP",
+        }[language]
+
+        preprocessor = depends_if(valid_compiler)(
+            lambda x: list(x.wrapper) + [x.compiler, "-E"] + list(x.flags)
+        )
+
+        set_config(pp_var, preprocessor)
+        add_old_configure_assignment(pp_var, preprocessor)
+
+    if language == "C":
+        linker_var = {
+            target: "LD",
+            host: "HOST_LD",
+        }.get(host_or_target)
+
+        if linker_var:
+
+            @deprecated_option(env=linker_var, nargs=1)
+            def linker(value):
+                if value:
+                    return value[0]
+
+            @depends(linker)
+            def unused_linker(linker):
+                if linker:
+                    log.warning(
+                        "The value of %s is not used by this build system." % linker_var
+                    )
+
+    return valid_compiler
+
+
+c_compiler = compiler("C", target)
+cxx_compiler = compiler("C++", target, c_compiler=c_compiler)
+host_c_compiler = compiler("C", host, other_compiler=c_compiler)
+host_cxx_compiler = compiler(
+    "C++",
+    host,
+    c_compiler=host_c_compiler,
+    other_compiler=cxx_compiler,
+    other_c_compiler=c_compiler,
+)
+
+
+@template
+def windows_abi(host_or_target, c_compiler):
+    @depends(host_or_target)
+    def windows_abi(host_or_target):
+        if host_or_target.os == "WINNT":
+            return host_or_target.abi
+
+    @depends(host_or_target, windows_abi)
+    def need_windows_abi_from_compiler(host_or_target, windows_abi):
+        return host_or_target.os == "WINNT" and windows_abi is None
+
+    @depends(host_or_target, c_compiler, when=need_windows_abi_from_compiler)
+    def windows_abi_from_compiler(host_or_target, c_compiler):
+        if host_or_target.os == "WINNT":
+            if c_compiler.type == "clang-cl":
+                return "msvc"
+            return "mingw"
+
+    return windows_abi | windows_abi_from_compiler
+
+
+target_windows_abi = windows_abi(target, c_compiler)
+host_windows_abi = windows_abi(host, host_c_compiler)
+
+
+# Generic compiler-based conditions.
+building_with_gcc = depends(c_compiler)(lambda info: info.type == "gcc")
+
+
+@depends(cxx_compiler, ccache_prefix)
+@imports("os")
+def cxx_is_icecream(info, ccache_prefix):
+    if (
+        os.path.islink(info.compiler)
+        and os.path.basename(os.readlink(info.compiler)) == "icecc"
+    ):
+        return True
+    if ccache_prefix and os.path.basename(ccache_prefix) == "icecc":
+        return True
+
+
+set_config("CXX_IS_ICECREAM", cxx_is_icecream)
+
+
+# Libstdc++ compatibility hacks
+# ==============================================================
+#
+@depends(target, host)
+def target_or_host_is_linux(target, host):
+    return any(t.os == "GNU" and t.kernel == "Linux" for t in (target, host))
+
+
+option(
+    "--enable-stdcxx-compat",
+    env="MOZ_STDCXX_COMPAT",
+    help="Enable compatibility with older libstdc++",
+    when=target_or_host_is_linux,
+)
+
+
+@depends("--enable-stdcxx-compat", when=target_or_host_is_linux)
+def stdcxx_compat(value):
+    if value:
+        return True
+
+
+set_config("MOZ_STDCXX_COMPAT", True, when=stdcxx_compat)
+
+
+# Linker detection
+# ==============================================================
+# The policy is as follows:
+# For Windows:
+# - the linker is picked via the LINKER environment variable per windows.configure,
+#   but ought to be lld-link in any case.
+# For macOS:
+# - the linker is lld if the clang used is >= 15 (per LLVM version, not Xcode version).
+# - the linker is also lld on local developer builds if the clang used is >= 13 (per LLVM
+#   version, not Xcode version)
+# - otherwise the linker is ld64, either from XCode on macOS, or from cctools-ports when
+#   cross-compiling.
+# For other OSes:
+# - on local developer builds: lld if present and the compiler is clang. Otherwise gold
+#   is used if present otherwise, whatever the compiler uses by default.
+# - on release/official builds: whatever the compiler uses by default, except when the
+#   compiler is clang, in which case lld is preferred when it's new enough.
+@template
+def is_not_winnt_or_sunos(host_or_target):
+    @depends(host_or_target)
+    def is_not_winnt_or_sunos(host_or_target):
+        if host_or_target.kernel not in ("WINNT", "SunOS"):
+            return True
+
+    return is_not_winnt_or_sunos
+
+
+is_linker_option_enabled = is_not_winnt_or_sunos(target)
+
+
+@deprecated_option("--enable-gold", env="MOZ_FORCE_GOLD", when=is_linker_option_enabled)
+def enable_gold(value):
+    if value:
+        die("--enable-gold is deprecated, use --enable-linker=gold instead")
+    else:
+        die("--disable-gold is deprecated, use --enable-linker=something_else instead")
+
+
+option(
+    "--enable-linker",
+    nargs=1,
+    help="Select the linker {bfd, gold, ld64, lld, lld-*, mold}",
+    when=is_linker_option_enabled,
+)
+
+
+# No-op to enable depending on --enable-linker from default_elfhack in
+# toolkit/moz.configure.
+@depends("--enable-linker", when=is_linker_option_enabled)
+def enable_linker(linker):
+    return linker
+
+
+@template
+def select_linker_tmpl(host_or_target):
+    if host_or_target is target:
+        deps = depends(
+            "--enable-linker",
+            c_compiler,
+            developer_options,
+            extra_toolchain_flags,
+            target,
+            stdcxx_compat,
+            when=is_linker_option_enabled,
+        )
+        host_or_target_str = "target"
+    else:
+        deps = depends(
+            dependable(None),
+            host_c_compiler,
+            developer_options,
+            dependable(None),
+            host,
+            stdcxx_compat,
+            when=is_not_winnt_or_sunos(host_or_target),
+        )
+        host_or_target_str = "host"
+
+    @deps
+    @checking(f"for {host_or_target_str} linker", lambda x: x.KIND)
+    @imports("os")
+    @imports("shutil")
+    def select_linker(
+        linker, c_compiler, developer_options, toolchain_flags, target, stdcxx_compat
+    ):
+        if linker:
+            linker = linker[0]
+        else:
+            linker = None
+
+        def is_valid_linker(linker):
+            if target.kernel == "Darwin":
+                valid_linkers = ("ld64", "lld")
+            else:
+                valid_linkers = ("bfd", "gold", "lld", "mold")
+            if linker in valid_linkers:
+                return True
+            if "lld" in valid_linkers and linker.startswith("lld-"):
+                return True
+            return False
+
+        if linker and not is_valid_linker(linker):
+            # Check that we are trying to use a supported linker
+            die("Unsupported linker " + linker)
+
+        # Check the kind of linker
+        version_check = ["-Wl,--version"]
+        cmd_base = c_compiler.wrapper + [c_compiler.compiler] + c_compiler.flags
+
+        def try_linker(linker):
+            # Generate the compiler flag
+            if linker == "ld64":
+                linker_flag = ["-fuse-ld=ld"]
+            elif linker:
+                linker_flag = ["-fuse-ld=" + linker]
+            else:
+                linker_flag = []
+            cmd = cmd_base + linker_flag + version_check
+            if toolchain_flags:
+                cmd += toolchain_flags
+
+            # ld64 doesn't have anything to print out a version. It does print out
+            # "ld64: For information on command line options please use 'man ld'."
+            # but that would require doing two attempts, one with --version, that
+            # would fail, and another with --help.
+            # Instead, abuse its LD_PRINT_OPTIONS feature to detect a message
+            # specific to it on stderr when it fails to process --version.
+            env = dict(os.environ)
+            env["LD_PRINT_OPTIONS"] = "1"
+            # Some locales might not print out the strings we are looking for, so
+            # ensure consistent output.
+            env["LC_ALL"] = "C"
+            retcode, stdout, stderr = get_cmd_output(*cmd, env=env)
+            if retcode == 1 and "Logging ld64 options" in stderr:
+                kind = "ld64"
+
+            elif retcode != 0:
+                return None
+
+            elif "mold" in stdout:
+                kind = "mold"
+
+            elif "GNU ld" in stdout:
+                # We are using the normal linker
+                kind = "bfd"
+
+            elif "GNU gold" in stdout:
+                kind = "gold"
+
+            elif "LLD" in stdout:
+                kind = "lld"
+
+            else:
+                kind = "unknown"
+
+            if kind == "unknown" or is_valid_linker(kind):
+                return namespace(
+                    KIND=kind,
+                    LINKER_FLAG=linker_flag,
+                )
+
+        result = None
+        if linker:
+            result = try_linker(linker)
+            if result is None:
+                die("Could not use {} as linker".format(linker))
+
+        if (
+            result is None
+            and c_compiler.type == "clang"
+            and (
+                (
+                    target.kernel != "Darwin"
+                    and (
+                        developer_options
+                        or host_or_target_str == "host"
+                        or c_compiler.version >= "15.0"
+                    )
+                )
+                or (
+                    target.kernel == "Darwin"
+                    and (
+                        (developer_options and c_compiler.version >= "13.0")
+                        or c_compiler.version >= "15.0"
+                    )
+                )
+            )
+        ):
+            result = try_linker("lld")
+
+        if result is None and developer_options and not stdcxx_compat:
+            result = try_linker("gold")
+
+        if result is None:
+            result = try_linker(None)
+
+        if result is None:
+            die("Failed to find an adequate linker")
+
+        if stdcxx_compat and result.KIND == "gold":
+            die("--enable-stdcxx-compat is not compatible with the gold linker")
+
+        # If an explicit linker was given, error out if what we found is different.
+        if linker and not linker.startswith(result.KIND):
+            die("Could not use {} as linker".format(linker))
+
+        return result
+
+    return select_linker
+
+
+select_linker = select_linker_tmpl(target)
+set_config("LINKER_KIND", select_linker.KIND)
+
+
+@template
+def linker_ldflags_tmpl(host_or_target):
+    if host_or_target is target:
+        deps = depends_if(
+            select_linker,
+            target,
+            target_sysroot,
+            target_multiarch_dir,
+            android_sysroot,
+            android_version,
+            c_compiler,
+            developer_options,
+        )
+    else:
+        deps = depends_if(
+            select_linker_tmpl(host),
+            host,
+            host_sysroot,
+            host_multiarch_dir,
+            dependable(None),
+            dependable(None),
+            host_c_compiler,
+            developer_options,
+        )
+
+    @deps
+    @imports("os")
+    def linker_ldflags(
+        linker,
+        target,
+        sysroot,
+        multiarch_dir,
+        android_sysroot,
+        android_version,
+        c_compiler,
+        developer_options,
+    ):
+        flags = list((linker and linker.LINKER_FLAG) or [])
+        # rpath-link is irrelevant to wasm, see for more info https://github.com/emscripten-core/emscripten/issues/11076.
+        if sysroot.path and multiarch_dir and target.os != "WASI":
+            for d in ("lib", "usr/lib"):
+                multiarch_lib_dir = os.path.join(sysroot.path, d, multiarch_dir)
+                if os.path.exists(multiarch_lib_dir):
+                    # Non-Debian-patched binutils linkers (both BFD and gold) don't lookup
+                    # in multi-arch directories.
+                    flags.append("-Wl,-rpath-link,%s" % multiarch_lib_dir)
+                    # GCC also needs -L.
+                    if c_compiler.type == "gcc":
+                        flags.append("-L%s" % multiarch_lib_dir)
+            if (
+                c_compiler.type == "gcc"
+                and sysroot.bootstrapped
+                and sysroot.stdcxx_version
+            ):
+                flags.append(
+                    "-L{}/usr/lib/gcc/{}/{}".format(
+                        sysroot.path, multiarch_dir, sysroot.stdcxx_version
+                    )
+                )
+        if android_sysroot:
+            # BFD/gold linkers need a manual --rpath-link for indirect
+            # dependencies.
+            flags += [
+                "-Wl,--rpath-link={}/usr/lib/{}".format(
+                    android_sysroot, target.toolchain
+                ),
+                "-Wl,--rpath-link={}/usr/lib/{}/{}".format(
+                    android_sysroot, target.toolchain, android_version
+                ),
+            ]
+        if (
+            developer_options
+            and linker
+            and linker.KIND == "lld"
+            and target.kernel != "WINNT"
+        ):
+            flags.append("-Wl,-O0")
+        return flags
+
+    return linker_ldflags
+
+
+linker_ldflags = linker_ldflags_tmpl(target)
+add_old_configure_assignment("LINKER_LDFLAGS", linker_ldflags)
+
+host_linker_ldflags = linker_ldflags_tmpl(host)
+add_old_configure_assignment("HOST_LINKER_LDFLAGS", host_linker_ldflags)
+
+
+# There's a wrinkle with MinGW: linker configuration is not enabled, so
+# `select_linker` is never invoked.  Hard-code around it.
+@depends(select_linker, target, c_compiler)
+def gcc_use_gnu_ld(select_linker, target, c_compiler):
+    if select_linker is not None and target.kernel != "Darwin":
+        return select_linker.KIND in ("bfd", "gold", "lld", "mold")
+    if target.kernel == "WINNT" and c_compiler.type == "clang":
+        return True
+    return None
+
+
+# GCC_USE_GNU_LD=1 means the linker is command line compatible with GNU ld.
+set_config("GCC_USE_GNU_LD", gcc_use_gnu_ld)
+add_old_configure_assignment("GCC_USE_GNU_LD", gcc_use_gnu_ld)
+
+
+include("compile-checks.configure")
+include("arm.configure", when=depends(target.cpu)(lambda cpu: cpu == "arm"))
+
+
+@depends(
+    have_64_bit,
+    try_compile(
+        body='static_assert(sizeof(void *) == 8, "")', check_msg="for 64-bit OS"
+    ),
+)
+def check_have_64_bit(have_64_bit, compiler_have_64_bit):
+    if have_64_bit != compiler_have_64_bit:
+        configure_error(
+            "The target compiler does not agree with configure "
+            "about the target bitness."
+        )
+
+
+@depends(cxx_compiler, target)
+def needs_libstdcxx_newness_check(cxx_compiler, target):
+    # We only have to care about this on Linux and MinGW.
+    if cxx_compiler.type == "clang-cl":
+        return
+
+    if target.kernel not in ("Linux", "WINNT"):
+        return
+
+    if target.os == "Android":
+        return
+
+    return True
+
+
+def die_on_old_libstdcxx():
+    die(
+        "The libstdc++ in use is not new enough.  Please run "
+        "./mach bootstrap to update your compiler, or update your system "
+        "libstdc++ installation."
+    )
+
+
+try_compile(
+    includes=["cstddef"],
+    body="\n".join(
+        [
+            # _GLIBCXX_RELEASE showed up in libstdc++ 7.
+            "#if defined(__GLIBCXX__) && !defined(_GLIBCXX_RELEASE)",
+            "#  error libstdc++ not new enough",
+            "#endif",
+            "#if defined(_GLIBCXX_RELEASE)",
+            "#  if _GLIBCXX_RELEASE < %d" % minimum_gcc_version().major,
+            "#    error libstdc++ not new enough",
+            "#  else",
+            "     (void) 0",
+            "#  endif",
+            "#endif",
+        ]
+    ),
+    check_msg="for new enough STL headers from libstdc++",
+    when=needs_libstdcxx_newness_check,
+    onerror=die_on_old_libstdcxx,
+)
+
+
+@depends(c_compiler, target)
+def default_debug_flags(compiler_info, target):
+    # Debug info is ON by default.
+    if compiler_info.type == "clang-cl":
+        return "-Z7"
+    elif target.kernel == "WINNT" and compiler_info.type == "clang":
+        return "-g -gcodeview"
+    # The oldest versions of supported compilers default to DWARF-4, but
+    # newer versions may default to DWARF-5 or newer (e.g. clang 14), which
+    # Valgrind doesn't support. Force-use DWARF-4.
+    return "-gdwarf-4"
+
+
+option(env="MOZ_DEBUG_FLAGS", nargs=1, help="Debug compiler flags")
+
+imply_option("--enable-debug-symbols", depends_if("--enable-debug")(lambda v: v))
+
+option(
+    "--disable-debug-symbols",
+    nargs="?",
+    help="Disable debug symbols using the given compiler flags",
+)
+
+set_config("MOZ_DEBUG_SYMBOLS", depends_if("--enable-debug-symbols")(lambda _: True))
+
+
+@depends("MOZ_DEBUG_FLAGS", "--enable-debug-symbols", default_debug_flags)
+def debug_flags(env_debug_flags, enable_debug_flags, default_debug_flags):
+    # If MOZ_DEBUG_FLAGS is set, and --enable-debug-symbols is set to a value,
+    # --enable-debug-symbols takes precedence. Note, the value of
+    # --enable-debug-symbols may be implied by --enable-debug.
+    if len(enable_debug_flags):
+        return enable_debug_flags[0]
+    if env_debug_flags:
+        return env_debug_flags[0]
+    return default_debug_flags
+
+
+set_config("MOZ_DEBUG_FLAGS", debug_flags)
+add_old_configure_assignment("MOZ_DEBUG_FLAGS", debug_flags)
+
+
+@depends(c_compiler, host)
+@imports(
+    _from="mach.logging", _import="enable_blessed", _as="_enable_ansi_escape_codes"
+)
+def color_cflags(info, host):
+    # We could test compiling with flags. By why incur the overhead when
+    # color support should always be present in a specific toolchain
+    # version?
+
+    # Code for auto-adding this flag to compiler invocations needs to
+    # determine if an existing flag isn't already present. That is likely
+    # using exact string matching on the returned value. So if the return
+    # value changes to e.g. "<x>=always", exact string match may fail and
+    # multiple color flags could be added. So examine downstream consumers
+    # before adding flags to return values.
+    if info.type == "gcc":
+        return "-fdiagnostics-color"
+    elif info.type in ["clang", "clang-cl"]:
+        if host.os == "WINNT" and _enable_ansi_escape_codes():
+            return "-fcolor-diagnostics -fansi-escape-codes"
+        else:
+            return "-fcolor-diagnostics"
+    else:
+        return ""
+
+
+set_config("COLOR_CFLAGS", color_cflags)
+
+# Some standard library headers (notably bionic on Android) declare standard
+# functions (e.g. getchar()) and also #define macros for those standard
+# functions.  libc++ deals with this by doing something like the following
+# (explanatory comments added):
+#
+#   #ifdef FUNC
+#   // Capture the definition of FUNC.
+#   inline _LIBCPP_INLINE_VISIBILITY int __libcpp_FUNC(...) { return FUNC(...); }
+#   #undef FUNC
+#   // Use a real inline definition.
+#   inline _LIBCPP_INLINE_VISIBILITY int FUNC(...) { return _libcpp_FUNC(...); }
+#   #endif
+#
+# _LIBCPP_INLINE_VISIBILITY is typically defined as:
+#
+#   __attribute__((__visibility__("hidden"), __always_inline__))
+#
+# Unfortunately, this interacts badly with our system header wrappers, as the:
+#
+#   #pragma GCC visibility push(default)
+#
+# that they do prior to including the actual system header is treated by the
+# compiler as an explicit declaration of visibility on every function declared
+# in the header.  Therefore, when the libc++ code above is encountered, it is
+# as though the compiler has effectively seen:
+#
+#   int FUNC(...) __attribute__((__visibility__("default")));
+#   int FUNC(...) __attribute__((__visibility__("hidden")));
+#
+# and the compiler complains about the mismatched visibility declarations.
+#
+# However, libc++ will only define _LIBCPP_INLINE_VISIBILITY if there is no
+# existing definition.  We can therefore define it to the empty string (since
+# we are properly managing visibility ourselves) and avoid this whole mess.
+# Note that we don't need to do this with gcc, as libc++ detects gcc and
+# effectively does the same thing we are doing here.
+#
+# _LIBCPP_ALWAYS_INLINE needs a similar workarounds, since it too declares
+# hidden visibility.
+#
+# _LIBCPP_HIDE_FROM_ABI is a macro in libc++ versions in NDKs >=r19.  It too
+# declares hidden visibility, but it also declares functions as excluded from
+# explicit instantiation (roughly: the function can be unused in the current
+# compilation, but does not then trigger an actual definition of the function;
+# it is assumed the real definition comes from elsewhere).  We need to replicate
+# this setup.
+
+
+@depends(c_compiler, target)
+def libcxx_override_visibility(c_compiler, target):
+    if c_compiler.type == "clang" and target.os == "Android":
+        return namespace(
+            empty="",
+            hide_from_abi="__attribute__((__exclude_from_explicit_instantiation__))",
+        )
+
+
+set_define("_LIBCPP_INLINE_VISIBILITY", libcxx_override_visibility.empty)
+set_define("_LIBCPP_ALWAYS_INLINE", libcxx_override_visibility.empty)
+
+set_define("_LIBCPP_HIDE_FROM_ABI", libcxx_override_visibility.hide_from_abi)
+
+
+@depends(target, build_environment)
+def visibility_flags(target, env):
+    if target.os != "WINNT":
+        if target.kernel == "Darwin":
+            return ("-fvisibility=hidden", "-fvisibility-inlines-hidden")
+        return (
+            "-I%s/system_wrappers" % os.path.join(env.dist),
+            "-include",
+            "%s/config/gcc_hidden.h" % env.topsrcdir,
+        )
+
+
+@depends(target, visibility_flags)
+def wrap_system_includes(target, visibility_flags):
+    if visibility_flags and target.kernel != "Darwin":
+        return True
+
+
+set_define(
+    "HAVE_VISIBILITY_HIDDEN_ATTRIBUTE",
+    depends(visibility_flags)(lambda v: bool(v) or None),
+)
+set_define(
+    "HAVE_VISIBILITY_ATTRIBUTE", depends(visibility_flags)(lambda v: bool(v) or None)
+)
+set_config("WRAP_SYSTEM_INCLUDES", wrap_system_includes)
+set_config("VISIBILITY_FLAGS", visibility_flags)
+
+
+@template
+def depend_cflags(host_or_target_c_compiler):
+    @depends(host_or_target_c_compiler)
+    def depend_cflags(host_or_target_c_compiler):
+        if host_or_target_c_compiler.type != "clang-cl":
+            return ["-MD", "-MP", "-MF $(MDDEPDIR)/$(@F).pp"]
+        else:
+            # clang-cl doesn't accept the normal -MD -MP -MF options that clang
+            # does, but the underlying cc1 binary understands how to generate
+            # dependency files.  These options are based on analyzing what the
+            # normal clang driver sends to cc1 when given the "correct"
+            # dependency options.
+            return [
+                "-Xclang",
+                "-MP",
+                "-Xclang",
+                "-dependency-file",
+                "-Xclang",
+                "$(MDDEPDIR)/$(@F).pp",
+                "-Xclang",
+                "-MT",
+                "-Xclang",
+                "$@",
+            ]
+
+    return depend_cflags
+
+
+set_config("_DEPEND_CFLAGS", depend_cflags(c_compiler))
+set_config("_HOST_DEPEND_CFLAGS", depend_cflags(host_c_compiler))
+
+
+@depends(c_compiler)
+def preprocess_option(compiler):
+    # The uses of PREPROCESS_OPTION depend on the spacing for -o/-Fi.
+    if compiler.type in ("gcc", "clang"):
+        return "-E -o "
+    else:
+        return "-P -Fi"
+
+
+set_config("PREPROCESS_OPTION", preprocess_option)
+
+
+# We only want to include windows.configure when we are compiling on
+# Windows, or for Windows.
+include("windows.configure", when=is_windows)
+
+
+# On Power ISA, determine compiler flags for VMX, VSX and VSX-3.
+
+set_config(
+    "PPC_VMX_FLAGS",
+    ["-maltivec"],
+    when=depends(target.cpu)(lambda cpu: cpu.startswith("ppc")),
+)
+
+set_config(
+    "PPC_VSX_FLAGS",
+    ["-mvsx"],
+    when=depends(target.cpu)(lambda cpu: cpu.startswith("ppc")),
+)
+
+set_config(
+    "PPC_VSX3_FLAGS",
+    ["-mvsx", "-mcpu=power9"],
+    when=depends(target.cpu)(lambda cpu: cpu.startswith("ppc")),
+)
+
+# ASAN
+# ==============================================================
+
+option("--enable-address-sanitizer", help="Enable Address Sanitizer")
+
+
+@depends(when="--enable-address-sanitizer")
+def asan():
+    return True
+
+
+add_old_configure_assignment("MOZ_ASAN", asan)
+
+# MSAN
+# ==============================================================
+
+option("--enable-memory-sanitizer", help="Enable Memory Sanitizer")
+
+
+@depends(when="--enable-memory-sanitizer")
+def msan():
+    return True
+
+
+add_old_configure_assignment("MOZ_MSAN", msan)
+
+# TSAN
+# ==============================================================
+
+option("--enable-thread-sanitizer", help="Enable Thread Sanitizer")
+
+
+@depends(when="--enable-thread-sanitizer")
+def tsan():
+    return True
+
+
+add_old_configure_assignment("MOZ_TSAN", tsan)
+
+# UBSAN
+# ==============================================================
+
+option(
+    "--enable-undefined-sanitizer", nargs="*", help="Enable UndefinedBehavior Sanitizer"
+)
+
+
+@depends("--enable-undefined-sanitizer", moz_optimize.optimize)
+def ubsan(options, optimize):
+    if not options:
+        return
+
+    default_checks = [
+        "bool",
+        "bounds",
+        "enum",
+        "function",
+        "integer-divide-by-zero",
+        "pointer-overflow",
+        "return",
+        "vla-bound",
+    ]
+
+    # adding object-size generates a warning if -O0 is set
+    if optimize:
+        default_checks.append("object-size")
+
+    checks = options if len(options) else default_checks
+
+    return ",".join(checks)
+
+
+add_old_configure_assignment("MOZ_UBSAN_CHECKS", ubsan)
+
+
+option(
+    "--enable-signed-overflow-sanitizer",
+    help="Enable UndefinedBehavior Sanitizer (Signed Integer Overflow Parts)",
+)
+
+
+@depends(when="--enable-signed-overflow-sanitizer")
+def ub_signed_overflow_san():
+    return True
+
+
+add_old_configure_assignment("MOZ_SIGNED_OVERFLOW_SANITIZE", ub_signed_overflow_san)
+
+
+option(
+    "--enable-unsigned-overflow-sanitizer",
+    help="Enable UndefinedBehavior Sanitizer (Unsigned Integer Overflow Parts)",
+)
+
+
+@depends(when="--enable-unsigned-overflow-sanitizer")
+def ub_unsigned_overflow_san():
+    return True
+
+
+add_old_configure_assignment("MOZ_UNSIGNED_OVERFLOW_SANITIZE", ub_unsigned_overflow_san)
+
+
+# Security Hardening
+# ==============================================================
+
+option(
+    "--enable-hardening",
+    env="MOZ_SECURITY_HARDENING",
+    help="Enables security hardening compiler options",
+)
+
+
+# This function is a bit confusing. It adds or removes hardening flags in
+# three stuations: if --enable-hardening is passed; if --disable-hardening
+# is passed, and if no flag is passed.
+#
+# At time of this comment writing, all flags are actually added in the
+# default no-flag case; making --enable-hardening the same as omitting the
+# flag. --disable-hardening will omit the security flags. (However, not all
+# possible security flags will be omitted by --disable-hardening, as many are
+# compiler-default options we do not explicitly enable.)
+@depends(
+    "--enable-hardening",
+    "--enable-address-sanitizer",
+    "--enable-debug",
+    "--enable-optimize",
+    c_compiler,
+    target,
+)
+def security_hardening_cflags(
+    hardening_flag, asan, debug, optimize, c_compiler, target
+):
+    compiler_is_gccish = c_compiler.type in ("gcc", "clang")
+    mingw_clang = c_compiler.type == "clang" and target.os == "WINNT"
+
+    flags = []
+    ldflags = []
+    trivial_auto_var_init = []
+
+    # WASI compiler doesn't support security hardening cflags
+    if target.os == "WASI":
+        return
+
+    # ----------------------------------------------------------
+    # If hardening is explicitly enabled, or not explicitly disabled
+    if hardening_flag.origin == "default" or hardening_flag:
+        # FORTIFY_SOURCE ------------------------------------
+        # Require optimization for FORTIFY_SOURCE. See Bug 1417452
+        # Also, undefine it before defining it just in case a distro adds it, see Bug 1418398
+        if compiler_is_gccish and optimize and not asan:
+            flags.append("-U_FORTIFY_SOURCE")
+            flags.append("-D_FORTIFY_SOURCE=2")
+
+        # fstack-protector ------------------------------------
+        # Enable only if hardening is not disabled and ASAN is
+        # not on as ASAN will catch the crashes for us
+        if compiler_is_gccish and not asan:
+            flags.append("-fstack-protector-strong")
+            ldflags.append("-fstack-protector-strong")
+
+            if (
+                c_compiler.type == "clang"
+                and c_compiler.version >= "11.0.1"
+                and target.os not in ("WINNT", "OSX", "OpenBSD")
+                and target.cpu in ("x86", "x86_64", "ppc64", "s390x")
+            ):
+                flags.append("-fstack-clash-protection")
+                ldflags.append("-fstack-clash-protection")
+
+        # ftrivial-auto-var-init ------------------------------
+        # Initialize local variables with a 0xAA pattern in clang builds.
+        # Linux32 fails some xpcshell tests with -ftrivial-auto-var-init
+        linux32 = target.kernel == "Linux" and target.cpu == "x86"
+        if (
+            (c_compiler.type == "clang" or c_compiler.type == "clang-cl")
+            and c_compiler.version >= "8"
+            and not linux32
+        ):
+            if c_compiler.type == "clang-cl":
+                trivial_auto_var_init.append("-Xclang")
+            trivial_auto_var_init.append("-ftrivial-auto-var-init=pattern")
+            # Always enable on debug builds.
+            if debug:
+                flags.extend(trivial_auto_var_init)
+
+        # ASLR ------------------------------------------------
+        # ASLR (dynamicbase) is enabled by default in clang-cl; but the
+        # mingw-clang build requires it to be explicitly enabled
+        if mingw_clang:
+            ldflags.append("-Wl,--dynamicbase")
+
+        # Control Flow Guard (CFG) ----------------------------
+        if (
+            c_compiler.type == "clang-cl"
+            and c_compiler.version >= "8"
+            and (target.cpu != "aarch64" or c_compiler.version >= "8.0.1")
+        ):
+            if target.cpu == "aarch64" and c_compiler.version >= "10.0.0":
+                # The added checks in clang 10 make arm64 builds crash. (Bug 1639318)
+                flags.append("-guard:cf,nochecks")
+            else:
+                flags.append("-guard:cf")
+            # nolongjmp is needed because clang doesn't emit the CFG tables of
+            # setjmp return addresses https://bugs.llvm.org/show_bug.cgi?id=40057
+            ldflags.append("-guard:cf,nolongjmp")
+
+    # ----------------------------------------------------------
+    # If ASAN _is_ on, disable FORTIFY_SOURCE just to be safe
+    if asan:
+        flags.append("-D_FORTIFY_SOURCE=0")
+
+    # fno-common -----------------------------------------
+    # Do not merge variables for ASAN; can detect some subtle bugs
+    if asan:
+        # clang-cl does not recognize the flag, it must be passed down to clang
+        if c_compiler.type == "clang-cl":
+            flags.append("-Xclang")
+        flags.append("-fno-common")
+
+    return namespace(
+        flags=flags,
+        ldflags=ldflags,
+        trivial_auto_var_init=trivial_auto_var_init,
+    )
+
+
+set_config("MOZ_HARDENING_CFLAGS", security_hardening_cflags.flags)
+set_config("MOZ_HARDENING_LDFLAGS", security_hardening_cflags.ldflags)
+set_config(
+    "MOZ_TRIVIAL_AUTO_VAR_INIT",
+    security_hardening_cflags.trivial_auto_var_init,
+)
+
+
+# Intel Control-flow Enforcement Technology
+# ==============================================================
+# We keep this separate from the hardening flags above, because we want to be
+# able to easily remove the flags in the build files for certain executables.
+@depends(c_compiler, target)
+def cet_ldflags(c_compiler, target):
+    ldflags = []
+    if (
+        c_compiler.type == "clang-cl"
+        and c_compiler.version >= "11"
+        and target.cpu == "x86_64"
+    ):
+        ldflags.append("-CETCOMPAT")
+    return ldflags
+
+
+set_config("MOZ_CETCOMPAT_LDFLAGS", cet_ldflags)
+
+
+# Frame pointers
+# ==============================================================
+@depends(c_compiler)
+def frame_pointer_flags(compiler):
+    if compiler.type == "clang-cl":
+        return namespace(
+            enable=["-Oy-"],
+            disable=["-Oy"],
+        )
+    return namespace(
+        enable=["-fno-omit-frame-pointer", "-funwind-tables"],
+        disable=["-fomit-frame-pointer", "-funwind-tables"],
+    )
+
+
+@depends(
+    moz_optimize.optimize,
+    moz_debug,
+    target,
+    "--enable-memory-sanitizer",
+    "--enable-address-sanitizer",
+    "--enable-undefined-sanitizer",
+)
+def frame_pointer_default(optimize, debug, target, msan, asan, ubsan):
+    return bool(
+        not optimize
+        or debug
+        or msan
+        or asan
+        or ubsan
+        or (target.os == "WINNT" and target.cpu in ("x86", "aarch64"))
+        or target.os == "OSX"
+    )
+
+
+option(
+    "--enable-frame-pointers",
+    default=frame_pointer_default,
+    help="{Enable|Disable} frame pointers",
+)
+
+
+@depends("--enable-frame-pointers", frame_pointer_flags)
+def frame_pointer_flags(enable, flags):
+    if enable:
+        return flags.enable
+    return flags.disable
+
+
+set_config("MOZ_FRAMEPTR_FLAGS", frame_pointer_flags)
+
+
+# Stack unwinding without frame pointers
+# ==============================================================
+
+
+have_unwind = check_symbol(
+    "_Unwind_Backtrace", when=check_header("unwind.h", when=target_is_unix)
+)
+
+
+# Code Coverage
+# ==============================================================
+
+option("--enable-coverage", env="MOZ_CODE_COVERAGE", help="Enable code coverage")
+
+
+@depends("--enable-coverage")
+def code_coverage(value):
+    if value:
+        return True
+
+
+set_config("MOZ_CODE_COVERAGE", code_coverage)
+set_define("MOZ_CODE_COVERAGE", code_coverage)
+
+
+@depends(target, c_compiler, build_environment, when=code_coverage)
+@imports("os")
+@imports("re")
+@imports(_from="__builtin__", _import="open")
+def coverage_cflags(target, c_compiler, build_env):
+    cflags = ["--coverage"]
+
+    # clang 11 no longer accepts this flag (its behavior became the default)
+    if c_compiler.type in ("clang", "clang-cl") and c_compiler.version < "11.0.0":
+        cflags += [
+            "-Xclang",
+            "-coverage-no-function-names-in-data",
+        ]
+
+    exclude = []
+    if target.os == "WINNT" and c_compiler.type == "clang-cl":
+        # VS files
+        exclude.append("^.*[vV][sS]20[0-9]{2}.*$")
+        # Files in fetches directory.
+        exclude.append("^.*[\\\\/]fetches[\\\\/].*$")
+    elif target.os == "OSX":
+        # Files in fetches directory.
+        exclude.append("^.*/fetches/.*$")
+    elif target.os == "GNU":
+        # Files in fetches directory.
+        exclude.append("^.*/fetches/.*$")
+        # Files in /usr/
+        exclude.append("^/usr/.*$")
+
+    if exclude:
+        exclude = ";".join(exclude)
+        cflags += [
+            f"-fprofile-exclude-files={exclude}",
+        ]
+
+    response_file_path = os.path.join(build_env.topobjdir, "code_coverage_cflags")
+
+    with open(response_file_path, "w") as f:
+        f.write(" ".join(cflags))
+
+    return ["@{}".format(response_file_path)]
+
+
+set_config("COVERAGE_CFLAGS", coverage_cflags)
+
+# Assembler detection
+# ==============================================================
+
+option(env="AS", nargs=1, help="Path to the assembler")
+
+
+@depends(target, c_compiler)
+def as_info(target, c_compiler):
+    if c_compiler.type == "clang-cl":
+        ml = {
+            "x86": "ml.exe",
+            "x86_64": "ml64.exe",
+            "aarch64": "armasm64.exe",
+        }.get(target.cpu)
+        return namespace(type="masm", names=(ml,))
+    # When building with anything but clang-cl, we just use the C compiler as the assembler.
+    return namespace(type="gcc", names=(c_compiler.compiler,))
+
+
+# One would expect the assembler to be specified merely as a program.  But in
+# cases where the assembler is passed down into js/, it can be specified in
+# the same way as CC: a program + a list of argument flags.  We might as well
+# permit the same behavior in general, even though it seems somewhat unusual.
+# So we have to do the same sort of dance as we did above with
+# `provided_compiler`.
+provided_assembler = provided_program("AS")
+assembler = check_prog(
+    "_AS",
+    input=provided_assembler.program,
+    what="the assembler",
+    progs=as_info.names,
+    paths=vc_toolchain_search_path,
+)
+
+
+@depends(as_info, assembler, provided_assembler, c_compiler)
+def as_with_flags(as_info, assembler, provided_assembler, c_compiler):
+    if provided_assembler:
+        return provided_assembler.wrapper + [assembler] + provided_assembler.flags
+
+    if as_info.type == "masm":
+        return assembler
+
+    assert as_info.type == "gcc"
+
+    # Need to add compiler wrappers and flags as appropriate.
+    return c_compiler.wrapper + [assembler] + c_compiler.flags
+
+
+set_config("AS", as_with_flags)
+
+
+@depends(assembler, c_compiler, extra_toolchain_flags)
+@imports("subprocess")
+@imports(_from="os", _import="devnull")
+def gnu_as(assembler, c_compiler, toolchain_flags):
+    # clang uses a compatible GNU assembler.
+    if c_compiler.type == "clang":
+        return True
+
+    if c_compiler.type == "gcc":
+        cmd = [assembler] + c_compiler.flags
+        if toolchain_flags:
+            cmd += toolchain_flags
+        cmd += ["-Wa,--version", "-c", "-o", devnull, "-x", "assembler", "-"]
+        # We don't actually have to provide any input on stdin, `Popen.communicate` will
+        # close the stdin pipe.
+        # clang will error if it uses its integrated assembler for this target,
+        # so handle failures gracefully.
+        if "GNU" in check_cmd_output(*cmd, stdin=subprocess.PIPE, onerror=lambda: ""):
+            return True
+
+
+set_config("GNU_AS", gnu_as)
+
+
+@depends(as_info, target)
+def as_dash_c_flag(as_info, target):
+    # armasm64 doesn't understand -c.
+    if as_info.type == "masm" and target.cpu == "aarch64":
+        return ""
+    else:
+        return "-c"
+
+
+set_config("AS_DASH_C_FLAG", as_dash_c_flag)
+
+
+@depends(as_info, target)
+def as_outoption(as_info, target):
+    # The uses of ASOUTOPTION depend on the spacing for -o/-Fo.
+    if as_info.type == "masm" and target.cpu != "aarch64":
+        return "-Fo"
+
+    return "-o "
+
+
+set_config("ASOUTOPTION", as_outoption)
+
+# clang plugin handling
+# ==============================================================
+
+option(
+    "--enable-clang-plugin",
+    env="ENABLE_CLANG_PLUGIN",
+    help="Enable building with the Clang plugin (gecko specific static analyzers)",
+)
+
+add_old_configure_assignment(
+    "ENABLE_CLANG_PLUGIN", depends_if("--enable-clang-plugin")(lambda _: True)
+)
+
+
+@depends(host_c_compiler, c_compiler, when="--enable-clang-plugin")
+def llvm_config(host_c_compiler, c_compiler):
+    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:
+        die("Cannot --enable-clang-plugin when not building with clang")
+    llvm_config = "llvm-config"
+    out = check_cmd_output(clang, "--print-prog-name=llvm-config", onerror=lambda: None)
+    if out:
+        llvm_config = out.rstrip()
+    return (llvm_config,)
+
+
+llvm_config = check_prog(
+    "LLVM_CONFIG",
+    llvm_config,
+    what="llvm-config",
+    when="--enable-clang-plugin",
+    paths=clang_search_path,
+)
+
+add_old_configure_assignment("LLVM_CONFIG", llvm_config)
+
+
+option(
+    "--enable-clang-plugin-alpha",
+    env="ENABLE_CLANG_PLUGIN_ALPHA",
+    help="Enable static analysis with clang-plugin alpha checks.",
+)
+
+
+@depends("--enable-clang-plugin", "--enable-clang-plugin-alpha")
+def check_clang_plugin_alpha(enable_clang_plugin, enable_clang_plugin_alpha):
+    if enable_clang_plugin_alpha:
+        if enable_clang_plugin:
+            return True
+        die("Cannot enable clang-plugin alpha checkers without --enable-clang-plugin.")
+
+
+add_old_configure_assignment("ENABLE_CLANG_PLUGIN_ALPHA", check_clang_plugin_alpha)
+set_define("MOZ_CLANG_PLUGIN_ALPHA", check_clang_plugin_alpha)
+
+option(
+    "--enable-mozsearch-plugin",
+    env="ENABLE_MOZSEARCH_PLUGIN",
+    help="Enable building with the mozsearch indexer plugin",
+)
+
+add_old_configure_assignment(
+    "ENABLE_MOZSEARCH_PLUGIN", depends_if("--enable-mozsearch-plugin")(lambda _: True)
+)
+
+# Use the old libstdc++ ABI
+# ==============================================================
+add_flag(
+    "-D_GLIBCXX_USE_CXX11_ABI=0",
+    cxx_compiler,
+    when=stdcxx_compat,
+)
+add_flag(
+    "-D_GLIBCXX_USE_CXX11_ABI=0",
+    host_cxx_compiler,
+    when=stdcxx_compat,
+)
+
+
+# Support various fuzzing options
+# ==============================================================
+option("--enable-fuzzing", help="Enable fuzzing support")
+
+
+@depends(build_project)
+def js_build(build_project):
+    return build_project == "js"
+
+
+option(
+    "--enable-js-fuzzilli",
+    when=js_build,
+    help="Enable fuzzilli support for the JS engine",
+)
+
+
+option(
+    "--enable-snapshot-fuzzing",
+    help="Enable experimental snapshot fuzzing support",
+)
+
+
+imply_option("--enable-fuzzing", True, when="--enable-snapshot-fuzzing")
+
+
+@depends("--enable-snapshot-fuzzing")
+def enable_snapshot_fuzzing(value):
+    if value:
+        return True
+
+
+@depends("--enable-fuzzing", enable_snapshot_fuzzing)
+def enable_fuzzing(value, snapshot_fuzzing):
+    if value or snapshot_fuzzing:
+        return True
+
+
+@depends("--enable-js-fuzzilli", when=js_build)
+def enable_js_fuzzilli(value):
+    if value:
+        return True
+
+
+@depends(enable_fuzzing, enable_snapshot_fuzzing)
+def check_aflfuzzer(fuzzing, snapshot_fuzzing):
+    if fuzzing and not snapshot_fuzzing:
+        return True
+
+
+@depends(
+    try_compile(
+        body="__AFL_COMPILER;", check_msg="for AFL compiler", when=check_aflfuzzer
+    )
+)
+def enable_aflfuzzer(afl):
+    if afl:
+        return True
+
+
+@depends(enable_fuzzing, enable_aflfuzzer, enable_snapshot_fuzzing, c_compiler, target)
+def enable_libfuzzer(fuzzing, afl, snapshot_fuzzing, c_compiler, target):
+    if (
+        fuzzing
+        and not afl
+        and not snapshot_fuzzing
+        and c_compiler.type == "clang"
+        and target.os != "Android"
+    ):
+        return True
+
+
+@depends(enable_fuzzing, enable_aflfuzzer, enable_libfuzzer, enable_js_fuzzilli)
+def enable_fuzzing_interfaces(fuzzing, afl, libfuzzer, enable_js_fuzzilli):
+    if fuzzing and (afl or libfuzzer) and not enable_js_fuzzilli:
+        return True
+
+
+set_config("FUZZING", enable_fuzzing)
+set_define("FUZZING", enable_fuzzing)
+
+set_config("LIBFUZZER", enable_libfuzzer)
+set_define("LIBFUZZER", enable_libfuzzer)
+add_old_configure_assignment("LIBFUZZER", enable_libfuzzer)
+
+set_config("AFLFUZZ", enable_aflfuzzer)
+set_define("AFLFUZZ", enable_aflfuzzer)
+
+set_config("FUZZING_INTERFACES", enable_fuzzing_interfaces)
+set_define("FUZZING_INTERFACES", enable_fuzzing_interfaces)
+add_old_configure_assignment("FUZZING_INTERFACES", enable_fuzzing_interfaces)
+
+set_config("FUZZING_JS_FUZZILLI", enable_js_fuzzilli)
+set_define("FUZZING_JS_FUZZILLI", enable_js_fuzzilli)
+
+set_config("FUZZING_SNAPSHOT", enable_snapshot_fuzzing)
+set_define("FUZZING_SNAPSHOT", enable_snapshot_fuzzing)
+
+
+@depends(
+    c_compiler.try_compile(
+        flags=["-fsanitize=fuzzer-no-link"],
+        when=enable_fuzzing,
+        check_msg="whether the C compiler supports -fsanitize=fuzzer-no-link",
+    ),
+    tsan,
+    enable_js_fuzzilli,
+)
+def libfuzzer_flags(value, tsan, enable_js_fuzzilli):
+    if tsan:
+        # With ThreadSanitizer, we should not use any libFuzzer instrumentation because
+        # it is incompatible (e.g. there are races on global sanitizer coverage counters).
+        # Instead we use an empty set of flags here but still build the fuzzing targets.
+        # With this setup, we can still run files through these targets in TSan builds,
+        # e.g. those obtained from regular fuzzing.
+        # This code can be removed once libFuzzer has been made compatible with TSan.
+        #
+        # Also, this code needs to be kept in sync with certain gyp files, currently:
+        #   - dom/media/webrtc/transport/third_party/nICEr/nicer.gyp
+        return namespace(no_link_flag_supported=False, use_flags=[])
+
+    if enable_js_fuzzilli:
+        # Fuzzilli comes with its own trace-pc interceptors and flag requirements.
+        no_link_flag_supported = False
+        use_flags = ["-fsanitize-coverage=trace-pc-guard", "-g"]
+    elif value:
+        no_link_flag_supported = True
+        # recommended for (and only supported by) clang >= 6
+        use_flags = ["-fsanitize=fuzzer-no-link"]
+    else:
+        no_link_flag_supported = False
+        use_flags = ["-fsanitize-coverage=trace-pc-guard,trace-cmp"]
+
+    return namespace(
+        no_link_flag_supported=no_link_flag_supported,
+        use_flags=use_flags,
+    )
+
+
+set_config("HAVE_LIBFUZZER_FLAG_FUZZER_NO_LINK", libfuzzer_flags.no_link_flag_supported)
+set_config("LIBFUZZER_FLAGS", libfuzzer_flags.use_flags)
+add_old_configure_assignment("LIBFUZZER_FLAGS", libfuzzer_flags.use_flags)
+
+# Shared library building
+# ==============================================================
+
+
+# XXX: The use of makefile constructs in these variables is awful.
+@depends(target, c_compiler)
+def make_shared_library(target, compiler):
+    if target.os == "WINNT":
+        if compiler.type == "gcc":
+            return namespace(
+                mkshlib=["$(CXX)", "$(DSO_LDOPTS)", "-o", "$@"],
+                mkcshlib=["$(CC)", "$(DSO_LDOPTS)", "-o", "$@"],
+            )
+        elif compiler.type == "clang":
+            return namespace(
+                mkshlib=[
+                    "$(CXX)",
+                    "$(DSO_LDOPTS)",
+                    "-Wl,-pdb,$(LINK_PDBFILE)",
+                    "-o",
+                    "$@",
+                ],
+                mkcshlib=[
+                    "$(CC)",
+                    "$(DSO_LDOPTS)",
+                    "-Wl,-pdb,$(LINK_PDBFILE)",
+                    "-o",
+                    "$@",
+                ],
+            )
+        else:
+            linker = [
+                "$(LINKER)",
+                "-NOLOGO",
+                "-DLL",
+                "-OUT:$@",
+                "-PDB:$(LINK_PDBFILE)",
+                "$(DSO_LDOPTS)",
+            ]
+            return namespace(
+                mkshlib=linker,
+                mkcshlib=linker,
+            )
+
+    cc = ["$(CC)", "$(COMPUTED_C_LDFLAGS)"]
+    cxx = ["$(CXX)", "$(COMPUTED_CXX_LDFLAGS)"]
+    flags = ["$(DSO_LDOPTS)"]
+    output = ["-o", "$@"]
+
+    if target.kernel == "Darwin":
+        soname = []
+    elif target.os == "NetBSD":
+        soname = ["-Wl,-soname,$(DSO_SONAME)"]
+    else:
+        assert compiler.type in ("gcc", "clang")
+
+        soname = ["-Wl,-h,$(DSO_SONAME)"]
+
+    return namespace(
+        mkshlib=cxx + flags + soname + output,
+        mkcshlib=cc + flags + soname + output,
+    )
+
+
+set_config("MKSHLIB", make_shared_library.mkshlib)
+set_config("MKCSHLIB", make_shared_library.mkcshlib)
+
+
+@depends(c_compiler, toolchain_prefix, when=target_is_windows)
+def rc_names(c_compiler, toolchain_prefix):
+    if c_compiler.type in ("gcc", "clang"):
+        return tuple("%s%s" % (p, "windres") for p in ("",) + (toolchain_prefix or ()))
+    return ("llvm-rc",)
+
+
+check_prog("RC", rc_names, paths=clang_search_path, when=target_is_windows)
+
+
+@template
+def ar_config(c_compiler, toolchain_prefix=None):
+    if not toolchain_prefix:
+        toolchain_prefix = dependable(None)
+
+    @depends(toolchain_prefix, c_compiler)
+    def ar_config(toolchain_prefix, c_compiler):
+        if c_compiler.type == "clang-cl":
+            return namespace(
+                names=("llvm-lib",),
+                flags=("-llvmlibthin", "-out:$@"),
+            )
+
+        names = tuple("%s%s" % (p, "ar") for p in (toolchain_prefix or ()) + ("",))
+        if c_compiler.type == "clang":
+            # Get the llvm-ar path as per the output from clang --print-prog-name=llvm-ar
+            # so that we directly get the one under the clang directory, rather than one
+            # that might be in /usr/bin and that might point to one from a different version
+            # of clang.
+            out = check_cmd_output(
+                c_compiler.compiler, "--print-prog-name=llvm-ar", onerror=lambda: None
+            )
+            llvm_ar = out.rstrip() if out else "llvm-ar"
+            names = (llvm_ar,) + names
+
+        return namespace(
+            names=names,
+            flags=("crs", "$@"),
+        )
+
+    return ar_config
+
+
+target_ar_config = ar_config(c_compiler, toolchain_prefix)
+
+target_ar = check_prog("AR", target_ar_config.names, paths=clang_search_path)
+
+set_config("AR_FLAGS", target_ar_config.flags)
+
+
+@depends(c_compiler, extra_toolchain_flags, target_ar, target_ar_config)
+@checking("whether ar supports response files")
+@imports("os")
+@imports(_from="tempfile", _import="mkstemp")
+@imports(_from="__builtin__", _import="FileNotFoundError")
+@imports(_from="mozbuild.configure.util", _import="LineIO")
+def ar_supports_response_files(c_compiler, extra_toolchain_flags, ar, ar_config):
+    lib_path = list_path = None
+    try:
+        fd, obj_path = mkstemp(prefix="conftest.", suffix=".o")
+        os.close(fd)
+        if (
+            try_invoke_compiler(
+                # No configure_cache because it would not create the
+                # expected output file.
+                None,
+                [c_compiler.compiler] + c_compiler.flags,
+                c_compiler.language,
+                "void foo() {}",
+                ["-c", "-o", obj_path] + (extra_toolchain_flags or []),
+                wrapper=c_compiler.wrapper,
+                onerror=lambda: None,
+            )
+            is not None
+        ):
+            fd, list_path = mkstemp(prefix="conftest.", suffix=".list")
+            with os.fdopen(fd, "w") as list:
+                list.write(obj_path)
+                log.debug("Creating `%s` with content:", list_path)
+                log.debug("| %s", obj_path)
+            fd, lib_path = mkstemp(prefix="conftest.", suffix=".a")
+            os.close(fd)
+            os.remove(lib_path)
+            ar_command = (
+                [ar]
+                + [x.replace("$@", lib_path) for x in ar_config.flags]
+                + ["@" + list_path]
+            )
+            result = check_cmd_output(*ar_command, onerror=lambda: None)
+            return result is not None
+    finally:
+        for cleanup_path in (obj_path, list_path, lib_path):
+            if cleanup_path:
+                try:
+                    os.remove(cleanup_path)
+                except FileNotFoundError:
+                    pass
+
+
+set_config("AR_SUPPORTS_RESPONSE_FILE", True, when=ar_supports_response_files)
+
+host_ar_config = ar_config(host_c_compiler)
+
+check_prog("HOST_AR", host_ar_config.names, paths=clang_search_path)
+
+
+@depends(toolchain_prefix, c_compiler)
+def nm_names(toolchain_prefix, c_compiler):
+    names = tuple("%s%s" % (p, "nm") for p in (toolchain_prefix or ()) + ("",))
+    if c_compiler.type == "clang":
+        # Get the llvm-nm path as per the output from clang --print-prog-name=llvm-nm
+        # so that we directly get the one under the clang directory, rather than one
+        # that might be in /usr/bin and that might point to one from a different version
+        # of clang.
+        out = check_cmd_output(
+            c_compiler.compiler, "--print-prog-name=llvm-nm", onerror=lambda: None
+        )
+        llvm_nm = out.rstrip() if out else "llvm-nm"
+        names = (llvm_nm,) + names
+
+    return names
+
+
+check_prog("NM", nm_names, paths=clang_search_path, when=target_has_linux_kernel)
+
+
+option("--enable-cpp-rtti", help="Enable C++ RTTI")
+
+add_old_configure_assignment("_MOZ_USE_RTTI", "1", when="--enable-cpp-rtti")
+
+
+option(
+    "--enable-path-remapping",
+    nargs="*",
+    choices=("c", "rust"),
+    help="Enable remapping source and object paths in compiled outputs.",
+)
+
+
+@depends("--enable-path-remapping")
+def path_remapping(value):
+    if len(value):
+        return value
+    if bool(value):
+        return ["c", "rust"]
+    return []
+
+
+@depends(
+    target,
+    build_environment,
+    target_sysroot.path,
+    valid_windows_sdk_dir,
+    vc_path,
+    when="--enable-path-remapping",
+)
+def path_remappings(target, build_env, sysroot_path, windows_sdk_dir, vc_path):
+    win = target.kernel == "WINNT"
+
+    # The prefix maps are processed in the order they're specified on the
+    # command line.  Therefore, to accommodate object directories in the source
+    # directory, it's important that we map the topobjdir before the topsrcdir,
+    # 'cuz we might have /src/obj/=/o/ and /src/=/s/.  The various other
+    # directories might be subdirectories of topsrcdir as well, so they come
+    # earlier still.
+
+    path_remappings = []
+
+    # We will have only one sysroot or SDK, so all can have the same mnemonic: K
+    # for "kit" (since S is taken for "source").  See
+    # https://blog.llvm.org/2019/11/deterministic-builds-with-clang-and-lld.html
+    # for how to use the Windows `subst` command to map these in debuggers and
+    # IDEs.
+    if sysroot_path:
+        path_remappings.append((sysroot_path, "k:/" if win else "/sysroot/"))
+    if windows_sdk_dir:
+        path_remappings.append(
+            (windows_sdk_dir.path, "k:/" if win else "/windows_sdk/")
+        )
+    if vc_path:
+        path_remappings.append((vc_path, "v:/" if win else "/vc/"))
+
+    path_remappings += [
+        (build_env.topobjdir, "o:/" if win else "/topobjdir/"),
+        (build_env.topsrcdir, "s:/" if win else "/topsrcdir/"),
+    ]
+
+    path_remappings = [
+        (normsep(old).rstrip("/") + "/", new) for old, new in path_remappings
+    ]
+
+    # It is tempting to sort these, but we want the order to be the same across
+    # machines so that we can share cache hits.  Therefore we reject bad
+    # configurations rather than trying to make the configuration good.
+    for i in range(len(path_remappings) - 1):
+        p = path_remappings[i][0]
+        for q, _ in path_remappings[i + 1 :]:
+            if q.startswith(p):
+                die(f"Cannot remap paths because {p} is an ancestor of {q}")
+
+    return path_remappings
+
+
+set_config("MMX_FLAGS", ["-mmmx"])
+set_config("SSE_FLAGS", ["-msse"])
+set_config("SSE2_FLAGS", ["-msse2"])
+set_config("SSSE3_FLAGS", ["-mssse3"])
+set_config("SSE4_2_FLAGS", ["-msse4.2"])
+set_config("FMA_FLAGS", ["-mfma"])
+set_config("AVX2_FLAGS", ["-mavx2"])
+set_config(
+    "AVXVNNI_FLAGS",
+    ["-mavxvnni"],
+    try_compile(check_msg="for -mavxvnni support", flags=["-mavxvnni"]),
+)
+set_config(
+    "AVX512BW_FLAGS",
+    ["-mavx512bw", "-mavx512f", "-mavx512dq", "-mavx512cd"],
+    try_compile(
+        check_msg="for -mavx512bw support",
+        flags=["-mavx512bw", "-mavx512f", "-mavx512dq", "-mavx512cd"],
+    ),
+)
+
+# AVX512VNNI can be based on either avx512bw or avx512vbmi. We choose the
+# former.
+set_config(
+    "AVX512VNNI_FLAGS",
+    ["-mavx512vnni", "-mavx512bw", "-mavx512f", "-mavx512dq", "-mavx512cd"],
+    try_compile(
+        check_msg="for -mavx512vnni support",
+        flags=["-mavx512vnni", "-mavx512bw", "-mavx512f", "-mavx512dq", "-mavx512cd"],
+    ),
+)
diff --git a/build/moz.configure/update-programs.configure b/build/moz.configure/update-programs.configure
new file mode 100644
index 0000000000..3be098308d
--- /dev/null
+++ b/build/moz.configure/update-programs.configure
@@ -0,0 +1,198 @@
+# -*- 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/.
+
+
+# Updater
+# ==============================================================
+@depends(build_project)
+def updater_default(build_project):
+    return build_project != "mobile/android"
+
+
+option(
+    "--enable-updater",
+    default=updater_default,
+    help="{Enable|Disable} building the updater",
+)
+
+set_config("MOZ_UPDATER", True, when="--enable-updater")
+set_define("MOZ_UPDATER", True, when="--enable-updater")
+
+# Updates that do not verify signatures
+# ==============================================================
+
+option(
+    "--enable-unverified-updates",
+    default=False,
+    help="Enable application update without verifying MAR or updater binary signatures",
+)
+
+
+@depends("--enable-unverified-updates", "--enable-compile-environment")
+def disable_unverified_updates(unverified_updates, compile_environment):
+    if unverified_updates:
+        if not compile_environment:
+            die("--enable-unverified-updates requires --enable-compile-environment")
+    return not unverified_updates
+
+
+set_define(
+    "MOZ_VERIFY_MAR_SIGNATURE",
+    depends_if(disable_unverified_updates)(lambda _: True),
+)
+set_config(
+    "MOZ_VERIFY_MAR_SIGNATURE",
+    True,
+    depends_if(disable_unverified_updates)(lambda _: True),
+)
+
+set_config(
+    "DISABLE_UPDATER_AUTHENTICODE_CHECK",
+    True,
+    depends_if("--enable-unverified-updates")(lambda _: True),
+)
+
+# Use NSS for MAR signatures even on platforms where system libraries are
+# supported (currently Windows and macOS).
+# ==============================================================
+
+can_toggle_nss_mar = target_is_windows | target_is_osx
+
+option(
+    "--enable-nss-mar",
+    when=can_toggle_nss_mar,
+    help="Enable using NSS to check MAR signatures instead of system crypto.",
+)
+
+
+@depends(
+    depends("--enable-nss-mar", when=can_toggle_nss_mar)(lambda x: x),
+    can_toggle_nss_mar,
+)
+def enable_nss_mar(enabled, can_toggle_nss_mar):
+    return enabled or not can_toggle_nss_mar
+
+
+set_config("MOZ_USE_NSS_FOR_MAR", True, when=enable_nss_mar)
+
+# Maintenance service (Windows only)
+# ==============================================================
+
+
+@depends("--enable-updater")
+def maintenance_service_default(updater):
+    return bool(updater)
+
+
+option(
+    "--enable-maintenance-service",
+    when=target_is_windows,
+    default=maintenance_service_default,
+    help="{Enable|Disable} building of maintenance service",
+)
+
+set_define(
+    "MOZ_MAINTENANCE_SERVICE",
+    depends_if("--enable-maintenance-service", when=target_is_windows)(lambda _: True),
+)
+set_config(
+    "MOZ_MAINTENANCE_SERVICE",
+    depends_if("--enable-maintenance-service", when=target_is_windows)(lambda _: True),
+)
+
+
+@depends("--enable-maintenance-service", "--enable-updater", when=target_is_windows)
+def check_maintenance_service(mainteance_service, updater):
+    if mainteance_service and not updater:
+        die("--enable-updater is required to --enable-maintenance-service")
+    return mainteance_service
+
+
+# Update agent (currently Windows and macOS only)
+# This is an independent task that runs on a schedule to
+# check for, download, and install updates.
+# ==============================================================
+
+
+@depends("--enable-backgroundtasks", "--enable-updater", build_project)
+def update_agent_default(backgroundtasks, updater, build_project):
+    return bool(backgroundtasks) and bool(updater) and build_project == "browser"
+
+
+option(
+    "--disable-update-agent",
+    when=target_is_windows | target_is_osx,
+    default=update_agent_default,
+    help="{Enable|Disable} building update agent",
+)
+
+set_config(
+    "MOZ_UPDATE_AGENT",
+    depends_if("--enable-update-agent", when=target_is_windows | target_is_osx)(
+        lambda _: True
+    ),
+)
+
+
+@depends(
+    "--enable-update-agent",
+    "--enable-backgroundtasks",
+    "--enable-updater",
+    when=target_is_windows | target_is_osx,
+)
+def check_update_agent(update_agent, backgroundtasks, updater):
+    if update_agent and not backgroundtasks:
+        die("--enable-backgroundtasks is required to --enable-update-agent")
+    if update_agent and not updater:
+        die("--enable-updater is required to --enable-update-agent")
+    return update_agent
+
+
+# Enable or disable the default browser agent, which monitors the user's default
+# browser setting on Windows.
+# ==============================================================================
+
+
+@depends(target, build_project)
+def default_browser_agent_default(target, build_project):
+    return target.os == "WINNT" and build_project == "browser"
+
+
+option(
+    "--enable-default-browser-agent",
+    default=default_browser_agent_default,
+    help="{Enable|Disable} building the default browser agent",
+)
+
+
+@depends("--enable-default-browser-agent", when=target_is_windows)
+def default_agent_flag(enabled):
+    if enabled:
+        return True
+
+
+set_config("MOZ_DEFAULT_BROWSER_AGENT", default_agent_flag)
+
+
+# Enable or disable the notification server, which allows Windows native
+# notifications to persist when the application is not running and relaunch as
+# necessary.
+# ==============================================================================
+@depends(target, build_project)
+def notification_server_default(target, build_project):
+    return target.os == "WINNT" and build_project in (
+        "browser",
+        "comm/mail",
+    )
+
+
+option(
+    "--disable-notification-server",
+    when=notification_server_default,
+    help="Disable building the notification server",
+)
+
+set_config("MOZ_NOTIFICATION_SERVER", True, when="--enable-notification-server")
diff --git a/build/moz.configure/util.configure b/build/moz.configure/util.configure
new file mode 100644
index 0000000000..d93b91fcdd
--- /dev/null
+++ b/build/moz.configure/util.configure
@@ -0,0 +1,550 @@
+# -*- 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/.
+
+
+@imports("sys")
+def die(*args):
+    "Print an error and terminate configure."
+    log.error(*args)
+    sys.exit(1)
+
+
+@imports(_from="mozbuild.configure", _import="ConfigureError")
+def configure_error(message):
+    """Raise a programming error and terminate configure.
+    Primarily for use in moz.configure templates to sanity check
+    their inputs from moz.configure usage."""
+    raise ConfigureError(message)
+
+
+# A wrapper to obtain a process' output and return code.
+# Returns a tuple (retcode, stdout, stderr).
+@imports("os")
+@imports("subprocess")
+@imports(_from="mozbuild.shellutil", _import="quote")
+@imports(_from="mozbuild.util", _import="system_encoding")
+def get_cmd_output(*args, **kwargs):
+    log.debug("Executing: `%s`", quote(*args))
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        # On Python 2 on Windows, close_fds prevents the process from inheriting
+        # stdout/stderr. Elsewhere, it simply prevents it from inheriting extra
+        # file descriptors, which is what we want.
+        close_fds=os.name != "nt",
+        encoding=system_encoding,
+        errors="replace",
+        **kwargs,
+    )
+    stdout, stderr = proc.communicate()
+    return proc.wait(), stdout, stderr
+
+
+# A wrapper to obtain a process' output that returns the output generated
+# by running the given command if it exits normally, and streams that
+# output to log.debug and calls die or the given error callback if it
+# does not.
+@imports(_from="mozbuild.configure.util", _import="LineIO")
+@imports(_from="mozbuild.shellutil", _import="quote")
+def check_cmd_output(*args, **kwargs):
+    onerror = kwargs.pop("onerror", None)
+
+    with log.queue_debug():
+        retcode, stdout, stderr = get_cmd_output(*args, **kwargs)
+        if retcode == 0:
+            with LineIO(lambda l: log.debug("| %s", l)) as o:
+                o.write(stderr)
+            return stdout
+
+        log.debug("The command returned non-zero exit status %d.", retcode)
+        for out, desc in ((stdout, "output"), (stderr, "error output")):
+            if out:
+                log.debug("Its %s was:", desc)
+                with LineIO(lambda l: log.debug("| %s", l)) as o:
+                    o.write(out)
+        if onerror:
+            return onerror()
+        die("Command `%s` failed with exit status %d." % (quote(*args), retcode))
+
+
+@imports("os")
+def is_absolute_or_relative(path):
+    if os.altsep and os.altsep in path:
+        return True
+    return os.sep in path
+
+
+@imports(_import="mozpack.path", _as="mozpath")
+def normsep(path):
+    return mozpath.normsep(path)
+
+
+@imports("ctypes")
+@imports(_from="ctypes", _import="wintypes")
+@imports(_from="mozbuild.configure.constants", _import="WindowsBinaryType")
+def windows_binary_type(path):
+    """Obtain the type of a binary on Windows.
+
+    Returns WindowsBinaryType constant.
+    """
+    GetBinaryTypeW = ctypes.windll.kernel32.GetBinaryTypeW
+    GetBinaryTypeW.argtypes = [wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD)]
+    GetBinaryTypeW.restype = wintypes.BOOL
+
+    bin_type = wintypes.DWORD()
+    res = GetBinaryTypeW(path, ctypes.byref(bin_type))
+    if not res:
+        die("could not obtain binary type of %s" % path)
+
+    if bin_type.value == 0:
+        return WindowsBinaryType("win32")
+    elif bin_type.value == 6:
+        return WindowsBinaryType("win64")
+    # If we see another binary type, something is likely horribly wrong.
+    else:
+        die("unsupported binary type on %s: %s" % (path, bin_type))
+
+
+@imports("ctypes")
+@imports(_from="ctypes", _import="wintypes")
+def get_GetShortPathNameW():
+    GetShortPathNameW = ctypes.windll.kernel32.GetShortPathNameW
+    GetShortPathNameW.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.DWORD]
+    GetShortPathNameW.restype = wintypes.DWORD
+    return GetShortPathNameW
+
+
+@template
+@imports("ctypes")
+@imports("platform")
+@imports(_from="mozbuild.shellutil", _import="quote")
+def normalize_path():
+    # Until the build system can properly handle programs that need quoting,
+    # transform those paths into their short version on Windows (e.g.
+    # c:\PROGRA~1...).
+    if platform.system() == "Windows":
+        GetShortPathNameW = get_GetShortPathNameW()
+
+        def normalize_path(path):
+            path = normsep(path)
+            if quote(path) == path:
+                return path
+            size = 0
+            while True:
+                out = ctypes.create_unicode_buffer(size)
+                needed = GetShortPathNameW(path, out, size)
+                if size >= needed:
+                    if " " in out.value:
+                        die(
+                            "GetShortPathName returned a long path name: `%s`. "
+                            "Use `fsutil file setshortname' "
+                            "to create a short name "
+                            "for any components of this path "
+                            "that have spaces.",
+                            out.value,
+                        )
+                    return normsep(out.value)
+                size = needed
+
+    else:
+
+        def normalize_path(path):
+            return normsep(path)
+
+    return normalize_path
+
+
+normalize_path = normalize_path()
+
+
+# Locates the given program using which, or returns the given path if it
+# exists.
+# The `paths` parameter may be passed to search the given paths instead of
+# $PATH.
+@imports("sys")
+@imports(_from="os", _import="pathsep")
+@imports(_from="os", _import="environ")
+@imports(_from="mozfile", _import="which")
+def find_program(file, paths=None, allow_spaces=False):
+    def which_normalize(file, path, exts):
+        path = which(file, path=path, exts=exts)
+        if not path:
+            return None
+        if not allow_spaces:
+            return normalize_path(path)
+        return normsep(path)
+
+    # The following snippet comes from `which` itself, with a slight
+    # modification to use lowercase extensions, because it's confusing rustup
+    # (on top of making results not really appealing to the eye).
+
+    # Windows has the concept of a list of extensions (PATHEXT env var).
+    if sys.platform.startswith("win"):
+        exts = [e.lower() for e in environ.get("PATHEXT", "").split(pathsep)]
+        # If '.exe' is not in exts then obviously this is Win9x and
+        # or a bogus PATHEXT, then use a reasonable default.
+        if ".exe" not in exts:
+            exts = [".com", ".exe", ".bat"]
+    else:
+        exts = None
+
+    if is_absolute_or_relative(file):
+        return which_normalize(
+            os.path.basename(file), path=os.path.dirname(file), exts=exts
+        )
+
+    if paths:
+        if not isinstance(paths, (list, tuple)):
+            die(
+                "Paths provided to find_program must be a list of strings, " "not %r",
+                paths,
+            )
+        paths = pathsep.join(paths)
+
+    return which_normalize(file, path=paths, exts=exts)
+
+
+@imports("os")
+@imports(_from="mozbuild.configure.util", _import="LineIO")
+@imports(_from="tempfile", _import="mkstemp")
+@imports(_import="subprocess")
+def try_invoke_compiler(
+    configure_cache, compiler, language, source, flags=None, onerror=None, wrapper=[]
+):
+    compiler_path = compiler[0]
+    compiler = wrapper + compiler
+    use_cache = configure_cache is not None
+
+    if use_cache and compiler_path not in configure_cache.version_checked_compilers:
+        try:
+            version_info = subprocess.check_output(
+                [compiler_path, "--version"],
+                encoding="UTF-8",
+            ).strip()
+        except subprocess.CalledProcessError:
+            # There's no sane way to use the cache without the version details, so
+            # we need to avoid both reads from and writes to the cache.
+            use_cache = False
+            pass
+
+        if use_cache:
+            if version_info != configure_cache.setdefault(compiler_path, {}).get(
+                "version"
+            ):
+                configure_cache[compiler_path].clear()
+
+            configure_cache[compiler_path]["version"] = version_info
+            configure_cache.version_checked_compilers.add(compiler_path)
+
+    flags = flags or []
+
+    if use_cache:
+        key = " ".join(compiler) + language + source + (" ".join(flags) or "")
+
+        if key in configure_cache[compiler_path]:
+            return configure_cache[compiler_path][key]
+
+    if not isinstance(flags, (list, tuple)):
+        die("Flags provided to try_compile must be a list of strings, " "not %r", flags)
+
+    suffix = {
+        "C": ".c",
+        "C++": ".cpp",
+    }[language]
+
+    fd, path = mkstemp(prefix="conftest.", suffix=suffix, text=True)
+    try:
+        source = source.encode("ascii", "replace")
+
+        log.debug("Creating `%s` with content:", path)
+        with LineIO(lambda l: log.debug("| %s", l)) as out:
+            out.write(source)
+
+        os.write(fd, source)
+        os.close(fd)
+        cmd = compiler + [path] + list(flags)
+        kwargs = {"onerror": onerror}
+        val = check_cmd_output(*cmd, **kwargs)
+        if use_cache:
+            configure_cache[compiler_path][key] = val
+        return val
+    finally:
+        os.remove(path)
+
+
+def unique_list(l):
+    result = []
+    for i in l:
+        if l not in result:
+            result.append(i)
+    return result
+
+
+# Get values out of the Windows registry. This function can only be called on
+# Windows.
+# The `pattern` argument is a string starting with HKEY_ and giving the full
+# "path" of the registry key to get the value for, with backslash separators.
+# The string can contains wildcards ('*').
+# The result of this functions is an enumerator yielding tuples for each
+# match. Each of these tuples contains the key name matching wildcards
+# followed by the value.
+#
+# The `get_32_and_64_bit` argument is a boolean, if True then it will return the
+# values from the 32-bit and 64-bit registry views. This defaults to False,
+# which will return the view depending on the bitness of python.
+#
+# Examples:
+#   get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+#                       r'Windows Kits\Installed Roots\KitsRoot*')
+#   yields e.g.:
+#     ('KitsRoot81', r'C:\Program Files (x86)\Windows Kits\8.1\')
+#     ('KitsRoot10', r'C:\Program Files (x86)\Windows Kits\10\')
+#
+#   get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+#                       r'Windows Kits\Installed Roots\KitsRoot8.1')
+#   yields e.g.:
+#     (r'C:\Program Files (x86)\Windows Kits\8.1\',)
+#
+#   get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+#                       r'Windows Kits\Installed Roots\KitsRoot8.1',
+#                       get_32_and_64_bit=True)
+#   yields e.g.:
+#     (r'C:\Program Files (x86)\Windows Kits\8.1\',)
+#     (r'C:\Program Files\Windows Kits\8.1\',)
+#
+#   get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+#                       r'Windows Kits\*\KitsRoot*')
+#   yields e.g.:
+#     ('Installed Roots', 'KitsRoot81',
+#      r'C:\Program Files (x86)\Windows Kits\8.1\')
+#     ('Installed Roots', 'KitsRoot10',
+#      r'C:\Program Files (x86)\Windows Kits\10\')
+#
+#   get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+#                       r'VisualStudio\VC\*\x86\*\Compiler')
+#   yields e.g.:
+#     ('19.0', 'arm', r'C:\...\amd64_arm\cl.exe')
+#     ('19.0', 'x64', r'C:\...\amd64\cl.exe')
+#     ('19.0', 'x86', r'C:\...\amd64_x86\cl.exe')
+@imports(_import="winreg")
+@imports(_from="__builtin__", _import="WindowsError")
+@imports(_from="fnmatch", _import="fnmatch")
+def get_registry_values(pattern, get_32_and_64_bit=False):
+    def enum_helper(func, key):
+        i = 0
+        while True:
+            try:
+                yield func(key, i)
+            except WindowsError:
+                break
+            i += 1
+
+    def get_keys(key, pattern, access_mask):
+        try:
+            s = winreg.OpenKey(key, "\\".join(pattern[:-1]), 0, access_mask)
+        except WindowsError:
+            return
+        for k in enum_helper(winreg.EnumKey, s):
+            if fnmatch(k, pattern[-1]):
+                try:
+                    yield k, winreg.OpenKey(s, k, 0, access_mask)
+                except WindowsError:
+                    pass
+
+    def get_values(key, pattern, access_mask):
+        try:
+            s = winreg.OpenKey(key, "\\".join(pattern[:-1]), 0, access_mask)
+        except WindowsError:
+            return
+        for k, v, t in enum_helper(winreg.EnumValue, s):
+            if fnmatch(k, pattern[-1]):
+                yield k, v
+
+    def split_pattern(pattern):
+        subpattern = []
+        for p in pattern:
+            subpattern.append(p)
+            if "*" in p:
+                yield subpattern
+                subpattern = []
+        if subpattern:
+            yield subpattern
+
+    def get_all_values(keys, pattern, access_mask):
+        for i, p in enumerate(pattern):
+            next_keys = []
+            for base_key in keys:
+                matches = base_key[:-1]
+                base_key = base_key[-1]
+                if i == len(pattern) - 1:
+                    want_name = "*" in p[-1]
+                    for name, value in get_values(base_key, p, access_mask):
+                        yield matches + ((name, value) if want_name else (value,))
+                else:
+                    for name, k in get_keys(base_key, p, access_mask):
+                        next_keys.append(matches + (name, k))
+            keys = next_keys
+
+    pattern = pattern.split("\\")
+    assert pattern[0].startswith("HKEY_")
+    keys = [(getattr(winreg, pattern[0]),)]
+    pattern = list(split_pattern(pattern[1:]))
+    if get_32_and_64_bit:
+        for match in get_all_values(
+            keys, pattern, winreg.KEY_READ | winreg.KEY_WOW64_32KEY
+        ):
+            yield match
+        for match in get_all_values(
+            keys, pattern, winreg.KEY_READ | winreg.KEY_WOW64_64KEY
+        ):
+            yield match
+    else:
+        for match in get_all_values(keys, pattern, winreg.KEY_READ):
+            yield match
+
+
+@imports(_from="mozbuild.configure.util", _import="Version", _as="_Version")
+def Version(v):
+    "A version number that can be compared usefully."
+    return _Version(v)
+
+
+# Denotes a deprecated option. Combines option() and @depends:
+# @deprecated_option('--option')
+# def option(value):
+#     ...
+# @deprecated_option() takes the same arguments as option(), except `help`.
+# The function may handle the option like a typical @depends function would,
+# but it is recommended it emits a deprecation error message suggesting an
+# alternative option to use if there is one.
+@template
+def deprecated_option(*args, **kwargs):
+    assert "help" not in kwargs
+    kwargs["help"] = "Deprecated"
+    opt = option(*args, **kwargs)
+    kwargs = {k: v for k, v in kwargs.items() if k == "when"}
+
+    def decorator(func):
+        @depends(opt.option, **kwargs)
+        def deprecated(value):
+            if value.origin != "default":
+                return func(value)
+
+        return deprecated
+
+    return decorator
+
+
+# Turn an object into an object that can be used as an argument to @depends.
+# The given object can be a literal value, a function that takes no argument,
+# or, for convenience, a @depends function.
+@template
+@imports(_from="mozbuild.configure", _import="SandboxDependsFunction")
+def dependable(obj):
+    if isinstance(obj, SandboxDependsFunction):
+        return obj
+    return depends(when=True)(obj)
+
+
+always = dependable(True)
+never = dependable(False)
+
+
+# Create a decorator that will only execute the body of a function
+# if the passed function returns True when passed all positional
+# arguments.
+@template
+def depends_tmpl(eval_args_fn, *args, **kwargs):
+    if kwargs:
+        assert len(kwargs) == 1
+        when = kwargs["when"]
+    else:
+        when = None
+
+    def decorator(func):
+        @depends(*args, when=when)
+        def wrapper(*args):
+            if eval_args_fn(args):
+                return func(*args)
+
+        return wrapper
+
+    return decorator
+
+
+# Like @depends, but the decorated function is only called if one of the
+# arguments it would be called with has a positive value (bool(value) is True)
+@template
+def depends_if(*args, **kwargs):
+    return depends_tmpl(any, *args, **kwargs)
+
+
+# Like @depends, but the decorated function is only called if all of the
+# arguments it would be called with have a positive value.
+@template
+def depends_all(*args, **kwargs):
+    return depends_tmpl(all, *args, **kwargs)
+
+
+# A template providing a shorthand for setting a variable. The created
+# option will only be settable with imply_option.
+# It is expected that a project-specific moz.configure will call imply_option
+# to set a value other than the default.
+# If required, the set_as_define argument will additionally cause the variable
+# to be set using set_define.
+@template
+def project_flag(env=None, set_as_define=False, **kwargs):
+    if not env:
+        configure_error("A project_flag must be passed a variable name to set.")
+
+    opt = option(env=env, possible_origins=("implied",), **kwargs)
+
+    @depends(opt.option)
+    def option_implementation(value):
+        if value:
+            if len(value):
+                return value
+            return bool(value)
+
+    set_config(env, option_implementation)
+    if set_as_define:
+        set_define(env, option_implementation)
+
+
+@template
+@imports(_from="mozbuild.configure.constants", _import="RaiseErrorOnUse")
+def obsolete_config(name, *, replacement):
+    set_config(name, RaiseErrorOnUse(f"{name} is obsolete. Use {replacement} instead."))
+
+
+# Hacks related to old-configure
+# ==============================
+
+
+@dependable
+def old_configure_assignments():
+    return []
+
+
+@template
+def add_old_configure_assignment(var, value, when=None):
+    var = dependable(var)
+    value = dependable(value)
+
+    @depends(old_configure_assignments, var, value, when=when)
+    @imports(_from="mozbuild.shellutil", _import="quote")
+    def add_assignment(assignments, var, value):
+        if var is None or value is None:
+            return
+        if value is True:
+            assignments.append((var, "1"))
+        elif value is False:
+            assignments.append((var, ""))
+        else:
+            if isinstance(value, (list, tuple)):
+                value = quote(*value)
+            assignments.append((var, str(value)))
diff --git a/build/moz.configure/warnings.configure b/build/moz.configure/warnings.configure
new file mode 100644
index 0000000000..9340c9e6ab
--- /dev/null
+++ b/build/moz.configure/warnings.configure
@@ -0,0 +1,324 @@
+# -*- Mode: python; c-basic-offset: 4; 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/.
+
+option(
+    "--enable-warnings-as-errors",
+    env="MOZ_ENABLE_WARNINGS_AS_ERRORS",
+    default=depends("MOZ_AUTOMATION")(lambda x: bool(x)),
+    help="{Enable|Disable} treating warnings as errors",
+)
+
+
+@depends("--enable-warnings-as-errors")
+def warnings_as_errors(warnings_as_errors):
+    if not warnings_as_errors:
+        return ""
+
+    return "-Werror"
+
+
+set_config("WARNINGS_AS_ERRORS", warnings_as_errors)
+
+not_clang_cl = depends(c_compiler)(lambda c: c.type != "clang-cl")
+
+# GCC/Clang warnings:
+# https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
+# https://clang.llvm.org/docs/DiagnosticsReference.html
+
+# Lots of useful warnings
+add_warning("-Wall", when=not_clang_cl)
+# In clang-cl, -Wall actually means -Weverything. -W3 does mean -Wall.
+add_warning("-W3", when=depends(c_compiler)(lambda c: c.type == "clang-cl"))
+
+# catch implicit truncation of enum values assigned to smaller bit fields
+check_and_add_warning("-Wbitfield-enum-conversion")
+
+# catches deprecated implicit capture of `this` in lambdas.
+check_and_add_warning("-Wdeprecated-this-capture", cxx_compiler)
+
+# catches bugs, e.g. "if (c); foo();", few false positives
+add_warning("-Wempty-body")
+
+# catches mismatched printf integer sizes.
+check_and_add_warning("-Wformat-type-confusion")
+
+# catches return types with qualifiers like const
+add_warning("-Wignored-qualifiers")
+
+# catches pointer arithmetic using NULL or sizeof(void)
+add_warning("-Wpointer-arith")
+
+# catch modifying constructor parameter that shadows member variable
+check_and_add_warning("-Wshadow-field-in-constructor-modified")
+
+# catches comparing signed/unsigned ints
+add_warning("-Wsign-compare")
+
+# catches comparisons of values and sized types are always true or false
+check_and_add_warning("-Wtautological-constant-in-range-compare")
+
+# catches overflow bugs, few false positives
+add_warning("-Wtype-limits")
+
+# This can be triggered by certain patterns used deliberately in portable code
+check_and_add_warning("-Wno-error=tautological-type-limit-compare")
+
+# catches some dead code
+add_warning("-Wunreachable-code")
+check_and_add_warning("-Wunreachable-code-return")
+
+# catches parameters that are set but not read
+# Only enable on clang because gcc reports false positives.
+check_and_add_warning(
+    "-Wunused-but-set-parameter",
+    when=depends(c_compiler)(lambda c: c.type in ("clang", "clang-cl")),
+)
+
+# turned on by -Wall, but we use offsetof on non-POD types frequently
+add_warning("-Wno-invalid-offsetof", cxx_compiler)
+
+# catches objects passed by value to variadic functions.
+check_and_add_warning("-Wclass-varargs")
+
+# catches empty if/switch/for initialization statements that have no effect
+check_and_add_warning("-Wempty-init-stmt", cxx_compiler)
+
+# catches some implicit conversion of floats to ints
+check_and_add_warning("-Wfloat-overflow-conversion")
+check_and_add_warning("-Wfloat-zero-conversion")
+
+# catches issues around loops
+check_and_add_warning("-Wloop-analysis")
+# But, disable range-loop-analysis because it can raise unhelpful false
+# positives.
+check_and_add_warning("-Wno-range-loop-analysis")
+
+# Enable some C++20 compat warnings. We can remove these flags after we compile
+# as C++20 (bug 1768116), because they will be enabled by default:
+check_and_add_warning("-Wc++2a-compat", cxx_compiler)
+check_and_add_warning("-Wcomma-subscript", cxx_compiler)
+check_and_add_warning("-Wenum-compare-conditional")
+check_and_add_warning("-Wenum-float-conversion")
+check_and_add_warning("-Wvolatile", cxx_compiler)
+
+# Downgrade some C++20 warnings-as-errors to warnings that we can fix after we
+# compile as C++20 (bug 1768116). They don't need to block upgrading to C++20.
+check_and_add_warning("-Wno-error=deprecated", cxx_compiler)
+check_and_add_warning("-Wno-error=deprecated-anon-enum-enum-conversion", cxx_compiler)
+check_and_add_warning("-Wno-error=deprecated-enum-enum-conversion", cxx_compiler)
+check_and_add_warning("-Wno-error=deprecated-pragma", cxx_compiler)
+check_and_add_warning("-Wno-error=deprecated-this-capture", cxx_compiler)
+
+# catches possible misuse of the comma operator
+check_and_add_warning("-Wcomma", cxx_compiler)
+
+# catches duplicated conditions in if-else-if chains
+check_and_add_warning("-Wduplicated-cond")
+
+# catches unintentional switch case fallthroughs
+check_and_add_warning("-Wimplicit-fallthrough", cxx_compiler)
+
+# Warn about suspicious uses of logical operators in expressions.
+check_and_add_warning("-Wlogical-op")
+
+# Enable some ObjC diagnostics that are only relevant when targeting macOS:
+with only_when(depends(target)(lambda t: t.kernel == "Darwin")):
+    # catch redeclaration of ObjC method parameter name
+    check_and_add_warning("-Wduplicate-method-arg")
+
+    # catch multiple declarations of ObjC method found
+    check_and_add_warning("-Wduplicate-method-match")
+
+    # catch ObjC method with no return type specified
+    check_and_add_warning("-Wmissing-method-return-type")
+
+    # catch implicit conversions between ObjC BOOL and int
+    check_and_add_warning("-Wobjc-signed-char-bool")
+
+    # catch semicolon before ObjC method body
+    check_and_add_warning("-Wsemicolon-before-method-body")
+
+    # catch ObjC method parameter type not matching super class method
+    check_and_add_warning("-Wsuper-class-method-mismatch")
+
+# catches string literals used in boolean expressions
+check_and_add_warning("-Wstring-conversion")
+
+# we inline 'new' and 'delete' in mozalloc
+check_and_add_warning("-Wno-inline-new-delete", cxx_compiler)
+
+# Prevent the following GCC warnings from being treated as errors:
+# too many false positives
+check_and_add_warning("-Wno-error=maybe-uninitialized")
+
+# we don't want our builds held hostage when a platform-specific API
+# becomes deprecated.
+check_and_add_warning("-Wno-error=deprecated-declarations")
+
+# false positives depending on optimization
+check_and_add_warning("-Wno-error=array-bounds")
+
+# false positives depending on optimizations
+check_and_add_warning("-Wno-error=free-nonheap-object")
+
+# Would be a pain to fix all occurrences, for very little gain
+check_and_add_warning("-Wno-multistatement-macros")
+
+# Disable the -Werror for -Wclass-memaccess as we have a long
+# tail of issues to fix
+check_and_add_warning("-Wno-error=class-memaccess")
+
+# -Watomic-alignment is a new warning in clang 7 that seems way too broad.
+# https://bugs.llvm.org/show_bug.cgi?id=38593
+check_and_add_warning("-Wno-error=atomic-alignment")
+
+# New warning with clang 15. Catches uses of deprecated builtins in abseil-cpp.
+# https://bugzilla.mozilla.org/show_bug.cgi?id=1779528
+check_and_add_warning("-Wno-error=deprecated-builtins")
+
+# catches format/argument mismatches with printf
+c_format_warning, cxx_format_warning = check_and_add_warning(
+    "-Wformat", when=depends(target)(lambda t: t.kernel != "WINNT")
+)
+
+# Add compile-time warnings for unprotected functions and format functions
+# that represent possible security problems. Enable this only when -Wformat
+# is enabled, otherwise it is an error
+check_and_add_warning("-Wformat-security", when=c_format_warning & cxx_format_warning)
+check_and_add_warning("-Wformat-overflow=2", when=c_format_warning & cxx_format_warning)
+
+# Other Windows specific things
+with only_when(target_is_windows):
+    # When compiling for Windows with gcc, we encounter lots of "#pragma warning"'s
+    # which is an MSVC-only pragma that GCC does not recognize.
+    # With clang-cl, as it claims to be MSVC it would be difficult to add
+    # #if defined(_MSC_VER) && !defined(__clang__) everywhere we use such pragmas,
+    # so just ignore them.
+    check_and_add_warning("-Wno-unknown-pragmas")
+
+    with only_when(depends(c_compiler)(lambda c: c.type == "clang-cl")):
+        # We get errors about various #pragma intrinsic directives from
+        # clang-cl, and we don't need to hear about those.
+        check_and_add_warning("-Wno-ignored-pragmas")
+
+        # clang-cl's Intrin.h marks things like _ReadWriteBarrier as
+        # __attribute((__deprecated__)).  This is nice to know, but since we don't
+        # get the equivalent warning from MSVC, let's just ignore it.
+        check_and_add_warning("-Wno-deprecated-declarations")
+
+        # This warns for reasonable things like:
+        #   enum { X = 0xffffffffU };
+        # which is annoying for IDL headers.
+        check_and_add_warning("-Wno-microsoft-enum-value", cxx_compiler)
+
+        # This warns for cases that would be reached by the Microsoft
+        # #include rules, but also currently warns on cases that would
+        # *also* be reached by standard C++ include rules.  That
+        # behavior doesn't seem useful, so we turn it off.
+        check_and_add_warning("-Wno-microsoft-include", cxx_compiler)
+
+        # We use a function like:
+        #   __declspec(noreturn) __inline void f() {}
+        # which -Winvalid-noreturn complains about.  Again, MSVC seems
+        # OK with it, so let's silence the warning.
+        check_and_add_warning("-Wno-invalid-noreturn")
+
+        # Missing |override| on virtual function declarations isn't
+        # something that MSVC currently warns about.
+        check_and_add_warning("-Wno-inconsistent-missing-override", cxx_compiler)
+
+        # We use -DHAS_EXCEPTIONS=0, which removes the |throw()|
+        # declaration on |operator delete(void*)|.  However, clang-cl
+        # must internally declare |operator delete(void*)| differently,
+        # which causes this warning for virtually every file in the
+        # tree.  clang-cl doesn't support -fno-exceptions or equivalent,
+        # so there doesn't seem to be any way to convince clang-cl to
+        # declare |delete| differently.  Therefore, suppress this
+        # warning.
+        check_and_add_warning("-Wno-implicit-exception-spec-mismatch", cxx_compiler)
+
+        # Macros like STDMETHOD() and IFACEMETHOD() can declare
+        # __attribute__((nothrow)) on their respective method declarations,
+        # while the definitions are left without the matching attribute.
+        check_and_add_warning("-Wno-microsoft-exception-spec", cxx_compiler)
+
+        # At least one MSVC header and several headers in-tree have
+        # unused typedefs, so turn this on.
+        check_and_add_warning("-Wno-unused-local-typedef", cxx_compiler)
+
+        # jemalloc uses __declspec(allocator) as a profiler hint,
+        # which clang-cl doesn't understand.
+        check_and_add_warning("-Wno-ignored-attributes", cxx_compiler)
+
+        # __attribute__((unused)) really means "might be unused" and
+        # we use it to avoid warnings about things that are unused
+        # in some compilation units, but used in many others.  This
+        # warning insists on complaining about the latter case, which
+        # is annoying, and rather noisy.
+        check_and_add_warning("-Wno-used-but-marked-unused", cxx_compiler)
+
+    with only_when(depends(c_compiler)(lambda c: c.type != "clang-cl")):
+        # When compiling for Windows with gcc, gcc throws false positives and true
+        # positives where the callsite is ifdef-ed out
+        check_and_add_warning("-Wno-unused-function")
+
+        # When compiling for Windows with gcc, gcc cannot produce this warning
+        # correctly: it mistakes DWORD_PTR and ULONG_PTR as types you cannot
+        # give NULL to. (You can in fact do that.)
+        check_and_add_warning("-Wno-conversion-null")
+
+        # Throughout the codebase we regularly have switch statements off of enums
+        # without covering every value in the enum. We don't care about these warnings.
+        check_and_add_warning("-Wno-switch")
+
+        # Another code pattern we have is using start and end constants in enums of
+        # different types. We do this for safety, but then when comparing it throws
+        # an error, which we would like to ignore. This seems to only affect the MinGW
+        # build, but we're not sure why.
+        check_and_add_warning("-Wno-enum-compare")
+
+# Make it an error to be missing function declarations for C code.
+check_and_add_warning("-Werror=implicit-function-declaration", c_compiler)
+
+# New in clang 11. We can't really do anything about this warning.
+check_and_add_warning("-Wno-psabi")
+
+# Disable broken missing-braces warning on old clang versions
+check_and_add_warning(
+    "-Wno-missing-braces",
+    when=depends(c_compiler)(lambda c: c.type == "clang" and c.version < "6.0"),
+)
+
+# Turn on clang thread-safety analysis
+# Older clangs don't support AutoUnlock, and have other issues
+check_and_add_warning(
+    "-Wthread-safety",
+    when=depends(c_compiler)(
+        lambda c: c.type in ("clang", "clang-cl") and c.version >= "8.0"
+    ),
+)
+
+# Warn if APIs are used without available() checks on macOS.
+check_and_add_warning("-Werror=unguarded-availability-new", when=target_is_osx)
+
+# clang 17 warns about builtins being redefined and... well, we do that in
+# multiple places, some of which are third-party. Until the situation is
+# fixed, disable the new warning.
+check_and_add_warning("-Wno-error=builtin-macro-redefined")
+
+# clang 18 has a new warning about VLAs being an extension in C++, but we
+# have a number of them.
+check_and_add_warning("-Wno-vla-cxx-extension", cxx_compiler)
+
+# Please keep the following last in this file
+
+# Avoid requiring complicated logic for extra warning flags in moz.build files.
+check_and_add_warning("-Wno-unknown-warning-option")
+
+set_config("WARNINGS_CFLAGS", warnings_flags.cflags)
+set_config("WARNINGS_CXXFLAGS", warnings_flags.cxxflags)
+set_config("WARNINGS_HOST_CFLAGS", warnings_flags.host_cflags)
+set_config("WARNINGS_HOST_CXXFLAGS", warnings_flags.host_cxxflags)
diff --git a/build/moz.configure/windows.configure b/build/moz.configure/windows.configure
new file mode 100644
index 0000000000..f23aa2a499
--- /dev/null
+++ b/build/moz.configure/windows.configure
@@ -0,0 +1,481 @@
+# -*- Mode: python; c-basic-offset: 4; 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/.
+
+option(
+    "--with-windows-version",
+    nargs=1,
+    default="603",
+    help="Windows SDK version to target. Win 8.1 (603) is currently"
+    "the minimum supported version.",
+)
+
+
+@depends("--with-windows-version")
+@imports(_from="__builtin__", _import="ValueError")
+def valid_windows_version(value):
+    if not value:
+        die("Cannot build with --without-windows-version")
+    try:
+        version = int(value[0], 16)
+        if version in (0x603,):
+            return version
+    except ValueError:
+        pass
+
+    die("Invalid value for --with-windows-version (%s)", value[0])
+
+
+option(env="WINDOWSSDKDIR", nargs=1, help="Directory containing the Windows SDK")
+
+
+@depends(
+    "WINDOWSSDKDIR", "WINSYSROOT", winsysroot, target_windows_abi, host_windows_abi
+)
+def windows_sdk_dir(
+    value, winsysroot_env, winsysroot, target_windows_abi, host_windows_abi
+):
+    if value:
+        if winsysroot_env:
+            die("WINDOWSSDKDIR and WINSYSROOT cannot be set together.")
+        if winsysroot:
+            die("WINDOWSSDKDIR cannot be set when using the bootstrapped WINSYSROOT")
+        return value
+    if target_windows_abi != "msvc" and host_windows_abi != "msvc":
+        return ()
+
+    if winsysroot:
+        return [os.path.join(winsysroot, "Windows Kits", "10")]
+
+    return set(
+        normalize_path(x[1])
+        for x in get_registry_values(
+            r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Kits\Installed Roots"
+            r"\KitsRoot*",
+            get_32_and_64_bit=True,
+        )
+    )
+
+
+@imports("glob")
+def get_sdk_dirs(sdk, subdir):
+    def get_dirs_containing(sdk, stem, subdir):
+        return [
+            os.path.dirname(p) for p in glob.glob(os.path.join(sdk, stem, "*", subdir))
+        ]
+
+    def categorize(dirs):
+        return {os.path.basename(d): d for d in dirs}
+
+    include_dirs = categorize(get_dirs_containing(sdk, "Include", subdir))
+    lib_dirs = categorize(get_dirs_containing(sdk, "Lib", subdir))
+
+    valid_versions = sorted(set(include_dirs) & set(lib_dirs), reverse=True)
+    return [
+        namespace(
+            path=sdk,
+            lib=lib_dirs[vv],
+            include=include_dirs[vv],
+        )
+        for vv in valid_versions
+    ]
+
+
+@imports(_from="mozbuild.shellutil", _import="quote")
+def valid_windows_sdk_dir_result(value):
+    if value:
+        return "0x%04x in %s" % (value.version, quote(value.path))
+
+
+@depends(
+    target_windows_abi,
+    host_windows_abi,
+    windows_sdk_dir,
+    valid_windows_version,
+    "WINDOWSSDKDIR",
+)
+@checking("for Windows SDK", valid_windows_sdk_dir_result)
+@imports(_from="__builtin__", _import="Exception")
+@imports(_from="__builtin__", _import="open")
+def valid_windows_sdk_dir(
+    target_windows_abi,
+    host_windows_abi,
+    windows_sdk_dir,
+    target_version,
+    windows_sdk_dir_env,
+):
+    if target_windows_abi != "msvc" and host_windows_abi != "msvc":
+        return None
+    if windows_sdk_dir_env:
+        windows_sdk_dir_env = windows_sdk_dir_env[0]
+    sdks = {}
+    for d in windows_sdk_dir:
+        sdklist = get_sdk_dirs(d, "um")
+        for sdk in sdklist:
+            maxver = None
+            winsdkver = os.path.join(sdk.include, "um", "winsdkver.h")
+            with open(winsdkver) as fh:
+                for line in fh.readlines():
+                    if line.startswith("#define"):
+                        line = line.split(None, 2)
+                        assert line.pop(0) == "#define"
+                        if line.pop(0) == "WINVER_MAXVER":
+                            maxver = line.pop(0)
+                            break
+
+            if maxver:
+                try:
+                    maxver = int(maxver, 0)
+                except Exception:
+                    pass
+                else:
+                    sdks[d] = maxver, sdk
+                    break
+
+        if d == windows_sdk_dir_env and d not in sdks:
+            raise FatalCheckError(
+                "Error while checking the version of the SDK in "
+                "WINDOWSSDKDIR (%s). Please verify it contains a valid and "
+                "complete SDK installation." % windows_sdk_dir_env
+            )
+
+    valid_sdks = sorted(sdks, key=lambda x: sdks[x][0], reverse=True)
+    if valid_sdks:
+        biggest_version, sdk = sdks[valid_sdks[0]]
+    if not valid_sdks or biggest_version < target_version:
+        if windows_sdk_dir_env:
+            raise FatalCheckError(
+                "You are targeting Windows version 0x%04x, but your SDK only "
+                "supports up to version 0x%04x. Install and use an updated SDK, "
+                "or target a lower version using --with-windows-version. "
+                "Alternatively, try running the Windows SDK Configuration Tool "
+                "and selecting a newer SDK. See "
+                "https://developer.mozilla.org/En/Windows_SDK_versions for "
+                "details on fixing this." % (target_version, biggest_version)
+            )
+
+        raise FatalCheckError(
+            "Cannot find a Windows SDK for version >= 0x%04x." % target_version
+        )
+
+    return namespace(
+        path=sdk.path,
+        include=sdk.include,
+        lib=sdk.lib,
+        version=biggest_version,
+    )
+
+
+@imports(_from="mozbuild.shellutil", _import="quote")
+def valid_ucrt_sdk_dir_result(value):
+    if value:
+        return "%s in %s" % (value.version, quote(value.path))
+
+
+@depends(windows_sdk_dir, "WINDOWSSDKDIR", target_windows_abi, host_windows_abi)
+@checking("for Universal CRT SDK", valid_ucrt_sdk_dir_result)
+@imports("os")
+@imports(_import="mozpack.path", _as="mozpath")
+def valid_ucrt_sdk_dir(
+    windows_sdk_dir, windows_sdk_dir_env, target_windows_abi, host_windows_abi
+):
+    if target_windows_abi != "msvc" and host_windows_abi != "msvc":
+        return None
+    if windows_sdk_dir_env:
+        windows_sdk_dir_env = windows_sdk_dir_env[0]
+    sdks = {}
+    for d in windows_sdk_dir:
+        sdklist = get_sdk_dirs(d, "ucrt")
+        for sdk in sdklist:
+            version = os.path.basename(sdk.include)
+            # We're supposed to always find a version in the directory, because
+            # the 8.1 SDK, which doesn't have a version in the directory, doesn't
+            # contain the Universal CRT SDK. When the main SDK is 8.1, there
+            # is, however, supposed to be a reduced install of the SDK 10
+            # with the UCRT.
+            if version != "include":
+                sdks[d] = Version(version), sdk
+                break
+
+        if d == windows_sdk_dir_env and d not in sdks:
+            # When WINDOWSSDKDIR is set in the environment and we can't find the
+            # Universal CRT SDK, chances are this is a start-shell-msvc*.bat
+            # setup, where INCLUDE and LIB already contain the UCRT paths.
+            ucrt_includes = [
+                p
+                for p in os.environ.get("INCLUDE", "").split(";")
+                if os.path.basename(p).lower() == "ucrt"
+            ]
+            ucrt_libs = [
+                p
+                for p in os.environ.get("LIB", "").split(";")
+                if os.path.basename(os.path.dirname(p)).lower() == "ucrt"
+            ]
+            if ucrt_includes and ucrt_libs:
+                # Pick the first of each, since they are the ones that the
+                # compiler would look first. Assume they contain the SDK files.
+                include = os.path.dirname(ucrt_includes[0])
+                lib = os.path.dirname(os.path.dirname(ucrt_libs[0]))
+                path = os.path.dirname(os.path.dirname(include))
+                version = os.path.basename(include)
+                if version != "include" and mozpath.basedir(lib, [path]):
+                    sdks[d] = (
+                        Version(version),
+                        namespace(
+                            path=path,
+                            include=include,
+                            lib=lib,
+                        ),
+                    )
+                    continue
+            raise FatalCheckError(
+                "The SDK in WINDOWSSDKDIR (%s) does not contain the Universal "
+                "CRT." % windows_sdk_dir_env
+            )
+
+    valid_sdks = sorted(sdks, key=lambda x: sdks[x][0], reverse=True)
+    if not valid_sdks:
+        raise FatalCheckError(
+            "Cannot find the Universal CRT SDK. " "Please install it."
+        )
+
+    version, sdk = sdks[valid_sdks[0]]
+    minimum_ucrt_version = Version("10.0.17134.0")
+    if version < minimum_ucrt_version:
+        raise FatalCheckError(
+            "Latest Universal CRT SDK version found %s"
+            " and minimum required is %s. This or a later"
+            " version can be installed using the Visual"
+            " Studio installer." % (version, minimum_ucrt_version)
+        )
+
+    return namespace(
+        path=sdk.path,
+        include=sdk.include,
+        lib=sdk.lib,
+        version=version,
+    )
+
+
+@depends(target_windows_abi, host_windows_abi, vc_toolchain_search_path)
+@imports("os")
+def vc_path(target_windows_abi, host_windows_abi, vc_toolchain_search_path):
+    if target_windows_abi != "msvc" and host_windows_abi != "msvc":
+        return
+
+    # In clang-cl builds, we need the headers and libraries from an MSVC installation.
+    vc_program = find_program("cl.exe", paths=vc_toolchain_search_path)
+    if not vc_program:
+        die("Cannot find a Visual C++ install for e.g. ATL headers.")
+
+    result = os.path.dirname(vc_program)
+    while True:
+        next, p = os.path.split(result)
+        if next == result:
+            die(
+                "Cannot determine the Visual C++ directory the compiler (%s) "
+                "is in" % vc_program
+            )
+        result = next
+        if p.lower() == "bin":
+            break
+    return os.path.normpath(result)
+
+
+@depends(vc_path, valid_windows_sdk_dir, valid_ucrt_sdk_dir)
+@imports("os")
+def include_path(vc_path, windows_sdk_dir, ucrt_sdk_dir):
+    if not vc_path:
+        return
+    atlmfc_dir = os.path.join(vc_path, "atlmfc", "include")
+    if not os.path.isdir(atlmfc_dir):
+        die(
+            "Cannot find the ATL/MFC headers in the Visual C++ directory (%s). "
+            "Please install them." % vc_path
+        )
+
+    winrt_dir = os.path.join(windows_sdk_dir.include, "winrt")
+    if not os.path.isdir(winrt_dir):
+        die(
+            "Cannot find the WinRT headers in the Windows SDK directory (%s). "
+            "Please install them." % windows_sdk_dir.path
+        )
+
+    cppwinrt_dir = os.path.join(windows_sdk_dir.include, "cppwinrt")
+    if not os.path.isdir(cppwinrt_dir):
+        die(
+            "Cannot find the C++/WinRT headers in the Windows SDK directory (%s). "
+            "Please install them." % windows_sdk_dir.path
+        )
+
+    includes = []
+    include_env = os.environ.get("INCLUDE")
+    if include_env:
+        includes.append(include_env)
+    includes.extend(
+        (
+            os.path.join(vc_path, "include"),
+            atlmfc_dir,
+            os.path.join(windows_sdk_dir.include, "shared"),
+            os.path.join(windows_sdk_dir.include, "um"),
+            winrt_dir,
+            cppwinrt_dir,
+            os.path.join(ucrt_sdk_dir.include, "ucrt"),
+        )
+    )
+    # Set in the environment for old-configure
+    includes = ";".join(includes)
+    os.environ["INCLUDE"] = includes
+    return includes
+
+
+set_config("INCLUDE", include_path)
+
+# cppwinrt requires this on clang because of no coroutine support, which is okay
+set_define("_SILENCE_CLANG_COROUTINE_MESSAGE", "")
+
+
+@template
+def lib_path_for(host_or_target):
+    @depends(
+        host_or_target,
+        dependable(host_or_target is host),
+        vc_path,
+        valid_windows_sdk_dir,
+        valid_ucrt_sdk_dir,
+        c_compiler,
+    )
+    @imports("os")
+    def lib_path(target, is_host, vc_path, windows_sdk_dir, ucrt_sdk_dir, compiler):
+        if not vc_path or target.os != "WINNT":
+            return
+        sdk_target = {
+            "x86": "x86",
+            "x86_64": "x64",
+            "arm": "arm",
+            "aarch64": "arm64",
+        }.get(target.cpu)
+
+        # MSVC2017 switched to use the same target naming as the sdk.
+        atlmfc_dir = os.path.join(vc_path, "atlmfc", "lib", sdk_target)
+        if not os.path.isdir(atlmfc_dir):
+            die(
+                "Cannot find the ATL/MFC libraries in the Visual C++ directory "
+                "(%s). Please install them." % vc_path
+            )
+
+        libs = []
+        lib_env = os.environ.get("LIB")
+        if lib_env and not is_host:
+            libs.extend(lib_env.split(";"))
+        libs.extend(
+            (
+                os.path.join(vc_path, "lib", sdk_target),
+                atlmfc_dir,
+                os.path.join(windows_sdk_dir.lib, "um", sdk_target),
+                os.path.join(ucrt_sdk_dir.lib, "ucrt", sdk_target),
+            )
+        )
+        if compiler.type == "clang-cl":
+            runtime_dir = check_cmd_output(
+                compiler.compiler,
+                "/clang:--print-runtime-dir",
+                *compiler.flags,
+                onerror=lambda: None
+            ).strip()
+            if runtime_dir and os.path.exists(runtime_dir):
+                # Put the clang runtime directory first, in case there is
+                # a different version in some of the other directories (notably,
+                # some versions of MSVC come with clang runtimes)
+                libs.insert(0, runtime_dir)
+        return libs
+
+    return lib_path
+
+
+@depends_if(lib_path_for(target), when=target_is_windows)
+@imports("os")
+def lib_path(libs):
+    # Set in the environment for old-configure
+    libs = ";".join(libs)
+    os.environ["LIB"] = libs
+    return libs
+
+
+set_config("LIB", lib_path)
+
+
+lib_path_for_host = lib_path_for(host)
+
+
+@depends_if(lib_path_for_host, when=host_is_windows)
+@imports(_from="mozbuild.shellutil", _import="quote")
+def host_linker_libpaths(libs):
+    return ["-LIBPATH:%s" % quote(l) for l in libs]
+
+
+@depends_if(lib_path_for_host, when=host_is_windows)
+@imports(_from="mozbuild.shellutil", _import="quote")
+def host_linker_libpaths_bat(libs):
+    # .bat files need a different style of quoting. Batch quoting is actually
+    # not defined, and up to applications to handle, so it's not really clear
+    # what should be escaped and what not, but most paths should work just
+    # fine without escaping. And we don't care about double-quotes possibly
+    # having to be escaped because they're not allowed in file names on
+    # Windows.
+    return ['"-LIBPATH:%s"' % l for l in libs]
+
+
+set_config("HOST_LINKER_LIBPATHS", host_linker_libpaths)
+set_config("HOST_LINKER_LIBPATHS_BAT", host_linker_libpaths_bat)
+
+
+@depends(valid_windows_sdk_dir, valid_ucrt_sdk_dir, host)
+@imports(_from="os", _import="environ")
+def sdk_bin_path(valid_windows_sdk_dir, valid_ucrt_sdk_dir, host):
+    if not valid_windows_sdk_dir:
+        return
+
+    vc_host = {
+        "x86": "x86",
+        "x86_64": "x64",
+    }.get(host.cpu)
+
+    # From version 10.0.15063.0 onwards the bin path contains the version number.
+    versioned_bin = (
+        "bin"
+        if valid_ucrt_sdk_dir.version < "10.0.15063.0"
+        else os.path.join("bin", str(valid_ucrt_sdk_dir.version))
+    )
+    result = [
+        environ["PATH"],
+        os.path.join(valid_windows_sdk_dir.path, versioned_bin, vc_host),
+    ]
+    if vc_host == "x64":
+        result.append(os.path.join(valid_windows_sdk_dir.path, versioned_bin, "x86"))
+    return result
+
+
+option(env="LINKER", nargs=1, when=target_is_windows, help="Path to the linker")
+
+link = check_prog(
+    "LINKER",
+    ("lld-link",),
+    input="LINKER",
+    when=target_is_windows,
+    paths=clang_search_path,
+)
+
+option(env="HOST_LINKER", nargs=1, when=host_is_windows, help="Path to the host linker")
+
+host_link = check_prog(
+    "HOST_LINKER",
+    ("lld-link",),
+    input="HOST_LINKER",
+    when=host_is_windows,
+    paths=clang_search_path,
+)
+
+add_old_configure_assignment("LINKER", link)