Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef mozilla_WasiAtomic_h
#define mozilla_WasiAtomic_h
// Clang >= 14 supports <atomic> for wasm targets.
#if _LIBCPP_VERSION >= 14000
# include <atomic>
#else
# include <cstddef> // For ptrdiff_t
# include <cstdint>
// WASI doesn't support <atomic> and we use it as single-threaded for now.
// This is a stub implementation of std atomics to build WASI port of SM.
namespace std {
enum memory_order {
relaxed,
consume, // load-consume
acquire, // load-acquire
release, // store-release
acq_rel, // store-release load-acquire
seq_cst // store-release load-acquire
};
inline constexpr auto memory_order_relaxed = memory_order::relaxed;
inline constexpr auto memory_order_consume = memory_order::consume;
inline constexpr auto memory_order_acquire = memory_order::acquire;
inline constexpr auto memory_order_release = memory_order::release;
inline constexpr auto memory_order_acq_rel = memory_order::acq_rel;
inline constexpr auto memory_order_seq_cst = memory_order::seq_cst;
template <class T>
struct atomic {
using value_type = T;
value_type value_;
atomic() noexcept = default;
constexpr atomic(T desired) noexcept : value_{desired} {}
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
~atomic() noexcept = default;
T load(memory_order m = memory_order_seq_cst) const volatile noexcept {
return value_;
}
void store(T desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
value_ = desired;
}
T operator=(T desired) volatile noexcept { return value_ = desired; }
T exchange(T desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
T tmp = value_;
value_ = desired;
return tmp;
}
bool compare_exchange_weak(T& expected, T desired, memory_order,
memory_order) volatile noexcept {
expected = desired;
return true;
}
bool compare_exchange_weak(
T& expected, T desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
expected = desired;
return true;
}
bool compare_exchange_strong(T& expected, T desired, memory_order,
memory_order) volatile noexcept {
expected = desired;
return true;
}
bool compare_exchange_strong(
T& expected, T desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
expected = desired;
return true;
}
T fetch_add(T arg, memory_order m = memory_order_seq_cst) volatile noexcept {
T previous = value_;
value_ = value_ + arg;
return previous;
}
T fetch_sub(T arg, memory_order m = memory_order_seq_cst) volatile noexcept {
T previous = value_;
value_ = value_ - arg;
return previous;
}
T fetch_or(T arg, memory_order m = memory_order_seq_cst) volatile noexcept {
T previous = value_;
value_ = value_ | arg;
return previous;
}
T fetch_xor(T arg, memory_order m = memory_order_seq_cst) volatile noexcept {
T previous = value_;
value_ = value_ ^ arg;
return previous;
}
T fetch_and(T arg, memory_order m = memory_order_seq_cst) volatile noexcept {
T previous = value_;
value_ = value_ & arg;
return previous;
}
};
template <class T>
struct atomic<T*> {
using value_type = T*;
using difference_type = ptrdiff_t;
value_type value_;
atomic() noexcept = default;
constexpr atomic(T* desired) noexcept : value_{desired} {}
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
T* load(memory_order m = memory_order_seq_cst) const volatile noexcept {
return value_;
}
void store(T* desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
value_ = desired;
}
T* operator=(T* other) volatile noexcept { return value_ = other; }
T* exchange(T* desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
T* previous = value_;
value_ = desired;
return previous;
}
bool compare_exchange_weak(T*& expected, T* desired, memory_order s,
memory_order f) volatile noexcept {
expected = desired;
return true;
}
bool compare_exchange_weak(
T*& expected, T* desired,
memory_order m = memory_order_seq_cst) volatile noexcept {
expected = desired;
return true;
}
bool compare_exchange_strong(T*& expected, T* desired, memory_order s,
memory_order f) volatile noexcept {
expected = desired;
return true;
}
T* fetch_add(ptrdiff_t arg,
memory_order m = memory_order_seq_cst) volatile noexcept {
T* previous = value_;
value_ = value_ + arg;
return previous;
}
T* fetch_sub(ptrdiff_t arg,
memory_order m = memory_order_seq_cst) volatile noexcept {
T* previous = value_;
value_ = value_ - arg;
return previous;
}
};
using atomic_uint8_t = atomic<uint8_t>;
using atomic_uint16_t = atomic<uint16_t>;
using atomic_uint32_t = atomic<uint32_t>;
using atomic_uint64_t = atomic<uint64_t>;
} // namespace std
#endif
#endif // mozilla_WasiAtomic_h