From bae5179cfb1c0222b29794cb18fda1c47f1547c0 Mon Sep 17 00:00:00 2001 From: Brian Hackett Date: Thu, 25 Oct 2018 11:42:18 -1000 Subject: [PATCH] Bug 1502207 Part 2 - Fix useUse new atomic access API in Gecko, r=froydnj. --HG-- extra : rebase_source : 2b9b5bb77fb53cd9f028912b4ba54136c9066447 --- mfbt/Atomics.h | 26 +++++++++++++------------- mfbt/RefCounted.h | 8 ++++---- xpcom/base/nsISupportsImpl.h | 8 ++++---- 3 files changed, 21 insertions(+), 21 deletions(-) diff --git a/mfbt/Atomics.h b/mfbt/Atomics.h index 94bdf44241d3..6528a5763314 100644 --- a/mfbt/Atomics.h +++ b/mfbt/Atomics.h @@ -158,13 +158,13 @@ template struct AutoRecordAtomicAccess; template<> struct AutoRecordAtomicAccess { - AutoRecordAtomicAccess() {} + explicit AutoRecordAtomicAccess(const void* aValue) {} ~AutoRecordAtomicAccess() {} }; template<> struct AutoRecordAtomicAccess { - AutoRecordAtomicAccess() { recordreplay::BeginOrderedAtomicAccess(); } + explicit AutoRecordAtomicAccess(const void* aValue) { recordreplay::BeginOrderedAtomicAccess(aValue); } ~AutoRecordAtomicAccess() { recordreplay::EndOrderedAtomicAccess(); } }; @@ -218,26 +218,26 @@ struct IntrinsicMemoryOps : public IntrinsicBase static T load(const typename Base::ValueType& aPtr) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.load(Base::OrderedOp::LoadOrder); } static void store(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); aPtr.store(aVal, Base::OrderedOp::StoreOrder); } static T exchange(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.exchange(aVal, Base::OrderedOp::AtomicRMWOrder); } static bool compareExchange(typename Base::ValueType& aPtr, T aOldVal, T aNewVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.compare_exchange_strong(aOldVal, aNewVal, Base::OrderedOp::AtomicRMWOrder, Base::OrderedOp::CompareExchangeFailureOrder); @@ -251,13 +251,13 @@ struct IntrinsicAddSub : public IntrinsicBase static T add(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder); } static T sub(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder); } }; @@ -269,13 +269,13 @@ struct IntrinsicAddSub : public IntrinsicBase static T* add(typename Base::ValueType& aPtr, ptrdiff_t aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_add(aVal, Base::OrderedOp::AtomicRMWOrder); } static T* sub(typename Base::ValueType& aPtr, ptrdiff_t aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_sub(aVal, Base::OrderedOp::AtomicRMWOrder); } }; @@ -304,19 +304,19 @@ struct AtomicIntrinsics : public IntrinsicMemoryOps, static T or_(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_or(aVal, Base::OrderedOp::AtomicRMWOrder); } static T xor_(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_xor(aVal, Base::OrderedOp::AtomicRMWOrder); } static T and_(typename Base::ValueType& aPtr, T aVal) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(&aPtr); return aPtr.fetch_and(aVal, Base::OrderedOp::AtomicRMWOrder); } }; diff --git a/mfbt/RefCounted.h b/mfbt/RefCounted.h index dcc631a69234..e8ea984fbf5a 100644 --- a/mfbt/RefCounted.h +++ b/mfbt/RefCounted.h @@ -124,7 +124,7 @@ public: // first increment on that thread. The necessary memory // synchronization is done by the mechanism that transfers the // pointer between threads. - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(this); return mValue.fetch_add(1, std::memory_order_relaxed) + 1; } @@ -134,7 +134,7 @@ public: // release semantics so that prior writes on this thread are visible // to the thread that destroys the object when it reads mValue with // acquire semantics. - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(this); T result = mValue.fetch_sub(1, std::memory_order_release) - 1; if (result == 0) { // We're going to destroy the object on this thread, so we need @@ -149,7 +149,7 @@ public: // This method is only called in debug builds, so we're not too concerned // about its performance. void operator=(const T& aValue) { - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(this); mValue.store(aValue, std::memory_order_seq_cst); } @@ -157,7 +157,7 @@ public: { // Use acquire semantics since we're not sure what the caller is // doing. - AutoRecordAtomicAccess record; + AutoRecordAtomicAccess record(this); return mValue.load(std::memory_order_acquire); } diff --git a/xpcom/base/nsISupportsImpl.h b/xpcom/base/nsISupportsImpl.h index 822c980329c4..0094de5ce2e2 100644 --- a/xpcom/base/nsISupportsImpl.h +++ b/xpcom/base/nsISupportsImpl.h @@ -339,7 +339,7 @@ public: // first increment on that thread. The necessary memory // synchronization is done by the mechanism that transfers the // pointer between threads. - detail::AutoRecordAtomicAccess record; + detail::AutoRecordAtomicAccess record(this); return mValue.fetch_add(1, std::memory_order_relaxed) + 1; } MOZ_ALWAYS_INLINE nsrefcnt operator--() @@ -348,7 +348,7 @@ public: // release semantics so that prior writes on this thread are visible // to the thread that destroys the object when it reads mValue with // acquire semantics. - detail::AutoRecordAtomicAccess record; + detail::AutoRecordAtomicAccess record(this); nsrefcnt result = mValue.fetch_sub(1, std::memory_order_release) - 1; if (result == 0) { // We're going to destroy the object on this thread, so we need @@ -364,7 +364,7 @@ public: { // Use release semantics since we're not sure what the caller is // doing. - detail::AutoRecordAtomicAccess record; + detail::AutoRecordAtomicAccess record(this); mValue.store(aValue, std::memory_order_release); return aValue; } @@ -373,7 +373,7 @@ public: { // Use acquire semantics since we're not sure what the caller is // doing. - detail::AutoRecordAtomicAccess record; + detail::AutoRecordAtomicAccess record(this); return mValue.load(std::memory_order_acquire); }