def test_sw(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("sw $s0, 4($s1)")
p.reg[16] = 0xdeadbeef
p.reg[17] = 0x2f8 - 4
p.do_instr(the_cmd)
self.assertListEqual(list(p.mem[0x2f8:0x2f8 + 4]),
[0xef, 0xbe, 0xad, 0xde])
the_cmd = CMDParse.parse_cmd("sw $s0, 0($s1)")
p.reg[16] = 0xdeadbeef
p.reg[17] = 1
try:
p.do_instr(the_cmd)
self.assertTrue(
False,
"Cannot store to not naturally aligned memory addresses.")
except AddressError:
pass
def test_noop(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("noop")
p.pc = 12
p.do_instr(the_cmd)
self.assertEqual(p.pc, 16)
def test_syscall(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("syscall")
try:
p.do_instr(the_cmd)
self.assertTrue(False, "Software interrupt not thrown on syscall.")
except SoftwareInterrupt:
pass
def test_jal(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("jal 0xf")
p.pc = np.uint32(0xa)
p.reg[31] = 0x0
p.do_instr(the_cmd)
self.assertEqual(p.pc, 0xf * 4)
self.assertEqual(p.reg[31], 0xa + 8)
p.pc = np.uint32(0xa00000ba)
p.reg[31] = 0x0
p.do_instr(the_cmd)
self.assertEqual(p.pc, np.bitwise_or(0xa0000000, 0xf * 4))
self.assertEqual(p.reg[31], 0xa00000ba + 8)
def test_ori(self):
p = MIPSProcessor()
for i in range(100):
imm = np.uint32(random.getrandbits(32))
rt = random.randint(8, 23)
rs = random.randint(8, 23)
rsval = np.uint32(random.getrandbits(32))
p.reg[rs] = rsval
res = np.bitwise_or(rsval, imm)
p._ori(rt, rs, imm)
self.assertEqual(p.reg[rt], res)
def test_jr(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("jr $s0")
p.pc = np.uint32(0xa)
p.reg[16] = 0xf * 4
p.do_instr(the_cmd)
self.assertEqual(p.pc, 0xf * 4)
p.pc = np.uint32(0xa)
p.reg[16] = 0xf
try:
p.do_instr(the_cmd)
self.assertTrue(
False,
"Branching to a non 4-byte aligned address isn't allowed.")
except AddressError:
pass
def test_divu(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("divu $s0, $s1")
p.reg[16] = 14
p.reg[17] = 4
p.do_instr(the_cmd)
self.assertEqual(p.hi, 2)
self.assertEqual(p.lo, 3)
p.reg[16] = np.uint32(-14)
p.reg[17] = 4
p.do_instr(the_cmd)
self.assertEqual(p.hi, 2)
self.assertEqual(p.lo, 1073741820)
def test_mflo(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("mflo $s0")
p.lo = 55
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 55)
p.lo = -55
p.do_instr(the_cmd)
self.assertEqual(np.int32(p.reg[16]), -55)
def test_sllv(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("sllv $s0, $s1, $s2")
p.reg[16] = 0x0
p.reg[17] = 0xa
p.reg[18] = 0xa
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], np.left_shift(0xa, 10))
def test_sltu(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("sltu $s0, $s1, $s2")
p.reg[16] = 0x0
p.reg[17] = np.uint32(-10)
p.reg[18] = np.uint32(0)
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 0)
def test_srlv(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("srlv $s0, $s1, $s2")
p.reg[16] = 0x0
p.reg[17] = 0xabbaabba
p.reg[18] = 0xa
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], np.right_shift(0xabbaabba, 0xa))
def test_lw(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("lw $s0, 4($s1)")
p.mem[0x2f8:0x2f8 + 4] = np.uint32([0xdeadbeef]).view('uint8')
p.reg[16] = 0x0
p.reg[17] = 0x2f8 - 4
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 0xdeadbeef)
def test_beq(self):
p = MIPSProcessor()
beq_cmd = CMDParse.parse_cmd("beq $t0, $s0, 0x3")
p.pc = 10
p.reg[8] = 10
p.reg[16] = 10
p.do_instr(beq_cmd)
self.assertEqual(p.pc, 26)
def test_sb(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("sb $s0, 4($s1)")
p.reg[16] = 0xabba
p.reg[17] = 0x2f8 - 4
p.do_instr(the_cmd)
self.assertEqual(p.mem[0x2f8], 0xba)
def test_sra(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("sra $s0, $s1, 2")
p.reg[16] = 0x0
p.reg[17] = np.uint32(-200)
p.do_instr(the_cmd)
self.assertEqual(np.int32(p.reg[16]), -50)
def test_srl(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("srl $s0, $s1, 2")
p.reg[16] = 0x0
p.reg[17] = np.uint32(-200)
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 1073741774)
def test_lui(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("lui $s0, 0xabba")
p.reg[16] = 0x0
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 0xabba0000)
the_cmd = CMDParse.parse_cmd("lui $s0, 0xdead")
p.reg[16] = 0xbeef
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 0xdead0000)
def test_or(self):
p = MIPSProcessor()
for i in range(100):
a = np.uint32(random.getrandbits(32))
b = np.uint32(random.getrandbits(32))
p.reg[11] = a
p.reg[12] = b
c = np.bitwise_or(a, b)
p._or(10, 11, 12)
self.assertEqual(p.reg[10], c)
def test_mult(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("mult $s0, $s1")
p.reg[16] = 0xabbaabba
p.reg[17] = 0x9ba461595
p.do_instr(the_cmd)
res = np.int64(np.uint32([p.lo, p.hi]).view('int64')[0])
self.assertEqual(
res,
np.int64(np.int32(0xabbaabba)) * np.int64(np.int32(0x9ba461595)))
def test_and(self):
""" Test and $rd, $rs, $rt """
p = MIPSProcessor()
for i in range(100):
a = np.uint32(random.getrandbits(32))
b = np.uint32(random.getrandbits(32))
p.reg[11] = a
p.reg[12] = b
c = np.bitwise_and(a, b)
p._and(10, 11, 12)
self.assertEqual(p.reg[10], c)
def test_subu(self):
""" Test subu $rd, $rs, $rt """
p = MIPSProcessor()
p.reg[10] = 11
p.reg[11] = 22
p.reg[12] = 3
p._subu(10, 11, 12)
self.assertEqual(p.reg[10], 19)
p.reg[11] = 2**32 - 1
p.reg[12] = -1
p._subu(10, 11, 12)
self.assertEqual(p.reg[10], 0)
p.reg[11] = 0
p.reg[12] = 1
p._subu(10, 11, 12)
self.assertEqual(p.reg[10], 2**32 - 1)
def test_sub(self):
p = MIPSProcessor()
p.reg[10] = 11
p.reg[11] = 22
p.reg[12] = 3
p._sub(10, 11, 12)
self.assertEqual(p.reg[10], 19)
try:
p.reg[11] = 2**31 - 1 # INT_MAX - -2 = overflow
p.reg[12] = -1
p._sub(10, 11, 12)
except IntegerOverflow:
pass
try:
p.reg[11] = -2**31 # INT_MIN - 2 = overflow
p.reg[12] = 1
p._sub(10, 11, 12)
except IntegerOverflow:
pass
inst = CMDParse.parse_cmd("sub $s3, $s4, $s5")
p.reg[19] = 2
p.reg[20] = 22
p.reg[21] = 11
p.do_instr(inst)
self.assertEqual(p.reg[19], 11)
def test_add(self):
p = MIPSProcessor()
p.reg[10] = 11
p.reg[11] = 22
p.reg[12] = 3
p._add(10, 11, 12)
self.assertEqual(p.reg[10], 25)
try:
p.reg[11] = 2**31 - 1 # INT_MAX + 1 = overflow
p.reg[12] = 1
p._add(10, 11, 12)
self.assertTrue(False)
except IntegerOverflow:
pass
try:
p.reg[11] = -2**31 # INT_MIN - 2 = overflow
p.reg[12] = -2
p._add(10, 11, 12)
self.assertTrue(False)
except IntegerOverflow:
pass
inst = CMDParse.parse_cmd("add $s3, $s4, $s5")
p.reg[19] = 2
p.reg[20] = 11
p.reg[21] = 22
p.do_instr(inst)
self.assertEqual(p.reg[19], 33)
def test_addi(self):
p = MIPSProcessor()
p.reg[10] = 5
p._addi(11, 10, 0x5)
self.assertEqual(p.reg[11], 10)
try:
p.reg[10] = 2**31 - 1
p._addi(11, 10, 2)
self.assertTrue(False)
except IntegerOverflow:
pass
try:
p.reg[10] = -2**31
p._addi(11, 10, -2)
self.assertTrue(False)
except IntegerOverflow:
pass
inst = CMDParse.parse_cmd("addi $s3, $s4, 0xa")
p.reg[19] = 2
p.reg[20] = 11
p.do_instr(inst)
self.assertEqual(p.reg[19], 21)
def test_addiu(self):
p = MIPSProcessor()
p.reg[10] = 5
p._addiu(11, 10, 2)
self.assertEqual(p.reg[11], 7)
p.reg[10] = 2**32 - 1
p._addiu(11, 10, 2)
self.assertEqual(p.reg[11], 1)
p.reg[10] = 1
p._addiu(11, 10, -2)
self.assertEqual(p.reg[11], 2**32 - 1)
def test_addu(self):
""" Test addu $rd, $rs, $rt """
p = MIPSProcessor()
p.reg[10] = 11
p.reg[11] = 22
p.reg[12] = 3
p._addu(10, 11, 12)
self.assertEqual(p.reg[10], 25)
p.reg[11] = 2**32 - 1
p.reg[12] = 2
p._addu(10, 11, 12)
self.assertTrue(p.reg[10], 1)
p.reg[11] = 0
p.reg[12] = -1
p._addu(10, 11, 12)
self.assertTrue(p.reg[10], 2**32 - 1)
def test_bltz(self):
p = MIPSProcessor()
bgez_cmd = CMDParse.parse_cmd("bltz $s0, 0xa")
p.pc = 10
p.reg[16] = np.uint32(-5)
p.do_instr(bgez_cmd)
self.assertEqual(p.pc, 54)
p.pc = 10
p.reg[16] = 0
p.do_instr(bgez_cmd)
self.assertEqual(p.pc, 14)
p.pc = 10
p.reg[16] = 22
p.do_instr(bgez_cmd)
self.assertEqual(p.pc, 14)
def test_bltzal(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("bltzal $s0, 0xa")
p.pc = 10
p.reg[16] = np.uint32(-5)
p.reg[31] = 0
p.do_instr(the_cmd)
self.assertEqual(p.pc, 54)
self.assertEqual(p.reg[31], 18)
p.pc = 10
p.reg[16] = 0
p.reg[31] = 0
p.do_instr(the_cmd)
self.assertEqual(p.pc, 14)
self.assertEqual(p.reg[31], 0)
p.pc = 10
p.reg[16] = 22
p.reg[31] = 0
p.do_instr(the_cmd)
self.assertEqual(p.pc, 14)
self.assertEqual(p.reg[31], 0)
def test_bne(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("bne $t0, $s0, 0xa")
p.pc = 10
p.reg[8] = 10
p.reg[16] = 10
p.do_instr(the_cmd)
self.assertEqual(p.pc, 14)
p.pc = 10
p.reg[8] = 10
p.reg[16] = 9
p.do_instr(the_cmd)
self.assertEqual(p.pc, 54)
def test_lb(self):
p = MIPSProcessor()
the_cmd = CMDParse.parse_cmd("lb $s0, 4($s1)")
p.mem[0x2f8] = 77
p.reg[16] = 0x0
p.reg[17] = 0x2f8 - 4
p.do_instr(the_cmd)
self.assertEqual(p.reg[16], 77)
p.mem[0x2f8] = np.uint8(-96)
p.reg[16] = 0x0
p.reg[17] = 0x2f8 - 4
p.do_instr(the_cmd)
self.assertEqual(np.int32(p.reg[16]), -96)
