aboutsummaryrefslogtreecommitdiff
path: root/src/isa
diff options
context:
space:
mode:
authorDavid Li <li.davidm96@gmail.com>2016-01-14 10:35:40 -0700
committerDavid Li <li.davidm96@gmail.com>2016-01-14 10:35:40 -0700
commit59ae270a4fa286e72f7deef08dcd044828eefe63 (patch)
tree91b6fabdf4e477a5437cf32e5f2d6d1114007ad2 /src/isa
parent36b21d7691bb452a68d857a71c16b9f922b047a2 (diff)
Convert ISA types to newtype structs
Diffstat (limited to 'src/isa')
-rw-r--r--src/isa/mod.rs208
1 files changed, 184 insertions, 24 deletions
diff --git a/src/isa/mod.rs b/src/isa/mod.rs
index 2c20d05..d5a5c14 100644
--- a/src/isa/mod.rs
+++ b/src/isa/mod.rs
@@ -14,18 +14,178 @@
// You should have received a copy of the GNU General Public License
// along with rustv. If not, see <http://www.gnu.org/licenses/>.
+use std::fmt;
+use std::ops;
+
pub mod opcodes;
pub mod funct3;
pub mod funct7;
-pub type Word = u32;
-pub type SignedWord = i32;
-pub type HalfWord = u16;
-pub type SignedHalfWord = i16;
-pub type Byte = u8;
-pub type SignedByte = i8;
+macro_rules! isa_type_op {
+ ($name: ident, $ty: ty, $op: ident, $op_name: ident) => {
+ impl ops::$op<$name> for $name {
+ type Output = $name;
+
+ fn $op_name(self, _rhs: $name) -> $name {
+ $name(ops::$op::$op_name(self.0, _rhs.0))
+ }
+ }
+
+ impl ops::$op<$ty> for $name {
+ type Output = $name;
+
+ fn $op_name(self, _rhs: $ty) -> $name {
+ $name(ops::$op::$op_name(self.0, _rhs))
+ }
+ }
+ }
+}
+
+macro_rules! isa_type_assign_op {
+ ($name: ident, $ty: ty, $op: ident, $op_name: ident) => {
+ impl ops::$op<$name> for $name {
+ fn $op_name(&mut self, _rhs: $name) {
+ ops::$op::$op_name(&mut self.0, _rhs.0)
+ }
+ }
+
+ impl ops::$op<$ty> for $name {
+ fn $op_name(&mut self, _rhs: $ty) {
+ ops::$op::$op_name(&mut self.0, _rhs)
+ }
+ }
+ }
+}
+
+macro_rules! isa_type {
+ ($name: ident, $utype: ty) => {
+ #[derive(Clone,Copy,Debug,Eq,Ord,PartialEq,PartialOrd)]
+ pub struct $name(pub $utype);
+
+ impl $name {
+ pub fn wrapping_add(self, rhs: Self) -> Self {
+ $name(self.0.wrapping_add(rhs.0))
+ }
+
+ pub fn wrapping_sub(self, rhs: Self) -> Self {
+ $name(self.0.wrapping_sub(rhs.0))
+ }
+
+ }
+
+ isa_type_op!($name, $utype, Add, add);
+ isa_type_assign_op!($name, $utype, AddAssign, add_assign);
+ isa_type_op!($name, $utype, Sub, sub);
+ isa_type_op!($name, $utype, Mul, mul);
+ isa_type_op!($name, $utype, Div, div);
+ isa_type_op!($name, $utype, Rem, rem);
+ isa_type_op!($name, $utype, Shr, shr);
+ isa_type_op!($name, $utype, Shl, shl);
+ isa_type_op!($name, $utype, BitAnd, bitand);
+ isa_type_op!($name, $utype, BitOr, bitor);
+ isa_type_op!($name, $utype, BitXor, bitxor);
+
+ impl fmt::LowerHex for $name {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{:x}", self.0)
+ }
+ }
+
+ impl fmt::UpperHex for $name {
+ fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+ write!(f, "{:X}", self.0)
+ }
+ }
+ }
+}
+
+pub trait IsaType {
+ type Unsigned;
+ type Signed;
+
+ fn as_signed(self) -> Self::Signed;
+ fn as_signed_word(self) -> SignedWord;
+ fn as_word(self) -> Word;
+ fn as_half_word(self) -> HalfWord;
+ fn as_byte(self) -> Byte;
+ fn as_address(self) -> Address;
+}
+
+macro_rules! isa_utype {
+ ($name: ident, $signed: ident, $utype: ty, $stype: ty) => {
+ impl IsaType for $name {
+ type Unsigned = $name;
+ type Signed = $signed;
+
+ fn as_signed(self) -> Self::Signed {
+ $signed(self.0 as $stype)
+ }
+
+ fn as_signed_word(self) -> SignedWord {
+ // Convert self to signed so that second cast will
+ // sign-extend
+ SignedWord((self.0 as $stype) as i32)
+ }
+
+ fn as_word(self) -> Word {
+ Word(self.0 as u32)
+ }
+
+ fn as_half_word(self) -> HalfWord {
+ HalfWord(self.0 as u16)
+ }
+
+ fn as_byte(self) -> Byte {
+ Byte(self.0 as u8)
+ }
+
+ fn as_address(self) -> Address {
+ self.as_word()
+ }
+ }
+
+ impl IsaType for $signed {
+ type Unsigned = $name;
+ type Signed = $signed;
+
+ fn as_signed(self) -> Self::Signed {
+ self
+ }
+
+ fn as_signed_word(self) -> SignedWord {
+ SignedWord(self.0 as i32)
+ }
+
+ fn as_word(self) -> Word {
+ Word(self.0 as u32)
+ }
+
+ fn as_half_word(self) -> HalfWord {
+ HalfWord(self.0 as u16)
+ }
+
+ fn as_byte(self) -> Byte {
+ Byte(self.0 as u8)
+ }
+
+ fn as_address(self) -> Address {
+ self.as_word()
+ }
+ }
+ }
+}
+
+isa_type!(Word, u32);
+isa_type!(SignedWord, i32);
+isa_utype!(Word, SignedWord, u32, i32);
+isa_type!(HalfWord, u16);
+isa_type!(SignedHalfWord, i16);
+isa_utype!(HalfWord, SignedHalfWord, u16, i16);
+isa_type!(Byte, u8);
+isa_type!(SignedByte, i8);
+isa_utype!(Byte, SignedByte, u8, i8);
-pub type Address = u32;
+pub type Address = Word;
#[derive(Debug, PartialEq)]
pub enum Register {
@@ -111,52 +271,52 @@ impl Register {
pub struct Instruction {
// TODO: rename word to something correct - instructions are not always a
// word
- word: u32,
+ word: Word,
}
impl Instruction {
- pub fn new(word: u32) -> Instruction {
+ pub fn new(word: Word) -> Instruction {
Instruction {
word: word,
}
}
pub fn opcode(&self) -> u32 {
- self.word & 0x7F
+ (self.word & 0x7F).0
}
pub fn rd(&self) -> Register {
- Register::from_num((self.word >> 7) & 0x1F)
+ Register::from_num(((self.word >> 7) & 0x1F).0)
}
pub fn funct3(&self) -> u32 {
- (self.word >> 12) & 0x7
+ ((self.word >> 12) & 0x7).0
}
pub fn funct7(&self) -> u32 {
- (self.word >> 25) & 0x7F
+ ((self.word >> 25) & 0x7F).0
}
pub fn shamt(&self) -> u32 {
- (self.word >> 20) & 0x1F
+ ((self.word >> 20) & 0x1F).0
}
pub fn rs1(&self) -> Register {
- Register::from_num((self.word >> 15) & 0x1F)
+ Register::from_num(((self.word >> 15) & 0x1F).0)
}
pub fn rs2(&self) -> Register {
- Register::from_num((self.word >> 20) & 0x1F)
+ Register::from_num(((self.word >> 20) & 0x1F).0)
}
pub fn i_imm(&self) -> SignedWord {
- (self.word as SignedWord) >> 20
+ (self.word.as_signed_word()) >> 20
}
pub fn s_imm(&self) -> SignedWord {
let low = (self.word >> 7) & 0x1F;
- let high = ((self.word as SignedWord) >> 25) as Word;
- ((high << 5) | low) as SignedWord
+ let high = ((self.word.as_signed_word()) >> 25).as_word();
+ ((high << 5) | low).as_signed_word()
}
pub fn uj_imm(&self) -> SignedWord {
@@ -165,19 +325,19 @@ impl Instruction {
let low11 = (self.word >> 20) & 0x1;
let low12 = (self.word >> 12) & 0xFF;
// Want sign-extension
- let low20 = ((self.word as SignedWord) >> 30) as Word;
- ((low20 << 20) | (low12 << 12) | (low11 << 11) | (low1 << 1)) as SignedWord
+ let low20 = ((self.word.as_signed_word()) >> 30).as_word();
+ ((low20 << 20) | (low12 << 12) | (low11 << 11) | (low1 << 1)).as_signed_word()
}
pub fn sb_imm(&self) -> SignedWord {
let low1 = (self.word >> 8) & 0xF;
let low5 = (self.word >> 25) & 0x3F;
let low11 = (self.word >> 7) & 0x1;
- let low12 = ((self.word as SignedWord) >> 31) as Word;
- ((low12 << 12) | (low11 << 11) | (low5 << 5) | (low1 << 1)) as SignedWord
+ let low12 = ((self.word.as_signed_word()) >> 31).as_word();
+ ((low12 << 12) | (low11 << 11) | (low5 << 5) | (low1 << 1)).as_signed_word()
}
pub fn u_imm(&self) -> SignedWord {
- (self.word & 0xFFFFF000) as SignedWord
+ (self.word & 0xFFFFF000).as_signed_word()
}
}