Backed out 2 changesets (bug 1524429) for build bustages at lint.py on a CLOSED TREE
authorAndreea Pavel <apavel@mozilla.com>
Wed, 20 Mar 2019 02:16:41 +0200
changeset 465155 fece5bb7e809fd3a7dd960ad9c0df9167b27fecc
parent 465154 7beefe9e4d811305370548773956f56c5cc74fd5
child 465156 19b8243cbd30a962e691bf53c5f93e76166fa4ce
push id112493
push useropoprus@mozilla.com
push dateWed, 20 Mar 2019 11:12:22 +0000
treeherdermozilla-inbound@e1350f7a1914 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1524429
milestone68.0a1
backs out7947b90f15808c0de5673831950fe2886558d23c
1a5a5aef01d5b745fa7ebd0185556b01f16b7c4f
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 2 changesets (bug 1524429) for build bustages at lint.py on a CLOSED TREE Backed out changeset 7947b90f1580 (bug 1524429) Backed out changeset 1a5a5aef01d5 (bug 1524429)
build/autoconf/arch.m4
build/moz.configure/arm.configure
build/moz.configure/old.configure
build/moz.configure/toolchain.configure
js/src/old-configure.in
old-configure.in
--- a/build/autoconf/arch.m4
+++ b/build/autoconf/arch.m4
@@ -1,15 +1,272 @@
 dnl This Source Code Form is subject to the terms of the Mozilla Public
 dnl License, v. 2.0. If a copy of the MPL was not distributed with this
 dnl file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 AC_DEFUN([MOZ_ARCH_OPTS],
 [
-if test -n "$_ARM_FLAGS"; then
-    CFLAGS="$CFLAGS $_ARM_FLAGS"
-    CXXFLAGS="$CXXFLAGS $_ARM_FLAGS"
-    ASFLAGS="$ASFLAGS $_ARM_FLAGS"
-    if test -n "$_THUMB_FLAGS"; then
-        LDFLAGS="$LDFLAGS $_THUMB_FLAGS"
+
+dnl ========================================================
+dnl = ARM toolchain tweaks
+dnl ========================================================
+
+MOZ_THUMB=toolchain-default
+MOZ_THUMB_INTERWORK=toolchain-default
+MOZ_FPU=toolchain-default
+MOZ_FLOAT_ABI=toolchain-default
+MOZ_SOFT_FLOAT=toolchain-default
+MOZ_ALIGN=toolchain-default
+
+MOZ_ARG_WITH_STRING(arch,
+[  --with-arch=[[type|toolchain-default]]
+                           Use specific CPU features (-march=type). Resets
+                           thumb, fpu, float-abi, etc. defaults when set],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-arch is not supported on non-GNU toolchains])
+    fi
+    MOZ_ARCH=$withval)
+
+if test -z "$MOZ_ARCH"; then
+    dnl Defaults
+    case "${CPU_ARCH}-${OS_TARGET}" in
+    arm-Android)
+        MOZ_THUMB=yes
+        MOZ_ARCH=armv7-a
+        MOZ_FPU=neon
+        MOZ_FLOAT_ABI=softfp
+        MOZ_ALIGN=no
+        ;;
+    arm-Darwin)
+        MOZ_ARCH=toolchain-default
+        ;;
+    esac
+fi
+
+if test "$MOZ_ARCH" = "armv6" -a "$OS_TARGET" = "Android"; then
+    AC_MSG_ERROR([Android/armv6 is not supported])
+fi
+
+MOZ_ARG_WITH_STRING(thumb,
+[  --with-thumb[[=yes|no|toolchain-default]]]
+[                          Use Thumb instruction set (-mthumb)],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-thumb is not supported on non-GNU toolchains])
+    fi
+    MOZ_THUMB=$withval)
+
+MOZ_ARG_WITH_STRING(thumb-interwork,
+[  --with-thumb-interwork[[=yes|no|toolchain-default]]
+                           Use Thumb/ARM instuctions interwork (-mthumb-interwork)],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-thumb-interwork is not supported on non-GNU toolchains])
+    fi
+    MOZ_THUMB_INTERWORK=$withval)
+
+MOZ_ARG_WITH_STRING(fpu,
+[  --with-fpu=[[type|toolchain-default]]
+                           Use specific FPU type (-mfpu=type)],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-fpu is not supported on non-GNU toolchains])
+    fi
+    MOZ_FPU=$withval)
+
+MOZ_ARG_WITH_STRING(float-abi,
+[  --with-float-abi=[[type|toolchain-default]]
+                           Use specific arm float ABI (-mfloat-abi=type)],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-float-abi is not supported on non-GNU toolchains])
+    fi
+    MOZ_FLOAT_ABI=$withval)
+
+MOZ_ARG_WITH_STRING(soft-float,
+[  --with-soft-float[[=yes|no|toolchain-default]]
+                           Use soft float library (-msoft-float)],
+    if test -z "$GNU_CC"; then
+        AC_MSG_ERROR([--with-soft-float is not supported on non-GNU toolchains])
+    fi
+    MOZ_SOFT_FLOAT=$withval)
+
+case "$MOZ_ARCH" in
+toolchain-default|"")
+    arch_flag=""
+    ;;
+*)
+    arch_flag="-march=$MOZ_ARCH"
+    ;;
+esac
+
+case "$MOZ_THUMB" in
+yes)
+    MOZ_THUMB2=1
+    thumb_flag="-mthumb"
+    ;;
+no)
+    MOZ_THUMB2=
+    thumb_flag="-marm"
+    ;;
+*)
+    _SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="$arch_flag"
+    AC_TRY_COMPILE([],[return sizeof(__thumb2__);],
+        MOZ_THUMB2=1,
+        MOZ_THUMB2=)
+    CFLAGS="$_SAVE_CFLAGS"
+    thumb_flag=""
+    ;;
+esac
+
+if test "$MOZ_THUMB2" = 1; then
+    AC_DEFINE(MOZ_THUMB2)
+fi
+
+case "$MOZ_THUMB_INTERWORK" in
+yes)
+    thumb_interwork_flag="-mthumb-interwork"
+    ;;
+no)
+    thumb_interwork_flag="-mno-thumb-interwork"
+    ;;
+*) # toolchain-default
+    thumb_interwork_flag=""
+    ;;
+esac
+
+case "$MOZ_FPU" in
+toolchain-default|"")
+    fpu_flag=""
+    ;;
+*)
+    fpu_flag="-mfpu=$MOZ_FPU"
+    ;;
+esac
+
+case "$MOZ_FLOAT_ABI" in
+toolchain-default|"")
+    float_abi_flag=""
+    ;;
+*)
+    float_abi_flag="-mfloat-abi=$MOZ_FLOAT_ABI"
+    ;;
+esac
+
+case "$MOZ_SOFT_FLOAT" in
+yes)
+    soft_float_flag="-msoft-float"
+    ;;
+no)
+    soft_float_flag="-mno-soft-float"
+    ;;
+*) # toolchain-default
+    soft_float_flag=""
+    ;;
+esac
+
+case "$MOZ_ALIGN" in
+no)
+    align_flag="-mno-unaligned-access"
+    ;;
+yes)
+    align_flag="-munaligned-access"
+    ;;
+*)
+    align_flag=""
+    ;;
+esac
+
+if test -n "$align_flag"; then
+  _SAVE_CFLAGS="$CFLAGS"
+  CFLAGS="$CFLAGS $align_flag"
+  AC_MSG_CHECKING(whether alignment flag ($align_flag) is supported)
+  AC_TRY_COMPILE([],[],,align_flag="")
+  CFLAGS="$_SAVE_CFLAGS"
+fi
+
+dnl Use echo to avoid accumulating space characters
+all_flags=`echo $arch_flag $thumb_flag $thumb_interwork_flag $fpu_flag $float_abi_flag $soft_float_flag $align_flag`
+if test -n "$all_flags"; then
+    _SAVE_CFLAGS="$CFLAGS"
+    CFLAGS="$all_flags"
+    AC_MSG_CHECKING(whether the chosen combination of compiler flags ($all_flags) works)
+    AC_TRY_COMPILE([],[return 0;],
+        AC_MSG_RESULT([yes]),
+        AC_MSG_ERROR([no]))
+
+    CFLAGS="$_SAVE_CFLAGS $all_flags"
+    CXXFLAGS="$CXXFLAGS $all_flags"
+    ASFLAGS="$ASFLAGS $all_flags"
+    if test -n "$thumb_flag"; then
+        LDFLAGS="$LDFLAGS $thumb_flag"
     fi
 fi
+
+AC_SUBST(MOZ_THUMB2)
+
+if test "$CPU_ARCH" = "arm"; then
+  NEON_FLAGS="-mfpu=neon"
+  AC_MSG_CHECKING(for ARM SIMD support in compiler)
+  # We try to link so that this also fails when
+  # building with LTO.
+  AC_TRY_LINK([],
+                 [asm("uqadd8 r1, r1, r2");],
+                 result="yes", result="no")
+  AC_MSG_RESULT("$result")
+  if test "$result" = "yes"; then
+      AC_DEFINE(HAVE_ARM_SIMD)
+      HAVE_ARM_SIMD=1
+  fi
+
+  AC_MSG_CHECKING(ARM version support in compiler)
+  dnl Determine the target ARM architecture (5 for ARMv5, v5T, v5E, etc.; 6 for ARMv6, v6K, etc.)
+  ARM_ARCH=`${CC-cc} ${CFLAGS} -dM -E - < /dev/null | sed -n 's/.*__ARM_ARCH_\([[0-9]][[0-9]]*\).*/\1/p' | head -n 1`
+  AC_MSG_RESULT("$ARM_ARCH")
+
+  AC_MSG_CHECKING(for ARM NEON support in compiler)
+  # We try to link so that this also fails when
+  # building with LTO.
+  AC_TRY_LINK([],
+                 [asm(".fpu neon\n vadd.i8 d0, d0, d0");],
+                 result="yes", result="no")
+  AC_MSG_RESULT("$result")
+  if test "$result" = "yes"; then
+      AC_DEFINE(HAVE_ARM_NEON)
+      HAVE_ARM_NEON=1
+
+      dnl We don't need to build NEON support if we're targetting a non-NEON device.
+      dnl This matches media/webrtc/trunk/webrtc/build/common.gypi.
+      if test -n "$ARM_ARCH"; then
+          if test "$ARM_ARCH" -lt 7; then
+              BUILD_ARM_NEON=
+          else
+              AC_DEFINE(BUILD_ARM_NEON)
+              BUILD_ARM_NEON=1
+          fi
+      fi
+  fi
+
+  dnl Building with -mfpu=neon requires either the "softfp" or the
+  dnl "hardfp" ABI. Depending on the compiler's default target, and the
+  dnl CFLAGS, the default ABI might be neither, in which case it is the
+  dnl "softfloat" ABI.
+  dnl The "softfloat" ABI is binary-compatible with the "softfp" ABI, so
+  dnl we can safely mix code built with both ABIs. So, if we detect
+  dnl that compiling uses the "softfloat" ABI, force the use of the
+  dnl "softfp" ABI instead.
+  dnl Confusingly, the __SOFTFP__ preprocessor variable indicates the
+  dnl "softfloat" ABI, not the "softfp" ABI.
+  dnl Note: VPX_ASFLAGS is also used in CFLAGS.
+  AC_TRY_COMPILE([],
+    [#ifndef __SOFTFP__
+     #error "compiler target supports -mfpu=neon, so we don't have to add extra flags"
+     #endif],
+     NEON_FLAGS="$NEON_FLAGS -mfloat-abi=softfp"
+  )
+
+fi # CPU_ARCH = arm
+
+AC_SUBST(HAVE_ARM_SIMD)
+AC_SUBST(HAVE_ARM_NEON)
+AC_SUBST(BUILD_ARM_NEON)
+AC_SUBST(ARM_ARCH)
+AC_SUBST_LIST(NEON_FLAGS)
+AC_SUBST(MOZ_FPU)
+
 ])
deleted file mode 100644
--- a/build/moz.configure/arm.configure
+++ /dev/null
@@ -1,252 +0,0 @@
-# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
-# vim: set filetype=python:
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-@depends(target.os, '--help')
-def arm_option_defaults(os, _):
-    if os == 'Android':
-        arch = 'armv7-a'
-        thumb = 'yes'
-        fpu = 'neon'
-        float_abi = 'softfp'
-    else:
-        arch = thumb = fpu = float_abi = 'toolchain-default'
-    return namespace(
-        arch=arch,
-        thumb=thumb,
-        fpu=fpu,
-        float_abi=float_abi,
-    )
-
-
-js_option('--with-arch', nargs=1,
-          default=arm_option_defaults.arch,
-          help='Use specific CPU features (-march=type). Resets thumb, fpu, '
-               'float-abi, etc. defaults when set')
-
-
-@depends('--with-arch')
-def arch_option(value):
-    if value:
-        if value[0] != 'toolchain-default':
-            return ['-march={}'.format(value[0])]
-    return []
-
-
-js_option('--with-thumb', choices=('yes', 'no', 'toolchain-default'),
-          default=arm_option_defaults.thumb,
-          nargs='?', help='Use Thumb instruction set (-mthumb)')
-
-
-def normalize_arm_option(value):
-    if value:
-        if len(value):
-            if value[0] == 'yes':
-                return True
-            elif value[0] == 'no':
-                return False
-            else:
-                return value[0]
-        return True
-    return False
-
-@depends('--with-thumb')
-def thumb_option(value):
-    value = normalize_arm_option(value)
-    if value is True:
-        return ['-mthumb']
-    if value is False:
-        return ['-marm']
-    return []
-
-
-js_option('--with-thumb-interwork', choices=('yes', 'no', 'toolchain-default'),
-          default='toolchain-default',
-          nargs='?', help='Use Thumb/ARM instuctions interwork (-mthumb-interwork)')
-
-
-@depends('--with-thumb-interwork')
-def thumb_interwork_option(value):
-    value = normalize_arm_option(value)
-    if value is True:
-        return ['-mthumb-interwork']
-    if value is False:
-        return ['-mno-thumb-interwork']
-    return []
-
-
-js_option('--with-fpu', nargs=1,
-          default=arm_option_defaults.fpu,
-          help='Use specific FPU type (-mfpu=type)')
-
-
-@depends('--with-fpu')
-def fpu_option(value):
-    if value:
-        if value[0] != 'toolchain-default':
-            return ['-mfpu={}'.format(value[0])]
-    return []
-
-
-js_option('--with-float-abi', nargs=1,
-          default=arm_option_defaults.float_abi,
-          help='Use specific arm float ABI (-mfloat-abi=type)')
-
-
-@depends('--with-float-abi')
-def float_abi_option(value):
-    if value:
-        if value[0] != 'toolchain-default':
-            return ['-mfloat-abi={}'.format(value[0])]
-    return []
-
-
-js_option('--with-soft-float', choices=('yes', 'no', 'toolchain-default'),
-          default='toolchain-default',
-          nargs='?', help='Use soft float library (-msoft-float)')
-
-
-@depends('--with-soft-float')
-def soft_float_option(value):
-    value = normalize_arm_option(value)
-    if value is True:
-        return ['-msoft-float']
-    if value is False:
-        return ['-mno-soft-float']
-    return []
-
-
-check_and_add_gcc_flag('-mno-unaligned-access',
-                       when=depends(target.os)(lambda os: os == 'Android'))
-
-
-@depends(arch_option, thumb_option, thumb_interwork_option, fpu_option,
-         float_abi_option, soft_float_option)
-def all_flags(arch, thumb, interwork, fpu, float_abi, soft_float):
-    return arch + thumb + interwork + fpu + float_abi + soft_float
-
-
-add_old_configure_assignment('_ARM_FLAGS', all_flags)
-add_old_configure_assignment('_THUMB_FLAGS', thumb_option)
-
-
-@depends(c_compiler, all_flags)
-@checking('ARM version support in compiler', lambda x: x.arm_arch)
-@imports(_from='textwrap', _import='dedent')
-def arm_target(compiler, all_flags):
-    # We're going to preprocess the following source to figure out some details
-    # about the arm target options we have enabled.
-    source = dedent('''\
-        %ARM_ARCH __ARM_ARCH
-        #if __thumb2__
-        %THUMB2 yes
-        #else
-        %THUMB2 no
-        #endif
-        // Confusingly, the __SOFTFP__ preprocessor variable indicates the
-        // "softfloat" ABI, not the "softfp" ABI.
-        #if __SOFTFP__
-        %FLOAT_ABI soft
-        #elif __ARM_PCS_VFP
-        %FLOAT_ABI hard
-        #else
-        %FLOAT_ABI softfp
-        #endif
-        // There is more subtlety to it than this preprocessor test, but MOZ_FPU doesn't
-        // need to be too fine-grained.
-        #if __ARM_NEON
-        %FPU neon
-        #elif __ARM_VFPV2__
-        %FPU vfpv2
-        #elif __ARM_VFPV3__
-        %FPU vfpv3
-        #elif __ARM_VFPV4__
-        %FPU vfpv4
-        #elif __ARM_FPV5__
-        %FPU fp-armv8
-        #endif
-    ''')
-    result = try_invoke_compiler(
-        compiler.wrapper + [compiler.compiler] + compiler.flags,
-        compiler.language,
-        source,
-        ['-E'] + all_flags,
-    )
-    # 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('%').lower()
-            if k == 'arm_arch':
-                data[k] = int(v)
-            else:
-                data[k] = {
-                    'yes': True,
-                    'no': False,
-                }.get(v, v)
-            log.debug('%s = %s', k, data[k])
-
-    return namespace(**data)
-
-
-@depends(arm_target.arm_arch, when=depends(target.os)(lambda os: os == 'Android'))
-def armv7(arch):
-    if arch < 7:
-        die('Android/armv6 and earlier are not supported')
-
-
-set_config('MOZ_THUMB2', True, when=arm_target.thumb2)
-set_define('MOZ_THUMB2', True, when=arm_target.thumb2)
-add_old_configure_assignment('MOZ_THUMB2', True, when=arm_target.thumb2)
-
-
-have_arm_simd = c_compiler.try_compile(body='asm("uqadd8 r1, r1, r2");',
-                                       check_msg='for ARM SIMD support in compiler')
-
-set_config('HAVE_ARM_SIMD', have_arm_simd)
-set_define('HAVE_ARM_SIMD', have_arm_simd)
-
-have_arm_neon = c_compiler.try_compile(body='asm(".fpu neon\\n vadd.i8 d0, d0, d0");',
-                                       check_msg='for ARM NEON support in compiler')
-
-set_config('HAVE_ARM_NEON', have_arm_neon)
-set_define('HAVE_ARM_NEON', have_arm_neon)
-
-
-# We don't need to build NEON support if we're targetting a non-NEON device.
-# This matches media/webrtc/trunk/webrtc/build/common.gypi.
-@depends(arm_target.arm_arch, when=have_arm_neon)
-def build_arm_neon(arm_arch):
-    return arm_arch >= 7
-
-
-set_config('BUILD_ARM_NEON', build_arm_neon)
-set_define('BUILD_ARM_NEON', build_arm_neon)
-
-
-set_config('ARM_ARCH', depends(arm_target.arm_arch)(lambda x: str(x)))
-add_old_configure_assignment('ARM_ARCH', depends(arm_target.arm_arch)(lambda x: str(x)))
-set_config('MOZ_FPU', arm_target.fpu)
-
-
-@depends(arm_target.float_abi)
-def neon_flags(float_abi):
-    # Building with -mfpu=neon requires either the "softfp" or the
-    # "hardfp" ABI. Depending on the compiler's default target, and the
-    # CFLAGS, the default ABI might be neither, in which case it is the
-    # "softfloat" ABI.
-    # The "softfloat" ABI is binary-compatible with the "softfp" ABI, so
-    # we can safely mix code built with both ABIs. So, if we detect
-    # that compiling uses the "softfloat" ABI, force the use of the
-    # "softfp" ABI instead.
-    flags = ['-mfpu=neon']
-    if float_abi == 'soft':
-        flags.append('-mfloat-abi=softfp')
-    return tuple(flags)
-
-
-set_config('NEON_FLAGS', neon_flags)
--- a/build/moz.configure/old.configure
+++ b/build/moz.configure/old.configure
@@ -226,42 +226,48 @@ def old_configure_options(*options):
     '--includedir',
     '--libdir',
     '--prefix',
     '--with-android-distribution-directory',
     '--with-android-max-sdk',
     '--with-android-min-sdk',
     '--with-app-basename',
     '--with-app-name',
+    '--with-arch',
     '--with-branding',
     '--with-cross-lib',
     '--with-debug-label',
     '--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-nspr-cflags',
     '--with-nspr-exec-prefix',
     '--with-nspr-libs',
     '--with-nspr-prefix',
     '--with-nss-exec-prefix',
     '--with-nss-prefix',
     '--with-qemu-exe',
     '--with-sixgill',
+    '--with-soft-float',
     '--with-system-bz2',
     '--with-system-icu',
     '--with-system-libevent',
     '--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',
 )
 def prepare_configure_options(extra_old_configure_args, all_options, *options):
     # old-configure only supports the options listed in @old_configure_options
     # so we don't need to pass it every single option we've been passed. Only
--- a/build/moz.configure/toolchain.configure
+++ b/build/moz.configure/toolchain.configure
@@ -1178,17 +1178,16 @@ def msvs_version(info):
         return '2017'
 
     return ''
 
 
 set_config('MSVS_VERSION', msvs_version)
 
 include('compile-checks.configure')
-include('arm.configure', when=depends(target.cpu)(lambda cpu: cpu == 'arm'))
 
 
 @depends(have_64_bit,
          try_compile(body='static_assert(sizeof(void *) == 8, "")',
                      check_msg='for 64-bit OS'))
 def check_have_64_bit(have_64_bit, compiler_have_64_bit):
     if have_64_bit != compiler_have_64_bit:
         configure_error('The target compiler does not agree with configure '
--- a/js/src/old-configure.in
+++ b/js/src/old-configure.in
@@ -297,17 +297,18 @@ MOZ_USER_DIR=".mozilla"
 
 MOZ_FIX_LINK_PATHS="-Wl,-rpath-link,${DIST}/bin -Wl,-rpath-link,${prefix}/lib"
 
 dnl Configure platform-specific CPU architecture compiler options.
 dnl ==============================================================
 MOZ_ARCH_OPTS
 
 dnl ========================================================
-dnl Android libstdc++
+dnl Android libstdc++, placed here so it can use MOZ_ARCH
+dnl computed above.
 dnl ========================================================
 
 MOZ_ANDROID_CPU_ARCH
 MOZ_ANDROID_STLPORT
 
 dnl ========================================================
 dnl Suppress Clang Argument Warnings
 dnl ========================================================
--- a/old-configure.in
+++ b/old-configure.in
@@ -278,20 +278,26 @@ MOZ_USER_DIR=".mozilla"
 MOZ_FIX_LINK_PATHS="-Wl,-rpath-link,${DIST}/bin -Wl,-rpath-link,${prefix}/lib"
 
 MOZ_FS_LAYOUT=unix
 
 dnl Configure platform-specific CPU architecture compiler options.
 dnl ==============================================================
 if test "$COMPILE_ENVIRONMENT"; then
     MOZ_ARCH_OPTS
+else
+    if test "$OS_TARGET" = Android; then
+        dnl Default Android builds to ARMv7.
+        MOZ_ARCH=armv7-a
+    fi
 fi # COMPILE_ENVIRONMENT
 
 dnl ========================================================
-dnl Android libstdc++
+dnl Android libstdc++, placed here so it can use MOZ_ARCH
+dnl computed above.
 dnl ========================================================
 
 MOZ_ANDROID_CPU_ARCH
 if test "$COMPILE_ENVIRONMENT"; then
     MOZ_ANDROID_STLPORT
 fi # COMPILE_ENVIRONMENT
 
 dnl ========================================================