Make pylint happy.

[riscv-tests.git] / debug / gdbserver.py

diff --git a/debug/gdbserver.py b/debug/gdbserver.py
index bd9babc717b5fabfdd2bc75870146de0f1bca37c..6f0f844f52a1172953fce6f899bccdfb9be57a61 100755 (executable)
--- 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
 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
 
 MSTATUS_UIE = 0x00000001
 MSTATUS_SIE = 0x00000002


@@ -552,60 +553,88 @@ class MulticoreRegTest(GdbTest):
                 value = self.gdb.p("$x%d" % n)
                 assertEqual(value, hart.index * 0x800 + n - 1)
 
                 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):
     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.load()
         for hart in self.target.harts:
             self.gdb.select_hart(hart)

-            self.gdb.p("$mhartid")

             self.gdb.p("$pc=_start")
 
     def test(self):
             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):
     compile_args = ("programs/multicore.c", "-DMULTICORE")
 
     def early_applicable(self):


@@ -619,19 +648,20 @@ class MulticoreRunAllHaltOne(GdbTest):
             self.gdb.p("$pc=_start")
 
     def test(self):
             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'
 
             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", )
 
 class StepTest(GdbSingleHartTest):
     compile_args = ("programs/step.S", )


@@ -652,6 +682,29 @@ class StepTest(GdbSingleHartTest):
             pc = self.gdb.p("$pc")
             assertEqual("%x" % (pc - main_address), "%x" % expected)
 
             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):
 class TriggerTest(GdbSingleHartTest):
     compile_args = ("programs/trigger.S", )
     def setup(self):


@@ -920,28 +973,29 @@ class PrivRw(PrivTest):
             if privilege in self.supported:
                 assertEqual(actual, privilege)
 
             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():
 
 parsed = None
 def main():