debug/gdbserver.py

   1 #!/usr/bin/python
   2
   3 import os
   4 import sys
   5 import argparse
   6 import testlib
   7 import unittest
   8 import tempfile
   9 import time
  10 import random
  11 import binascii
  12
  13 def ihex_line(address, record_type, data):
  14     assert len(data) < 128
  15     line = ":%02X%04X%02X" % (len(data), address, record_type)
  16     check = len(data)
  17     check += address % 256
  18     check += address >> 8
  19     check += record_type
  20     for char in data:
  21         value = ord(char)
  22         check += value
  23         line += "%02X" % value
  24     line += "%02X\n" % ((256-check)%256)
  25     return line
  26
  27 def ihex_parse(line):
  28     assert line.startswith(":")
  29     line = line[1:]
  30     data_len = int(line[:2], 16)
  31     address = int(line[2:6], 16)
  32     record_type = int(line[6:8], 16)
  33     data = ""
  34     for i in range(data_len):
  35         data += "%c" % int(line[8+2*i:10+2*i], 16)
  36     return record_type, address, data
  37
  38 class DeleteServer(unittest.TestCase):
  39     def tearDown(self):
  40         del self.server
  41
  42 class SimpleRegisterTest(DeleteServer):
  43     def setUp(self):
  44         self.server = target.server()
  45         self.gdb = testlib.Gdb()
  46         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
  47
  48         # 0x13 is nop
  49         self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
  50         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
  51         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
  52         self.gdb.p("$pc=0x%x" % target.ram)
  53
  54     def check_reg(self, name):
  55         a = random.randrange(1<<target.xlen)
  56         b = random.randrange(1<<target.xlen)
  57         self.gdb.p("$%s=0x%x" % (name, a))
  58         self.gdb.stepi()
  59         self.assertEqual(self.gdb.p("$%s" % name), a)
  60         self.gdb.p("$%s=0x%x" % (name, b))
  61         self.gdb.stepi()
  62         self.assertEqual(self.gdb.p("$%s" % name), b)
  63
  64     def test_s0(self):
  65         # S0 is saved/restored in DSCRATCH
  66         self.check_reg("s0")
  67
  68     def test_s1(self):
  69         # S1 is saved/restored in Debug RAM
  70         self.check_reg("s1")
  71
  72     def test_t0(self):
  73         # T0 is not saved/restored at all
  74         self.check_reg("t2")
  75
  76     def test_t2(self):
  77         # T2 is not saved/restored at all
  78         self.check_reg("t2")
  79
  80 class SimpleMemoryTest(DeleteServer):
  81     def setUp(self):
  82         self.server = target.server()
  83         self.gdb = testlib.Gdb()
  84         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
  85
  86     def access_test(self, size, data_type):
  87         a = 0x86753095555aaaa & ((1<<(size*8))-1)
  88         b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
  89         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram, a))
  90         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram + size, b))
  91         self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram)), a)
  92         self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram + size)), b)
  93
  94     def test_8(self):
  95         self.access_test(1, 'char')
  96
  97     def test_16(self):
  98         self.access_test(2, 'short')
  99
 100     def test_32(self):
 101         self.access_test(4, 'long')
 102
 103     def test_64(self):
 104         self.access_test(8, 'long long')
 105
 106     def test_block(self):
 107         length = 1024
 108         line_length = 16
 109         fd = file("write.ihex", "w")
 110         data = ""
 111         for i in range(length / line_length):
 112             line_data = "".join(["%c" % random.randrange(256) for _ in range(line_length)])
 113             data += line_data
 114             fd.write(ihex_line(i * line_length, 0, line_data))
 115         fd.close()
 116
 117         self.gdb.command("restore write.ihex 0x%x" % target.ram)
 118         for offset in range(0, length, 19*4) + [length-4]:
 119             value = self.gdb.p("*((long*)0x%x)" % (target.ram + offset))
 120             written = ord(data[offset]) | \
 121                     (ord(data[offset+1]) << 8) | \
 122                     (ord(data[offset+2]) << 16) | \
 123                     (ord(data[offset+3]) << 24)
 124             self.assertEqual(value, written)
 125
 126         self.gdb.command("dump ihex memory read.ihex 0x%x 0x%x" % (target.ram,
 127             target.ram + length))
 128         for line in file("read.ihex"):
 129             record_type, address, line_data = ihex_parse(line)
 130             if (record_type == 0):
 131                 self.assertEqual(line_data, data[address:address+len(line_data)])
 132
 133 class InstantHaltTest(DeleteServer):
 134     def setUp(self):
 135         self.server = target.server()
 136         self.gdb = testlib.Gdb()
 137         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 138
 139     def test_instant_halt(self):
 140         self.assertEqual(0x1000, self.gdb.p("$pc"))
 141         # For some reason instret resets to 0.
 142         self.assertLess(self.gdb.p("$instret"), 8)
 143         self.gdb.stepi()
 144         self.assertNotEqual(0x1000, self.gdb.p("$pc"))
 145
 146     def test_change_pc(self):
 147         """Change the PC right as we come out of reset."""
 148         # 0x13 is nop
 149         self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
 150         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
 151         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
 152         self.gdb.p("$pc=0x%x" % target.ram)
 153         self.gdb.stepi()
 154         self.assertEqual((target.ram + 4), self.gdb.p("$pc"))
 155         self.gdb.stepi()
 156         self.assertEqual((target.ram + 8), self.gdb.p("$pc"))
 157
 158 class DebugTest(DeleteServer):
 159     def setUp(self):
 160         self.binary = target.compile("programs/debug.c", "programs/checksum.c")
 161         self.server = target.server()
 162         self.gdb = testlib.Gdb()
 163         self.gdb.command("file %s" % self.binary)
 164         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 165         self.gdb.load()
 166         self.gdb.b("_exit")
 167
 168     def exit(self):
 169         output = self.gdb.c()
 170         self.assertIn("Breakpoint", output)
 171         #TODO self.assertIn("_exit", output)
 172         #TODO self.assertEqual(self.gdb.p("status"), 0xc86455d4)
 173         # Use a0 until gdb can resolve "status"
 174         self.assertEqual(self.gdb.p("$a0") & 0xffffffff, 0xc86455d4)
 175
 176     def test_turbostep(self):
 177         """Single step a bunch of times."""
 178         self.gdb.command("p i=0");
 179         last_pc = None
 180         advances = 0
 181         jumps = 0
 182         for _ in range(100):
 183             self.gdb.stepi()
 184             pc = self.gdb.p("$pc")
 185             self.assertNotEqual(last_pc, pc)
 186             if (last_pc and pc > last_pc and pc - last_pc <= 4):
 187                 advances += 1
 188             else:
 189                 jumps += 1
 190             last_pc = pc
 191         # Some basic sanity that we're not running between breakpoints or
 192         # something.
 193         self.assertGreater(jumps, 10)
 194         self.assertGreater(advances, 50)
 195
 196     def test_exit(self):
 197         self.exit()
 198
 199     def test_breakpoint(self):
 200         self.gdb.b("rot13")
 201         # The breakpoint should be hit exactly 2 times.
 202         for i in range(2):
 203             output = self.gdb.c()
 204             self.gdb.p("$pc")
 205             self.assertIn("Breakpoint ", output)
 206             #TODO self.assertIn("rot13 ", output)
 207         self.exit()
 208
 209     def test_hwbp_1(self):
 210         self.gdb.hbreak("rot13")
 211         # The breakpoint should be hit exactly 2 times.
 212         for i in range(2):
 213             output = self.gdb.c()
 214             self.gdb.p("$pc")
 215             self.assertIn("Breakpoint ", output)
 216             #TODO self.assertIn("rot13 ", output)
 217         self.exit()
 218
 219     def test_hwbp_2(self):
 220         self.gdb.hbreak("main")
 221         self.gdb.hbreak("rot13")
 222         # We should hit 3 breakpoints.
 223         for i in range(3):
 224             output = self.gdb.c()
 225             self.gdb.p("$pc")
 226             self.assertIn("Breakpoint ", output)
 227             #TODO self.assertIn("rot13 ", output)
 228         self.exit()
 229
 230     def test_too_many_hwbp(self):
 231         for i in range(30):
 232             self.gdb.hbreak("*rot13 + %d" % (i * 4))
 233
 234         output = self.gdb.c()
 235         self.assertIn("Cannot insert hardware breakpoint", output)
 236
 237     def test_registers(self):
 238         # Get to a point in the code where some registers have actually been
 239         # used.
 240         self.gdb.b("rot13")
 241         self.gdb.c()
 242         self.gdb.c()
 243         # Try both forms to test gdb.
 244         for cmd in ("info all-registers", "info registers all"):
 245             output = self.gdb.command(cmd)
 246             self.assertNotIn("Could not", output)
 247             for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
 248                 self.assertIn(reg, output)
 249
 250         #TODO
 251         # mcpuid is one of the few registers that should have the high bit set
 252         # (for rv64).
 253         # Leave this commented out until gdb and spike agree on the encoding of
 254         # mcpuid (which is going to be renamed to misa in any case).
 255         #self.assertRegexpMatches(output, ".*mcpuid *0x80")
 256
 257         #TODO:
 258         # The instret register should always be changing.
 259         #last_instret = None
 260         #for _ in range(5):
 261         #    instret = self.gdb.p("$instret")
 262         #    self.assertNotEqual(instret, last_instret)
 263         #    last_instret = instret
 264         #    self.gdb.stepi()
 265
 266         self.exit()
 267
 268     def test_interrupt(self):
 269         """Sending gdb ^C while the program is running should cause it to halt."""
 270         self.gdb.b("main:start")
 271         self.gdb.c()
 272         self.gdb.p("i=123");
 273         self.gdb.c(wait=False)
 274         time.sleep(0.1)
 275         output = self.gdb.interrupt()
 276         #TODO: assert "main" in output
 277         self.assertGreater(self.gdb.p("j"), 10)
 278         self.gdb.p("i=0");
 279         self.exit()
 280
 281 class StepTest(DeleteServer):
 282     def setUp(self):
 283         self.binary = target.compile("programs/step.S")
 284         self.server = target.server()
 285         self.gdb = testlib.Gdb()
 286         self.gdb.command("file %s" % self.binary)
 287         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 288         self.gdb.load()
 289         self.gdb.b("main")
 290         self.gdb.c()
 291
 292     def test_step(self):
 293         main = self.gdb.p("$pc")
 294         for expected in (4, 0xc, 0x10, 0x18, 0x14, 0x14):
 295             self.gdb.stepi()
 296             pc = self.gdb.p("$pc")
 297             self.assertEqual(pc - main, expected)
 298
 299 class RegsTest(DeleteServer):
 300     def setUp(self):
 301         self.binary = target.compile("programs/regs.S")
 302         self.server = target.server()
 303         self.gdb = testlib.Gdb()
 304         self.gdb.command("file %s" % self.binary)
 305         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 306         self.gdb.load()
 307         self.gdb.b("main")
 308         self.gdb.b("handle_trap")
 309         self.gdb.c()
 310
 311     def test_write_gprs(self):
 312         regs = [("x%d" % n) for n in range(2, 32)]
 313
 314         self.gdb.p("$pc=write_regs")
 315         for i, r in enumerate(regs):
 316             self.gdb.command("p $%s=%d" % (r, (0xdeadbeef<<i)+17))
 317         self.gdb.command("p $x1=data")
 318         self.gdb.command("b all_done")
 319         output = self.gdb.c()
 320         self.assertIn("Breakpoint ", output)
 321
 322         # Just to get this data in the log.
 323         self.gdb.command("x/30gx data")
 324         self.gdb.command("info registers")
 325         for n in range(len(regs)):
 326             self.assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
 327                     ((0xdeadbeef<<n)+17) & ((1<<target.xlen)-1))
 328
 329     def test_write_csrs(self):
 330         # As much a test of gdb as of the simulator.
 331         self.gdb.p("$mscratch=0")
 332         self.gdb.stepi()
 333         self.assertEqual(self.gdb.p("$mscratch"), 0)
 334         self.gdb.p("$mscratch=123")
 335         self.gdb.stepi()
 336         self.assertEqual(self.gdb.p("$mscratch"), 123)
 337
 338         self.gdb.command("p $pc=write_regs")
 339         self.gdb.command("p $a0=data")
 340         self.gdb.command("b all_done")
 341         self.gdb.command("c")
 342
 343         self.assertEqual(123, self.gdb.p("$mscratch"))
 344         self.assertEqual(123, self.gdb.p("$x1"))
 345         self.assertEqual(123, self.gdb.p("$csr832"))
 346
 347 class DownloadTest(DeleteServer):
 348     def setUp(self):
 349         length = 2**20
 350         fd = file("download.c", "w")
 351         fd.write("#include <stdint.h>\n")
 352         fd.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n")
 353         fd.write("uint32_t length = %d;\n" % length)
 354         fd.write("uint8_t d[%d] = {\n" % length)
 355         self.crc = 0
 356         for i in range(length / 16):
 357             fd.write("  /* 0x%04x */ " % (i * 16));
 358             for _ in range(16):
 359                 value = random.randrange(1<<8)
 360                 fd.write("%d, " % value)
 361                 self.crc = binascii.crc32("%c" % value, self.crc)
 362             fd.write("\n");
 363         fd.write("};\n");
 364         fd.write("uint8_t *data = &d[0];\n");
 365         fd.write("uint32_t main() { return crc32a(data, length); }\n")
 366         fd.close()
 367
 368         if self.crc < 0:
 369             self.crc += 2**32
 370
 371         self.binary = target.compile("download.c", "programs/checksum.c")
 372         self.server = target.server()
 373         self.gdb = testlib.Gdb()
 374         self.gdb.command("file %s" % self.binary)
 375         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 376
 377     def test_download(self):
 378         output = self.gdb.load()
 379         self.gdb.command("b _exit")
 380         self.gdb.c()
 381         self.assertEqual(self.gdb.p("status"), self.crc)
 382
 383 class MprvTest(DeleteServer):
 384     def setUp(self):
 385         self.binary = target.compile("programs/mprv.S")
 386         self.server = target.server()
 387         self.gdb = testlib.Gdb()
 388         self.gdb.command("file %s" % self.binary)
 389         self.gdb.command("target extended-remote localhost:%d" % self.server.port)
 390         self.gdb.load()
 391
 392     def test_mprv(self):
 393         """Test that the debugger can access memory when MPRV is set."""
 394         self.gdb.c(wait=False)
 395         self.gdb.interrupt()
 396         output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
 397         self.assertIn("0xbead", output)
 398
 399 class Target(object):
 400     directory = None
 401
 402     def server(self):
 403         raise NotImplementedError
 404
 405     def compile(self, *sources):
 406         return testlib.compile(sources +
 407                 ("programs/entry.S", "programs/init.c",
 408                     "-I", "../env",
 409                     "-T", "targets/%s/link.lds" % (self.directory or self.name),
 410                     "-nostartfiles",
 411                     "-mcmodel=medany"), xlen=self.xlen)
 412
 413 class Spike64Target(Target):
 414     name = "spike"
 415     xlen = 64
 416     ram = 0x80010000
 417
 418     def server(self):
 419         return testlib.Spike(parsed.cmd, halted=True)
 420
 421 class Spike32Target(Target):
 422     name = "spike32"
 423     directory = "spike"
 424     xlen = 32
 425     ram = 0x80010000
 426
 427     def server(self):
 428         return testlib.Spike(parsed.cmd, halted=True, xlen=32)
 429
 430 class MicroSemiTarget(Target):
 431     name = "m2gl_m2s"
 432     xlen = 32
 433     ram = 0x80000000
 434
 435     def server(self):
 436         return testlib.Openocd(cmd=parsed.cmd,
 437                 config="targets/%s/openocd.cfg" % self.name)
 438
 439 targets = [
 440         Spike32Target,
 441         Spike64Target,
 442         MicroSemiTarget
 443         ]
 444
 445 def main():
 446     parser = argparse.ArgumentParser(
 447             epilog="""
 448             Example command line from the real world:
 449             Run all RegsTest cases against a MicroSemi m2gl_m2s board, with custom openocd command:
 450             ./gdbserver.py --m2gl_m2s --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest
 451             """)
 452     group = parser.add_mutually_exclusive_group(required=True)
 453     for t in targets:
 454         group.add_argument("--%s" % t.name, action="store_const", const=t,
 455                 dest="target")
 456     parser.add_argument("--cmd",
 457             help="The command to use to start the debug server.")
 458     parser.add_argument("unittest", nargs="*")
 459     global parsed
 460     parsed = parser.parse_args()
 461
 462     global target
 463     target = parsed.target()
 464     unittest.main(argv=[sys.argv[0]] + parsed.unittest)
 465
 466 # TROUBLESHOOTING TIPS
 467 # If a particular test fails, run just that one test, eg.:
 468 # ./tests/gdbserver.py MprvTest.test_mprv
 469 # Then inspect gdb.log and spike.log to see what happened in more detail.
 470
 471 if __name__ == '__main__':
 472     sys.exit(main())