Page MenuHomeWildfire Games
Differential D3094 Diff 13856 libraries/source/spidermonkey/include-win32-debug/mozilla/Atomics.h

Changeset View

Standalone View

View Options

libraries/source/spidermonkey/include-win32-debug/mozilla/Atomics.h

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Lines
struct AtomicIntrinsics<T*, Order> struct AtomicIntrinsics<T*, Order>
: public IntrinsicMemoryOps<T*, Order>, public IntrinsicIncDec<T*, Order> : public IntrinsicMemoryOps<T*, Order>, public IntrinsicIncDec<T*, Order>
{ {
}; };
template<typename T> template<typename T>
struct ToStorageTypeArgument struct ToStorageTypeArgument
{ {
static T convert (T aT) { return aT; } static constexpr T convert (T aT) { return aT; }
}; };
} // namespace detail } // namespace detail
} // namespace mozilla } // namespace mozilla
#elif defined(__GNUC__) #elif defined(__GNUC__)
namespace mozilla { namespace mozilla {
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
{ {
}; };
template<typename T, bool TIsEnum = IsEnum<T>::value> template<typename T, bool TIsEnum = IsEnum<T>::value>
struct ToStorageTypeArgument struct ToStorageTypeArgument
{ {
typedef typename AtomicStorageType<T>::Type ResultType; typedef typename AtomicStorageType<T>::Type ResultType;
static ResultType convert (T aT) { return ResultType(aT); } static constexpr ResultType convert (T aT) { return ResultType(aT); }
}; };
template<typename T> template<typename T>
struct ToStorageTypeArgument<T, false> struct ToStorageTypeArgument<T, false>
{ {
static T convert (T aT) { return aT; } static constexpr T convert (T aT) { return aT; }
}; };
} // namespace detail } // namespace detail
} // namespace mozilla } // namespace mozilla
#else #else
# error "Atomic compiler intrinsics are not supported on your platform" # error "Atomic compiler intrinsics are not supported on your platform"
#endif #endif
Show All 9 Lines static_assert(sizeof(T) == 4 || sizeof(T) == 8,
"mozilla/Atomics.h only supports 32-bit and 64-bit types"); "mozilla/Atomics.h only supports 32-bit and 64-bit types");
protected: protected:
typedef typename detail::AtomicIntrinsics<T, Order> Intrinsics; typedef typename detail::AtomicIntrinsics<T, Order> Intrinsics;
typedef typename Intrinsics::ValueType ValueType; typedef typename Intrinsics::ValueType ValueType;
ValueType mValue; ValueType mValue;
public: public:
MOZ_CONSTEXPR AtomicBase() : mValue() {} constexpr AtomicBase() : mValue() {}
explicit MOZ_CONSTEXPR AtomicBase(T aInit) explicit constexpr AtomicBase(T aInit)
: mValue(ToStorageTypeArgument<T>::convert(aInit)) : mValue(ToStorageTypeArgument<T>::convert(aInit))
{} {}
// Note: we can't provide operator T() here because Atomic<bool> inherits // Note: we can't provide operator T() here because Atomic<bool> inherits
// from AtomcBase with T=uint32_t and not T=bool. If we implemented // from AtomcBase with T=uint32_t and not T=bool. If we implemented
// operator T() here, it would cause errors when comparing Atomic<bool> with // operator T() here, it would cause errors when comparing Atomic<bool> with
// a regular bool. // a regular bool.
Show All 34 Lines
}; };
template<typename T, MemoryOrdering Order> template<typename T, MemoryOrdering Order>
class AtomicBaseIncDec : public AtomicBase<T, Order> class AtomicBaseIncDec : public AtomicBase<T, Order>
{ {
typedef typename detail::AtomicBase<T, Order> Base; typedef typename detail::AtomicBase<T, Order> Base;
public: public:
MOZ_CONSTEXPR AtomicBaseIncDec() : Base() {} constexpr AtomicBaseIncDec() : Base() {}
explicit MOZ_CONSTEXPR AtomicBaseIncDec(T aInit) : Base(aInit) {} explicit constexpr AtomicBaseIncDec(T aInit) : Base(aInit) {}
using Base::operator=; using Base::operator=;
operator T() const { return Base::Intrinsics::load(Base::mValue); } operator T() const { return Base::Intrinsics::load(Base::mValue); }
T operator++(int) { return Base::Intrinsics::inc(Base::mValue); } T operator++(int) { return Base::Intrinsics::inc(Base::mValue); }
T operator--(int) { return Base::Intrinsics::dec(Base::mValue); } T operator--(int) { return Base::Intrinsics::dec(Base::mValue); }
T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; } T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; }
T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; } T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; }
Show All 38 Lines
template<typename T, MemoryOrdering Order> template<typename T, MemoryOrdering Order>
class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value && class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value &&
!IsSame<T, bool>::value>::Type> !IsSame<T, bool>::value>::Type>
: public detail::AtomicBaseIncDec<T, Order> : public detail::AtomicBaseIncDec<T, Order>
{ {
typedef typename detail::AtomicBaseIncDec<T, Order> Base; typedef typename detail::AtomicBaseIncDec<T, Order> Base;
public: public:
MOZ_CONSTEXPR Atomic() : Base() {} constexpr Atomic() : Base() {}
explicit MOZ_CONSTEXPR Atomic(T aInit) : Base(aInit) {} explicit constexpr Atomic(T aInit) : Base(aInit) {}
using Base::operator=; using Base::operator=;
T operator+=(T aDelta) T operator+=(T aDelta)
{ {
return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta; return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
} }
Show All 30 Lines
* exchange()) is included as well. * exchange()) is included as well.
*/ */
template<typename T, MemoryOrdering Order> template<typename T, MemoryOrdering Order>
class Atomic<T*, Order> : public detail::AtomicBaseIncDec<T*, Order> class Atomic<T*, Order> : public detail::AtomicBaseIncDec<T*, Order>
{ {
typedef typename detail::AtomicBaseIncDec<T*, Order> Base; typedef typename detail::AtomicBaseIncDec<T*, Order> Base;
public: public:
MOZ_CONSTEXPR Atomic() : Base() {} constexpr Atomic() : Base() {}
explicit MOZ_CONSTEXPR Atomic(T* aInit) : Base(aInit) {} explicit constexpr Atomic(T* aInit) : Base(aInit) {}
using Base::operator=; using Base::operator=;
T* operator+=(ptrdiff_t aDelta) T* operator+=(ptrdiff_t aDelta)
{ {
return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta; return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
} }
Show All 13 Lines
*/ */
template<typename T, MemoryOrdering Order> template<typename T, MemoryOrdering Order>
class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type> class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type>
: public detail::AtomicBase<T, Order> : public detail::AtomicBase<T, Order>
{ {
typedef typename detail::AtomicBase<T, Order> Base; typedef typename detail::AtomicBase<T, Order> Base;
public: public:
MOZ_CONSTEXPR Atomic() : Base() {} constexpr Atomic() : Base() {}
explicit MOZ_CONSTEXPR Atomic(T aInit) : Base(aInit) {} explicit constexpr Atomic(T aInit) : Base(aInit) {}
operator T() const { return T(Base::Intrinsics::load(Base::mValue)); } operator T() const { return T(Base::Intrinsics::load(Base::mValue)); }
using Base::operator=; using Base::operator=;
private: private:
Atomic(Atomic<T, Order>& aOther) = delete; Atomic(Atomic<T, Order>& aOther) = delete;
}; };
Show All 16 Lines
*/ */
template<MemoryOrdering Order> template<MemoryOrdering Order>
class Atomic<bool, Order> class Atomic<bool, Order>
: protected detail::AtomicBase<uint32_t, Order> : protected detail::AtomicBase<uint32_t, Order>
{ {
typedef typename detail::AtomicBase<uint32_t, Order> Base; typedef typename detail::AtomicBase<uint32_t, Order> Base;
public: public:
MOZ_CONSTEXPR Atomic() : Base() {} constexpr Atomic() : Base() {}
explicit MOZ_CONSTEXPR Atomic(bool aInit) : Base(aInit) {} explicit constexpr Atomic(bool aInit) : Base(aInit) {}
// We provide boolean wrappers for the underlying AtomicBase methods. // We provide boolean wrappers for the underlying AtomicBase methods.
MOZ_IMPLICIT operator bool() const MOZ_IMPLICIT operator bool() const
{ {
return Base::Intrinsics::load(Base::mValue); return Base::Intrinsics::load(Base::mValue);
} }
bool operator=(bool aVal) bool operator=(bool aVal)
Show All 21 Lines
Wildfire Games · Phabricator