Add test case for `riscv expose_custom`.

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

diff --git a/debug/gdbserver.py b/debug/gdbserver.py
index 51c6ab6b09d550e2d1fbce5d4b8ee81ef09c5d35..c362e1dc03dea441af582c093cbf490eba36101e 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


@@ -65,15 +66,19 @@ def readable_binary_string(s):
     return "".join("%02x" % ord(c) for c in s)
 
 class SimpleRegisterTest(GdbTest):
     return "".join("%02x" % ord(c) for c in s)
 
 class SimpleRegisterTest(GdbTest):

-    def check_reg(self, name):
+    def check_reg(self, name, alias):

         a = random.randrange(1<<self.hart.xlen)
         b = random.randrange(1<<self.hart.xlen)
         self.gdb.p("$%s=0x%x" % (name, a))
         a = random.randrange(1<<self.hart.xlen)
         b = random.randrange(1<<self.hart.xlen)
         self.gdb.p("$%s=0x%x" % (name, a))

+        assertEqual(self.gdb.p("$%s" % alias), a)

         self.gdb.stepi()
         assertEqual(self.gdb.p("$%s" % name), a)
         self.gdb.stepi()
         assertEqual(self.gdb.p("$%s" % name), a)

-        self.gdb.p("$%s=0x%x" % (name, b))
+        assertEqual(self.gdb.p("$%s" % alias), a)
+        self.gdb.p("$%s=0x%x" % (alias, b))
+        assertEqual(self.gdb.p("$%s" % name), b)

         self.gdb.stepi()
         assertEqual(self.gdb.p("$%s" % name), b)
         self.gdb.stepi()
         assertEqual(self.gdb.p("$%s" % name), b)

+        assertEqual(self.gdb.p("$%s" % alias), b)

 
     def setup(self):
         # 0x13 is nop
 
     def setup(self):
         # 0x13 is nop


@@ -86,38 +91,94 @@ class SimpleRegisterTest(GdbTest):
 
 class SimpleS0Test(SimpleRegisterTest):
     def test(self):
 
 class SimpleS0Test(SimpleRegisterTest):
     def test(self):

-        self.check_reg("s0")
+        self.check_reg("s0", "x8")

 
 class SimpleS1Test(SimpleRegisterTest):
     def test(self):
 
 class SimpleS1Test(SimpleRegisterTest):
     def test(self):

-        self.check_reg("s1")
+        self.check_reg("s1", "x9")

 
 class SimpleT0Test(SimpleRegisterTest):
     def test(self):
 
 class SimpleT0Test(SimpleRegisterTest):
     def test(self):

-        self.check_reg("t0")
+        self.check_reg("t0", "x5")

 
 class SimpleT1Test(SimpleRegisterTest):
     def test(self):
 
 class SimpleT1Test(SimpleRegisterTest):
     def test(self):

-        self.check_reg("t1")
+        self.check_reg("t1", "x6")

 
 class SimpleF18Test(SimpleRegisterTest):
 
 class SimpleF18Test(SimpleRegisterTest):

-    def check_reg(self, name):
-        self.gdb.p_raw("$mstatus=$mstatus | 0x00006000")
-        self.gdb.stepi()
-        a = random.random()
-        b = random.random()
-        self.gdb.p_raw("$%s=%f" % (name, a))
-        self.gdb.stepi()
-        assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - a), .001)
-        self.gdb.p_raw("$%s=%f" % (name, b))
-        self.gdb.stepi()
-        assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - b), .001)
+    def check_reg(self, name, alias):
+        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)
+
+            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 CustomRegisterTest(SimpleRegisterTest):

     def early_applicable(self):
     def early_applicable(self):

-        return self.hart.extensionSupported('F')
+        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):
 
     def test(self):

-        self.check_reg("f18")
+        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:
+            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):
 
 class SimpleMemoryTest(GdbTest):
     def access_test(self, size, data_type):


@@ -199,7 +260,7 @@ class MemTestBlock(GdbTest):
         self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name,
             self.hart.ram, self.hart.ram + self.length))
         self.gdb.command("shell cat %s" % b.name)
         self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name,
             self.hart.ram, self.hart.ram + self.length))
         self.gdb.command("shell cat %s" % b.name)

-        for line in b:
+        for line in b.xreadlines():

             record_type, address, line_data = ihex_parse(line)
             if record_type == 0:
                 written_data = data[address:address+len(line_data)]
             record_type, address, line_data = ihex_parse(line)
             if record_type == 0:
                 written_data = data[address:address+len(line_data)]


@@ -388,6 +449,8 @@ class Registers(DebugTest):
             output = self.gdb.command(cmd)
             for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
                 assertIn(reg, output)
             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
 
         #TODO
         # mcpuid is one of the few registers that should have the high bit set


@@ -465,9 +528,63 @@ class InterruptTest(GdbSingleHartTest):
         self.gdb.p("interrupt_count")
         self.gdb.p("local")
 
         self.gdb.p("interrupt_count")
         self.gdb.p("local")
 

-# Fails nondeterministically.
-#class MulticoreRegTest(GdbTest):
-#    compile_args = ("programs/infinite_loop.S", "-DMULTICORE")
+class MulticoreRegTest(GdbTest):
+    compile_args = ("programs/infinite_loop.S", "-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("$pc=_start")
+
+    def test(self):
+        # Run to main
+        for hart in self.target.harts:
+            self.gdb.select_hart(hart)
+            self.gdb.b("main")
+            self.gdb.c()
+            assertIn("main", self.gdb.where())
+            self.gdb.command("delete breakpoints")
+
+        # Run through the entire loop.
+        for hart in self.target.harts:
+            self.gdb.select_hart(hart)
+            self.gdb.b("main_end")
+            self.gdb.c()
+            assertIn("main_end", self.gdb.where())
+
+        hart_ids = []
+        for hart in self.target.harts:
+            self.gdb.select_hart(hart)
+            # Check register values.
+            hart_id = self.gdb.p("$x1")
+            assertNotIn(hart_id, hart_ids)
+            hart_ids.append(hart_id)
+            for n in range(2, 32):
+                value = self.gdb.p("$x%d" % n)
+                assertEqual(value, hart_ids[-1] + n - 1)
+
+        # Confirmed that we read different register values for different harts.
+        # Write a new value to x1, and run through the add sequence again.
+
+        for hart in self.target.harts:
+            self.gdb.select_hart(hart)
+            self.gdb.p("$x1=0x%x" % (hart.index * 0x800))
+            self.gdb.p("$pc=main_post_csrr")
+            self.gdb.c()
+        for hart in self.target.harts:
+            self.gdb.select_hart(hart)
+            assertIn("main", self.gdb.where())
+            # Check register values.
+            for n in range(1, 32):
+                value = self.gdb.p("$x%d" % n)
+                assertEqual(value, hart.index * 0x800 + n - 1)
+
+#class MulticoreRunHaltStepiTest(GdbTest):
+#    compile_args = ("programs/multicore.c", "-DMULTICORE")

 #
 #    def early_applicable(self):
 #        return len(self.target.harts) > 1
 #
 #    def early_applicable(self):
 #        return len(self.target.harts) > 1


@@ -476,90 +593,107 @@ class InterruptTest(GdbSingleHartTest):
 #        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):

-#        # Run to main
-#        # Hart 0 is the first to be resumed, so we have to set the breakpoint
-#        # there. gdb won't actually set the breakpoint until we tell it to
-#        # resume.
-#        self.gdb.select_hart(self.target.harts[0])
-#        self.gdb.b("main")
-#        self.gdb.c_all()
-#        for hart in self.target.harts:
-#            self.gdb.select_hart(hart)
-#            assertIn("main", self.gdb.where())
-#        self.gdb.select_hart(self.target.harts[0])
-#        self.gdb.command("delete breakpoints")
-#
-#        # Run through the entire loop.
-#        self.gdb.b("main_end")
-#        self.gdb.c_all()
-#
-#        hart_ids = []
-#        for hart in self.target.harts:
-#            self.gdb.select_hart(hart)
-#            assertIn("main_end", self.gdb.where())
-#            # Check register values.
-#            hart_id = self.gdb.p("$x1")
-#            assertNotIn(hart_id, hart_ids)
-#            hart_ids.append(hart_id)
-#            for n in range(2, 32):
-#                value = self.gdb.p("$x%d" % n)
-#                assertEqual(value, hart_ids[-1] + n - 1)
-#
-#        # Confirmed that we read different register values for different harts.
-#        # Write a new value to x1, and run through the add sequence again.
-#
-#        for hart in self.target.harts:
-#            self.gdb.select_hart(hart)
-#            self.gdb.p("$x1=0x%x" % (hart.index * 0x800))
-#            self.gdb.p("$pc=main_post_csrr")
-#        self.gdb.c_all()
-#        for hart in self.target.harts:
-#            self.gdb.select_hart(hart)
-#            assertIn("main", self.gdb.where())
-#            # Check register values.
-#            for n in range(1, 32):
-#                value = self.gdb.p("$x%d" % n)
-#                assertEqual(value, hart.index * 0x800 + n - 1)
-
-class MulticoreRunHaltStepiTest(GdbTest):
+#        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.p("$pc=_start")
 
     def test(self):
         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)
             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 StepTest(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):
+        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 self.gdb.one_hart_per_gdb():
+            return 'not_applicable'
+
+        # 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")
+
+        # 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", )
 
     def setup(self):
     compile_args = ("programs/step.S", )
 
     def setup(self):


@@ -578,7 +712,30 @@ class StepTest(GdbTest):
             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 TriggerTest(GdbTest):
+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):
         self.gdb.load()
     compile_args = ("programs/trigger.S", )
     def setup(self):
         self.gdb.load()


@@ -617,12 +774,18 @@ class TriggerLoadAddressInstant(TriggerTest):
         self.gdb.command("b just_before_read_loop")
         self.gdb.c()
         read_loop = self.gdb.p("&read_loop")
         self.gdb.command("b just_before_read_loop")
         self.gdb.c()
         read_loop = self.gdb.p("&read_loop")

-        self.gdb.command("rwatch data")
+        read_again = self.gdb.p("&read_again")
+        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])
         assertEqual(self.gdb.p("$a0"), self.gdb.p("&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):
 # FIXME: Triggers aren't quite working yet
 #class TriggerStoreAddress(TriggerTest):
 #    def test(self):


@@ -640,8 +803,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("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"))
         # 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"))


@@ -692,7 +868,7 @@ class TriggerDmode(TriggerTest):
         assertIn("clear_triggers", output)
         self.check_triggers((1<<6) | (1<<0), 0xfeedac00)
 
         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()
     compile_args = ("programs/regs.S", )
     def setup(self):
         self.gdb.load()


@@ -769,16 +945,17 @@ class DownloadTest(GdbTest):
 
         self.binary = self.target.compile(self.hart, self.download_c.name,
                 "programs/checksum.c")
 
         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):
         self.gdb.load()
 
     def test(self):
         self.gdb.load()

+        self.parkOtherHarts()

         self.gdb.command("b _exit")
         self.gdb.command("b _exit")

-        self.gdb.c(timeout=60)
+        self.gdb.c()

         assertEqual(self.gdb.p("status"), self.crc)
         os.unlink(self.download_c.name)
 
         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()
 #    compile_args = ("programs/mprv.S", )
 #    def setup(self):
 #        self.gdb.load()


@@ -791,7 +968,7 @@ class DownloadTest(GdbTest):
 #        output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
 #        assertIn("0xbead", output)
 
 #        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
     compile_args = ("programs/priv.S", )
     def setup(self):
         # pylint: disable=attribute-defined-outside-init


@@ -810,6 +987,26 @@ class PrivTest(GdbTest):
 class PrivRw(PrivTest):
     def test(self):
         """Test reading/writing priv."""
 class PrivRw(PrivTest):
     def test(self):
         """Test reading/writing priv."""

+        # Disable physical memory protection by allowing U mode access to all
+        # memory.
+        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.

         for privilege in range(4):
             self.gdb.p("$priv=%d" % privilege)
             self.gdb.stepi()
         for privilege in range(4):
             self.gdb.p("$priv=%d" % privilege)
             self.gdb.stepi()


@@ -818,28 +1015,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():


@@ -858,9 +1056,7 @@ def main():
     global parsed   # pylint: disable=global-statement
     parsed = parser.parse_args()
     target = targets.target(parsed)
     global parsed   # pylint: disable=global-statement
     parsed = parser.parse_args()
     target = targets.target(parsed)

-
-    if parsed.xlen:
-        target.xlen = parsed.xlen
+    testlib.print_log_names = parsed.print_log_names

 
     module = sys.modules[__name__]
 
 
     module = sys.modules[__name__]