Struct riscy::RegVal

pub struct RegVal(_);

A struct for representing a value that can be held inside of a general purpose register (eg, x0, x1, ..., x32).

While all general purpose registers are 32-bits wide in rv32i, the interpretation of those bits depends on the operation in question. For example, some instructions (such as lw) treat registers values as signed integers, while other instructions (such as lwu) treat them as unsigned integers.

Therefore, riscy uses this type to prevent programmers from assuming one interpretation or the other, and instead, it forces them to explicitly cast any RegVal to the representation they need.

All immediate values used by the decode module (such as ImmS) can also be cast to RegVal.

// get the value of the first argument register, `a0` (also known as `x10`)
let value = riscv.reg(10);
println!("a0 = {} (as an unsigned integer)", u32::from(value));
println!("a0 = {} (as an   signed integer)", i32::from(value));

Several operations which correspond to register-register instructions (eg, add, xor), are provided as either methods or as traits.

let value1 = RegVal::from_u32(2);
let value2 = RegVal::from_u32(3);

// addition
println!("value1 + value2 = {}", u32::from(value1 + value2));

// bitwise exclusive or
println!("value1 ^ value2 = {}", u32::from(value1 ^ value2));

// left logical shift
println!("value1 << value2 = {}", u32::from(value1.shift_left_logical(value2));

Implementations

impl RegVal

pub fn less_than_signed(&self, other: RegVal) -> bool

Compares two RegVals, interpreting them both as signed integers.

pub fn less_than_unsigned(&self, other: RegVal) -> bool

Compares two RegVals, interpreting them both as unsigned integers.

pub fn greater_than_equal_to_signed(&self, other: RegVal) -> bool

Compares two RegVals, interpreting them both as signed integers.

pub fn greater_than_equal_to_unsigned(&self, other: RegVal) -> bool

Compares two RegVals, interpreting them both as unsigned integers.

pub fn shift_left_logical(&self, other: RegVal) -> RegVal

Does a logical left shift of this register by the value in another register.

A logical left shift is one where the vacant bits are all set to 0.

The value in other is interpreted as an unsigned integer.

The sll instruction (shift left logical) will only ever supply small values for other. The behavior of this function is only guaranteed for values that could come from that instruction.

pub fn shift_right_logical(&self, other: RegVal) -> RegVal

Does a logical right shift of this register by the value in another register.

A logical right shift is one where the vacant bits are all set to 0. This is most common when the register value is interpreted as an unsigned integer, since it has the effect of dividing by 2 to the power of other.

The value in other is interpreted as an unsigned integer.

The srl instruction (shift right logical) will only ever supply small values for other. The behavior of this function is only guaranteed for values that could come from that instruction.

pub fn shift_right_arithmetic(&self, other: RegVal) -> RegVal

Does an arithmetic right shift of this register by the value in another register.

An arithmetic right shift is one where the vacant bits are all set to a copy of the most signfint bit. This is most common when the register value is interpreted as a signed integer, since it has the effect of dividing by 2 to the power of other, while preserving the sign.

The value in other is interpreted as an unsigned integer.

The srl instruction (shift right logical) will only ever supply small values for other. The behavior of this function is only guaranteed for values that could come from that instruction.

pub fn from_u32(val: u32) -> RegVal

pub fn from_i32(val: i32) -> RegVal

pub fn from_addr(addr: Addr) -> RegVal

pub fn to_u32(self) -> u32

pub fn to_i32(self) -> i32

pub fn to_addr(self) -> Addr

Trait Implementations

impl Add<RegVal> for Addr

type Output = Addr

The resulting type after applying the + operator.

pub fn add(self, offset: RegVal) -> Self

Performs the + operation.

impl Add<RegVal> for RegVal

type Output = RegVal

The resulting type after applying the + operator.

pub fn add(self, other: RegVal) -> Self

Performs the + operation.

impl AddAssign<RegVal> for Addr

pub fn add_assign(&mut self, offset: RegVal)

Performs the += operation.

impl BitAnd<RegVal> for RegVal

type Output = RegVal

The resulting type after applying the & operator.

pub fn bitand(self, other: RegVal) -> Self

Performs the & operation.

impl BitOr<RegVal> for RegVal

type Output = RegVal

The resulting type after applying the | operator.

pub fn bitor(self, other: RegVal) -> Self

Performs the | operation.

impl BitXor<RegVal> for RegVal

type Output = RegVal

The resulting type after applying the ^ operator.

pub fn bitxor(self, other: RegVal) -> Self

Performs the ^ operation.

impl Clone for RegVal

pub fn clone(&self) -> RegVal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for RegVal

impl Debug for RegVal

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

Formats the value using the given formatter.

impl Eq for RegVal

impl From<Addr> for RegVal

pub fn from(addr: Addr) -> RegVal

Performs the conversion.

impl From<RegVal> for u32

pub fn from(val: RegVal) -> u32

Performs the conversion.

impl From<RegVal> for i32

pub fn from(val: RegVal) -> i32

Performs the conversion.

impl From<RegVal> for Addr

pub fn from(val: RegVal) -> Addr

Performs the conversion.

impl From<i32> for RegVal

pub fn from(val: i32) -> RegVal

Performs the conversion.

impl From<u32> for RegVal

pub fn from(val: u32) -> RegVal

Performs the conversion.

impl Hash for RegVal

pub 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 PartialEq<RegVal> for RegVal

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

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

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

This method tests for !=.

impl StructuralEq for RegVal

impl StructuralPartialEq for RegVal

impl Sub<RegVal> for RegVal

type Output = RegVal

The resulting type after applying the - operator.

pub fn sub(self, other: RegVal) -> Self

Performs the - operation.