import testlib
from testlib import assertEqual, assertNotEqual, assertIn, assertNotIn
from testlib import assertGreater, assertRegexpMatches, assertLess
-from testlib import GdbTest, GdbSingleHartTest, TestFailed
+from testlib import GdbTest, GdbSingleHartTest, TestFailed, assertTrue
MSTATUS_UIE = 0x00000001
MSTATUS_SIE = 0x00000002
return "".join("%02x" % ord(c) for c in s)
class SimpleRegisterTest(GdbTest):
- def check_reg(self, name):
+ def check_reg(self, name, alias):
a = random.randrange(1<<self.hart.xlen)
b = random.randrange(1<<self.hart.xlen)
self.gdb.p("$%s=0x%x" % (name, a))
+ assertEqual(self.gdb.p("$%s" % alias), a)
self.gdb.stepi()
assertEqual(self.gdb.p("$%s" % name), a)
- self.gdb.p("$%s=0x%x" % (name, b))
+ assertEqual(self.gdb.p("$%s" % alias), a)
+ self.gdb.p("$%s=0x%x" % (alias, b))
+ assertEqual(self.gdb.p("$%s" % name), b)
self.gdb.stepi()
assertEqual(self.gdb.p("$%s" % name), b)
+ assertEqual(self.gdb.p("$%s" % alias), b)
def setup(self):
# 0x13 is nop
class SimpleS0Test(SimpleRegisterTest):
def test(self):
- self.check_reg("s0")
+ self.check_reg("s0", "x8")
class SimpleS1Test(SimpleRegisterTest):
def test(self):
- self.check_reg("s1")
+ self.check_reg("s1", "x9")
class SimpleT0Test(SimpleRegisterTest):
def test(self):
- self.check_reg("t0")
+ self.check_reg("t0", "x5")
class SimpleT1Test(SimpleRegisterTest):
def test(self):
- self.check_reg("t1")
+ self.check_reg("t1", "x6")
class SimpleF18Test(SimpleRegisterTest):
- def check_reg(self, name):
+ def check_reg(self, name, alias):
self.gdb.p_raw("$mstatus=$mstatus | 0x00006000")
self.gdb.stepi()
a = random.random()
b = random.random()
self.gdb.p_raw("$%s=%f" % (name, a))
+ assertLess(abs(float(self.gdb.p_raw("$%s" % alias)) - a), .001)
self.gdb.stepi()
assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - a), .001)
- self.gdb.p_raw("$%s=%f" % (name, b))
+ assertLess(abs(float(self.gdb.p_raw("$%s" % alias)) - a), .001)
+ self.gdb.p_raw("$%s=%f" % (alias, b))
+ assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - b), .001)
self.gdb.stepi()
assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - b), .001)
+ assertLess(abs(float(self.gdb.p_raw("$%s" % alias)) - b), .001)
def early_applicable(self):
return self.hart.extensionSupported('F')
def test(self):
- self.check_reg("f18")
+ self.check_reg("f18", "fs2")
class SimpleMemoryTest(GdbTest):
def access_test(self, size, data_type):
a.write(ihex_line(i * self.line_length, 0, line_data))
a.flush()
+ self.gdb.command("shell cat %s" % a.name)
self.gdb.command("restore %s 0x%x" % (a.name, self.hart.ram))
- for offset in range(0, self.length, 19*4) + [self.length-4]:
+ increment = 19 * 4
+ for offset in range(0, self.length, increment) + [self.length-4]:
value = self.gdb.p("*((int*)0x%x)" % (self.hart.ram + offset))
written = ord(data[offset]) | \
(ord(data[offset+1]) << 8) | \
b = tempfile.NamedTemporaryFile(suffix=".ihex")
self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name,
self.hart.ram, self.hart.ram + self.length))
- for line in b:
+ self.gdb.command("shell cat %s" % b.name)
+ for line in b.xreadlines():
record_type, address, line_data = ihex_parse(line)
if record_type == 0:
written_data = data[address:address+len(line_data)]
self.gdb.thread(t)
pcs.append(self.gdb.p("$pc"))
for pc in pcs:
- assertEqual(self.hart.reset_vector, pc)
+ assertIn(pc, self.hart.reset_vectors)
# mcycle and minstret have no defined reset value.
mstatus = self.gdb.p("$mstatus")
assertEqual(mstatus & (MSTATUS_MIE | MSTATUS_MPRV |
self.exit()
class TooManyHwbp(DebugTest):
- def run(self):
+ def test(self):
for i in range(30):
self.gdb.hbreak("*rot13 + %d" % (i * 4))
def test(self):
# Run to main
- self.gdb.b("main")
- self.gdb.c()
- for t in self.gdb.threads():
- assertIn("main", t.frame)
- self.gdb.command("delete breakpoints")
+ for hart in self.target.harts:
+ self.gdb.select_hart(hart)
+ self.gdb.b("main")
+ self.gdb.c()
+ assertIn("main", self.gdb.where())
+ self.gdb.command("delete breakpoints")
# Run through the entire loop.
- self.gdb.b("main_end")
- self.gdb.c()
+ for hart in self.target.harts:
+ self.gdb.select_hart(hart)
+ self.gdb.b("main_end")
+ self.gdb.c()
+ assertIn("main_end", self.gdb.where())
hart_ids = []
- for t in self.gdb.threads():
- assertIn("main_end", t.frame)
+ for hart in self.target.harts:
+ self.gdb.select_hart(hart)
# Check register values.
- self.gdb.thread(t)
hart_id = self.gdb.p("$x1")
assertNotIn(hart_id, hart_ids)
hart_ids.append(hart_id)
self.gdb.select_hart(hart)
self.gdb.p("$x1=0x%x" % (hart.index * 0x800))
self.gdb.p("$pc=main_post_csrr")
- self.gdb.c()
- for t in self.gdb.threads():
- assertIn("main_end", t.frame)
+ self.gdb.c()
for hart in self.target.harts:
- # Check register values.
self.gdb.select_hart(hart)
+ assertIn("main", self.gdb.where())
+ # Check register values.
for n in range(1, 32):
value = self.gdb.p("$x%d" % n)
assertEqual(value, hart.index * 0x800 + n - 1)
assertEqual(self.gdb.p("status"), self.crc)
os.unlink(self.download_c.name)
-# FIXME: PRIV isn't implemented in the current OpenOCD
#class MprvTest(GdbTest):
# compile_args = ("programs/mprv.S", )
# def setup(self):
# self.gdb.interrupt()
# output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
# assertIn("0xbead", output)
-#
-#class PrivTest(GdbTest):
-# compile_args = ("programs/priv.S", )
-# def setup(self):
-# # pylint: disable=attribute-defined-outside-init
-# self.gdb.load()
-#
-# misa = self.hart.misa
-# self.supported = set()
-# if misa & (1<<20):
-# self.supported.add(0)
-# if misa & (1<<18):
-# self.supported.add(1)
-# if misa & (1<<7):
-# self.supported.add(2)
-# self.supported.add(3)
-#
-#class PrivRw(PrivTest):
-# def test(self):
-# """Test reading/writing priv."""
-# for privilege in range(4):
-# self.gdb.p("$priv=%d" % privilege)
-# self.gdb.stepi()
-# actual = self.gdb.p("$priv")
-# assertIn(actual, self.supported)
-# if privilege in self.supported:
-# assertEqual(actual, privilege)
-#
-#class PrivChange(PrivTest):
-# def test(self):
-# """Test that the core's privilege level actually changes."""
-#
-# if 0 not in self.supported:
-# return 'not_applicable'
-#
-# self.gdb.b("main")
-# self.gdb.c()
-#
-# # Machine mode
-# self.gdb.p("$priv=3")
-# main_address = self.gdb.p("$pc")
-# self.gdb.stepi()
-# assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
-#
-# # User mode
-# self.gdb.p("$priv=0")
-# self.gdb.stepi()
-# # Should have taken an exception, so be nowhere near main.
-# pc = self.gdb.p("$pc")
-# assertTrue(pc < main_address or pc > main_address + 0x100)
+
+class PrivTest(GdbTest):
+ compile_args = ("programs/priv.S", )
+ def setup(self):
+ # pylint: disable=attribute-defined-outside-init
+ self.gdb.load()
+
+ misa = self.hart.misa
+ self.supported = set()
+ if misa & (1<<20):
+ self.supported.add(0)
+ if misa & (1<<18):
+ self.supported.add(1)
+ if misa & (1<<7):
+ self.supported.add(2)
+ self.supported.add(3)
+
+class PrivRw(PrivTest):
+ def test(self):
+ """Test reading/writing priv."""
+ for privilege in range(4):
+ self.gdb.p("$priv=%d" % privilege)
+ self.gdb.stepi()
+ actual = self.gdb.p("$priv")
+ assertIn(actual, self.supported)
+ if privilege in self.supported:
+ assertEqual(actual, privilege)
+
+class PrivChange(PrivTest):
+ def test(self):
+ """Test that the core's privilege level actually changes."""
+
+ if 0 not in self.supported:
+ return 'not_applicable'
+
+ self.gdb.b("main")
+ self.gdb.c()
+
+ # Machine mode
+ self.gdb.p("$priv=3")
+ main_address = self.gdb.p("$pc")
+ self.gdb.stepi()
+ assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
+
+ # User mode
+ self.gdb.p("$priv=0")
+ self.gdb.stepi()
+ # Should have taken an exception, so be nowhere near main.
+ pc = self.gdb.p("$pc")
+ assertTrue(pc < main_address or pc > main_address + 0x100)
parsed = None
def main():
projects / riscv-tests.git / blobdiff