summaryrefslogtreecommitdiffstats
path: root/ipc/chromium/src/base/atomicops_internals_mutex.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /ipc/chromium/src/base/atomicops_internals_mutex.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'ipc/chromium/src/base/atomicops_internals_mutex.h')
-rw-r--r--ipc/chromium/src/base/atomicops_internals_mutex.h251
1 files changed, 251 insertions, 0 deletions
diff --git a/ipc/chromium/src/base/atomicops_internals_mutex.h b/ipc/chromium/src/base/atomicops_internals_mutex.h
new file mode 100644
index 000000000..f8fe4c6ac
--- /dev/null
+++ b/ipc/chromium/src/base/atomicops_internals_mutex.h
@@ -0,0 +1,251 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+// This file is an internal atomic implementation, use
+// base/atomicops.h instead.
+//
+// This is a very slow fallback implementation of atomic operations
+// that uses a mutex instead of atomic instructions.
+//
+// (NB: a small "optimization" here would be using a spinlock instead
+// of a blocking mutex, but it's probably not worth the time.)
+
+#ifndef base_atomicops_internals_mutex_h
+#define base_atomicops_internals_mutex_h
+
+#include "base/lock.h"
+
+namespace base {
+namespace subtle {
+
+extern Lock gAtomicsMutex;
+
+template<typename T>
+T Locked_CAS(volatile T* ptr, T old_value, T new_value) {
+ AutoLock _(gAtomicsMutex);
+
+ T current_value = *ptr;
+ if (current_value == old_value)
+ *ptr = new_value;
+
+ return current_value;
+}
+
+template<typename T>
+T Locked_AtomicExchange(volatile T* ptr, T new_value) {
+ AutoLock _(gAtomicsMutex);
+
+ T current_value = *ptr;
+ *ptr = new_value;
+ return current_value;
+}
+
+template<typename T>
+T Locked_AtomicIncrement(volatile T* ptr, T increment) {
+ AutoLock _(gAtomicsMutex);
+ return *ptr += increment;
+}
+
+template<typename T>
+void Locked_Store(volatile T* ptr, T value) {
+ AutoLock _(gAtomicsMutex);
+ *ptr = value;
+}
+
+template<typename T>
+T Locked_Load(volatile const T* ptr) {
+ AutoLock _(gAtomicsMutex);
+ return *ptr;
+}
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value,
+ Atomic32 new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+ Atomic32 new_value) {
+ return Locked_AtomicExchange(ptr, new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+ Atomic32 increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+ Atomic32 increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value,
+ Atomic32 new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+ Atomic32 old_value,
+ Atomic32 new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline void MemoryBarrier() {
+ AutoLock _(gAtomicsMutex);
+ // lock/unlock work as a barrier here
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+ return Locked_Load(ptr);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+ return NoBarrier_Load(ptr);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+ return Locked_Load(ptr);
+}
+
+#ifdef ARCH_CPU_64_BITS
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+ Atomic64 old_value,
+ Atomic64 new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+ Atomic64 new_value) {
+ return Locked_AtomicExchange(ptr, new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+ Atomic64 increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+ Atomic64 increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+ Atomic64 old_value,
+ Atomic64 new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+ return Locked_Store(ptr, value);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+ return Locked_Load(ptr);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+ return Locked_Load(ptr);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+ return Locked_Load(ptr);
+}
+
+#endif // ARCH_CPU_64_BITS
+
+#ifdef OS_MACOSX
+// From atomicops_internals_x86_macosx.h:
+//
+// MacOS uses long for intptr_t, AtomicWord and Atomic32 are always
+// different on the Mac, even when they are the same size. We need
+// to explicitly cast from AtomicWord to Atomic32/64 to implement
+// the AtomicWord interface.
+
+inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr,
+ AtomicWord new_value) {
+ return Locked_AtomicExchange(ptr, new_value);
+}
+
+inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr,
+ AtomicWord increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr,
+ AtomicWord increment) {
+ return Locked_AtomicIncrement(ptr, increment);
+}
+
+inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
+ AtomicWord old_value,
+ AtomicWord new_value) {
+ return Locked_CAS(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) {
+ return Locked_Store(ptr, value);
+}
+
+inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) {
+ return Locked_Store(ptr, value);
+}
+
+inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
+ return Locked_Store(ptr, value);
+}
+
+inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) {
+ return Locked_Load(ptr);
+}
+
+inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
+ return Locked_Load(ptr);
+}
+
+inline AtomicWord Release_Load(volatile const AtomicWord* ptr) {
+ return Locked_Load(ptr);
+}
+
+#endif // OS_MACOSX
+
+} // namespace subtle
+} // namespace base
+
+#endif // base_atomicops_internals_mutex_h