X-Git-Url: https://git.libre-soc.org/?p=riscv-tests.git;a=blobdiff_plain;f=debug%2Fgdbserver.py;h=8a6e87439a124f9835ba8b81f8cea43ee505276f;hp=0f5c28e50430b3a38257630909dc83c87e1000fd;hb=37a93a9f86521aea2758271a1cc87c23bca06f59;hpb=3ed5afdc5b7e2c32bc6facf410c8fa091dd55470 diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 0f5c28e..8a6e874 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -10,6 +10,50 @@ import time import random import binascii + +MSTATUS_UIE = 0x00000001 +MSTATUS_SIE = 0x00000002 +MSTATUS_HIE = 0x00000004 +MSTATUS_MIE = 0x00000008 +MSTATUS_UPIE = 0x00000010 +MSTATUS_SPIE = 0x00000020 +MSTATUS_HPIE = 0x00000040 +MSTATUS_MPIE = 0x00000080 +MSTATUS_SPP = 0x00000100 +MSTATUS_HPP = 0x00000600 +MSTATUS_MPP = 0x00001800 +MSTATUS_FS = 0x00006000 +MSTATUS_XS = 0x00018000 +MSTATUS_MPRV = 0x00020000 +MSTATUS_PUM = 0x00040000 +MSTATUS_MXR = 0x00080000 +MSTATUS_VM = 0x1F000000 +MSTATUS32_SD = 0x80000000 +MSTATUS64_SD = 0x8000000000000000 + +def gdb( + target=None, + port=None, + binary=None + ): + + gdb = None + if parsed.gdb: + gdb = testlib.Gdb(parsed.gdb) + else: + gdb = testlib.Gdb() + + if (binary): + gdb.command("file %s" % self.binary) + if (target): + gdb.command("set arch riscv:rv%d" % target.xlen) + gdb.command("set remotetimeout %d" % target.timeout_sec) + if (port): + gdb.command("target extended-remote localhost:%d" % port) + + return gdb + + def ihex_line(address, record_type, data): assert len(data) < 128 line = ":%02X%04X%02X" % (len(data), address, record_type) @@ -35,6 +79,9 @@ def ihex_parse(line): data += "%c" % int(line[8+2*i:10+2*i], 16) return record_type, address, data +def readable_binary_string(s): + return "".join("%02x" % ord(c) for c in s) + class DeleteServer(unittest.TestCase): def tearDown(self): del self.server @@ -42,8 +89,7 @@ class DeleteServer(unittest.TestCase): class SimpleRegisterTest(DeleteServer): def setUp(self): self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port) # 0x13 is nop self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram) @@ -80,10 +126,11 @@ class SimpleRegisterTest(DeleteServer): class SimpleMemoryTest(DeleteServer): def setUp(self): self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port) def access_test(self, size, data_type): + self.assertEqual(self.gdb.p("sizeof(%s)" % data_type), + size) a = 0x86753095555aaaa & ((1<<(size*8))-1) b = 0xdeadbeef12345678 & ((1<<(size*8))-1) self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram, a)) @@ -98,7 +145,7 @@ class SimpleMemoryTest(DeleteServer): self.access_test(2, 'short') def test_32(self): - self.access_test(4, 'long') + self.access_test(4, 'int') def test_64(self): self.access_test(8, 'long long') @@ -106,42 +153,43 @@ class SimpleMemoryTest(DeleteServer): def test_block(self): length = 1024 line_length = 16 - fd = file("write.ihex", "w") + a = tempfile.NamedTemporaryFile(suffix=".ihex") data = "" for i in range(length / line_length): line_data = "".join(["%c" % random.randrange(256) for _ in range(line_length)]) data += line_data - fd.write(ihex_line(i * line_length, 0, line_data)) - fd.close() + a.write(ihex_line(i * line_length, 0, line_data)) + a.flush() - self.gdb.command("restore write.ihex 0x%x" % target.ram) + self.gdb.command("restore %s 0x%x" % (a.name, target.ram)) for offset in range(0, length, 19*4) + [length-4]: - value = self.gdb.p("*((long*)0x%x)" % (target.ram + offset)) + value = self.gdb.p("*((int*)0x%x)" % (target.ram + offset)) written = ord(data[offset]) | \ (ord(data[offset+1]) << 8) | \ (ord(data[offset+2]) << 16) | \ (ord(data[offset+3]) << 24) self.assertEqual(value, written) - self.gdb.command("dump ihex memory read.ihex 0x%x 0x%x" % (target.ram, + b = tempfile.NamedTemporaryFile(suffix=".ihex") + self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name, target.ram, target.ram + length)) - for line in file("read.ihex"): + for line in b: record_type, address, line_data = ihex_parse(line) if (record_type == 0): - self.assertEqual(line_data, data[address:address+len(line_data)]) + self.assertEqual(readable_binary_string(line_data), + readable_binary_string(data[address:address+len(line_data)])) class InstantHaltTest(DeleteServer): def setUp(self): self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("target extended-remote localhost:%d" % self.server.port) - + self.gdb = gdb(target, self.server.port) + def test_instant_halt(self): - self.assertEqual(0x1000, self.gdb.p("$pc")) - # For some reason instret resets to 0. - self.assertLess(self.gdb.p("$instret"), 8) - self.gdb.stepi() - self.assertNotEqual(0x1000, self.gdb.p("$pc")) + self.assertEqual(target.reset_vector, self.gdb.p("$pc")) + # mcycle and minstret have no defined reset value. + mstatus = self.gdb.p("$mstatus") + self.assertEqual(mstatus & (MSTATUS_MIE | MSTATUS_MPRV | + MSTATUS_VM), 0) def test_change_pc(self): """Change the PC right as we come out of reset.""" @@ -163,9 +211,7 @@ class DebugTest(DeleteServer): self.binary = target.compile("programs/debug.c", "programs/checksum.c", "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE") self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("file %s" % self.binary) - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port, self.binary) self.gdb.load() self.gdb.b("_exit") @@ -232,6 +278,9 @@ class DebugTest(DeleteServer): self.exit() def test_hwbp_1(self): + if target.instruction_hardware_breakpoint_count < 1: + return + self.gdb.hbreak("rot13") # The breakpoint should be hit exactly 2 times. for i in range(2): @@ -242,6 +291,9 @@ class DebugTest(DeleteServer): self.exit() def test_hwbp_2(self): + if target.instruction_hardware_breakpoint_count < 2: + return + self.gdb.hbreak("main") self.gdb.hbreak("rot13") # We should hit 3 breakpoints. @@ -310,9 +362,7 @@ class StepTest(DeleteServer): def setUp(self): self.binary = target.compile("programs/step.S") self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("file %s" % self.binary) - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port, self.binary) self.gdb.load() self.gdb.b("main") self.gdb.c() @@ -328,9 +378,7 @@ class RegsTest(DeleteServer): def setUp(self): self.binary = target.compile("programs/regs.S") self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("file %s" % self.binary) - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port, self.binary) self.gdb.load() self.gdb.b("main") self.gdb.b("handle_trap") @@ -375,33 +423,31 @@ class RegsTest(DeleteServer): class DownloadTest(DeleteServer): def setUp(self): length = min(2**20, target.ram_size - 2048) - fd = file("download.c", "w") - fd.write("#include \n") - fd.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n") - fd.write("uint32_t length = %d;\n" % length) - fd.write("uint8_t d[%d] = {\n" % length) + download_c = tempfile.NamedTemporaryFile(prefix="download_", suffix=".c") + download_c.write("#include \n") + download_c.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n") + download_c.write("uint32_t length = %d;\n" % length) + download_c.write("uint8_t d[%d] = {\n" % length) self.crc = 0 for i in range(length / 16): - fd.write(" /* 0x%04x */ " % (i * 16)); + download_c.write(" /* 0x%04x */ " % (i * 16)); for _ in range(16): value = random.randrange(1<<8) - fd.write("%d, " % value) + download_c.write("%d, " % value) self.crc = binascii.crc32("%c" % value, self.crc) - fd.write("\n"); - fd.write("};\n"); - fd.write("uint8_t *data = &d[0];\n"); - fd.write("uint32_t main() { return crc32a(data, length); }\n") - fd.close() + download_c.write("\n"); + download_c.write("};\n"); + download_c.write("uint8_t *data = &d[0];\n"); + download_c.write("uint32_t main() { return crc32a(data, length); }\n") + download_c.flush() if self.crc < 0: self.crc += 2**32 - self.binary = target.compile("download.c", "programs/checksum.c") + self.binary = target.compile(download_c.name, "programs/checksum.c") self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("file %s" % self.binary) - self.gdb.command("target extended-remote localhost:%d" % self.server.port) - + self.gdb = gdb(target, self.server.port, self.binary) + def test_download(self): output = self.gdb.load() self.gdb.command("b _exit") @@ -412,9 +458,7 @@ class MprvTest(DeleteServer): def setUp(self): self.binary = target.compile("programs/mprv.S") self.server = target.server() - self.gdb = testlib.Gdb() - self.gdb.command("file %s" % self.binary) - self.gdb.command("target extended-remote localhost:%d" % self.server.port) + self.gdb = gdb(target, self.server.port, self.binary) self.gdb.load() def test_mprv(self): @@ -425,68 +469,185 @@ class MprvTest(DeleteServer): output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)") self.assertIn("0xbead", output) +class PrivTest(DeleteServer): + def setUp(self): + self.binary = target.compile("programs/priv.S") + self.server = target.server() + self.gdb = gdb(target, self.server.port, self.binary) + self.gdb.load() + + misa = self.gdb.p("$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) + + def test_rw(self): + """Test reading/writing priv.""" + for privilege in range(4): + self.gdb.p("$priv=%d" % privilege) + self.gdb.stepi() + actual = self.gdb.p("$priv") + self.assertIn(actual, self.supported) + if privilege in self.supported: + self.assertEqual(actual, privilege) + + def test_change(self): + """Test that the core's privilege level actually changes.""" + + if 0 not in self.supported: + # TODO: return not applicable + return + + self.gdb.b("main") + self.gdb.c() + + # Machine mode + self.gdb.p("$priv=3") + main = self.gdb.p("$pc") + self.gdb.stepi() + self.assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main+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") + self.assertTrue(pc < main or pc > main + 0x100) + class Target(object): directory = None - + timeout_sec = 2 + def server(self): raise NotImplementedError def compile(self, *sources): - return testlib.compile(sources + + binary_name = "%s_%s" % ( + self.name, + os.path.basename(os.path.splitext(sources[0])[0])) + if parsed.isolate: + self.temporary_binary = tempfile.NamedTemporaryFile( + prefix=binary_name + "_") + binary_name = self.temporary_binary.name + testlib.compile(sources + ("programs/entry.S", "programs/init.c", "-I", "../env", "-T", "targets/%s/link.lds" % (self.directory or self.name), "-nostartfiles", - "-mcmodel=medany"), xlen=self.xlen) + "-mcmodel=medany", + "-o", binary_name), + xlen=self.xlen) + return binary_name -class Spike64Target(Target): - name = "spike" - xlen = 64 +class SpikeTarget(Target): + directory = "spike" ram = 0x80010000 ram_size = 5 * 1024 * 1024 + instruction_hardware_breakpoint_count = 0 + reset_vector = 0x1000 + +class Spike64Target(SpikeTarget): + name = "spike64" + xlen = 64 def server(self): return testlib.Spike(parsed.cmd, halted=True) -class Spike32Target(Target): +class Spike32Target(SpikeTarget): name = "spike32" - directory = "spike" xlen = 32 - ram = 0x80010000 - ram_size = 5 * 1024 * 1024 def server(self): return testlib.Spike(parsed.cmd, halted=True, xlen=32) -class MicroSemiTarget(Target): - name = "m2gl_m2s" +class FreedomE300Target(Target): + name = "freedom-e300" + xlen = 32 + ram = 0x80000000 + ram_size = 16 * 1024 + instruction_hardware_breakpoint_count = 2 + + def server(self): + return testlib.Openocd(cmd=parsed.cmd, + config="targets/%s/openocd.cfg" % self.name) + +class FreedomE300SimTarget(Target): + name = "freedom-e300-sim" xlen = 32 + timeout_sec = 240 + ram = 0x80000000 + ram_size = 256 * 1024 * 1024 + instruction_hardware_breakpoint_count = 2 + + def server(self): + sim = testlib.VcsSim(simv=parsed.run, debug=False) + openocd = testlib.Openocd(cmd=parsed.cmd, + config="targets/%s/openocd.cfg" % self.name, + otherProcess = sim) + time.sleep(20) + return openocd + +class FreedomU500Target(Target): + name = "freedom-u500" + xlen = 64 ram = 0x80000000 ram_size = 16 * 1024 + instruction_hardware_breakpoint_count = 2 def server(self): return testlib.Openocd(cmd=parsed.cmd, config="targets/%s/openocd.cfg" % self.name) + +class FreedomU500SimTarget(Target): + name = "freedom-u500-sim" + xlen = 64 + timeout_sec = 240 + ram = 0x80000000 + ram_size = 256 * 1024 * 1024 + instruction_hardware_breakpoint_count = 2 + + def server(self): + sim = testlib.VcsSim(simv=parsed.run, debug=False) + openocd = testlib.Openocd(cmd=parsed.cmd, + config="targets/%s/openocd.cfg" % self.name, + otherProcess = sim) + time.sleep(20) + return openocd targets = [ Spike32Target, Spike64Target, - MicroSemiTarget - ] + FreedomE300Target, + FreedomU500Target, + FreedomE300SimTarget, + FreedomU500SimTarget] def main(): parser = argparse.ArgumentParser( epilog=""" Example command line from the real world: - Run all RegsTest cases against a MicroSemi m2gl_m2s board, with custom openocd command: - ./gdbserver.py --m2gl_m2s --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest + Run all RegsTest cases against a physical FPGA, with custom openocd command: + ./gdbserver.py --freedom-e-300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest """) group = parser.add_mutually_exclusive_group(required=True) for t in targets: group.add_argument("--%s" % t.name, action="store_const", const=t, dest="target") + parser.add_argument("--run", + help="The command to use to start the actual target (e.g. simulation)") parser.add_argument("--cmd", help="The command to use to start the debug server.") + parser.add_argument("--gdb", + help="The command to use to start gdb.") + parser.add_argument("--isolate", action="store_true", + help="Try to run in such a way that multiple instances can run at " + "the same time. This may make it harder to debug a failure if it " + "does occur.") parser.add_argument("unittest", nargs="*") global parsed parsed = parser.parse_args() @@ -497,7 +658,7 @@ def main(): # TROUBLESHOOTING TIPS # If a particular test fails, run just that one test, eg.: -# ./tests/gdbserver.py MprvTest.test_mprv +# ./gdbserver.py MprvTest.test_mprv # Then inspect gdb.log and spike.log to see what happened in more detail. if __name__ == '__main__':