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 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 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 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 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 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 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 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 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 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 }); }
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 }
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 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 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 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 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 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 CsrrwiTest1() { var instCsrrw = InstructionTypeFactory.CreateIType(C.OPSYSTEM, 11, 5, 5, 100); var app = instCsrrw; core.Run(app); var register = core.Register; var csrRegister = core.CsrRegister; var x10 = register.ReadSignedInt(10); var x11 = register.ReadSignedInt(11); var csr100 = csrRegister.Read(100); Assert.AreEqual(x11, 0); Assert.AreEqual(csr100, 5); }
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); }
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 AddITest2() { var program = new List <byte>(); // addi : rd = rd-1 + 1 for (uint rd = 1; rd < 32; rd++) { var instruction = InstructionTypeFactory.CreateIType(C.OPIMM, rd, C.opOPIMMaddi, rd - 1, 1); program.AddRange(instruction); } core.Run(program); for (int registerIndex = 0; registerIndex < 32; registerIndex++) { var value = core.Register.ReadUnsignedLong(registerIndex); Assert.AreEqual(value, registerIndex); } }
public void LhTestWithRSandImmTest1() { core.Load(400, new byte[] { 0x01, 0x02 }); core.Load(600, new byte[] { 0x03, 0x84 }); var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 9, C.opOPIMMaddi, 9, 100); var instLh1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 10, C.OPLOADlh, 9, 300); var instLh2 = InstructionTypeFactory.CreateIType(C.OPLOAD, 11, C.OPLOADlh, 9, 500); var program = instAddi.Concat(instLh1).Concat(instLh2); core.Run(program); var register = core.Register; var x10 = register.ReadBlock(10); var x11 = register.ReadBlock(11); Assert.AreEqual(x10, new byte[] { 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); Assert.AreEqual(x11, new byte[] { 0x03, 0x84, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }); }
public void LbTest1() { core.Load(400, new byte[] { 0x01 }); core.Load(600, new byte[] { 0x83 }); var instLh1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 10, C.OPLOADlb, 0, 400); var instLh2 = InstructionTypeFactory.CreateIType(C.OPLOAD, 11, C.OPLOADlb, 0, 600); var program = instLh1.Concat(instLh2); core.Run(program); var register = core.Register; var x10 = register.ReadBlock(10); var x11 = register.ReadBlock(11); Assert.AreEqual(x10, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); Assert.AreEqual(x11, new byte[] { 0x83, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }); }
public void XorIBitwiseComplementTest1() { var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 0x05); var instAndi = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMxor, 1, 0x0F); var program = new List <byte>(); program.AddRange(instAddi); program.AddRange(instAndi); core.Run(program); var register = core.Register; var x1Block = register.ReadBlock(1); var x2Block = register.ReadBlock(2); Assert.AreEqual(x1Block, new byte[] { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); Assert.AreEqual(x2Block, new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); }
public void SraiTest1() { var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 0x02); var instSrai = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMsrlisrai, 1, 0x401); var program = new List <byte>(); program.AddRange(instAddi); program.AddRange(instSrai); core.Run(program); var register = core.Register; var x1Block = register.ReadBlock(1); var x2Block = register.ReadBlock(2); Assert.AreEqual(x1Block, new byte[] { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); Assert.AreEqual(x2Block, new byte[] { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }); }
public void SllTest1() { // Not tested by this test. Please go to Opcode04 test if this does not work as expected var instAddi1 = InstructionTypeFactory.CreateIType(C.OPIMM, 1, C.opOPIMMaddi, 0, 1); // x1 = 1 var instAddi2 = InstructionTypeFactory.CreateIType(C.OPIMM, 2, C.opOPIMMaddi, 0, 1); // x2 = 1 var instsll1 = InstructionTypeFactory.CreateRType(C.OPOP, 3, C.opOPsll, 1, 2, 0); // x1 left shift (x2) var program = instAddi1.Concat(instAddi2).Concat(instsll1); core.Run(program); var x1Value = core.Register.ReadSignedInt(1); var x2Value = core.Register.ReadSignedInt(2); var x3Value = core.Register.ReadSignedInt(3); Assert.AreEqual(x1Value, 1); Assert.AreEqual(x2Value, 1); Assert.AreEqual(x3Value, 2); }
public void LwAndLwuTest1() { core.Load(400, new byte[] { 0x01, 0x02, 0x03, 0x04 }); core.Load(600, new byte[] { 0x05, 0x06, 0x07, 0x08 }); var instLh1 = InstructionTypeFactory.CreateIType(C.OPLOAD, 10, C.OPLOADlw, 0, 400); var instLh2 = InstructionTypeFactory.CreateIType(C.OPLOAD, 11, C.OPLOADlwu, 0, 600); var program = instLh1.Concat(instLh2); core.Run(program); var register = core.Register; var x10 = register.ReadBlock(10); var x11 = register.ReadBlock(11); Assert.AreEqual(x10, new byte[] { 0x01, 0x02, 0x03, 0x04 }); Assert.AreEqual(x11, new byte[] { 0x05, 0x06, 0x07, 0x08 }); }
public void CsrrwTest2() { var instAddi = InstructionTypeFactory.CreateIType(C.OPIMM, 10, 0, 0, 0xFF); var instCsrrw1 = InstructionTypeFactory.CreateIType(C.OPSYSTEM, 11, 1, 10, 100); var app = instAddi.Concat(instCsrrw1); core.Run(app); var register = core.Register; var csrRegister = core.CsrRegister; var x10 = register.ReadSignedInt(10); var x11 = register.ReadSignedInt(11); var csr100 = csrRegister.Read(100); Assert.AreEqual(x10, 0xFF); Assert.AreEqual(x11, 0); Assert.AreEqual(csr100, 0x1F); }