X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=debug%2Fgdbserver.py;h=162854c59939d7ac57fa789910a8c42370a9f867;hb=6f7ebb610d6bb8817a9592cc06a7d108381f1761;hp=91c385f548909d86e0da527c42d203119bd03134;hpb=acb593160f2f7e22bfd6a480570f2c5094634165;p=riscv-tests.git diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 91c385f..162854c 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -2,15 +2,17 @@ import argparse import binascii -import os import random -import re import sys import tempfile import time -import traceback +import os +import targets import testlib +from testlib import assertEqual, assertNotEqual, assertIn, assertNotIn +from testlib import assertGreater, assertRegexpMatches, assertLess +from testlib import GdbTest, GdbSingleHartTest, TestFailed, assertTrue MSTATUS_UIE = 0x00000001 MSTATUS_SIE = 0x00000002 @@ -34,30 +36,6 @@ MSTATUS64_SD = 0x8000000000000000 # pylint: disable=abstract-method -def gdb( - target=None, - port=None, - binary=None - ): - - g = None - if parsed.gdb: - g = testlib.Gdb(parsed.gdb) - else: - g = testlib.Gdb() - - if binary: - g.command("file %s" % binary) - if target: - g.command("set arch riscv:rv%d" % target.xlen) - g.command("set remotetimeout %d" % target.timeout_sec) - if port: - g.command("target extended-remote localhost:%d" % port) - - g.p("$priv=3") - - return g - def ihex_line(address, record_type, data): assert len(data) < 128 line = ":%02X%04X%02X" % (len(data), address, record_type) @@ -86,196 +64,80 @@ def ihex_parse(line): def readable_binary_string(s): return "".join("%02x" % ord(c) for c in s) -def header(title): - dashes = '-' * (36 - len(title)) - before = dashes[:len(dashes)/2] - after = dashes[len(dashes)/2:] - print "%s[ %s ]%s" % (before, title, after) - -class GdbTest(object): - compiled = {} - - def __init__(self, target): - self.target = target - self.server = None - self.binary = None - self.gdb = None - - def setUp(self): - pass - - def run(self): - """ - If compile_args is set, compile a program and set self.binary. - - Call setUp(). - - Then call test() and return the result, displaying relevant information - if an exception is raised. - """ - self.server = self.target.server() - - print "Running", type(self).__name__, "...", - sys.stdout.flush() - - start = time.time() - - compile_args = getattr(self, 'compile_args', None) - if compile_args: - if compile_args not in GdbTest.compiled: - try: - # pylint: disable=star-args - GdbTest.compiled[compile_args] = \ - self.target.compile(*compile_args) - except Exception: # pylint: disable=broad-except - print "exception while compiling in %.2fs" % ( - time.time() - start) - print "=" * 40 - header("Traceback") - traceback.print_exc(file=sys.stdout) - print "/" * 40 - return "exception" - self.binary = GdbTest.compiled.get(compile_args) - - self.gdb = gdb(self.target, self.server.port, self.binary) - - try: - self.setUp() - result = self.test() # pylint: disable=no-member - except Exception as e: # pylint: disable=broad-except - if isinstance(e, TestFailed): - result = "fail" - else: - result = "exception" - print "%s in %.2fs" % (result, time.time() - start) - print "=" * 40 - if isinstance(e, TestFailed): - header("Message") - print e.message - header("Traceback") - traceback.print_exc(file=sys.stdout) - header("gdb.log") - print open("gdb.log", "r").read() - header(self.server.logname) - print open(self.server.logname, "r").read() - print "/" * 40 - return result - - finally: - del self.server - del self.gdb - - if not result: - result = 'pass' - print "%s in %.2fs" % (result, time.time() - start) - return result - -class TestFailed(Exception): - def __init__(self, message): - Exception.__init__(self) - self.message = message - -def run_all_tests(target, tests, fail_fast): - good_results = set(('pass', 'not_applicable')) - - results = {} - module = sys.modules[__name__] - for name in dir(module): - definition = getattr(module, name) - if type(definition) == type and hasattr(definition, 'test') and \ - (not tests or any(test in name for test in tests)): - instance = definition(target) - result = instance.run() - results.setdefault(result, []).append(name) - if result not in good_results and fail_fast: - break - - print ":" * 40 - - result = 0 - for key, value in results.iteritems(): - print "%d tests returned %s" % (len(value), key) - if key not in good_results: - result = 1 - for test in value: - print " ", test - - return result - -def assertEqual(a, b): - if a != b: - raise TestFailed("%r != %r" % (a, b)) - -def assertNotEqual(a, b): - if a == b: - raise TestFailed("%r == %r" % (a, b)) - -def assertIn(a, b): - if a not in b: - raise TestFailed("%r not in %r" % (a, b)) - -def assertNotIn(a, b): - if a in b: - raise TestFailed("%r in %r" % (a, b)) - -def assertGreater(a, b): - if not a > b: - raise TestFailed("%r not greater than %r" % (a, b)) - -def assertTrue(a): - if not a: - raise TestFailed("%r is not True" % a) - -def assertRegexpMatches(text, regexp): - if not re.search(regexp, text): - raise TestFailed("can't find %r in %r" % (regexp, text)) - class SimpleRegisterTest(GdbTest): - def check_reg(self, name): - a = random.randrange(1< 1000 and \ + local > 1000: + return + + assertGreater(interrupt_count, 1000) + assertGreater(local, 1000) + + def postMortem(self): + GdbSingleHartTest.postMortem(self) + self.gdb.p("*((long long*) 0x200bff8)") + self.gdb.p("*((long long*) 0x2004000)") + self.gdb.p("interrupt_count") + self.gdb.p("local") + +class MulticoreRegTest(GdbTest): + compile_args = ("programs/infinite_loop.S", "-DMULTICORE") + + def early_applicable(self): + return len(self.target.harts) > 1 + + def setup(self): + self.gdb.load() + for hart in self.target.harts: + self.gdb.select_hart(hart) + self.gdb.p("$pc=_start") + + def test(self): + # Run to main + 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. + 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 hart in self.target.harts: + self.gdb.select_hart(hart) + # Check register values. + hart_id = self.gdb.p("$x1") + assertNotIn(hart_id, hart_ids) + hart_ids.append(hart_id) + for n in range(2, 32): + value = self.gdb.p("$x%d" % n) + assertEqual(value, hart_ids[-1] + n - 1) + + # Confirmed that we read different register values for different harts. + # Write a new value to x1, and run through the add sequence again. + + for hart in self.target.harts: + 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 hart in self.target.harts: + 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) + +class MulticoreRunHaltStepiTest(GdbTest): + compile_args = ("programs/multicore.c", "-DMULTICORE") + + def early_applicable(self): + return len(self.target.harts) > 1 + + def setup(self): + self.gdb.load() + for hart in self.target.harts: + self.gdb.select_hart(hart) + self.gdb.p("$pc=_start") + + def test(self): + previous_hart_count = [0 for h in self.target.harts] + previous_interrupt_count = [0 for h in self.target.harts] + for _ in range(10): + self.gdb.c(wait=False) + time.sleep(2) + self.gdb.interrupt() + self.gdb.p("$mie") + self.gdb.p("$mip") + self.gdb.p("$mstatus") + self.gdb.p("$priv") + self.gdb.p("buf", fmt="") + hart_count = self.gdb.p("hart_count") + interrupt_count = self.gdb.p("interrupt_count") + for i, h in enumerate(self.target.harts): + assertGreater(hart_count[i], previous_hart_count[i]) + assertGreater(interrupt_count[i], previous_interrupt_count[i]) + self.gdb.select_hart(h) + pc = self.gdb.p("$pc") + self.gdb.stepi() + stepped_pc = self.gdb.p("$pc") + assertNotEqual(pc, stepped_pc) + class StepTest(GdbTest): compile_args = ("programs/step.S", ) - def setUp(self): + def setup(self): self.gdb.load() self.gdb.b("main") self.gdb.c() def test(self): main_address = self.gdb.p("$pc") - for expected in (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c): + if self.hart.extensionSupported("c"): + sequence = (4, 8, 0xc, 0xe, 0x14, 0x18, 0x22, 0x1c, 0x24, 0x24) + else: + sequence = (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c) + for expected in sequence: self.gdb.stepi() pc = self.gdb.p("$pc") - assertEqual("%x" % pc, "%x" % (expected + main_address)) + assertEqual("%x" % (pc - main_address), "%x" % expected) class TriggerTest(GdbTest): compile_args = ("programs/trigger.S", ) - def setUp(self): + def setup(self): self.gdb.load() self.gdb.b("_exit") self.gdb.b("main") @@ -559,14 +604,15 @@ class TriggerExecuteInstant(TriggerTest): self.gdb.c() assertEqual(self.gdb.p("$pc"), main_address+4) -class TriggerLoadAddress(TriggerTest): - def test(self): - self.gdb.command("rwatch *((&data)+1)") - output = self.gdb.c() - assertIn("read_loop", output) - assertEqual(self.gdb.p("$a0"), - self.gdb.p("(&data)+1")) - self.exit() +# FIXME: Triggers aren't quite working yet +#class TriggerLoadAddress(TriggerTest): +# def test(self): +# self.gdb.command("rwatch *((&data)+1)") +# output = self.gdb.c() +# assertIn("read_loop", output) +# assertEqual(self.gdb.p("$a0"), +# self.gdb.p("(&data)+1")) +# self.exit() class TriggerLoadAddressInstant(TriggerTest): """Test a load address breakpoint on the first instruction executed out of @@ -581,14 +627,15 @@ class TriggerLoadAddressInstant(TriggerTest): assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4]) assertEqual(self.gdb.p("$a0"), self.gdb.p("&data")) -class TriggerStoreAddress(TriggerTest): - def test(self): - self.gdb.command("watch *((&data)+3)") - output = self.gdb.c() - assertIn("write_loop", output) - assertEqual(self.gdb.p("$a0"), - self.gdb.p("(&data)+3")) - self.exit() +# FIXME: Triggers aren't quite working yet +#class TriggerStoreAddress(TriggerTest): +# def test(self): +# self.gdb.command("watch *((&data)+3)") +# output = self.gdb.c() +# assertIn("write_loop", output) +# assertEqual(self.gdb.p("$a0"), +# self.gdb.p("(&data)+3")) +# self.exit() class TriggerStoreAddressInstant(TriggerTest): def test(self): @@ -604,14 +651,17 @@ class TriggerStoreAddressInstant(TriggerTest): assertEqual(self.gdb.p("$a0"), self.gdb.p("&data")) class TriggerDmode(TriggerTest): + def early_applicable(self): + return self.hart.honors_tdata1_hmode + def check_triggers(self, tdata1_lsbs, tdata2): - dmode = 1 << (self.target.xlen-5) + dmode = 1 << (self.hart.xlen-5) triggers = [] - if self.target.xlen == 32: + if self.hart.xlen == 32: xlen_type = 'int' - elif self.target.xlen == 64: + elif self.hart.xlen == 64: xlen_type = 'long long' else: raise NotImplementedError @@ -648,7 +698,7 @@ class TriggerDmode(TriggerTest): class RegsTest(GdbTest): compile_args = ("programs/regs.S", ) - def setUp(self): + def setup(self): self.gdb.load() self.gdb.b("main") self.gdb.b("handle_trap") @@ -671,7 +721,7 @@ class WriteGprs(RegsTest): self.gdb.command("info registers") for n in range(len(regs)): assertEqual(self.gdb.x("data+%d" % (8*n), 'g'), - ((0xdeadbeef<\n") - download_c.write( + def setup(self): + # pylint: disable=attribute-defined-outside-init + length = min(2**10, self.hart.ram_size - 2048) + self.download_c = tempfile.NamedTemporaryFile(prefix="download_", + suffix=".c", delete=False) + self.download_c.write("#include \n") + self.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.download_c.write("uint32_t length = %d;\n" % length) + self.download_c.write("uint8_t d[%d] = {\n" % length) self.crc = 0 + assert length % 16 == 0 for i in range(length / 16): - download_c.write(" /* 0x%04x */ " % (i * 16)) + self.download_c.write(" /* 0x%04x */ " % (i * 16)) for _ in range(16): value = random.randrange(1<<8) - download_c.write("%d, " % value) + self.download_c.write("0x%02x, " % value) self.crc = binascii.crc32("%c" % value, self.crc) - 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() + self.download_c.write("\n") + self.download_c.write("};\n") + self.download_c.write("uint8_t *data = &d[0];\n") + self.download_c.write( + "uint32_t main() { return crc32a(data, length); }\n") + self.download_c.flush() if self.crc < 0: self.crc += 2**32 - self.binary = self.target.compile(download_c.name, + self.binary = self.target.compile(self.hart, self.download_c.name, "programs/checksum.c") self.gdb.command("file %s" % self.binary) def test(self): self.gdb.load() self.gdb.command("b _exit") - self.gdb.c() + self.gdb.c(timeout=60) assertEqual(self.gdb.p("status"), self.crc) - -class MprvTest(GdbTest): - compile_args = ("programs/mprv.S", ) - def setUp(self): - self.gdb.load() - - def test(self): - """Test that the debugger can access memory when MPRV is set.""" - self.gdb.c(wait=False) - time.sleep(0.5) - self.gdb.interrupt() - output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)") - assertIn("0xbead", output) + os.unlink(self.download_c.name) + +#class MprvTest(GdbTest): +# compile_args = ("programs/mprv.S", ) +# def setup(self): +# self.gdb.load() +# +# def test(self): +# """Test that the debugger can access memory when MPRV is set.""" +# self.gdb.c(wait=False) +# time.sleep(0.5) +# 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): + def setup(self): + # pylint: disable=attribute-defined-outside-init self.gdb.load() - misa = self.gdb.p("$misa") + misa = self.hart.misa self.supported = set() if misa & (1<<20): self.supported.add(0) @@ -790,166 +845,32 @@ class PrivChange(PrivTest): pc = self.gdb.p("$pc") assertTrue(pc < main_address or pc > main_address + 0x100) -class Target(object): - name = "name" - xlen = 0 - directory = None - timeout_sec = 2 - temporary_files = [] - temporary_binary = None - - def server(self): - raise NotImplementedError - - def compile(self, *sources): - binary_name = "%s_%s-%d" % ( - self.name, - os.path.basename(os.path.splitext(sources[0])[0]), - self.xlen) - if parsed.isolate: - self.temporary_binary = tempfile.NamedTemporaryFile( - prefix=binary_name + "_") - binary_name = self.temporary_binary.name - Target.temporary_files.append(self.temporary_binary) - testlib.compile(sources + - ("programs/entry.S", "programs/init.c", - "-I", "../env", - "-T", "targets/%s/link.lds" % (self.directory or self.name), - "-nostartfiles", - "-mcmodel=medany", - "-o", binary_name), - xlen=self.xlen) - return binary_name - -class SpikeTarget(Target): - directory = "spike" - ram = 0x80010000 - ram_size = 5 * 1024 * 1024 - instruction_hardware_breakpoint_count = 4 - reset_vector = 0x1000 - -class Spike64Target(SpikeTarget): - name = "spike64" - xlen = 64 - - def server(self): - return testlib.Spike(parsed.cmd, halted=True) - -class Spike32Target(SpikeTarget): - name = "spike32" - xlen = 32 - - def server(self): - return testlib.Spike(parsed.cmd, halted=True, xlen=32) - -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, - FreedomE300Target, - FreedomU500Target, - FreedomE300SimTarget, - FreedomU500SimTarget] - parsed = None def main(): parser = argparse.ArgumentParser( + description="Test that gdb can talk to a RISC-V target.", epilog=""" Example command line from the real world: Run all RegsTest cases against a physical FPGA, with custom openocd command: - ./gdbserver.py --freedom-e300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" RegsTest + ./gdbserver.py --freedom-e300 --server_cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" Simple """) - 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.") - - xlen_group = parser.add_mutually_exclusive_group() - xlen_group.add_argument("--32", action="store_const", const=32, dest="xlen", - help="Force the target to be 32-bit.") - xlen_group.add_argument("--64", action="store_const", const=64, dest="xlen", - help="Force the target to be 64-bit.") - - 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("--fail-fast", "-f", action="store_true", - help="Exit as soon as any test fails.") - - parser.add_argument("test", nargs='*', - help="Run only tests that are named here.") + targets.add_target_options(parser) + + testlib.add_test_run_options(parser) # TODO: remove global global parsed # pylint: disable=global-statement parsed = parser.parse_args() + target = targets.target(parsed) + + testlib.print_log_names = parsed.print_log_names - target = parsed.target() if parsed.xlen: target.xlen = parsed.xlen - return run_all_tests(target, parsed.test, parsed.fail_fast) + module = sys.modules[__name__] + + return testlib.run_all_tests(module, target, parsed) # TROUBLESHOOTING TIPS # If a particular test fails, run just that one test, eg.: