diff options
Diffstat (limited to 'toolkit/moz.configure')
| -rw-r--r-- | toolkit/moz.configure | 3684 |
1 files changed, 3684 insertions, 0 deletions
diff --git a/toolkit/moz.configure b/toolkit/moz.configure new file mode 100644 index 0000000000..b616109b1f --- /dev/null +++ b/toolkit/moz.configure @@ -0,0 +1,3684 @@ +# -*- 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/. + + +# Set the MOZ_CONFIGURE_OPTIONS variable with all the options that +# were passed somehow (environment, command line, mozconfig) +@dependable +@imports(_from="mozbuild.shellutil", _import="quote") +@imports(_from="mozbuild.util", _import="ensure_unicode") +@imports(_from="mozbuild.util", _import="system_encoding") +@imports("__sandbox__") +def all_configure_options(): + result = [] + previous = None + for option in __sandbox__._options.values(): + # __sandbox__._options contains items for both option.name and + # option.env. But it's also an OrderedDict, meaning both are + # consecutive. + # Also ignore OLD_CONFIGURE and MOZCONFIG because they're not + # interesting. + if option == previous or option.env in ("OLD_CONFIGURE", "MOZCONFIG"): + continue + previous = option + value = __sandbox__._value_for(option) + # We only want options that were explicitly given on the command + # line, the environment, or mozconfig, and that differ from the + # defaults. + if ( + value is not None + and value.origin not in ("default", "implied") + and value != option.default + ): + result.append( + ensure_unicode(__sandbox__._raw_options[option], system_encoding) + ) + # We however always include options that are sent to old configure + # because we don't know their actual defaults. (Keep the conditions + # separate for ease of understanding and ease of removal) + elif ( + option.help == "Help missing for old configure options" + and option in __sandbox__._raw_options + ): + result.append( + ensure_unicode(__sandbox__._raw_options[option], system_encoding) + ) + + # We shouldn't need this, but currently, quote will return a byte string + # if result is empty, and that's not wanted here. + if not result: + return "" + + return quote(*result) + + +set_config("MOZ_CONFIGURE_OPTIONS", all_configure_options) + + +@depends(target) +def fold_libs(target): + return target.os in ("WINNT", "OSX", "Android") + + +set_config("MOZ_FOLD_LIBS", fold_libs) + +# Profiling +# ============================================================== +# Some of the options here imply an option from js/moz.configure, +# so, need to be declared before the include. + +option( + "--enable-jprof", + env="MOZ_JPROF", + help="Enable jprof profiling tool (needs mozilla/tools/jprof)", +) + + +@depends("--enable-jprof") +def jprof(value): + if value: + return True + + +set_config("MOZ_JPROF", jprof) +set_define("MOZ_JPROF", jprof) +imply_option("--enable-profiling", jprof) + + +@depends(target) +def gecko_profiler(target): + if target.os == "Android": + return target.cpu in ("aarch64", "arm", "x86", "x86_64") + elif target.kernel == "Linux": + return target.cpu in ("aarch64", "arm", "x86", "x86_64", "mips64") + elif target.kernel == "FreeBSD": + return target.cpu in ("aarch64", "x86_64") + return target.os in ("OSX", "WINNT") + + +@depends(gecko_profiler) +def gecko_profiler_define(value): + if value: + return True + + +set_config("MOZ_GECKO_PROFILER", gecko_profiler_define) +set_define("MOZ_GECKO_PROFILER", gecko_profiler_define) + + +# Whether code to parse ELF binaries should be compiled for the Gecko profiler +# (for symbol table dumping). +@depends(gecko_profiler, target) +def gecko_profiler_parse_elf(value, target): + # Currently we only want to build this code on Linux (including Android) and BSD. + # For Android, this is in order to dump symbols from Android system, where + # on other platforms there exist alternatives that don't require bloating + # up our binary size. For Linux more generally, we use this in profile + # pre-symbolication support, since MozDescribeCodeAddress doesn't do + # anything useful on that platform. (Ideally, we would update + # MozDescribeCodeAddress to call into some Rust crates that parse ELF and + # DWARF data, but build system issues currently prevent Rust from being + # used in mozglue.) + if value and (target.kernel == "Linux" or target.kernel == "FreeBSD"): + return True + + +set_config("MOZ_GECKO_PROFILER_PARSE_ELF", gecko_profiler_parse_elf) +set_define("MOZ_GECKO_PROFILER_PARSE_ELF", gecko_profiler_parse_elf) + +# enable this by default if the profiler is enabled +# Note: also requires jemalloc +set_config("MOZ_PROFILER_MEMORY", gecko_profiler_define) +set_define("MOZ_PROFILER_MEMORY", gecko_profiler_define) + + +@depends( + "--enable-debug", + milestone, + build_project, + # Artifact builds are included because the downloaded artifacts can + # have DMD enabled. + when=artifact_builds | depends(when="--enable-replace-malloc")(lambda: True), +) +def dmd_default(debug, milestone, build_project): + return bool(build_project == "browser" and (debug or milestone.is_nightly)) + + +option( + "--enable-dmd", + env="MOZ_DMD", + default=dmd_default, + help="{Enable|Disable} Dark Matter Detector (heap profiler). " + "Also enables jemalloc, replace-malloc and profiling", +) + + +@depends("--enable-dmd") +def dmd(value): + if value: + return True + + +set_config("MOZ_DMD", dmd) +set_define("MOZ_DMD", dmd) +imply_option("--enable-profiling", dmd) +imply_option("--enable-jemalloc", dmd, when=compile_environment) +imply_option("--enable-replace-malloc", dmd, when=compile_environment) + + +# midir-based Web MIDI support +# ============================================================== +@depends(target) +def midir_linux_support(target): + return ( + target.kernel == "Linux" and target.os != "Android" and target.cpu != "riscv64" + ) + + +@depends(target, midir_linux_support) +def midir_support(target, midir_linux_support): + if target.os in ("WINNT", "OSX") or midir_linux_support: + return True + + +set_config("MOZ_WEBMIDI_MIDIR_IMPL", midir_support) + + +# Enable various cubeb backends +# ============================================================== +@depends(target) +def audio_backends_default(target): + if target.os == "Android": + return ( + "aaudio", + "opensl", + ) + elif target.os in ("DragonFly", "FreeBSD", "SunOS"): + return ("oss",) + elif target.os == "OpenBSD": + return ("sndio",) + elif target.os == "OSX": + return ("audiounit",) + elif target.os == "NetBSD": + return ("sunaudio",) + elif target.os == "SunOS": + return ("sunaudio",) + elif target.os == "WINNT": + return ("wasapi",) + else: + return ("pulseaudio",) + + +option( + "--enable-audio-backends", + nargs="+", + choices=( + "aaudio", + "alsa", + "audiounit", + "jack", + "opensl", + "oss", + "pulseaudio", + "sndio", + "sunaudio", + "wasapi", + ), + default=audio_backends_default, + help="{Enable|Disable} various cubeb backends", +) + + +@depends("--enable-audio-backends", target) +def imply_aaudio(values, target): + if any("aaudio" in value for value in values) and target.os != "Android": + die("Cannot enable AAudio on %s", target.os) + return any("aaudio" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_alsa(values, target): + if ( + any("alsa" in value for value in values) + and target.kernel != "Linux" + and target.os != "FreeBSD" + ): + die("Cannot enable ALSA on %s", target.os) + return any("alsa" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_audiounit(values, target): + if ( + any("audiounit" in value for value in values) + and target.os != "OSX" + and target.kernel != "Darwin" + ): + die("Cannot enable AudioUnit on %s", target.os) + return any("audiounit" in value for value in values) or None + + +@depends("--enable-audio-backends") +def imply_jack(values): + return any("jack" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_opensl(values, target): + if any("opensl" in value for value in values) and target.os != "Android": + die("Cannot enable OpenSL on %s", target.os) + return any("opensl" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_oss(values, target): + if any("oss" in value for value in values) and ( + target.os == "Android" or target.os == "OSX" or target.os == "WINNT" + ): + die("Cannot enable OSS on %s", target.os) + return any("oss" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_pulseaudio(values, target): + if any("pulseaudio" in value for value in values) and ( + target.os == "Android" or target.os == "OSX" or target.os == "WINNT" + ): + die("Cannot enable PulseAudio on %s", target.os) + return any("pulseaudio" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_sndio(values, target): + if any("sndio" in value for value in values) and ( + target.os == "Android" or target.os == "OSX" or target.os == "WINNT" + ): + die("Cannot enable sndio on %s", target.os) + return any("sndio" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_sunaudio(values, target): + if any("sunaudio" in value for value in values) and ( + target.os != "NetBSD" and target.os != "SunOS" + ): + die("Cannot enable sunaudio on %s", target.os) + return any("sunaudio" in value for value in values) or None + + +@depends("--enable-audio-backends", target) +def imply_wasapi(values, target): + if any("wasapi" in value for value in values) and target.os != "WINNT": + die("Cannot enable WASAPI on %s", target.os) + return any("wasapi" in value for value in values) or None + + +set_config("MOZ_AAUDIO", imply_aaudio, when="--enable-audio-backends") + +imply_option("--enable-alsa", imply_alsa, reason="--enable-audio-backends") + +set_config("MOZ_AUDIOUNIT_RUST", imply_audiounit, when="--enable-audio-backends") + +imply_option("--enable-jack", imply_jack, reason="--enable-audio-backends") + +set_config("MOZ_OPENSL", imply_opensl, when="--enable-audio-backends") + +set_config("MOZ_OSS", imply_oss, when="--enable-audio-backends") + +imply_option("--enable-pulseaudio", imply_pulseaudio, reason="--enable-audio-backends") + +imply_option("--enable-sndio", imply_sndio, reason="--enable-audio-backends") + +set_config("MOZ_SUNAUDIO", imply_sunaudio, when="--enable-audio-backends") + +set_config("MOZ_WASAPI", imply_wasapi, when="--enable-audio-backends") + +# ALSA cubeb backend +# ============================================================== +option("--enable-alsa", env="MOZ_ALSA", help="Enable ALSA audio backend.") + + +@depends("--enable-alsa", midir_linux_support) +def enable_alsa_or_midir_linux_support(alsa_enabled, midir_linux_support): + return alsa_enabled or midir_linux_support + + +pkg_check_modules("MOZ_ALSA", "alsa", when=enable_alsa_or_midir_linux_support) + +set_config("MOZ_ALSA", True, when="--enable-alsa") +set_define("MOZ_ALSA", True, when="--enable-alsa") + +# JACK cubeb backend +# ============================================================== +system_lib_option("--enable-jack", env="MOZ_JACK", help="Enable JACK audio backend.") + +jack = pkg_check_modules("MOZ_JACK", "jack", when="--enable-jack") + +set_config("MOZ_JACK", depends_if(jack)(lambda _: True)) + +# PulseAudio cubeb backend +# ============================================================== +option( + "--enable-pulseaudio", + env="MOZ_PULSEAUDIO", + help="{Enable|Disable} PulseAudio audio backend.", +) + +pulseaudio = pkg_check_modules("MOZ_PULSEAUDIO", "libpulse", when="--enable-pulseaudio") + +set_config("MOZ_PULSEAUDIO", depends_if(pulseaudio)(lambda _: True)) +set_define("MOZ_PULSEAUDIO", depends_if(pulseaudio)(lambda _: True)) + +# sndio cubeb backend +# ============================================================== +system_lib_option("--enable-sndio", env="MOZ_SNDIO", help="Enable sndio audio backend.") + +sndio = pkg_check_modules("MOZ_SNDIO", "sndio", when="--enable-sndio") + +set_config("MOZ_SNDIO", depends_if(sndio)(lambda _: True)) + +# Javascript engine +# ============================================================== +include("../js/moz.configure") + + +# NodeJS +# ============================================================== +include("../build/moz.configure/node.configure") + +# JsonCpp +# ============================================================== +set_define("JSON_USE_EXCEPTION", 0) + +# L10N +# ============================================================== +option("--with-l10n-base", nargs=1, env="L10NBASEDIR", help="Path to l10n repositories") + + +@depends("--with-l10n-base", "MOZ_AUTOMATION", build_environment) +@imports(_from="os.path", _import="isdir") +@imports(_from="os.path", _import="expanduser") +@imports(_from="os", _import="environ") +def l10n_base(value, automation, build_env): + if value: + path = value[0] + if not isdir(path): + die("Invalid value --with-l10n-base, %s doesn't exist", path) + elif automation: + path = os.path.join(build_env.topsrcdir, "../l10n-central") + else: + path = os.path.join( + environ.get( + "MOZBUILD_STATE_PATH", expanduser(os.path.join("~", ".mozbuild")) + ), + "l10n-central", + ) + return os.path.realpath(os.path.abspath(path)) + + +set_config("L10NBASEDIR", l10n_base) + + +# Default toolkit +# ============================================================== +@depends(target) +def toolkit_choices(target): + if target.os == "WINNT": + return ("cairo-windows",) + elif target.os == "OSX": + return ("cairo-cocoa",) + elif target.os == "Android": + return ("cairo-android",) + else: + # cairo-gtk3 - X11 backend with optional Wayland backend (auto detected) + # cairo-gtk3-wayland - Wayland backend with optional X11 backend (auto detected) + # cairo-gtk3-x11-wayland - builds explicitly with X11 & Wayland backends + return ( + "cairo-gtk3", + "cairo-gtk3-wayland", + "cairo-gtk3-x11-wayland", + "cairo-gtk3-wayland-only", + "cairo-gtk3-x11-only", + ) + + +@depends(toolkit_choices) +def toolkit_default(choices): + return choices[0] + + +option( + "--enable-default-toolkit", + nargs=1, + choices=toolkit_choices, + default=toolkit_default, + help="Select default toolkit", +) + + +@depends("--enable-default-toolkit") +def full_toolkit(value): + if value: + return value[0] + + +@depends(full_toolkit) +def toolkit(toolkit): + if toolkit.startswith("cairo-gtk3"): + widget_toolkit = "gtk" + else: + widget_toolkit = toolkit.replace("cairo-", "") + return widget_toolkit + + +set_config("MOZ_WIDGET_TOOLKIT", toolkit) +add_old_configure_assignment("MOZ_WIDGET_TOOLKIT", toolkit) + + +@depends(toolkit) +def toolkit_define(toolkit): + if toolkit != "windows": + return "MOZ_WIDGET_%s" % toolkit.upper() + + +set_define(toolkit_define, True) + + +@depends(toolkit) +def toolkit_gtk(toolkit): + return toolkit == "gtk" + + +@depends(toolkit_gtk, full_toolkit) +def toolkit_gtk_x11(toolkit_gtk, full_toolkit): + return toolkit_gtk and full_toolkit != "cairo-gtk3-wayland-only" + + +@depends(full_toolkit) +def toolkit_gtk_x11_optional(full_toolkit): + return full_toolkit == "cairo-gtk3-wayland" + + +@depends(toolkit_gtk, full_toolkit) +def toolkit_gtk_wayland(toolkit_gtk, full_toolkit): + return toolkit_gtk and full_toolkit != "cairo-gtk3-x11-only" + + +@depends(full_toolkit) +def toolkit_gtk_wayland_optional(full_toolkit): + return full_toolkit == "cairo-gtk3" + + +# Wayland support +# ============================================================== +wayland_headers = pkg_check_modules( + "MOZ_WAYLAND", + "gtk+-wayland-3.0 >= 3.14 xkbcommon >= 0.4.1", + allow_missing=toolkit_gtk_wayland_optional, + when=toolkit_gtk_wayland, +) + + +@depends(wayland_headers, toolkit_gtk, artifact_builds, toolkit_gtk_wayland) +def wayland_headers(wayland, toolkit_gtk, artifacts, toolkit_gtk_wayland): + if not toolkit_gtk_wayland: + return False + if toolkit_gtk and artifacts: + return True + return wayland + + +set_config("MOZ_WAYLAND", depends_if(wayland_headers)(lambda _: True)) +set_define("MOZ_WAYLAND", depends_if(wayland_headers)(lambda _: True)) + + +# Hardware-accelerated video decode with VAAPI and V4L2 on Linux +# ============================================================== +set_config("MOZ_ENABLE_VAAPI", True, when=toolkit_gtk) +set_define("MOZ_ENABLE_VAAPI", True, when=toolkit_gtk) + + +@depends(target, toolkit_gtk) +def v4l2(target, toolkit_gtk): + # V4L2 decode is only used in GTK/Linux and generally only appears on + # embedded SOCs. + if target.cpu in ("arm", "aarch64", "riscv64") and toolkit_gtk: + return True + + +set_config("MOZ_ENABLE_V4L2", True, when=v4l2) +set_define("MOZ_ENABLE_V4L2", True, when=v4l2) + +# GL Provider +# ============================================================== +option("--with-gl-provider", nargs=1, help="Set GL provider backend type") + + +@depends("--with-gl-provider") +def gl_provider(value): + if value: + return value[0] + + +@depends(gl_provider) +def gl_provider_define(provider): + if provider: + return "GLContextProvider%s" % provider + + +set_define("MOZ_GL_PROVIDER", gl_provider_define) + + +@depends(gl_provider, toolkit_gtk) +def gl_default_provider(value, toolkit_gtk): + if value: + return value + elif toolkit_gtk: + return "EGL" + + +set_config("MOZ_GL_PROVIDER", gl_provider) +set_config("MOZ_GL_DEFAULT_PROVIDER", gl_default_provider) + + +@depends(gl_default_provider) +def gl_provider_define(provider): + if provider: + return "GL_PROVIDER_%s" % provider + + +set_define(gl_provider_define, True) + + +# PDF printing +# ============================================================== +@depends(toolkit) +def pdf_printing(toolkit): + if toolkit in ("windows", "gtk", "android"): + return True + + +set_config("MOZ_PDF_PRINTING", pdf_printing) +set_define("MOZ_PDF_PRINTING", pdf_printing) + + +# Event loop instrumentation +# ============================================================== +option(env="MOZ_INSTRUMENT_EVENT_LOOP", help="Force-enable event loop instrumentation") + + +@depends("MOZ_INSTRUMENT_EVENT_LOOP", toolkit) +def instrument_event_loop(value, toolkit): + if value or ( + toolkit in ("windows", "gtk", "cocoa", "android") and value.origin == "default" + ): + return True + + +set_config("MOZ_INSTRUMENT_EVENT_LOOP", instrument_event_loop) +set_define("MOZ_INSTRUMENT_EVENT_LOOP", instrument_event_loop) + + +# Fontconfig Freetype +# ============================================================== +option(env="USE_FC_FREETYPE", help="Force-enable the use of fontconfig freetype") + + +@depends("USE_FC_FREETYPE", toolkit) +def fc_freetype(value, toolkit): + if value or (toolkit == "gtk" and value.origin == "default"): + return True + + +set_define("USE_FC_FREETYPE", fc_freetype) + +# Pango +# ============================================================== +pkg_check_modules("MOZ_PANGO", "pango >= 1.22.0", when=toolkit_gtk) + +# Fontconfig +# ============================================================== +fontconfig_info = pkg_check_modules( + "_FONTCONFIG", "fontconfig >= 2.7.0", when=fc_freetype +) + + +@depends(fc_freetype) +def check_for_freetype2(fc_freetype): + if fc_freetype: + return True + + +# Check for freetype2. Flags are combined with fontconfig flags. +freetype2_info = pkg_check_modules( + "_FT2", "freetype2 >= 9.10.3", when=check_for_freetype2 +) + + +@depends(fontconfig_info, freetype2_info) +def freetype2_combined_info(fontconfig_info, freetype2_info): + if not freetype2_info: + return + if not fontconfig_info: + return freetype2_info + return namespace( + cflags=freetype2_info.cflags + fontconfig_info.cflags, + libs=freetype2_info.libs + fontconfig_info.libs, + ) + + +set_define("MOZ_HAVE_FREETYPE2", depends_if(freetype2_info)(lambda _: True)) + + +# Apple platform decoder support +# ============================================================== +@depends(toolkit) +def applemedia(toolkit): + if toolkit in ("cocoa", "uikit"): + return True + + +set_config("MOZ_APPLEMEDIA", applemedia) +set_define("MOZ_APPLEMEDIA", applemedia) + +# Windows Media Foundation support +# ============================================================== +option("--disable-wmf", help="Disable support for Windows Media Foundation") + + +@depends("--disable-wmf", target, "--help") +def wmf(value, target, _): + enabled = bool(value) + if value.origin == "default": + # Enable Windows Media Foundation support by default. + # Note our minimum SDK version is Windows 7 SDK, so we are (currently) + # guaranteed to have a recent-enough SDK to build WMF. + enabled = target.os == "WINNT" + if enabled and target.os != "WINNT": + die("Cannot enable Windows Media Foundation support on %s", target.os) + if enabled: + return True + + +@depends(artifact_builds, c_compiler, when=wmf) +def wmfmediaengine(artifact_builds, c_compiler): + if c_compiler: + return c_compiler.type == "clang-cl" + return bool(artifact_builds) + + +set_config("MOZ_WMF", wmf) +set_define("MOZ_WMF", wmf) + +set_config("MOZ_WMF_MEDIA_ENGINE", True, when=wmfmediaengine) +set_define("MOZ_WMF_MEDIA_ENGINE", True, when=wmfmediaengine) + +# FFmpeg H264/AAC Decoding Support +# ============================================================== +option("--disable-ffmpeg", help="Disable FFmpeg for fragmented H264/AAC decoding") + + +@depends("--disable-ffmpeg", target) +def ffmpeg(value, target): + enabled = bool(value) + if value.origin == "default": + enabled = target.os not in ("Android", "WINNT") + if enabled: + return True + + +set_config("MOZ_FFMPEG", ffmpeg) +set_define("MOZ_FFMPEG", ffmpeg) + +# AV1 Video Codec Support +# ============================================================== +option("--disable-av1", help="Disable av1 video support") + + +@depends("--enable-av1") +def av1(value): + if value: + return True + + +@depends(target, when=av1 & compile_environment) +def dav1d_asm(target): + if target.cpu in ("aarch64", "x86", "x86_64"): + return True + + +@depends(target, when=av1 & compile_environment) +def dav1d_nasm(target): + if target.cpu in ("x86", "x86_64"): + return namespace(version="2.14", what="AV1") + + +set_config("MOZ_DAV1D_ASM", dav1d_asm) +set_define("MOZ_DAV1D_ASM", dav1d_asm) +set_config("MOZ_AV1", av1) +set_define("MOZ_AV1", av1) + +# JXL Image Codec Support +# ============================================================== +option("--disable-jxl", help="Disable jxl image support") + + +@depends("--disable-jxl", milestone.is_nightly) +def jxl(value, is_nightly): + if is_nightly and value: + return True + + +set_config("MOZ_JXL", jxl) +set_define("MOZ_JXL", jxl) + +set_config("MOZ_SAMPLE_TYPE_FLOAT32", True) +set_define("MOZ_SAMPLE_TYPE_FLOAT32", True) + +set_define("MOZ_VORBIS", True) +set_config("MOZ_VORBIS", True) + +option( + "--disable-real-time-tracing", + help="Disable tracing of real-time audio callbacks", +) + +set_config("MOZ_REAL_TIME_TRACING", True, when="--enable-real-time-tracing") +set_define("MOZ_REAL_TIME_TRACING", True, when="--enable-real-time-tracing") + +# OpenMAX IL Decoding Support +# ============================================================== +option("--enable-openmax", help="Enable OpenMAX IL for video/audio decoding") + + +@depends("--enable-openmax") +def openmax(value): + enabled = bool(value) + if enabled: + return True + + +set_config("MOZ_OMX", openmax) +set_define("MOZ_OMX", openmax) + + +# EME Support +# ============================================================== +@depends(target, wmf) +def eme_choices(target, wmf): + if ( + target.kernel in ("WINNT", "Linux") + and target.os != "Android" + and target.cpu in ("x86", "x86_64") + ): + if wmf: + return ("widevine", "wmfcdm") + return ("widevine",) + if target.kernel == "WINNT" and target.cpu == "aarch64": + return ("widevine",) + if target.os in ("OSX"): + return ("widevine",) + + +# Widevine is enabled by default in desktop browser builds. +@depends(build_project, eme_choices) +def eme_default(build_project, choices): + if build_project == "browser": + return choices + + +option( + "--enable-eme", + nargs="+", + choices=eme_choices, + default=eme_default, + when=eme_choices, + help="{Enable|Disable} support for Encrypted Media Extensions", +) + + +@depends("--enable-eme", when=eme_choices) +def eme_modules(value): + return value + + +# Fallback to an empty list when eme_choices is empty, setting eme_modules to +# None. +set_config("MOZ_EME_MODULES", eme_modules | dependable([])) + + +# Media Foundation CDM support +# ============================================================== +@depends(eme_modules, when=wmfmediaengine) +def wmfcdm(modules): + if "wmfcdm" in modules: + return True + + +set_config("MOZ_WMF_CDM", True, when=wmfcdm) +set_define("MOZ_WMF_CDM", True, when=wmfcdm) + + +option( + name="--enable-chrome-format", + help="Select FORMAT of chrome files during packaging.", + nargs=1, + choices=("omni", "jar", "flat"), + default="omni", +) + + +@depends("--enable-chrome-format") +def packager_format(value): + return value[0] + + +set_config("MOZ_PACKAGER_FORMAT", packager_format) + +# The packager minifies two different types of files: non-JS (mostly property +# files for l10n), and JS. Setting MOZ_PACKAGER_MINIFY only minifies the +# former. Firefox doesn't yet minify JS, due to concerns about debuggability. +# +# Also, the JS minification setup really only works correctly on Android: +# we need extra setup to use the newly-built shell for Linux and Windows, +# and cross-compilation for macOS requires some extra care. + + +@depends(target_is_android, "--enable-debug", milestone.is_nightly) +def enable_minify_default(is_android, debug, is_nightly): + if is_android and not debug and not is_nightly: + return ("properties", "js") + return ("properties",) + + +option( + name="--enable-minify", + help="Select types of files to minify during packaging.", + nargs="*", + choices=("properties", "js"), + default=enable_minify_default, +) + + +@depends("--enable-minify") +def enable_minify(value): + if "js" in value and "properties" not in value: + die("--enable-minify=js requires --enable-minify=properties.") + return namespace( + properties="properties" in value, + js="js" in value, + ) + + +set_config("MOZ_PACKAGER_MINIFY", True, when=enable_minify.properties) +set_config("MOZ_PACKAGER_MINIFY_JS", True, when=enable_minify.js) + + +@depends(host, build_project) +def jar_maker_format(host, build_project): + # Multilocales for mobile/android use the same mergedirs for all locales, + # so we can't use symlinks for those builds. + if host.os == "WINNT" or build_project == "mobile/android": + return "flat" + return "symlink" + + +set_config("MOZ_JAR_MAKER_FILE_FORMAT", jar_maker_format) + + +@depends(toolkit) +def omnijar_name(toolkit): + # Fennec's static resources live in the assets/ folder of the + # APK. Adding a path to the name here works because we only + # have one omnijar file in the final package (which is not the + # case on desktop). + return "assets/omni.ja" if toolkit == "android" else "omni.ja" + + +set_config("OMNIJAR_NAME", omnijar_name) + +project_flag("MOZ_PLACES", help="Build Places if required", set_as_define=True) + +project_flag( + "MOZ_SERVICES_HEALTHREPORT", + help="Build Firefox Health Reporter Service", + set_as_define=True, +) + +project_flag( + "MOZ_NORMANDY", + help="Enable Normandy recipe runner", + set_as_define=True, +) + +project_flag("MOZ_SERVICES_SYNC", help="Build Sync Services if required") + +project_flag( + "MOZ_ANDROID_HISTORY", + help="Enable Android History instead of Places", + set_as_define=True, +) + +project_flag( + "MOZ_DEDICATED_PROFILES", + help="Enable dedicated profiles per install", + set_as_define=True, +) + +project_flag( + "MOZ_BLOCK_PROFILE_DOWNGRADE", + help="Block users from starting profiles last used by a newer build", + set_as_define=True, +) + + +@depends("MOZ_PLACES", "MOZ_ANDROID_HISTORY") +def check_places_and_android_history(places, android_history): + if places and android_history: + die("Cannot use MOZ_ANDROID_HISTORY alongside MOZ_PLACES.") + + +option( + env="MOZ_TELEMETRY_REPORTING", + default=mozilla_official, + help="Enable telemetry reporting", +) + +set_define("MOZ_TELEMETRY_REPORTING", True, when="MOZ_TELEMETRY_REPORTING") + + +@depends("MOZ_TELEMETRY_REPORTING", milestone.is_nightly) +def telemetry_on_by_default(reporting, is_nightly): + return reporting and is_nightly + + +set_define("MOZ_TELEMETRY_ON_BY_DEFAULT", True, when=telemetry_on_by_default) + + +# gpsd support +# ============================================================== +system_lib_option("--enable-gpsd", env="MOZ_GPSD", help="Enable gpsd support") + + +@depends("--enable-gpsd") +def gpsd(value): + return bool(value) + + +system_gpsd = pkg_check_modules("MOZ_GPSD", "libgps >= 3.11", when=gpsd) + +set_config("MOZ_GPSD", depends_if(system_gpsd)(lambda _: True)) + +# Miscellaneous programs +# ============================================================== + +check_prog("TAR", ("gnutar", "gtar", "tar")) +check_prog("UNZIP", ("unzip",)) + +# Key files +# ============================================================== +include("../build/moz.configure/keyfiles.configure") + +simple_keyfile("Mozilla API") + +simple_keyfile("Google Location Service API") + +simple_keyfile("Google Safebrowsing API") + +id_and_secret_keyfile("Bing API") + +simple_keyfile("Adjust SDK") + +id_and_secret_keyfile("Leanplum SDK") + +simple_keyfile("Pocket API") + + +# WebRender Debugger integration +# ============================================================== + +option( + "--enable-webrender-debugger", help="Build the websocket debug server in WebRender" +) + +set_config( + "MOZ_WEBRENDER_DEBUGGER", depends_if("--enable-webrender-debugger")(lambda _: True) +) + +# Additional system headers defined at the application level +# ============================================================== + +option( + "--enable-app-system-headers", + env="MOZ_APP_SYSTEM_HEADERS", + help="Use additional system headers defined in $MOZ_BUILD_APP/app-system-headers.mozbuild", +) + + +@depends("--enable-app-system-headers") +def app_system_headers(value): + if value: + return True + + +set_config("MOZ_APP_SYSTEM_HEADERS", app_system_headers) +set_define("MOZ_APP_SYSTEM_HEADERS", app_system_headers) + +# Printing +# ============================================================== +option("--disable-printing", help="Disable printing support") + + +@depends("--disable-printing") +def printing(value): + if value: + return True + + +set_config("NS_PRINTING", printing) +set_define("NS_PRINTING", printing) +set_define("NS_PRINT_PREVIEW", printing) + + +# Speech-dispatcher support +# ============================================================== +@depends(toolkit) +def no_speechd_on_non_gtk(toolkit): + if toolkit != "gtk": + return False + + +imply_option( + "--enable-synth-speechd", no_speechd_on_non_gtk, reason="--enable-default-toolkit" +) + +option("--disable-synth-speechd", help="Disable speech-dispatcher support") + +set_config("MOZ_SYNTH_SPEECHD", depends_if("--disable-synth-speechd")(lambda _: True)) + +# Speech API +# ============================================================== +option("--disable-webspeech", help="Disable support for HTML Speech API") + + +@depends("--disable-webspeech") +def webspeech(value): + if value: + return True + + +set_config("MOZ_WEBSPEECH", webspeech) +set_define("MOZ_WEBSPEECH", webspeech) + +# Speech API test backend +# ============================================================== +option( + "--enable-webspeechtestbackend", + default=webspeech, + help="{Enable|Disable} support for HTML Speech API Test Backend", +) + + +@depends_if("--enable-webspeechtestbackend") +def webspeech_test_backend(value): + return True + + +set_config("MOZ_WEBSPEECH_TEST_BACKEND", webspeech_test_backend) +set_define("MOZ_WEBSPEECH_TEST_BACKEND", webspeech_test_backend) + + +# Graphics +# ============================================================== +@depends(target, milestone) +def skia_pdf_default(target, milestone): + return milestone.is_nightly and target.os != "WINNT" + + +option("--enable-skia-pdf", default=skia_pdf_default, help="{Enable|Disable} Skia PDF") + +set_config("MOZ_ENABLE_SKIA_PDF", True, when="--enable-skia-pdf") +set_define("MOZ_ENABLE_SKIA_PDF", True, when="--enable-skia-pdf") + +set_config( + "SKIA_INCLUDES", + [ + "/gfx/skia", + "/gfx/skia/skia", + ], +) + +system_lib_option( + "--with-system-webp", help="Use system libwebp (located with pkgconfig)" +) + +system_webp = pkg_check_modules( + "MOZ_WEBP", "libwebp >= 1.0.2 libwebpdemux >= 1.0.2", when="--with-system-webp" +) + +set_config("MOZ_SYSTEM_WEBP", depends(when=system_webp)(lambda: True)) + + +# Build Freetype in the tree +# ============================================================== +@depends(target, "--enable-skia-pdf") +def tree_freetype(target, skia_pdf): + if target.os == "Android" or (skia_pdf and target.os == "WINNT"): + return True + + +set_define("MOZ_TREE_FREETYPE", tree_freetype) +set_config("MOZ_TREE_FREETYPE", tree_freetype) + +set_define("HAVE_FT_BITMAP_SIZE_Y_PPEM", tree_freetype) +set_define("HAVE_FT_GLYPHSLOT_EMBOLDEN", tree_freetype) +set_define("HAVE_FT_LOAD_SFNT_TABLE", tree_freetype) + + +@depends(freetype2_combined_info, tree_freetype, build_environment) +def ft2_info(freetype2_combined_info, tree_freetype, build_env): + if tree_freetype: + return namespace( + cflags=("-I%s/modules/freetype2/include" % build_env.topsrcdir,), libs=() + ) + if freetype2_combined_info: + return freetype2_combined_info + + +set_config("FT2_LIBS", ft2_info.libs) + + +@depends(target, tree_freetype, freetype2_info) +def enable_cairo_ft(target, tree_freetype, freetype2_info): + # Avoid defining MOZ_ENABLE_CAIRO_FT on Windows platforms because + # "cairo-ft-font.c" includes <dlfcn.h>, which only exists on posix platforms + return freetype2_info or (tree_freetype and target.os != "WINNT") + + +set_config("MOZ_ENABLE_CAIRO_FT", True, when=enable_cairo_ft) +set_config("CAIRO_FT_CFLAGS", ft2_info.cflags, when=enable_cairo_ft) + + +# WebDriver (HTTP / BiDi) +# ============================================================== +# +# WebDriver is a remote control interface that enables introspection and +# control of user agents. It provides a platform- and language-neutral wire +# protocol as a way for out-of-process programs to remotely instruct the +# behavior of web browsers. +# +# The Gecko implementation is backed by Marionette and Remote Agent. +# Both protocols are not really toolkit features, as much as Gecko engine +# features. But they are enabled based on the toolkit, so here it lives. +# +# Marionette remote protocol +# ----------------------------------------------------------- +# +# Marionette is the Gecko remote protocol used for various remote control, +# automation, and testing purposes throughout Gecko-based applications like +# Firefox, Thunderbird, and any mobile browser built upon GeckoView. +# +# It also backs ../testing/geckodriver, which is Mozilla's WebDriver +# implementation. +# +# The source of Marionette lives in ../remote/marionette. +# +# For more information, see: +# https://firefox-source-docs.mozilla.org/testing/marionette/index.html +# +# Remote Agent (WebDriver BiDi / partial CDP) +# ----------------------------------------------------------- +# +# The primary purpose is the implementation of the WebDriver BiDi specification. +# But it also complements the existing Firefox Developer Tools Remote Debugging +# Protocol (RDP) by implementing a subset of the Chrome DevTools Protocol (CDP). +# +# The source of Remote Agent lives in ../remote. +# +# For more information, see: +# https://firefox-source-docs.mozilla.org/remote/index.html + + +option( + "--disable-webdriver", + help="Disable support for WebDriver remote protocols", +) + + +@depends("--disable-webdriver") +def webdriver(enabled): + if enabled: + return True + + +set_config("ENABLE_WEBDRIVER", webdriver) +set_define("ENABLE_WEBDRIVER", webdriver) + + +# geckodriver WebDriver implementation +# ============================================================== +# +# Turn off geckodriver for build configs we don't handle yet, +# but allow --enable-geckodriver to override when compile environment is available. +# --disable-tests implies disabling geckodriver. +# Disable building in CI + + +@depends( + "--enable-tests", target, cross_compiling, hazard_analysis, asan, "MOZ_AUTOMATION" +) +def geckodriver_default(enable_tests, target, cross_compile, hazard, asan, automation): + if not enable_tests: + return False + if hazard or target.os == "Android" or (asan and cross_compile): + return False + if automation: + return False + return True + + +option( + "--enable-geckodriver", + default=geckodriver_default, + when="--enable-compile-environment", + help="{Build|Do not build} geckodriver", +) + + +@depends("--enable-geckodriver", when="--enable-compile-environment") +def geckodriver(enabled): + if enabled: + return True + + +set_config("MOZ_GECKODRIVER", geckodriver) + + +# WebRTC +# ======================================================== +@depends(target) +def webrtc_default(target): + # Turn off webrtc for OS's we don't handle yet, but allow + # --enable-webrtc to override. + os_match = target.kernel in ( + "Linux", + "WINNT", + "DragonFly", + "FreeBSD", + "kFreeBSD", + "NetBSD", + "OpenBSD", + ) + + if not os_match: + os_match = target.os in ("OSX",) + + cpu_match = target.cpu in ( + "x86_64", + "arm", + "aarch64", + "x86", + "ia64", + "mips32", + "mips64", + "ppc", + "ppc64", + "riscv64", + ) + + return os_match and cpu_match and target.endianness == "little" + + +option( + "--disable-webrtc", + default=webrtc_default, + help="{Enable|Disable} support for WebRTC", +) + + +@depends("--disable-webrtc") +def webrtc(enabled): + if enabled: + return True + + +set_config("MOZ_WEBRTC", webrtc) +set_define("MOZ_WEBRTC", webrtc) +set_config("MOZ_SCTP", webrtc) +set_define("MOZ_SCTP", webrtc) +set_config("MOZ_SRTP", webrtc) +set_define("MOZ_SRTP", webrtc) +set_config("MOZ_WEBRTC_SIGNALING", webrtc) +set_define("MOZ_WEBRTC_SIGNALING", webrtc) +set_config("MOZ_PEERCONNECTION", webrtc) +set_define("MOZ_PEERCONNECTION", webrtc) +# MOZ_WEBRTC_ASSERT_ALWAYS turns on a number of safety asserts in +# opt/production builds (via MOZ_CRASH()) +set_config("MOZ_WEBRTC_ASSERT_ALWAYS", webrtc) +set_define("MOZ_WEBRTC_ASSERT_ALWAYS", webrtc) + +# RAW media +# ============================================================== + + +@depends(target, webrtc) +def raw_media_default(target, webrtc): + if target.os == "Android": + return True + if webrtc: + return True + + +option( + "--enable-raw", + default=raw_media_default, + help="{Enable|Disable} support for RAW media", +) + +set_config("MOZ_RAW", depends_if("--enable-raw")(lambda _: True)) +set_define("MOZ_RAW", depends_if("--enable-raw")(lambda _: True)) + + +# X11 +# ============================================================== +@depends(webrtc, when=toolkit_gtk) +def x11_libs(webrtc): + libs = [ + "x11", + "xcb", + "xcb-shm", + "x11-xcb", + "xext", + "xrandr >= 1.4.0", + ] + if webrtc: + # third_party/libwebrtc/webrtc/webrtc_gn/moz.build adds those + # manually, ensure they're available. + libs += [ + "xcomposite", + "xcursor", + "xdamage", + "xfixes", + "xi", + ] + return libs + + +x11_headers = pkg_check_modules( + "MOZ_X11", + x11_libs, + allow_missing=toolkit_gtk_x11_optional, + when=toolkit_gtk_x11, +) + + +set_config("MOZ_X11", True, when=x11_headers) +set_define("MOZ_X11", True, when=x11_headers) + +pkg_check_modules( + "MOZ_X11_SM", + ["ice", "sm"], + cflags_only=True, + allow_missing=toolkit_gtk_x11_optional, + when=toolkit_gtk_x11, +) + + +# ASan Reporter Addon +# ============================================================== +option( + "--enable-address-sanitizer-reporter", + help="Enable Address Sanitizer Reporter Extension", +) + + +@depends("--enable-address-sanitizer-reporter") +def enable_asan_reporter(value): + if value: + return True + + +set_config("MOZ_ASAN_REPORTER", enable_asan_reporter) +set_define("MOZ_ASAN_REPORTER", enable_asan_reporter) + +# Checks for library functions +# ============================================================== +with only_when(compile_environment & depends(target.os)(lambda os: os != "WINNT")): + set_define("HAVE_STAT64", check_symbol("stat64")) + set_define("HAVE_LSTAT64", check_symbol("lstat64")) + set_define("HAVE_TRUNCATE64", check_symbol("truncate64")) + set_define("HAVE_STATVFS64", check_symbol("statvfs64")) + set_define("HAVE_STATVFS", check_symbol("statvfs")) + set_define("HAVE_STATFS64", check_symbol("statfs64")) + set_define("HAVE_STATFS", check_symbol("statfs")) + set_define("HAVE_LUTIMES", check_symbol("lutimes")) + set_define("HAVE_POSIX_FADVISE", check_symbol("posix_fadvise")) + set_define("HAVE_POSIX_FALLOCATE", check_symbol("posix_fallocate")) + set_define("HAVE_EVENTFD", check_symbol("eventfd")) + + have_arc4random = check_symbol("arc4random") + set_define("HAVE_ARC4RANDOM", have_arc4random) + set_define("HAVE_ARC4RANDOM_BUF", check_symbol("arc4random_buf")) + set_define("HAVE_MALLINFO", check_symbol("mallinfo")) + +# Checks for headers +# ============================================================== +with only_when(compile_environment & depends(target.os)(lambda os: os != "WINNT")): + set_define("HAVE_SYSIOCCOM_H", check_header("sys/ioccom.h")) + +# Elfhack +# ============================================================== +with only_when("--enable-compile-environment"): + + @depends(host, target) + def has_elfhack(host, target): + return ( + target.kernel == "Linux" + and host.kernel == "Linux" + and target.cpu in ("arm", "aarch64", "x86", "x86_64") + ) + + option( + "--disable-elf-hack", + nargs="?", + choices=("legacy", "relr"), + help="{Enable|Disable} elf hacks", + when=has_elfhack, + ) + + @depends("--enable-elf-hack", when=has_elfhack) + def may_enable_legacy_elfhack(enable): + if enable and enable != ("relr",): + return enable + + @depends("--enable-elf-hack", when=has_elfhack) + def may_enable_relrhack(enable): + if enable and enable != ("legacy",): + return enable + + @depends( + have_arc4random, + android_version, + when=target_has_linux_kernel, + ) + def may_use_pack_relative_relocs(have_arc4random, android_version): + # Packed relative relocations are only supported on Android since + # version 11 (API 30), and in glibc since version 2.36. + # glibc 2.36 also added the arc4random function, which is our proxy + # to detect this (or newer) version being used. + # When targetting those newer versions, we allow ourselves to use + # packed relative relocations rather than elfhack. + if android_version: + return android_version >= 30 + return have_arc4random + + @depends( + c_compiler, + extra_toolchain_flags, + linker_ldflags, + readelf, + when=may_use_pack_relative_relocs | may_enable_relrhack, + ) + @checking("for -z pack-relative-relocs option to ld", bool) + @imports(_from="__builtin__", _import="FileNotFoundError") + @imports("os") + @imports(_from="tempfile", _import="mkstemp") + @imports("textwrap") + def has_pack_relative_relocs( + c_compiler, + extra_toolchain_flags, + linker_ldflags, + readelf, + ): + try: + fd, path = mkstemp(prefix="conftest.") + os.close(fd) + + pack_rel_relocs = ["-Wl,-z,pack-relative-relocs"] + 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, + # The resulting binary is expected to have relative + # relocations, the `ptr` variable attempts to ensure + # there is at least one. This requires the executable + # being built as position independent. + "int main() { return 0; }\nint (*ptr)() = main;", + pack_rel_relocs + + ["-pie", "-o", path] + + (extra_toolchain_flags or []) + + linker_ldflags, + wrapper=c_compiler.wrapper, + onerror=lambda: None, + ) + is not None + ): + # BFD ld ignores options it doesn't understand. So check + # that we did get packed relative relocations (DT_RELR). + env = os.environ.copy() + env["LANG"] = "C" + dyn = check_cmd_output(readelf, "-d", path, env=env).splitlines() + tags = [ + int(l.split()[0], 16) for l in dyn if l.strip().startswith("0x") + ] + # Older versions of readelf don't know about DT_RELR but will + # still display the tag number. + if 0x23 in tags: + needed = [l for l in dyn if l.split()[1:2] == ["(NEEDED)"]] + is_glibc = any(l.endswith("[libc.so.6]") for l in needed) + # The mold linker doesn't add a GLIBC_ABI_DT_RELR version + # dependency, which ld.so doesn't like. + # https://github.com/rui314/mold/issues/653#issuecomment-1670274638 + if is_glibc: + versions = check_cmd_output(readelf, "-V", path, env=env) + if "GLIBC_ABI_DT_RELR" in versions.split(): + return pack_rel_relocs + else: + return pack_rel_relocs + finally: + try: + os.remove(path) + except FileNotFoundError: + pass + + @depends( + has_pack_relative_relocs, + may_enable_legacy_elfhack, + may_enable_relrhack, + may_use_pack_relative_relocs, + when=has_pack_relative_relocs, + ) + def pack_relative_relocs_flags( + flags, + may_enable_legacy_elfhack, + may_enable_relrhack, + may_use_pack_relative_relocs, + ): + # When relrhack is enabled, we don't pass the flag to the linker because + # relrhack will take care of it. + if may_enable_relrhack and may_enable_relrhack.origin != "default": + return None + # if elfhack is explicitly enabled instead of relrhack, we prioritize it + # over packed relative relocs. + if may_enable_legacy_elfhack and may_enable_legacy_elfhack.origin != "default": + return None + if may_use_pack_relative_relocs: + return flags + + add_old_configure_assignment("PACK_REL_RELOC_FLAGS", pack_relative_relocs_flags) + + @depends( + select_linker, + pack_relative_relocs_flags, + has_pack_relative_relocs, + may_enable_legacy_elfhack, + may_enable_relrhack, + when=has_elfhack, + ) + def which_elf_hack( + linker, + pack_relative_relocs_flags, + has_pack_relative_relocs, + may_enable_legacy_elfhack, + may_enable_relrhack, + ): + if pack_relative_relocs_flags: + return + if may_enable_relrhack: + if has_pack_relative_relocs: + return "relr" + elif ( + may_enable_relrhack.origin != "default" + and not may_enable_legacy_elfhack + ): + die( + "Cannot enable relrhack without linker support for -z pack-relative-relocs" + ) + if may_enable_legacy_elfhack: + if linker and linker.KIND in ("lld", "mold"): + if may_enable_legacy_elfhack.origin != "default": + die( + f"Cannot enable elfhack with {linker.KIND}." + " Use --enable-linker=bfd, --enable-linker=gold, or --disable-elf-hack" + ) + else: + return "legacy" + + set_config( + "USE_ELF_HACK", True, when=depends(which_elf_hack)(lambda x: x == "legacy") + ) + + use_relrhack = depends(which_elf_hack)(lambda x: x == "relr") + set_config("RELRHACK", True, when=use_relrhack) + + @depends(c_compiler, linker_ldflags, when=use_relrhack) + def relrhack_real_linker(c_compiler, linker_ldflags): + ld = "ld" + for flag in linker_ldflags: + if flag.startswith("-fuse-ld="): + ld = "ld." + flag[len("-fuse-ld=") :] + ld = check_cmd_output( + c_compiler.compiler, f"--print-prog-name={ld}", *c_compiler.flags + ) + return ld.rstrip() + + @depends(relrhack_real_linker, when=use_relrhack) + def relrhack_linker(ld): + return os.path.basename(ld) + + set_config("RELRHACK_LINKER", relrhack_linker) + + std_filesystem = host_cxx_compiler.try_run( + header="#include <filesystem>", + body='auto foo = std::filesystem::absolute("");', + flags=host_linker_ldflags, + when=use_relrhack, + onerror=lambda: None, + ) + + stdcxxfs = host_cxx_compiler.try_run( + header="#include <filesystem>", + body='auto foo = std::filesystem::absolute("");', + flags=depends(host_linker_ldflags)( + lambda flags: (flags or []) + ["-lstdc++fs"] + ), + check_msg="whether std::filesystem requires -lstdc++fs", + when=use_relrhack & depends(std_filesystem)(lambda x: not x), + onerror=lambda: None, + ) + + set_config("RELRHACK_LIBS", ["stdc++fs"], when=stdcxxfs) + + @depends(build_environment, relrhack_real_linker, when=use_relrhack) + def relrhack_ldflags(build_env, ld): + flags = [ + "-B", + os.path.join(build_env.topobjdir, "build", "unix", "elfhack"), + ] + if os.path.basename(ld) != ld: + flags.append(f"-Wl,--real-linker,{ld}") + return flags + + set_config("RELRHACK_LDFLAGS", relrhack_ldflags) + + +@depends(build_environment) +def idl_roots(build_env): + return namespace( + ipdl_root=os.path.join(build_env.topobjdir, "ipc", "ipdl"), + webidl_root=os.path.join(build_env.topobjdir, "dom", "bindings"), + xpcom_root=os.path.join(build_env.topobjdir, "xpcom", "components"), + ) + + +set_config("WEBIDL_ROOT", idl_roots.webidl_root) +set_config("IPDL_ROOT", idl_roots.ipdl_root) +set_config("XPCOM_ROOT", idl_roots.xpcom_root) + +# Proxy bypass protection +# ============================================================== + +option( + "--enable-proxy-bypass-protection", + help="Prevent suspected or confirmed proxy bypasses", +) + + +@depends_if("--enable-proxy-bypass-protection") +def proxy_bypass_protection(_): + return True + + +set_config("MOZ_PROXY_BYPASS_PROTECTION", proxy_bypass_protection) +set_define("MOZ_PROXY_BYPASS_PROTECTION", proxy_bypass_protection) + +# Proxy direct failover +# ============================================================== + +option( + "--disable-proxy-direct-failover", + help="Disable direct failover for system requests", +) + + +@depends_if("--disable-proxy-direct-failover") +def proxy_direct_failover(value): + if value: + return True + + +set_config("MOZ_PROXY_DIRECT_FAILOVER", proxy_direct_failover) +set_define("MOZ_PROXY_DIRECT_FAILOVER", proxy_direct_failover) + +# MIDL +# ============================================================== + + +@depends(c_compiler, toolchain_prefix) +def midl_names(c_compiler, toolchain_prefix): + if c_compiler and c_compiler.type in ["gcc", "clang"]: + # mingw + widl = ("widl",) + if toolchain_prefix: + prefixed = tuple("%s%s" % (p, "widl") for p in toolchain_prefix) + widl = prefixed + widl + return widl + + return ("midl.exe",) + + +@depends(target, "--enable-compile-environment") +def check_for_midl(target, compile_environment): + if target.os != "WINNT": + return + + if compile_environment: + return True + + +midl = check_prog( + "MIDL", + midl_names, + when=check_for_midl, + allow_missing=True, + paths=sdk_bin_path, + # MIDL being used from a python wrapper script, we can live with it + # having spaces. + allow_spaces=True, +) + +option(env="MIDL_FLAGS", nargs=1, help="Extra flags to pass to MIDL") + + +@depends( + "MIDL_FLAGS", + target, + midl, + when=depends(midl, target)(lambda m, t: m and t.kernel == "WINNT"), +) +def midl_flags(flags, target, midl): + if flags: + flags = flags[0].split() + else: + flags = [] + + if not midl.endswith("widl"): + env = { + "x86": "win32", + "x86_64": "x64", + "aarch64": "arm64", + }[target.cpu] + return flags + ["-nologo", "-no_cpp", "-env", env] + + # widl + return ( + flags + + { + "x86": ["--win32", "-m32"], + "x86_64": ["--win64", "-m64"], + }[target.cpu] + ) + + +set_config("MIDL_FLAGS", midl_flags) + +# Accessibility +# ============================================================== + +option("--disable-accessibility", help="Disable accessibility support") + + +@depends("--enable-accessibility", check_for_midl, midl, c_compiler) +def accessibility(value, check_for_midl, midl, c_compiler): + enabled = bool(value) + + if not enabled: + return + + if check_for_midl and not midl: + if c_compiler and c_compiler.type in ("gcc", "clang"): + die( + "You have accessibility enabled, but widl could not be found. " + "Add --disable-accessibility to your mozconfig or install widl. " + "See https://developer.mozilla.org/en-US/docs/Cross_Compile_Mozilla_for_Mingw32 for details." + ) + else: + die( + "MIDL could not be found. " + "Building accessibility without MIDL is not supported." + ) + + return enabled + + +set_config("ACCESSIBILITY", accessibility) +set_define("ACCESSIBILITY", accessibility) + + +@depends(moz_debug, developer_options) +def a11y_log(debug, developer_options): + return debug or developer_options + + +set_config("A11Y_LOG", True, when=a11y_log) +set_define("A11Y_LOG", True, when=a11y_log) + + +# Addon signing +# ============================================================== +@depends(milestone) +def require_signing(milestone): + return milestone.is_release_or_beta and not milestone.is_esr + + +option( + env="MOZ_REQUIRE_SIGNING", + default=require_signing, + help="Enforce that add-ons are signed by the trusted root", +) + +set_config("MOZ_REQUIRE_SIGNING", True, when="MOZ_REQUIRE_SIGNING") +set_define("MOZ_REQUIRE_SIGNING", True, when="MOZ_REQUIRE_SIGNING") + +option( + "--with-unsigned-addon-scopes", + nargs="+", + choices=("app", "system"), + help="Addon scopes where signature is not required", +) + + +@depends("--with-unsigned-addon-scopes") +def unsigned_addon_scopes(scopes): + return namespace( + app="app" in scopes or None, + system="system" in scopes or None, + ) + + +set_config("MOZ_UNSIGNED_APP_SCOPE", unsigned_addon_scopes.app) +set_config("MOZ_UNSIGNED_SYSTEM_SCOPE", unsigned_addon_scopes.system) + + +# Addon sideloading +# ============================================================== +option( + "--allow-addon-sideload", + default=milestone.is_esr, + help="Addon sideloading is allowed", +) + + +set_config("MOZ_ALLOW_ADDON_SIDELOAD", True, when="--allow-addon-sideload") + +# WebExtensions API WebIDL bindings +# ============================================================== + + +@depends(milestone) +def extensions_webidl_bindings_default(milestone): + # Only enable the webidl bindings for the WebExtensions APIs + # in Nightly. + return milestone.is_nightly + + +option( + "--enable-extensions-webidl-bindings", + default=extensions_webidl_bindings_default, + help="{Enable|Disable} building experimental WebExtensions WebIDL bindings", +) + + +@depends("--enable-extensions-webidl-bindings") +def extensions_webidl_enabled(value): + return bool(value) + + +set_config("MOZ_WEBEXT_WEBIDL_ENABLED", extensions_webidl_enabled) + +# Launcher process (Windows only) +# ============================================================== + + +@depends(target) +def launcher_process_default(target): + return target.os == "WINNT" + + +option( + "--enable-launcher-process", + default=launcher_process_default, + help="{Enable|Disable} launcher process by default", +) + + +@depends("--enable-launcher-process", target) +def launcher(value, target): + enabled = bool(value) + if enabled and target.os != "WINNT": + die("Cannot enable launcher process on %s", target.os) + if enabled: + return True + + +set_config("MOZ_LAUNCHER_PROCESS", launcher) +set_define("MOZ_LAUNCHER_PROCESS", launcher) + +# llvm-dlltool (Windows only) +# ============================================================== + + +@depends(build_project, target, "--enable-compile-environment") +def check_for_llvm_dlltool(build_project, target, compile_environment): + if build_project != "browser": + return + + if target.os != "WINNT": + return + + return compile_environment + + +llvm_dlltool = check_prog( + "LLVM_DLLTOOL", + ("llvm-dlltool",), + what="llvm-dlltool", + when=check_for_llvm_dlltool, + paths=clang_search_path, +) + + +@depends(target, when=llvm_dlltool) +def llvm_dlltool_flags(target): + arch = { + "x86": "i386", + "x86_64": "i386:x86-64", + "aarch64": "arm64", + }[target.cpu] + + return ["-m", arch] + + +set_config("LLVM_DLLTOOL_FLAGS", llvm_dlltool_flags) + +# BITS download (Windows only) +# ============================================================== + +option( + "--enable-bits-download", + when=target_is_windows, + default=target_is_windows, + help="{Enable|Disable} building BITS download support", +) + +set_define( + "MOZ_BITS_DOWNLOAD", + depends_if("--enable-bits-download", when=target_is_windows)(lambda _: True), +) +set_config( + "MOZ_BITS_DOWNLOAD", + depends_if("--enable-bits-download", when=target_is_windows)(lambda _: True), +) + +# Bundled fonts on desktop platform +# ============================================================== + + +@depends(target) +def bundled_fonts_default(target): + return target.os == "WINNT" or target.kernel == "Linux" + + +@depends(build_project) +def allow_bundled_fonts(project): + return project == "browser" or project == "comm/mail" + + +option( + "--enable-bundled-fonts", + default=bundled_fonts_default, + when=allow_bundled_fonts, + help="{Enable|Disable} support for bundled fonts on desktop platforms", +) + +set_define( + "MOZ_BUNDLED_FONTS", + depends_if("--enable-bundled-fonts", when=allow_bundled_fonts)(lambda _: True), +) + +# Reflow counting +# ============================================================== + + +@depends(moz_debug) +def reflow_perf(debug): + if debug: + return True + + +option( + "--enable-reflow-perf", + default=reflow_perf, + help="{Enable|Disable} reflow performance tracing", +) + +# The difference in conditions here comes from the initial implementation +# in old-configure, which was unexplained there as well. +set_define("MOZ_REFLOW_PERF", depends_if("--enable-reflow-perf")(lambda _: True)) +set_define("MOZ_REFLOW_PERF_DSP", reflow_perf) + +# Layout debugger +# ============================================================== + + +@depends(moz_debug) +def layout_debugger(debug): + if debug: + return True + + +option( + "--enable-layout-debugger", + default=layout_debugger, + help="{Enable|Disable} layout debugger", +) + +set_config("MOZ_LAYOUT_DEBUGGER", True, when="--enable-layout-debugger") +set_define("MOZ_LAYOUT_DEBUGGER", True, when="--enable-layout-debugger") + + +# Shader Compiler for Windows (and MinGW Cross Compile) +# ============================================================== + +with only_when(compile_environment): + fxc = check_prog( + "FXC", + ("fxc.exe", "fxc2.exe"), + when=depends(target)(lambda t: t.kernel == "WINNT"), + paths=sdk_bin_path, + # FXC being used from a python wrapper script, we can live with it + # having spaces. + allow_spaces=True, + ) + + +# VPX +# === + +with only_when(compile_environment): + system_lib_option( + "--with-system-libvpx", help="Use system libvpx (located with pkgconfig)" + ) + + with only_when("--with-system-libvpx"): + vpx = pkg_check_modules("MOZ_LIBVPX", "vpx >= 1.10.0") + + check_header( + "vpx/vpx_decoder.h", + flags=vpx.cflags, + onerror=lambda: die( + "Couldn't find vpx/vpx_decoder.h, which is required to build " + "with system libvpx. Use --without-system-libvpx to build " + "with in-tree libvpx." + ), + ) + + check_symbol( + "vpx_codec_dec_init_ver", + flags=vpx.libs, + onerror=lambda: die( + "--with-system-libvpx requested but symbol vpx_codec_dec_init_ver " + "not found" + ), + ) + + set_config("MOZ_SYSTEM_LIBVPX", True) + + @depends("--with-system-libvpx", target) + def in_tree_vpx(system_libvpx, target): + if system_libvpx: + return + + arm_asm = (target.cpu == "arm") or None + return namespace(arm_asm=arm_asm) + + @depends(target, when=in_tree_vpx) + def vpx_nasm(target): + if target.cpu in ("x86", "x86_64"): + if target.kernel == "WINNT": + # Version 2.03 is needed for automatic safeseh support. + return namespace(version="2.03", what="VPX") + return namespace(what="VPX") + + @depends(in_tree_vpx, vpx_nasm, target, neon_flags) + def vpx_as_flags(vpx, vpx_nasm, target, neon_flags): + if vpx and vpx.arm_asm: + # These flags are a lie; they're just used to enable the requisite + # opcodes; actual arch detection is done at runtime. + return neon_flags + elif vpx and vpx_nasm and target.os != "WINNT" and target.cpu != "x86_64": + return ("-DPIC",) + + set_config("VPX_USE_NASM", True, when=vpx_nasm) + set_config("VPX_ASFLAGS", vpx_as_flags) + + +# JPEG +# ==== + +with only_when(compile_environment): + system_lib_option( + "--with-system-jpeg", + nargs="?", + help="Use system libjpeg (installed at given prefix)", + ) + + @depends_if("--with-system-jpeg") + def jpeg_flags(value): + if len(value): + return namespace( + cflags=("-I%s/include" % value[0],), + ldflags=("-L%s/lib" % value[0], "-ljpeg"), + ) + return namespace( + ldflags=("-ljpeg",), + ) + + with only_when("--with-system-jpeg"): + check_symbol( + "jpeg_destroy_compress", + flags=jpeg_flags.ldflags, + onerror=lambda: die( + "--with-system-jpeg requested but symbol " + "jpeg_destroy_compress not found." + ), + ) + + c_compiler.try_compile( + includes=[ + "stdio.h", + "sys/types.h", + "jpeglib.h", + ], + body=""" + #if JPEG_LIB_VERSION < 62 + #error Insufficient JPEG library version + #endif + """, + flags=jpeg_flags.cflags, + check_msg="for sufficient jpeg library version", + onerror=lambda: die( + "Insufficient JPEG library version for " + "--with-system-jpeg (62 required)" + ), + ) + + c_compiler.try_compile( + includes=[ + "stdio.h", + "sys/types.h", + "jpeglib.h", + ], + body=""" + #ifndef JCS_EXTENSIONS + #error libjpeg-turbo JCS_EXTENSIONS required + #endif + """, + flags=jpeg_flags.cflags, + check_msg="for sufficient libjpeg-turbo JCS_EXTENSIONS", + onerror=lambda: die( + "libjpeg-turbo JCS_EXTENSIONS required for " "--with-system-jpeg" + ), + ) + + set_config("MOZ_JPEG_CFLAGS", jpeg_flags.cflags) + set_config("MOZ_JPEG_LIBS", jpeg_flags.ldflags) + + @depends("--with-system-jpeg", target, neon_flags) + def in_tree_jpeg_arm(system_jpeg, target, neon_flags): + if system_jpeg: + return + + if target.cpu == "arm": + return neon_flags + elif target.cpu == "aarch64": + return ("-march=armv8-a",) + + @depends("--with-system-jpeg", target) + def in_tree_jpeg_mips64(system_jpeg, target): + if system_jpeg: + return + + if target.cpu == "mips64": + return ("-Wa,-mloongson-mmi", "-mloongson-ext") + + # Compiler check from https://github.com/libjpeg-turbo/libjpeg-turbo/blob/57ba02a408a9a55ccff25aae8b164632a3a4f177/simd/CMakeLists.txt#L419 + jpeg_mips64_mmi = c_compiler.try_compile( + body='int c = 0, a = 0, b = 0; asm("paddb %0, %1, %2" : "=f" (c) : "f" (a), "f" (b));', + check_msg="for loongson mmi support", + flags=in_tree_jpeg_mips64, + when=in_tree_jpeg_mips64, + ) + + @depends( + "--with-system-jpeg", + target, + in_tree_jpeg_arm, + in_tree_jpeg_mips64, + jpeg_mips64_mmi, + ) + def in_tree_jpeg( + system_jpeg, target, in_tree_jpeg_arm, in_tree_jpeg_mips64, jpeg_mips64_mmi + ): + if system_jpeg: + return + + if target.cpu in ("arm", "aarch64"): + return in_tree_jpeg_arm + elif target.kernel == "Darwin": + if target.cpu == "x86": + return ("-DPIC", "-DMACHO") + elif target.cpu == "x86_64": + return ("-D__x86_64__", "-DPIC", "-DMACHO") + elif target.kernel == "WINNT": + if target.cpu == "x86": + return ("-DPIC", "-DWIN32") + elif target.cpu == "x86_64": + return ("-D__x86_64__", "-DPIC", "-DWIN64", "-DMSVC") + elif target.cpu == "mips32": + return ("-mdspr2",) + elif target.cpu == "mips64" and jpeg_mips64_mmi: + return in_tree_jpeg_mips64 + elif target.cpu == "x86": + return ("-DPIC", "-DELF") + elif target.cpu == "x86_64": + return ("-D__x86_64__", "-DPIC", "-DELF") + + @depends(target, when=depends("--with-system-jpeg")(lambda x: not x)) + def jpeg_nasm(target): + if target.cpu in ("x86", "x86_64"): + # libjpeg-turbo 2.0.6 requires nasm 2.10. + return namespace(version="2.10", what="JPEG") + + # Compiler checks from https://github.com/libjpeg-turbo/libjpeg-turbo/blob/57ba02a408a9a55ccff25aae8b164632a3a4f177/simd/CMakeLists.txt#L258 + jpeg_arm_neon_vld1_s16_x3 = c_compiler.try_compile( + includes=["arm_neon.h"], + body="int16_t input[12] = {}; int16x4x3_t output = vld1_s16_x3(input);", + check_msg="for vld1_s16_x3 in arm_neon.h", + flags=in_tree_jpeg_arm, + when=in_tree_jpeg_arm, + ) + + jpeg_arm_neon_vld1_u16_x2 = c_compiler.try_compile( + includes=["arm_neon.h"], + body="uint16_t input[8] = {}; uint16x4x2_t output = vld1_u16_x2(input);", + check_msg="for vld1_u16_x2 in arm_neon.h", + flags=in_tree_jpeg_arm, + when=in_tree_jpeg_arm, + ) + + jpeg_arm_neon_vld1q_u8_x4 = c_compiler.try_compile( + includes=["arm_neon.h"], + body="uint8_t input[64] = {}; uint8x16x4_t output = vld1q_u8_x4(input);", + check_msg="for vld1q_u8_x4 in arm_neon.h", + flags=in_tree_jpeg_arm, + when=in_tree_jpeg_arm, + ) + + set_config("LIBJPEG_TURBO_USE_NASM", True, when=jpeg_nasm) + set_config("LIBJPEG_TURBO_SIMD_FLAGS", in_tree_jpeg) + set_config("LIBJPEG_TURBO_HAVE_VLD1_S16_X3", jpeg_arm_neon_vld1_s16_x3) + set_config("LIBJPEG_TURBO_HAVE_VLD1_U16_X2", jpeg_arm_neon_vld1_u16_x2) + set_config("LIBJPEG_TURBO_HAVE_VLD1Q_U8_X4", jpeg_arm_neon_vld1q_u8_x4) + set_config( + "LIBJPEG_TURBO_NEON_INTRINSICS", + jpeg_arm_neon_vld1_s16_x3 + & jpeg_arm_neon_vld1_u16_x2 + & jpeg_arm_neon_vld1q_u8_x4, + ) + + +# PNG +# === +with only_when(compile_environment): + system_lib_option( + "--with-system-png", + nargs="?", + help="Use system libpng", + ) + + @depends("--with-system-png") + def deprecated_system_png_path(value): + if len(value) == 1: + die( + "--with-system-png=PATH is not supported anymore. Please use " + "--with-system-png and set any necessary pkg-config environment variable." + ) + + png = pkg_check_modules("MOZ_PNG", "libpng >= 1.6.35", when="--with-system-png") + + check_symbol( + "png_get_acTL", + flags=png.libs, + onerror=lambda: die( + "--with-system-png won't work because the system's libpng doesn't have APNG support" + ), + when="--with-system-png", + ) + + set_config("MOZ_SYSTEM_PNG", True, when="--with-system-png") + + +# FFmpeg's ffvpx configuration +# ============================================================== +with only_when(compile_environment): + + @depends(target) + def libav_fft(target): + if target.os == "Android" and target.cpu != "arm": + return True + return target.kernel in ("WINNT", "Darwin") or target.cpu == "x86_64" + + set_config("MOZ_LIBAV_FFT", depends(when=libav_fft)(lambda: True)) + set_define("MOZ_LIBAV_FFT", depends(when=libav_fft)(lambda: True)) + + +# Artifact builds need MOZ_FFVPX defined as if compilation happened. +with only_when(compile_environment | artifact_builds): + + @depends(target) + def ffvpx(target): + enable = use_nasm = True + flac_only = False + flags = [] + + if target.kernel == "WINNT": + if target.cpu == "x86": + # 32-bit windows need to prefix symbols with an underscore. + flags = ["-DPIC", "-DWIN32", "-DPREFIX", "-Pconfig_win32.asm"] + elif target.cpu == "x86_64": + flags = [ + "-D__x86_64__", + "-DPIC", + "-DWIN64", + "-DMSVC", + "-Pconfig_win64.asm", + ] + elif target.cpu == "aarch64": + flags = ["-DPIC", "-DWIN64"] + use_nasm = False + elif target.kernel == "Darwin": + # 32/64-bit macosx assemblers need to prefix symbols with an + # underscore. + flags = ["-DPIC", "-DMACHO", "-DPREFIX"] + if target.cpu == "x86_64": + flags += [ + "-D__x86_64__", + "-Pconfig_darwin64.asm", + ] + elif target.cpu == "aarch64": + use_nasm = False + elif target.cpu == "x86_64": + flags = ["-D__x86_64__", "-DPIC", "-DELF", "-Pconfig_unix64.asm"] + elif target.cpu in ("x86", "arm", "aarch64"): + flac_only = True + else: + enable = False + + if flac_only or not enable: + use_nasm = False + + return namespace( + enable=enable, + use_nasm=use_nasm, + flac_only=flac_only, + flags=flags, + ) + + @depends(when=ffvpx.use_nasm) + def ffvpx_nasm(): + # nasm 2.10 for AVX-2 support. + return namespace(version="2.10", what="FFVPX") + + # ffvpx_nasm can't indirectly depend on vpx_as_flags, because it depends + # on a compiler test, so we have to do a little bit of dance here. + @depends(ffvpx, vpx_as_flags, target) + def ffvpx(ffvpx, vpx_as_flags, target): + if ffvpx and vpx_as_flags and target.cpu in ("arm", "aarch64"): + ffvpx.flags.extend(vpx_as_flags) + return ffvpx + + set_config("MOZ_FFVPX", True, when=ffvpx.enable) + set_define("MOZ_FFVPX", True, when=ffvpx.enable) + set_config("MOZ_FFVPX_AUDIOONLY", True, when=ffvpx.flac_only) + set_define("MOZ_FFVPX_AUDIOONLY", True, when=ffvpx.flac_only) + set_config("FFVPX_ASFLAGS", ffvpx.flags) + set_config("FFVPX_USE_NASM", True, when=ffvpx.use_nasm) + + +# nasm detection +# ============================================================== +@depends(dav1d_nasm, vpx_nasm, jpeg_nasm, ffvpx_nasm, when=compile_environment) +def need_nasm(*requirements): + requires = { + x.what: x.version if hasattr(x, "version") else True for x in requirements if x + } + if requires: + items = sorted(requires.keys()) + if len(items) > 1: + what = " and ".join((", ".join(items[:-1]), items[-1])) + else: + what = items[0] + versioned = {k: v for (k, v) in requires.items() if v is not True} + return namespace(what=what, versioned=versioned) + + +nasm = check_prog( + "NASM", + ["nasm"], + allow_missing=True, + bootstrap="nasm", + when=need_nasm, +) + + +@depends(nasm, need_nasm.what) +def check_nasm(nasm, what): + if not nasm and what: + die("Nasm is required to build with %s, but it was not found." % what) + return nasm + + +@depends_if(check_nasm) +@checking("nasm version") +def nasm_version(nasm): + version = ( + check_cmd_output(nasm, "-v", onerror=lambda: die("Failed to get nasm version.")) + .splitlines()[0] + .split()[2] + ) + return Version(version) + + +@depends(nasm_version, need_nasm.versioned, when=need_nasm.versioned) +def check_nasm_version(nasm_version, versioned): + by_version = sorted(versioned.items(), key=lambda x: x[1]) + what, version = by_version[-1] + if nasm_version < version: + die( + "Nasm version %s or greater is required to build with %s." % (version, what) + ) + return nasm_version + + +@depends(target, when=check_nasm_version) +def nasm_asflags(target): + asflags = { + ("OSX", "x86"): ["-f", "macho32"], + ("OSX", "x86_64"): ["-f", "macho64"], + ("WINNT", "x86"): ["-f", "win32"], + ("WINNT", "x86_64"): ["-f", "win64"], + }.get((target.os, target.cpu), None) + if asflags is None: + # We're assuming every x86 platform we support that's + # not Windows or Mac is ELF. + if target.cpu == "x86": + asflags = ["-f", "elf32"] + elif target.cpu == "x86_64": + asflags = ["-f", "elf64"] + return asflags + + +set_config("NASM_ASFLAGS", nasm_asflags) + + +# ANGLE OpenGL->D3D translator for WebGL +# ============================================================== + +with only_when(compile_environment & target_is_windows): + set_config("MOZ_ANGLE_RENDERER", True) + +# Remoting protocol support +# ============================================================== + + +@depends(toolkit) +def has_remote(toolkit): + if toolkit in ("gtk", "windows", "cocoa"): + return True + + +set_config("MOZ_HAS_REMOTE", has_remote) +set_define("MOZ_HAS_REMOTE", has_remote) + +# RLBox Library Sandboxing wasm support +# ============================================================== + + +def wasm_sandboxing_libraries(): + return ( + "graphite", + "ogg", + "hunspell", + "expat", + "woff2", + "soundtouch", + ) + + +@depends(dependable(wasm_sandboxing_libraries), build_project) +def default_wasm_sandboxing_libraries(libraries, build_project): + if build_project != "tools/rusttests": + non_default_libs = {} + + return tuple(l for l in libraries if l not in non_default_libs) + + +option( + "--with-wasm-sandboxed-libraries", + env="WASM_SANDBOXED_LIBRARIES", + help="{Enable wasm sandboxing for the selected libraries|Disable wasm sandboxing}", + nargs="+", + choices=dependable(wasm_sandboxing_libraries), + default=default_wasm_sandboxing_libraries, +) + + +@depends("--with-wasm-sandboxed-libraries") +def requires_wasm_sandboxing(libraries): + if libraries: + return True + + +set_config("MOZ_USING_WASM_SANDBOXING", requires_wasm_sandboxing) +set_define("MOZ_USING_WASM_SANDBOXING", requires_wasm_sandboxing) + +with only_when(requires_wasm_sandboxing & compile_environment): + option( + "--with-wasi-sysroot", + env="WASI_SYSROOT", + nargs=1, + help="Path to wasi sysroot for wasm sandboxing", + ) + + @depends("--with-wasi-sysroot", requires_wasm_sandboxing) + def bootstrap_wasi_sysroot(wasi_sysroot, requires_wasm_sandboxing): + return requires_wasm_sandboxing and not wasi_sysroot + + @depends( + "--with-wasi-sysroot", + bootstrap_path("sysroot-wasm32-wasi", when=bootstrap_wasi_sysroot), + ) + @imports("os") + def wasi_sysroot(wasi_sysroot, bootstrapped_sysroot): + if not wasi_sysroot: + return bootstrapped_sysroot + + wasi_sysroot = wasi_sysroot[0] + if not os.path.isdir(wasi_sysroot): + die("Argument to --with-wasi-sysroot must be a directory") + if not os.path.isabs(wasi_sysroot): + die("Argument to --with-wasi-sysroot must be an absolute path") + + return wasi_sysroot + + @depends(wasi_sysroot) + def wasi_sysroot_flags(wasi_sysroot): + if wasi_sysroot: + log.info("Using wasi sysroot in %s", wasi_sysroot) + return ["--sysroot=%s" % wasi_sysroot] + return [] + + set_config("WASI_SYSROOT", wasi_sysroot) + + def wasm_compiler_with_flags(compiler, sysroot_flags): + if compiler: + return ( + compiler.wrapper + [compiler.compiler] + compiler.flags + sysroot_flags + ) + + @template + def wasm_compiler_error(msg): + @depends("--with-wasm-sandboxed-libraries") + def wasm_compiler_error(sandboxed_libs): + suggest_disable = "" + if sandboxed_libs.origin == "default": + suggest_disable = " Or build with --without-wasm-sandboxed-libraries." + return lambda: die(msg + suggest_disable) + + return wasm_compiler_error + + @template + def check_wasm_compiler(compiler, language): + compiler.try_compile( + includes=["cstring" if language == "C++" else "string.h"], + flags=wasi_sysroot_flags, + check_msg="the wasm %s compiler can find wasi headers" % language, + onerror=wasm_compiler_error( + "Cannot find wasi headers or problem with the wasm compiler. " + "Please fix the problem." + ), + ) + + compiler.try_run( + flags=wasi_sysroot_flags, + check_msg="the wasm %s linker can find wasi libraries" % language, + onerror=wasm_compiler_error( + "Cannot find wasi libraries or problem with the wasm linker. " + "Please fix the problem." + ), + ) + + wasm_cc = compiler("C", wasm, other_compiler=c_compiler) + check_wasm_compiler(wasm_cc, "C") + + @depends(wasm_cc, wasi_sysroot_flags) + def wasm_cc_with_flags(wasm_cc, wasi_sysroot_flags): + return wasm_compiler_with_flags(wasm_cc, wasi_sysroot_flags) + + set_config("WASM_CC", wasm_cc_with_flags) + + wasm_cxx = compiler( + "C++", + wasm, + c_compiler=wasm_cc, + other_compiler=cxx_compiler, + other_c_compiler=c_compiler, + ) + check_wasm_compiler(wasm_cxx, "C++") + + @depends(wasm_cxx, wasi_sysroot_flags) + def wasm_cxx_with_flags(wasm_cxx, wasi_sysroot_flags): + return wasm_compiler_with_flags(wasm_cxx, wasi_sysroot_flags) + + set_config("WASM_CXX", wasm_cxx_with_flags) + + wasm_compile_flags = dependable(["-fno-exceptions", "-fno-strict-aliasing"]) + option(env="WASM_CFLAGS", nargs=1, help="Options to pass to WASM_CC") + + @depends("WASM_CFLAGS", wasm_compile_flags) + def wasm_cflags(value, wasm_compile_flags): + if value: + return wasm_compile_flags + value + else: + return wasm_compile_flags + + set_config("WASM_CFLAGS", wasm_cflags) + + option(env="WASM_CXXFLAGS", nargs=1, help="Options to pass to WASM_CXX") + + @depends("WASM_CXXFLAGS", wasm_compile_flags) + def wasm_cxxflags(value, wasm_compile_flags): + if value: + return wasm_compile_flags + value + else: + return wasm_compile_flags + + set_config("WASM_CXXFLAGS", wasm_cxxflags) + + +@depends("--with-wasm-sandboxed-libraries") +def wasm_sandboxing(libraries): + if not libraries: + return + + return namespace(**{name: True for name in libraries}) + + +@template +def wasm_sandboxing_config_defines(): + for lib in wasm_sandboxing_libraries(): + set_config( + "MOZ_WASM_SANDBOXING_%s" % lib.upper(), getattr(wasm_sandboxing, lib) + ) + set_define( + "MOZ_WASM_SANDBOXING_%s" % lib.upper(), getattr(wasm_sandboxing, lib) + ) + + +wasm_sandboxing_config_defines() + + +with only_when(compile_environment & wasm_sandboxing.hunspell): + clock_in_wasi_sysroot = wasm_cc.try_run( + header="#include <time.h>", + body="clock();", + check_msg="for clock() in wasi sysroot", + flags=depends(wasi_sysroot_flags)( + lambda sysroot_flags: ["-Werror"] + sysroot_flags + ), + ) + + wasi_emulated_clock = wasm_cc.try_run( + header="#include <time.h>", + body="clock();", + check_msg="for emulated clock() in wasi sysroot", + flags=depends(wasi_sysroot_flags)( + lambda sysroot_flags: [ + "-Werror", + "-D_WASI_EMULATED_PROCESS_CLOCKS", + "-lwasi-emulated-process-clocks", + ] + + sysroot_flags + ), + when=depends(clock_in_wasi_sysroot)(lambda x: not x), + onerror=lambda: die("Can't find clock() in wasi sysroot."), + ) + + set_config("MOZ_WASI_EMULATED_CLOCK", True, when=wasi_emulated_clock) + + +# new Notification Store implementation +# ============================================================== + + +@depends(milestone) +def new_notification_store(milestone): + if milestone.is_nightly: + return True + + +set_config("MOZ_NEW_NOTIFICATION_STORE", True, when=new_notification_store) +set_define("MOZ_NEW_NOTIFICATION_STORE", True, when=new_notification_store) + + +# Auxiliary files persistence on application close +# ============================================================== + +option( + "--enable-disk-remnant-avoidance", + help="Prevent persistence of auxiliary files on application close", +) + + +set_config( + "MOZ_AVOID_DISK_REMNANT_ON_CLOSE", + True, + when="--enable-disk-remnant-avoidance", +) + + +# Glean SDK Integration Crate +# ============================================================== + + +@depends(target) +def glean_android(target): + return target.os == "Android" + + +set_config("MOZ_GLEAN_ANDROID", True, when=glean_android) +set_define("MOZ_GLEAN_ANDROID", True, when=glean_android) + + +# dump_syms +# ============================================================== + +check_prog( + "DUMP_SYMS", + ["dump_syms"], + allow_missing=True, + bootstrap="dump_syms", + when=compile_environment, +) + + +@depends(valid_windows_sdk_dir, host) +@imports(_from="os", _import="environ") +def pdbstr_paths(valid_windows_sdk_dir, host): + if not valid_windows_sdk_dir: + return + + vc_host = { + "x86": "x86", + "x86_64": "x64", + }.get(host.cpu) + + return [ + environ["PATH"], + os.path.join(valid_windows_sdk_dir.path, "Debuggers", vc_host, "srcsrv"), + ] + + +check_prog( + "PDBSTR", + ["pdbstr.exe"], + allow_missing=True, + when=compile_environment & target_is_windows, + paths=pdbstr_paths, + allow_spaces=True, +) + + +@depends("MOZ_AUTOMATION", c_compiler) +def allow_missing_winchecksec(automation, c_compiler): + if not automation: + return True + if c_compiler and c_compiler.type != "clang-cl": + return True + + +check_prog( + "WINCHECKSEC", + ["winchecksec.exe", "winchecksec"], + bootstrap="winchecksec", + allow_missing=allow_missing_winchecksec, + when=compile_environment & target_is_windows, +) + + +# Fork server +@depends(target, build_project) +def forkserver_default(target, build_project): + return build_project == "browser" and ( + (target.os == "GNU" and target.kernel == "Linux") + or target.os == "FreeBSD" + or target.os == "OpenBSD" + ) + + +option( + "--enable-forkserver", + default=forkserver_default, + env="MOZ_ENABLE_FORKSERVER", + help="{Enable|Disable} fork server", +) + + +@depends("--enable-forkserver", target) +def forkserver_flag(value, target): + if ( + target.os == "Android" + or (target.os == "GNU" and target.kernel == "Linux") + or target.os == "FreeBSD" + or target.os == "OpenBSD" + ): + return bool(value) + pass + + +set_config("MOZ_ENABLE_FORKSERVER", forkserver_flag) +set_define("MOZ_ENABLE_FORKSERVER", forkserver_flag, forkserver_flag) + +# Crash Reporter +# ============================================================== + +with only_when(compile_environment & target_has_linux_kernel): + # Check if we need to use the breakpad_getcontext fallback. + getcontext = check_symbol("getcontext") + set_config("HAVE_GETCONTEXT", getcontext) + set_define("HAVE_GETCONTEXT", getcontext) + +# NSS +# ============================================================== +include("../build/moz.configure/nss.configure") + + +# Enable or disable running in background task mode: headless for +# periodic, short-lived, maintenance tasks. +# ============================================================================== +option( + "--disable-backgroundtasks", + help="Disable running in background task mode", +) +set_config("MOZ_BACKGROUNDTASKS", True, when="--enable-backgroundtasks") +set_define("MOZ_BACKGROUNDTASKS", True, when="--enable-backgroundtasks") + + +# Update-related programs: updater, maintenance service, update agent, +# default browser agent. +# ============================================================== +include("../build/moz.configure/update-programs.configure") + + +# Mobile optimizations +# ============================================================== +option( + "--enable-mobile-optimize", + default=target_is_android, + help="{Enable|Disable} mobile optimizations", +) + +set_define("MOZ_GFX_OPTIMIZE_MOBILE", True, when="--enable-mobile-optimize") +# We ignore "paint will resample" on mobile for performance. +# We may want to revisit this later. +set_define("MOZ_IGNORE_PAINT_WILL_RESAMPLE", True, when="--enable-mobile-optimize") + +# Pref extensions +# ============================================================== +option("--disable-pref-extensions", help="Disable pref extensions such as autoconfig") +set_config("MOZ_PREF_EXTENSIONS", True, when="--enable-pref-extensions") + +# Offer a way to disable the startup cache +# ============================================================== +option("--disable-startupcache", help="Disable startup cache") + + +@depends("--enable-startupcache") +def enable_startupcache(value): + if value: + return True + + +set_define( + "MOZ_DISABLE_STARTUPCACHE", True, when=depends(enable_startupcache)(lambda x: not x) +) + + +# Branding +# ============================================================== +option( + env="MOZ_APP_REMOTINGNAME", + nargs=1, + help="Used for the internal program name, which affects profile name " + "and remoting. If not set, defaults to MOZ_APP_NAME if the update channel " + "is release, and MOZ_APP_NAME-MOZ_UPDATE_CHANNEL otherwise.", +) + + +@depends("MOZ_APP_REMOTINGNAME", moz_app_name, update_channel) +def moz_app_remotingname(value, moz_app_name, update_channel): + if value: + return value[0] + if update_channel == "release": + return moz_app_name + return moz_app_name + "-" + update_channel + + +set_config("MOZ_APP_REMOTINGNAME", moz_app_remotingname) + +option( + env="ANDROID_PACKAGE_NAME", + nargs=1, + help="Name of the Android package (default org.mozilla.$MOZ_APP_NAME)", +) + + +@depends("ANDROID_PACKAGE_NAME", moz_app_name) +def android_package_name(value, moz_app_name): + if value: + return value[0] + if moz_app_name == "fennec": + return "org.mozilla.fennec_aurora" + return "org.mozilla.%s" % moz_app_name + + +set_config("ANDROID_PACKAGE_NAME", android_package_name) + + +# Miscellaneous options +# ============================================================== +option(env="MOZ_WINCONSOLE", nargs="?", help="Whether we can create a console window.") +set_define("MOZ_WINCONSOLE", True, when=depends("MOZ_WINCONSOLE")(lambda x: x)) + + +# Alternative Crashreporter setting +option( + "--with-crashreporter-url", + env="MOZ_CRASHREPORTER_URL", + default="https://crash-reports.mozilla.com/", + nargs=1, + help="Set an alternative crashreporter url", +) + +set_config( + "MOZ_CRASHREPORTER_URL", + depends("--with-crashreporter-url")(lambda x: x[0].rstrip("/")), +) + + +# Crash reporter options +# ============================================================== +@depends(target) +def oxidized_breakpad(target): + if target.kernel == "Linux": + return target.cpu in ("aarch64", "arm", "x86", "x86_64") + return False + + +set_config("MOZ_OXIDIZED_BREAKPAD", True, when=oxidized_breakpad) +set_define("MOZ_OXIDIZED_BREAKPAD", True, when=oxidized_breakpad) + + +# Wine +# ============================================================== +@depends(target, host) +def want_wine(target, host): + return target.kernel == "WINNT" and host.kernel != "WINNT" + + +wine = check_prog( + "WINE", + ["wine64", "wine"], + when=want_wine, + bootstrap="wine/bin", +) + +# DOM Streams +# ============================================================== +# Set this to true so the JS engine knows we're doing a browser build. +set_config("MOZ_DOM_STREAMS", True) +set_define("MOZ_DOM_STREAMS", True) + +# libevent +# ============================================================== +with only_when(compile_environment): + system_lib_option( + "--with-system-libevent", + nargs="?", + help="Use system libevent", + ) + + @depends("--with-system-libevent") + def deprecated_system_libevent_path(value): + if len(value) == 1: + die( + "--with-system-libevent=PATH is not supported anymore. Please use " + "--with-system-libevent and set any necessary pkg-config environment variable." + ) + + pkg_check_modules("MOZ_LIBEVENT", "libevent", when="--with-system-libevent") + + set_config("MOZ_SYSTEM_LIBEVENT", True, when="--with-system-libevent") + + +# Crash reporting +# ============================================================== +@depends(target, developer_options, artifact_builds) +def crashreporter_default(target, developer_options, artifacts): + if target.kernel in ("WINNT", "Darwin"): + return True + if target.kernel == "Linux" and target.cpu in ("x86", "x86_64", "arm", "aarch64"): + # The crash reporter prevents crash stacktraces to be logged in the + # logs on Android, so we leave it out by default in developer builds. + return target.os != "Android" or not developer_options or artifacts + + +option( + "--enable-crashreporter", + default=crashreporter_default, + help="{Enable|Disable} crash reporting", +) + + +set_config("MOZ_CRASHREPORTER", True, when="--enable-crashreporter") +set_define("MOZ_CRASHREPORTER", True, when="--enable-crashreporter") + +with only_when(compile_environment): + with only_when("--enable-crashreporter"): + pkg_check_modules( + "MOZ_GTHREAD", + "gthread-2.0", + when=depends(target)(lambda t: t.os == "GNU" and t.kernel == "Linux"), + ) + + set_config( + "MOZ_CRASHREPORTER_INJECTOR", + True, + when=depends(target)(lambda t: t.os == "WINNT" and t.bitness == 32), + ) + set_define( + "MOZ_CRASHREPORTER_INJECTOR", + True, + when=depends(target)(lambda t: t.os == "WINNT" and t.bitness == 32), + ) + + +# If we have any service that uploads data (and requires data submission +# policy alert), set MOZ_DATA_REPORTING. +# ============================================================== +@depends( + "MOZ_TELEMETRY_REPORTING", + "MOZ_SERVICES_HEALTHREPORT", + "--enable-crashreporter", + "MOZ_NORMANDY", +) +def data_reporting(telemetry, healthreport, crashreporter, normandy): + return telemetry or healthreport or crashreporter or normandy + + +set_config("MOZ_DATA_REPORTING", True, when=data_reporting) +set_define("MOZ_DATA_REPORTING", True, when=data_reporting) + + +# Gtk+ +# ============================================================== +with only_when(toolkit_gtk): + pkg_check_modules( + "MOZ_GTK3", + "gtk+-3.0 >= 3.14.0 gtk+-unix-print-3.0 glib-2.0 gobject-2.0 gio-unix-2.0", + ) + + set_define("GDK_VERSION_MIN_REQUIRED", "GDK_VERSION_3_14") + set_define("GDK_VERSION_MAX_ALLOWED", "GDK_VERSION_3_14") + + pkg_check_modules("GLIB", "glib-2.0 >= 2.42 gobject-2.0") + + set_define("GLIB_VERSION_MIN_REQUIRED", "GLIB_VERSION_2_42") + set_define("GLIB_VERSION_MAX_ALLOWED", "GLIB_VERSION_2_42") + + set_define("MOZ_ACCESSIBILITY_ATK", True, when=accessibility) + +# DBus +# ============================================================== +with only_when(toolkit_gtk): + option("--disable-dbus", help="Disable dbus support") + + with only_when("--enable-dbus"): + pkg_check_modules("MOZ_DBUS", "dbus-1 >= 0.60") + + set_config("MOZ_ENABLE_DBUS", True) + set_define("MOZ_ENABLE_DBUS", True) + + +# Necko's wifi scanner +# ============================================================== +@depends(target) +def necko_wifi_when(target): + return target.os in ("WINNT", "OSX", "DragonFly", "FreeBSD") or ( + target.kernel == "Linux" and target.os == "GNU" + ) + + +option("--disable-necko-wifi", help="Disable necko wifi scanner", when=necko_wifi_when) + +set_config("NECKO_WIFI", True, when="--enable-necko-wifi") +set_define("NECKO_WIFI", True, when="--enable-necko-wifi") + + +@depends( + depends("--enable-necko-wifi", when=necko_wifi_when)(lambda x: x), + depends("--enable-dbus", when=toolkit_gtk)(lambda x: x), + when=depends(target)(lambda t: t.os == "GNU" and t.kernel == "Linux"), +) +def necko_wifi_dbus(necko_wifi, dbus): + if necko_wifi and not dbus: + die( + "Necko WiFi scanning needs DBus on your platform, remove --disable-dbus" + " or use --disable-necko-wifi" + ) + return necko_wifi and dbus + + +set_config("NECKO_WIFI_DBUS", True, when=necko_wifi_dbus) +set_define("NECKO_WIFI_DBUS", True, when=necko_wifi_dbus) + + +# Frontend JS debug mode +# ============================================================== +option("--enable-debug-js-modules", help="Enable debug mode for frontend JS libraries") + +set_config("DEBUG_JS_MODULES", True, when="--enable-debug-js-modules") + + +# moz_dump_painting +# ============================================================== +option("--enable-dump-painting", help="Enable paint debugging") + +set_define( + "MOZ_DUMP_PAINTING", + True, + when=depends("--enable-dump-painting", "--enable-debug")( + lambda painting, debug: painting or debug + ), +) +set_define("MOZ_LAYERS_HAVE_LOG", True, when="--enable-dump-painting") + + +# libproxy support +# ============================================================== +with only_when(toolkit_gtk): + system_lib_option("--enable-libproxy", help="Enable libproxy support") + + with only_when("--enable-libproxy"): + pkg_check_modules("MOZ_LIBPROXY", "libproxy-1.0") + + set_config("MOZ_ENABLE_LIBPROXY", True) + set_define("MOZ_ENABLE_LIBPROXY", True) + + +# Enable runtime logging +# ============================================================== +set_define("MOZ_LOGGING", True) +set_define("FORCE_PR_LOG", True) + +# This will enable logging of addref, release, ctor, dtor. +# ============================================================== +option( + "--enable-logrefcnt", + default=moz_debug, + help="{Enable|Disable} logging of refcounts", +) + +set_define("NS_BUILD_REFCNT_LOGGING", True, when="--enable-logrefcnt") + + +# NegotiateAuth +# ============================================================== +option("--disable-negotiateauth", help="Disable GSS-API negotiation") + +set_config("MOZ_AUTH_EXTENSION", True, when="--enable-negotiateauth") +set_define("MOZ_AUTH_EXTENSION", True, when="--enable-negotiateauth") + + +# Parental control +# ============================================================== +option("--disable-parental-controls", help="Do not build parental controls") + +set_config( + "MOZ_DISABLE_PARENTAL_CONTROLS", + True, + when=depends("--enable-parental-controls")(lambda x: not x), +) +set_define( + "MOZ_DISABLE_PARENTAL_CONTROLS", + True, + when=depends("--enable-parental-controls")(lambda x: not x), +) + + +# Sandboxing support +# ============================================================== +@depends(target, tsan, asan) +def sandbox_default(target, tsan, asan): + # Only enable the sandbox by default on Linux, OpenBSD, macOS, and Windows + if target.kernel == "Linux" and target.os == "GNU": + # Bug 1182565: TSan conflicts with sandboxing on Linux. + # Bug 1287971: LSan also conflicts with sandboxing on Linux. + if tsan or asan: + return False + # Linux sandbox is only available on x86{,_64} and arm{,64}. + return target.cpu in ("x86", "x86_64", "arm", "aarch64") + return target.kernel in ("WINNT", "Darwin", "OpenBSD") + + +option( + "--enable-sandbox", + default=sandbox_default, + help="{Enable|Disable} sandboxing support", +) + +set_config("MOZ_SANDBOX", True, when="--enable-sandbox") +set_define("MOZ_SANDBOX", True, when="--enable-sandbox") + +with only_when(depends(target.kernel)(lambda k: k not in ("Darwin", "WINNT"))): + set_define("MOZ_CONTENT_TEMP_DIR", True, when="--enable-sandbox") + +# Searching of system directories for extensions. +# ============================================================== +# Note: this switch is meant to be used for test builds whose behavior should +# not depend on what happens to be installed on the local machine. +option( + "--disable-system-extension-dirs", + help="Disable searching system- and account-global directories for extensions" + " of any kind; use only profile-specific extension directories", +) + +set_define("ENABLE_SYSTEM_EXTENSION_DIRS", True, when="--enable-system-extension-dirs") + + +# Pixman +# ============================================================== +with only_when(compile_environment): + system_lib_option( + "--enable-system-pixman", help="Use system pixman (located with pkgconfig)" + ) + + @depends("--enable-system-pixman") + def in_tree_pixman(pixman): + return not pixman + + set_config("MOZ_TREE_PIXMAN", True, when=in_tree_pixman) + set_define("MOZ_TREE_PIXMAN", True, when=in_tree_pixman) + + pkg_check_modules("MOZ_PIXMAN", "pixman-1 >= 0.36.0", when="--enable-system-pixman") + # Set MOZ_PIXMAN_CFLAGS to an explicit empty value when --enable-system-pixman is *not* used, + # for layout/style/extra-bindgen-flags + set_config("MOZ_PIXMAN_CFLAGS", [], when=in_tree_pixman) + + +# Universalchardet +# ============================================================== +with only_when(compile_environment): + option("--disable-universalchardet", help="Disable universal encoding detection") + + set_config("MOZ_UNIVERSALCHARDET", True, when="--enable-universalchardet") + + +# Disable zipwriter +# ============================================================== +with only_when(compile_environment): + option("--disable-zipwriter", help="Disable zipwriter component") + + set_config("MOZ_ZIPWRITER", True, when="--enable-zipwriter") + + +# Location of the mozilla user directory +# ============================================================== +with only_when(compile_environment): + + @depends(target) + def default_user_appdir(target): + if target.kernel in ("WINNT", "Darwin"): + return "Mozilla" + return ".mozilla" + + option( + "--with-user-appdir", + nargs=1, + default=default_user_appdir, + help="Set user-specific appdir", + ) + + @depends("--with-user-appdir") + def user_appdir(appdir): + if not appdir: + die("--without-user-appdir is not a valid option.") + if "/" in appdir[0]: + die("--with-user-appdir must be a single relative path.") + return '"{}"'.format(appdir[0]) + + set_define("MOZ_USER_DIR", user_appdir) + + +# Check for sin_len and sin6_len - used by SCTP; only appears in Mac/*BSD generally +# ============================================================== +with only_when(compile_environment): + have_sin_len = c_compiler.try_compile( + includes=["netinet/in.h"], + body="struct sockaddr_in x; void *foo = (void*) &x.sin_len;", + check_msg="for sin_len in struct sockaddr_in", + ) + have_sin6_len = c_compiler.try_compile( + includes=["netinet/in.h"], + body="struct sockaddr_in6 x; void *foo = (void*) &x.sin6_len;", + check_msg="for sin_len6 in struct sockaddr_in6", + ) + set_define("HAVE_SIN_LEN", have_sin_len) + set_define("HAVE_SIN6_LEN", have_sin6_len) + # HAVE_CONN_LEN must be the same as HAVE_SIN_LEN and HAVE_SIN6_LEN + set_define("HAVE_SCONN_LEN", have_sin_len & have_sin6_len) + set_define( + "HAVE_SA_LEN", + c_compiler.try_compile( + includes=["netinet/in.h"], + body="struct sockaddr x; void *foo = (void*) &x.sa_len;", + check_msg="for sa_len in struct sockaddr", + ), + ) + + +# Check for pthread_cond_timedwait_monotonic_np +# ============================================================== +with only_when(compile_environment): + set_define( + "HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC", + c_compiler.try_compile( + includes=["pthread.h"], + body="pthread_cond_timedwait_monotonic_np(0, 0, 0);", + # -Werror to catch any "implicit declaration" warning that means the function + # is not supported. + flags=["-Werror=implicit-function-declaration"], + check_msg="for pthread_cond_timedwait_monotonic_np", + ), + ) + + +# Custom dynamic linker for Android +# ============================================================== +with only_when(target_has_linux_kernel & compile_environment): + option( + env="MOZ_LINKER", + default=depends(target.os, when="--enable-jemalloc")( + lambda os: os == "Android" + ), + help="{Enable|Disable} custom dynamic linker", + ) + + set_config("MOZ_LINKER", True, when="MOZ_LINKER") + set_define("MOZ_LINKER", True, when="MOZ_LINKER") + add_old_configure_assignment("MOZ_LINKER", True, when="MOZ_LINKER") + + moz_linker = depends(when="MOZ_LINKER")(lambda: True) + + +# 32-bits ethtool_cmd.speed +# ============================================================== +with only_when(target_has_linux_kernel & compile_environment): + set_config( + "MOZ_WEBRTC_HAVE_ETHTOOL_SPEED_HI", + c_compiler.try_compile( + includes=["linux/ethtool.h"], + body="struct ethtool_cmd cmd; cmd.speed_hi = 0;", + check_msg="for 32-bits ethtool_cmd.speed", + ), + ) + +# Gamepad support +# ============================================================== +check_header( + "linux/joystick.h", + onerror=lambda: die( + "Can't find header linux/joystick.h, needed for gamepad support." + " Please install Linux kernel headers." + ), + when=target_has_linux_kernel & compile_environment, +) + + +# Smart card support +# ============================================================== +@depends(build_project) +def disable_smart_cards(build_project): + return build_project == "mobile/android" + + +set_config("MOZ_NO_SMART_CARDS", True, when=disable_smart_cards) +set_define("MOZ_NO_SMART_CARDS", True, when=disable_smart_cards) + +# Enable UniFFI fixtures +# ============================================================== +# These are used to test the uniffi-bindgen-gecko-js code generation. They +# should not be enabled in release builds. + +option( + "--enable-uniffi-fixtures", + help="Enable UniFFI Fixtures/Examples", +) + +set_config("MOZ_UNIFFI_FIXTURES", True, when="--enable-uniffi-fixtures") + +# System policies +# ============================================================== + +option( + "--disable-system-policies", + help="Disable reading policies from Windows registry, macOS's file system attributes, and /etc/firefox", +) + +set_config("MOZ_SYSTEM_POLICIES", True, when="--enable-system-policies") + +# Allow disabling the creation a legacy profile +# ============================================================== + +option( + "--disable-legacy-profile-creation", + help="Disable the creation a legacy profile, to be used by old versions " + "of Firefox, when no profiles exist.", +) + +set_config("MOZ_CREATE_LEGACY_PROFILE", True, when="--enable-legacy-profile-creation") + + +# STL wrapping +# ============================================================== +set_config("WRAP_STL_INCLUDES", True) +set_config( + "STL_FLAGS", + depends(build_environment.dist)(lambda dist: [f"-I{dist}/stl_wrappers"]), +) + + +# Perl detection +# ============================================================== +@depends(target) +def need_perl(target): + # Ideally, we'd also depend on gnu_as here, but that adds complications. + return target.cpu == "arm" + + +perl = check_prog("PERL", ("perl5", "perl"), when=need_perl) + + +@template +def perl_version_check(min_version): + @depends(perl) + @checking("for minimum required perl version >= %s" % min_version) + def get_perl_version(perl): + return Version( + check_cmd_output( + perl, + "-e", + "print $]", + onerror=lambda: die("Failed to get perl version."), + ) + ) + + @depends(get_perl_version) + def check_perl_version(version): + if version < min_version: + die("Perl %s or higher is required.", min_version) + + @depends(perl) + @checking("for full perl installation") + @imports("subprocess") + def has_full_perl_installation(perl): + ret = subprocess.call([perl, "-e", "use Config; exit(!-d $Config{archlib})"]) + return ret == 0 + + @depends(has_full_perl_installation) + def require_full_perl_installation(has_full_perl_installation): + if not has_full_perl_installation: + die( + "Cannot find Config.pm or $Config{archlib}. " + "A full perl installation is required." + ) + + +with only_when(need_perl): + perl_version_check("5.006") + + +# windows-rs as bootstrappable toolchain +# ============================================================== +# The in-tree windows crate's purpose is to avoid vendoring the +# original windows crate, which is too large. +# The ideal solution would be for cargo to allow exceptions to +# vendoring, but it doesn't. +# The adopted solution is to somehow use the crate contents from +# a directory given via the mozbuild config, or bootstrapped. +# +# Unfortunately, doing `include!(mozbuild::windows_rs_path!("src/lib.rs"))` +# in the crate's lib.rs doesn't work because of +# https://github.com/rust-lang/rust/issues/66920. +# +# Previous versions of the windows crate had submodules declared +# directly in lib.rs. Annotating each of them with +# `#[path = concat!(mozbuild::windows_rs_path!("path/to/mod.rs"))]` +# unfortunately also didn't work, because of +# https://github.com/rust-lang/rust/issues/48250. +# +# Thankfully, newer versions of the windows crate now only have an +# `include!` at the end of lib.rs, so we can get away with simply +# replacing it with an `include!` that uses `mozbuild::windows_rs_path!`. +# +# We ensure that the in-tree contents match what we expect based on +# the original crate. +# The expectations are as such: +# - Cargo.toml is identical to the original one with the addition of the +# following two lines at the end (after an empty line): +# [dependencies.mozbuild] +# version = "0.1" +# - src/lib.rs is mostly identical to the original one, with two notable +# differences: +# - the addition of `#![allow(warnings)]` on the first line, because if +# the crate had been vendored normally, it would not be affected by +# `-D warnings`, and `#![allow(warnings)]` mimicks that. +# - the replacement of any +# `include!("path/file.rs")` +# with +# `include!(mozbuild::windows_rs_path!("src/path/file.rs"))` +with only_when(target_is_windows & compile_environment): + option( + env="MOZ_WINDOWS_RS_DIR", + nargs=1, + help="Path to the source of the 'windows' Rust crate", + ) + + @depends( + "MOZ_WINDOWS_RS_DIR", + bootstrap_path( + "windows-rs", + when=depends("MOZ_WINDOWS_RS_DIR")(lambda x: not x), + ), + build_environment.topsrcdir, + ) + @checking("for the windows rust crate source") + @imports(_from="__builtin__", _import="open") + @imports("re") + @imports("toml") + def windows_rs_dir(dir, bootstrapped, topsrcdir): + if bootstrapped: + dir = bootstrapped + elif dir: + dir = dir[0] + + raw_cargo_toml = open( + os.path.join(topsrcdir, "build/rust/windows/Cargo.toml") + ).read() + cargo_toml = toml.loads(raw_cargo_toml) + expected_version = cargo_toml["package"]["version"] + + if not dir: + raise FatalCheckError( + "Cannot find the windows rust crate source.\n" + f"Try downloading it with `cargo download -x windows={expected_version}`\n" + "(you may need to `cargo install cargo-download` first)\n" + f"and set `MOZ_WINDOWS_RS_DIR` to location of the `windows-{expected_version}`" + " directory" + ) + + raw_cargo_toml_orig = open(os.path.join(dir, "Cargo.toml")).read() + cargo_toml = toml.loads(raw_cargo_toml_orig) + version = cargo_toml["package"]["version"] + if version != expected_version: + raise FatalCheckError( + f"The windows rust crate source in {dir} contains version " + f"{version}, but expected {expected_version}." + ) + # Now that we've done the basic sanity check, let's go deeper. + DEPENDENCIES = '\n[dependencies.mozbuild]\nversion = "0.1"\n' + if not raw_cargo_toml.endswith(DEPENDENCIES): + configure_error("In-tree windows crate is missing dependency on mozbuild") + if raw_cargo_toml[: -len(DEPENDENCIES)] != raw_cargo_toml_orig: + configure_error("In-tree windows crate Cargo.toml doesn't match original") + + lib_rs = open(os.path.join(topsrcdir, "build/rust/windows/src/lib.rs")).read() + lib_rs_orig = open(os.path.join(dir, "src/lib.rs")).read() + lib_rs_expected = "#![allow(warnings)]\n" + re.sub( + r'include!\("([^"]*)"\)', + r'include!(mozbuild::windows_rs_path!("src/\1"))', + lib_rs_orig, + ) + if lib_rs != lib_rs_expected: + configure_error("In-tree windows crate lib.rs doesn't match original") + + return dir + + set_config("MOZ_WINDOWS_RS_DIR", windows_rs_dir) |