Backed out 5 changesets (bug 1325771) for Spidermonkey failures and build bustage in build/src/mfbt/tests/TestCompactPair.cpp. CLOSED TREE
authorDorel Luca <dluca@mozilla.com>
Wed, 03 Jun 2020 20:23:08 +0300
changeset 597819 c593e06b6cf405c5056e20337f2c3acb9883f428
parent 597818 6911e019190eeedbc3f64e07fc8034bc20d5207b
child 597820 36f295b440e6e9968e0a6dfb10741a0ad6776e9d
push id13310
push userffxbld-merge
push dateMon, 29 Jun 2020 14:50:06 +0000
treeherdermozilla-beta@15a59a0afa5c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1325771
milestone79.0a1
backs outace40545b46c2c994e05a51ec466e3cb81a97d0c
b3e0fb410a1c1bf1881887f049da04a5e473e067
d69ac62c063fd9a31b7033c960fa67528f780159
24e6299e112dac7dc5891a1d61abc3e4dbbbb689
393a6ff847ce341fbe0e86f1bccfbea5ed8c3157
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 5 changesets (bug 1325771) for Spidermonkey failures and build bustage in build/src/mfbt/tests/TestCompactPair.cpp. CLOSED TREE Backed out changeset ace40545b46c (bug 1325771) Backed out changeset b3e0fb410a1c (bug 1325771) Backed out changeset d69ac62c063f (bug 1325771) Backed out changeset 24e6299e112d (bug 1325771) Backed out changeset 393a6ff847ce (bug 1325771)
build/moz.configure/init.configure
js/src/jit/AtomicOperations.h
js/src/jsapi-tests/testAtomicOperations.cpp
js/src/wasm/WasmTypes.h
mfbt/Alignment.h
mfbt/tests/TestCompactPair.cpp
mfbt/tests/TestPoisonArea.cpp
python/mozbuild/mozbuild/configure/constants.py
python/mozbuild/mozbuild/test/configure/test_toolchain_configure.py
--- a/build/moz.configure/init.configure
+++ b/build/moz.configure/init.configure
@@ -727,19 +727,16 @@ def split_triplet(triplet, allow_msvc=Fa
         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 ('m68k'):
-        canonical_cpu = 'm68k'
-        endianness = 'big'
     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'
--- a/js/src/jit/AtomicOperations.h
+++ b/js/src/jit/AtomicOperations.h
@@ -386,16 +386,15 @@ inline bool AtomicOperations::isLockfree
 #  if defined(__clang__) || defined(__GNUC__)
 #    include "jit/mips-shared/AtomicOperations-mips-shared.h"
 #  else
 #    error "AtomicOperations on MIPS for an unknown compiler"
 #  endif
 #elif defined(__ppc__) || defined(__PPC__) || defined(__sparc__) ||     \
     defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || \
     defined(__PPC64LE__) || defined(__alpha__) || defined(__hppa__) ||  \
-    defined(__sh__) || defined(__s390__) || defined(__s390x__) ||       \
-    defined(__m68k__)
+    defined(__sh__) || defined(__s390__) || defined(__s390x__)
 #  include "jit/shared/AtomicOperations-feeling-lucky.h"
 #else
 #  error "No AtomicOperations support provided for this platform"
 #endif
 
 #endif  // jit_AtomicOperations_h
--- a/js/src/jsapi-tests/testAtomicOperations.cpp
+++ b/js/src/jsapi-tests/testAtomicOperations.cpp
@@ -80,18 +80,18 @@ END_TEST(testAtomicFence)
 
 // These tests for the atomic load and store primitives ascertain that the
 // primitives are defined and that they load and store the values they should,
 // but not that the primitives are actually atomic wrt to the memory subsystem.
 
 // Memory for testing atomics.  This must be aligned to the natural alignment of
 // the type we're testing; for now, use 8-byte alignment for all.
 
-MOZ_ALIGNED_DECL(8, static uint8_t atomicMem[8]);
-MOZ_ALIGNED_DECL(8, static uint8_t atomicMem2[8]);
+MOZ_ALIGNED_DECL(static uint8_t atomicMem[8], 8);
+MOZ_ALIGNED_DECL(static uint8_t atomicMem2[8], 8);
 
 // T is the primitive type we're testing, and A and B are references to constant
 // bindings holding values of that type.
 //
 // No bytes of A and B should be 0 or FF.  A+B and A-B must not overflow.
 
 #define ATOMIC_TESTS(T, A, B)                                           \
   T* q = (T*)hidePointerValue((void*)atomicMem);                        \
--- a/js/src/wasm/WasmTypes.h
+++ b/js/src/wasm/WasmTypes.h
@@ -2869,17 +2869,17 @@ struct TlsData {
 
   // When compiling with tiering, the jumpTable has one entry for each
   // baseline-compiled function.
   void** jumpTable;
 
   // The globalArea must be the last field.  Globals for the module start here
   // and are inline in this structure.  16-byte alignment is required for SIMD
   // data.
-  MOZ_ALIGNED_DECL(16, char globalArea);
+  MOZ_ALIGNED_DECL(char globalArea, 16);
 };
 
 static const size_t TlsDataAlign = 16;  // = Simd128DataSize
 static_assert(offsetof(TlsData, globalArea) % TlsDataAlign == 0, "aligned");
 
 struct TlsDataDeleter {
   void operator()(TlsData* tlsData) { js_free(tlsData->allocatedBase); }
 };
--- a/mfbt/Alignment.h
+++ b/mfbt/Alignment.h
@@ -57,28 +57,28 @@ struct AlignasHelper {
  */
 #define MOZ_ALIGNAS_IN_STRUCT(T) alignas(mozilla::detail::AlignasHelper<T>)
 
 /*
  * Declare the MOZ_ALIGNED_DECL macro for declaring aligned types.
  *
  * For instance,
  *
- *   MOZ_ALIGNED_DECL(8, char arr[2]);
+ *   MOZ_ALIGNED_DECL(char arr[2], 8);
  *
  * will declare a two-character array |arr| aligned to 8 bytes.
  */
 
 #if defined(__GNUC__)
-#  define MOZ_ALIGNED_DECL(_align, _type) _type __attribute__((aligned(_align)))
+#  define MOZ_ALIGNED_DECL(_type, _align) _type __attribute__((aligned(_align)))
 #elif defined(_MSC_VER)
-#  define MOZ_ALIGNED_DECL(_align, _type) __declspec(align(_align)) _type
+#  define MOZ_ALIGNED_DECL(_type, _align) __declspec(align(_align)) _type
 #else
 #  warning "We don't know how to align variables on this compiler."
-#  define MOZ_ALIGNED_DECL(_align, _type) _type
+#  define MOZ_ALIGNED_DECL(_type, _align) _type
 #endif
 
 /*
  * AlignedElem<N> is a structure whose alignment is guaranteed to be at least N
  * bytes.
  *
  * We support 1, 2, 4, 8, and 16-byte alignment.
  */
@@ -87,37 +87,37 @@ struct AlignedElem;
 
 /*
  * We have to specialize this template because GCC doesn't like
  * __attribute__((aligned(foo))) where foo is a template parameter.
  */
 
 template <>
 struct AlignedElem<1> {
-  MOZ_ALIGNED_DECL(1, uint8_t elem);
+  MOZ_ALIGNED_DECL(uint8_t elem, 1);
 };
 
 template <>
 struct AlignedElem<2> {
-  MOZ_ALIGNED_DECL(2, uint8_t elem);
+  MOZ_ALIGNED_DECL(uint8_t elem, 2);
 };
 
 template <>
 struct AlignedElem<4> {
-  MOZ_ALIGNED_DECL(4, uint8_t elem);
+  MOZ_ALIGNED_DECL(uint8_t elem, 4);
 };
 
 template <>
 struct AlignedElem<8> {
-  MOZ_ALIGNED_DECL(8, uint8_t elem);
+  MOZ_ALIGNED_DECL(uint8_t elem, 8);
 };
 
 template <>
 struct AlignedElem<16> {
-  MOZ_ALIGNED_DECL(16, uint8_t elem);
+  MOZ_ALIGNED_DECL(uint8_t elem, 16);
 };
 
 template <typename T>
 struct MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS AlignedStorage2 {
   union U {
     char mBytes[sizeof(T)];
     uint64_t mDummy;
   } u;
--- a/mfbt/tests/TestCompactPair.cpp
+++ b/mfbt/tests/TestCompactPair.cpp
@@ -30,34 +30,29 @@ using mozilla::MakeCompactPair;
                 "first method should work on CompactPair<" #T2 ", " #T1 ">");  \
                                                                                \
   static_assert(sizeof(name##_2.second()) > 0,                                 \
                 "second method should work on CompactPair<" #T2 ", " #T1 ">"); \
                                                                                \
   static_assert(sizeof(name##_2) == (size),                                    \
                 "CompactPair<" #T2 ", " #T1 "> has an unexpected size");
 
-static constexpr size_t sizemax(size_t a, size_t b)
-{
-  return (a > b) ? a : b;
-}
-
 INSTANTIATE(int, int, prim1, 2 * sizeof(int));
-INSTANTIATE(int, long, prim2, sizeof(long) + sizemax(sizeof(int), alignof(long)));
+INSTANTIATE(int, long, prim2, 2 * sizeof(long));
 
 struct EmptyClass {
   explicit EmptyClass(int) {}
 };
 struct NonEmpty {
   char mC;
   explicit NonEmpty(int) : mC('\0') {}
 };
 
 INSTANTIATE(int, EmptyClass, both1, sizeof(int));
-INSTANTIATE(int, NonEmpty, both2, sizeof(int) + alignof(int));
+INSTANTIATE(int, NonEmpty, both2, 2 * sizeof(int));
 INSTANTIATE(EmptyClass, NonEmpty, both3, 1);
 
 struct A {
   char dummy;
   explicit A(int) : dummy('\0') {}
 };
 struct B : A {
   explicit B(int aI) : A(aI) {}
--- a/mfbt/tests/TestPoisonArea.cpp
+++ b/mfbt/tests/TestPoisonArea.cpp
@@ -127,19 +127,16 @@
 #elif defined __arm__ || defined _M_ARM
 #  define RETURN_INSTR 0xE12FFF1E /* bx lr */
 
 // PPC has its own style of CPU-id #defines.  There is no Windows for
 // PPC as far as I know, so no _M_ variant.
 #elif defined _ARCH_PPC || defined _ARCH_PWR || defined _ARCH_PWR2
 #  define RETURN_INSTR 0x4E800020 /* blr */
 
-#elif defined __m68k__
-#  define RETURN_INSTR 0x4E754E75 /* rts; rts */
-
 #elif defined __sparc || defined __sparcv9
 #  define RETURN_INSTR 0x81c3e008 /* retl */
 
 #elif defined __alpha
 #  define RETURN_INSTR 0x6bfa8001 /* ret */
 
 #elif defined __hppa
 #  define RETURN_INSTR 0xe840c002 /* bv,n r0(rp) */
--- a/python/mozbuild/mozbuild/configure/constants.py
+++ b/python/mozbuild/mozbuild/configure/constants.py
@@ -40,17 +40,16 @@ Kernel = EnumString.subclass(
 )
 
 CPU_bitness = {
     'aarch64': 64,
     'Alpha': 64,
     'arm': 32,
     'hppa': 32,
     'ia64': 64,
-    'm68k': 32,
     'mips32': 32,
     'mips64': 64,
     'ppc': 32,
     'ppc64': 64,
     's390': 32,
     's390x': 64,
     'sh4': 32,
     'sparc': 32,
@@ -81,17 +80,16 @@ CPU_preprocessor_checks = OrderedDict((
     ('s390x', '__s390x__'),
     ('s390', '__s390__'),
     ('ppc64', '__powerpc64__'),
     ('ppc', '__powerpc__'),
     ('Alpha', '__alpha__'),
     ('hppa', '__hppa__'),
     ('sparc64', '__sparc__ && __arch64__'),
     ('sparc', '__sparc__'),
-    ('m68k', '__m68k__'),
     ('mips64', '__mips64'),
     ('mips32', '__mips__'),
     ('sh4', '__sh__'),
 ))
 
 assert sorted(CPU_preprocessor_checks.keys()) == sorted(CPU.POSSIBLE_VALUES)
 
 kernel_preprocessor_checks = {
--- a/python/mozbuild/mozbuild/test/configure/test_toolchain_configure.py
+++ b/python/mozbuild/mozbuild/test/configure/test_toolchain_configure.py
@@ -1196,19 +1196,16 @@ class LinuxCrossCompileToolchainTest(Bas
         'sparc-unknown-linux-gnu': big_endian + {
             None: {
                 '__sparc__': 1,
             },
             '-m64': {
                 '__arch64__': 1,
             },
         },
-        'm68k-unknown-linux-gnu': big_endian + {
-            '__m68k__': 1,
-        },
         'mips64-unknown-linux-gnuabi64': big_endian + {
             '__mips64': 1,
             '__mips__': 1,
         },
         'mips-unknown-linux-gnu': big_endian + {
             '__mips__': 1,
         },
         'sh4-unknown-linux-gnu': little_endian + {