X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=debug%2Fgdbserver.py;h=a56d4a1f8a84216ac63596f0acf5944adccb1bcd;hb=c0aa8a601202a5de0d3334cb74f75105df627eee;hp=0c3cee4b3328fd12bb0c045482923c2c532a51d4;hpb=6513bdb6f8ed77cd6a333ebc166e964e15357065;p=riscv-tests.git diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 0c3cee4..a56d4a1 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -351,9 +351,7 @@ 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() @@ -554,42 +552,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("$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): + 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) - 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 MulticoreRunAllHaltOne(GdbTest): + 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): @@ -603,19 +647,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", ) @@ -636,6 +681,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): @@ -676,7 +744,8 @@ class TriggerLoadAddressInstant(TriggerTest): self.gdb.c() read_loop = self.gdb.p("&read_loop") read_again = self.gdb.p("&read_again") - self.gdb.command("rwatch data") + data = self.gdb.p("&data") + self.gdb.command("rwatch *0x%x" % data) self.gdb.c() # Accept hitting the breakpoint before or after the load instruction. assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4]) @@ -703,7 +772,8 @@ class TriggerStoreAddressInstant(TriggerTest): self.gdb.command("b just_before_write_loop") self.gdb.c() write_loop = self.gdb.p("&write_loop") - self.gdb.command("watch data") + data = self.gdb.p("&data") + self.gdb.command("watch *0x%x" % data) self.gdb.c() # Accept hitting the breakpoint before or after the store instruction. assertIn(self.gdb.p("$pc"), [write_loop, write_loop + 4]) @@ -832,25 +902,12 @@ class DownloadTest(GdbTest): self.binary = self.target.compile(self.hart, self.download_c.name, "programs/checksum.c") - self.gdb.command("file %s" % self.binary) + self.gdb.global_command("file %s" % self.binary) def test(self): - # 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.load() + self.parkOtherHarts() + self.gdb.command("b _exit") self.gdb.c() assertEqual(self.gdb.p("status"), self.crc) os.unlink(self.download_c.name)