From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../jit/mips-shared/AtomicOperations-mips-shared.h | 521 +++++++++++++++++++++ 1 file changed, 521 insertions(+) create mode 100644 js/src/jit/mips-shared/AtomicOperations-mips-shared.h (limited to 'js/src/jit/mips-shared/AtomicOperations-mips-shared.h') diff --git a/js/src/jit/mips-shared/AtomicOperations-mips-shared.h b/js/src/jit/mips-shared/AtomicOperations-mips-shared.h new file mode 100644 index 0000000000..5ef11fd8c2 --- /dev/null +++ b/js/src/jit/mips-shared/AtomicOperations-mips-shared.h @@ -0,0 +1,521 @@ +/* -*- 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/. */ + +/* For documentation, see jit/AtomicOperations.h */ + +// NOTE, MIPS32 unlike MIPS64 doesn't provide hardware support for lock-free +// 64-bit atomics. We lie down below about 8-byte atomics being always lock- +// free in order to support wasm jit. The 64-bit atomic for MIPS32 do not use +// __atomic intrinsic and therefore do not relay on -latomic. +// Access to a aspecific 64-bit variable in memory is protected by an +// AddressLock whose instance is shared between jit and AtomicOperations. + +#ifndef jit_mips_shared_AtomicOperations_mips_shared_h +#define jit_mips_shared_AtomicOperations_mips_shared_h + +#include "mozilla/Assertions.h" +#include "mozilla/Types.h" + +#include "builtin/AtomicsObject.h" +#include "vm/Uint8Clamped.h" + +#if !defined(__clang__) && !defined(__GNUC__) +# error "This file only for gcc-compatible compilers" +#endif + +#if defined(JS_SIMULATOR_MIPS32) && !defined(__i386__) +# error "The MIPS32 simulator atomics assume x86" +#endif + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +struct AddressLock { + public: + void acquire(); + void release(); + + private: + uint32_t spinlock; +}; + +static_assert(sizeof(AddressLock) == sizeof(uint32_t), + "AddressLock must be 4 bytes for it to be consumed by jit"); + +// For now use a single global AddressLock. +static AddressLock gAtomic64Lock; + +struct MOZ_RAII AddressGuard { + explicit AddressGuard(void* addr) { gAtomic64Lock.acquire(); } + + ~AddressGuard() { gAtomic64Lock.release(); } +}; + +#endif + +} // namespace jit +} // namespace js + +inline bool js::jit::AtomicOperations::hasAtomic8() { return true; } + +inline bool js::jit::AtomicOperations::isLockfree8() { + MOZ_ASSERT(__atomic_always_lock_free(sizeof(int8_t), 0)); + MOZ_ASSERT(__atomic_always_lock_free(sizeof(int16_t), 0)); + MOZ_ASSERT(__atomic_always_lock_free(sizeof(int32_t), 0)); +#if defined(JS_64BIT) + MOZ_ASSERT(__atomic_always_lock_free(sizeof(int64_t), 0)); +#endif + return true; +} + +inline void js::jit::AtomicOperations::fenceSeqCst() { + __atomic_thread_fence(__ATOMIC_SEQ_CST); +} + +template +inline T js::jit::AtomicOperations::loadSeqCst(T* addr) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + T v; + __atomic_load(addr, &v, __ATOMIC_SEQ_CST); + return v; +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::loadSeqCst(int64_t* addr) { + AddressGuard guard(addr); + return *addr; +} + +template <> +inline uint64_t js::jit::AtomicOperations::loadSeqCst(uint64_t* addr) { + AddressGuard guard(addr); + return *addr; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline void js::jit::AtomicOperations::storeSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + __atomic_store(addr, &val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline void js::jit::AtomicOperations::storeSeqCst(int64_t* addr, int64_t val) { + AddressGuard guard(addr); + *addr = val; +} + +template <> +inline void js::jit::AtomicOperations::storeSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + *addr = val; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::compareExchangeSeqCst(T* addr, T oldval, + T newval) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + __atomic_compare_exchange(addr, &oldval, &newval, false, __ATOMIC_SEQ_CST, + __ATOMIC_SEQ_CST); + return oldval; +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::compareExchangeSeqCst( + int64_t* addr, int64_t oldval, int64_t newval) { + AddressGuard guard(addr); + int64_t val = *addr; + if (val == oldval) { + *addr = newval; + } + return val; +} + +template <> +inline uint64_t js::jit::AtomicOperations::compareExchangeSeqCst( + uint64_t* addr, uint64_t oldval, uint64_t newval) { + AddressGuard guard(addr); + uint64_t val = *addr; + if (val == oldval) { + *addr = newval; + } + return val; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::fetchAddSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + return __atomic_fetch_add(addr, val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::fetchAddSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = old + val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::fetchAddSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = old + val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::fetchSubSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + return __atomic_fetch_sub(addr, val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::fetchSubSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = old - val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::fetchSubSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = old - val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::fetchAndSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + return __atomic_fetch_and(addr, val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::fetchAndSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = old & val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::fetchAndSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = old & val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::fetchOrSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + return __atomic_fetch_or(addr, val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::fetchOrSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = old | val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::fetchOrSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = old | val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::fetchXorSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + return __atomic_fetch_xor(addr, val, __ATOMIC_SEQ_CST); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::fetchXorSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = old ^ val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::fetchXorSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = old ^ val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +template +inline T js::jit::AtomicOperations::loadSafeWhenRacy(T* addr) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + T v; + __atomic_load(addr, &v, __ATOMIC_RELAXED); + return v; +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::loadSafeWhenRacy(int64_t* addr) { + return *addr; +} + +template <> +inline uint64_t js::jit::AtomicOperations::loadSafeWhenRacy(uint64_t* addr) { + return *addr; +} + +#endif + +template <> +inline uint8_clamped js::jit::AtomicOperations::loadSafeWhenRacy( + uint8_clamped* addr) { + uint8_t v; + __atomic_load(&addr->val, &v, __ATOMIC_RELAXED); + return uint8_clamped(v); +} + +template <> +inline float js::jit::AtomicOperations::loadSafeWhenRacy(float* addr) { + return *addr; +} + +template <> +inline double js::jit::AtomicOperations::loadSafeWhenRacy(double* addr) { + return *addr; +} + +} // namespace jit +} // namespace js + +template +inline void js::jit::AtomicOperations::storeSafeWhenRacy(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + __atomic_store(addr, &val, __ATOMIC_RELAXED); +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline void js::jit::AtomicOperations::storeSafeWhenRacy(int64_t* addr, + int64_t val) { + *addr = val; +} + +template <> +inline void js::jit::AtomicOperations::storeSafeWhenRacy(uint64_t* addr, + uint64_t val) { + *addr = val; +} + +#endif + +template <> +inline void js::jit::AtomicOperations::storeSafeWhenRacy(uint8_clamped* addr, + uint8_clamped val) { + __atomic_store(&addr->val, &val.val, __ATOMIC_RELAXED); +} + +template <> +inline void js::jit::AtomicOperations::storeSafeWhenRacy(float* addr, + float val) { + *addr = val; +} + +template <> +inline void js::jit::AtomicOperations::storeSafeWhenRacy(double* addr, + double val) { + *addr = val; +} + +} // namespace jit +} // namespace js + +inline void js::jit::AtomicOperations::memcpySafeWhenRacy(void* dest, + const void* src, + size_t nbytes) { + MOZ_ASSERT(!((char*)dest <= (char*)src && (char*)src < (char*)dest + nbytes)); + MOZ_ASSERT(!((char*)src <= (char*)dest && (char*)dest < (char*)src + nbytes)); + ::memcpy(dest, src, nbytes); +} + +inline void js::jit::AtomicOperations::memmoveSafeWhenRacy(void* dest, + const void* src, + size_t nbytes) { + ::memmove(dest, src, nbytes); +} + +template +inline T js::jit::AtomicOperations::exchangeSeqCst(T* addr, T val) { + static_assert(sizeof(T) <= sizeof(void*), + "atomics supported up to pointer size only"); + T v; + __atomic_exchange(addr, &val, &v, __ATOMIC_SEQ_CST); + return v; +} + +namespace js { +namespace jit { + +#if !defined(JS_64BIT) + +template <> +inline int64_t js::jit::AtomicOperations::exchangeSeqCst(int64_t* addr, + int64_t val) { + AddressGuard guard(addr); + int64_t old = *addr; + *addr = val; + return old; +} + +template <> +inline uint64_t js::jit::AtomicOperations::exchangeSeqCst(uint64_t* addr, + uint64_t val) { + AddressGuard guard(addr); + uint64_t old = *addr; + *addr = val; + return old; +} + +#endif + +} // namespace jit +} // namespace js + +#if !defined(JS_64BIT) + +inline void js::jit::AddressLock::acquire() { + uint32_t zero = 0; + uint32_t one = 1; + while (!__atomic_compare_exchange(&spinlock, &zero, &one, true, + __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) { + zero = 0; + } +} + +inline void js::jit::AddressLock::release() { + uint32_t zero = 0; + __atomic_store(&spinlock, &zero, __ATOMIC_SEQ_CST); +} + +#endif + +#endif // jit_mips_shared_AtomicOperations_mips_shared_h -- cgit v1.2.3