moz.configure

   1 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
   2 # vim: set filetype=python:
   3 # This Source Code Form is subject to the terms of the Mozilla Public
   4 # License, v. 2.0. If a copy of the MPL was not distributed with this
   5 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   6
   7 include("build/moz.configure/init.configure")
   8
   9 # Note:
  10 # - Gecko-specific options and rules should go in toolkit/moz.configure.
  11 # - Firefox-specific options and rules should go in browser/moz.configure.
  12 # - Fennec-specific options and rules should go in
  13 #   mobile/android/moz.configure.
  14 # - Spidermonkey-specific options and rules should go in js/moz.configure.
  15 # - etc.
  16
  17 option(
  18     "--enable-artifact-builds",
  19     env="MOZ_ARTIFACT_BUILDS",
  20     help="Download and use prebuilt binary artifacts.",
  21 )
  22
  23
  24 @depends("--enable-artifact-builds")
  25 def artifact_builds(value):
  26     if value:
  27         return True
  28
  29
  30 set_config("MOZ_ARTIFACT_BUILDS", artifact_builds)
  31
  32 imply_option(
  33     "--enable-artifact-build-symbols",
  34     depends(artifact_builds)(lambda v: False if v is None else None),
  35     reason="--disable-artifact-builds",
  36 )
  37
  38 option(
  39     "--enable-artifact-build-symbols",
  40     nargs="?",
  41     choices=("full",),
  42     help="Download symbols when artifact builds are enabled.",
  43 )
  44
  45
  46 @depends("--enable-artifact-build-symbols", "MOZ_AUTOMATION", target)
  47 def enable_artifact_build_symbols(value, automation, target):
  48     if len(value):
  49         return value[0]
  50     if bool(value):
  51         if target.os == "Android" and not automation:
  52             return "full"
  53         return True
  54     return None
  55
  56
  57 set_config("MOZ_ARTIFACT_BUILD_SYMBOLS", enable_artifact_build_symbols)
  58
  59
  60 @depends("--enable-artifact-builds")
  61 def imply_disable_compile_environment(value):
  62     if value:
  63         return False
  64
  65
  66 option(
  67     env="MOZ_COPY_PDBS",
  68     help="For builds that do not support symbols in the normal fashion,"
  69     " generate and copy them into the resulting build archive.",
  70 )
  71
  72 set_config("MOZ_COPY_PDBS", depends_if("MOZ_COPY_PDBS")(lambda _: True))
  73
  74 imply_option("--enable-compile-environment", imply_disable_compile_environment)
  75
  76 option("--disable-compile-environment", help="Disable compiler/library checks")
  77
  78
  79 @depends("--disable-compile-environment")
  80 def compile_environment(compile_env):
  81     if compile_env:
  82         return True
  83
  84
  85 set_config("COMPILE_ENVIRONMENT", compile_environment)
  86 add_old_configure_assignment("COMPILE_ENVIRONMENT", compile_environment)
  87
  88 option("--disable-tests", help="Do not build test libraries & programs")
  89
  90
  91 @depends("--disable-tests")
  92 def enable_tests(value):
  93     if value:
  94         return True
  95
  96
  97 set_config("ENABLE_TESTS", enable_tests)
  98 set_define("ENABLE_TESTS", enable_tests)
  99
 100
 101 @depends(enable_tests)
 102 def gtest_has_rtti(value):
 103     if value:
 104         return "0"
 105
 106
 107 set_define("GTEST_HAS_RTTI", gtest_has_rtti)
 108
 109
 110 @depends(target, enable_tests)
 111 def linux_gtest_defines(target, enable_tests):
 112     if enable_tests and target.os == "Android":
 113         return namespace(os_linux_android=True, use_own_tr1_tuple=True, has_clone="0")
 114
 115
 116 set_define("GTEST_OS_LINUX_ANDROID", linux_gtest_defines.os_linux_android)
 117 set_define("GTEST_USE_OWN_TR1_TUPLE", linux_gtest_defines.use_own_tr1_tuple)
 118 set_define("GTEST_HAS_CLONE", linux_gtest_defines.has_clone)
 119
 120 option(
 121     "--enable-debug",
 122     nargs="?",
 123     help="Enable building with developer debug info "
 124     "(using the given compiler flags).",
 125 )
 126
 127
 128 @depends("--enable-debug")
 129 def moz_debug(debug):
 130     if debug:
 131         return bool(debug)
 132
 133
 134 set_config("MOZ_DEBUG", moz_debug)
 135 set_define("MOZ_DEBUG", moz_debug)
 136 # Override any value MOZ_DEBUG may have from the environment when passing it
 137 # down to old-configure.
 138 add_old_configure_assignment("MOZ_DEBUG", depends("--enable-debug")(lambda x: bool(x)))
 139
 140 option(
 141     "--with-debug-label",
 142     nargs="+",
 143     help="Debug DEBUG_<value> for each comma-separated value given",
 144 )
 145
 146
 147 @depends(moz_debug, "--with-debug-label")
 148 def debug_defines(debug, labels):
 149     if debug:
 150         return ["DEBUG"] + ["DEBUG_%s" % label for label in labels]
 151     return ["NDEBUG", "TRIMMED"]
 152
 153
 154 set_config("MOZ_DEBUG_DEFINES", debug_defines)
 155
 156 option(
 157     "--enable-rust-debug",
 158     default=depends(when="--enable-debug")(lambda: True),
 159     help="{Build|Do not build} Rust code with debug assertions turned " "on.",
 160 )
 161
 162
 163 @depends(when="--enable-rust-debug")
 164 def debug_rust():
 165     return True
 166
 167
 168 set_config("MOZ_DEBUG_RUST", debug_rust)
 169 set_define("MOZ_DEBUG_RUST", debug_rust)
 170
 171 option(env="MOZ_PGO", help="Build with profile guided optimizations")
 172
 173 set_config("MOZ_PGO", depends("MOZ_PGO")(lambda x: bool(x)))
 174
 175
 176 wine = check_prog(
 177     "WINE",
 178     ["wine64", "wine"],
 179     allow_missing=True,
 180     when=depends(target, host)(
 181         lambda t, h: t.kernel == "WINNT" and h.kernel != "WINNT"
 182     ),
 183 )
 184 check_prog("WGET", ("wget",), allow_missing=True)
 185
 186
 187 include("build/moz.configure/toolchain.configure", when="--enable-compile-environment")
 188
 189 include("build/moz.configure/pkg.configure")
 190 # Make this assignment here rather than in pkg.configure to avoid
 191 # requiring this file in unit tests.
 192 add_old_configure_assignment("PKG_CONFIG", pkg_config)
 193
 194 include("build/moz.configure/memory.configure", when="--enable-compile-environment")
 195 include("build/moz.configure/headers.configure", when="--enable-compile-environment")
 196 include("build/moz.configure/warnings.configure", when="--enable-compile-environment")
 197 include("build/moz.configure/flags.configure", when="--enable-compile-environment")
 198 include("build/moz.configure/lto-pgo.configure", when="--enable-compile-environment")
 199 # rust.configure is included by js/moz.configure.
 200
 201 option("--enable-valgrind", help="Enable Valgrind integration hooks")
 202
 203 valgrind_h = check_header("valgrind/valgrind.h", when="--enable-valgrind")
 204
 205
 206 @depends("--enable-valgrind", valgrind_h)
 207 def check_valgrind(valgrind, valgrind_h):
 208     if valgrind:
 209         if not valgrind_h:
 210             die("--enable-valgrind specified but Valgrind is not installed")
 211         return True
 212
 213
 214 set_define("MOZ_VALGRIND", check_valgrind)
 215 set_config("MOZ_VALGRIND", check_valgrind)
 216
 217
 218 @depends(target, host)
 219 def is_openbsd(target, host):
 220     return target.kernel == "OpenBSD" or host.kernel == "OpenBSD"
 221
 222
 223 option(
 224     env="SO_VERSION",
 225     nargs=1,
 226     default="1.0",
 227     when=is_openbsd,
 228     help="Shared library version for OpenBSD systems",
 229 )
 230
 231
 232 @depends("SO_VERSION", when=is_openbsd)
 233 def so_version(value):
 234     return value
 235
 236
 237 @template
 238 def library_name_info_template(host_or_target):
 239     assert host_or_target in {host, target}
 240     compiler = {
 241         host: host_c_compiler,
 242         target: c_compiler,
 243     }[host_or_target]
 244
 245     @depends(host_or_target, compiler, so_version)
 246     def library_name_info_impl(host_or_target, compiler, so_version):
 247         if host_or_target.kernel == "WINNT":
 248             # There aren't artifacts for mingw builds, so it's OK that the
 249             # results are inaccurate in that case.
 250             if compiler and compiler.type != "clang-cl":
 251                 return namespace(
 252                     dll=namespace(prefix="", suffix=".dll"),
 253                     lib=namespace(prefix="lib", suffix="a"),
 254                     import_lib=namespace(prefix="lib", suffix="a"),
 255                     obj=namespace(prefix="", suffix="o"),
 256                 )
 257
 258             return namespace(
 259                 dll=namespace(prefix="", suffix=".dll"),
 260                 lib=namespace(prefix="", suffix="lib"),
 261                 import_lib=namespace(prefix="", suffix="lib"),
 262                 obj=namespace(prefix="", suffix="obj"),
 263             )
 264
 265         elif host_or_target.kernel == "Darwin":
 266             return namespace(
 267                 dll=namespace(prefix="lib", suffix=".dylib"),
 268                 lib=namespace(prefix="lib", suffix="a"),
 269                 import_lib=namespace(prefix=None, suffix=""),
 270                 obj=namespace(prefix="", suffix="o"),
 271             )
 272         elif so_version:
 273             so = ".so.%s" % so_version
 274         else:
 275             so = ".so"
 276
 277         return namespace(
 278             dll=namespace(prefix="lib", suffix=so),
 279             lib=namespace(prefix="lib", suffix="a"),
 280             import_lib=namespace(prefix=None, suffix=""),
 281             obj=namespace(prefix="", suffix="o"),
 282         )
 283
 284     return library_name_info_impl
 285
 286
 287 host_library_name_info = library_name_info_template(host)
 288 library_name_info = library_name_info_template(target)
 289
 290 set_config("DLL_PREFIX", library_name_info.dll.prefix)
 291 set_config("DLL_SUFFIX", library_name_info.dll.suffix)
 292 set_config("HOST_DLL_PREFIX", host_library_name_info.dll.prefix)
 293 set_config("HOST_DLL_SUFFIX", host_library_name_info.dll.suffix)
 294 set_config("LIB_PREFIX", library_name_info.lib.prefix)
 295 set_config("LIB_SUFFIX", library_name_info.lib.suffix)
 296 set_config("OBJ_SUFFIX", library_name_info.obj.suffix)
 297 # Lots of compilation tests depend on this variable being present.
 298 add_old_configure_assignment("OBJ_SUFFIX", library_name_info.obj.suffix)
 299 set_config("IMPORT_LIB_SUFFIX", library_name_info.import_lib.suffix)
 300 set_define(
 301     "MOZ_DLL_PREFIX", depends(library_name_info.dll.prefix)(lambda s: '"%s"' % s)
 302 )
 303 set_define(
 304     "MOZ_DLL_SUFFIX", depends(library_name_info.dll.suffix)(lambda s: '"%s"' % s)
 305 )
 306 set_config("WASM_OBJ_SUFFIX", "wasm")
 307
 308 # Make `profiling` available to this file even when js/moz.configure
 309 # doesn't end up included.
 310 profiling = dependable(False)
 311 # Same for js_standalone
 312 js_standalone = dependable(False)
 313 # Same for fold_libs
 314 fold_libs = dependable(False)
 315
 316 include(include_project_configure)
 317
 318
 319 @depends("--help")
 320 @imports(_from="mozbuild.backend", _import="backends")
 321 def build_backends_choices(_):
 322     return tuple(backends)
 323
 324
 325 @deprecated_option("--enable-build-backend", nargs="+", choices=build_backends_choices)
 326 def build_backend(backends):
 327     if backends:
 328         return tuple("+%s" % b for b in backends)
 329
 330
 331 imply_option("--build-backends", build_backend)
 332
 333
 334 @depends(
 335     "--enable-artifact-builds",
 336     "--disable-compile-environment",
 337     "--enable-build-backend",
 338     "--enable-project",
 339     "--enable-application",
 340     "--help",
 341 )
 342 @imports("sys")
 343 def build_backend_defaults(
 344     artifact_builds, compile_environment, requested_backends, project, application, _
 345 ):
 346     if application:
 347         project = application[0]
 348     elif project:
 349         project = project[0]
 350
 351     if "Tup" in requested_backends:
 352         # As a special case, if Tup was requested, do not combine it with any
 353         # Make based backend by default.
 354         all_backends = []
 355     elif artifact_builds:
 356         all_backends = ["FasterMake+RecursiveMake"]
 357     else:
 358         all_backends = ["RecursiveMake", "FasterMake"]
 359     # Normally, we'd use target.os == 'WINNT', but a dependency on target
 360     # would require target to depend on --help, as well as host and shell,
 361     # and this is not a can of worms we can open at the moment.
 362     if sys.platform == "win32" and compile_environment and project != "mobile/android":
 363         all_backends.append("VisualStudio")
 364     return tuple(all_backends) or None
 365
 366
 367 option(
 368     "--build-backends",
 369     nargs="+",
 370     default=build_backend_defaults,
 371     choices=build_backends_choices,
 372     help="Build backends to generate",
 373 )
 374
 375
 376 @depends("--build-backends")
 377 def build_backends(backends):
 378     return backends
 379
 380
 381 set_config("BUILD_BACKENDS", build_backends)
 382
 383
 384 @depends(check_build_environment, build_backends)
 385 @imports("glob")
 386 def check_objdir_backend_reuse(build_env, backends):
 387     # "Make based" might be RecursiveMake or a hybrid backend, so "Make" is
 388     # intentionally vague for use with the substring match below.
 389     incompatible_backends = (("Tup", "Make"), ("Make", "Tup"))
 390     for backend_file in glob.iglob(
 391         os.path.join(build_env.topobjdir, "backend.*Backend")
 392     ):
 393         for prev, curr in incompatible_backends:
 394             if prev in backend_file and any(curr in b for b in backends):
 395                 die(
 396                     "The active objdir, %s, was previously "
 397                     "used to build with a %s based backend. "
 398                     "Change objdirs (by setting MOZ_OBJDIR in "
 399                     "your mozconfig) or clobber to continue.\n",
 400                     build_env.topobjdir,
 401                     prev,
 402                 )
 403
 404
 405 option(
 406     "--disable-gtest-in-build",
 407     help="Force disable building the gtest libxul during the build.",
 408     when="--enable-compile-environment",
 409 )
 410
 411 # Determine whether to build the gtest xul. This happens in automation
 412 # on Android and Desktop platforms with the exception of:
 413 #  - Windows PGO, where linking xul-gtest.dll takes too long;
 414 #  - Android other than x86_64, where gtest is not required.
 415 @depends(
 416     "MOZ_PGO",
 417     build_project,
 418     target,
 419     "MOZ_AUTOMATION",
 420     "--disable-gtest-in-build",
 421     enable_tests,
 422     when="--enable-compile-environment",
 423 )
 424 def build_gtest(pgo, build_project, target, automation, enabled, enable_tests):
 425     if not enable_tests or not enabled:
 426         return None
 427     if (
 428         automation
 429         and build_project in ("browser", "comm/mail", "mobile/android")
 430         and not (
 431             (pgo and target.os == "WINNT")
 432             or (target.os == "Android" and target.cpu != "x86_64")
 433         )
 434     ):
 435         return True
 436
 437
 438 set_config("LINK_GTEST_DURING_COMPILE", build_gtest)
 439
 440 # Localization
 441 # ==============================================================
 442 option(
 443     "--enable-ui-locale",
 444     default="en-US",
 445     help="Select the user interface locale (default: en-US)",
 446 )
 447
 448 set_config("MOZ_UI_LOCALE", depends("--enable-ui-locale")(lambda x: x))
 449
 450 # clang-plugin location
 451 # ==============================================================
 452 @depends(host_library_name_info, check_build_environment, when="--enable-clang-plugin")
 453 def clang_plugin_path(library_name_info, build_env):
 454     topobjdir = build_env.topobjdir
 455     if topobjdir.endswith("/js/src"):
 456         topobjdir = topobjdir[:-7]
 457     return os.path.abspath(
 458         os.path.join(
 459             topobjdir,
 460             "build",
 461             "clang-plugin",
 462             "%sclang-plugin%s"
 463             % (library_name_info.dll.prefix, library_name_info.dll.suffix),
 464         )
 465     )
 466
 467
 468 add_old_configure_assignment("CLANG_PLUGIN", clang_plugin_path)
 469
 470
 471 # Awk detection
 472 # ==============================================================
 473 awk = check_prog("AWK", ("gawk", "mawk", "nawk", "awk"))
 474
 475 # Until the AWK variable is not necessary in old-configure
 476 @depends(awk)
 477 def awk_for_old_configure(value):
 478     return value
 479
 480
 481 add_old_configure_assignment("AWK", awk_for_old_configure)
 482
 483
 484 # Perl detection
 485 # ==============================================================
 486 perl = check_prog("PERL", ("perl5", "perl"))
 487
 488 # Until the PERL variable is not necessary in old-configure
 489 @depends(perl)
 490 def perl_for_old_configure(value):
 491     return value
 492
 493
 494 add_old_configure_assignment("PERL", perl_for_old_configure)
 495
 496
 497 @template
 498 def perl_version_check(min_version):
 499     @depends(perl)
 500     @checking("for minimum required perl version >= %s" % min_version)
 501     def get_perl_version(perl):
 502         return Version(
 503             check_cmd_output(
 504                 perl,
 505                 "-e",
 506                 "print $]",
 507                 onerror=lambda: die("Failed to get perl version."),
 508             )
 509         )
 510
 511     @depends(get_perl_version)
 512     def check_perl_version(version):
 513         if version < min_version:
 514             die("Perl %s or higher is required.", min_version)
 515
 516     @depends(perl)
 517     @checking("for full perl installation")
 518     @imports("subprocess")
 519     def has_full_perl_installation(perl):
 520         ret = subprocess.call([perl, "-e", "use Config; exit(!-d $Config{archlib})"])
 521         return ret == 0
 522
 523     @depends(has_full_perl_installation)
 524     def require_full_perl_installation(has_full_perl_installation):
 525         if not has_full_perl_installation:
 526             die(
 527                 "Cannot find Config.pm or $Config{archlib}. "
 528                 "A full perl installation is required."
 529             )
 530
 531
 532 perl_version_check("5.006")
 533
 534
 535 # GNU make detection
 536 # ==============================================================
 537 option(env="MAKE", nargs=1, help="Path to GNU make")
 538
 539
 540 @depends("MAKE", host)
 541 def possible_makes(make, host):
 542     candidates = []
 543     if host.kernel == "WINNT":
 544         candidates.append("mingw32-make")
 545     if make:
 546         candidates.append(make[0])
 547     if host.kernel == "WINNT":
 548         candidates.extend(("make", "gmake"))
 549     else:
 550         candidates.extend(("gmake", "make"))
 551     return candidates
 552
 553
 554 check_prog("GMAKE", possible_makes)
 555
 556 # watchman detection
 557 # ==============================================================
 558
 559 option(env="WATCHMAN", nargs=1, help="Path to the watchman program")
 560
 561
 562 @depends(host, "WATCHMAN")
 563 @checking("for watchman", callback=lambda w: w.path if w else "not found")
 564 def watchman(host, prog):
 565     # On Windows, `watchman` is only supported on 64-bit hosts.
 566     if host.os == "WINNT" and host.cpu != "x86_64":
 567         return
 568
 569     if not prog:
 570         prog = find_program("watchman")
 571
 572     if not prog:
 573         return
 574
 575     # `watchman version` will talk to the Watchman daemon service.
 576     # This can hang due to permissions problems. e.g.
 577     # https://github.com/facebook/watchman/issues/376. So use
 578     # `watchman --version` to prevent a class of failures.
 579     out = check_cmd_output(prog, "--version", onerror=lambda: None)
 580     if out is None:
 581         return
 582
 583     return namespace(path=prog, version=Version(out.strip()))
 584
 585
 586 @depends_if(watchman)
 587 @checking("for watchman version")
 588 def watchman_version(w):
 589     return w.version
 590
 591
 592 set_config("WATCHMAN", watchman.path)
 593
 594
 595 @depends_all(hg_version, hg_config, watchman)
 596 @checking("for watchman Mercurial integration")
 597 @imports("os")
 598 def watchman_hg(hg_version, hg_config, watchman):
 599     if hg_version < Version("3.8"):
 600         return "no (Mercurial 3.8+ required)"
 601
 602     ext_enabled = False
 603     mode_disabled = False
 604
 605     for k in ("extensions.fsmonitor", "extensions.hgext.fsmonitor"):
 606         if k in hg_config and hg_config[k] != "!":
 607             ext_enabled = True
 608
 609     mode_disabled = hg_config.get("fsmonitor.mode") == "off"
 610
 611     if not ext_enabled:
 612         return "no (fsmonitor extension not enabled)"
 613     if mode_disabled:
 614         return "no (fsmonitor.mode=off disables fsmonitor)"
 615
 616     return True
 617
 618
 619 # Miscellaneous programs
 620 # ==============================================================
 621 check_prog("XARGS", ("xargs",))
 622
 623
 624 @depends(target)
 625 def extra_programs(target):
 626     if target.kernel == "Darwin":
 627         return namespace(
 628             DSYMUTIL=("dsymutil", "llvm-dsymutil"),
 629             MKFSHFS=("newfs_hfs", "mkfs.hfsplus"),
 630             HFS_TOOL=("hfsplus",),
 631         )
 632     if target.os == "GNU" and target.kernel == "Linux":
 633         return namespace(RPMBUILD=("rpmbuild",))
 634
 635
 636 check_prog("DSYMUTIL", extra_programs.DSYMUTIL, allow_missing=True)
 637 check_prog("MKFSHFS", extra_programs.MKFSHFS, allow_missing=True)
 638 check_prog("HFS_TOOL", extra_programs.HFS_TOOL, allow_missing=True)
 639 check_prog("RPMBUILD", extra_programs.RPMBUILD, allow_missing=True)
 640
 641
 642 @depends(target)
 643 @imports("os")
 644 def makensis_progs(target):
 645     if target.kernel != "WINNT":
 646         return
 647
 648     candidates = [
 649         "makensis-3.01",
 650         "makensis-3.0b3",
 651         "makensis-3.0b1",
 652         "makensis",
 653     ]
 654
 655     # Look for nsis installed by msys environment. But only the 32-bit version.
 656     # We use an absolute path and insert as the first entry so it is preferred
 657     # over a 64-bit exe that may be in PATH.
 658     if "MSYSTEM_PREFIX" in os.environ:
 659         prefix = os.path.dirname(os.environ["MSYSTEM_PREFIX"])
 660         candidates.insert(0, os.path.join(prefix, "mingw32", "bin", "makensis.exe"))
 661
 662     return tuple(candidates)
 663
 664
 665 nsis = check_prog("MAKENSISU", makensis_progs, allow_missing=True)
 666
 667 # Make sure the version of makensis is up to date.
 668 @depends(nsis, wine)
 669 @checking("for NSIS version")
 670 @imports("re")
 671 def nsis_version(nsis, wine):
 672     if not nsis:
 673         return None
 674     nsis_min_version = "3.0b1"
 675     onerror = lambda: die("Failed to get nsis version.")
 676     if wine and nsis.lower().endswith(".exe"):
 677         out = check_cmd_output(wine, nsis, "-version", onerror=onerror)
 678     else:
 679         out = check_cmd_output(nsis, "-version", onerror=onerror)
 680
 681     m = re.search(r"(?<=v)[0-9]+\.[0-9]+((a|b|rc)[0-9]+)?", out)
 682
 683     if not m:
 684         raise FatalCheckError("Unknown version of makensis")
 685     ver = Version(m.group(0))
 686
 687     # Versions comparisons don't quite work well with beta versions, so ensure
 688     # it works for the non-beta version.
 689     if ver < nsis_min_version and (ver >= "3.0a" or ver < "3"):
 690         raise FatalCheckError(
 691             "To build the installer you must have NSIS"
 692             " version %s or greater in your path" % nsis_min_version
 693         )
 694
 695     return ver
 696
 697
 698 # And that makensis is 32-bit (but only on Windows).
 699 @depends_if(nsis, when=depends(host)(lambda h: h.kernel == "WINNT"))
 700 @checking("for 32-bit NSIS")
 701 def nsis_binary_type(nsis):
 702     bin_type = windows_binary_type(nsis)
 703     if bin_type != "win32":
 704         raise FatalCheckError("%s is not a 32-bit Windows application" % nsis)
 705
 706     return "yes"
 707
 708
 709 # And any flags we have to give to makensis
 710 @depends(host)
 711 def nsis_flags(host):
 712     if host.kernel != "WINNT":
 713         return "-nocd"
 714     return ""
 715
 716
 717 set_config("MAKENSISU_FLAGS", nsis_flags)
 718
 719 check_prog("7Z", ("7z", "7za"), allow_missing=True, when=target_is_windows)
 720 check_prog("UPX", ("upx",), allow_missing=True, when=target_is_windows)
 721
 722
 723 @depends(host_c_compiler, c_compiler, bindgen_config_paths)
 724 def llvm_objdump(host_c_compiler, c_compiler, bindgen_config_paths):
 725     clang = None
 726     for compiler in (host_c_compiler, c_compiler):
 727         if compiler and compiler.type == "clang":
 728             clang = compiler.compiler
 729             break
 730         elif compiler and compiler.type == "clang-cl":
 731             clang = os.path.join(os.path.dirname(compiler.compiler), "clang")
 732             break
 733
 734     if not clang and bindgen_config_paths:
 735         clang = bindgen_config_paths.clang_path
 736     llvm_objdump = "llvm-objdump"
 737     if clang:
 738         out = check_cmd_output(
 739             clang, "--print-prog-name=llvm-objdump", onerror=lambda: None
 740         )
 741         if out:
 742             llvm_objdump = out.rstrip()
 743     return (llvm_objdump,)
 744
 745
 746 llvm_objdump = check_prog(
 747     "LLVM_OBJDUMP",
 748     llvm_objdump,
 749     what="llvm-objdump",
 750     when="--enable-compile-environment",
 751     paths=toolchain_search_path,
 752 )
 753
 754 add_old_configure_assignment("LLVM_OBJDUMP", llvm_objdump)
 755
 756
 757 option("--enable-dtrace", help="Build with dtrace support")
 758
 759 dtrace = check_header(
 760     "sys/sdt.h",
 761     when="--enable-dtrace",
 762     onerror=lambda: die("dtrace enabled but sys/sdt.h not found"),
 763 )
 764
 765 set_config("HAVE_DTRACE", True, when=dtrace)
 766 set_define("INCLUDE_MOZILLA_DTRACE", True, when=dtrace)
 767 add_old_configure_assignment("enable_dtrace", "yes", when=dtrace)
 768
 769
 770 option("--disable-icf", help="Disable Identical Code Folding")
 771
 772 add_old_configure_assignment(
 773     "MOZ_DISABLE_ICF", "1", when=depends("--enable-icf")(lambda x: not x)
 774 )
 775
 776
 777 option(
 778     "--enable-strip",
 779     when=compile_environment,
 780     help="Enable stripping of libs & executables",
 781 )
 782
 783 # This should be handled as a `when` once bug 1617793 is fixed.
 784 @depends("--enable-strip", c_compiler, when=compile_environment)
 785 def enable_strip(strip, c_compiler):
 786     if strip and c_compiler.type != "clang-cl":
 787         return True
 788
 789
 790 set_config("ENABLE_STRIP", enable_strip)
 791
 792 option(
 793     "--disable-install-strip",
 794     when=compile_environment,
 795     help="Enable stripping of libs & executables when packaging",
 796 )
 797
 798 # This should be handled as a `when` once bug 1617793 is fixed.
 799 @depends("--enable-install-strip", c_compiler, when=compile_environment)
 800 def enable_install_strip(strip, c_compiler):
 801     if strip and c_compiler.type != "clang-cl":
 802         return True
 803
 804
 805 set_config("PKG_STRIP", enable_install_strip)
 806
 807
 808 @depends("--enable-strip", "--enable-install-strip", when=compile_environment)
 809 def strip(strip, install_strip):
 810     return strip or install_strip
 811
 812
 813 option(env="STRIP_FLAGS", nargs=1, when=strip, help="Flags for the strip command")
 814
 815
 816 @depends("STRIP_FLAGS", profiling, target, when=strip)
 817 def strip_flags(flags, profiling, target):
 818     if flags:
 819         return flags[0].split()
 820     if profiling:
 821         # Only strip debug info and symbols when profiling is enabled, keeping
 822         # local symbols.
 823         if target.kernel == "Darwin":
 824             return ["-S"]
 825         elif target.os == "Android":
 826             # The tooling we use with Android supports detached symbols, and the
 827             # size increase caused by local symbols are too much for mobile. So,
 828             # don't restrict the amount of stripping with a flag.
 829             return
 830         else:
 831             return ["--strip-debug"]
 832     # Otherwise strip everything we can, which happens without flags on non-Darwin.
 833     # On Darwin, it tries to strip things it can't, so we need to limit its scope.
 834     elif target.kernel == "Darwin":
 835         return ["-x", "-S"]
 836
 837
 838 set_config("STRIP_FLAGS", strip_flags)
 839
 840
 841 @depends(js_standalone, target)
 842 def system_zlib_default(js_standalone, target):
 843     return js_standalone and target.kernel != "WINNT"
 844
 845
 846 option(
 847     "--with-system-zlib",
 848     nargs="?",
 849     default=system_zlib_default,
 850     help="{Use|Do not use} system libz",
 851 )
 852
 853
 854 @depends("--with-system-zlib")
 855 def deprecated_system_zlib_path(value):
 856     if len(value) == 1:
 857         die(
 858             "--with-system-zlib=PATH is not supported anymore. Please use "
 859             "--with-system-zlib and set any necessary pkg-config environment variable."
 860         )
 861
 862
 863 pkg_check_modules("MOZ_ZLIB", "zlib >= 1.2.3", when="--with-system-zlib")
 864
 865 set_config("MOZ_SYSTEM_ZLIB", True, when="--with-system-zlib")
 866 add_old_configure_assignment("MOZ_SYSTEM_ZLIB", True, when="--with-system-zlib")
 867
 868
 869 # Please do not add configure checks from here on.
 870
 871 # Fallthrough to autoconf-based configure
 872 include("build/moz.configure/old.configure")
 873
 874 # JS Subconfigure.
 875 include("js/sub.configure", when=compile_environment & toolkit)
 876
 877
 878 @depends(check_build_environment, build_project)
 879 @imports("__sandbox__")
 880 @imports("glob")
 881 @imports(_from="os.path", _import="exists")
 882 def config_status_deps(build_env, build_project):
 883
 884     topsrcdir = build_env.topsrcdir
 885     topobjdir = build_env.topobjdir
 886
 887     if not topobjdir.endswith("js/src"):
 888         extra_deps = [os.path.join(topobjdir, ".mozconfig.json")]
 889     else:
 890         # mozconfig changes may impact js configure.
 891         extra_deps = [os.path.join(topobjdir[:-7], ".mozconfig.json")]
 892
 893     confvars = os.path.join(topsrcdir, build_project, "confvars.sh")
 894     if exists(confvars):
 895         extra_deps.append(confvars)
 896
 897     return (
 898         list(__sandbox__._all_paths)
 899         + extra_deps
 900         + [
 901             os.path.join(topsrcdir, "CLOBBER"),
 902             os.path.join(topsrcdir, "configure.in"),
 903             os.path.join(topsrcdir, "js", "src", "configure.in"),
 904             os.path.join(topsrcdir, "nsprpub", "configure"),
 905             os.path.join(topsrcdir, "config", "milestone.txt"),
 906             os.path.join(topsrcdir, "browser", "config", "version.txt"),
 907             os.path.join(topsrcdir, "browser", "config", "version_display.txt"),
 908             os.path.join(topsrcdir, "build", "build_virtualenv_packages.txt"),
 909             os.path.join(topsrcdir, "build", "common_virtualenv_packages.txt"),
 910             os.path.join(topsrcdir, "build", "mach_virtualenv_packages.txt"),
 911             os.path.join(topsrcdir, "python", "mozbuild", "mozbuild", "virtualenv.py"),
 912             os.path.join(topsrcdir, "testing", "mozbase", "packages.txt"),
 913             os.path.join(topsrcdir, "aclocal.m4"),
 914             os.path.join(topsrcdir, "old-configure.in"),
 915             os.path.join(topsrcdir, "js", "src", "aclocal.m4"),
 916             os.path.join(topsrcdir, "js", "src", "old-configure.in"),
 917         ]
 918         + glob.glob(os.path.join(topsrcdir, "build", "autoconf", "*.m4"))
 919     )
 920
 921
 922 set_config("CONFIG_STATUS_DEPS", config_status_deps)
 923 # Please do not add anything after setting config_dep_paths.