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); }