Backed out changeset f3d9fbb2daf1 (bug 1613985) for causing hazard bustages on Linux.

CLOSED TREE

Author: Mihai Alexandru Michis

mfbt/Array.h

@@ -28,7 +28,7 @@ class Array {
   using ElementType = T;
   static constexpr size_t Length = _Length;
 
-  Array() = default;
+  Array() {}
 
   template <typename... Args>
   MOZ_IMPLICIT constexpr Array(Args&&... aArgs)

mfbt/Atomics.h

@@ -160,7 +160,7 @@ struct AutoRecordAtomicAccess;
 template <>
 struct AutoRecordAtomicAccess<recordreplay::Behavior::DontPreserve> {
   explicit AutoRecordAtomicAccess(const void* aValue) {}
-  ~AutoRecordAtomicAccess() = default;
+  ~AutoRecordAtomicAccess() {}
 };
 
 template <>

mfbt/DebugOnly.h

@@ -41,7 +41,7 @@ class MOZ_STACK_CLASS DebugOnly {
 #ifdef DEBUG
   T value;
 
-  DebugOnly() = default;
+  DebugOnly() {}
   MOZ_IMPLICIT DebugOnly(const T& aOther) : value(aOther) {}
   DebugOnly(const DebugOnly& aOther) : value(aOther.value) {}
   DebugOnly& operator=(const T& aRhs) {
@@ -65,7 +65,7 @@ class MOZ_STACK_CLASS DebugOnly {
   const T& operator->() const { return value; }
 
 #else
-  DebugOnly() = default;
+  DebugOnly() {}
   MOZ_IMPLICIT DebugOnly(const T&) {}
   DebugOnly(const DebugOnly&) {}
   DebugOnly& operator=(const T&) { return *this; }
@@ -79,7 +79,7 @@ class MOZ_STACK_CLASS DebugOnly {
 #endif
 
   /*
-   * DebugOnly must always have a user-defined destructor or else it will
+   * DebugOnly must always have a destructor or else it will
    * generate "unused variable" warnings, exactly what it's intended
    * to avoid!
    */

mfbt/EnumeratedArray.h

@@ -50,7 +50,7 @@ class EnumeratedArray {
   ArrayType mArray;
 
  public:
-  EnumeratedArray() = default;
+  EnumeratedArray() {}
 
   template <typename... Args>
   MOZ_IMPLICIT constexpr EnumeratedArray(Args&&... aArgs)

mfbt/HashTable.h

@@ -178,8 +178,11 @@ class HashMap {
   explicit HashMap(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}
 
   // HashMap is movable.
-  HashMap(HashMap&& aRhs) = default;
-  HashMap& operator=(HashMap&& aRhs) = default;
+  HashMap(HashMap&& aRhs) : mImpl(std::move(aRhs.mImpl)) {}
+  void operator=(HashMap&& aRhs) {
+    MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
+    mImpl = std::move(aRhs.mImpl);
+  }
 
   // -- Status and sizing ----------------------------------------------------
 
@@ -460,8 +463,11 @@ class HashSet {
   explicit HashSet(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}
 
   // HashSet is movable.
-  HashSet(HashSet&& aRhs) = default;
-  HashSet& operator=(HashSet&& aRhs) = default;
+  HashSet(HashSet&& aRhs) : mImpl(std::move(aRhs.mImpl)) {}
+  void operator=(HashSet&& aRhs) {
+    MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
+    mImpl = std::move(aRhs.mImpl);
+  }
 
   // -- Status and sizing ----------------------------------------------------
 
@@ -905,8 +911,13 @@ class HashMapEntry {
       : key_(std::forward<KeyInput>(aKey)),
         value_(std::forward<ValueInput>(aValue)) {}
 
-  HashMapEntry(HashMapEntry&& aRhs) = default;
-  HashMapEntry& operator=(HashMapEntry&& aRhs) = default;
+  HashMapEntry(HashMapEntry&& aRhs)
+      : key_(std::move(aRhs.key_)), value_(std::move(aRhs.value_)) {}
+
+  void operator=(HashMapEntry&& aRhs) {
+    key_ = std::move(aRhs.key_);
+    value_ = std::move(aRhs.value_);
+  }
 
   using KeyType = Key;
   using ValueType = Value;
@@ -1503,14 +1514,13 @@ class HashTable : private AllocPolicy {
 
   // HashTable is movable
   HashTable(HashTable&& aRhs) : AllocPolicy(std::move(aRhs)) { moveFrom(aRhs); }
-  HashTable& operator=(HashTable&& aRhs) {
+  void operator=(HashTable&& aRhs) {
     MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
     if (mTable) {
       destroyTable(*this, mTable, capacity());
     }
     AllocPolicy::operator=(std::move(aRhs));
     moveFrom(aRhs);
-    return *this;
   }
 
  private:

mfbt/JSONWriter.h

@@ -110,7 +110,7 @@ namespace mozilla {
 class JSONWriteFunc {
  public:
   virtual void Write(const char* aStr) = 0;
-  virtual ~JSONWriteFunc() = default;
+  virtual ~JSONWriteFunc() {}
 };
 
 // Ideally this would be within |EscapedString| but when compiling with GCC

mfbt/LinkedList.h

@@ -620,7 +620,10 @@ class AutoCleanLinkedList : public LinkedList<T> {
  public:
   ~AutoCleanLinkedList() { clear(); }
 
-  AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther) = default;
+  AutoCleanLinkedList& operator=(AutoCleanLinkedList&& aOther) {
+    LinkedList<T>::operator=(std::forward<LinkedList<T>>(aOther));
+    return *this;
+  }
 
   void clear() {
     while (ClientType element = this->popFirst()) {

mfbt/Opaque.h

@@ -26,7 +26,7 @@ class Opaque final {
   T mValue;
 
  public:
-  Opaque() = default;
+  Opaque() {}
   explicit Opaque(T aValue) : mValue(aValue) {}
 
   bool operator==(const Opaque& aOther) const {

mfbt/Pair.h

@@ -142,10 +142,20 @@ struct Pair : private detail::PairHelper<A, B> {
   Pair(AArg&& aA, BArg&& aB)
       : Base(std::forward<AArg>(aA), std::forward<BArg>(aB)) {}
 
-  Pair(Pair&& aOther) = default;
+  Pair(Pair&& aOther)
+      : Base(std::move(aOther.first()), std::move(aOther.second())) {}
+
   Pair(const Pair& aOther) = default;
 
-  Pair& operator=(Pair&& aOther) = default;
+  Pair& operator=(Pair&& aOther) {
+    MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
+
+    first() = std::move(aOther.first());
+    second() = std::move(aOther.second());
+
+    return *this;
+  }
+
   Pair& operator=(const Pair& aOther) = default;
 
   /** The A instance. */

mfbt/RecordReplay.cpp

@@ -138,7 +138,7 @@ void Initialize(int aArgc, char* aArgv[]) {
 // Record/replay API functions can't GC, but we can't use
 // JS::AutoSuppressGCAnalysis here due to linking issues.
 struct AutoSuppressGCAnalysis {
-  AutoSuppressGCAnalysis() = default;
+  AutoSuppressGCAnalysis() {}
   ~AutoSuppressGCAnalysis() {
 #ifdef DEBUG
     // Need nontrivial destructor.

mfbt/RollingMean.h

@@ -44,7 +44,15 @@ class RollingMean {
     MOZ_ASSERT(aMaxValues > 0);
   }
 
-  RollingMean& operator=(RollingMean&& aOther) = default;
+  RollingMean& operator=(RollingMean&& aOther) {
+    MOZ_ASSERT(this != &aOther, "self-assignment is forbidden");
+    this->~RollingMean();
+    new (this) RollingMean(aOther.mMaxValues);
+    mInsertIndex = aOther.mInsertIndex;
+    mTotal = aOther.mTotal;
+    mValues.swap(aOther.mValues);
+    return *this;
+  }
 
   /**
    * Insert a value into the rolling mean.

mfbt/Scoped.h

@@ -174,8 +174,10 @@ class MOZ_NON_TEMPORARY_CLASS Scoped {
       Super::operator=(aRhs);                                                 \
       return *this;                                                           \
     }                                                                         \
-    name& operator=(name&& aRhs) = default;                                   \
-                                                                              \
+    name& operator=(name&& aRhs) {                                            \
+      Super::operator=(std::move(aRhs));                                      \
+      return *this;                                                           \
+    }                                                                         \
     explicit name(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM)                       \
         : Super(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT) {}            \
     explicit name(Resource aRhs MOZ_GUARD_OBJECT_NOTIFIER_PARAM)              \
@@ -184,8 +186,8 @@ class MOZ_NON_TEMPORARY_CLASS Scoped {
         : Super(std::move(aRhs) MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) {} \
                                                                               \
    private:                                                                   \
-    explicit name(const name&) = delete;                                      \
-    name& operator=(const name&) = delete;                                    \
+    explicit name(name&) = delete;                                            \
+    name& operator=(name&) = delete;                                          \
   };
 
 /*

mfbt/Span.h

@@ -260,7 +260,7 @@ class extent_type {
 
   static_assert(Ext >= 0, "A fixed-size Span must be >= 0 in size.");
 
-  constexpr extent_type() = default;
+  constexpr extent_type() {}
 
   template <index_type Other>
   constexpr MOZ_IMPLICIT extent_type(extent_type<Other> ext) {

mfbt/ThreadSafeWeakPtr.h

@@ -258,13 +258,21 @@ class ThreadSafeWeakPtr {
   typedef typename T::ThreadSafeWeakReference ThreadSafeWeakReference;
 
  public:
-  ThreadSafeWeakPtr() = default;
+  ThreadSafeWeakPtr() {}
 
-  ThreadSafeWeakPtr& operator=(const ThreadSafeWeakPtr& aOther) = default;
-  ThreadSafeWeakPtr(const ThreadSafeWeakPtr& aOther) = default;
+  ThreadSafeWeakPtr& operator=(const ThreadSafeWeakPtr& aOther) {
+    mRef = aOther.mRef;
+    return *this;
+  }
+
+  ThreadSafeWeakPtr(const ThreadSafeWeakPtr& aOther) : mRef(aOther.mRef) {}
+
+  ThreadSafeWeakPtr& operator=(ThreadSafeWeakPtr&& aOther) {
+    mRef = aOther.mRef.forget();
+    return *this;
+  }
 
-  ThreadSafeWeakPtr& operator=(ThreadSafeWeakPtr&& aOther) = default;
-  ThreadSafeWeakPtr(ThreadSafeWeakPtr&& aOther) = default;
+  ThreadSafeWeakPtr(ThreadSafeWeakPtr&& aOther) : mRef(aOther.mRef.forget()) {}
 
   ThreadSafeWeakPtr& operator=(const RefPtr<T>& aOther) {
     if (aOther) {

mfbt/UniquePtr.h

@@ -474,7 +474,7 @@ class UniquePtr<T[], D> {
 template <typename T>
 class DefaultDelete {
  public:
-  constexpr DefaultDelete() = default;
+  constexpr DefaultDelete() {}
 
   template <typename U>
   MOZ_IMPLICIT DefaultDelete(
@@ -492,7 +492,7 @@ class DefaultDelete {
 template <typename T>
 class DefaultDelete<T[]> {
  public:
-  constexpr DefaultDelete() = default;
+  constexpr DefaultDelete() {}
 
   void operator()(T* aPtr) const {
     static_assert(sizeof(T) > 0, "T must be complete");

mfbt/tests/TestRollingMean.cpp

@@ -32,7 +32,7 @@ class MyClass {
 
 class RollingMeanSuite {
  public:
-  RollingMeanSuite() = default;
+  RollingMeanSuite() {}
 
   void runTests() {
     testZero();

mfbt/tests/TestSPSCQueue.cpp

@@ -23,7 +23,7 @@ using namespace mozilla;
 template <typename T>
 class SequenceGenerator {
  public:
-  SequenceGenerator() = default;
+  SequenceGenerator() {}
   void Get(T* aElements, size_t aCount) {
     for (size_t i = 0; i < aCount; i++) {
       aElements[i] = static_cast<T>(mIndex);
@@ -40,7 +40,7 @@ class SequenceGenerator {
 template <typename T>
 class SequenceVerifier {
  public:
-  SequenceVerifier() = default;
+  SequenceVerifier() {}
   void Check(T* aElements, size_t aCount) {
     for (size_t i = 0; i < aCount; i++) {
       if (aElements[i] != static_cast<T>(mIndex)) {

mfbt/tests/TestTypeTraits.cpp

@@ -168,7 +168,7 @@ struct NE1 {
 };
 struct NE2 : virtual E1 {};
 struct NE3 : E2 {
-  virtual ~NE3() = default;
+  virtual ~NE3() {}
 };
 struct NE4 {
   virtual void f() {}
@@ -258,13 +258,13 @@ struct TrivialCtor1 {
 };
 
 struct DefaultCtor0 {
-  DefaultCtor0() = default;
+  DefaultCtor0() {}
 };
 struct DefaultCtor1 {
   DefaultCtor1() = default;
 };
 struct DefaultCtor2 {
-  DefaultCtor2() = default;
+  DefaultCtor2() {}
   explicit DefaultCtor2(int) {}
 };
 
@@ -276,7 +276,7 @@ struct NoDefaultCtor1 {
 };
 
 class PrivateCtor0 {
-  PrivateCtor0() = default;
+  PrivateCtor0() {}
 };
 class PrivateCtor1 {
   PrivateCtor1() = default;

mfbt/tests/TestUniquePtr.cpp

@@ -77,7 +77,7 @@ static void TestDeleterType() {
   typedef int* Ptr;
   struct Deleter {
     typedef Ptr pointer;
-    Deleter() = default;
+    Deleter() {}
     void operator()(int* p) { delete p; }
   };
   UniquePtr<Ptr, Deleter> u(new int, Deleter());
@@ -216,7 +216,7 @@ static size_t FreeClassCounter = 0;
 
 struct FreeClass {
  public:
-  FreeClass() = default;
+  FreeClass() {}
 
   void operator()(int* aPtr) {
     FreeClassCounter++;
@@ -366,7 +366,7 @@ static bool TestFunctionReferenceDeleter() {
 
 template <typename T>
 struct AppendNullptrTwice {
-  AppendNullptrTwice() = default;
+  AppendNullptrTwice() {}
 
   bool operator()(Vector<T>& vec) {
     CHECK(vec.append(nullptr));
@@ -481,8 +481,8 @@ static bool TestArray() {
 }
 
 struct Q {
-  Q() = default;
-  Q(const Q&) = default;
+  Q() {}
+  Q(const Q&) {}
 
   Q(Q&, char) {}
 

mfbt/tests/gtest/TestMozDbg.cpp

@@ -24,11 +24,14 @@ using namespace mozilla;
 struct Number {
   explicit Number(int aValue) : mValue(aValue) {}
 
-  Number(const Number& aOther) = default;
+  Number(const Number& aOther) : mValue(aOther.mValue) {}
 
   Number(Number&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
 
-  Number& operator=(const Number& aOther) = default;
+  Number& operator=(const Number& aOther) {
+    mValue = aOther.mValue;
+    return *this;
+  }
 
   Number& operator=(Number&& aOther) {
     mValue = aOther.mValue;
@@ -50,7 +53,10 @@ struct MoveOnly {
 
   MoveOnly(MoveOnly&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
 
-  MoveOnly& operator=(MoveOnly& aOther) = default;
+  MoveOnly& operator=(MoveOnly& aOther) {
+    mValue = aOther.mValue;
+    return *this;
+  }
 
   MoveOnly& operator=(MoveOnly&& aOther) {
     mValue = aOther.mValue;