debug/gdbserver.py

   1 #!/usr/bin/env python
   2
   3 import argparse
   4 import binascii
   5 import random
   6 import sys
   7 import tempfile
   8 import time
   9
  10 import targets
  11 import testlib
  12 from testlib import assertEqual, assertNotEqual, assertIn
  13 from testlib import assertGreater, assertTrue, assertRegexpMatches, assertLess
  14
  15 MSTATUS_UIE = 0x00000001
  16 MSTATUS_SIE = 0x00000002
  17 MSTATUS_HIE = 0x00000004
  18 MSTATUS_MIE = 0x00000008
  19 MSTATUS_UPIE = 0x00000010
  20 MSTATUS_SPIE = 0x00000020
  21 MSTATUS_HPIE = 0x00000040
  22 MSTATUS_MPIE = 0x00000080
  23 MSTATUS_SPP = 0x00000100
  24 MSTATUS_HPP = 0x00000600
  25 MSTATUS_MPP = 0x00001800
  26 MSTATUS_FS = 0x00006000
  27 MSTATUS_XS = 0x00018000
  28 MSTATUS_MPRV = 0x00020000
  29 MSTATUS_PUM = 0x00040000
  30 MSTATUS_MXR = 0x00080000
  31 MSTATUS_VM = 0x1F000000
  32 MSTATUS32_SD = 0x80000000
  33 MSTATUS64_SD = 0x8000000000000000
  34
  35 # pylint: disable=abstract-method
  36
  37 def gdb(
  38         target=None,
  39         port=None,
  40         binary=None
  41         ):
  42
  43     g = None
  44     if parsed.gdb:
  45         g = testlib.Gdb(parsed.gdb)
  46     else:
  47         g = testlib.Gdb()
  48
  49     if binary:
  50         g.command("file %s" % binary)
  51     if target:
  52         g.command("set arch riscv:rv%d" % target.xlen)
  53         g.command("set remotetimeout %d" % target.timeout_sec)
  54     if port:
  55         g.command("target extended-remote localhost:%d" % port)
  56
  57     g.p("$priv=3")
  58
  59     return g
  60
  61 def ihex_line(address, record_type, data):
  62     assert len(data) < 128
  63     line = ":%02X%04X%02X" % (len(data), address, record_type)
  64     check = len(data)
  65     check += address % 256
  66     check += address >> 8
  67     check += record_type
  68     for char in data:
  69         value = ord(char)
  70         check += value
  71         line += "%02X" % value
  72     line += "%02X\n" % ((256-check)%256)
  73     return line
  74
  75 def ihex_parse(line):
  76     assert line.startswith(":")
  77     line = line[1:]
  78     data_len = int(line[:2], 16)
  79     address = int(line[2:6], 16)
  80     record_type = int(line[6:8], 16)
  81     data = ""
  82     for i in range(data_len):
  83         data += "%c" % int(line[8+2*i:10+2*i], 16)
  84     return record_type, address, data
  85
  86 def readable_binary_string(s):
  87     return "".join("%02x" % ord(c) for c in s)
  88
  89 class GdbTest(testlib.BaseTest):
  90     def __init__(self, target):
  91         testlib.BaseTest.__init__(self, target)
  92         self.gdb = None
  93
  94     def classSetup(self):
  95         testlib.BaseTest.classSetup(self)
  96         self.logs.append("gdb.log")
  97         self.gdb = gdb(self.target, self.server.port, self.binary)
  98
  99     def classTeardown(self):
 100         del self.gdb
 101         testlib.BaseTest.classTeardown(self)
 102
 103 class SimpleRegisterTest(GdbTest):
 104     def check_reg(self, name):
 105         a = random.randrange(1<<self.target.xlen)
 106         b = random.randrange(1<<self.target.xlen)
 107         self.gdb.p("$%s=0x%x" % (name, a))
 108         self.gdb.stepi()
 109         assertEqual(self.gdb.p("$%s" % name), a)
 110         self.gdb.p("$%s=0x%x" % (name, b))
 111         self.gdb.stepi()
 112         assertEqual(self.gdb.p("$%s" % name), b)
 113
 114     def setup(self):
 115         # 0x13 is nop
 116         self.gdb.command("p *((int*) 0x%x)=0x13" % self.target.ram)
 117         self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 4))
 118         self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 8))
 119         self.gdb.p("$pc=0x%x" % self.target.ram)
 120
 121 class SimpleS0Test(SimpleRegisterTest):
 122     def test(self):
 123         self.check_reg("s0")
 124
 125 class SimpleS1Test(SimpleRegisterTest):
 126     def test(self):
 127         self.check_reg("s1")
 128
 129 class SimpleT0Test(SimpleRegisterTest):
 130     def test(self):
 131         self.check_reg("t0")
 132
 133 class SimpleT1Test(SimpleRegisterTest):
 134     def test(self):
 135         self.check_reg("t1")
 136
 137 class SimpleF18Test(SimpleRegisterTest):
 138     def check_reg(self, name):
 139         a = random.random()
 140         b = random.random()
 141         self.gdb.p_raw("$%s=%f" % (name, a))
 142         self.gdb.stepi()
 143         assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - a), .001)
 144         self.gdb.p_raw("$%s=%f" % (name, b))
 145         self.gdb.stepi()
 146         assertLess(abs(float(self.gdb.p_raw("$%s" % name)) - b), .001)
 147
 148     def test(self):
 149         misa = self.gdb.p("$misa")
 150         if not misa & (1<<(ord('F')-ord('A'))):
 151             return 'not_applicable'
 152         self.check_reg("f18")
 153
 154 class SimpleMemoryTest(GdbTest):
 155     def access_test(self, size, data_type):
 156         assertEqual(self.gdb.p("sizeof(%s)" % data_type), size)
 157         a = 0x86753095555aaaa & ((1<<(size*8))-1)
 158         b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
 159         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, self.target.ram, a))
 160         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, self.target.ram + size,
 161             b))
 162         assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, self.target.ram)),
 163                 a)
 164         assertEqual(self.gdb.p("*((%s*)0x%x)" % (
 165             data_type, self.target.ram + size)), b)
 166
 167 class MemTest8(SimpleMemoryTest):
 168     def test(self):
 169         self.access_test(1, 'char')
 170
 171 class MemTest16(SimpleMemoryTest):
 172     def test(self):
 173         self.access_test(2, 'short')
 174
 175 class MemTest32(SimpleMemoryTest):
 176     def test(self):
 177         self.access_test(4, 'int')
 178
 179 class MemTest64(SimpleMemoryTest):
 180     def test(self):
 181         self.access_test(8, 'long long')
 182
 183 class MemTestReadInvalid(SimpleMemoryTest):
 184     def test(self):
 185         # This test relies on 'gdb_report_data_abort enable' being executed in
 186         # the openocd.cfg file.
 187         try:
 188             self.gdb.p("*((int*)0xdeadbeef)")
 189             assert False, "Read should have failed."
 190         except testlib.CannotAccess as e:
 191             assertEqual(e.address, 0xdeadbeef)
 192         self.gdb.p("*((int*)0x%x)" % self.target.ram)
 193
 194 class MemTestWriteInvalid(SimpleMemoryTest):
 195     def test(self):
 196         # This test relies on 'gdb_report_data_abort enable' being executed in
 197         # the openocd.cfg file.
 198         try:
 199             self.gdb.p("*((int*)0xdeadbeef)=8675309")
 200             assert False, "Write should have failed."
 201         except testlib.CannotAccess as e:
 202             assertEqual(e.address, 0xdeadbeef)
 203         self.gdb.p("*((int*)0x%x)=6874742" % self.target.ram)
 204
 205 class MemTestBlock(GdbTest):
 206     def test(self):
 207         length = 1024
 208         line_length = 16
 209         a = tempfile.NamedTemporaryFile(suffix=".ihex")
 210         data = ""
 211         for i in range(length / line_length):
 212             line_data = "".join(["%c" % random.randrange(256)
 213                 for _ in range(line_length)])
 214             data += line_data
 215             a.write(ihex_line(i * line_length, 0, line_data))
 216         a.flush()
 217
 218         self.gdb.command("restore %s 0x%x" % (a.name, self.target.ram))
 219         for offset in range(0, length, 19*4) + [length-4]:
 220             value = self.gdb.p("*((int*)0x%x)" % (self.target.ram + offset))
 221             written = ord(data[offset]) | \
 222                     (ord(data[offset+1]) << 8) | \
 223                     (ord(data[offset+2]) << 16) | \
 224                     (ord(data[offset+3]) << 24)
 225             assertEqual(value, written)
 226
 227         b = tempfile.NamedTemporaryFile(suffix=".ihex")
 228         self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name,
 229             self.target.ram, self.target.ram + length))
 230         for line in b:
 231             record_type, address, line_data = ihex_parse(line)
 232             if record_type == 0:
 233                 assertEqual(readable_binary_string(line_data),
 234                         readable_binary_string(
 235                             data[address:address+len(line_data)]))
 236
 237 class InstantHaltTest(GdbTest):
 238     def test(self):
 239         assertEqual(self.target.reset_vector, self.gdb.p("$pc"))
 240         # mcycle and minstret have no defined reset value.
 241         mstatus = self.gdb.p("$mstatus")
 242         assertEqual(mstatus & (MSTATUS_MIE | MSTATUS_MPRV |
 243             MSTATUS_VM), 0)
 244
 245 class InstantChangePc(GdbTest):
 246     def test(self):
 247         """Change the PC right as we come out of reset."""
 248         # 0x13 is nop
 249         self.gdb.command("p *((int*) 0x%x)=0x13" % self.target.ram)
 250         self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 4))
 251         self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 8))
 252         self.gdb.p("$pc=0x%x" % self.target.ram)
 253         self.gdb.stepi()
 254         assertEqual((self.target.ram + 4), self.gdb.p("$pc"))
 255         self.gdb.stepi()
 256         assertEqual((self.target.ram + 8), self.gdb.p("$pc"))
 257
 258 class DebugTest(GdbTest):
 259     # Include malloc so that gdb can make function calls. I suspect this malloc
 260     # will silently blow through the memory set aside for it, so be careful.
 261     compile_args = ("programs/debug.c", "programs/checksum.c",
 262             "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
 263
 264     def setup(self):
 265         self.gdb.load()
 266         self.gdb.b("_exit")
 267
 268     def exit(self, expected_result=0xc86455d4):
 269         output = self.gdb.c()
 270         assertIn("Breakpoint", output)
 271         assertIn("_exit", output)
 272         assertEqual(self.gdb.p("status"), expected_result)
 273
 274 class DebugCompareSections(DebugTest):
 275     def test(self):
 276         output = self.gdb.command("compare-sections")
 277         matched = 0
 278         for line in output.splitlines():
 279             if line.startswith("Section"):
 280                 assert line.endswith("matched.")
 281                 matched += 1
 282         assertGreater(matched, 1)
 283
 284 class DebugFunctionCall(DebugTest):
 285     def test(self):
 286         self.gdb.b("main:start")
 287         self.gdb.c()
 288         assertEqual(self.gdb.p('fib(6)'), 8)
 289         assertEqual(self.gdb.p('fib(7)'), 13)
 290         self.exit()
 291
 292 class DebugChangeString(DebugTest):
 293     def test(self):
 294         text = "This little piggy went to the market."
 295         self.gdb.b("main:start")
 296         self.gdb.c()
 297         self.gdb.p('fox = "%s"' % text)
 298         self.exit(0x43b497b8)
 299
 300 class DebugTurbostep(DebugTest):
 301     def test(self):
 302         """Single step a bunch of times."""
 303         self.gdb.b("main:start")
 304         self.gdb.c()
 305         self.gdb.command("p i=0")
 306         last_pc = None
 307         advances = 0
 308         jumps = 0
 309         for _ in range(100):
 310             self.gdb.stepi()
 311             pc = self.gdb.p("$pc")
 312             assertNotEqual(last_pc, pc)
 313             if last_pc and pc > last_pc and pc - last_pc <= 4:
 314                 advances += 1
 315             else:
 316                 jumps += 1
 317             last_pc = pc
 318         # Some basic sanity that we're not running between breakpoints or
 319         # something.
 320         assertGreater(jumps, 10)
 321         assertGreater(advances, 50)
 322
 323 class DebugExit(DebugTest):
 324     def test(self):
 325         self.exit()
 326
 327 class DebugSymbols(DebugTest):
 328     def test(self):
 329         self.gdb.b("main")
 330         self.gdb.b("rot13")
 331         output = self.gdb.c()
 332         assertIn(", main ", output)
 333         output = self.gdb.c()
 334         assertIn(", rot13 ", output)
 335
 336 class DebugBreakpoint(DebugTest):
 337     def test(self):
 338         self.gdb.b("rot13")
 339         # The breakpoint should be hit exactly 2 times.
 340         for _ in range(2):
 341             output = self.gdb.c()
 342             self.gdb.p("$pc")
 343             assertIn("Breakpoint ", output)
 344             assertIn("rot13 ", output)
 345         self.exit()
 346
 347 class Hwbp1(DebugTest):
 348     def test(self):
 349         if self.target.instruction_hardware_breakpoint_count < 1:
 350             return 'not_applicable'
 351
 352         self.gdb.hbreak("rot13")
 353         # The breakpoint should be hit exactly 2 times.
 354         for _ in range(2):
 355             output = self.gdb.c()
 356             self.gdb.p("$pc")
 357             assertRegexpMatches(output, r"[bB]reakpoint")
 358             assertIn("rot13 ", output)
 359         self.exit()
 360
 361 class Hwbp2(DebugTest):
 362     def test(self):
 363         if self.target.instruction_hardware_breakpoint_count < 2:
 364             return 'not_applicable'
 365
 366         self.gdb.hbreak("main")
 367         self.gdb.hbreak("rot13")
 368         # We should hit 3 breakpoints.
 369         for expected in ("main", "rot13", "rot13"):
 370             output = self.gdb.c()
 371             self.gdb.p("$pc")
 372             assertRegexpMatches(output, r"[bB]reakpoint")
 373             assertIn("%s " % expected, output)
 374         self.exit()
 375
 376 class TooManyHwbp(DebugTest):
 377     def run(self):
 378         for i in range(30):
 379             self.gdb.hbreak("*rot13 + %d" % (i * 4))
 380
 381         output = self.gdb.c()
 382         assertIn("Cannot insert hardware breakpoint", output)
 383         # Clean up, otherwise the hardware breakpoints stay set and future
 384         # tests may fail.
 385         self.gdb.command("D")
 386
 387 class Registers(DebugTest):
 388     def test(self):
 389         # Get to a point in the code where some registers have actually been
 390         # used.
 391         self.gdb.b("rot13")
 392         self.gdb.c()
 393         self.gdb.c()
 394         # Try both forms to test gdb.
 395         for cmd in ("info all-registers", "info registers all"):
 396             output = self.gdb.command(cmd)
 397             for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
 398                 assertIn(reg, output)
 399
 400         #TODO
 401         # mcpuid is one of the few registers that should have the high bit set
 402         # (for rv64).
 403         # Leave this commented out until gdb and spike agree on the encoding of
 404         # mcpuid (which is going to be renamed to misa in any case).
 405         #assertRegexpMatches(output, ".*mcpuid *0x80")
 406
 407         #TODO:
 408         # The instret register should always be changing.
 409         #last_instret = None
 410         #for _ in range(5):
 411         #    instret = self.gdb.p("$instret")
 412         #    assertNotEqual(instret, last_instret)
 413         #    last_instret = instret
 414         #    self.gdb.stepi()
 415
 416         self.exit()
 417
 418 class UserInterrupt(DebugTest):
 419     def test(self):
 420         """Sending gdb ^C while the program is running should cause it to
 421         halt."""
 422         self.gdb.b("main:start")
 423         self.gdb.c()
 424         self.gdb.p("i=123")
 425         self.gdb.c(wait=False)
 426         time.sleep(0.1)
 427         output = self.gdb.interrupt()
 428         assert "main" in output
 429         assertGreater(self.gdb.p("j"), 10)
 430         self.gdb.p("i=0")
 431         self.exit()
 432
 433 class StepTest(GdbTest):
 434     compile_args = ("programs/step.S", )
 435
 436     def setup(self):
 437         self.gdb.load()
 438         self.gdb.b("main")
 439         self.gdb.c()
 440
 441     def test(self):
 442         main_address = self.gdb.p("$pc")
 443         for expected in (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c):
 444             self.gdb.stepi()
 445             pc = self.gdb.p("$pc")
 446             assertEqual("%x" % pc, "%x" % (expected + main_address))
 447
 448 class TriggerTest(GdbTest):
 449     compile_args = ("programs/trigger.S", )
 450     def setup(self):
 451         self.gdb.load()
 452         self.gdb.b("_exit")
 453         self.gdb.b("main")
 454         self.gdb.c()
 455
 456     def exit(self):
 457         output = self.gdb.c()
 458         assertIn("Breakpoint", output)
 459         assertIn("_exit", output)
 460
 461 class TriggerExecuteInstant(TriggerTest):
 462     """Test an execute breakpoint on the first instruction executed out of
 463     debug mode."""
 464     def test(self):
 465         main_address = self.gdb.p("$pc")
 466         self.gdb.command("hbreak *0x%x" % (main_address + 4))
 467         self.gdb.c()
 468         assertEqual(self.gdb.p("$pc"), main_address+4)
 469
 470 class TriggerLoadAddress(TriggerTest):
 471     def test(self):
 472         self.gdb.command("rwatch *((&data)+1)")
 473         output = self.gdb.c()
 474         assertIn("read_loop", output)
 475         assertEqual(self.gdb.p("$a0"),
 476                 self.gdb.p("(&data)+1"))
 477         self.exit()
 478
 479 class TriggerLoadAddressInstant(TriggerTest):
 480     """Test a load address breakpoint on the first instruction executed out of
 481     debug mode."""
 482     def test(self):
 483         self.gdb.command("b just_before_read_loop")
 484         self.gdb.c()
 485         read_loop = self.gdb.p("&read_loop")
 486         self.gdb.command("rwatch data")
 487         self.gdb.c()
 488         # Accept hitting the breakpoint before or after the load instruction.
 489         assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4])
 490         assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
 491
 492 class TriggerStoreAddress(TriggerTest):
 493     def test(self):
 494         self.gdb.command("watch *((&data)+3)")
 495         output = self.gdb.c()
 496         assertIn("write_loop", output)
 497         assertEqual(self.gdb.p("$a0"),
 498                 self.gdb.p("(&data)+3"))
 499         self.exit()
 500
 501 class TriggerStoreAddressInstant(TriggerTest):
 502     def test(self):
 503         """Test a store address breakpoint on the first instruction executed out
 504         of debug mode."""
 505         self.gdb.command("b just_before_write_loop")
 506         self.gdb.c()
 507         write_loop = self.gdb.p("&write_loop")
 508         self.gdb.command("watch data")
 509         self.gdb.c()
 510         # Accept hitting the breakpoint before or after the store instruction.
 511         assertIn(self.gdb.p("$pc"), [write_loop, write_loop + 4])
 512         assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
 513
 514 class TriggerDmode(TriggerTest):
 515     def check_triggers(self, tdata1_lsbs, tdata2):
 516         dmode = 1 << (self.target.xlen-5)
 517
 518         triggers = []
 519
 520         if self.target.xlen == 32:
 521             xlen_type = 'int'
 522         elif self.target.xlen == 64:
 523             xlen_type = 'long long'
 524         else:
 525             raise NotImplementedError
 526
 527         dmode_count = 0
 528         i = 0
 529         for i in range(16):
 530             tdata1 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i))
 531             if tdata1 == 0:
 532                 break
 533             tdata2 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i+1))
 534
 535             if tdata1 & dmode:
 536                 dmode_count += 1
 537             else:
 538                 assertEqual(tdata1 & 0xffff, tdata1_lsbs)
 539                 assertEqual(tdata2, tdata2)
 540
 541         assertGreater(i, 1)
 542         assertEqual(dmode_count, 1)
 543
 544         return triggers
 545
 546     def test(self):
 547         self.gdb.command("hbreak write_load_trigger")
 548         self.gdb.b("clear_triggers")
 549         self.gdb.p("$pc=write_store_trigger")
 550         output = self.gdb.c()
 551         assertIn("write_load_trigger", output)
 552         self.check_triggers((1<<6) | (1<<1), 0xdeadbee0)
 553         output = self.gdb.c()
 554         assertIn("clear_triggers", output)
 555         self.check_triggers((1<<6) | (1<<0), 0xfeedac00)
 556
 557 class RegsTest(GdbTest):
 558     compile_args = ("programs/regs.S", )
 559     def setup(self):
 560         self.gdb.load()
 561         self.gdb.b("main")
 562         self.gdb.b("handle_trap")
 563         self.gdb.c()
 564
 565 class WriteGprs(RegsTest):
 566     def test(self):
 567         regs = [("x%d" % n) for n in range(2, 32)]
 568
 569         self.gdb.p("$pc=write_regs")
 570         for i, r in enumerate(regs):
 571             self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17))
 572         self.gdb.p("$x1=data")
 573         self.gdb.command("b all_done")
 574         output = self.gdb.c()
 575         assertIn("Breakpoint ", output)
 576
 577         # Just to get this data in the log.
 578         self.gdb.command("x/30gx data")
 579         self.gdb.command("info registers")
 580         for n in range(len(regs)):
 581             assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
 582                     ((0xdeadbeef<<n)+17) & ((1<<self.target.xlen)-1))
 583
 584 class WriteCsrs(RegsTest):
 585     def test(self):
 586         # As much a test of gdb as of the simulator.
 587         self.gdb.p("$mscratch=0")
 588         self.gdb.stepi()
 589         assertEqual(self.gdb.p("$mscratch"), 0)
 590         self.gdb.p("$mscratch=123")
 591         self.gdb.stepi()
 592         assertEqual(self.gdb.p("$mscratch"), 123)
 593
 594         self.gdb.p("$pc=write_regs")
 595         self.gdb.p("$x1=data")
 596         self.gdb.command("b all_done")
 597         self.gdb.command("c")
 598
 599         assertEqual(123, self.gdb.p("$mscratch"))
 600         assertEqual(123, self.gdb.p("$x1"))
 601         assertEqual(123, self.gdb.p("$csr832"))
 602
 603 class DownloadTest(GdbTest):
 604     def setup(self):
 605         # pylint: disable=attribute-defined-outside-init
 606         length = min(2**20, self.target.ram_size - 2048)
 607         download_c = tempfile.NamedTemporaryFile(prefix="download_",
 608                 suffix=".c")
 609         download_c.write("#include <stdint.h>\n")
 610         download_c.write(
 611                 "unsigned int crc32a(uint8_t *message, unsigned int size);\n")
 612         download_c.write("uint32_t length = %d;\n" % length)
 613         download_c.write("uint8_t d[%d] = {\n" % length)
 614         self.crc = 0
 615         for i in range(length / 16):
 616             download_c.write("  /* 0x%04x */ " % (i * 16))
 617             for _ in range(16):
 618                 value = random.randrange(1<<8)
 619                 download_c.write("%d, " % value)
 620                 self.crc = binascii.crc32("%c" % value, self.crc)
 621             download_c.write("\n")
 622         download_c.write("};\n")
 623         download_c.write("uint8_t *data = &d[0];\n")
 624         download_c.write("uint32_t main() { return crc32a(data, length); }\n")
 625         download_c.flush()
 626
 627         if self.crc < 0:
 628             self.crc += 2**32
 629
 630         self.binary = self.target.compile(download_c.name,
 631                 "programs/checksum.c")
 632         self.gdb.command("file %s" % self.binary)
 633
 634     def test(self):
 635         self.gdb.load()
 636         self.gdb.command("b _exit")
 637         self.gdb.c()
 638         assertEqual(self.gdb.p("status"), self.crc)
 639
 640 class MprvTest(GdbTest):
 641     compile_args = ("programs/mprv.S", )
 642     def setup(self):
 643         self.gdb.load()
 644
 645     def test(self):
 646         """Test that the debugger can access memory when MPRV is set."""
 647         self.gdb.c(wait=False)
 648         time.sleep(0.5)
 649         self.gdb.interrupt()
 650         output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
 651         assertIn("0xbead", output)
 652
 653 class PrivTest(GdbTest):
 654     compile_args = ("programs/priv.S", )
 655     def setup(self):
 656         # pylint: disable=attribute-defined-outside-init
 657         self.gdb.load()
 658
 659         misa = self.gdb.p("$misa")
 660         self.supported = set()
 661         if misa & (1<<20):
 662             self.supported.add(0)
 663         if misa & (1<<18):
 664             self.supported.add(1)
 665         if misa & (1<<7):
 666             self.supported.add(2)
 667         self.supported.add(3)
 668
 669 class PrivRw(PrivTest):
 670     def test(self):
 671         """Test reading/writing priv."""
 672         for privilege in range(4):
 673             self.gdb.p("$priv=%d" % privilege)
 674             self.gdb.stepi()
 675             actual = self.gdb.p("$priv")
 676             assertIn(actual, self.supported)
 677             if privilege in self.supported:
 678                 assertEqual(actual, privilege)
 679
 680 class PrivChange(PrivTest):
 681     def test(self):
 682         """Test that the core's privilege level actually changes."""
 683
 684         if 0 not in self.supported:
 685             return 'not_applicable'
 686
 687         self.gdb.b("main")
 688         self.gdb.c()
 689
 690         # Machine mode
 691         self.gdb.p("$priv=3")
 692         main_address = self.gdb.p("$pc")
 693         self.gdb.stepi()
 694         assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
 695
 696         # User mode
 697         self.gdb.p("$priv=0")
 698         self.gdb.stepi()
 699         # Should have taken an exception, so be nowhere near main.
 700         pc = self.gdb.p("$pc")
 701         assertTrue(pc < main_address or pc > main_address + 0x100)
 702
 703 parsed = None
 704 def main():
 705     parser = argparse.ArgumentParser(
 706             description="Test that gdb can talk to a RISC-V target.",
 707             epilog="""
 708             Example command line from the real world:
 709             Run all RegsTest cases against a physical FPGA, with custom openocd command:
 710             ./gdbserver.py --freedom-e300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" Simple
 711             """)
 712     targets.add_target_options(parser)
 713     parser.add_argument("--gdb",
 714             help="The command to use to start gdb.")
 715
 716     testlib.add_test_run_options(parser)
 717
 718     # TODO: remove global
 719     global parsed   # pylint: disable=global-statement
 720     parsed = parser.parse_args()
 721
 722     target = parsed.target(parsed.cmd, parsed.run, parsed.isolate)
 723     if parsed.xlen:
 724         target.xlen = parsed.xlen
 725
 726     module = sys.modules[__name__]
 727
 728     return testlib.run_all_tests(module, target, parsed.test, parsed.fail_fast)
 729
 730 # TROUBLESHOOTING TIPS
 731 # If a particular test fails, run just that one test, eg.:
 732 # ./gdbserver.py MprvTest.test_mprv
 733 # Then inspect gdb.log and spike.log to see what happened in more detail.
 734
 735 if __name__ == '__main__':
 736     sys.exit(main())