Source code

Revision control

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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef vm_SharedMem_h
#define vm_SharedMem_h
#include <type_traits>
template <typename T>
class SharedMem {
static_assert(std::is_pointer_v<T>, "SharedMem encapsulates pointer types");
enum Sharedness { IsUnshared, IsShared };
T ptr_;
#ifdef DEBUG
Sharedness sharedness_;
#endif
SharedMem(T ptr, Sharedness sharedness)
: ptr_(ptr)
#ifdef DEBUG
,
sharedness_(sharedness)
#endif
{
}
public:
// Create a SharedMem<T> that is an unshared nullptr.
SharedMem()
: ptr_(nullptr)
#ifdef DEBUG
,
sharedness_(IsUnshared)
#endif
{
}
// Create a SharedMem<T> that's shared/unshared in the same way as
// "forSharedness".
SharedMem(T ptr, const SharedMem& forSharedness)
: ptr_(ptr)
#ifdef DEBUG
,
sharedness_(forSharedness.sharedness_)
#endif
{
}
// Create a SharedMem<T> that's marked as shared.
static SharedMem shared(void* p) {
return SharedMem(static_cast<T>(p), IsShared);
}
// Create a SharedMem<T> that's marked as unshared.
static SharedMem unshared(void* p) {
return SharedMem(static_cast<T>(p), IsUnshared);
}
SharedMem& operator=(const SharedMem& that) {
ptr_ = that.ptr_;
#ifdef DEBUG
sharedness_ = that.sharedness_;
#endif
return *this;
}
// Reinterpret-cast the pointer to type U, preserving sharedness.
// Eg, "obj->dataPointerEither().cast<uint8_t*>()" yields a
// SharedMem<uint8_t*>.
template <typename U>
inline SharedMem<U> cast() const {
#ifdef DEBUG
MOZ_ASSERT(
asValue() %
sizeof(std::conditional_t<std::is_void_v<std::remove_pointer_t<U>>,
char, std::remove_pointer_t<U>>) ==
0);
if (sharedness_ == IsUnshared) {
return SharedMem<U>::unshared(unwrap());
}
#endif
return SharedMem<U>::shared(unwrap());
}
explicit operator bool() { return ptr_ != nullptr; }
SharedMem operator+(size_t offset) { return SharedMem(ptr_ + offset, *this); }
SharedMem operator-(size_t offset) { return SharedMem(ptr_ - offset, *this); }
SharedMem operator++() {
ptr_++;
return *this;
}
SharedMem operator++(int) {
SharedMem<T> result(*this);
ptr_++;
return result;
}
SharedMem operator--() {
ptr_--;
return *this;
}
SharedMem operator--(int) {
SharedMem<T> result(*this);
ptr_--;
return result;
}
uintptr_t asValue() const { return reinterpret_cast<uintptr_t>(ptr_); }
// Cast to char*, add nbytes, and cast back to T. Simplifies code in a few
// places.
SharedMem addBytes(size_t nbytes) {
MOZ_ASSERT(
nbytes %
sizeof(std::conditional_t<std::is_void_v<std::remove_pointer_t<T>>,
char, std::remove_pointer_t<T>>) ==
0);
return SharedMem(
reinterpret_cast<T>(reinterpret_cast<char*>(ptr_) + nbytes), *this);
}
T unwrap() const { return ptr_; }
T unwrapUnshared() const {
MOZ_ASSERT(sharedness_ == IsUnshared);
return ptr_;
}
uintptr_t unwrapValue() const { return reinterpret_cast<uintptr_t>(ptr_); }
};
template <typename T>
inline bool operator>=(const SharedMem<T>& a, const SharedMem<T>& b) {
return a.unwrap() >= b.unwrap();
}
template <typename T>
inline bool operator>=(const void* a, const SharedMem<T>& b) {
return a >= b.unwrap();
}
template <typename T>
inline bool operator==(const void* a, const SharedMem<T>& b) {
return a == b.unwrap();
}
template <typename T>
inline bool operator==(const SharedMem<T>& a, decltype(nullptr) b) {
return a.unwrap() == b;
}
template <typename T>
inline bool operator==(const SharedMem<T>& a, const SharedMem<T>& b) {
return a.unwrap() == b.unwrap();
}
template <typename T>
inline bool operator!=(const SharedMem<T>& a, decltype(nullptr) b) {
return a.unwrap() != b;
}
template <typename T>
inline bool operator!=(const SharedMem<T>& a, const SharedMem<T>& b) {
return a.unwrap() != b.unwrap();
}
template <typename T>
inline bool operator>(const SharedMem<T>& a, const SharedMem<T>& b) {
return a.unwrap() > b.unwrap();
}
template <typename T>
inline bool operator>(const void* a, const SharedMem<T>& b) {
return a > b.unwrap();
}
template <typename T>
inline bool operator<=(const SharedMem<T>& a, const SharedMem<T>& b) {
return a.unwrap() <= b.unwrap();
}
template <typename T>
inline bool operator<=(const void* a, const SharedMem<T>& b) {
return a <= b.unwrap();
}
template <typename T>
inline bool operator<(const void* a, const SharedMem<T>& b) {
return a < b.unwrap();
}
#endif // vm_SharedMem_h