X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=debug%2Fgdbserver.py;h=c362e1dc03dea441af582c093cbf490eba36101e;hb=4dddbc79ada7f0a836cf538676c57c8df103ccf6;hp=bd9babc717b5fabfdd2bc75870146de0f1bca37c;hpb=8519aa3f0ccf4032249b346fbd67855da99b5f3c;p=riscv-tests.git diff --git a/debug/gdbserver.py b/debug/gdbserver.py index bd9babc..c362e1d 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -12,7 +12,8 @@ import targets import testlib from testlib import assertEqual, assertNotEqual, assertIn, assertNotIn from testlib import assertGreater, assertRegexpMatches, assertLess -from testlib import GdbTest, GdbSingleHartTest, TestFailed, assertTrue +from testlib import GdbTest, GdbSingleHartTest, TestFailed +#from testlib import assertTrue MSTATUS_UIE = 0x00000001 MSTATUS_SIE = 0x00000002 @@ -136,6 +137,36 @@ class SimpleF18Test(SimpleRegisterTest): def test(self): self.check_reg("f18", "fs2") +class CustomRegisterTest(SimpleRegisterTest): + def early_applicable(self): + return self.target.implements_custom_test + + def check_custom(self, magic): + regs = self.gdb.info_registers("custom") + assertEqual(set(regs.keys()), + set(("custom1", + "custom12345", + "custom12346", + "custom12347", + "custom12348"))) + for name, value in regs.iteritems(): + number = int(name[6:]) + if number % 2: + expect = number + magic + assertIn(value, (expect, expect + (1<<32))) + else: + assertIn("Could not fetch register", value) + + def test(self): + self.check_custom(0) + + # Now test writing + magic = 6667 + self.gdb.p("$custom12345=%d" % (12345 + magic)) + self.gdb.stepi() + + self.check_custom(magic) + class SimpleNoExistTest(GdbTest): def test(self): try: @@ -552,60 +583,88 @@ class MulticoreRegTest(GdbTest): value = self.gdb.p("$x%d" % n) assertEqual(value, hart.index * 0x800 + n - 1) -class MulticoreRunHaltStepiTest(GdbTest): +#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("$mhartid") +# 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] +# # Check 10 times +# for i in range(10): +# # 3 attempts for each time we want the check to pass +# for attempt in range(3): +# self.gdb.global_command("echo round %d attempt %d\\n" % (i, +# attempt)) +# self.gdb.c_all(wait=False) +# time.sleep(2) +# self.gdb.interrupt_all() +# hart_count = self.gdb.p("hart_count") +# interrupt_count = self.gdb.p("interrupt_count") +# ok = True +# for i, h in enumerate(self.target.harts): +# if hart_count[i] <= previous_hart_count[i]: +# ok = False +# break +# if interrupt_count[i] <= previous_interrupt_count[i]: +# ok = False +# break +# self.gdb.p("$mie") +# self.gdb.p("$mip") +# self.gdb.p("$mstatus") +# self.gdb.p("$priv") +# self.gdb.p("buf", fmt="") +# self.gdb.select_hart(h) +# pc = self.gdb.p("$pc") +# self.gdb.stepi() +# stepped_pc = self.gdb.p("$pc") +# assertNotEqual(pc, stepped_pc) +# previous_hart_count = hart_count +# previous_interrupt_count = interrupt_count +# if ok: +# break +# else: +# assert False, \ +# "hart count or interrupt didn't increment as expected" + +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("$mhartid") 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] - # Check 10 times - for i in range(10): - # 3 attempts for each time we want the check to pass - for attempt in range(3): - self.gdb.global_command("echo round %d attempt %d\\n" % (i, - attempt)) - self.gdb.c_all(wait=False) - time.sleep(2) - self.gdb.interrupt_all() - hart_count = self.gdb.p("hart_count") - interrupt_count = self.gdb.p("interrupt_count") - ok = True - for i, h in enumerate(self.target.harts): - if hart_count[i] <= previous_hart_count[i]: - ok = False - break - if interrupt_count[i] <= previous_interrupt_count[i]: - ok = False - break - self.gdb.p("$mie") - self.gdb.p("$mip") - self.gdb.p("$mstatus") - self.gdb.p("$priv") - self.gdb.p("buf", fmt="") - self.gdb.select_hart(h) - pc = self.gdb.p("$pc") - self.gdb.stepi() - stepped_pc = self.gdb.p("$pc") - assertNotEqual(pc, stepped_pc) - previous_hart_count = hart_count - previous_interrupt_count = interrupt_count - if ok: - break - else: - assert False, \ - "hart count or interrupt didn't increment as expected" + if not self.gdb.one_hart_per_gdb(): + return 'not_applicable' -class MulticoreRunAllHaltOne(GdbTest): + # 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 MulticoreRtosSwitchActiveHartTest(GdbTest): compile_args = ("programs/multicore.c", "-DMULTICORE") def early_applicable(self): @@ -619,19 +678,20 @@ class MulticoreRunAllHaltOne(GdbTest): self.gdb.p("$pc=_start") def test(self): - if not self.gdb.one_hart_per_gdb(): + if 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) + # Set breakpoint near '_start' label to increase the chances of a + # situation when all harts hit breakpoint immediately and + # simultaneously. + self.gdb.b("set_trap_handler") - 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="") + # Check that all harts hit breakpoint one by one. + for _ in range(len(self.target.harts)): + output = self.gdb.c() + assertIn("hit Breakpoint", output) + assertIn("set_trap_handler", output) + assertNotIn("received signal SIGTRAP", output) class StepTest(GdbSingleHartTest): compile_args = ("programs/step.S", ) @@ -652,6 +712,29 @@ class StepTest(GdbSingleHartTest): pc = self.gdb.p("$pc") assertEqual("%x" % (pc - main_address), "%x" % expected) +class JumpHbreak(GdbSingleHartTest): + """'jump' resumes execution at location. Execution stops again immediately + if there is a breakpoint there. + That second line can be trouble.""" + compile_args = ("programs/trigger.S", ) + + def early_applicable(self): + return self.hart.instruction_hardware_breakpoint_count >= 1 + + def setup(self): + self.gdb.load() + self.gdb.hbreak("main") + self.gdb.c() + self.gdb.command("delete 1") + + def test(self): + self.gdb.b("read_loop") + self.gdb.command("hbreak just_before_read_loop") + output = self.gdb.command("jump just_before_read_loop") + assertRegexpMatches(output, r"Breakpoint \d, just_before_read_loop ") + output = self.gdb.c() + assertRegexpMatches(output, r"Breakpoint \d, read_loop ") + class TriggerTest(GdbSingleHartTest): compile_args = ("programs/trigger.S", ) def setup(self): @@ -722,7 +805,19 @@ class TriggerStoreAddressInstant(TriggerTest): write_loop = self.gdb.p("&write_loop") data = self.gdb.p("&data") self.gdb.command("watch *0x%x" % data) - self.gdb.c() + output = self.gdb.c() + if "_exit (status=0)" in output: + # We ran to _exit. It looks as if we didn't hit the trigger at all. + # However this can be "correct" behavior. gdb's definition of + # "watch" is to run until the value in memory changes. To do this + # it reads the memory value when the trigger is set, and then when + # the halt happens. Because our triggers can fire just before the + # write happens, when gdb does this check the memory hasn't + # changed. So it silently resumes running. + # https://github.com/riscv/riscv-openocd/issues/295 tracks this + # problem. Until it's fixed, we're going to allow running to _exit. + return + # Accept hitting the breakpoint before or after the store instruction. assertIn(self.gdb.p("$pc"), [write_loop, write_loop + 4]) assertEqual(self.gdb.p("$a0"), self.gdb.p("&data")) @@ -920,28 +1015,29 @@ class PrivRw(PrivTest): 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) +# XXX temporarily disabling this test +#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():