Struct mmtk::util::address::Address

#[repr(transparent)]pub struct Address(_);

Address represents an arbitrary address. This is designed to represent address and do address arithmetic mostly in a safe way, and to allow mark some operations as unsafe. This type needs to be zero overhead (memory wise and time wise). The idea is from the paper High-level Low-level Programming (VEE09) and JikesRVM.

Implementations

impl Address

pub const ZERO: Self

pub const MAX: Self

pub fn from_ptr<T>(ptr: *const T) -> Address

creates Address from a pointer

pub fn from_ref<T>(r: &T) -> Address

pub fn from_mut_ptr<T>(ptr: *mut T) -> Address

creates Address from a mutable pointer

pub const unsafe fn zero() -> Address

creates a null Address (0)

Safety

It is unsafe and the user needs to be aware that they are creating an invalid address. The zero address should only be used as unininitialized or sentinel values in performance critical code (where you dont want to use Option

).

pub unsafe fn max() -> Address

creates an Address of (usize::MAX)

Safety

It is unsafe and the user needs to be aware that they are creating an invalid address. The max address should only be used as unininitialized or sentinel values in performance critical code (where you dont want to use Option

).

pub const unsafe fn from_usize(raw: usize) -> Address

creates an arbitrary Address

Safety

It is unsafe and the user needs to be aware that they may create an invalid address. This creates arbitrary addresses which may not be valid. This should only be used for hard-coded addresses. Any other uses of this function could be replaced with more proper alternatives.

pub fn shift<T>(self, offset: isize) -> Self

shifts the address by N T-typed objects (returns addr + N * size_of(T))

pub const fn get_extent(self, other: Address) -> ByteSize

pub const fn get_offset(self, other: Address) -> ByteOffset

pub const fn add(self, size: usize) -> Address

pub unsafe fn load<T: Copy>(self) -> T

loads a value of type T from the address

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn store<T>(self, value: T)

stores a value of type T to the address

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn atomic_load<T: Atomic>(self, order: Ordering) -> T::Type

atomic operation: load

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn atomic_store<T: Atomic>(self, val: T::Type, order: Ordering)

atomic operation: store

Safety

This could throw a segment fault if the address is invalid

pub unsafe fn compare_exchange<T: Atomic>(
    self,
    old: T::Type,
    new: T::Type,
    success: Ordering,
    failure: Ordering
) -> Result<T::Type, T::Type>

atomic operation: compare and exchange usize

Safety

This could throw a segment fault if the address is invalid

pub fn is_zero(self) -> bool

is this address zero?

pub const fn align_up(self, align: ByteSize) -> Address

aligns up the address to the given alignment

pub const fn align_down(self, align: ByteSize) -> Address

aligns down the address to the given alignment

pub fn is_aligned_to(self, align: usize) -> bool

is this address aligned to the given alignment

pub unsafe fn to_object_reference(self) -> ObjectReference

converts the Address into an ObjectReference

Safety

We would expect ObjectReferences point to valid objects, but an arbitrary Address may not reside an object. This conversion is unsafe, and it is the user’s responsibility to ensure the safety.

pub fn to_ptr<T>(self) -> *const T

converts the Address to a pointer

pub fn to_mut_ptr<T>(self) -> *mut T

converts the Address to a mutable pointer

pub const fn as_usize(self) -> usize

converts the Address to a pointer-sized integer

pub fn chunk_index(self) -> usize

returns the chunk index for this address

pub fn is_mapped(self) -> bool

return true if the referenced memory is mapped

Trait Implementations

impl Add<isize> for Address

Address + ByteOffset (positive or negative)

type Output = Address

The resulting type after applying the + operator.

fn add(self, offset: ByteOffset) -> Address

Performs the + operation.

impl Add<usize> for Address

Address + ByteSize (positive)

type Output = Address

The resulting type after applying the + operator.

fn add(self, offset: ByteSize) -> Address

Performs the + operation.

impl AddAssign<isize> for Address

Address += ByteOffset (positive or negative)

fn add_assign(&mut self, offset: ByteOffset)

Performs the += operation.

impl AddAssign<usize> for Address

Address += ByteSize (positive)

fn add_assign(&mut self, offset: ByteSize)

Performs the += operation.

impl BitAnd<u8> for Address

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, other: u8) -> u8

Performs the & operation.

impl BitAnd<usize> for Address

Address & mask

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, other: usize) -> usize

Performs the & operation.

impl BitOr<u8> for Address

type Output = usize

The resulting type after applying the | operator.

fn bitor(self, other: u8) -> usize

Performs the | operation.

impl BitOr<usize> for Address

Address | mask

type Output = usize

The resulting type after applying the | operator.

fn bitor(self, other: usize) -> usize

Performs the | operation.

impl Clone for Address

fn clone(&self) -> Address

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Address

impl Debug for Address

allows Debug format the Address (as upper-case hex value with 0x prefix)

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Address

allows Display format the Address (as upper-case hex value with 0x prefix)

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Address

impl Hash for Address

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl LowerHex for Address

allows print Address as lower-case hex value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<Address> for Address

fn eq(&self, other: &Address) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Address) -> bool

This method tests for !=.

impl PartialOrd<Address> for Address

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Shl<usize> for Address

Address << shift (get an index)

type Output = usize

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> usize

Performs the << operation.

impl Shr<usize> for Address

Address >> shift (get an index)

type Output = usize

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> usize

Performs the >> operation.

impl StructuralEq for Address

impl StructuralPartialEq for Address

impl Sub<Address> for Address

Address - Address (the first address must be higher)

type Output = ByteSize

The resulting type after applying the - operator.

fn sub(self, other: Address) -> ByteSize

Performs the - operation.

impl Sub<usize> for Address

Address - ByteSize (positive)

type Output = Address

The resulting type after applying the - operator.

fn sub(self, offset: ByteSize) -> Address

Performs the - operation.

impl SubAssign<usize> for Address

Address -= ByteSize (positive)

fn sub_assign(&mut self, offset: ByteSize)

Performs the -= operation.

impl UpperHex for Address

allows print Address as upper-case hex value

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.