summaryrefslogtreecommitdiffstats
path: root/build/moz.configure
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /build/moz.configure
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'build/moz.configure')
-rw-r--r--build/moz.configure/android-ndk.configure150
-rw-r--r--build/moz.configure/checks.configure144
-rw-r--r--build/moz.configure/compile-checks.configure152
-rw-r--r--build/moz.configure/compilers-util.configure62
-rw-r--r--build/moz.configure/headers.configure93
-rw-r--r--build/moz.configure/init.configure780
-rw-r--r--build/moz.configure/java.configure62
-rw-r--r--build/moz.configure/keyfiles.configure68
-rw-r--r--build/moz.configure/memory.configure98
-rw-r--r--build/moz.configure/old.configure425
-rw-r--r--build/moz.configure/pkg.configure97
-rw-r--r--build/moz.configure/rust.configure166
-rw-r--r--build/moz.configure/toolchain.configure910
-rw-r--r--build/moz.configure/util.configure440
-rw-r--r--build/moz.configure/warnings.configure111
-rw-r--r--build/moz.configure/windows.configure431
16 files changed, 4189 insertions, 0 deletions
diff --git a/build/moz.configure/android-ndk.configure b/build/moz.configure/android-ndk.configure
new file mode 100644
index 000000000..6a0b30529
--- /dev/null
+++ b/build/moz.configure/android-ndk.configure
@@ -0,0 +1,150 @@
+# -*- 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/.
+
+
+js_option('--with-android-ndk', nargs=1,
+ help='location where the Android NDK can be found')
+
+js_option('--with-android-toolchain', nargs=1,
+ help='location of the Android toolchain')
+
+js_option('--with-android-gnu-compiler-version', nargs=1,
+ help='GNU compiler version to use')
+
+min_android_version = dependable(lambda: '9')
+
+js_option('--with-android-version',
+ nargs=1,
+ help='android platform version',
+ default=min_android_version)
+
+@depends('--with-android-version', min_android_version)
+@imports(_from='__builtin__', _import='ValueError')
+def android_version(value, min_version):
+ if not value:
+ # Someone has passed --without-android-version.
+ die('--with-android-version cannot be disabled.')
+
+ try:
+ version = int(value[0])
+ except ValueError:
+ die('--with-android-version expects an integer value')
+
+ if version < int(min_version):
+ die('--with-android-version must be at least %s (got %s)',
+ min_version, value[0])
+
+ return version
+
+add_old_configure_assignment('android_version', android_version)
+
+@depends('--with-android-ndk', build_project)
+def ndk(value, build_project):
+ if build_project == 'mobile/android' and not value:
+ die('You must specify --with-android-ndk=/path/to/ndk when '
+ 'building mobile/android')
+ if value:
+ return value[0]
+
+set_config('ANDROID_NDK', ndk)
+add_old_configure_assignment('android_ndk', ndk)
+
+@depends(target, android_version, ndk)
+@checking('for android platform directory')
+@imports(_from='os.path', _import='isdir')
+def android_platform(target, android_version, ndk):
+ if target.os != 'Android':
+ return
+
+ if 'mips' in target.cpu:
+ target_dir_name = 'mips'
+ elif 'aarch64' == target.cpu:
+ target_dir_name = 'arm64'
+ else:
+ target_dir_name = target.cpu
+
+ # Not all Android releases have their own platform release. We use
+ # the next lower platform version in these cases.
+ if android_version in (11, 10):
+ platform_version = 9
+ elif android_version in (20, 22):
+ platform_version = android_version - 1
+ else:
+ platform_version = android_version
+
+ platform_dir = os.path.join(ndk,
+ 'platforms',
+ 'android-%s' % platform_version,
+ 'arch-%s' % target_dir_name)
+
+ if not isdir(platform_dir):
+ die("Android platform directory not found. With the current "
+ "configuration, it should be in %s" % platform_dir)
+
+ return platform_dir
+
+add_old_configure_assignment('android_platform', android_platform)
+
+@depends(android_platform)
+def extra_toolchain_flags(platform_dir):
+ if not platform_dir:
+ return []
+ return ['-idirafter',
+ os.path.join(platform_dir, 'usr', 'include')]
+
+@depends(target, host, ndk, '--with-android-toolchain',
+ '--with-android-gnu-compiler-version')
+@checking('for the Android toolchain directory', lambda x: x or 'not found')
+@imports(_from='os.path', _import='isdir')
+@imports(_from='mozbuild.shellutil', _import='quote')
+def android_toolchain(target, host, ndk, toolchain, gnu_compiler_version):
+ if not ndk:
+ return
+ if toolchain:
+ return toolchain[0]
+ else:
+ if target.cpu == 'arm' and target.endianness == 'little':
+ target_base = 'arm-linux-androideabi'
+ elif target.cpu == 'x86':
+ target_base = 'x86'
+ elif target.cpu == 'mips32' and target.endianness == 'little':
+ target_base = 'mipsel-linux-android'
+ elif target.cpu == 'aarch64' and target.endianness == 'little':
+ target_base = 'aarch64-linux-android'
+ else:
+ die('Target cpu is not supported.')
+
+ toolchain_format = '%s/toolchains/%s-%s/prebuilt/%s-%s'
+
+ for version in gnu_compiler_version or ['4.9', '4.8', '4.7']:
+ toolchain = toolchain_format % (ndk, target_base, version,
+ host.kernel.lower(), host.cpu)
+ log.debug('Trying %s' % quote(toolchain))
+ if not isdir(toolchain) and host.cpu == 'x86_64':
+ toolchain = toolchain_format % (ndk, target_base, version,
+ host.kernel.lower(), 'x86')
+ log.debug('Trying %s' % quote(toolchain))
+ if isdir(toolchain):
+ return toolchain
+ else:
+ if gnu_compiler_version:
+ die('Your --with-android-gnu-compiler-version may be wrong')
+ die('You have to specify --with-android-toolchain='
+ '/path/to/ndk/toolchain.')
+
+set_config('ANDROID_TOOLCHAIN', android_toolchain)
+
+@depends(target, android_toolchain)
+def android_toolchain_prefix(target, toolchain):
+ if toolchain:
+ if target.cpu == 'x86':
+ # Ideally, the --target should just have the right x86 variant
+ # in the first place.
+ return '%s/bin/i686-linux-android-' % toolchain
+ return '%s/bin/%s-' % (toolchain, target.toolchain)
+
+imply_option('--with-toolchain-prefix', android_toolchain_prefix,
+ reason='--with-android-ndk')
diff --git a/build/moz.configure/checks.configure b/build/moz.configure/checks.configure
new file mode 100644
index 000000000..8c2dbc0cc
--- /dev/null
+++ b/build/moz.configure/checks.configure
@@ -0,0 +1,144 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Templates implementing some generic checks.
+# ==============================================================
+
+# Declare some exceptions. This is cumbersome, but since we shouldn't need a
+# lot of them, let's stack them all here. When adding a new one, put it in the
+# _declare_exceptions template, and add it to the return statement. Then
+# destructure in the assignment below the function declaration.
+@template
+@imports(_from='__builtin__', _import='Exception')
+def _declare_exceptions():
+ class FatalCheckError(Exception):
+ '''An exception to throw from a function decorated with @checking.
+ It will result in calling die() with the given message.
+ Debugging messages emitted from the decorated function will also be
+ printed out.'''
+ return (FatalCheckError,)
+
+(FatalCheckError,) = _declare_exceptions()
+
+del _declare_exceptions
+
+# Helper to display "checking" messages
+# @checking('for foo')
+# def foo():
+# return 'foo'
+# is equivalent to:
+# def foo():
+# log.info('checking for foo... ')
+# ret = foo
+# log.info(ret)
+# return ret
+# This can be combined with e.g. @depends:
+# @depends(some_option)
+# @checking('for something')
+# def check(value):
+# ...
+# An optional callback can be given, that will be used to format the returned
+# value when displaying it.
+@template
+def checking(what, callback=None):
+ def decorator(func):
+ def wrapped(*args, **kwargs):
+ log.info('checking %s... ', what)
+ with log.queue_debug():
+ error, ret = None, None
+ try:
+ ret = func(*args, **kwargs)
+ except FatalCheckError as e:
+ error = e.message
+ display_ret = callback(ret) if callback else ret
+ if display_ret is True:
+ log.info('yes')
+ elif display_ret is False or display_ret is None:
+ log.info('no')
+ else:
+ log.info(display_ret)
+ if error is not None:
+ die(error)
+ return ret
+ return wrapped
+ return decorator
+
+
+# Template to check for programs in $PATH.
+# - `var` is the name of the variable that will be set with `set_config` when
+# the program is found.
+# - `progs` is a list (or tuple) of program names that will be searched for.
+# It can also be a reference to a @depends function that returns such a
+# list. If the list is empty and there is no input, the check is skipped.
+# - `what` is a human readable description of what is being looked for. It
+# defaults to the lowercase version of `var`.
+# - `input` is a string reference to an existing option or a reference to a
+# @depends function resolving to explicit input for the program check.
+# The default is to create an option for the environment variable `var`.
+# This argument allows to use a different kind of option (possibly using a
+# configure flag), or doing some pre-processing with a @depends function.
+# - `allow_missing` indicates whether not finding the program is an error.
+# - `paths` is a list of paths or @depends function returning a list of paths
+# that will cause the given path(s) to be searched rather than $PATH. Input
+# paths may either be individual paths or delimited by os.pathsep, to allow
+# passing $PATH (for example) as an element.
+#
+# The simplest form is:
+# check_prog('PROG', ('a', 'b'))
+# This will look for 'a' or 'b' in $PATH, and set_config PROG to the one
+# it can find. If PROG is already set from the environment or command line,
+# use that value instead.
+@template
+@imports(_from='mozbuild.shellutil', _import='quote')
+def check_prog(var, progs, what=None, input=None, allow_missing=False,
+ paths=None):
+ if input:
+ # Wrap input with type checking and normalization.
+ @depends(input)
+ def input(value):
+ if not value:
+ return
+ if isinstance(value, str):
+ return (value,)
+ if isinstance(value, (tuple, list)) and len(value) == 1:
+ return value
+ configure_error('input must resolve to a tuple or a list with a '
+ 'single element, or a string')
+ else:
+ option(env=var, nargs=1,
+ help='Path to %s' % (what or 'the %s program' % var.lower()))
+ input = var
+ what = what or var.lower()
+
+ # Trick to make a @depends function out of an immediate value.
+ progs = dependable(progs)
+ paths = dependable(paths)
+
+ @depends_if(input, progs, paths)
+ @checking('for %s' % what, lambda x: quote(x) if x else 'not found')
+ def check(value, progs, paths):
+ if progs is None:
+ progs = ()
+
+ if not isinstance(progs, (tuple, list)):
+ configure_error('progs must resolve to a list or tuple!')
+
+ for prog in value or progs:
+ log.debug('%s: Trying %s', var.lower(), quote(prog))
+ result = find_program(prog, paths)
+ if result:
+ return result
+
+ if not allow_missing or value:
+ raise FatalCheckError('Cannot find %s' % what)
+
+ @depends_if(check, progs)
+ def normalized_for_config(value, progs):
+ return ':' if value is None else value
+
+ set_config(var, normalized_for_config)
+
+ return check
diff --git a/build/moz.configure/compile-checks.configure b/build/moz.configure/compile-checks.configure
new file mode 100644
index 000000000..9f0ebcd61
--- /dev/null
+++ b/build/moz.configure/compile-checks.configure
@@ -0,0 +1,152 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+# Generates a test program and attempts to compile it. In case of failure, the
+# resulting check will return None. If the test program succeeds, it will return
+# the output of the test program.
+# - `includes` are the includes (as file names) that will appear at the top of
+# the generated test program.
+# - `body` is the code that will appear in the main function of the generated
+# test program. `return 0;` is appended to the function body automatically.
+# - `language` is the language selection, so that the appropriate compiler is
+# used.
+# - `flags` are the flags to be passed to the compiler, in addition to `-c`.
+# - `check_msg` is the message to be printed to accompany compiling the test
+# program.
+@template
+def try_compile(includes=None, body='', language='C++', flags=None, check_msg=None,
+ when=None):
+ compiler = {
+ 'C': c_compiler,
+ 'C++': cxx_compiler,
+ }[language]
+
+ return compiler.try_compile(includes, body, flags, check_msg, when=when)
+
+
+# Checks for the presence of the given header on the target system by compiling
+# a test program including that header. The return value of the template is a
+# check function returning True if the header is present, and None if it is not.
+# The value of this check function is also used to set a variable (with set_define)
+# corresponding to the checked header. For instance, HAVE_MALLOC_H will be set in
+# defines if check_header if called with 'malloc.h' as input and malloc.h is
+# present on the target.
+# - `header` is the header, as a file name, to check for.
+# - `language` is the language selection, so that the appropriate compiler is
+# used.
+# - `flags` are the flags to be passed to the compiler, in addition to `-c`.
+# - `includes` are additional includes, as file names, to appear before the
+# header checked for.
+# - `when` is a depends function that if present will make performing the check
+# conditional on the value of that function.
+@template
+def check_header(header, language='C++', flags=None, includes=None, when=None):
+ when = when or always
+
+ if includes:
+ includes = includes[:]
+ else:
+ includes = []
+ includes.append(header)
+
+ have_header = try_compile(includes=includes, language=language, flags=flags,
+ check_msg='for %s' % header, when=when)
+ header_var = 'HAVE_%s' % (header.upper()
+ .replace('-', '_')
+ .replace('/', '_')
+ .replace('.', '_'))
+ set_define(header_var, have_header)
+ return have_header
+
+# A convenience wrapper for check_header for checking multiple headers.
+# returns an array of the resulting checks in order corresponding to the
+# provided headers.
+# - `headers` are the headers to be checked.
+# - `kwargs` are keyword arguments passed verbatim to check_header.
+@template
+def check_headers(*headers, **kwargs):
+ checks = []
+ for header in headers:
+ checks.append(check_header(header, **kwargs))
+ return checks
+
+
+@depends(c_compiler)
+def warnings_cflags(c_compiler):
+ return []
+
+@depends(cxx_compiler)
+def warnings_cxxflags(cxx_compiler):
+ return []
+
+
+# Tests whether GCC or clang support the given warning flag, and if it is,
+# add it to the list of warning flags for the build.
+# - `warning` is the warning flag (e.g. -Wfoo)
+# - `compiler` (optional) is the compiler to test against (c_compiler or
+# cxx_compiler, from toolchain.configure). When omitted, both compilers
+# are tested.
+# - `when` (optional) is a @depends function or option name conditioning
+# when the warning flag is wanted.
+# - `check`, when not set, skips checking whether the flag is supported and
+# adds it to the list of warning flags unconditionally. This is only meant
+# for add_gcc_warning().
+@template
+def check_and_add_gcc_warning(warning, compiler=None, when=None, check=True):
+ if compiler:
+ compilers = (compiler,)
+ else:
+ compilers = (c_compiler, cxx_compiler)
+
+ when = when or always
+
+ for c in compilers:
+ assert c in (c_compiler, cxx_compiler)
+ lang, warnings_flags = {
+ c_compiler: ('C', warnings_cflags),
+ cxx_compiler: ('C++', warnings_cxxflags),
+ }[c]
+
+ # GCC and clang will fail if given an unknown warning option like
+ # -Wfoobar. But later versions won't fail if given an unknown negated
+ # warning option like -Wno-foobar. So when we are checking for support
+ # of a negated warning option, we actually test the positive form, but
+ # add the negated form to the flags variable.
+ if (warning.startswith('-Wno-') and
+ not warning.startswith('-Wno-error=')):
+ flags = ['-Werror', '-W' + warning[5:]]
+ elif warning.startswith('-Werror='):
+ flags = [warning]
+ else:
+ flags = ['-Werror', warning]
+
+ @depends(c, when)
+ def result(c, when):
+ if when and c.type in ('clang', 'gcc'):
+ return True
+
+ if check:
+ result = c.try_compile(
+ flags=flags, when=result,
+ check_msg='whether the %s compiler supports %s' % (lang,
+ warning))
+
+ @depends(result, warnings_flags)
+ def maybe_add_flag(result, warnings_flags):
+ if result:
+ warnings_flags.append(warning)
+
+# Add the given warning to the list of warning flags for the build.
+# - `warning` is the warning flag (e.g. -Wfoo)
+# - `compiler` (optional) is the compiler to add the flag for (c_compiler or
+# cxx_compiler, from toolchain.configure). When omitted, the warning flag
+# is added for both compilers.
+# - `when` (optional) is a @depends function or option name conditioning
+# when the warning flag is wanted.
+@template
+def add_gcc_warning(warning, compiler=None, when=None):
+ check_and_add_gcc_warning(warning, compiler, when, check=False)
diff --git a/build/moz.configure/compilers-util.configure b/build/moz.configure/compilers-util.configure
new file mode 100644
index 000000000..32271a010
--- /dev/null
+++ b/build/moz.configure/compilers-util.configure
@@ -0,0 +1,62 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+@template
+@imports('textwrap')
+@imports(_from='mozbuild.configure', _import='SandboxDependsFunction')
+def compiler_class(compiler):
+ class Compiler(SandboxDependsFunction):
+ # Generates a test program and attempts to compile it. In case of
+ # failure, the resulting check will return None. If the test program
+ # succeeds, it will return the output of the test program.
+ # - `includes` are the includes (as file names) that will appear at the
+ # top of the generated test program.
+ # - `body` is the code that will appear in the main function of the
+ # generated test program. `return 0;` is appended to the function
+ # body automatically.
+ # - `flags` are the flags to be passed to the compiler, in addition to
+ # `-c`.
+ # - `check_msg` is the message to be printed to accompany compiling the
+ # test program.
+ def try_compile(self, includes=None, body='', flags=None,
+ check_msg=None, when=None, onerror=lambda: None):
+ includes = includes or []
+ source_lines = ['#include <%s>' % f for f in includes]
+ source = '\n'.join(source_lines) + '\n'
+ source += textwrap.dedent('''\
+ int
+ main(void)
+ {
+ %s
+ ;
+ return 0;
+ }
+ ''' % body)
+
+ if check_msg:
+ def checking_fn(fn):
+ return checking(check_msg)(fn)
+ else:
+ def checking_fn(fn):
+ return fn
+
+ @depends_when(self, dependable(flags), extra_toolchain_flags, when=when)
+ @checking_fn
+ def func(compiler, flags, extra_flags):
+ flags = flags or []
+ flags += extra_flags or []
+ flags.append('-c')
+
+ if try_invoke_compiler(
+ compiler.wrapper + [compiler.compiler] + compiler.flags,
+ compiler.language, source, flags,
+ onerror=onerror) is not None:
+ return True
+
+ return func
+
+ compiler.__class__ = Compiler
+ return compiler
diff --git a/build/moz.configure/headers.configure b/build/moz.configure/headers.configure
new file mode 100644
index 000000000..52ffa2f89
--- /dev/null
+++ b/build/moz.configure/headers.configure
@@ -0,0 +1,93 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Check for headers defining standard int types.
+check_header('stdint.h')
+have_inttypes = check_header('inttypes.h')
+
+# Assume we have ansi C header files available.
+set_define('STDC_HEADERS', True)
+
+set_config('HAVE_INTTYPES_H', have_inttypes)
+
+building_linux = depends(target)(lambda target: target.kernel == 'Linux')
+
+have_malloc = check_header('malloc.h')
+
+check_header('alloca.h')
+
+add_old_configure_assignment('HAVE_MALLOC_H', have_malloc)
+
+check_headers(
+ 'sys/byteorder.h',
+ 'getopt.h',
+ 'unistd.h',
+ 'nl_types.h',
+ 'cpuid.h',
+ when=non_msvc_compiler,
+)
+
+# These are all the places some variant of statfs can be hiding.
+check_headers(
+ 'sys/statvfs.h',
+ 'sys/statfs.h',
+ 'sys/vfs.h',
+ 'sys/mount.h',
+ when=non_msvc_compiler,
+)
+
+# Quota support
+check_header('sys/quota.h',
+ when=non_msvc_compiler)
+check_header('linux/quota.h',
+ includes=['sys/socket.h'],
+ when=building_linux)
+
+# SCTP support - needs various network include headers
+check_headers(
+ 'linux/if_addr.h',
+ 'linux/rtnetlink.h',
+ includes=['sys/socket.h'],
+ when=building_linux,
+)
+
+check_header('sys/queue.h',
+ when=non_msvc_compiler)
+
+check_headers(
+ 'sys/types.h',
+ 'netinet/in.h',
+ 'byteswap.h',
+ when=non_msvc_compiler,
+)
+
+# TODO: Move these checks to file specific to --enable-project=js.
+have_perf_event_h = check_header('linux/perf_event.h',
+ when=building_linux)
+
+js_option('--with-linux-headers',
+ help='location where the Linux kernel headers can be found',
+ nargs=1)
+
+passed_linux_header_flags = depends_if('--with-linux-headers')(lambda v: ['-I%s' % v[0]])
+
+@depends_when(try_compile(includes=['asm/unistd.h'],
+ body='return sizeof(__NR_perf_event_open);',
+ flags=passed_linux_header_flags,
+ check_msg='for perf_event_open system call'),
+ when=have_perf_event_h)
+def have_perf_event_open(have_perf_event_open):
+ if have_perf_event_open:
+ return True
+
+set_config('HAVE_LINUX_PERF_EVENT_H', have_perf_event_open)
+
+@depends(passed_linux_header_flags, have_perf_event_open)
+def linux_headers_includes(passed_linux_header_flags, have_perf_event_open):
+ if have_perf_event_open and passed_linux_header_flags:
+ return passed_linux_header_flags[0]
+
+set_config('LINUX_HEADERS_INCLUDES', linux_headers_includes)
diff --git a/build/moz.configure/init.configure b/build/moz.configure/init.configure
new file mode 100644
index 000000000..2123bebc9
--- /dev/null
+++ b/build/moz.configure/init.configure
@@ -0,0 +1,780 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+include('util.configure')
+include('checks.configure')
+
+option(env='DIST', nargs=1, help='DIST directory')
+
+# Do not allow objdir == srcdir builds.
+# ==============================================================
+@depends('--help', 'DIST')
+@imports(_from='os.path', _import='exists')
+def check_build_environment(help, dist):
+ topobjdir = os.path.realpath(os.path.abspath('.'))
+ topsrcdir = os.path.realpath(os.path.abspath(
+ os.path.join(os.path.dirname(__file__), '..', '..')))
+
+ if dist:
+ dist = normsep(dist[0])
+ else:
+ dist = os.path.join(topobjdir, 'dist')
+
+ result = namespace(
+ topsrcdir=topsrcdir,
+ topobjdir=topobjdir,
+ dist=dist,
+ )
+
+ if help:
+ return result
+
+ if topsrcdir == topobjdir:
+ die(' ***\n'
+ ' * Building directly in the main source directory is not allowed.\n'
+ ' *\n'
+ ' * To build, you must run configure from a separate directory\n'
+ ' * (referred to as an object directory).\n'
+ ' *\n'
+ ' * If you are building with a mozconfig, you will need to change your\n'
+ ' * mozconfig to point to a different object directory.\n'
+ ' ***'
+ )
+
+ # Check for a couple representative files in the source tree
+ conflict_files = [
+ '* %s' % f for f in ('Makefile', 'config/autoconf.mk')
+ if exists(os.path.join(topsrcdir, f))
+ ]
+ if conflict_files:
+ die(' ***\n'
+ ' * Your source tree contains these files:\n'
+ ' %s\n'
+ ' * This indicates that you previously built in the source tree.\n'
+ ' * A source tree build can confuse the separate objdir build.\n'
+ ' *\n'
+ ' * To clean up the source tree:\n'
+ ' * 1. cd %s\n'
+ ' * 2. gmake distclean\n'
+ ' ***'
+ % ('\n '.join(conflict_files), topsrcdir)
+ )
+
+ return result
+
+set_config('TOPSRCDIR', delayed_getattr(check_build_environment, 'topsrcdir'))
+set_config('TOPOBJDIR', delayed_getattr(check_build_environment, 'topobjdir'))
+set_config('MOZ_BUILD_ROOT', delayed_getattr(check_build_environment,
+ 'topobjdir'))
+set_config('DIST', delayed_getattr(check_build_environment, 'dist'))
+
+
+option(env='MOZ_AUTOMATION', help='Enable options for automated builds')
+set_config('MOZ_AUTOMATION', depends_if('MOZ_AUTOMATION')(lambda x: True))
+
+
+option(env='OLD_CONFIGURE', nargs=1, help='Path to the old configure script')
+
+option(env='MOZ_CURRENT_PROJECT', nargs=1, help='Current build project')
+option(env='MOZCONFIG', nargs=1, help='Mozconfig location')
+
+# Read user mozconfig
+# ==============================================================
+# Note: the dependency on --help is only there to always read the mozconfig,
+# even when --help is passed. Without this dependency, the function wouldn't
+# be called when --help is passed, and the mozconfig wouldn't be read.
+@depends('MOZ_CURRENT_PROJECT', 'MOZCONFIG', 'OLD_CONFIGURE',
+ check_build_environment, '--help')
+@imports(_from='mozbuild.mozconfig', _import='MozconfigLoader')
+def mozconfig(current_project, mozconfig, old_configure, build_env, help):
+ if not old_configure:
+ die('The OLD_CONFIGURE environment variable must be set')
+
+ # Don't read the mozconfig for the js configure (yay backwards
+ # compatibility)
+ # While the long term goal is that js and top-level use the same configure
+ # and the same overall setup, including the possibility to use mozconfigs,
+ # figuring out what we want to do wrt mozconfig vs. command line and
+ # environment variable is not a clear-cut case, and it's more important to
+ # fix the immediate problem mozconfig causes to js developers by
+ # "temporarily" returning to the previous behavior of not loading the
+ # mozconfig for the js configure.
+ # Separately to the immediate problem for js developers, there is also the
+ # need to not load a mozconfig when running js configure as a subconfigure.
+ # Unfortunately, there is no direct way to tell whether the running
+ # configure is the js configure. The indirect way is to look at the
+ # OLD_CONFIGURE path, which points to js/src/old-configure.
+ # I expect we'll have figured things out for mozconfigs well before
+ # old-configure dies.
+ if os.path.dirname(os.path.abspath(old_configure[0])).endswith('/js/src'):
+ return {'path': None}
+
+ loader = MozconfigLoader(build_env.topsrcdir)
+ current_project = current_project[0] if current_project else None
+ mozconfig = mozconfig[0] if mozconfig else None
+ mozconfig = loader.find_mozconfig(env={'MOZCONFIG': mozconfig})
+ mozconfig = loader.read_mozconfig(mozconfig, moz_build_app=current_project)
+
+ return mozconfig
+
+set_config('MOZCONFIG', depends(mozconfig)(lambda m: m['path']))
+
+
+option(env='PYTHON', nargs=1, help='Python interpreter')
+
+# Setup python virtualenv
+# ==============================================================
+@depends('PYTHON', check_build_environment, mozconfig, '--help')
+@imports('os')
+@imports('sys')
+@imports('subprocess')
+@imports(_from='mozbuild.configure.util', _import='LineIO')
+@imports(_from='mozbuild.virtualenv', _import='VirtualenvManager')
+@imports(_from='mozbuild.virtualenv', _import='verify_python_version')
+@imports('distutils.sysconfig')
+def virtualenv_python(env_python, build_env, mozconfig, help):
+ if help:
+ return
+
+ python = env_python[0] if env_python else None
+
+ # Ideally we'd rely on the mozconfig injection from mozconfig_options,
+ # but we'd rather avoid the verbosity when we need to reexecute with
+ # a different python.
+ if mozconfig['path']:
+ if 'PYTHON' in mozconfig['env']['added']:
+ python = mozconfig['env']['added']['PYTHON']
+ elif 'PYTHON' in mozconfig['env']['modified']:
+ python = mozconfig['env']['modified']['PYTHON'][1]
+ elif 'PYTHON' in mozconfig['vars']['added']:
+ python = mozconfig['vars']['added']['PYTHON']
+ elif 'PYTHON' in mozconfig['vars']['modified']:
+ python = mozconfig['vars']['modified']['PYTHON'][1]
+
+ with LineIO(lambda l: log.error(l)) as out:
+ verify_python_version(out)
+ topsrcdir, topobjdir = build_env.topsrcdir, build_env.topobjdir
+ if topobjdir.endswith('/js/src'):
+ topobjdir = topobjdir[:-7]
+
+ with LineIO(lambda l: log.info(l)) as out:
+ manager = VirtualenvManager(
+ topsrcdir, topobjdir,
+ os.path.join(topobjdir, '_virtualenv'), out,
+ os.path.join(topsrcdir, 'build', 'virtualenv_packages.txt'))
+
+ if python:
+ # If we're not in the virtualenv, we need the which module for
+ # find_program.
+ if normsep(sys.executable) != normsep(manager.python_path):
+ sys.path.append(os.path.join(topsrcdir, 'python', 'which'))
+ found_python = find_program(python)
+ if not found_python:
+ die('The PYTHON environment variable does not contain '
+ 'a valid path. Cannot find %s', python)
+ python = found_python
+ else:
+ python = sys.executable
+
+ if not manager.up_to_date(python):
+ log.info('Creating Python environment')
+ manager.build(python)
+
+ python = normsep(manager.python_path)
+
+ if python != normsep(sys.executable):
+ log.info('Reexecuting in the virtualenv')
+ if env_python:
+ del os.environ['PYTHON']
+ # One would prefer to use os.execl, but that's completely borked on
+ # Windows.
+ sys.exit(subprocess.call([python] + sys.argv))
+
+ # We are now in the virtualenv
+ if not distutils.sysconfig.get_python_lib():
+ die('Could not determine python site packages directory')
+
+ return python
+
+set_config('PYTHON', virtualenv_python)
+add_old_configure_assignment('PYTHON', virtualenv_python)
+
+# Inject mozconfig options
+# ==============================================================
+# All options defined above this point can't be injected in mozconfig_options
+# below, so collect them.
+@template
+def early_options():
+ @dependable
+ @imports('__sandbox__')
+ def early_options():
+ return set(
+ option.env
+ for option in __sandbox__._options.itervalues()
+ if option.env
+ )
+ return early_options
+
+early_options = early_options()
+
+@depends(mozconfig, '--help')
+# This gives access to the sandbox. Don't copy this blindly.
+@imports('__sandbox__')
+@imports('os')
+def mozconfig_options(mozconfig, help):
+ if mozconfig['path']:
+ helper = __sandbox__._helper
+ log.info('Adding configure options from %s' % mozconfig['path'])
+ for arg in mozconfig['configure_args']:
+ log.info(' %s' % arg)
+ # We could be using imply_option() here, but it has other
+ # contraints that don't really apply to the command-line
+ # emulation that mozconfig provides.
+ helper.add(arg, origin='mozconfig', args=helper._args)
+
+ def add(key, value):
+ if key.isupper():
+ arg = '%s=%s' % (key, value)
+ log.info(' %s' % arg)
+ helper.add(arg, origin='mozconfig', args=helper._args)
+
+ for key, value in mozconfig['env']['added'].iteritems():
+ add(key, value)
+ os.environ[key] = value
+ for key, (_, value) in mozconfig['env']['modified'].iteritems():
+ add(key, value)
+ os.environ[key] = value
+ for key, value in mozconfig['vars']['added'].iteritems():
+ # mozconfig_loader adds _IS_SET variables that are irrelevant
+ if not key.endswith('_IS_SET'):
+ add(key, value)
+ for key, (_, value) in mozconfig['vars']['modified'].iteritems():
+ add(key, value)
+
+
+# Mozilla-Build
+# ==============================================================
+option(env='MOZILLABUILD', nargs=1,
+ help='Path to Mozilla Build (Windows-only)')
+
+option(env='CONFIG_SHELL', nargs=1, help='Path to a POSIX shell')
+
+# It feels dirty replicating this from python/mozbuild/mozbuild/mozconfig.py,
+# but the end goal being that the configure script would go away...
+@depends('CONFIG_SHELL', 'MOZILLABUILD')
+@checking('for a shell')
+@imports('sys')
+def shell(value, mozillabuild):
+ if value:
+ return find_program(value[0])
+ shell = 'sh'
+ if mozillabuild:
+ shell = mozillabuild[0] + '/msys/bin/sh'
+ if sys.platform == 'win32':
+ shell = shell + '.exe'
+ return find_program(shell)
+
+
+# Host and target systems
+# ==============================================================
+option('--host', nargs=1, help='Define the system type performing the build')
+
+option('--target', nargs=1,
+ help='Define the system type where the resulting executables will be '
+ 'used')
+
+@imports(_from='mozbuild.configure.constants', _import='CPU')
+@imports(_from='mozbuild.configure.constants', _import='CPU_bitness')
+@imports(_from='mozbuild.configure.constants', _import='Endianness')
+@imports(_from='mozbuild.configure.constants', _import='Kernel')
+@imports(_from='mozbuild.configure.constants', _import='OS')
+def split_triplet(triplet):
+ # The standard triplet is defined as
+ # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+ # There is also a quartet form:
+ # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+ # But we can consider the "KERNEL-OPERATING_SYSTEM" as one.
+ cpu, manufacturer, os = triplet.split('-', 2)
+
+ # Autoconf uses config.sub to validate and canonicalize those triplets,
+ # but the granularity of its results has never been satisfying to our
+ # use, so we've had our own, different, canonicalization. We've also
+ # historically not been very consistent with how we use the canonicalized
+ # values. Hopefully, this will help us make things better.
+ # The tests are inherited from our decades-old autoconf-based configure,
+ # which can probably be improved/cleaned up because they are based on a
+ # mix of uname and config.guess output, while we now only use the latter,
+ # which presumably has a cleaner and leaner output. Let's refine later.
+ os = os.replace('/', '_')
+ if 'android' in os:
+ canonical_os = 'Android'
+ canonical_kernel = 'Linux'
+ elif os.startswith('linux'):
+ canonical_os = 'GNU'
+ canonical_kernel = 'Linux'
+ elif os.startswith('kfreebsd') and os.endswith('-gnu'):
+ canonical_os = 'GNU'
+ canonical_kernel = 'kFreeBSD'
+ elif os.startswith('gnu'):
+ canonical_os = canonical_kernel = 'GNU'
+ elif os.startswith('mingw'):
+ canonical_os = canonical_kernel = 'WINNT'
+ elif os.startswith('darwin'):
+ canonical_kernel = 'Darwin'
+ canonical_os = 'OSX'
+ elif os.startswith('ios'):
+ canonical_kernel = 'Darwin'
+ canonical_os = 'iOS'
+ elif os.startswith('dragonfly'):
+ canonical_os = canonical_kernel = 'DragonFly'
+ elif os.startswith('freebsd'):
+ canonical_os = canonical_kernel = 'FreeBSD'
+ elif os.startswith('netbsd'):
+ canonical_os = canonical_kernel = 'NetBSD'
+ elif os.startswith('openbsd'):
+ canonical_os = canonical_kernel = 'OpenBSD'
+ else:
+ die('Unknown OS: %s' % os)
+
+ # The CPU granularity is probably not enough. Moving more things from
+ # old-configure will tell us if we need more
+ if cpu.endswith('86') or (cpu.startswith('i') and '86' in cpu):
+ canonical_cpu = 'x86'
+ endianness = 'little'
+ elif cpu in ('x86_64', 'ia64'):
+ canonical_cpu = cpu
+ endianness = 'little'
+ elif cpu in ('s390', 's390x'):
+ canonical_cpu = cpu
+ endianness = 'big'
+ elif cpu in ('powerpc64', 'ppc64', 'powerpc64le', 'ppc64le'):
+ canonical_cpu = 'ppc64'
+ endianness = 'little' if 'le' in cpu else 'big'
+ elif cpu in ('powerpc', 'ppc', 'rs6000') or cpu.startswith('powerpc'):
+ canonical_cpu = 'ppc'
+ endianness = 'big'
+ elif cpu in ('Alpha', 'alpha', 'ALPHA'):
+ canonical_cpu = 'Alpha'
+ endianness = 'little'
+ elif cpu.startswith('hppa') or cpu == 'parisc':
+ canonical_cpu = 'hppa'
+ endianness = 'big'
+ elif cpu.startswith('sparc64'):
+ canonical_cpu = 'sparc64'
+ endianness = 'big'
+ elif cpu.startswith('sparc') or cpu == 'sun4u':
+ canonical_cpu = 'sparc'
+ endianness = 'big'
+ elif cpu.startswith('arm'):
+ canonical_cpu = 'arm'
+ endianness = 'big' if cpu.startswith(('armeb', 'armbe')) else 'little'
+ elif cpu in ('mips', 'mipsel'):
+ canonical_cpu = 'mips32'
+ endianness = 'little' if 'el' in cpu else 'big'
+ elif cpu in ('mips64', 'mips64el'):
+ canonical_cpu = 'mips64'
+ endianness = 'little' if 'el' in cpu else 'big'
+ elif cpu.startswith('aarch64'):
+ canonical_cpu = 'aarch64'
+ endianness = 'little'
+ else:
+ die('Unknown CPU type: %s' % cpu)
+
+ return namespace(
+ alias=triplet,
+ cpu=CPU(canonical_cpu),
+ bitness=CPU_bitness[canonical_cpu],
+ kernel=Kernel(canonical_kernel),
+ os=OS(canonical_os),
+ endianness=Endianness(endianness),
+ raw_cpu=cpu,
+ raw_os=os,
+ # Toolchains, most notably for cross compilation may use cpu-os
+ # prefixes.
+ toolchain='%s-%s' % (cpu, os),
+ )
+
+
+@imports('subprocess')
+def config_sub(shell, triplet):
+ config_sub = os.path.join(os.path.dirname(__file__), '..',
+ 'autoconf', 'config.sub')
+ return subprocess.check_output([shell, config_sub, triplet]).strip()
+
+
+@depends('--host', shell)
+@checking('for host system type', lambda h: h.alias)
+@imports('subprocess')
+def host(value, shell):
+ if not value:
+ config_guess = os.path.join(os.path.dirname(__file__), '..',
+ 'autoconf', 'config.guess')
+ host = subprocess.check_output([shell, config_guess]).strip()
+ else:
+ host = value[0]
+
+ return split_triplet(config_sub(shell, host))
+
+
+@depends('--target', host, shell)
+@checking('for target system type', lambda t: t.alias)
+def target(value, host, shell):
+ if not value:
+ return host
+ return split_triplet(config_sub(shell, value[0]))
+
+
+@depends(host, target)
+@checking('whether cross compiling')
+def cross_compiling(host, target):
+ return host != target
+
+set_config('CROSS_COMPILE', cross_compiling)
+set_define('CROSS_COMPILE', cross_compiling)
+add_old_configure_assignment('CROSS_COMPILE', cross_compiling)
+
+
+@depends(target)
+def have_64_bit(target):
+ if target.bitness == 64:
+ return True
+
+set_config('HAVE_64BIT_BUILD', have_64_bit)
+set_define('HAVE_64BIT_BUILD', have_64_bit)
+add_old_configure_assignment('HAVE_64BIT_BUILD', have_64_bit)
+
+
+# Autoconf needs these set
+@depends(host)
+def host_for_old_configure(host):
+ return '--host=%s' % host.alias
+
+add_old_configure_arg(host_for_old_configure)
+
+@depends(host, target)
+def target_for_old_configure(host, target):
+ target_alias = target.alias
+ # old-configure does plenty of tests against $target and $target_os
+ # and expects darwin for iOS, so make it happy.
+ if target.os == 'iOS':
+ target_alias = target_alias.replace('-ios', '-darwin')
+ return '--target=%s' % target_alias
+
+add_old_configure_arg(target_for_old_configure)
+
+
+# These variables are for compatibility with the current moz.builds and
+# old-configure. Eventually, we'll want to canonicalize better.
+@depends(target)
+def target_variables(target):
+ if target.kernel == 'kFreeBSD':
+ os_target = 'GNU/kFreeBSD'
+ os_arch = 'GNU_kFreeBSD'
+ elif target.kernel == 'Darwin' or (target.kernel == 'Linux' and
+ target.os == 'GNU'):
+ os_target = target.kernel
+ os_arch = target.kernel
+ else:
+ os_target = target.os
+ os_arch = target.kernel
+
+ if target.kernel == 'Darwin' and target.cpu == 'x86':
+ os_test = 'i386'
+ else:
+ os_test = target.raw_cpu
+
+ return namespace(
+ OS_TARGET=os_target,
+ OS_ARCH=os_arch,
+ OS_TEST=os_test,
+ INTEL_ARCHITECTURE=target.cpu in ('x86', 'x86_64') or None,
+ )
+
+set_config('OS_TARGET', delayed_getattr(target_variables, 'OS_TARGET'))
+add_old_configure_assignment('OS_TARGET',
+ delayed_getattr(target_variables, 'OS_TARGET'))
+set_config('OS_ARCH', delayed_getattr(target_variables, 'OS_ARCH'))
+add_old_configure_assignment('OS_ARCH',
+ delayed_getattr(target_variables, 'OS_ARCH'))
+set_config('OS_TEST', delayed_getattr(target_variables, 'OS_TEST'))
+add_old_configure_assignment('OS_TEST',
+ delayed_getattr(target_variables, 'OS_TEST'))
+set_config('CPU_ARCH', delayed_getattr(target, 'cpu'))
+add_old_configure_assignment('CPU_ARCH', delayed_getattr(target, 'cpu'))
+set_config('INTEL_ARCHITECTURE', delayed_getattr(target_variables,
+ 'INTEL_ARCHITECTURE'))
+set_config('TARGET_CPU', delayed_getattr(target, 'raw_cpu'))
+set_config('TARGET_OS', delayed_getattr(target, 'raw_os'))
+
+
+@depends(host)
+def host_variables(host):
+ if host.kernel == 'kFreeBSD':
+ os_arch = 'GNU_kFreeBSD'
+ else:
+ os_arch = host.kernel
+ return namespace(
+ HOST_OS_ARCH=os_arch,
+ )
+
+set_config('HOST_OS_ARCH', delayed_getattr(host_variables, 'HOST_OS_ARCH'))
+add_old_configure_assignment('HOST_OS_ARCH',
+ delayed_getattr(host_variables, 'HOST_OS_ARCH'))
+
+@depends(target)
+def target_is_windows(target):
+ if target.kernel == 'WINNT':
+ return True
+
+set_define('_WINDOWS', target_is_windows)
+set_define('WIN32', target_is_windows)
+set_define('XP_WIN', target_is_windows)
+set_define('XP_WIN32', target_is_windows)
+
+@depends(target)
+def target_is_unix(target):
+ if target.kernel != 'WINNT':
+ return True
+
+set_define('XP_UNIX', target_is_unix)
+
+@depends(target)
+def target_is_darwin(target):
+ if target.kernel == 'Darwin':
+ return True
+
+set_define('XP_DARWIN', target_is_darwin)
+
+@depends(target)
+def target_is_ios(target):
+ if target.kernel == 'Darwin' and target.os == 'iOS':
+ return True
+
+set_define('XP_IOS', target_is_ios)
+
+@depends(target)
+def target_is_osx(target):
+ if target.kernel == 'Darwin' and target.os == 'OSX':
+ return True
+
+set_define('XP_MACOSX', target_is_osx)
+
+@depends(target)
+def target_is_linux(target):
+ if target.kernel == 'Linux':
+ return True
+
+set_define('XP_LINUX', target_is_linux)
+
+# The application/project to build
+# ==============================================================
+option('--enable-application', nargs=1, env='MOZ_BUILD_APP',
+ help='Application to build. Same as --enable-project.')
+
+@depends('--enable-application', '--help')
+def application(app, help):
+ if app:
+ return app
+
+imply_option('--enable-project', application)
+
+
+@depends(check_build_environment, '--help')
+def default_project(build_env, help):
+ if build_env.topobjdir.endswith('/js/src'):
+ return 'js'
+ return 'browser'
+
+option('--enable-project', nargs=1, default=default_project,
+ help='Project to build')
+
+option('--with-external-source-dir', env='EXTERNAL_SOURCE_DIR', nargs=1,
+ help='External directory containing additional build files')
+
+@depends('--enable-project', '--with-external-source-dir',
+ check_build_environment, '--help')
+@imports(_from='os.path', _import='exists')
+def include_project_configure(project, external_source_dir, build_env, help):
+ if not project:
+ die('--enable-project is required.')
+
+ base_dir = build_env.topsrcdir
+ if external_source_dir:
+ base_dir = os.path.join(base_dir, external_source_dir[0])
+
+ path = os.path.join(base_dir, project[0], 'moz.configure')
+ if not exists(path):
+ die('Cannot find project %s', project[0])
+ return path
+
+@depends('--with-external-source-dir')
+def external_source_dir(value):
+ if value:
+ return value[0]
+
+set_config('EXTERNAL_SOURCE_DIR', external_source_dir)
+add_old_configure_assignment('EXTERNAL_SOURCE_DIR', external_source_dir)
+
+
+@depends(include_project_configure, check_build_environment, '--help')
+def build_project(include_project_configure, build_env, help):
+ ret = os.path.dirname(os.path.relpath(include_project_configure,
+ build_env.topsrcdir))
+ return ret
+
+set_config('MOZ_BUILD_APP', build_project)
+set_define('MOZ_BUILD_APP', build_project)
+add_old_configure_assignment('MOZ_BUILD_APP', build_project)
+
+
+# set RELEASE_OR_BETA and NIGHTLY_BUILD variables depending on the cycle we're in
+# The logic works like this:
+# - if we have "a1" in GRE_MILESTONE, we're building Nightly (define NIGHTLY_BUILD)
+# - otherwise, if we have "a" in GRE_MILESTONE, we're building Nightly or Aurora
+# - otherwise, we're building Release/Beta (define RELEASE_OR_BETA)
+@depends(check_build_environment, '--help')
+@imports(_from='__builtin__', _import='open')
+def milestone(build_env, _):
+ milestone_path = os.path.join(build_env.topsrcdir,
+ 'config',
+ 'milestone.txt')
+ with open(milestone_path, 'r') as fh:
+ milestone = fh.read().splitlines()[-1]
+
+ is_nightly = is_release_or_beta = None
+
+ if 'a1' in milestone:
+ is_nightly = True
+ elif 'a' not in milestone:
+ is_release_or_beta = True
+
+ return namespace(version=milestone,
+ is_nightly=is_nightly,
+ is_release_or_beta=is_release_or_beta)
+
+set_config('GRE_MILESTONE', delayed_getattr(milestone, 'version'))
+set_config('NIGHTLY_BUILD', delayed_getattr(milestone, 'is_nightly'))
+set_define('NIGHTLY_BUILD', delayed_getattr(milestone, 'is_nightly'))
+add_old_configure_assignment('NIGHTLY_BUILD',
+ delayed_getattr(milestone, 'is_nightly'))
+set_config('RELEASE_OR_BETA', delayed_getattr(milestone, 'is_release_or_beta'))
+set_define('RELEASE_OR_BETA', delayed_getattr(milestone, 'is_release_or_beta'))
+add_old_configure_assignment('RELEASE_OR_BETA',
+ delayed_getattr(milestone, 'is_release_or_beta'))
+
+# The app update channel is 'default' when not supplied. The value is used in
+# the application's confvars.sh (and is made available to a project specific
+# moz.configure).
+option('--enable-update-channel',
+ nargs=1,
+ help='Select application update channel',
+ default='default')
+
+@depends('--enable-update-channel')
+def update_channel(channel):
+ if channel[0] == '':
+ return 'default'
+ return channel[0].lower()
+
+set_config('MOZ_UPDATE_CHANNEL', update_channel)
+set_define('MOZ_UPDATE_CHANNEL', update_channel)
+add_old_configure_assignment('MOZ_UPDATE_CHANNEL', update_channel)
+
+
+# A template providing a shorthand for setting a variable. The created
+# option will only be settable with imply_option.
+# It is expected that a project-specific moz.configure will call imply_option
+# to set a value other than the default.
+# If required, the set_as_define and set_for_old_configure arguments
+# will additionally cause the variable to be set using set_define and
+# add_old_configure_assignment. util.configure would be an appropriate place for
+# this, but it uses add_old_configure_assignment, which is defined in this file.
+@template
+def project_flag(env=None, set_for_old_configure=False,
+ set_as_define=False, **kwargs):
+
+ if not env:
+ configure_error("A project_flag must be passed a variable name to set.")
+
+ opt = option(env=env, possible_origins=('implied',), **kwargs)
+
+ @depends(opt.option)
+ def option_implementation(value):
+ if value:
+ if len(value):
+ return value
+ return bool(value)
+
+ set_config(env, option_implementation)
+ if set_as_define:
+ set_define(env, option_implementation)
+ if set_for_old_configure:
+ add_old_configure_assignment(env, option_implementation)
+
+# milestone.is_nightly corresponds to cases NIGHTLY_BUILD is set.
+@depends(milestone, '--help')
+def enabled_in_nightly(milestone, _):
+ return milestone.is_nightly
+
+# Set the MOZ_CONFIGURE_OPTIONS variable with all the options that
+# were passed somehow (environment, command line, mozconfig)
+@depends(mozconfig_options)
+@imports(_from='mozbuild.shellutil', _import='quote')
+@imports('__sandbox__')
+def all_configure_options(_):
+ result = []
+ previous = None
+ for option in __sandbox__._options.itervalues():
+ # __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(__sandbox__._raw_options[option])
+ # 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(__sandbox__._raw_options[option])
+
+ return quote(*result)
+
+set_config('MOZ_CONFIGURE_OPTIONS', all_configure_options)
+
+
+# This is temporary until js/src/configure and configure are merged.
+# Use instead of option() in js/moz.configure and more generally, for
+# options that are shared between configure and js/src/configure.
+@template
+def js_option(*args, **kwargs):
+ opt = option(*args, **kwargs)
+
+ @depends(opt.option, build_project)
+ def js_option(value, build_project):
+ if build_project != 'js':
+ return value.format(opt.option)
+
+ add_old_configure_arg(js_option)
+
+
+# Bug 1278542: This function is a workaround to resolve
+# |android_ndk_include|'s dependency on 'gonkdir.' The
+# actual implementation is located in b2g/moz.configure.
+# Remove this function as soon as 'android_ndk_include'
+# depends on 'target.'
+@depends('--help')
+def gonkdir(_):
+ return None
diff --git a/build/moz.configure/java.configure b/build/moz.configure/java.configure
new file mode 100644
index 000000000..459bd44cf
--- /dev/null
+++ b/build/moz.configure/java.configure
@@ -0,0 +1,62 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+# Java detection
+# ========================================================
+option('--with-java-bin-path', nargs=1,
+ help='Location of Java binaries (java, javac, jar)')
+
+@depends('--with-java-bin-path')
+@imports(_from='os', _import='environ')
+def java_search_paths(path):
+ if path:
+ # Look for javac and jar in the specified path.
+ return path
+ # With no path specified, look for javac and jar in $JAVA_HOME (if set)
+ # and $PATH.
+ if 'JAVA_HOME' in environ:
+ return [os.path.join(environ['JAVA_HOME'], 'bin'),
+ environ.get('PATH', '')]
+ return [environ.get('PATH')]
+
+# Finds the given java tool, failing with a custom error message if we can't
+# find it.
+@template
+def check_java_tool(tool):
+ check = check_prog(tool.upper(), (tool,), paths=java_search_paths,
+ allow_missing=True)
+
+ @depends(check)
+ def require_tool(result):
+ if result is None:
+ die("The program %s was not found. Set $JAVA_HOME to your Java "
+ "SDK directory or use '--with-java-bin-path={java-bin-dir}'"
+ % tool)
+ return result
+
+ return require_tool
+
+check_java_tool('java')
+check_java_tool('javah')
+check_java_tool('jar')
+check_java_tool('jarsigner')
+check_java_tool('keytool')
+javac = check_java_tool('javac')
+
+@depends(javac)
+@checking('for javac version')
+@imports('subprocess')
+def javac_version(javac):
+ try:
+ output = subprocess.check_output([javac, '-version'],
+ stderr=subprocess.STDOUT).rstrip()
+ version = Version(output.split(' ')[-1])
+ if version < '1.7':
+ die('javac 1.7 or higher is required (found %s)' % version)
+ return version
+ except subprocess.CalledProcessError as e:
+ die('Failed to get javac version: %s', e.output)
diff --git a/build/moz.configure/keyfiles.configure b/build/moz.configure/keyfiles.configure
new file mode 100644
index 000000000..5a71fd4b2
--- /dev/null
+++ b/build/moz.configure/keyfiles.configure
@@ -0,0 +1,68 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+@template
+def keyfile(desc, help=None, callback=lambda x: x):
+ help = help or ('Use the secret key contained in the given keyfile '
+ 'for %s requests' % desc)
+ name = desc.lower().replace(' ', '-')
+ no_key = callback('no-%s-key' % name)
+
+ option('--with-%s-keyfile' % name, nargs=1, help=help)
+
+ @depends('--with-%s-keyfile' % name)
+ @checking('for the %s key' % desc, lambda x: x and x is not no_key)
+ @imports(_from='__builtin__', _import='open')
+ @imports(_from='__builtin__', _import='IOError')
+ def keyfile(value):
+ if value:
+ try:
+ with open(value[0]) as fh:
+ result = fh.read().strip()
+ if result:
+ return callback(result)
+ raise FatalCheckError("'%s' is empty." % value[0])
+ except IOError as e:
+ raise FatalCheckError("'%s': %s." % (value[0], e.strerror))
+ return no_key
+
+ return keyfile
+
+
+@template
+def simple_keyfile(desc):
+ value = keyfile(desc)
+ set_config('MOZ_%s_KEY' % desc.upper().replace(' ', '_'), value)
+ # Only really required for MOZ_ADJUST_SDK_KEY currently still used in
+ # old-configure.
+ add_old_configure_assignment('MOZ_%s_KEY' % desc.upper().replace(' ', '_'),
+ value)
+
+
+@template
+def id_and_secret_keyfile(desc):
+ def id_and_secret(value):
+ if value.startswith('no-') and value.endswith('-key'):
+ id = value[:-3] + 'clientid'
+ secret = value
+ elif ' ' in value:
+ id, secret = value.split(' ', 1)
+ else:
+ raise FatalCheckError('%s key file has an invalid format.' % desc)
+ return namespace(
+ id=id,
+ secret=secret,
+ )
+
+ content = keyfile(desc, help='Use the client id and secret key contained '
+ 'in the given keyfile for %s requests' % desc,
+ callback=id_and_secret)
+
+
+ name = desc.upper().replace(' ', '_')
+ set_config('MOZ_%s_CLIENTID' % name, delayed_getattr(content, 'id'))
+ set_config('MOZ_%s_KEY' % name, delayed_getattr(content, 'secret'))
diff --git a/build/moz.configure/memory.configure b/build/moz.configure/memory.configure
new file mode 100644
index 000000000..3beed2fb2
--- /dev/null
+++ b/build/moz.configure/memory.configure
@@ -0,0 +1,98 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+option(env='MOZ_JEMALLOC4', help='Enable jemalloc 4')
+imply_option('--enable-jemalloc', depends_if('MOZ_JEMALLOC4')(lambda x: '4'))
+
+
+option('--enable-jemalloc', nargs='?', choices=('4', 'moz'), env='MOZ_MEMORY',
+ help='Replace memory allocator with jemalloc')
+
+@depends('--enable-jemalloc', target, build_project, c_compiler)
+def jemalloc(value, target, build_project, c_compiler):
+ if value.origin != 'default':
+ return bool(value) or None
+
+ if build_project == 'js':
+ return True
+
+ if target.kernel == 'Darwin' and target.cpu == 'x86_64':
+ # Don't enable by default on 32-bits OSX. See bug 702250.
+ return True
+
+ if target.kernel == 'WINNT' and c_compiler.type in ('msvc', 'clang-cl'):
+ return True
+
+ if target.kernel == 'Linux':
+ return True
+
+@depends('--enable-jemalloc')
+def jemalloc4(jemalloc):
+ if len(jemalloc) and jemalloc[0] == '4':
+ return True
+
+
+set_config('MOZ_MEMORY', jemalloc)
+set_define('MOZ_MEMORY', jemalloc)
+add_old_configure_assignment('MOZ_MEMORY', jemalloc)
+
+set_config('MOZ_JEMALLOC4', jemalloc4)
+set_define('MOZ_JEMALLOC4', jemalloc4)
+add_old_configure_assignment('MOZ_JEMALLOC4', jemalloc4)
+
+
+# Because --enable-jemalloc doesn't use a default because of the dependency
+# on the target, we can't use a js_option for it to propagate to js/src
+# through the old-configure.
+@depends(jemalloc, jemalloc4)
+def jemalloc_for_old_configure(jemalloc, jemalloc4):
+ if jemalloc:
+ return '--enable-jemalloc=4' if jemalloc4 else '--enable-jemalloc'
+ return '--disable-jemalloc'
+
+add_old_configure_arg(jemalloc_for_old_configure)
+
+
+@depends(jemalloc, jemalloc4, target)
+def jemalloc_os_define(jemalloc, jemalloc4, target):
+ if jemalloc and not jemalloc4:
+ if target.kernel == 'WINNT':
+ return 'MOZ_MEMORY_WINDOWS'
+ if target.kernel == 'Linux':
+ return 'MOZ_MEMORY_LINUX'
+ if target.kernel == 'Darwin':
+ return 'MOZ_MEMORY_DARWIN'
+ if target.kernel in ('kFreeBSD', 'FreeBSD', 'NetBSD'):
+ return 'MOZ_MEMORY_BSD'
+ die('--enable-jemalloc is not supported on %s', target.kernel)
+
+set_define(jemalloc_os_define, '1')
+
+@depends(jemalloc, jemalloc4, target)
+def jemalloc_os_define_android(jemalloc, jemalloc4, target):
+ if jemalloc and not jemalloc4 and target.os == 'Android':
+ return 'MOZ_MEMORY_ANDROID'
+
+set_define(jemalloc_os_define_android, '1')
+
+
+option('--enable-replace-malloc',
+ help='Enable ability to dynamically replace the malloc implementation')
+
+@depends('--enable-replace-malloc', jemalloc, milestone, build_project)
+def replace_malloc(value, jemalloc, milestone, build_project):
+ # Enable on central for the debugging opportunities it adds.
+ if value and not jemalloc:
+ die('--enable-replace-malloc requires --enable-jemalloc')
+ if value.origin != 'default':
+ return bool(value) or None
+ if milestone.is_nightly and jemalloc and build_project != 'js':
+ return True
+
+set_config('MOZ_REPLACE_MALLOC', replace_malloc)
+set_define('MOZ_REPLACE_MALLOC', replace_malloc)
+add_old_configure_assignment('MOZ_REPLACE_MALLOC', replace_malloc)
diff --git a/build/moz.configure/old.configure b/build/moz.configure/old.configure
new file mode 100644
index 000000000..b32c3f7b7
--- /dev/null
+++ b/build/moz.configure/old.configure
@@ -0,0 +1,425 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+@imports('codecs')
+@imports('sys')
+def encoded_open(path, mode):
+ encoding = 'mbcs' if sys.platform == 'win32' else 'utf-8'
+ return codecs.open(path, mode, encoding)
+
+
+option(env='AUTOCONF', nargs=1, help='Path to autoconf 2.13')
+
+@depends(mozconfig, 'AUTOCONF')
+@checking('for autoconf')
+@imports(_from='os.path', _import='exists')
+@imports('re')
+def autoconf(mozconfig, autoconf):
+ mozconfig_autoconf = None
+ if mozconfig['path']:
+ make_extra = mozconfig['make_extra']
+ if make_extra:
+ for assignment in make_extra:
+ m = re.match('(?:export\s+)?AUTOCONF\s*:?=\s*(.+)$',
+ assignment)
+ if m:
+ mozconfig_autoconf = m.group(1)
+
+ autoconf = autoconf[0] if autoconf else None
+
+ for ac in (mozconfig_autoconf, autoconf, 'autoconf-2.13', 'autoconf2.13',
+ 'autoconf213'):
+ if ac:
+ autoconf = find_program(ac)
+ if autoconf:
+ break
+ else:
+ fink = find_program('fink')
+ if fink:
+ autoconf = os.path.normpath(os.path.join(
+ fink, '..', '..', 'lib', 'autoconf2.13', 'bin', 'autoconf'))
+ else:
+ brew = find_program('brew')
+ if brew:
+ autoconf = os.path.normpath(os.path.join(
+ brew, '..', '..', 'Cellar', 'autoconf213', '2.13', 'bin',
+ 'autoconf213'))
+
+ if not autoconf:
+ die('Could not find autoconf 2.13')
+
+ if not exists(autoconf):
+ die('Could not find autoconf 2.13 at %s', autoconf)
+
+ return autoconf
+
+set_config('AUTOCONF', autoconf)
+
+
+@depends('OLD_CONFIGURE', mozconfig, autoconf, check_build_environment, shell,
+ old_configure_assignments, build_project)
+@imports(_from='__builtin__', _import='open')
+@imports(_from='__builtin__', _import='print')
+@imports('glob')
+@imports('itertools')
+@imports('subprocess')
+# Import getmtime without overwriting the sandbox os.path.
+@imports(_from='os.path', _import='getmtime')
+@imports(_from='os.path', _import='exists')
+@imports(_from='mozbuild.shellutil', _import='quote')
+def prepare_configure(old_configure, mozconfig, autoconf, build_env, shell,
+ old_configure_assignments, build_project):
+ # os.path.abspath in the sandbox will ensure forward slashes on Windows,
+ # which is actually necessary because this path actually ends up literally
+ # as $0, and backslashes there breaks autoconf's detection of the source
+ # directory.
+ old_configure = os.path.abspath(old_configure[0])
+ if build_project == 'js':
+ old_configure_dir = os.path.dirname(old_configure)
+ if not old_configure_dir.endswith('/js/src'):
+ old_configure = os.path.join(old_configure_dir, 'js', 'src',
+ os.path.basename(old_configure))
+
+ refresh = True
+ if exists(old_configure):
+ mtime = getmtime(old_configure)
+ aclocal = os.path.join(build_env.topsrcdir, 'build', 'autoconf',
+ '*.m4')
+ for input in itertools.chain(
+ (old_configure + '.in',
+ os.path.join(os.path.dirname(old_configure), 'aclocal.m4')),
+ glob.iglob(aclocal),
+ ):
+ if getmtime(input) > mtime:
+ break
+ else:
+ refresh = False
+
+ if refresh:
+ log.info('Refreshing %s with %s', old_configure, autoconf)
+ script = subprocess.check_output([
+ shell, autoconf,
+ '--localdir=%s' % os.path.dirname(old_configure),
+ old_configure + '.in'])
+
+ # Make old-configure append to config.log, where we put our own log.
+ # This could be done with a m4 macro, but it's way easier this way
+ script = script.replace('>./config.log', '>>./config.log')
+
+ with open(old_configure, 'wb') as fh:
+ fh.write(script)
+
+ cmd = [shell, old_configure]
+ with encoded_open('old-configure.vars', 'w') as out:
+ log.debug('Injecting the following to old-configure:')
+ def inject(command):
+ print(command, file=out)
+ log.debug('| %s', command)
+
+ if mozconfig['path']:
+ for key, value in mozconfig['vars']['added'].items():
+ inject("%s=%s" % (key, quote(value)))
+ for key, (old, value) in mozconfig['vars']['modified'].items():
+ inject("%s=%s" % (key, quote(value)))
+ for t in ('env', 'vars'):
+ for key in mozconfig[t]['removed'].keys():
+ inject("unset %s" % key)
+
+ # Autoconf is special, because it might be passed from
+ # mozconfig['make_extra'], which we don't pass automatically above.
+ inject('export AUTOCONF=%s' % quote(autoconf))
+
+ for assignment in old_configure_assignments:
+ inject(assignment)
+
+ return cmd
+
+
+@template
+def old_configure_options(*options):
+ for opt in options:
+ option(opt, nargs='*', help='Help missing for old configure options')
+
+ @dependable
+ def all_options():
+ return list(options)
+
+ return depends(prepare_configure, extra_old_configure_args, all_options,
+ *options)
+
+
+@old_configure_options(
+ '--cache-file',
+ '--datadir',
+ '--enable-accessibility',
+ '--enable-address-sanitizer',
+ '--enable-alsa',
+ '--enable-android-omx',
+ '--enable-b2g-bt',
+ '--enable-b2g-camera',
+ '--enable-b2g-ril',
+ '--enable-bundled-fonts',
+ '--enable-clang-plugin',
+ '--enable-content-sandbox',
+ '--enable-cookies',
+ '--enable-cpp-rtti',
+ '--enable-crashreporter',
+ '--enable-dbus',
+ '--enable-debug-js-modules',
+ '--enable-directshow',
+ '--enable-dtrace',
+ '--enable-dump-painting',
+ '--enable-elf-hack',
+ '--enable-extensions',
+ '--enable-faststripe',
+ '--enable-feeds',
+ '--enable-gamepad',
+ '--enable-gconf',
+ '--enable-gczeal',
+ '--enable-gio',
+ '--enable-gnomeui',
+ '--enable-gold',
+ '--enable-hardware-aec-ns',
+ '--enable-icf',
+ '--enable-install-strip',
+ '--enable-ion',
+ '--enable-ios-target',
+ '--enable-jitspew',
+ '--enable-libjpeg-turbo',
+ '--enable-libproxy',
+ '--enable-llvm-hacks',
+ '--enable-logrefcnt',
+ '--enable-maintenance-service',
+ '--enable-memory-sanitizer',
+ '--enable-mobile-optimize',
+ '--enable-mozril-geoloc',
+ '--enable-necko-wifi',
+ '--enable-negotiateauth',
+ '--enable-nfc',
+ '--enable-nspr-build',
+ '--enable-official-branding',
+ '--enable-omx-plugin',
+ '--enable-oom-breakpoint',
+ '--enable-optimize',
+ '--enable-parental-controls',
+ '--enable-pie',
+ '--enable-png-arm-neon-support',
+ '--enable-posix-nspr-emulation',
+ '--enable-pref-extensions',
+ '--enable-pulseaudio',
+ '--enable-raw',
+ '--enable-readline',
+ '--enable-reflow-perf',
+ '--enable-release',
+ '--enable-require-all-d3dc-versions',
+ '--enable-safe-browsing',
+ '--enable-sandbox',
+ '--enable-signmar',
+ '--enable-simulator',
+ '--enable-small-chunk-size',
+ '--enable-startup-notification',
+ '--enable-startupcache',
+ '--enable-stdcxx-compat',
+ '--enable-strip',
+ '--enable-synth-pico',
+ '--enable-system-cairo',
+ '--enable-system-extension-dirs',
+ '--enable-system-pixman',
+ '--enable-system-sqlite',
+ '--enable-tasktracer',
+ '--enable-thread-sanitizer',
+ '--enable-trace-logging',
+ '--enable-ui-locale',
+ '--enable-universalchardet',
+ '--enable-updater',
+ '--enable-url-classifier',
+ '--enable-valgrind',
+ '--enable-verify-mar',
+ '--enable-webrtc',
+ '--enable-xul',
+ '--enable-zipwriter',
+ '--includedir',
+ '--libdir',
+ '--no-create',
+ '--prefix',
+ '--with-android-cxx-stl',
+ '--with-android-distribution-directory',
+ '--with-android-max-sdk',
+ '--with-android-min-sdk',
+ '--with-android-sdk',
+ '--with-app-basename',
+ '--with-app-name',
+ '--with-arch',
+ '--with-branding',
+ '--with-crashreporter-enable-percent',
+ '--with-cross-lib',
+ '--with-debug-label',
+ '--with-default-mozilla-five-home',
+ '--with-distribution-id',
+ '--with-doc-include-dirs',
+ '--with-doc-input-dirs',
+ '--with-doc-output-dir',
+ '--with-float-abi',
+ '--with-fpu',
+ '--with-intl-api',
+ '--with-ios-sdk',
+ '--with-jitreport-granularity',
+ '--with-macbundlename-prefix',
+ '--with-macos-private-frameworks',
+ '--with-macos-sdk',
+ '--with-nspr-cflags',
+ '--with-nspr-exec-prefix',
+ '--with-nspr-libs',
+ '--with-nspr-prefix',
+ '--with-nss-exec-prefix',
+ '--with-nss-prefix',
+ '--with-pthreads',
+ '--with-qemu-exe',
+ '--with-sixgill',
+ '--with-soft-float',
+ '--with-system-bz2',
+ '--with-system-icu',
+ '--with-system-jpeg',
+ '--with-system-libevent',
+ '--with-system-libvpx',
+ '--with-system-nspr',
+ '--with-system-nss',
+ '--with-system-png',
+ '--with-system-zlib',
+ '--with-thumb',
+ '--with-thumb-interwork',
+ '--with-unify-dist',
+ '--with-user-appdir',
+ '--x-includes',
+ '--x-libraries',
+
+ # Below are the configure flags used by comm-central.
+ '--enable-ldap',
+ '--enable-mapi',
+ '--enable-calendar',
+ '--enable-incomplete-external-linkage',
+)
+@imports(_from='__builtin__', _import='compile')
+@imports(_from='__builtin__', _import='open')
+@imports('logging')
+@imports('os')
+@imports('subprocess')
+@imports('sys')
+@imports(_from='mozbuild.shellutil', _import='quote')
+def old_configure(prepare_configure, extra_old_configure_args, all_options,
+ *options):
+ cmd = prepare_configure
+
+ # old-configure only supports the options listed in @old_configure_options
+ # so we don't need to pass it every single option we've been passed. Only
+ # the ones that are not supported by python configure need to.
+ cmd += [
+ value.format(name)
+ for name, value in zip(all_options, options)
+ if value.origin != 'default'
+ ]
+
+ # We also pass it the options from js/moz.configure so that it can pass
+ # them down to js/src/configure. Note this list is empty when running
+ # js/src/configure, in which case we don't need to pass those options
+ # to old-configure since old-configure doesn't handle them anyways.
+ if extra_old_configure_args:
+ cmd += extra_old_configure_args
+
+ # For debugging purpose, in case it's not what we'd expect.
+ log.debug('Running %s', quote(*cmd))
+
+ # Our logging goes to config.log, the same file old.configure uses.
+ # We can't share the handle on the file, so close it. We assume nothing
+ # beyond this point is going to be interesting to log to config.log from
+ # our end, so we don't make the effort to recreate a logging.FileHandler.
+ logger = logging.getLogger('moz.configure')
+ for handler in logger.handlers:
+ if isinstance(handler, logging.FileHandler):
+ handler.close()
+ logger.removeHandler(handler)
+
+ log_size = os.path.getsize('config.log')
+
+ ret = subprocess.call(cmd)
+ if ret:
+ with log.queue_debug():
+ with encoded_open('config.log', 'r') as fh:
+ fh.seek(log_size)
+ for line in fh:
+ log.debug(line.rstrip())
+ log.error('old-configure failed')
+ sys.exit(ret)
+
+ raw_config = {}
+ with encoded_open('config.data', 'r') as fh:
+ code = compile(fh.read(), 'config.data', 'exec')
+ # Every variation of the exec() function I tried led to:
+ # SyntaxError: unqualified exec is not allowed in function 'main' it
+ # contains a nested function with free variables
+ exec code in raw_config
+
+ # Ensure all the flags known to old-configure appear in the
+ # @old_configure_options above.
+ all_options = set(all_options)
+ for flag in raw_config['flags']:
+ if flag not in all_options:
+ die('Missing option in `@old_configure_options` in %s: %s',
+ __file__, flag)
+
+ # If the code execution above fails, we want to keep the file around for
+ # debugging.
+ os.remove('config.data')
+ return raw_config
+
+
+# set_config is only available in the global namespace, not directly in
+# @depends functions, but we do need to enumerate the result of
+# old_configure, so we cheat.
+@imports('__sandbox__')
+def set_old_configure_config(name, value):
+ __sandbox__.set_config_impl(name, value)
+
+# Same as set_old_configure_config, but for set_define.
+@imports('__sandbox__')
+def set_old_configure_define(name, value):
+ __sandbox__.set_define_impl(name, value)
+
+
+@depends(old_configure)
+@imports('types')
+def post_old_configure(raw_config):
+ for k, v in raw_config['substs']:
+ set_old_configure_config(
+ k[1:-1], v[1:-1] if isinstance(v, types.StringTypes) else v)
+
+ for k, v in dict(raw_config['defines']).iteritems():
+ set_old_configure_define(k[1:-1], v[1:-1])
+
+ set_old_configure_config('non_global_defines',
+ raw_config['non_global_defines'])
+
+
+# Assuming no other option is declared after this function, handle the
+# env options that were injected by mozconfig_options by creating dummy
+# Option instances and having the sandbox's CommandLineHelper handle
+# them. We only do so for options that haven't been declared so far,
+# which should be a proxy for the options that old-configure handles
+# and that we don't know anything about.
+@depends('--help')
+@imports('__sandbox__')
+@imports(_from='mozbuild.configure.options', _import='Option')
+def remaining_mozconfig_options(_):
+ helper = __sandbox__._helper
+ for arg in helper:
+ if helper._origins[arg] != 'mozconfig':
+ continue
+ name = arg.split('=', 1)[0]
+ if name.isupper() and name not in __sandbox__._options:
+ option = Option(env=name, nargs='*', help=name)
+ helper.handle(option)
+
+# Please do not add anything after remaining_mozconfig_options()
diff --git a/build/moz.configure/pkg.configure b/build/moz.configure/pkg.configure
new file mode 100644
index 000000000..991f401ae
--- /dev/null
+++ b/build/moz.configure/pkg.configure
@@ -0,0 +1,97 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+@depends('--enable-compile-environment')
+def pkg_config(compile_env):
+ if compile_env:
+ return ('pkg-config',)
+
+pkg_config = check_prog('PKG_CONFIG', pkg_config, allow_missing=True)
+
+@depends_if(pkg_config)
+@checking('for pkg-config version')
+@imports('subprocess')
+def pkg_config_version(pkg_config):
+ return Version(check_cmd_output(pkg_config, '--version').rstrip())
+
+# Locates the given module using pkg-config.
+# - `var` determines the name of variables to set when the package is found.
+# <var>_CFLAGS and <var>_LIBS are set with corresponding values.
+# - `package_desc` package name and version requirement string, list of
+# strings describing packages to locate, or depends function that will
+# resolve to such a string or list of strings.
+# - `when` a depends function that will determine whether to perform
+# any checks (default is to always perform checks).
+# - `allow_missing` If set, failure to fulfill the package description
+# will not result in an error or logged message, and any error message
+# will be returned to the caller.
+# Returns `True` when the package description is fulfilled.
+@template
+def pkg_check_modules(var, package_desc, when=always,
+ allow_missing=False):
+ if isinstance(package_desc, (tuple, list)):
+ package_desc = ' '.join(package_desc)
+ package_desc = dependable(package_desc)
+
+ @depends(when, '--enable-compile-environment')
+ def when_and_compile_environment(when, compile_environment):
+ return when and compile_environment
+
+ @depends_when(pkg_config, pkg_config_version,
+ when=when_and_compile_environment)
+ def check_pkg_config(pkg_config, version):
+ min_version = '0.9.0'
+ if pkg_config is None:
+ die("*** The pkg-config script could not be found. Make sure it is\n"
+ "*** in your path, or set the PKG_CONFIG environment variable\n"
+ "*** to the full path to pkg-config.")
+ if version < min_version:
+ die("*** Your version of pkg-config is too old. You need version %s or newer.",
+ min_version)
+
+ @depends_when(pkg_config, package_desc, when=when_and_compile_environment)
+ @imports('subprocess')
+ @imports('sys')
+ @imports(_from='mozbuild.configure.util', _import='LineIO')
+ def package(pkg_config, package_desc):
+ # package_desc may start as a depends function, so we can't use
+ # @checking here.
+ log.info("checking for %s... " % package_desc)
+ with log.queue_debug():
+ try:
+ subprocess.check_output([pkg_config, '--errors-to-stdout',
+ '--print-errors', package_desc])
+ log.info("yes")
+ return True
+ except subprocess.CalledProcessError as e:
+ log.info("no")
+ log_writer = log.warning if allow_missing else log.error
+ with LineIO(lambda l: log_writer(l)) as o:
+ o.write(e.output)
+ if not allow_missing:
+ sys.exit(1)
+
+ @depends_when(pkg_config, package_desc, when=package)
+ @checking('%s_CFLAGS' % var, callback=lambda t: ' '.join(t))
+ def pkg_cflags(pkg_config, package_desc):
+ flags = check_cmd_output(pkg_config, '--cflags', package_desc)
+ return tuple(flags.split())
+
+ @depends_when(pkg_config, package_desc, when=package)
+ @checking('%s_LIBS' % var, callback=lambda t: ' '.join(t))
+ def pkg_libs(pkg_config, package_desc):
+ libs = check_cmd_output(pkg_config, '--libs', package_desc)
+ # Remove evil flags like -Wl,--export-dynamic
+ return tuple(libs.replace('-Wl,--export-dynamic', '').split())
+
+ @depends_when(pkg_cflags, pkg_libs, when=package)
+ def pkg_info(cflags, libs):
+ return namespace(cflags=cflags, libs=libs)
+
+ set_config('%s_CFLAGS' % var, pkg_cflags)
+ set_config('%s_LIBS' % var, pkg_libs)
+
+ return pkg_info
diff --git a/build/moz.configure/rust.configure b/build/moz.configure/rust.configure
new file mode 100644
index 000000000..261768f64
--- /dev/null
+++ b/build/moz.configure/rust.configure
@@ -0,0 +1,166 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+option('--enable-rust', help='Include Rust language sources')
+
+@depends('--enable-rust')
+def rust_compiler_names(value):
+ if value:
+ return ['rustc']
+
+@depends('--enable-rust')
+def cargo_binary_names(value):
+ if value:
+ return ['cargo']
+
+rustc = check_prog('RUSTC', rust_compiler_names, allow_missing=True)
+cargo = check_prog('CARGO', cargo_binary_names, allow_missing=True)
+
+@depends_if(rustc)
+@checking('rustc version', lambda info: info.version)
+def rustc_info(rustc):
+ out = check_cmd_output(rustc, '--version', '--verbose').splitlines()
+ info = dict((s.strip() for s in line.split(':', 1)) for line in out[1:])
+ return namespace(
+ version=Version(info.get('release', '0')),
+ commit=info.get('commit-hash', 'unknown'),
+ )
+
+@depends_if(cargo)
+@checking('cargo support for --frozen')
+@imports('subprocess')
+@imports('os')
+def cargo_supports_frozen(cargo):
+ try:
+ lines = subprocess.check_output(
+ [cargo, 'help', 'build']
+ ).splitlines()
+ supported = any(' --frozen' in l for l in lines)
+ if 'MOZ_AUTOMATION' in os.environ and not supported:
+ die('cargo in automation must support --frozen')
+ return supported
+ except subprocess.CalledProcessError as e:
+ die('Failed to call cargo: %s', e.message)
+
+set_config('MOZ_CARGO_SUPPORTS_FROZEN', cargo_supports_frozen)
+
+@depends('--enable-rust', rustc, rustc_info)
+@imports(_from='textwrap', _import='dedent')
+def rust_compiler(value, rustc, rustc_info):
+ if value:
+ if not rustc:
+ die(dedent('''\
+ Rust compiler not found.
+ To compile rust language sources, you must have 'rustc' in your path.
+ See https//www.rust-lang.org/ for more information.
+ '''))
+ version = rustc_info.version
+ min_version = Version('1.10')
+ if version < min_version:
+ die(dedent('''\
+ Rust compiler {} is too old.
+ To compile Rust language sources please install at least
+ version {} of the 'rustc' toolchain and make sure it is
+ first in your path.
+ You can verify this by typing 'rustc --version'.
+ '''.format(version, min_version)))
+ return True
+
+set_config('MOZ_RUST', rust_compiler)
+
+@depends(rust_compiler, rustc, target, cross_compiling)
+@imports('os')
+@imports('subprocess')
+@imports(_from='mozbuild.configure.util', _import='LineIO')
+@imports(_from='mozbuild.shellutil', _import='quote')
+@imports(_from='tempfile', _import='mkstemp')
+def rust_target(rust_compiler, rustc, target, cross_compiling):
+ if rust_compiler:
+ # Rust's --target options are similar to, but not exactly the same
+ # as, the autoconf-derived targets we use. An example would be that
+ # Rust uses distinct target triples for targetting the GNU C++ ABI
+ # and the MSVC C++ ABI on Win32, whereas autoconf has a single
+ # triple and relies on the user to ensure that everything is
+ # compiled for the appropriate ABI. We need to perform appropriate
+ # munging to get the correct option to rustc.
+ #
+ # The canonical list of targets supported can be derived from:
+ #
+ # https://github.com/rust-lang/rust/tree/master/mk/cfg
+
+ # Avoid having to write out os+kernel for all the platforms where
+ # they don't differ.
+ os_or_kernel = target.kernel if target.kernel == 'Linux' and target.os != 'Android' else target.os
+ rustc_target = {
+ # DragonFly
+ ('x86_64', 'DragonFly'): 'x86_64-unknown-dragonfly',
+ # FreeBSD
+ ('x86', 'FreeBSD'): 'i686-unknown-freebsd',
+ ('x86_64', 'FreeBSD'): 'x86_64-unknown-freebsd',
+ # NetBSD
+ ('x86_64', 'NetBSD'): 'x86_64-unknown-netbsd',
+ # OpenBSD
+ ('x86_64', 'OpenBSD'): 'x86_64-unknown-openbsd',
+ # Linux
+ ('x86', 'Linux'): 'i586-unknown-linux-gnu',
+ # Linux
+ ('x86_64', 'Linux'): 'x86_64-unknown-linux-gnu',
+ # OS X and iOS
+ ('x86', 'OSX'): 'i686-apple-darwin',
+ ('x86', 'iOS'): 'i386-apple-ios',
+ ('x86_64', 'OSX'): 'x86_64-apple-darwin',
+ # Android
+ ('x86', 'Android'): 'i686-linux-android',
+ ('arm', 'Android'): 'armv7-linux-androideabi',
+ # Windows
+ # XXX better detection of CXX needed here, to figure out whether
+ # we need i686-pc-windows-gnu instead, since mingw32 builds work.
+ ('x86', 'WINNT'): 'i686-pc-windows-msvc',
+ ('x86_64', 'WINNT'): 'x86_64-pc-windows-msvc',
+ }.get((target.cpu, os_or_kernel), None)
+
+ if rustc_target is None:
+ die("Don't know how to translate {} for rustc".format(target.alias))
+
+ # Check to see whether our rustc has a reasonably functional stdlib
+ # for our chosen target.
+ target_arg = '--target=' + rustc_target
+ in_fd, in_path = mkstemp(prefix='conftest', suffix='.rs')
+ out_fd, out_path = mkstemp(prefix='conftest', suffix='.rlib')
+ os.close(out_fd)
+ try:
+ source = 'pub extern fn hello() { println!("Hello world"); }'
+ log.debug('Creating `%s` with content:', in_path)
+ with LineIO(lambda l: log.debug('| %s', l)) as out:
+ out.write(source)
+
+ os.write(in_fd, source)
+ os.close(in_fd)
+
+ cmd = [
+ rustc,
+ '--crate-type', 'staticlib',
+ target_arg,
+ '-o', out_path,
+ in_path,
+ ]
+ def failed():
+ die('Cannot compile for {} with {}'.format(target.alias, rustc))
+ check_cmd_output(*cmd, onerror=failed)
+ if not os.path.exists(out_path) or os.path.getsize(out_path) == 0:
+ failed()
+ finally:
+ os.remove(in_path)
+ os.remove(out_path)
+ # This target is usable.
+ return rustc_target
+
+set_config('RUST_TARGET', rust_target)
+
+# Until we remove all the other Rust checks in old-configure.
+add_old_configure_assignment('MOZ_RUST', rust_compiler)
+add_old_configure_assignment('RUSTC', rustc)
+add_old_configure_assignment('RUST_TARGET', rust_target)
diff --git a/build/moz.configure/toolchain.configure b/build/moz.configure/toolchain.configure
new file mode 100644
index 000000000..8b2416152
--- /dev/null
+++ b/build/moz.configure/toolchain.configure
@@ -0,0 +1,910 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# PGO
+# ==============================================================
+option(env='MOZ_PGO', help='Build with profile guided optimizations')
+
+set_config('MOZ_PGO', depends('MOZ_PGO')(lambda x: bool(x)))
+add_old_configure_assignment('MOZ_PGO', depends('MOZ_PGO')(lambda x: bool(x)))
+
+# yasm detection
+# ==============================================================
+yasm = check_prog('YASM', ['yasm'], allow_missing=True)
+
+@depends_if(yasm)
+@checking('yasm version')
+def yasm_version(yasm):
+ version = check_cmd_output(
+ yasm, '--version',
+ onerror=lambda: die('Failed to get yasm version.')
+ ).splitlines()[0].split()[1]
+ return Version(version)
+
+# Until we move all the yasm consumers out of old-configure.
+# bug 1257904
+add_old_configure_assignment('_YASM_MAJOR_VERSION',
+ delayed_getattr(yasm_version, 'major'))
+add_old_configure_assignment('_YASM_MINOR_VERSION',
+ delayed_getattr(yasm_version, 'minor'))
+
+@depends(yasm, target)
+def yasm_asflags(yasm, target):
+ if yasm:
+ asflags = {
+ ('OSX', 'x86'): '-f macho32',
+ ('OSX', 'x86_64'): '-f macho64',
+ ('WINNT', 'x86'): '-f win32',
+ ('WINNT', 'x86_64'): '-f x64',
+ }.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'
+ if asflags:
+ asflags += ' -rnasm -pnasm'
+ return asflags
+
+set_config('YASM_ASFLAGS', yasm_asflags)
+
+@depends(yasm_asflags)
+def have_yasm(value):
+ if value:
+ return True
+
+set_config('HAVE_YASM', have_yasm)
+# Until the YASM variable is not necessary in old-configure.
+add_old_configure_assignment('YASM', have_yasm)
+
+# Android NDK
+# ==============================================================
+
+@depends('--disable-compile-environment', build_project, gonkdir, '--help')
+def compiling_android(compile_env, build_project, gonkdir, _):
+ return compile_env and (gonkdir or build_project in ('mobile/android', 'js'))
+
+include('android-ndk.configure', when=compiling_android)
+
+# MacOS deployment target version
+# ==============================================================
+# This needs to happen before any compilation test is done.
+
+option('--enable-macos-target', env='MACOSX_DEPLOYMENT_TARGET', nargs=1,
+ default='10.7', help='Set the minimum MacOS version needed at runtime')
+
+@depends('--enable-macos-target', target)
+@imports(_from='os', _import='environ')
+def macos_target(value, target):
+ if value and target.os == 'OSX':
+ # Ensure every compiler process we spawn uses this value.
+ environ['MACOSX_DEPLOYMENT_TARGET'] = value[0]
+ return value[0]
+ if value and value.origin != 'default':
+ die('--enable-macos-target cannot be used when targeting %s',
+ target.os)
+
+
+set_config('MACOSX_DEPLOYMENT_TARGET', macos_target)
+add_old_configure_assignment('MACOSX_DEPLOYMENT_TARGET', macos_target)
+
+
+# Compiler wrappers
+# ==============================================================
+# Normally, we'd use js_option and automatically have those variables
+# propagated to js/src, but things are complicated by possible additional
+# wrappers in CC/CXX, and by other subconfigures that do not handle those
+# options and do need CC/CXX altered.
+option('--with-compiler-wrapper', env='COMPILER_WRAPPER', nargs=1,
+ help='Enable compiling with wrappers such as distcc and ccache')
+
+option('--with-ccache', env='CCACHE', nargs='?',
+ help='Enable compiling with ccache')
+
+@depends_if('--with-ccache')
+def ccache(value):
+ if len(value):
+ return value
+ # If --with-ccache was given without an explicit value, we default to
+ # 'ccache'.
+ return 'ccache'
+
+ccache = check_prog('CCACHE', progs=(), input=ccache)
+
+@depends_if(ccache)
+def using_ccache(ccache):
+ return True
+
+set_config('MOZ_USING_CCACHE', using_ccache)
+
+@depends('--with-compiler-wrapper', ccache)
+@imports(_from='mozbuild.shellutil', _import='split', _as='shell_split')
+def compiler_wrapper(wrapper, ccache):
+ if wrapper:
+ raw_wrapper = wrapper[0]
+ wrapper = shell_split(raw_wrapper)
+ wrapper_program = find_program(wrapper[0])
+ if not wrapper_program:
+ die('Cannot find `%s` from the given compiler wrapper `%s`',
+ wrapper[0], raw_wrapper)
+ wrapper[0] = wrapper_program
+
+ if ccache:
+ if wrapper:
+ return tuple([ccache] + wrapper)
+ else:
+ return (ccache,)
+ elif wrapper:
+ return tuple(wrapper)
+
+add_old_configure_assignment('COMPILER_WRAPPER', compiler_wrapper)
+
+@depends_if(compiler_wrapper)
+def using_compiler_wrapper(compiler_wrapper):
+ return True
+
+set_config('MOZ_USING_COMPILER_WRAPPER', using_compiler_wrapper)
+
+
+# Cross-compilation related things.
+# ==============================================================
+js_option('--with-toolchain-prefix', env='TOOLCHAIN_PREFIX', nargs=1,
+ help='Prefix for the target toolchain')
+
+@depends('--with-toolchain-prefix', target, host, cross_compiling)
+def toolchain_prefix(value, target, host, cross_compiling):
+ if value:
+ return tuple(value)
+ if cross_compiling:
+ return ('%s-' % target.toolchain, '%s-' % target.alias)
+
+@depends(toolchain_prefix, target)
+def first_toolchain_prefix(toolchain_prefix, target):
+ # Pass TOOLCHAIN_PREFIX down to the build system if it was given from the
+ # command line/environment (in which case there's only one value in the tuple),
+ # or when cross-compiling for Android.
+ if toolchain_prefix and (target.os == 'Android' or len(toolchain_prefix) == 1):
+ return toolchain_prefix[0]
+
+set_config('TOOLCHAIN_PREFIX', first_toolchain_prefix)
+add_old_configure_assignment('TOOLCHAIN_PREFIX', first_toolchain_prefix)
+
+
+# Compilers
+# ==============================================================
+include('compilers-util.configure')
+
+def try_preprocess(compiler, language, source):
+ return try_invoke_compiler(compiler, language, source, ['-E'])
+
+@imports(_from='mozbuild.configure.constants', _import='CompilerType')
+@imports(_from='mozbuild.configure.constants',
+ _import='CPU_preprocessor_checks')
+@imports(_from='mozbuild.configure.constants',
+ _import='kernel_preprocessor_checks')
+@imports(_from='textwrap', _import='dedent')
+def get_compiler_info(compiler, language):
+ '''Returns information about the given `compiler` (command line in the
+ form of a list or tuple), in the given `language`.
+
+ The returned information includes:
+ - the compiler type (msvc, clang-cl, clang or gcc)
+ - the compiler version
+ - the compiler supported language
+ - the compiler supported language version
+ '''
+ # Note: MSVC doesn't expose __STDC_VERSION__. It does expose __STDC__,
+ # but only when given the -Za option, which disables compiler
+ # extensions.
+ # Note: We'd normally do a version check for clang, but versions of clang
+ # in Xcode have a completely different versioning scheme despite exposing
+ # the version with the same defines.
+ # So instead, we make things such that the version is missing when the
+ # clang used is below the minimum supported version (currently clang 3.6).
+ # We then only include the version information when the C++ compiler
+ # matches the feature check, so that an unsupported version of clang would
+ # have no version number.
+ check = dedent('''\
+ #if defined(_MSC_VER)
+ #if defined(__clang__)
+ %COMPILER "clang-cl"
+ %VERSION _MSC_FULL_VER
+ #else
+ %COMPILER "msvc"
+ %VERSION _MSC_FULL_VER
+ #endif
+ #elif defined(__clang__)
+ %COMPILER "clang"
+ # if !__cplusplus || __has_feature(cxx_alignof)
+ %VERSION __clang_major__.__clang_minor__.__clang_patchlevel__
+ # endif
+ #elif defined(__GNUC__)
+ %COMPILER "gcc"
+ %VERSION __GNUC__.__GNUC_MINOR__.__GNUC_PATCHLEVEL__
+ #endif
+
+ #if __cplusplus
+ %cplusplus __cplusplus
+ #elif __STDC_VERSION__
+ %STDC_VERSION __STDC_VERSION__
+ #elif __STDC__
+ %STDC_VERSION 198900L
+ #endif
+ ''')
+
+ # While we're doing some preprocessing, we might as well do some more
+ # preprocessor-based tests at the same time, to check the toolchain
+ # matches what we want.
+ for name, preprocessor_checks in (
+ ('CPU', CPU_preprocessor_checks),
+ ('KERNEL', kernel_preprocessor_checks),
+ ):
+ for n, (value, condition) in enumerate(preprocessor_checks.iteritems()):
+ check += dedent('''\
+ #%(if)s %(condition)s
+ %%%(name)s "%(value)s"
+ ''' % {
+ 'if': 'elif' if n else 'if',
+ 'condition': condition,
+ 'name': name,
+ 'value': value,
+ })
+ check += '#endif\n'
+
+ # Also check for endianness. The advantage of living in modern times is
+ # that all the modern compilers we support now have __BYTE_ORDER__ defined
+ # by the preprocessor, except MSVC, which only supports little endian.
+ check += dedent('''\
+ #if _MSC_VER || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+ %ENDIANNESS "little"
+ #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+ %ENDIANNESS "big"
+ #endif
+ ''')
+
+ result = try_preprocess(compiler, language, check)
+
+ if not result:
+ raise FatalCheckError(
+ 'Unknown compiler or compiler not supported.')
+
+ # Metadata emitted by preprocessors such as GCC with LANG=ja_JP.utf-8 may
+ # have non-ASCII characters. Treat the output as bytearray.
+ data = {}
+ for line in result.splitlines():
+ if line.startswith(b'%'):
+ k, _, v = line.partition(' ')
+ k = k.lstrip('%')
+ data[k] = v.replace(' ', '').lstrip('"').rstrip('"')
+ log.debug('%s = %s', k, data[k])
+
+ try:
+ type = CompilerType(data['COMPILER'])
+ except:
+ raise FatalCheckError(
+ 'Unknown compiler or compiler not supported.')
+
+ cplusplus = int(data.get('cplusplus', '0L').rstrip('L'))
+ stdc_version = int(data.get('STDC_VERSION', '0L').rstrip('L'))
+
+ version = data.get('VERSION')
+ if version and type in ('msvc', 'clang-cl'):
+ msc_ver = version
+ version = msc_ver[0:2]
+ if len(msc_ver) > 2:
+ version += '.' + msc_ver[2:4]
+ if len(msc_ver) > 4:
+ version += '.' + msc_ver[4:]
+
+ if version:
+ version = Version(version)
+
+ return namespace(
+ type=type,
+ version=version,
+ cpu=data.get('CPU'),
+ kernel=data.get('KERNEL'),
+ endianness=data.get('ENDIANNESS'),
+ language='C++' if cplusplus else 'C',
+ language_version=cplusplus if cplusplus else stdc_version,
+ )
+
+
+@imports(_from='mozbuild.shellutil', _import='quote')
+def check_compiler(compiler, language, target):
+ info = get_compiler_info(compiler, language)
+
+ flags = []
+
+ def append_flag(flag):
+ if flag not in flags:
+ if info.type == 'clang-cl':
+ flags.append('-Xclang')
+ flags.append(flag)
+
+ # Check language standards
+ # --------------------------------------------------------------------
+ if language != info.language:
+ raise FatalCheckError(
+ '`%s` is not a %s compiler.' % (quote(*compiler), language))
+
+ # Note: We do a strict version check because there sometimes are backwards
+ # incompatible changes in the standard, and not all code that compiles as
+ # C99 compiles as e.g. C11 (as of writing, this is true of libnestegg, for
+ # example)
+ if info.language == 'C' and info.language_version != 199901:
+ if info.type in ('clang-cl', 'clang', 'gcc'):
+ append_flag('-std=gnu99')
+
+ # Note: MSVC, while supporting C++11, still reports 199711L for __cplusplus.
+ # Note: this is a strict version check because we used to always add
+ # -std=gnu++11.
+ if info.language == 'C++':
+ if info.type in ('clang', 'gcc') and info.language_version != 201103:
+ append_flag('-std=gnu++11')
+ # MSVC 2015 headers include C++14 features, but don't guard them
+ # with appropriate checks.
+ if info.type == 'clang-cl' and info.language_version != 201402:
+ append_flag('-std=c++14')
+
+ # We force clang-cl to emulate Visual C++ 2015 Update 3 with fallback to
+ # cl.exe.
+ if info.type == 'clang-cl' and info.version != '19.00.24213':
+ # Those flags are direct clang-cl flags that don't need -Xclang, add
+ # them directly.
+ flags.append('-fms-compatibility-version=19.00.24213')
+ flags.append('-fallback')
+
+ # Check compiler target
+ # --------------------------------------------------------------------
+ if not info.cpu or info.cpu != target.cpu:
+ if info.type == 'clang':
+ append_flag('--target=%s' % target.toolchain)
+ elif info.type == 'gcc':
+ same_arch_different_bits = (
+ ('x86', 'x86_64'),
+ ('ppc', 'ppc64'),
+ ('sparc', 'sparc64'),
+ )
+ if (target.cpu, info.cpu) in same_arch_different_bits:
+ append_flag('-m32')
+ elif (info.cpu, target.cpu) in same_arch_different_bits:
+ append_flag('-m64')
+
+ if not info.kernel or info.kernel != target.kernel:
+ if info.type == 'clang':
+ append_flag('--target=%s' % target.toolchain)
+
+ if not info.endianness or info.endianness != target.endianness:
+ if info.type == 'clang':
+ append_flag('--target=%s' % target.toolchain)
+
+ return namespace(
+ type=info.type,
+ version=info.version,
+ target_cpu=info.cpu,
+ target_kernel=info.kernel,
+ target_endianness=info.endianness,
+ flags=flags,
+ )
+
+
+@imports(_from='collections', _import='defaultdict')
+@imports(_from='__builtin__', _import='sorted')
+def get_vc_paths(base):
+ vc = defaultdict(lambda: defaultdict(dict))
+ subkey = r'Microsoft\VisualStudio\VC\*\*\*\Compiler'
+ for v, h, t, p in get_registry_values(base + '\\' + subkey):
+ vc[v][h][t] = p
+ if not vc:
+ return
+ version, data = sorted(vc.iteritems(), key=lambda x: Version(x[0]))[-1]
+ return data
+
+
+@depends(host)
+@imports('platform')
+def vc_compiler_path(host):
+ if host.kernel != 'WINNT':
+ return
+ vc_host = {
+ 'x86': 'x86',
+ 'AMD64': 'x64',
+ }.get(platform.machine())
+ if vc_host is None:
+ return
+ vc_target = {
+ 'x86': 'x86',
+ 'x86_64': 'x64',
+ 'arm': 'arm',
+ }.get(host.cpu)
+ if vc_target is None:
+ return
+
+ base_key = r'HKEY_LOCAL_MACHINE\SOFTWARE'
+ data = get_vc_paths(base_key)
+ if not data:
+ data = get_vc_paths(base_key + r'\Wow6432Node')
+ if not data:
+ return
+
+ path = data.get(vc_host, {}).get(vc_target)
+ if not path and vc_host == 'x64':
+ vc_host = 'x86'
+ path = data.get(vc_host, {}).get(vc_target)
+ if not path:
+ return
+ path = os.path.dirname(path)
+ if vc_host != vc_target:
+ other_path = data.get(vc_host, {}).get(vc_host)
+ if other_path:
+ return (path, os.path.dirname(other_path))
+ return (path,)
+
+
+@depends(vc_compiler_path)
+@imports('os')
+def toolchain_search_path(vc_compiler_path):
+ if vc_compiler_path:
+ result = [os.environ.get('PATH')]
+ result.extend(vc_compiler_path)
+ # We're going to alter PATH for good in windows.configure, but we also
+ # need to do it for the valid_compiler() check below.
+ os.environ['PATH'] = os.pathsep.join(result)
+ return result
+
+
+@template
+def default_c_compilers(host_or_target):
+ '''Template defining the set of default C compilers for the host and
+ target platforms.
+ `host_or_target` is either `host` or `target` (the @depends functions
+ from init.configure.
+ '''
+ assert host_or_target in (host, target)
+
+ @depends(host_or_target, target, toolchain_prefix)
+ def default_c_compilers(host_or_target, target, toolchain_prefix):
+ gcc = ('gcc',)
+ if toolchain_prefix and host_or_target is target:
+ gcc = tuple('%sgcc' % p for p in toolchain_prefix) + gcc
+
+ if host_or_target.kernel == 'WINNT':
+ return ('cl', 'clang-cl') + gcc + ('clang',)
+ if host_or_target.kernel == 'Darwin':
+ return ('clang',)
+ return gcc + ('clang',)
+
+ return default_c_compilers
+
+
+@template
+def default_cxx_compilers(c_compiler):
+ '''Template defining the set of default C++ compilers for the host and
+ target platforms.
+ `c_compiler` is the @depends function returning a Compiler instance for
+ the desired platform.
+
+ Because the build system expects the C and C++ compilers to be from the
+ same compiler suite, we derive the default C++ compilers from the C
+ compiler that was found if none was provided.
+ '''
+
+ @depends(c_compiler)
+ def default_cxx_compilers(c_compiler):
+ dir = os.path.dirname(c_compiler.compiler)
+ file = os.path.basename(c_compiler.compiler)
+
+ if c_compiler.type == 'gcc':
+ return (os.path.join(dir, file.replace('gcc', 'g++')),)
+
+ if c_compiler.type == 'clang':
+ return (os.path.join(dir, file.replace('clang', 'clang++')),)
+
+ return (c_compiler.compiler,)
+
+ return default_cxx_compilers
+
+
+@template
+def compiler(language, host_or_target, c_compiler=None, other_compiler=None,
+ other_c_compiler=None):
+ '''Template handling the generic base checks for the compiler for the
+ given `language` on the given platform (`host_or_target`).
+ `host_or_target` is either `host` or `target` (the @depends functions
+ from init.configure.
+ When the language is 'C++', `c_compiler` is the result of the `compiler`
+ template for the language 'C' for the same `host_or_target`.
+ When `host_or_target` is `host`, `other_compiler` is the result of the
+ `compiler` template for the same `language` for `target`.
+ When `host_or_target` is `host` and the language is 'C++',
+ `other_c_compiler` is the result of the `compiler` template for the
+ language 'C' for `target`.
+ '''
+ assert host_or_target in (host, target)
+ assert language in ('C', 'C++')
+ assert language == 'C' or c_compiler
+ assert host_or_target == target or other_compiler
+ assert language == 'C' or host_or_target == target or other_c_compiler
+
+ host_or_target_str = {
+ host: 'host',
+ target: 'target',
+ }[host_or_target]
+
+ var = {
+ ('C', target): 'CC',
+ ('C++', target): 'CXX',
+ ('C', host): 'HOST_CC',
+ ('C++', host): 'HOST_CXX',
+ }[language, host_or_target]
+
+ default_compilers = {
+ 'C': lambda: default_c_compilers(host_or_target),
+ 'C++': lambda: default_cxx_compilers(c_compiler),
+ }[language]()
+
+ what='the %s %s compiler' % (host_or_target_str, language)
+
+ option(env=var, nargs=1, help='Path to %s' % what)
+
+ # Handle the compiler given by the user through one of the CC/CXX/HOST_CC/
+ # HOST_CXX variables.
+ @depends_if(var)
+ @imports(_from='itertools', _import='takewhile')
+ @imports(_from='mozbuild.shellutil', _import='split', _as='shell_split')
+ def provided_compiler(cmd):
+ # Historically, the compiler variables have contained more than the
+ # path to the compiler itself. So for backwards compatibility, try to
+ # find what is what in there, assuming the first dash-prefixed item is
+ # a compiler option, the item before that is the compiler, and anything
+ # before that is a compiler wrapper.
+ cmd = shell_split(cmd[0])
+
+ without_flags = list(takewhile(lambda x: not x.startswith('-'), cmd))
+
+ return namespace(
+ wrapper=without_flags[:-1],
+ compiler=without_flags[-1],
+ flags=cmd[len(without_flags):],
+ )
+
+ # Derive the host compiler from the corresponding target compiler when no
+ # explicit compiler was given and we're not cross compiling. For the C++
+ # compiler, though, prefer to derive from the host C compiler when it
+ # doesn't match the target C compiler.
+ # As a special case, since clang supports all kinds of targets in the same
+ # executable, when cross compiling with clang, default to the same compiler
+ # as the target compiler, resetting flags.
+ if host_or_target == host:
+ args = (c_compiler, other_c_compiler) if other_c_compiler else ()
+
+ @depends(provided_compiler, other_compiler, cross_compiling, *args)
+ def provided_compiler(value, other_compiler, cross_compiling, *args):
+ if value:
+ return value
+ c_compiler, other_c_compiler = args if args else (None, None)
+ if not cross_compiling and c_compiler == other_c_compiler:
+ return other_compiler
+ if cross_compiling and other_compiler.type == 'clang':
+ return namespace(**{
+ k: [] if k == 'flags' else v
+ for k, v in other_compiler.__dict__.iteritems()
+ })
+
+ # Normally, we'd use `var` instead of `_var`, but the interaction with
+ # old-configure complicates things, and for now, we a) can't take the plain
+ # result from check_prog as CC/CXX/HOST_CC/HOST_CXX and b) have to let
+ # old-configure AC_SUBST it (because it's autoconf doing it, not us)
+ compiler = check_prog('_%s' % var, what=what, progs=default_compilers,
+ input=delayed_getattr(provided_compiler, 'compiler'),
+ paths=toolchain_search_path)
+
+ @depends(compiler, provided_compiler, compiler_wrapper, host_or_target)
+ @checking('whether %s can be used' % what, lambda x: bool(x))
+ @imports(_from='mozbuild.shellutil', _import='quote')
+ def valid_compiler(compiler, provided_compiler, compiler_wrapper,
+ host_or_target):
+ wrapper = list(compiler_wrapper or ())
+ if provided_compiler:
+ provided_wrapper = list(provided_compiler.wrapper)
+ # When doing a subconfigure, the compiler is set by old-configure
+ # and it contains the wrappers from --with-compiler-wrapper and
+ # --with-ccache.
+ if provided_wrapper[:len(wrapper)] == wrapper:
+ provided_wrapper = provided_wrapper[len(wrapper):]
+ wrapper.extend(provided_wrapper)
+ flags = provided_compiler.flags
+ else:
+ flags = []
+
+ # Ideally, we'd always use the absolute path, but unfortunately, on
+ # Windows, the compiler is very often in a directory containing spaces.
+ # Unfortunately, due to the way autoconf does its compiler tests with
+ # eval, that doesn't work out. So in that case, check that the
+ # compiler can still be found in $PATH, and use the file name instead
+ # of the full path.
+ if quote(compiler) != compiler:
+ full_path = os.path.abspath(compiler)
+ compiler = os.path.basename(compiler)
+ found_compiler = find_program(compiler)
+ if not found_compiler:
+ die('%s is not in your $PATH'
+ % quote(os.path.dirname(full_path)))
+ if os.path.normcase(find_program(compiler)) != os.path.normcase(
+ full_path):
+ die('Found `%s` before `%s` in your $PATH. '
+ 'Please reorder your $PATH.',
+ quote(os.path.dirname(found_compiler)),
+ quote(os.path.dirname(full_path)))
+
+ info = check_compiler(wrapper + [compiler] + flags, language,
+ host_or_target)
+
+ # Check that the additional flags we got are enough to not require any
+ # more flags.
+ if info.flags:
+ flags += info.flags
+ info = check_compiler(wrapper + [compiler] + flags, language,
+ host_or_target)
+
+ if not info.target_cpu or info.target_cpu != host_or_target.cpu:
+ raise FatalCheckError(
+ '%s %s compiler target CPU (%s) does not match --%s CPU (%s)'
+ % (host_or_target_str.capitalize(), language,
+ info.target_cpu or 'unknown', host_or_target_str,
+ host_or_target.raw_cpu))
+
+ if not info.target_kernel or (info.target_kernel !=
+ host_or_target.kernel):
+ raise FatalCheckError(
+ '%s %s compiler target kernel (%s) does not match --%s kernel (%s)'
+ % (host_or_target_str.capitalize(), language,
+ info.target_kernel or 'unknown', host_or_target_str,
+ host_or_target.kernel))
+
+ if not info.target_endianness or (info.target_endianness !=
+ host_or_target.endianness):
+ raise FatalCheckError(
+ '%s %s compiler target endianness (%s) does not match --%s '
+ 'endianness (%s)'
+ % (host_or_target_str.capitalize(), language,
+ info.target_endianness or 'unknown', host_or_target_str,
+ host_or_target.endianness))
+
+ if info.flags:
+ raise FatalCheckError(
+ 'Unknown compiler or compiler not supported.')
+
+ # Compiler version checks
+ # ===================================================
+ # Check the compiler version here instead of in `compiler_version` so
+ # that the `checking` message doesn't pretend the compiler can be used
+ # to then bail out one line later.
+ if info.type == 'gcc' and info.version < '4.8.0':
+ raise FatalCheckError(
+ 'Only GCC 4.8 or newer is supported (found version %s).'
+ % info.version)
+
+ # If you want to bump the version check here search for
+ # __cpp_static_assert above, and see the associated comment.
+ if info.type == 'clang' and not info.version:
+ raise FatalCheckError(
+ 'Only clang/llvm 3.6 or newer is supported.')
+
+ if info.type == 'msvc':
+ if info.version < '19.00.24213':
+ raise FatalCheckError(
+ 'This version (%s) of the MSVC compiler is not '
+ 'supported.\n'
+ 'You must install Visual C++ 2015 Update 3 or newer in '
+ 'order to build.\n'
+ 'See https://developer.mozilla.org/en/'
+ 'Windows_Build_Prerequisites' % info.version)
+
+ return namespace(
+ wrapper=wrapper,
+ compiler=compiler,
+ flags=flags,
+ type=info.type,
+ version=info.version,
+ language=language,
+ )
+
+ @depends(valid_compiler)
+ @checking('%s version' % what)
+ def compiler_version(compiler):
+ return compiler.version
+
+ if language == 'C++':
+ @depends(valid_compiler, c_compiler)
+ def valid_compiler(compiler, c_compiler):
+ if compiler.type != c_compiler.type:
+ die('The %s C compiler is %s, while the %s C++ compiler is '
+ '%s. Need to use the same compiler suite.',
+ host_or_target_str, c_compiler.type,
+ host_or_target_str, compiler.type)
+
+ if compiler.version != c_compiler.version:
+ die('The %s C compiler is version %s, while the %s C++ '
+ 'compiler is version %s. Need to use the same compiler '
+ 'version.',
+ host_or_target_str, c_compiler.version,
+ host_or_target_str, compiler.version)
+ return compiler
+
+ # Set CC/CXX/HOST_CC/HOST_CXX for old-configure, which needs the wrapper
+ # and the flags that were part of the user input for those variables to
+ # be provided.
+ add_old_configure_assignment(var, depends_if(valid_compiler)(
+ lambda x: list(x.wrapper) + [x.compiler] + list(x.flags)))
+
+ # Set CC_TYPE/CC_VERSION/HOST_CC_TYPE/HOST_CC_VERSION to allow
+ # old-configure to do some of its still existing checks.
+ if language == 'C':
+ set_config(
+ '%s_TYPE' % var, delayed_getattr(valid_compiler, 'type'))
+ add_old_configure_assignment(
+ '%s_TYPE' % var, delayed_getattr(valid_compiler, 'type'))
+ add_old_configure_assignment(
+ '%s_VERSION' % var, delayed_getattr(valid_compiler, 'version'))
+
+ valid_compiler = compiler_class(valid_compiler)
+
+ def compiler_error():
+ raise FatalCheckError('Failed compiling a simple %s source with %s'
+ % (language, what))
+
+ valid_compiler.try_compile(check_msg='%s works' % what,
+ onerror=compiler_error)
+
+
+ # Set CPP/CXXCPP for both the build system and old-configure. We don't
+ # need to check this works for preprocessing, because we already relied
+ # on $CC -E/$CXX -E doing preprocessing work to validate the compiler
+ # in the first place.
+ if host_or_target == target:
+ pp_var = {
+ 'C': 'CPP',
+ 'C++': 'CXXCPP',
+ }[language]
+
+ preprocessor = depends_if(valid_compiler)(
+ lambda x: list(x.wrapper) + [x.compiler, '-E'] + list(x.flags))
+
+ set_config(pp_var, preprocessor)
+ add_old_configure_assignment(pp_var, preprocessor)
+
+ return valid_compiler
+
+
+c_compiler = compiler('C', target)
+cxx_compiler = compiler('C++', target, c_compiler=c_compiler)
+host_c_compiler = compiler('C', host, other_compiler=c_compiler)
+host_cxx_compiler = compiler('C++', host, c_compiler=host_c_compiler,
+ other_compiler=cxx_compiler,
+ other_c_compiler=c_compiler)
+
+# Generic compiler-based conditions.
+non_msvc_compiler = depends(c_compiler)(lambda info: info.type != 'msvc')
+building_with_gcc = depends(c_compiler)(lambda info: info.type == 'gcc')
+
+include('compile-checks.configure')
+
+@depends(have_64_bit,
+ try_compile(body='static_assert(sizeof(void *) == 8, "")',
+ check_msg='for 64-bit OS'))
+def check_have_64_bit(have_64_bit, compiler_have_64_bit):
+ if have_64_bit != compiler_have_64_bit:
+ configure_error('The target compiler does not agree with configure '
+ 'about the target bitness.')
+
+
+@depends(c_compiler)
+def default_debug_flags(compiler_info):
+ # Debug info is ON by default.
+ if compiler_info.type in ('msvc', 'clang-cl'):
+ return '-Zi'
+ return '-g'
+
+option(env='MOZ_DEBUG_FLAGS',
+ nargs=1,
+ help='Debug compiler flags')
+
+imply_option('--enable-debug-symbols',
+ depends_if('--enable-debug')(lambda v: v))
+
+js_option('--enable-debug-symbols',
+ nargs='?',
+ default=True,
+ help='Enable debug symbols using the given compiler flags')
+
+set_config('MOZ_DEBUG_SYMBOLS',
+ depends_if('--enable-debug-symbols')(lambda _: True))
+
+@depends('MOZ_DEBUG_FLAGS', '--enable-debug-symbols', default_debug_flags)
+def debug_flags(env_debug_flags, enable_debug_flags, default_debug_flags):
+ # If MOZ_DEBUG_FLAGS is set, and --enable-debug-symbols is set to a value,
+ # --enable-debug-symbols takes precedence. Note, the value of
+ # --enable-debug-symbols may be implied by --enable-debug.
+ if len(enable_debug_flags):
+ return enable_debug_flags[0]
+ if env_debug_flags:
+ return env_debug_flags[0]
+ return default_debug_flags
+
+set_config('MOZ_DEBUG_FLAGS', debug_flags)
+add_old_configure_assignment('MOZ_DEBUG_FLAGS', debug_flags)
+
+# Some standard library headers (notably bionic on Android) declare standard
+# functions (e.g. getchar()) and also #define macros for those standard
+# functions. libc++ deals with this by doing something like the following
+# (explanatory comments added):
+#
+# #ifdef FUNC
+# // Capture the definition of FUNC.
+# inline _LIBCPP_INLINE_VISIBILITY int __libcpp_FUNC(...) { return FUNC(...); }
+# #undef FUNC
+# // Use a real inline definition.
+# inline _LIBCPP_INLINE_VISIBILITY int FUNC(...) { return _libcpp_FUNC(...); }
+# #endif
+#
+# _LIBCPP_INLINE_VISIBILITY is typically defined as:
+#
+# __attribute__((__visibility__("hidden"), __always_inline__))
+#
+# Unfortunately, this interacts badly with our system header wrappers, as the:
+#
+# #pragma GCC visibility push(default)
+#
+# that they do prior to including the actual system header is treated by the
+# compiler as an explicit declaration of visibility on every function declared
+# in the header. Therefore, when the libc++ code above is encountered, it is
+# as though the compiler has effectively seen:
+#
+# int FUNC(...) __attribute__((__visibility__("default")));
+# int FUNC(...) __attribute__((__visibility__("hidden")));
+#
+# and the compiler complains about the mismatched visibility declarations.
+#
+# However, libc++ will only define _LIBCPP_INLINE_VISIBILITY if there is no
+# existing definition. We can therefore define it to the empty string (since
+# we are properly managing visibility ourselves) and avoid this whole mess.
+# Note that we don't need to do this with gcc, as libc++ detects gcc and
+# effectively does the same thing we are doing here.
+@depends(c_compiler, target)
+def libcxx_inline_visibility(c_compiler, target):
+ if c_compiler.type == 'clang' and target.os == 'Android':
+ return ''
+
+set_define('_LIBCPP_INLINE_VISIBILITY', libcxx_inline_visibility)
+set_define('_LIBCPP_INLINE_VISIBILITY_EXCEPT_GCC49', libcxx_inline_visibility)
+
+@depends(c_compiler, target, check_build_environment)
+def visibility_flags(c_compiler, target, env):
+ if target.os != 'WINNT':
+ if target.kernel == 'Darwin':
+ return ('-fvisibility=hidden', '-fvisibility-inlines-hidden')
+ return ('-I%s/system_wrappers' % os.path.join(env.dist),
+ '-include',
+ '%s/config/gcc_hidden.h' % env.topsrcdir)
+
+@depends(target, visibility_flags)
+def wrap_system_includes(target, visibility_flags):
+ if visibility_flags and target.kernel != 'Darwin':
+ return True
+
+set_define('HAVE_VISIBILITY_HIDDEN_ATTRIBUTE',
+ depends(visibility_flags)(lambda v: bool(v) or None))
+set_define('HAVE_VISIBILITY_ATTRIBUTE',
+ depends(visibility_flags)(lambda v: bool(v) or None))
+set_config('WRAP_SYSTEM_INCLUDES', wrap_system_includes)
+set_config('VISIBILITY_FLAGS', visibility_flags)
+
+include('windows.configure')
+include('rust.configure')
diff --git a/build/moz.configure/util.configure b/build/moz.configure/util.configure
new file mode 100644
index 000000000..33ed17de6
--- /dev/null
+++ b/build/moz.configure/util.configure
@@ -0,0 +1,440 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+@imports('sys')
+def die(*args):
+ 'Print an error and terminate configure.'
+ log.error(*args)
+ sys.exit(1)
+
+
+@imports(_from='mozbuild.configure', _import='ConfigureError')
+def configure_error(message):
+ '''Raise a programming error and terminate configure.
+ Primarily for use in moz.configure templates to sanity check
+ their inputs from moz.configure usage.'''
+ raise ConfigureError(message)
+
+# A wrapper to obtain a process' output that returns the output generated
+# by running the given command if it exits normally, and streams that
+# output to log.debug and calls die or the given error callback if it
+# does not.
+@imports('subprocess')
+@imports('sys')
+@imports(_from='mozbuild.configure.util', _import='LineIO')
+@imports(_from='mozbuild.shellutil', _import='quote')
+def check_cmd_output(*args, **kwargs):
+ onerror = kwargs.pop('onerror', None)
+
+ with log.queue_debug():
+ log.debug('Executing: `%s`', quote(*args))
+ proc = subprocess.Popen(args, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ stdout, stderr = proc.communicate()
+ retcode = proc.wait()
+ if retcode == 0:
+ return stdout
+
+ log.debug('The command returned non-zero exit status %d.',
+ retcode)
+ for out, desc in ((stdout, 'output'), (stderr, 'error output')):
+ if out:
+ log.debug('Its %s was:', desc)
+ with LineIO(lambda l: log.debug('| %s', l)) as o:
+ o.write(out)
+ if onerror:
+ return onerror()
+ die('Command `%s` failed with exit status %d.' %
+ (quote(*args), retcode))
+
+@imports('os')
+def is_absolute_or_relative(path):
+ if os.altsep and os.altsep in path:
+ return True
+ return os.sep in path
+
+
+@imports(_import='mozpack.path', _as='mozpath')
+def normsep(path):
+ return mozpath.normsep(path)
+
+
+@imports('ctypes')
+@imports(_from='ctypes', _import='wintypes')
+@imports(_from='mozbuild.configure.constants', _import='WindowsBinaryType')
+def windows_binary_type(path):
+ """Obtain the type of a binary on Windows.
+
+ Returns WindowsBinaryType constant.
+ """
+ GetBinaryTypeW = ctypes.windll.kernel32.GetBinaryTypeW
+ GetBinaryTypeW.argtypes = [wintypes.LPWSTR, wintypes.POINTER(wintypes.DWORD)]
+ GetBinaryTypeW.restype = wintypes.BOOL
+
+ bin_type = wintypes.DWORD()
+ res = GetBinaryTypeW(path, ctypes.byref(bin_type))
+ if not res:
+ die('could not obtain binary type of %s' % path)
+
+ if bin_type.value == 0:
+ return WindowsBinaryType('win32')
+ elif bin_type.value == 6:
+ return WindowsBinaryType('win64')
+ # If we see another binary type, something is likely horribly wrong.
+ else:
+ die('unsupported binary type on %s: %s' % (path, bin_type))
+
+
+@imports('ctypes')
+@imports(_from='ctypes', _import='wintypes')
+def get_GetShortPathNameW():
+ GetShortPathNameW = ctypes.windll.kernel32.GetShortPathNameW
+ GetShortPathNameW.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR,
+ wintypes.DWORD]
+ GetShortPathNameW.restype = wintypes.DWORD
+ return GetShortPathNameW
+
+
+@template
+@imports('ctypes')
+@imports('platform')
+@imports(_from='mozbuild.shellutil', _import='quote')
+def normalize_path():
+ # Until the build system can properly handle programs that need quoting,
+ # transform those paths into their short version on Windows (e.g.
+ # c:\PROGRA~1...).
+ if platform.system() == 'Windows':
+ GetShortPathNameW = get_GetShortPathNameW()
+
+ def normalize_path(path):
+ path = normsep(path)
+ if quote(path) == path:
+ return path
+ size = 0
+ while True:
+ out = ctypes.create_unicode_buffer(size)
+ needed = GetShortPathNameW(path, out, size)
+ if size >= needed:
+ if ' ' in out.value:
+ die("GetShortPathName returned a long path name. "
+ "Are 8dot3 filenames disabled?")
+ return normsep(out.value)
+ size = needed
+
+ else:
+ def normalize_path(path):
+ return normsep(path)
+
+ return normalize_path
+
+normalize_path = normalize_path()
+
+
+# Locates the given program using which, or returns the given path if it
+# exists.
+# The `paths` parameter may be passed to search the given paths instead of
+# $PATH.
+@imports(_from='which', _import='which')
+@imports(_from='which', _import='WhichError')
+@imports('itertools')
+@imports(_from='os', _import='pathsep')
+def find_program(file, paths=None):
+ try:
+ if is_absolute_or_relative(file):
+ return normalize_path(which(os.path.basename(file),
+ [os.path.dirname(file)]))
+ if paths:
+ if not isinstance(paths, (list, tuple)):
+ die("Paths provided to find_program must be a list of strings, "
+ "not %r", paths)
+ paths = list(itertools.chain(
+ *(p.split(pathsep) for p in paths if p)))
+ return normalize_path(which(file, path=paths))
+ except WhichError:
+ return None
+
+
+@imports('os')
+@imports('subprocess')
+@imports(_from='mozbuild.configure.util', _import='LineIO')
+@imports(_from='tempfile', _import='mkstemp')
+def try_invoke_compiler(compiler, language, source, flags=None, onerror=None):
+ flags = flags or []
+
+ if not isinstance(flags, (list, tuple)):
+ die("Flags provided to try_compile must be a list of strings, "
+ "not %r", paths)
+
+ suffix = {
+ 'C': '.c',
+ 'C++': '.cpp',
+ }[language]
+
+ fd, path = mkstemp(prefix='conftest.', suffix=suffix)
+ try:
+ source = source.encode('ascii', 'replace')
+
+ log.debug('Creating `%s` with content:', path)
+ with LineIO(lambda l: log.debug('| %s', l)) as out:
+ out.write(source)
+
+ os.write(fd, source)
+ os.close(fd)
+ cmd = compiler + list(flags) + [path]
+ kwargs = {'onerror': onerror}
+ return check_cmd_output(*cmd, **kwargs)
+ finally:
+ os.remove(path)
+
+
+def unique_list(l):
+ result = []
+ for i in l:
+ if l not in result:
+ result.append(i)
+ return result
+
+
+# Get values out of the Windows registry. This function can only be called on
+# Windows.
+# The `pattern` argument is a string starting with HKEY_ and giving the full
+# "path" of the registry key to get the value for, with backslash separators.
+# The string can contains wildcards ('*').
+# The result of this functions is an enumerator yielding tuples for each
+# match. Each of these tuples contains the key name matching wildcards
+# followed by the value.
+#
+# Examples:
+# get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+# r'Windows Kits\Installed Roots\KitsRoot*')
+# yields e.g.:
+# ('KitsRoot81', r'C:\Program Files (x86)\Windows Kits\8.1\')
+# ('KitsRoot10', r'C:\Program Files (x86)\Windows Kits\10\')
+#
+# get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+# r'Windows Kits\Installed Roots\KitsRoot8.1')
+# yields e.g.:
+# (r'C:\Program Files (x86)\Windows Kits\8.1\',)
+#
+# get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+# r'Windows Kits\*\KitsRoot*')
+# yields e.g.:
+# ('Installed Roots', 'KitsRoot81',
+# r'C:\Program Files (x86)\Windows Kits\8.1\')
+# ('Installed Roots', 'KitsRoot10',
+# r'C:\Program Files (x86)\Windows Kits\10\')
+#
+# get_registry_values(r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\'
+# r'VisualStudio\VC\*\x86\*\Compiler')
+# yields e.g.:
+# ('19.0', 'arm', r'C:\...\amd64_arm\cl.exe')
+# ('19.0', 'x64', r'C:\...\amd64\cl.exe')
+# ('19.0', 'x86', r'C:\...\amd64_x86\cl.exe')
+@imports(_import='_winreg', _as='winreg')
+@imports(_from='__builtin__', _import='WindowsError')
+@imports(_from='fnmatch', _import='fnmatch')
+def get_registry_values(pattern):
+ def enum_helper(func, key):
+ i = 0
+ while True:
+ try:
+ yield func(key, i)
+ except WindowsError:
+ break
+ i += 1
+
+ def get_keys(key, pattern):
+ try:
+ s = winreg.OpenKey(key, '\\'.join(pattern[:-1]))
+ except WindowsError:
+ return
+ for k in enum_helper(winreg.EnumKey, s):
+ if fnmatch(k, pattern[-1]):
+ try:
+ yield k, winreg.OpenKey(s, k)
+ except WindowsError:
+ pass
+
+ def get_values(key, pattern):
+ try:
+ s = winreg.OpenKey(key, '\\'.join(pattern[:-1]))
+ except WindowsError:
+ return
+ for k, v, t in enum_helper(winreg.EnumValue, s):
+ if fnmatch(k, pattern[-1]):
+ yield k, v
+
+ def split_pattern(pattern):
+ subpattern = []
+ for p in pattern:
+ subpattern.append(p)
+ if '*' in p:
+ yield subpattern
+ subpattern = []
+ if subpattern:
+ yield subpattern
+
+ pattern = pattern.split('\\')
+ assert pattern[0].startswith('HKEY_')
+ keys = [(getattr(winreg, pattern[0]),)]
+ pattern = list(split_pattern(pattern[1:]))
+ for i, p in enumerate(pattern):
+ next_keys = []
+ for base_key in keys:
+ matches = base_key[:-1]
+ base_key = base_key[-1]
+ if i == len(pattern) - 1:
+ want_name = '*' in p[-1]
+ for name, value in get_values(base_key, p):
+ yield matches + ((name, value) if want_name else (value,))
+ else:
+ for name, k in get_keys(base_key, p):
+ next_keys.append(matches + (name, k))
+ keys = next_keys
+
+
+@imports(_from='mozbuild.configure.util', _import='Version', _as='_Version')
+def Version(v):
+ 'A version number that can be compared usefully.'
+ return _Version(v)
+
+# Denotes a deprecated option. Combines option() and @depends:
+# @deprecated_option('--option')
+# def option(value):
+# ...
+# @deprecated_option() takes the same arguments as option(), except `help`.
+# The function may handle the option like a typical @depends function would,
+# but it is recommended it emits a deprecation error message suggesting an
+# alternative option to use if there is one.
+@template
+def deprecated_option(*args, **kwargs):
+ assert 'help' not in kwargs
+ kwargs['help'] = 'Deprecated'
+ opt = option(*args, **kwargs)
+
+ def decorator(func):
+ @depends(opt.option)
+ def deprecated(value):
+ if value.origin != 'default':
+ return func(value)
+ return deprecated
+
+ return decorator
+
+
+# from mozbuild.util import ReadOnlyNamespace as namespace
+@imports(_from='mozbuild.util', _import='ReadOnlyNamespace')
+def namespace(**kwargs):
+ return ReadOnlyNamespace(**kwargs)
+
+
+# Turn an object into an object that can be used as an argument to @depends.
+# The given object can be a literal value, a function that takes no argument,
+# or, for convenience, a @depends function.
+@template
+@imports(_from='inspect', _import='isfunction')
+@imports(_from='mozbuild.configure', _import='SandboxDependsFunction')
+def dependable(obj):
+ if isinstance(obj, SandboxDependsFunction):
+ return obj
+ if isfunction(obj):
+ return depends(when=True)(obj)
+ return depends(when=True)(lambda: obj)
+
+
+always = dependable(True)
+never = dependable(False)
+
+
+# Some @depends function return namespaces, and one could want to use one
+# specific attribute from such a namespace as a "value" given to functions
+# such as `set_config`. But those functions do not take immediate values.
+# The `delayed_getattr` function allows access to attributes from the result
+# of a @depends function in a non-immediate manner.
+# @depends('--option')
+# def option(value)
+# return namespace(foo=value)
+# set_config('FOO', delayed_getattr(option, 'foo')
+@template
+def delayed_getattr(func, key):
+ @depends(func)
+ def result(value):
+ # The @depends function we're being passed may have returned
+ # None, or an object that simply doesn't have the wanted key.
+ # In that case, just return None.
+ return getattr(value, key, None)
+
+ return result
+
+
+# Like @depends, but the decorated function is only called if one of the
+# arguments it would be called with has a positive value (bool(value) is True)
+@template
+def depends_if(*args):
+ def decorator(func):
+ @depends(*args)
+ def wrapper(*args):
+ if any(arg for arg in args):
+ return func(*args)
+ return wrapper
+ return decorator
+
+# Like @depends_if, but a distinguished value passed as a keyword argument
+# "when" is truth tested instead of every argument. This value is not passed
+# to the function if it is called.
+@template
+def depends_when(*args, **kwargs):
+ if not len(kwargs) == 1 and kwargs.get('when'):
+ die('depends_when requires a single keyword argument, "when"')
+ when = kwargs['when']
+ if not when:
+ return depends(*args)
+
+ def decorator(fn):
+ @depends(when, *args)
+ def wrapper(val, *args):
+ if val:
+ return fn(*args)
+ return wrapper
+ return decorator
+
+
+# Hacks related to old-configure
+# ==============================
+
+@dependable
+def old_configure_assignments():
+ return []
+
+@dependable
+def extra_old_configure_args():
+ return []
+
+@template
+def add_old_configure_assignment(var, value):
+ var = dependable(var)
+ value = dependable(value)
+
+ @depends(old_configure_assignments, var, value)
+ @imports(_from='mozbuild.shellutil', _import='quote')
+ def add_assignment(assignments, var, value):
+ if var is None or value is None:
+ return
+ if value is True:
+ assignments.append('%s=1' % var)
+ elif value is False:
+ assignments.append('%s=' % var)
+ else:
+ if isinstance(value, (list, tuple)):
+ value = quote(*value)
+ assignments.append('%s=%s' % (var, quote(str(value))))
+
+@template
+def add_old_configure_arg(arg):
+ @depends(extra_old_configure_args, arg)
+ def add_arg(args, arg):
+ if arg:
+ args.append(arg)
diff --git a/build/moz.configure/warnings.configure b/build/moz.configure/warnings.configure
new file mode 100644
index 000000000..273a41bd9
--- /dev/null
+++ b/build/moz.configure/warnings.configure
@@ -0,0 +1,111 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+js_option('--enable-warnings-as-errors', env='MOZ_ENABLE_WARNINGS_AS_ERRORS',
+ default=depends('MOZ_AUTOMATION', '--help')(lambda x, _: bool(x)),
+ help='Enable treating warnings as errors')
+
+add_old_configure_assignment(
+ 'MOZ_ENABLE_WARNINGS_AS_ERRORS',
+ depends('--enable-warnings-as-errors')(lambda x: bool(x)))
+
+
+# GCC/Clang warnings:
+# https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Warning-Options.html
+
+# lots of useful warnings
+add_gcc_warning('-Wall')
+
+# catches C++ version forward-compat issues
+add_gcc_warning('-Wc++11-compat', cxx_compiler)
+
+# catches bugs, e.g. "if (c); foo();", few false positives
+add_gcc_warning('-Wempty-body')
+
+# catches return types with qualifiers like const
+add_gcc_warning('-Wignored-qualifiers')
+
+# function declaration hides virtual function from base class
+add_gcc_warning('-Woverloaded-virtual', cxx_compiler)
+
+# catches pointer arithmetic using NULL or sizeof(void)
+add_gcc_warning('-Wpointer-arith')
+
+# catches comparing signed/unsigned ints
+add_gcc_warning('-Wsign-compare')
+
+# catches overflow bugs, few false positives
+add_gcc_warning('-Wtype-limits')
+
+# catches some dead code
+add_gcc_warning('-Wunreachable-code')
+
+# catches treating string literals as non-const
+add_gcc_warning('-Wwrite-strings', cxx_compiler)
+
+# turned on by -Wall, but we use offsetof on non-POD types frequently
+add_gcc_warning('-Wno-invalid-offsetof', cxx_compiler)
+
+# catches objects passed by value to variadic functions.
+check_and_add_gcc_warning('-Wclass-varargs')
+
+# catches issues around loops
+check_and_add_gcc_warning('-Wloop-analysis')
+
+# catches C++ version forward-compat issues
+check_and_add_gcc_warning('-Wc++11-compat-pedantic', cxx_compiler)
+check_and_add_gcc_warning('-Wc++14-compat', cxx_compiler)
+check_and_add_gcc_warning('-Wc++14-compat-pedantic', cxx_compiler)
+check_and_add_gcc_warning('-Wc++1z-compat', cxx_compiler)
+
+# catches unintentional switch case fallthroughs
+check_and_add_gcc_warning('-Wimplicit-fallthrough', cxx_compiler)
+
+# catches expressions used as a null pointer constant
+# XXX: at the time of writing, the version of clang used on the OS X test
+# machines has a bug that causes it to reject some valid files if both
+# -Wnon-literal-null-conversion and -Wsometimes-uninitialized are
+# specified. We work around this by instead using
+# -Werror=non-literal-null-conversion, but we only do that when
+# --enable-warnings-as-errors is specified so that no unexpected fatal
+# warnings are produced.
+check_and_add_gcc_warning('-Werror=non-literal-null-conversion',
+ when='--enable-warnings-as-errors')
+
+# catches string literals used in boolean expressions
+check_and_add_gcc_warning('-Wstring-conversion')
+
+# catches inconsistent use of mutexes
+check_and_add_gcc_warning('-Wthread-safety')
+
+# we inline 'new' and 'delete' in mozalloc
+check_and_add_gcc_warning('-Wno-inline-new-delete', cxx_compiler)
+
+# Prevent the following GCC warnings from being treated as errors:
+# too many false positives
+check_and_add_gcc_warning('-Wno-error=maybe-uninitialized')
+
+# we don't want our builds held hostage when a platform-specific API
+# becomes deprecated.
+check_and_add_gcc_warning('-Wno-error=deprecated-declarations')
+
+# false positives depending on optimization
+check_and_add_gcc_warning('-Wno-error=array-bounds')
+
+# can't get rid of those PGO warnings
+check_and_add_gcc_warning('-Wno-error=coverage-mismatch', when='MOZ_PGO')
+
+# false positives during PGO
+check_and_add_gcc_warning('-Wno-error=free-nonheap-object', when='MOZ_PGO')
+
+# We use mix of both POSIX and Win32 printf format across the tree, so format
+# warnings are useless on mingw.
+check_and_add_gcc_warning('-Wno-format',
+ when=depends(target)(lambda t: t.kernel == 'WINNT'))
+
+# Please keep these last in this file
+add_old_configure_assignment('_WARNINGS_CFLAGS', warnings_cflags)
+add_old_configure_assignment('_WARNINGS_CXXFLAGS', warnings_cxxflags)
diff --git a/build/moz.configure/windows.configure b/build/moz.configure/windows.configure
new file mode 100644
index 000000000..b9a3898a1
--- /dev/null
+++ b/build/moz.configure/windows.configure
@@ -0,0 +1,431 @@
+# -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+option('--with-windows-version', nargs=1, default='603',
+ help='Windows SDK version to target. Win 8.1 (603) is currently'
+ 'the minimum supported version.')
+
+@depends(target)
+def is_windows(target):
+ return target.kernel == 'WINNT'
+
+
+@template
+def depends_win(*args):
+ return depends_when(*args, when=is_windows)
+
+
+@depends_win('--with-windows-version')
+@imports(_from='__builtin__', _import='ValueError')
+def valid_windows_version(value):
+ if not value:
+ die('Cannot build with --without-windows-version')
+ try:
+ version = int(value[0], 16)
+ if version in (0x603,):
+ return version
+ except ValueError:
+ pass
+
+ die('Invalid value for --with-windows-version (%s)', value[0])
+
+
+option(env='WINDOWSSDKDIR', nargs=1,
+ help='Directory containing the Windows SDK')
+
+@depends_win('WINDOWSSDKDIR', host)
+def windows_sdk_dir(value, host):
+ if value:
+ return value
+ if host.kernel != 'WINNT':
+ return ()
+
+ return tuple(x[1] for x in get_registry_values(
+ r'HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows Kits\Installed Roots'
+ r'\KitsRoot*'))
+
+# The Windows SDK 8.1 and 10 have different layouts. The former has
+# $SDK/include/$subdir, while the latter has $SDK/include/$version/$subdir.
+# The vcvars* scripts don't actually care about the version, they just take
+# the last alphanumerically.
+# The $SDK/lib directories always have version subdirectories, but while the
+# versions match the one in $SDK/include for SDK 10, it's "winv6.3" for SDK
+# 8.1.
+@imports('os')
+@imports('re')
+@imports(_from='__builtin__', _import='sorted')
+@imports(_from='__builtin__', _import='WindowsError')
+def get_sdk_dirs(sdk, subdir):
+ def get_dirs_containing(sdk, stem, subdir):
+ base = os.path.join(sdk, stem)
+ try:
+ subdirs = [d for d in os.listdir(base)
+ if os.path.isdir(os.path.join(base, d))]
+ except WindowsError:
+ subdirs = []
+ if not subdirs:
+ return ()
+ if subdir in subdirs:
+ return (base,)
+ # At this point, either we have an incomplete or invalid SDK directory,
+ # or we exclusively have version numbers in subdirs.
+ return tuple(os.path.join(base, s) for s in subdirs
+ if os.path.isdir(os.path.join(base, s, subdir)))
+
+ def categorize(dirs):
+ return {os.path.basename(d): d for d in dirs}
+
+ include_dirs = categorize(get_dirs_containing(sdk, 'include', subdir))
+ lib_dirs = categorize(get_dirs_containing(sdk, 'lib', subdir))
+
+ if 'include' in include_dirs:
+ include_dirs['winv6.3'] = include_dirs['include']
+ del include_dirs['include']
+
+ valid_versions = sorted(set(include_dirs) & set(lib_dirs), reverse=True)
+ if valid_versions:
+ return namespace(
+ path=sdk,
+ lib=lib_dirs[valid_versions[0]],
+ include=include_dirs[valid_versions[0]],
+ )
+
+
+@imports(_from='mozbuild.shellutil', _import='quote')
+def valid_windows_sdk_dir_result(value):
+ if value:
+ return '0x%04x in %s' % (value.version, quote(value.path))
+
+@depends_win(c_compiler, windows_sdk_dir, valid_windows_version,
+ 'WINDOWSSDKDIR')
+@checking('for Windows SDK', valid_windows_sdk_dir_result)
+@imports(_from='__builtin__', _import='sorted')
+@imports(_from='textwrap', _import='dedent')
+def valid_windows_sdk_dir(compiler, windows_sdk_dir, target_version,
+ windows_sdk_dir_env):
+ if windows_sdk_dir_env:
+ windows_sdk_dir_env = windows_sdk_dir_env[0]
+ sdks = {}
+ for d in windows_sdk_dir:
+ sdk = get_sdk_dirs(d, 'um')
+ if sdk:
+ check = dedent('''\
+ #include <winsdkver.h>
+ WINVER_MAXVER
+ ''')
+ um_dir = os.path.join(sdk.include, 'um')
+ shared_dir = os.path.join(sdk.include, 'shared')
+ result = try_preprocess(compiler.wrapper + [compiler.compiler] +
+ compiler.flags +
+ ['-I', um_dir, '-I', shared_dir], 'C',
+ check)
+ if result:
+ maxver = result.splitlines()[-1]
+ try:
+ maxver = int(maxver, 0)
+ except:
+ pass
+ else:
+ sdks[d] = maxver, sdk
+ continue
+ if d == windows_sdk_dir_env:
+ raise FatalCheckError(
+ 'Error while checking the version of the SDK in '
+ 'WINDOWSSDKDIR (%s). Please verify it contains a valid and '
+ 'complete SDK installation.' % windows_sdk_dir_env)
+
+ valid_sdks = sorted(sdks, key=lambda x: sdks[x][0], reverse=True)
+ if valid_sdks:
+ biggest_version, sdk = sdks[valid_sdks[0]]
+ if not valid_sdks or biggest_version < target_version:
+ if windows_sdk_dir_env:
+ raise FatalCheckError(
+ 'You are targeting Windows version 0x%04x, but your SDK only '
+ 'supports up to version 0x%04x. Install and use an updated SDK, '
+ 'or target a lower version using --with-windows-version. '
+ 'Alternatively, try running the Windows SDK Configuration Tool '
+ 'and selecting a newer SDK. See '
+ 'https://developer.mozilla.org/En/Windows_SDK_versions for '
+ 'details on fixing this.' % (target_version, biggest_version))
+
+ raise FatalCheckError(
+ 'Cannot find a Windows SDK for version >= 0x%04x.' % target_version)
+
+ return namespace(
+ path=sdk.path,
+ include=sdk.include,
+ lib=sdk.lib,
+ version=biggest_version,
+ )
+
+
+add_old_configure_assignment(
+ 'WINDOWSSDKDIR',
+ delayed_getattr(valid_windows_sdk_dir, 'path'))
+add_old_configure_assignment(
+ 'MOZ_WINSDK_MAXVER',
+ depends(valid_windows_sdk_dir)(
+ lambda x: '0x%04X0000' % x.version if x else None))
+
+
+@imports(_from='mozbuild.shellutil', _import='quote')
+def valid_ucrt_sdk_dir_result(value):
+ if value:
+ return '%s in %s' % (value.version, quote(value.path))
+
+@depends_win(windows_sdk_dir, 'WINDOWSSDKDIR')
+@checking('for Universal CRT SDK', valid_ucrt_sdk_dir_result)
+@imports('os')
+@imports(_from='__builtin__', _import='sorted')
+@imports(_import='mozpack.path', _as='mozpath')
+def valid_ucrt_sdk_dir(windows_sdk_dir, windows_sdk_dir_env):
+ if windows_sdk_dir_env:
+ windows_sdk_dir_env = windows_sdk_dir_env[0]
+ sdks = {}
+ for d in windows_sdk_dir:
+ sdk = get_sdk_dirs(d, 'ucrt')
+ if sdk:
+ version = os.path.basename(sdk.include)
+ # We're supposed to always find a version in the directory, because
+ # the 8.1 SDK, which doesn't have a version in the directory, doesn't
+ # contain the Universal CRT SDK. When the main SDK is 8.1, there
+ # is, however, supposed to be a reduced install of the SDK 10
+ # with the UCRT.
+ if version != 'include':
+ sdks[d] = Version(version), sdk
+ continue
+ if d == windows_sdk_dir_env:
+ # When WINDOWSSDKDIR is set in the environment and we can't find the
+ # Universal CRT SDK, chances are this is a start-shell-msvc*.bat
+ # setup, where INCLUDE and LIB already contain the UCRT paths.
+ ucrt_includes = [
+ p for p in os.environ.get('INCLUDE', '').split(os.pathsep)
+ if os.path.basename(p).lower() == 'ucrt'
+ ]
+ ucrt_libs = [
+ p for p in os.environ.get('LIB', '').split(os.pathsep)
+ if os.path.basename(os.path.dirname(p)).lower() == 'ucrt'
+ ]
+ if ucrt_includes and ucrt_libs:
+ # Pick the first of each, since they are the ones that the
+ # compiler would look first. Assume they contain the SDK files.
+ include = os.path.dirname(ucrt_includes[0])
+ lib = os.path.dirname(os.path.dirname(ucrt_libs[0]))
+ path = os.path.dirname(os.path.dirname(include))
+ version = os.path.basename(include)
+ if version != 'include' and mozpath.basedir(lib, [path]):
+ sdks[d] = Version(version), namespace(
+ path=path,
+ include=include,
+ lib=lib,
+ )
+ continue
+ raise FatalCheckError(
+ 'The SDK in WINDOWSSDKDIR (%s) does not contain the Universal '
+ 'CRT.' % windows_sdk_dir_env)
+
+ valid_sdks = sorted(sdks, key=lambda x: sdks[x][0], reverse=True)
+ if not valid_sdks:
+ raise FatalCheckError('Cannot find the Universal CRT SDK. '
+ 'Please install it.')
+
+ version, sdk = sdks[valid_sdks[0]]
+
+ return namespace(
+ path=sdk.path,
+ include=sdk.include,
+ lib=sdk.lib,
+ version=version,
+ )
+
+
+@depends_win(c_compiler)
+@imports('os')
+def vc_path(c_compiler):
+ if c_compiler.type != 'msvc':
+ return
+ # Normally, we'd start from c_compiler.compiler, but for now, it's not the
+ # ideal full path to the compiler. At least, we're guaranteed find_program
+ # will get us the one we found in toolchain.configure.
+ cl = find_program(c_compiler.compiler)
+ result = os.path.dirname(cl)
+ while True:
+ next, p = os.path.split(result)
+ if next == result:
+ die('Cannot determine the Visual C++ directory the compiler (%s) '
+ 'is in' % cl)
+ result = next
+ if p.lower() == 'bin':
+ break
+ return result
+
+
+@depends_win(vc_path)
+@checking('for the Debug Interface Access SDK', lambda x: x or 'not found')
+@imports(_from='os.path', _import='isdir')
+def dia_sdk_dir(vc_path):
+ if vc_path:
+ path = os.path.join(os.path.dirname(vc_path), 'DIA SDK')
+ if isdir(path):
+ return path
+
+
+@depends_win(vc_path, valid_windows_sdk_dir, valid_ucrt_sdk_dir, dia_sdk_dir)
+@imports('os')
+def include_path(vc_path, windows_sdk_dir, ucrt_sdk_dir, dia_sdk_dir):
+ if not vc_path:
+ return
+ atlmfc_dir = os.path.join(vc_path, 'atlmfc', 'include')
+ if not os.path.isdir(atlmfc_dir):
+ die('Cannot find the ATL/MFC headers in the Visual C++ directory (%s). '
+ 'Please install them.' % vc_path)
+
+ winrt_dir = os.path.join(windows_sdk_dir.include, 'winrt')
+ if not os.path.isdir(winrt_dir):
+ die('Cannot find the WinRT headers in the Windows SDK directory (%s). '
+ 'Please install them.' % windows_sdk_dir.path)
+
+ includes = []
+ include_env = os.environ.get('INCLUDE')
+ if include_env:
+ includes.append(include_env)
+ includes.extend((
+ os.path.join(vc_path, 'include'),
+ atlmfc_dir,
+ os.path.join(windows_sdk_dir.include, 'shared'),
+ os.path.join(windows_sdk_dir.include, 'um'),
+ winrt_dir,
+ os.path.join(ucrt_sdk_dir.include, 'ucrt'),
+ ))
+ if dia_sdk_dir:
+ includes.append(os.path.join(dia_sdk_dir, 'include'))
+ # Set in the environment for old-configure
+ includes = os.pathsep.join(includes)
+ os.environ['INCLUDE'] = includes
+ return includes
+
+set_config('INCLUDE', include_path)
+
+
+@depends_win(target, vc_path, valid_windows_sdk_dir, valid_ucrt_sdk_dir, dia_sdk_dir)
+@imports('os')
+def lib_path(target, vc_path, windows_sdk_dir, ucrt_sdk_dir, dia_sdk_dir):
+ if not vc_path:
+ return
+ vc_target = {
+ 'x86': '',
+ 'x86_64': 'amd64',
+ 'arm': 'arm',
+ }.get(target.cpu)
+ if vc_target is None:
+ return
+ # As vc_target can be '', and os.path.join will happily use the empty
+ # string, leading to a string ending with a backslash, that Make will
+ # interpret as a "string continues on next line" indicator, use variable
+ # args.
+ vc_target = (vc_target,) if vc_target else ()
+ sdk_target = {
+ 'x86': 'x86',
+ 'x86_64': 'x64',
+ 'arm': 'arm',
+ }.get(target.cpu)
+
+ atlmfc_dir = os.path.join(vc_path, 'atlmfc', 'lib', *vc_target)
+ if not os.path.isdir(atlmfc_dir):
+ die('Cannot find the ATL/MFC libraries in the Visual C++ directory (%s). '
+ 'Please install them.' % vc_path)
+
+
+ libs = []
+ lib_env = os.environ.get('LIB')
+ if lib_env:
+ libs.append(lib_env)
+ libs.extend((
+ os.path.join(vc_path, 'lib', *vc_target),
+ atlmfc_dir,
+ os.path.join(windows_sdk_dir.lib, 'um', sdk_target),
+ os.path.join(ucrt_sdk_dir.lib, 'ucrt', sdk_target),
+ ))
+ if dia_sdk_dir:
+ libs.append(os.path.join(dia_sdk_dir, 'lib', *vc_target))
+ # Set in the environment for old-configure
+ libs = os.pathsep.join(libs)
+ os.environ['LIB'] = libs
+ return libs
+
+set_config('LIB', lib_path)
+
+
+option(env='MT', nargs=1, help='Path to the Microsoft Manifest Tool')
+
+@depends_win(valid_windows_sdk_dir)
+@imports(_from='os', _import='environ')
+@imports('platform')
+def sdk_bin_path(valid_windows_sdk_dir):
+ if not valid_windows_sdk_dir:
+ return
+
+ vc_host = {
+ 'x86': 'x86',
+ 'AMD64': 'x64',
+ }.get(platform.machine())
+
+ result = [
+ environ['PATH'],
+ os.path.join(valid_windows_sdk_dir.path, 'bin', vc_host)
+ ]
+ if vc_host == 'x64':
+ result.append(
+ os.path.join(valid_windows_sdk_dir.path, 'bin', 'x86'))
+ return result
+
+
+mt = check_prog('MT', depends_win()(lambda: ('mt.exe',)), input='MT',
+ paths=sdk_bin_path)
+
+
+# Check that MT is not something unexpected like "magnetic tape manipulation
+# utility".
+@depends_win(mt)
+@checking('whether MT is really Microsoft Manifest Tool', lambda x: bool(x))
+@imports('subprocess')
+def valid_mt(path):
+ try:
+ out = subprocess.check_output([path]).splitlines()
+ out = '\n'.join(l for l in out
+ if 'Microsoft (R) Manifest Tool' in l)
+ if out:
+ return path
+ except subprocess.CalledProcessError:
+ pass
+ raise FatalCheckError('%s is not Microsoft Manifest Tool')
+
+
+set_config('MSMANIFEST_TOOL', depends(valid_mt)(lambda x: bool(x)))
+
+
+# Ultimately, this will move to toolchain.configure and be turned into a
+# cross-platform check.
+option(env='LD', nargs=1, help='Path to the linker')
+
+link = check_prog('LINK', depends_win()(lambda: ('link.exe',)), input='LD',
+ paths=vc_compiler_path)
+
+add_old_configure_assignment('LD', depends_win(link)(lambda x: x))
+
+
+# Normally, we'd just have CC, etc. set to absolute paths, but the build system
+# doesn't currently handle properly the case where the paths contain spaces.
+# Additionally, there's the issue described in toolchain.configure, in
+# valid_compiler().
+@depends_win(sdk_bin_path)
+@imports('os')
+def alter_path(sdk_bin_path):
+ path = os.pathsep.join(sdk_bin_path)
+ os.environ['PATH'] = path
+ return path
+
+set_config('PATH', alter_path)