--- a/build/moz.configure/toolchain.configure
+++ b/build/moz.configure/toolchain.configure
@@ -409,16 +409,27 @@ def get_compiler_info(compiler, language
     check += dedent('''\
         #if _MSC_VER || __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
         %ENDIANNESS "little"
         #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
         %ENDIANNESS "big"
         #endif
     ''')
 
+    # Try including a header to ensure that cross-compilers are set up
+    # correctly.
+    header = {
+        'C': 'stddef.h',
+        'C++': 'cstddef',
+    }[language]
+
+    check += dedent('''\
+        #include <%(header)s>
+    ''' % {'header': header})
+
     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.
@@ -800,33 +811,37 @@ def compiler(language, host_or_target, c
     # Normally, we'd use `var` instead of `_var`, but the interaction with
     # old-configure complicates things, and for now, we a) can't take the plain
     # result from check_prog as CC/CXX/HOST_CC/HOST_CXX and b) have to let
     # old-configure AC_SUBST it (because it's autoconf doing it, not us)
     compiler = check_prog('_%s' % var, what=what, progs=default_compilers,
                           input=provided_compiler.compiler,
                           paths=toolchain_search_path)
 
-    @depends(compiler, provided_compiler, compiler_wrapper, host_or_target)
+    @depends(compiler, provided_compiler, compiler_wrapper, host_or_target,
+             extra_toolchain_flags)
     @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):
+                       host_or_target, extra_flags):
         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 = []
+        toolchain_flags = []
+        if host_or_target_str == 'target' and extra_flags:
+            toolchain_flags = extra_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:
@@ -838,29 +853,30 @@ def compiler(language, host_or_target, c
                     % 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)
+        info = check_compiler(wrapper + [compiler] + flags + toolchain_flags,
+                              language, host_or_target)
 
         # Check that the additional flags we got are enough to not require any
         # more flags. If we get an exception, just ignore it; it's liable to be
         # invalid command-line flags, which means the compiler we're checking
         # doesn't support those command-line flags and will fail one or more of
         # the checks below.
         try:
             if info.flags:
                 flags += info.flags
-                info = check_compiler(wrapper + [compiler] + flags, language,
-                                      host_or_target)
+                info = check_compiler(wrapper + [compiler] + flags +
+                                      toolchain_flags,
+                                      language, host_or_target)
         except FatalCheckError:
             pass
 
         if not info.target_cpu or info.target_cpu != host_or_target.cpu:
             raise FatalCheckError(
                 '%s %s compiler target CPU (%s) does not match --%s CPU (%s)'
                 % (host_or_target_str.capitalize(), language,
                    info.target_cpu or 'unknown', host_or_target_str,

--- a/python/mozbuild/mozbuild/test/configure/test_toolchain_helpers.py
+++ b/python/mozbuild/mozbuild/test/configure/test_toolchain_helpers.py
@@ -56,16 +56,30 @@ class CompilerPreprocessor(Preprocessor)
             for k, v in context.iteritems()
         )
         try:
             return Preprocessor.do_if(self, normalize_has_feature(expression),
                                       **kwargs)
         finally:
             self.context = context
 
+    def do_include(self, args, filters=True):
+        # We need to check headers during normal configure to make sure the
+        # user doesn't have a misconfigured environment.  But for the purposes
+        # of tests, we want to ignore headers.
+
+        # stddef.h and cstddef are the headers compiler configure checks use.
+        if type(args) in (str, unicode) and '<' in args:
+            if args in ('<stddef.h>', '<cstddef>'):
+                return
+            raise Preprocessor.Error(self, 'INVALID_INCLUDE_FILE', args)
+
+        # Pass everything else through.
+        Preprocessor.do_include(self, args, filters)
+
     class Context(dict):
         def __missing__(self, key):
             return None
 
     def filter_c_substitution(self, line):
         def repl(matchobj):
             varname = matchobj.group('VAR')
             if varname in self.context: