♻️ Started refactoring instruction.rs
This commit is contained in:
François Autin
parent
3fa3ce0e99
commit
2d241e4dd5
@ -1,3 +1,8 @@
|
||||
//! # Instruction
|
||||
//!
|
||||
//! This module describes the internal representation of an
|
||||
//!
|
||||
|
||||
use core::num::Wrapping; // Permet d'autoriser les overflow pour les opérations voulues
|
||||
use super::global::*;
|
||||
|
||||
@ -22,7 +27,6 @@ const REG_F: [&str; 32] = ["ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7
|
||||
"fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", "fs10", "fs11",
|
||||
"ft8", "ft9", "ft10", "ft11"];
|
||||
|
||||
#[allow(non_snake_case)] // supprimer le warning snake case (quand les noms de variables ont des majuscules)
|
||||
#[derive(Debug)]
|
||||
pub struct Instruction {
|
||||
pub value : u64,
|
||||
@ -52,8 +56,9 @@ pub struct Instruction {
|
||||
pub imm21_1_signed : i32,
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
pub fn decode(val : u64) -> Instruction {
|
||||
impl Instruction {
|
||||
|
||||
pub fn new(val : u64) -> Self {
|
||||
|
||||
let value = val;
|
||||
|
||||
@ -114,9 +119,11 @@ pub fn decode(val : u64) -> Instruction {
|
||||
|
||||
shamt
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pub fn print(ins: Instruction, pc: i32) -> String { //TODO pc should be u64
|
||||
pub fn print_instruction_debug(ins: &Instruction, pc: i32) -> String { //TODO pc should be u64
|
||||
let rd = ins.rd as usize;
|
||||
let rs1 = ins.rs1 as usize;
|
||||
let rs2 = ins.rs2 as usize;
|
||||
@ -313,6 +320,7 @@ pub fn print(ins: Instruction, pc: i32) -> String { //TODO pc should be u64
|
||||
|
||||
}
|
||||
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
#![allow(clippy::unusual_byte_groupings)]
|
||||
@ -321,106 +329,106 @@ mod test {
|
||||
|
||||
#[test]
|
||||
fn test_op() {
|
||||
let sub = decode(0b0100000_10000_10001_000_11100_0110011);
|
||||
let add = decode(0b0000000_10000_10001_000_11100_0110011);
|
||||
let xor = decode(0b0000000_10000_10001_100_11100_0110011);
|
||||
let slr = decode(0b0000000_10000_10001_101_11100_0110011);
|
||||
let sra = decode(0b0100000_10000_10001_101_11100_0110011);
|
||||
let sub = Instruction::new(0b0100000_10000_10001_000_11100_0110011);
|
||||
let add = Instruction::new(0b0000000_10000_10001_000_11100_0110011);
|
||||
let xor = Instruction::new(0b0000000_10000_10001_100_11100_0110011);
|
||||
let slr = Instruction::new(0b0000000_10000_10001_101_11100_0110011);
|
||||
let sra = Instruction::new(0b0100000_10000_10001_101_11100_0110011);
|
||||
|
||||
assert_eq!("sub\tt3,a7,a6", print(sub, 0));
|
||||
assert_eq!("xor\tt3,a7,a6", print(xor, 0));
|
||||
assert_eq!("srl\tt3,a7,a6", print(slr, 0));
|
||||
assert_eq!("sra\tt3,a7,a6", print(sra, 0));
|
||||
assert_eq!("add\tt3,a7,a6", print(add, 0));
|
||||
assert_eq!("sub\tt3,a7,a6", print_instruction_debug(&sub, 0));
|
||||
assert_eq!("xor\tt3,a7,a6", print_instruction_debug(&xor, 0));
|
||||
assert_eq!("srl\tt3,a7,a6", print_instruction_debug(&slr, 0));
|
||||
assert_eq!("sra\tt3,a7,a6", print_instruction_debug(&sra, 0));
|
||||
assert_eq!("add\tt3,a7,a6", print_instruction_debug(&add, 0));
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_opi() {
|
||||
let addi = decode(0b0000000000_10001_000_11100_0010011);
|
||||
let slli = decode(0b0000000000_10001_001_11100_0010011);
|
||||
let slti = decode(0b0000000000_10001_010_11100_0010011);
|
||||
let sltiu = decode(0b0000000000_10001_011_11100_0010011);
|
||||
let xori = decode(0b_0000000000010001_100_11100_0010011);
|
||||
let ori = decode(0b00000000000_10001_110_11100_0010011);
|
||||
let andi = decode(0b000000000000_10001_111_11100_0010011);
|
||||
assert_eq!("andi\tt3,a7,0", print(andi, 0));
|
||||
assert_eq!("addi\tt3,a7,0", print(addi, 0));
|
||||
assert_eq!("slli\tt3,a7,0", print(slli, 0));
|
||||
assert_eq!("slti\tt3,a7,0", print(slti, 0));
|
||||
assert_eq!("sltiu\tt3,a7,0", print(sltiu, 0));
|
||||
assert_eq!("xori\tt3,a7,0", print(xori, 0));
|
||||
assert_eq!("ori\tt3,a7,0", print(ori, 0));
|
||||
let addi = Instruction::new(0b0000000000_10001_000_11100_0010011);
|
||||
let slli = Instruction::new(0b0000000000_10001_001_11100_0010011);
|
||||
let slti = Instruction::new(0b0000000000_10001_010_11100_0010011);
|
||||
let sltiu = Instruction::new(0b0000000000_10001_011_11100_0010011);
|
||||
let xori = Instruction::new(0b_0000000000010001_100_11100_0010011);
|
||||
let ori = Instruction::new(0b00000000000_10001_110_11100_0010011);
|
||||
let andi = Instruction::new(0b000000000000_10001_111_11100_0010011);
|
||||
assert_eq!("andi\tt3,a7,0", print_instruction_debug(&andi, 0));
|
||||
assert_eq!("addi\tt3,a7,0", print_instruction_debug(&addi, 0));
|
||||
assert_eq!("slli\tt3,a7,0", print_instruction_debug(&slli, 0));
|
||||
assert_eq!("slti\tt3,a7,0", print_instruction_debug(&slti, 0));
|
||||
assert_eq!("sltiu\tt3,a7,0", print_instruction_debug(&sltiu, 0));
|
||||
assert_eq!("xori\tt3,a7,0", print_instruction_debug(&xori, 0));
|
||||
assert_eq!("ori\tt3,a7,0", print_instruction_debug(&ori, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_lui() {
|
||||
let lui = decode(0b01110001000011111000_11100_0110111);
|
||||
let lui_negatif = decode(0b11110001000011111000_11100_0110111);
|
||||
assert_eq!("lui\tt3,710f8000", print(lui, 0));
|
||||
assert_eq!("lui\tt3,f10f8000", print(lui_negatif, 0));
|
||||
let lui = Instruction::new(0b01110001000011111000_11100_0110111);
|
||||
let lui_negatif = Instruction::new(0b11110001000011111000_11100_0110111);
|
||||
assert_eq!("lui\tt3,710f8000", print_instruction_debug(&lui, 0));
|
||||
assert_eq!("lui\tt3,f10f8000", print_instruction_debug(&lui_negatif, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ld() {
|
||||
// imm rs1 f3 rd opcode
|
||||
let lb = decode(0b010111110000_10001_000_11100_0000011);
|
||||
let lh = decode(0b010111110000_10001_001_11100_0000011);
|
||||
let lw = decode(0b010111110000_10001_010_11100_0000011);
|
||||
let lbu = decode(0b010111110000_10001_100_11100_0000011);
|
||||
let lhu = decode(0b010111110000_10001_101_11100_0000011);
|
||||
let ld = decode(0b010111110000_10001_011_11100_0000011);
|
||||
let lwu = decode(0b010111110000_10001_110_11100_0000011);
|
||||
let lb = Instruction::new(0b010111110000_10001_000_11100_0000011);
|
||||
let lh = Instruction::new(0b010111110000_10001_001_11100_0000011);
|
||||
let lw = Instruction::new(0b010111110000_10001_010_11100_0000011);
|
||||
let lbu = Instruction::new(0b010111110000_10001_100_11100_0000011);
|
||||
let lhu = Instruction::new(0b010111110000_10001_101_11100_0000011);
|
||||
let ld = Instruction::new(0b010111110000_10001_011_11100_0000011);
|
||||
let lwu = Instruction::new(0b010111110000_10001_110_11100_0000011);
|
||||
|
||||
assert_eq!("lb\tt3,1520(a7)", print(lb, 0));
|
||||
assert_eq!("lh\tt3,1520(a7)", print(lh, 0));
|
||||
assert_eq!("lw\tt3,1520(a7)", print(lw, 0));
|
||||
assert_eq!("lbu\tt3,1520(a7)", print(lbu, 0));
|
||||
assert_eq!("lhu\tt3,1520(a7)", print(lhu, 0));
|
||||
assert_eq!("ld\tt3,1520(a7)", print(ld, 0));
|
||||
assert_eq!("lwu\tt3,1520(a7)", print(lwu, 0));
|
||||
assert_eq!("lb\tt3,1520(a7)", print_instruction_debug(&lb, 0));
|
||||
assert_eq!("lh\tt3,1520(a7)", print_instruction_debug(&lh, 0));
|
||||
assert_eq!("lw\tt3,1520(a7)", print_instruction_debug(&lw, 0));
|
||||
assert_eq!("lbu\tt3,1520(a7)", print_instruction_debug(&lbu, 0));
|
||||
assert_eq!("lhu\tt3,1520(a7)", print_instruction_debug(&lhu, 0));
|
||||
assert_eq!("ld\tt3,1520(a7)", print_instruction_debug(&ld, 0));
|
||||
assert_eq!("lwu\tt3,1520(a7)", print_instruction_debug(&lwu, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_opw() {
|
||||
let addw: Instruction = decode(0b0000000_10000_10001_000_11100_0111011);
|
||||
let sllw: Instruction = decode(0b0000000_10000_10001_001_11100_0111011);
|
||||
let srlw: Instruction = decode(0b0000000_10000_10001_101_11100_0111011);
|
||||
let sraw: Instruction = decode(0b0100000_10000_10001_101_11100_0111011);
|
||||
let addw: Instruction = Instruction::new(0b0000000_10000_10001_000_11100_0111011);
|
||||
let sllw: Instruction = Instruction::new(0b0000000_10000_10001_001_11100_0111011);
|
||||
let srlw: Instruction = Instruction::new(0b0000000_10000_10001_101_11100_0111011);
|
||||
let sraw: Instruction = Instruction::new(0b0100000_10000_10001_101_11100_0111011);
|
||||
|
||||
assert_eq!("addw\tt3,a7,a6", print(addw, 0));
|
||||
assert_eq!("sllw\tt3,a7,a6", print(sllw, 0));
|
||||
assert_eq!("srlw\tt3,a7,a6", print(srlw, 0));
|
||||
assert_eq!("sraw\tt3,a7,a6", print(sraw, 0));
|
||||
assert_eq!("addw\tt3,a7,a6", print_instruction_debug(&addw, 0));
|
||||
assert_eq!("sllw\tt3,a7,a6", print_instruction_debug(&sllw, 0));
|
||||
assert_eq!("srlw\tt3,a7,a6", print_instruction_debug(&srlw, 0));
|
||||
assert_eq!("sraw\tt3,a7,a6", print_instruction_debug(&sraw, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_opwi() {
|
||||
let addiw: Instruction =decode(0b000000000000_10001_000_11100_0011011);
|
||||
let slliw: Instruction = decode(0b0000000_10000_10001_001_11100_0011011);
|
||||
let srai: Instruction = decode(0b010000010001_10001_101_11100_0010011);
|
||||
assert_eq!("addiw\tt3,a7,0x0", print(addiw, 0));
|
||||
assert_eq!("slliw\tt3,a7,0x10", print(slliw, 0));
|
||||
assert_eq!("srai\tt3,a7,17", print(srai, 0));
|
||||
let addiw: Instruction =Instruction::new(0b000000000000_10001_000_11100_0011011);
|
||||
let slliw: Instruction = Instruction::new(0b0000000_10000_10001_001_11100_0011011);
|
||||
let srai: Instruction = Instruction::new(0b010000010001_10001_101_11100_0010011);
|
||||
assert_eq!("addiw\tt3,a7,0x0", print_instruction_debug(&addiw, 0));
|
||||
assert_eq!("slliw\tt3,a7,0x10", print_instruction_debug(&slliw, 0));
|
||||
assert_eq!("srai\tt3,a7,17", print_instruction_debug(&srai, 0));
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_br() {
|
||||
let beq: Instruction = decode(0b0000000_10000_10001_000_00000_1100011);
|
||||
let bne: Instruction = decode(0b0000000_10000_10001_001_00000_1100011);
|
||||
let blt: Instruction = decode(0b0000000_10000_10001_100_00000_1100011);
|
||||
let bge: Instruction = decode(0b0000000_10000_10001_101_00000_1100011);
|
||||
let bge2: Instruction = decode(0x00f75863);
|
||||
let bltu: Instruction = decode(0b0000000_10000_10001_110_00000_1100011);
|
||||
let bgeu: Instruction = decode(0b0000000_10000_10001_111_00000_1100011);
|
||||
assert_eq!("blt\ta7,a6,0", print(blt, 0));
|
||||
assert_eq!("bge\ta7,a6,0", print(bge, 0));
|
||||
assert_eq!("bge\ta4,a5,104d4", print(bge2, 0x104c4));
|
||||
assert_eq!("bltu\ta7,a6,0", print(bltu, 0));
|
||||
assert_eq!("bgeu\ta7,a6,0", print(bgeu, 0));
|
||||
assert_eq!("bne\ta7,a6,0", print(bne, 0));
|
||||
assert_eq!("beq\ta7,a6,0", print(beq, 0));
|
||||
let beq: Instruction = Instruction::new(0b0000000_10000_10001_000_00000_1100011);
|
||||
let bne: Instruction = Instruction::new(0b0000000_10000_10001_001_00000_1100011);
|
||||
let blt: Instruction = Instruction::new(0b0000000_10000_10001_100_00000_1100011);
|
||||
let bge: Instruction = Instruction::new(0b0000000_10000_10001_101_00000_1100011);
|
||||
let bge2: Instruction = Instruction::new(0x00f75863);
|
||||
let bltu: Instruction = Instruction::new(0b0000000_10000_10001_110_00000_1100011);
|
||||
let bgeu: Instruction = Instruction::new(0b0000000_10000_10001_111_00000_1100011);
|
||||
assert_eq!("blt\ta7,a6,0", print_instruction_debug(&blt, 0));
|
||||
assert_eq!("bge\ta7,a6,0", print_instruction_debug(&bge, 0));
|
||||
assert_eq!("bge\ta4,a5,104d4", print_instruction_debug(&bge2, 0x104c4));
|
||||
assert_eq!("bltu\ta7,a6,0", print_instruction_debug(&bltu, 0));
|
||||
assert_eq!("bgeu\ta7,a6,0", print_instruction_debug(&bgeu, 0));
|
||||
assert_eq!("bne\ta7,a6,0", print_instruction_debug(&bne, 0));
|
||||
assert_eq!("beq\ta7,a6,0", print_instruction_debug(&beq, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -433,72 +441,72 @@ mod test {
|
||||
a = a + b;
|
||||
b = a - b;
|
||||
*/
|
||||
assert_eq!("addi sp,sp,-32", print(decode(0xfe010113), 0));
|
||||
assert_eq!("sd s0,24(sp)", print(decode(0x00813c23), 0));
|
||||
assert_eq!("addi s0,sp,32", print(decode(0x02010413), 0));
|
||||
assert_eq!("sw zero,-20(s0)", print(decode(0xfe042623), 0));
|
||||
assert_eq!("addi a5,zero,5", print(decode(0x00500793), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print(decode(0xfef42423), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print(decode(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print(decode(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("mulw a5,a4,a5", print(decode(0x02f707bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print(decode(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print(decode(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("addw a5,a4,a5", print(decode(0x00f707bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print(decode(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print(decode(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("subw a5,a4,a5", print(decode(0x40f707bb), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print(decode(0xfef42423), 0));
|
||||
assert_eq!("addi a5,zero,0", print(decode(0x00000793), 0));
|
||||
assert_eq!("addi a0,a5,0", print(decode(0x00078513), 0));
|
||||
assert_eq!("ld s0,24(sp)", print(decode(0x01813403), 0));
|
||||
assert_eq!("addi sp,sp,32", print(decode(0x02010113), 0));
|
||||
assert_eq!("jalr zero,0(ra)", print(decode(0x00008067), 0));
|
||||
assert_eq!("addi sp,sp,-32", print_instruction_debug(&Instruction::new(0xfe010113), 0));
|
||||
assert_eq!("sd s0,24(sp)", print_instruction_debug(&Instruction::new(0x00813c23), 0));
|
||||
assert_eq!("addi s0,sp,32", print_instruction_debug(&Instruction::new(0x02010413), 0));
|
||||
assert_eq!("sw zero,-20(s0)", print_instruction_debug(&Instruction::new(0xfe042623), 0));
|
||||
assert_eq!("addi a5,zero,5", print_instruction_debug(&Instruction::new(0x00500793), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfef42423), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("mulw a5,a4,a5", print_instruction_debug(&Instruction::new(0x02f707bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("addw a5,a4,a5", print_instruction_debug(&Instruction::new(0x00f707bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("subw a5,a4,a5", print_instruction_debug(&Instruction::new(0x40f707bb), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfef42423), 0));
|
||||
assert_eq!("addi a5,zero,0", print_instruction_debug(&Instruction::new(0x00000793), 0));
|
||||
assert_eq!("addi a0,a5,0", print_instruction_debug(&Instruction::new(0x00078513), 0));
|
||||
assert_eq!("ld s0,24(sp)", print_instruction_debug(&Instruction::new(0x01813403), 0));
|
||||
assert_eq!("addi sp,sp,32", print_instruction_debug(&Instruction::new(0x02010113), 0));
|
||||
assert_eq!("jalr zero,0(ra)", print_instruction_debug(&Instruction::new(0x00008067), 0));
|
||||
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_fibo() {
|
||||
assert_eq!("jal zero,10504", print(decode(0x0500006f), 0x104b4));
|
||||
assert_eq!("blt a4,a5,104b8", print(decode(0xfaf740e3), 0x10518));
|
||||
assert_eq!("jal zero,10504", print_instruction_debug(&Instruction::new(0x0500006f), 0x104b4));
|
||||
assert_eq!("blt a4,a5,104b8", print_instruction_debug(&Instruction::new(0xfaf740e3), 0x10518));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_mul_prog() {
|
||||
assert_eq!("addi sp,sp,-32", print(decode(0xfe010113), 0));
|
||||
assert_eq!("sd s0,24(sp)", print(decode(0x00813c23), 0));
|
||||
assert_eq!("addi s0,sp,32", print(decode(0x02010413), 0));
|
||||
assert_eq!("addi a5,zero,5", print(decode(0x00500793), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print(decode(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print(decode(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("addi a5,a4,0", print(decode(0x00070793), 0));
|
||||
assert_eq!("slliw a5,a5,0x2", print(decode(0x0027979b), 0));
|
||||
assert_eq!("addw a5,a5,a4", print(decode(0x00e787bb), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print(decode(0xfef42423), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print(decode(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("mulw a5,a4,a5", print(decode(0x02f707bb), 0));
|
||||
assert_eq!("sw a5,-28(s0)", print(decode(0xfef42223), 0));
|
||||
assert_eq!("lw a5,-28(s0)", print(decode(0xfe442783), 0));
|
||||
assert_eq!("addi a4,a5,0", print(decode(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print(decode(0xfe842783), 0));
|
||||
assert_eq!("divw a5,a4,a5", print(decode(0x02f747bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print(decode(0xfef42623), 0));
|
||||
assert_eq!("addi a5,zero,0", print(decode(0x00000793), 0));
|
||||
assert_eq!("addi a0,a5,0", print(decode(0x00078513), 0));
|
||||
assert_eq!("ld s0,24(sp)", print(decode(0x01813403), 0));
|
||||
assert_eq!("addi sp,sp,32", print(decode(0x02010113), 0));
|
||||
assert_eq!("jalr zero,0(ra)", print(decode(0x00008067), 0));
|
||||
assert_eq!("addi sp,sp,-32", print_instruction_debug(&Instruction::new(0xfe010113), 0));
|
||||
assert_eq!("sd s0,24(sp)", print_instruction_debug(&Instruction::new(0x00813c23), 0));
|
||||
assert_eq!("addi s0,sp,32", print_instruction_debug(&Instruction::new(0x02010413), 0));
|
||||
assert_eq!("addi a5,zero,5", print_instruction_debug(&Instruction::new(0x00500793), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfef42623), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("addi a5,a4,0", print_instruction_debug(&Instruction::new(0x00070793), 0));
|
||||
assert_eq!("slliw a5,a5,0x2", print_instruction_debug(&Instruction::new(0x0027979b), 0));
|
||||
assert_eq!("addw a5,a5,a4", print_instruction_debug(&Instruction::new(0x00e787bb), 0));
|
||||
assert_eq!("sw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfef42423), 0));
|
||||
assert_eq!("lw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfec42783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("mulw a5,a4,a5", print_instruction_debug(&Instruction::new(0x02f707bb), 0));
|
||||
assert_eq!("sw a5,-28(s0)", print_instruction_debug(&Instruction::new(0xfef42223), 0));
|
||||
assert_eq!("lw a5,-28(s0)", print_instruction_debug(&Instruction::new(0xfe442783), 0));
|
||||
assert_eq!("addi a4,a5,0", print_instruction_debug(&Instruction::new(0x00078713), 0));
|
||||
assert_eq!("lw a5,-24(s0)", print_instruction_debug(&Instruction::new(0xfe842783), 0));
|
||||
assert_eq!("divw a5,a4,a5", print_instruction_debug(&Instruction::new(0x02f747bb), 0));
|
||||
assert_eq!("sw a5,-20(s0)", print_instruction_debug(&Instruction::new(0xfef42623), 0));
|
||||
assert_eq!("addi a5,zero,0", print_instruction_debug(&Instruction::new(0x00000793), 0));
|
||||
assert_eq!("addi a0,a5,0", print_instruction_debug(&Instruction::new(0x00078513), 0));
|
||||
assert_eq!("ld s0,24(sp)", print_instruction_debug(&Instruction::new(0x01813403), 0));
|
||||
assert_eq!("addi sp,sp,32", print_instruction_debug(&Instruction::new(0x02010113), 0));
|
||||
assert_eq!("jalr zero,0(ra)", print_instruction_debug(&Instruction::new(0x00008067), 0));
|
||||
}
|
||||
|
||||
}
|
||||
@ -236,10 +236,10 @@ impl Machine {
|
||||
}
|
||||
|
||||
let val = u32::from_be_bytes(val) as u64;
|
||||
let inst : Instruction = decode(val);
|
||||
let inst : Instruction = Instruction::new(val);
|
||||
self.print_status();
|
||||
println!("executing instruction : {:016x} at pc {:x}", val, self.pc);
|
||||
println!("{}", instruction::print(decode(val), self.pc as i32));
|
||||
println!("{}", instruction::print_instruction_debug(&inst, self.pc as i32));
|
||||
let trace = Self::string_registers(self);
|
||||
self.registers_trace.push_str(format!("{}\n", trace).as_str());
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user