public void ShWithMaxNegativeImmedateValueTest()
{
int value = 2048 * -1;
var bytes = BitConverter.GetBytes(value);
var instLui1 = InstructionTypeFactory.CreateUType(C.OPLUI, 10, 0xFF);
//var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 10, C.opOPIMMaddi, 0, 0x7FF); // 2K = 2047 = 0x7FF;
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 11, C.opOPIMMaddi, 0, 0x07CD);
var instStore1 = InstructionTypeFactory.CreateSType(C.OPSTORE, C.OPSTOREsh, 10, 11, 0xFFFFF8);
var instLoad1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 12, C.OPLOADlhu, 10, 0xFFFFF8);
var program = new List <byte>();
program.AddRange(instLui1);
//program.AddRange(instAddi1); // x10 = x0 + 200
program.AddRange(instAddi2); // x11 = <Test Content>
program.AddRange(instStore1); // STORE x11 to address 100 + x10
program.AddRange(instLoad1); // x12 = LOAD (x10 + 100)
core.Run(program);
var register = core.Register;
var x10 = register.ReadBlock(10);
var x11 = register.ReadBlock(11);
var x12 = register.ReadBlock(12);
Assert.AreEqual(x10, new byte[] { 0x00, 0xF0, 0x0F, 0x00 });
Assert.AreEqual(x11, new byte[] { 0xCD, 0x07, 0x00, 0x00 });
Assert.AreEqual(x12, new byte[] { 0xCD, 0x07, 0x00, 0x00 });
}
public void AddSubTest2()
{
// Not tested by this test. Please go to Opcode04 test if this does not work as expected
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMaddi, 1, 0xFFF);
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 1, 4);
// x2 = 5, x3 = 4;
var instAdd = InstructionTypeFactory.CreateRType(C.OPOP, 4, C.opOPaddAndSub, 2, 3, C.opOPf7Add);
// x4 = x2 + x3
// x5 = x3 - x2;
// x6 = x2 - x3;
List <byte> program = new List <byte>();
program.AddRange(instAddi1);
program.AddRange(instAddi2);
program.AddRange(instAdd);
core.Run(program);
var x2Value = core.Register.ReadSignedInt(2);
var x3Value = core.Register.ReadSignedInt(3);
var x4Value = core.Register.ReadSignedInt(4);
// Check if X2 and X3 are correct
Assert.AreEqual(x2Value, -1);
Assert.AreEqual(x3Value, 4);
// Check if X4 is correct
Assert.AreEqual(x4Value, 3);
}
public void SwTest1()
{
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 10, C.opOPIMMaddi, 0, 200);
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 11, C.opOPIMMaddi, 0, 0xFFF);
var instLui1 = InstructionTypeFactory.CreateUType(C.OPLUI, 11, 0xFFFF);
var instStore1 = InstructionTypeFactory.CreateSType(C.OPSTORE, C.OPSTOREsw, 10, 11, 100);
var instLoad1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 12, C.OPLOADlwu, 10, 100);
var program = new List <byte>();
program.AddRange(instAddi1); // x10 = x0 + 200
program.AddRange(instAddi2); // x11 = <Test Content>
program.AddRange(instLui1);
program.AddRange(instStore1); // STORE x11 to address 100 + x10
program.AddRange(instLoad1); // x12 = LOAD (x10 + 100)
core.Run(program);
var register = core.Register;
var x10 = register.ReadBlock(10);
var x11 = register.ReadBlock(11);
var x12 = register.ReadBlock(12);
Assert.AreEqual(x10, new byte[] { 0xC8, 0x00, 0x00, 0x00 });
Assert.AreEqual(x11, new byte[] { 0x00, 0xF0, 0xFF, 0x0F });
Assert.AreEqual(x12, new byte[] { 0x00, 0xF0, 0xFF, 0x0F });
}
public void CsrrciTest1()
{
var instCsrrw1 = InstructionTypeFactory.CreateIType(C.OPSYSTEM, 11, 5, 0x1F, 100);
var instCsrrs1 = InstructionTypeFactory.CreateIType(C.OPSYSTEM, 13, 7, 0x02, 100);
// 1. Fill CSR(100) with 0x1F
// 2. Run csrrs from RS1=12
var app = new List <byte>();
app.AddRange(instCsrrw1);
app.AddRange(instCsrrs1);
core.Run(app);
var register = core.Register;
var csrRegister = core.CsrRegister;
var x10 = register.ReadSignedInt(10);
var x11 = register.ReadSignedInt(11);
var x12 = register.ReadSignedInt(12);
var x13 = register.ReadSignedInt(13);
var csr100 = csrRegister.Read(100);
Assert.AreEqual(x13, 0x1F);
Assert.AreEqual(x11, 0x00);
Assert.AreEqual(csr100, 0x1D);
}
public void JalrRasPopTest()
{
// Idee:
// 1. Springe via JAL zu einer Speicherstelle x1 und schreibe eine 1 in ein Register 10
// 2. Von dort springe zurück (via POP)
// 3. Springe via JAL zu einer Speicherstelle x2 und schreibe eine 2 in ein Register 11
// 4. Von dort springe zurück
// 5. Addiere x10 und x11 mit rd = 12
// Testen der Register
var instJal1 = new byte[] { 0xEF, 0x00, 0x00, 0x10 }; // Jump rd = x1 with Offset 0x100
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 11, C.opOPIMMaddi, 0, 1); // X11 = 1;
var program = new List <byte>();
program.AddRange(instJal1);
program.AddRange(instAddi1);
InitJalrSubRoutine();
core.Run(program);
// Test: The subroutine writes x10 and after return x11 is written
var register = core.Register;
var x10 = register.ReadSignedInt(10);
var x11 = register.ReadSignedInt(11);
Assert.AreEqual(x10, 1);
Assert.AreEqual(x11, 1);
}
public void SltiTest1()
{
var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 5); // x1 = 0 + 5;
var instSlti1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMslti, 1, 4); // x2 = x1 < 4 ?
var instSlti2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMslti, 1, 5); // x3 = x1 < 5 ?
var instSlti3 = InstructionTypeFactory.CreateIType(C.OPIMM, 4, C.opOPIMMslti, 1, 6); // x4 = x1 < 6 ?
var program = new List <byte>();
program.AddRange(instAddi);
program.AddRange(instSlti1);
program.AddRange(instSlti2);
program.AddRange(instSlti3);
core.Run(program);
var register = core.Register;
var x1 = register.ReadSignedLong(1);
var x2 = register.ReadSignedLong(2);
var x3 = register.ReadSignedLong(3);
var x4 = register.ReadSignedLong(4);
Assert.AreEqual(x1, 5);
Assert.AreEqual(x2, 0); // 5 < 4 => 0
Assert.AreEqual(x3, 0); // 5 < 5 => 0
Assert.AreEqual(x4, 1); // 5 < 6 => 1
}
public void SlliTest1()
{
var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 0x01);
var instSlli1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMslli, 1, 0x01); // Left Shift of x1 with 1
var instSlli2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMslli, 1, 0x1F); // Left shift of x1 with 0x1F = 31
var instSlli3 = InstructionTypeFactory.CreateIType(C.OPIMM, 4, C.opOPIMMslli, 1, 0x20); // Left shift of x1 with 0x20 = 32
var program = new List <byte>();
program.AddRange(instAddi);
program.AddRange(instSlli1);
program.AddRange(instSlli2);
program.AddRange(instSlli3);
core.Run(program);
var register = core.Register;
var x1Block = register.ReadBlock(1);
var x2Block = register.ReadBlock(2);
var x3Block = register.ReadBlock(3);
var x4Block = register.ReadBlock(4);
Assert.AreEqual(x1Block, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
Assert.AreEqual(x2Block, new byte[] { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); // Just a simple left shift
Assert.AreEqual(x3Block, new byte[] { 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00 }); // Last bit of the register must have 1!
Assert.AreEqual(x4Block, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 }); // Last bit of the register must have 1!
}
public void SraiTest2()
{
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 0x01); // x1 = 0 + 1;
var instSll11 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMslli, 1, 0x20); // Left shift 32
var instSll12 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMslli, 2, 0x1F); // Left Shift 31
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 2, 0x01); // x1 = 0 + 1;
// OK.. We have a 1 at the MSB and 1 at LSB. Run the two shift commands now.
var instSrai1 = InstructionTypeFactory.CreateIType(C.OPIMM, 4, C.opOPIMMsrlisrai, 3, 0x01); // slri (logical mode)
var instSrai2 = InstructionTypeFactory.CreateIType(C.OPIMM, 5, C.opOPIMMsrlisrai, 3, 0x401); // srai (arithmetic mode)
var program = new List <byte>();
program.AddRange(instAddi1);
program.AddRange(instSll11);
program.AddRange(instSll12);
program.AddRange(instAddi2);
program.AddRange(instSrai1);
program.AddRange(instSrai2);
core.Run(program);
var register = core.Register;
var x1Block = register.ReadBlock(1);
var x2Block = register.ReadBlock(2);
var x3Block = register.ReadBlock(3);
var x4Block = register.ReadBlock(4);
var x5Block = register.ReadBlock(5);
Assert.AreEqual(x1Block, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
Assert.AreEqual(x2Block, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 });
Assert.AreEqual(x3Block, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }); // MSB = 1, LSB = 1
Assert.AreEqual(x4Block, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40 }); // Right Shift byte 1 as logical mode
Assert.AreEqual(x5Block, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0 }); // Right Shift byte 1 as arithmetic mode
}
public void SltiuTest2()
{
//
// Tests the SEQZ rd,rs function (...if Immediate = 1...)
//
var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 5); // x1 = 0 + 5;
var instSlti1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMsltiu, 1, 1); // assembler pseudoinstruction SEQZ rd, rs
var instSlti2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMsltiu, 0, 1); // assembler pseudoinstruction SEQZ rd, rs
var program = new List <byte>();
program.AddRange(instAddi);
program.AddRange(instSlti1);
program.AddRange(instSlti2);
core.Run(program);
var register = core.Register;
var x1 = register.ReadSignedLong(1);
var x2 = register.ReadSignedLong(2);
var x3 = register.ReadSignedLong(3);
Assert.AreEqual(x1, 5);
Assert.AreEqual(x2, 0); // X1 != 0 and I = 1 => 0
Assert.AreEqual(x3, 1); // X0 = 0 and I = 1 => 1
}
public void NopDetectionTest()
{
var nop1 = InstructionTypeFactory.CreateNop();
var nop2 = InstructionTypeFactory.CreateIType(C.OPIMM, 0, C.opOPIMMaddi, 0, 0);
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMaddi, 1, 5);
var nop3 = InstructionTypeFactory.CreateIType(C.OPIMM, 0, C.opOPIMMaddi, 0, 0);
// The CPU shall ignore the NOP instructions and execute the ADDI one
var program = new List <byte>();
program.AddRange(nop1);
program.AddRange(nop2);
program.AddRange(instAddi1);
program.AddRange(nop3);
core.Run(program);
var register = core.Register;
var x2 = register.ReadSignedInt(2);
Assert.AreEqual(x2, 5);
var hint = core.Environment;
Assert.AreEqual(3, hint.NopCounter);
}
public void SltuTest1()
{
// Not tested by this test. Please go to Opcode04 test if this does not work as expected
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMaddi, 1, 5);
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 1, 4);
var instSlt1 = InstructionTypeFactory.CreateRType(C.OPOP, 4, C.opOPsltu, 2, 3, 0);
var instSlt2 = InstructionTypeFactory.CreateRType(C.OPOP, 5, C.opOPsltu, 3, 2, 0);
var instSlt3 = InstructionTypeFactory.CreateRType(C.OPOP, 6, C.opOPsltu, 0, 2, C.opOPf2sra);
var instSlt4 = InstructionTypeFactory.CreateRType(C.OPOP, 7, C.opOPsltu, 0, 10, C.opOPf2sra);
var program = instAddi1.Concat(instAddi2).Concat(instSlt1).Concat(instSlt2).Concat(instSlt3).Concat(instSlt4);
core.Run(program);
var x2Value = core.Register.ReadUnsignedInt(2);
var x3Value = core.Register.ReadUnsignedInt(3);
var x4Value = core.Register.ReadUnsignedInt(4);
var x5Value = core.Register.ReadUnsignedInt(5);
var x6Value = core.Register.ReadUnsignedInt(6);
var x7Value = core.Register.ReadUnsignedInt(7);
Assert.AreEqual(x2Value, 5);
Assert.AreEqual(x3Value, 4);
Assert.AreEqual(x4Value, 0); // 5 < 4 = false
Assert.AreEqual(x5Value, 1); // 4 < 5 = true
Assert.AreEqual(x6Value, 1); // x1 != 0 -> true
Assert.AreEqual(x7Value, 0); // x10 == 0 -> false
}
public void SraTest1()
{
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 0x01); // x1 = 0 + 1;
var instSll1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMslli, 1, 0x1F); //x2 = x1 << 32;
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 2, 0x01); // x1 = 0 + 1;
var instAddi3 = InstructionTypeFactory.CreateIType(C.OPIMM, 4, C.opOPIMMaddi, 0, 0x01); // x1 = 0 + 1;
var instsra1 = InstructionTypeFactory.CreateRType(C.OPOP, 5, C.opOPsrlsra, 3, 4, C.opOPf2sra);
// OK.. We have a 1 at the MSB and 1 at LSB. x4 has the shift counter with 1
var program = instAddi1.Concat(instSll1).Concat(instAddi2).Concat(instAddi3).Concat(instsra1);
core.Run(program);
var x1Value = core.Register.ReadBlock(1);
var x2Value = core.Register.ReadBlock(2);
var x3Value = core.Register.ReadBlock(3);
var x4Value = core.Register.ReadBlock(4);
var x5Value = core.Register.ReadBlock(5);
Assert.AreEqual(x1Value, new byte[] { 0x01, 0x00, 0x00, 0x00 });
Assert.AreEqual(x2Value, new byte[] { 0x00, 0x00, 0x00, 0x80 });
Assert.AreEqual(x3Value, new byte[] { 0x01, 0x00, 0x00, 0x80 });
Assert.AreEqual(x4Value, new byte[] { 0x01, 0x00, 0x00, 0x00 });
Assert.AreEqual(x5Value, new byte[] { 0x00, 0x00, 0x00, 0xC0 });
}
private void InitJalrSubRoutine()
{
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 10, C.opOPIMMaddi, 0, 1); // X10 =1
var instJalr1 = InstructionTypeFactory.CreateIType(C.OPJALR, 0, 0, 1, 0); // pop and return
var subRoutine = new List <byte>();
subRoutine.AddRange(instAddi1);
subRoutine.AddRange(instJalr1);
core.Load(0x200, subRoutine);
}
public void LuiTest3()
{
var insLui1 = InstructionTypeFactory.CreateUType(C.OPLUI, 1, 0xFFFFF);
var program = insLui1;
core.Run(program);
var register = core.Register;
var x1 = register.ReadBlock(1);
Assert.AreEqual(x1, new byte[] { 0x00, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF });
}
public void bneTest1()
{
var instBeq = InstructionTypeFactory.CreateBType(C.OPB, 15, 17, C.OPBbne, 0x100);
var program = initBlock.Concat(instBeq);
core.Run(program);
var register = core.Register;
var x11 = register.ReadSignedInt(11);
Assert.AreEqual(x11, 1);
}
public void AddiWTest2()
{
//var program = new byte[] { 0x00, 0x81, 0x00, 0x93, };
var inst1 = InstructionTypeFactory.CreateIType(C.OPIMM32, 1, C.OPIMM32_addiw, 0, 0xFFE); // addi : rd(1) = 0 - 2
var program = inst1;
core.Run(program);
var x1Content = core.Register.ReadBlock(1);
Assert.AreEqual(x1Content, new byte[] { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF });
}
public void LdTest1()
{
core.Load(400, new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 });
var instLh1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 10, C.OPLOADld, 0, 400);
var program = instLh1;
core.Run(program);
var register = core.Register;
var x10 = register.ReadBlock(10);
Assert.AreEqual(x10, new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 });
}
public void AuipcTest2()
{
var insAuipc1 = InstructionTypeFactory.CreateUType(C.OPAUIPC, 1, 0x100);
var program = insAuipc1;
// PC = 100
core.Run(program);
core.BaseAddres = 0x100;
var register = core.Register;
var x1 = register.ReadBlock(1);
Assert.AreEqual(x1, new byte[] { 0x00, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 });
}
public void AuipcTest2()
{
var insAuipc2 = InstructionTypeFactory.CreateUType(C.OPAUIPC, 2, 0x100);
var program = insAuipc2;
// PC = 100
core.Run(program);
core.BaseAddres = 100;
var register = core.Register;
var x2 = register.ReadUnsignedInt(2);
Assert.AreEqual(x2, 0x100100);
}
public void AddITest3()
{
//var program = new byte[] { 0x00, 0x81, 0x00, 0x93, };
var inst1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 2, 0x7FF); // addi : rd(1) = rs(2) + 0x7FF
var program = inst1;
core.Run(program);
var x1Content = core.Register.ReadUnsignedLong(1);
var x3Content = core.Register.ReadUnsignedLong(3);
Assert.AreEqual(x1Content, 0x7FF);
}
public void AuipcTest3()
{
var insAuipc3 = InstructionTypeFactory.CreateUType(C.OPAUIPC, 3, 0xFFF);
var program = insAuipc3;
// PC = 100
core.Run(program);
core.BaseAddres = 100;
var register = core.Register;
var x3 = register.ReadUnsignedInt(3);
Assert.AreEqual(x3, 0xFFF100);
}
public void AuipcTest1()
{
var insAuipc1 = InstructionTypeFactory.CreateUType(C.OPAUIPC, 1, 0x01);
var program = insAuipc1;
// PC = 100
core.Run(program);
core.BaseAddres = 100;
var register = core.Register;
var x1 = register.ReadUnsignedInt(1);
Assert.AreEqual(x1, 0x1100);
}
public void LuiTest1()
{
var insLui1 = InstructionTypeFactory.CreateUType(C.OPLUI, 1, 0x01);
var insLui2 = InstructionTypeFactory.CreateUType(C.OPLUI, 2, 0x100);
var program = insLui1.Concat(insLui2);
core.Run(program);
var register = core.Register;
var x1 = register.ReadBlock(1);
var x2 = register.ReadBlock(2);
Assert.AreEqual(x1, new byte[] { 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
Assert.AreEqual(x2, new byte[] { 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 });
}
public void AddITest1()
{
//var program = new byte[] { 0x00, 0x81, 0x00, 0x93, };
var inst1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 2, 8); // addi : rd(1) = rs(2) + 8
var inst2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 1, 2); // addi : rd(3) = rs(1) + 2
var program = inst1.Concat(inst2);
core.Run(program);
var x1Content = core.Register.ReadUnsignedLong(1);
var x3Content = core.Register.ReadUnsignedLong(3);
Assert.AreEqual(x1Content, 8);
Assert.AreEqual(x3Content, 10);
}
public void JalrTest3()
{
var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 25, 0, 0, 0x05);
var instJalr = InstructionTypeFactory.CreateIType(C.OPJALR, 0, 0, 25, 0x200);
var program = instAddi.Concat(instJalr);
var register = core.Register;
var pc_old = register.ReadUnsignedInt(register.ProgramCounter);
core.Run(program);
var pc_new = register.ReadUnsignedInt(register.ProgramCounter);
Assert.AreNotEqual(pc_old, pc_new);
Assert.AreEqual(pc_new, 0x204);
}
public void RemTest2()
{
program.AddRange(InstructionTypeFactory.Addi(10, 0, 4));
program.AddRange(InstructionTypeFactory.Addi(11, 0, 2));
program.AddRange(InstructionTypeFactory.DivideOP(12, 10, 11, 6));
core.Run(program);
var register = core.Register;
var x10 = register.ReadBlock(10);
var x11 = register.ReadBlock(11);
var x12 = register.ReadBlock(12);
Assert.AreEqual(x10, new byte[] { 0x04, 0x00, 0x00, 0x00 });
Assert.AreEqual(x11, new byte[] { 0x02, 0x00, 0x00, 0x00 });
Assert.AreEqual(x12, new byte[] { 0x00, 0x00, 0x00, 0x00 });
}
public void AddITest4()
{
//var program = new byte[] { 0x00, 0x81, 0x00, 0x93, };
var inst1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 2, 0x7FF); // addi : rd(1) = rs(2) + 0x7FF
var inst2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 1, 0xFFF); // addi : rd(1) = rs(2) + 0x7FF
var program = inst1.Concat(inst2);
core.Run(program);
var x1Content = core.Register.ReadSignedInt(1);
var x3Content = core.Register.ReadSignedInt(3);
Assert.AreEqual(x1Content, 0x7FF);
Assert.AreEqual(x3Content, 0x7FE); // 0x7FF -1 = 0x7FE
}
public void LogicalXorTest1()
{
// Not tested by this test. Please go to Opcode04 test if this does not work as expected
var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMaddi, 1, 9);
var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 3, C.opOPIMMaddi, 1, 6);
var instor1 = InstructionTypeFactory.CreateRType(C.OPOP, 4, C.opOPxor, 2, 3, 0);
var program = instAddi1.Concat(instAddi2).Concat(instor1);
core.Run(program);
var x2Value = core.Register.ReadUnsignedInt(2);
var x3Value = core.Register.ReadUnsignedInt(3);
var x4Value = core.Register.ReadUnsignedInt(4);
Assert.AreEqual(x2Value, 9);
Assert.AreEqual(x3Value, 6);
Assert.AreEqual(x4Value, 0x0F);
}
public void BootStrapCoreInstructionPayloadTest8()
{
//var program = new byte[] { 0xE3, 0x8F, 0x20, 0xFE };
var program = InstructionTypeFactory.CreateBType(C.OPB, 1, 2, 0, 0xFFE);
core.Run(program);
var payloads = core.InstructionPayloads;
Assert.IsTrue(payloads.Count == 1);
var ins1 = payloads.First();
Assert.AreEqual(ins1.OpCode, 0x18);
Assert.AreEqual(ins1.Type, InstructionType.B_Type);
Assert.AreEqual(ins1.Rs1, 1);
Assert.AreEqual(ins1.Rs2, 2);
Assert.AreEqual(ins1.SignedImmediate, 0xFFE);
}
public void JalrTest1()
{
var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 25, 0, 0, 0x04);
var instJalr = InstructionTypeFactory.CreateIType(C.OPJALR, 26, 0, 25, 0x200);
var program = instAddi.Concat(instJalr);
var register = core.Register;
var pc_old = register.ReadUnsignedInt(register.ProgramCounter);
core.Run(program);
var pc_new = register.ReadUnsignedInt(register.ProgramCounter);
var x26 = register.ReadSignedInt(26);
Assert.AreEqual(x26, 0x108); // 100 + Addi (4) + next(4) = 108
Assert.AreNotEqual(pc_old, pc_new);
Assert.AreEqual(pc_new, 0x204);
}
