X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=debug%2Fgdbserver.py;h=c352bc0471cf98d0f81c390e6eace2ec1ee42ef1;hb=ce2b91bad31742fffb8377cf24f43f5a2b429a17;hp=0c3cee4b3328fd12bb0c045482923c2c532a51d4;hpb=6513bdb6f8ed77cd6a333ebc166e964e15357065;p=riscv-tests.git diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 0c3cee4..c352bc0 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 @@ -351,9 +352,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 +553,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 +648,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 +682,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 +745,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,8 +773,21 @@ 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") - self.gdb.c() + data = self.gdb.p("&data") + self.gdb.command("watch *0x%x" % data) + 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")) @@ -832,25 +915,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) @@ -884,9 +954,6 @@ class PrivTest(GdbSingleHartTest): self.supported.add(2) self.supported.add(3) -class PrivRw(PrivTest): - def test(self): - """Test reading/writing priv.""" # Disable physical memory protection by allowing U mode access to all # memory. try: @@ -905,6 +972,9 @@ class PrivRw(PrivTest): # SATP only exists if you have S mode. pass +class PrivRw(PrivTest): + def test(self): + """Test reading/writing priv.""" # Leave the PC at _start, where the first 4 instructions should be # legal in any mode. for privilege in range(4):