X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=debug%2Fgdbserver.py;h=0c3cee4b3328fd12bb0c045482923c2c532a51d4;hb=6513bdb6f8ed77cd6a333ebc166e964e15357065;hp=3e61449ce8daa9550a127bdb3060fcf27ebb8db0;hpb=96b21fa7b8912cc2ecc86f6b0e91d19a65103a55;p=riscv-tests.git diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 3e61449..0c3cee4 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -106,27 +106,49 @@ class SimpleT1Test(SimpleRegisterTest): class SimpleF18Test(SimpleRegisterTest): 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) - 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) + if self.hart.extensionSupported('F'): + 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) + 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') + size = self.gdb.p("sizeof($%s)" % name) + if self.hart.extensionSupported('D'): + assertEqual(size, 8) + else: + assertEqual(size, 4) + else: + output = self.gdb.p_raw("$" + name) + assertEqual(output, "void") + output = self.gdb.p_raw("$" + alias) + assertEqual(output, "void") def test(self): self.check_reg("f18", "fs2") +class SimpleNoExistTest(GdbTest): + def test(self): + try: + self.gdb.p("$csr2288") + assert False, "Reading csr2288 should have failed" + except testlib.CouldNotFetch: + pass + try: + self.gdb.p("$csr2288=5") + assert False, "Writing csr2288 should have failed" + except testlib.CouldNotFetch: + pass + class SimpleMemoryTest(GdbTest): def access_test(self, size, data_type): assertEqual(self.gdb.p("sizeof(%s)" % data_type), size) @@ -329,7 +351,9 @@ class DebugSymbols(DebugTest): class DebugBreakpoint(DebugTest): def test(self): + self.gdb.b("rot13") + # The breakpoint should be hit exactly 2 times. for _ in range(2): output = self.gdb.c() @@ -396,6 +420,8 @@ class Registers(DebugTest): output = self.gdb.command(cmd) for reg in ('zero', 'ra', 'sp', 'gp', 'tp'): assertIn(reg, output) + for line in output.splitlines(): + assertRegexpMatches(line, r"^\S") #TODO # mcpuid is one of the few registers that should have the high bit set @@ -563,7 +589,35 @@ class MulticoreRunHaltStepiTest(GdbTest): stepped_pc = self.gdb.p("$pc") assertNotEqual(pc, stepped_pc) -class StepTest(GdbTest): +class MulticoreRunAllHaltOne(GdbTest): + compile_args = ("programs/multicore.c", "-DMULTICORE") + + def early_applicable(self): + return len(self.target.harts) > 1 + + def setup(self): + self.gdb.select_hart(self.target.harts[0]) + self.gdb.load() + for hart in self.target.harts: + self.gdb.select_hart(hart) + self.gdb.p("$pc=_start") + + def test(self): + if not self.gdb.one_hart_per_gdb(): + return 'not_applicable' + + # Run harts in reverse order + for h in reversed(self.target.harts): + self.gdb.select_hart(h) + self.gdb.c(wait=False) + + self.gdb.interrupt() + # Give OpenOCD time to call poll() on both harts, which is what causes + # the bug. + time.sleep(1) + self.gdb.p("buf", fmt="") + +class StepTest(GdbSingleHartTest): compile_args = ("programs/step.S", ) def setup(self): @@ -582,7 +636,7 @@ class StepTest(GdbTest): pc = self.gdb.p("$pc") assertEqual("%x" % (pc - main_address), "%x" % expected) -class TriggerTest(GdbTest): +class TriggerTest(GdbSingleHartTest): compile_args = ("programs/trigger.S", ) def setup(self): self.gdb.load() @@ -621,12 +675,17 @@ class TriggerLoadAddressInstant(TriggerTest): self.gdb.command("b just_before_read_loop") self.gdb.c() read_loop = self.gdb.p("&read_loop") + read_again = self.gdb.p("&read_again") self.gdb.command("rwatch data") self.gdb.c() # Accept hitting the breakpoint before or after the load instruction. assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4]) assertEqual(self.gdb.p("$a0"), self.gdb.p("&data")) + self.gdb.c() + assertIn(self.gdb.p("$pc"), [read_again, read_again + 4]) + assertEqual(self.gdb.p("$a0"), self.gdb.p("&data")) + # FIXME: Triggers aren't quite working yet #class TriggerStoreAddress(TriggerTest): # def test(self): @@ -696,7 +755,7 @@ class TriggerDmode(TriggerTest): assertIn("clear_triggers", output) self.check_triggers((1<<6) | (1<<0), 0xfeedac00) -class RegsTest(GdbTest): +class RegsTest(GdbSingleHartTest): compile_args = ("programs/regs.S", ) def setup(self): self.gdb.load() @@ -776,13 +835,27 @@ class DownloadTest(GdbTest): self.gdb.command("file %s" % self.binary) def test(self): - self.gdb.load() - self.gdb.command("b _exit") - self.gdb.c(timeout=60) + # Some hart will compete the CRC calculation first! + # Let them race in RTOS mode. + # In non-RTOS mode, only one hart will continue. + # This loop will fail because the others won't know + # about '_start'. But if that is the case, they + # won't run on the `continue` either, so we don't really care. + try: + self.gdb.load() + for hart in self.target.harts: + self.gdb.select_hart(hart) + self.gdb.p("$pc=_start") + except ValueError: #invalid literal for int() with base 0: 'No symbol table is loaded. Use the "file" command.' + pass + finally: + + self.gdb.select_hart(self.hart) + self.gdb.c() assertEqual(self.gdb.p("status"), self.crc) os.unlink(self.download_c.name) -#class MprvTest(GdbTest): +#class MprvTest(GdbSingleHartTest): # compile_args = ("programs/mprv.S", ) # def setup(self): # self.gdb.load() @@ -795,7 +868,7 @@ class DownloadTest(GdbTest): # output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)") # assertIn("0xbead", output) -class PrivTest(GdbTest): +class PrivTest(GdbSingleHartTest): compile_args = ("programs/priv.S", ) def setup(self): # pylint: disable=attribute-defined-outside-init @@ -816,8 +889,21 @@ class PrivRw(PrivTest): """Test reading/writing priv.""" # Disable physical memory protection by allowing U mode access to all # memory. - self.gdb.p("$pmpcfg0=0xf") # TOR, R, W, X - self.gdb.p("$pmpaddr0=0x%x" % ((self.hart.ram + self.hart.ram_size) >> 2)) + try: + self.gdb.p("$pmpcfg0=0xf") # TOR, R, W, X + self.gdb.p("$pmpaddr0=0x%x" % + ((self.hart.ram + self.hart.ram_size) >> 2)) + except testlib.CouldNotFetch: + # PMP registers are optional + pass + + # Ensure Virtual Memory is disabled if applicable (SATP register is not + # reset) + try: + self.gdb.p("$satp=0") + except testlib.CouldNotFetch: + # SATP only exists if you have S mode. + pass # Leave the PC at _start, where the first 4 instructions should be # legal in any mode. @@ -869,12 +955,8 @@ def main(): global parsed # pylint: disable=global-statement parsed = parser.parse_args() target = targets.target(parsed) - testlib.print_log_names = parsed.print_log_names - if parsed.xlen: - target.xlen = parsed.xlen - module = sys.modules[__name__] return testlib.run_all_tests(module, target, parsed)