/* -*- 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/. */
#ifndef jit_AtomicOp_h
#define jit_AtomicOp_h
#include <stdint.h>
namespace js {
namespace jit {
// Types of atomic operation, shared by MIR and LIR.
enum class AtomicOp {
Add,
Sub,
And,
Or,
Xor,
};
// Memory barrier type, shared by MIR and LIR.
class MemoryBarrier {
enum MemoryBarrierBits : uint8_t {
MembarLoadLoad = 1,
MembarLoadStore = 2,
MembarStoreStore = 4,
MembarStoreLoad = 8,
// MembarSynchronizing is here because some platforms can make the
// distinction (DSB vs DMB on ARM, SYNC vs parameterized SYNC on MIPS)
// but there's been no reason to use it yet.
MembarSynchronizing = 16,
// For validity testing
MembarNobits = 0,
MembarAllbits = 31,
};
MemoryBarrierBits bits_;
template <
typename... MembarBits>
constexpr
explicit MemoryBarrier(MembarBits... bits)
: bits_(
static_cast<MemoryBarrierBits>((bits | ...))) {}
public:
// Accessors for currently used memory barrier types.
constexpr
bool isNone()
const {
return bits_ == MembarNobits; }
constexpr
bool isStoreStore()
const {
return bits_ == MembarStoreStore; }
constexpr
bool isSyncStoreStore()
const {
return bits_ ==
static_cast<MemoryBarrierBits>(MembarStoreStore |
MembarSynchronizing);
}
constexpr
bool hasSync()
const {
return bits_ & MembarSynchronizing; }
constexpr
bool hasStoreLoad()
const {
return bits_ & MembarStoreLoad; }
// No memory barrier.
static constexpr MemoryBarrier None() {
return MemoryBarrier{MembarNobits}; }
// Full memory barrier.
static constexpr MemoryBarrier Full() {
return MemoryBarrier{MembarLoadLoad, MembarLoadStore, MembarStoreLoad,
MembarStoreStore};
}
// Standard sets of barriers for atomic loads and stores.
// See http://gee.cs.oswego.edu/dl/jmm/cookbook.html for more.
static constexpr MemoryBarrier BeforeLoad() {
return MemoryBarrier{MembarNobits};
}
static constexpr MemoryBarrier AfterLoad() {
return MemoryBarrier{MembarLoadLoad, MembarLoadStore};
}
static constexpr MemoryBarrier BeforeStore() {
return MemoryBarrier{MembarStoreStore};
}
static constexpr MemoryBarrier AfterStore() {
return MemoryBarrier{MembarStoreLoad};
}
};
struct Synchronization {
const MemoryBarrier barrierBefore;
const MemoryBarrier barrierAfter;
constexpr Synchronization(MemoryBarrier before, MemoryBarrier after)
: barrierBefore(before), barrierAfter(after) {}
static constexpr Synchronization None() {
return {MemoryBarrier::None(), MemoryBarrier::None()};
}
static constexpr Synchronization Full() {
return {MemoryBarrier::Full(), MemoryBarrier::Full()};
}
static constexpr Synchronization Load() {
return {MemoryBarrier::BeforeLoad(), MemoryBarrier::AfterLoad()};
}
static constexpr Synchronization Store() {
return {MemoryBarrier::BeforeStore(), MemoryBarrier::AfterStore()};
}
constexpr
bool isNone()
const {
return barrierBefore.isNone() && barrierAfter.isNone();
}
};
}
// namespace jit
}
// namespace js
#endif /* jit_AtomicOp_h */
