--- 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 + {