debug/gdbserver.py

   1 #!/usr/bin/env python
   2
   3 import os
   4 import sys
   5 import argparse
   6 import unittest
   7 import tempfile
   8 import time
   9 import random
  10 import binascii
  11
  12 import testlib
  13
  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 def gdb(
  36         target=None,
  37         port=None,
  38         binary=None
  39         ):
  40
  41     gdb = None
  42     if parsed.gdb:
  43         gdb = testlib.Gdb(parsed.gdb)
  44     else:
  45         gdb = testlib.Gdb()
  46
  47     if binary:
  48         gdb.command("file %s" % binary)
  49     if target:
  50         gdb.command("set arch riscv:rv%d" % target.xlen)
  51         gdb.command("set remotetimeout %d" % target.timeout_sec)
  52     if port:
  53         gdb.command("target extended-remote localhost:%d" % port)
  54
  55     gdb.p("$priv=3")
  56
  57     return gdb
  58
  59
  60 def ihex_line(address, record_type, data):
  61     assert len(data) < 128
  62     line = ":%02X%04X%02X" % (len(data), address, record_type)
  63     check = len(data)
  64     check += address % 256
  65     check += address >> 8
  66     check += record_type
  67     for char in data:
  68         value = ord(char)
  69         check += value
  70         line += "%02X" % value
  71     line += "%02X\n" % ((256-check)%256)
  72     return line
  73
  74 def ihex_parse(line):
  75     assert line.startswith(":")
  76     line = line[1:]
  77     data_len = int(line[:2], 16)
  78     address = int(line[2:6], 16)
  79     record_type = int(line[6:8], 16)
  80     data = ""
  81     for i in range(data_len):
  82         data += "%c" % int(line[8+2*i:10+2*i], 16)
  83     return record_type, address, data
  84
  85 def readable_binary_string(s):
  86     return "".join("%02x" % ord(c) for c in s)
  87
  88 class DeleteServer(unittest.TestCase):
  89     def tearDown(self):
  90         del self.server
  91
  92 class SimpleRegisterTest(DeleteServer):
  93     def setUp(self):
  94         self.server = target.server()
  95         self.gdb = gdb(target, self.server.port)
  96
  97         # 0x13 is nop
  98         self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
  99         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
 100         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
 101         self.gdb.p("$pc=0x%x" % target.ram)
 102
 103     def check_reg(self, name):
 104         a = random.randrange(1<<target.xlen)
 105         b = random.randrange(1<<target.xlen)
 106         self.gdb.p("$%s=0x%x" % (name, a))
 107         self.gdb.stepi()
 108         self.assertEqual(self.gdb.p("$%s" % name), a)
 109         self.gdb.p("$%s=0x%x" % (name, b))
 110         self.gdb.stepi()
 111         self.assertEqual(self.gdb.p("$%s" % name), b)
 112
 113     def test_s0(self):
 114         # S0 is saved/restored in DSCRATCH
 115         self.check_reg("s0")
 116
 117     def test_s1(self):
 118         # S1 is saved/restored in Debug RAM
 119         self.check_reg("s1")
 120
 121     def test_t0(self):
 122         # T0 is not saved/restored at all
 123         self.check_reg("t2")
 124
 125     def test_t2(self):
 126         # T2 is not saved/restored at all
 127         self.check_reg("t2")
 128
 129 class SimpleMemoryTest(DeleteServer):
 130     def setUp(self):
 131         self.server = target.server()
 132         self.gdb = gdb(target, self.server.port)
 133
 134     def access_test(self, size, data_type):
 135         self.assertEqual(self.gdb.p("sizeof(%s)" % data_type),
 136                 size)
 137         a = 0x86753095555aaaa & ((1<<(size*8))-1)
 138         b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
 139         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram, a))
 140         self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram + size, b))
 141         self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram)), a)
 142         self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram + size)), b)
 143
 144     def test_8(self):
 145         self.access_test(1, 'char')
 146
 147     def test_16(self):
 148         self.access_test(2, 'short')
 149
 150     def test_32(self):
 151         self.access_test(4, 'int')
 152
 153     def test_64(self):
 154         self.access_test(8, 'long long')
 155
 156     def test_block(self):
 157         length = 1024
 158         line_length = 16
 159         a = tempfile.NamedTemporaryFile(suffix=".ihex")
 160         data = ""
 161         for i in range(length / line_length):
 162             line_data = "".join(["%c" % random.randrange(256) for _ in range(line_length)])
 163             data += line_data
 164             a.write(ihex_line(i * line_length, 0, line_data))
 165         a.flush()
 166
 167         self.gdb.command("restore %s 0x%x" % (a.name, target.ram))
 168         for offset in range(0, length, 19*4) + [length-4]:
 169             value = self.gdb.p("*((int*)0x%x)" % (target.ram + offset))
 170             written = ord(data[offset]) | \
 171                     (ord(data[offset+1]) << 8) | \
 172                     (ord(data[offset+2]) << 16) | \
 173                     (ord(data[offset+3]) << 24)
 174             self.assertEqual(value, written)
 175
 176         b = tempfile.NamedTemporaryFile(suffix=".ihex")
 177         self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name, target.ram,
 178             target.ram + length))
 179         for line in b:
 180             record_type, address, line_data = ihex_parse(line)
 181             if (record_type == 0):
 182                 self.assertEqual(readable_binary_string(line_data),
 183                         readable_binary_string(data[address:address+len(line_data)]))
 184
 185 class InstantHaltTest(DeleteServer):
 186     def setUp(self):
 187         self.server = target.server()
 188         self.gdb = gdb(target, self.server.port)
 189
 190     def test_instant_halt(self):
 191         self.assertEqual(target.reset_vector, self.gdb.p("$pc"))
 192         # mcycle and minstret have no defined reset value.
 193         mstatus = self.gdb.p("$mstatus")
 194         self.assertEqual(mstatus & (MSTATUS_MIE | MSTATUS_MPRV |
 195             MSTATUS_VM), 0)
 196
 197     def test_change_pc(self):
 198         """Change the PC right as we come out of reset."""
 199         # 0x13 is nop
 200         self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
 201         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
 202         self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
 203         self.gdb.p("$pc=0x%x" % target.ram)
 204         self.gdb.stepi()
 205         self.assertEqual((target.ram + 4), self.gdb.p("$pc"))
 206         self.gdb.stepi()
 207         self.assertEqual((target.ram + 8), self.gdb.p("$pc"))
 208
 209 class DebugTest(DeleteServer):
 210     def setUp(self):
 211         # Include malloc so that gdb can make function calls. I suspect this
 212         # malloc will silently blow through the memory set aside for it, so be
 213         # careful.
 214         self.binary = target.compile("programs/debug.c", "programs/checksum.c",
 215                 "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
 216         self.server = target.server()
 217         self.gdb = gdb(target, self.server.port, self.binary)
 218         self.gdb.load()
 219         self.gdb.b("_exit")
 220
 221     def exit(self, expected_result = 0xc86455d4):
 222         output = self.gdb.c()
 223         self.assertIn("Breakpoint", output)
 224         self.assertIn("_exit", output)
 225         self.assertEqual(self.gdb.p("status"), expected_result)
 226
 227     def test_function_call(self):
 228         self.gdb.b("main:start")
 229         self.gdb.c()
 230         self.assertEqual(self.gdb.p('fib(6)'), 8)
 231         self.assertEqual(self.gdb.p('fib(7)'), 13)
 232         self.exit()
 233
 234     def test_change_string(self):
 235         text = "This little piggy went to the market."
 236         self.gdb.b("main:start")
 237         self.gdb.c()
 238         self.gdb.p('fox = "%s"' % text)
 239         self.exit(0x43b497b8)
 240
 241     def test_turbostep(self):
 242         """Single step a bunch of times."""
 243         self.gdb.b("main:start")
 244         self.gdb.c()
 245         self.gdb.command("p i=0");
 246         last_pc = None
 247         advances = 0
 248         jumps = 0
 249         for _ in range(100):
 250             self.gdb.stepi()
 251             pc = self.gdb.p("$pc")
 252             self.assertNotEqual(last_pc, pc)
 253             if (last_pc and pc > last_pc and pc - last_pc <= 4):
 254                 advances += 1
 255             else:
 256                 jumps += 1
 257             last_pc = pc
 258         # Some basic sanity that we're not running between breakpoints or
 259         # something.
 260         self.assertGreater(jumps, 10)
 261         self.assertGreater(advances, 50)
 262
 263     def test_exit(self):
 264         self.exit()
 265
 266     def test_symbols(self):
 267         self.gdb.b("main")
 268         self.gdb.b("rot13")
 269         output = self.gdb.c()
 270         self.assertIn(", main ", output)
 271         output = self.gdb.c()
 272         self.assertIn(", rot13 ", output)
 273
 274     def test_breakpoint(self):
 275         self.gdb.b("rot13")
 276         # The breakpoint should be hit exactly 2 times.
 277         for i in range(2):
 278             output = self.gdb.c()
 279             self.gdb.p("$pc")
 280             self.assertIn("Breakpoint ", output)
 281             #TODO self.assertIn("rot13 ", output)
 282         self.exit()
 283
 284     def test_hwbp_1(self):
 285         if target.instruction_hardware_breakpoint_count < 1:
 286             return
 287
 288         self.gdb.hbreak("rot13")
 289         # The breakpoint should be hit exactly 2 times.
 290         for i in range(2):
 291             output = self.gdb.c()
 292             self.gdb.p("$pc")
 293             self.assertIn("Breakpoint ", output)
 294             #TODO self.assertIn("rot13 ", output)
 295         self.exit()
 296
 297     def test_hwbp_2(self):
 298         if target.instruction_hardware_breakpoint_count < 2:
 299             return
 300
 301         self.gdb.hbreak("main")
 302         self.gdb.hbreak("rot13")
 303         # We should hit 3 breakpoints.
 304         for i in range(3):
 305             output = self.gdb.c()
 306             self.gdb.p("$pc")
 307             self.assertIn("Breakpoint ", output)
 308             #TODO self.assertIn("rot13 ", output)
 309         self.exit()
 310
 311     def test_too_many_hwbp(self):
 312         for i in range(30):
 313             self.gdb.hbreak("*rot13 + %d" % (i * 4))
 314
 315         output = self.gdb.c()
 316         self.assertIn("Cannot insert hardware breakpoint", output)
 317         # Clean up, otherwise the hardware breakpoints stay set and future
 318         # tests may fail.
 319         self.gdb.command("D")
 320
 321     def test_registers(self):
 322         # Get to a point in the code where some registers have actually been
 323         # used.
 324         self.gdb.b("rot13")
 325         self.gdb.c()
 326         self.gdb.c()
 327         # Try both forms to test gdb.
 328         for cmd in ("info all-registers", "info registers all"):
 329             output = self.gdb.command(cmd)
 330             self.assertNotIn("Could not", output)
 331             for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
 332                 self.assertIn(reg, output)
 333
 334         #TODO
 335         # mcpuid is one of the few registers that should have the high bit set
 336         # (for rv64).
 337         # Leave this commented out until gdb and spike agree on the encoding of
 338         # mcpuid (which is going to be renamed to misa in any case).
 339         #self.assertRegexpMatches(output, ".*mcpuid *0x80")
 340
 341         #TODO:
 342         # The instret register should always be changing.
 343         #last_instret = None
 344         #for _ in range(5):
 345         #    instret = self.gdb.p("$instret")
 346         #    self.assertNotEqual(instret, last_instret)
 347         #    last_instret = instret
 348         #    self.gdb.stepi()
 349
 350         self.exit()
 351
 352     def test_interrupt(self):
 353         """Sending gdb ^C while the program is running should cause it to halt."""
 354         self.gdb.b("main:start")
 355         self.gdb.c()
 356         self.gdb.p("i=123");
 357         self.gdb.c(wait=False)
 358         time.sleep(0.1)
 359         output = self.gdb.interrupt()
 360         #TODO: assert "main" in output
 361         self.assertGreater(self.gdb.p("j"), 10)
 362         self.gdb.p("i=0");
 363         self.exit()
 364
 365 class StepTest(DeleteServer):
 366     def setUp(self):
 367         self.binary = target.compile("programs/step.S")
 368         self.server = target.server()
 369         self.gdb = gdb(target, self.server.port, self.binary)
 370         self.gdb.load()
 371         self.gdb.b("main")
 372         self.gdb.c()
 373
 374     def test_step(self):
 375         main = self.gdb.p("$pc")
 376         for expected in (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c):
 377             self.gdb.stepi()
 378             pc = self.gdb.p("$pc")
 379             self.assertEqual("%x" % pc, "%x" % (expected + main))
 380
 381 class TriggerTest(DeleteServer):
 382     def setUp(self):
 383         self.binary = target.compile("programs/trigger.S")
 384         self.server = target.server()
 385         self.gdb = gdb(target, self.server.port, self.binary)
 386         self.gdb.load()
 387         self.gdb.b("_exit")
 388         self.gdb.b("main")
 389         self.gdb.c()
 390
 391     def exit(self):
 392         output = self.gdb.c()
 393         self.assertIn("Breakpoint", output)
 394         self.assertIn("_exit", output)
 395
 396     def test_execute_instant(self):
 397         """Test an execute breakpoint on the first instruction executed out of
 398         debug mode."""
 399         main = self.gdb.p("$pc")
 400         self.gdb.command("hbreak *0x%x" % (main + 4))
 401         self.gdb.c()
 402         self.assertEqual(self.gdb.p("$pc"), main+4)
 403
 404     def test_load_address(self):
 405         self.gdb.command("rwatch *((&data)+1)");
 406         output = self.gdb.c()
 407         self.assertIn("read_loop", output)
 408         self.assertEqual(self.gdb.p("$a0"),
 409                 self.gdb.p("(&data)+1"))
 410         self.exit()
 411
 412     def test_load_address_instant(self):
 413         """Test a load address breakpoint on the first instruction executed out
 414         of debug mode."""
 415         self.gdb.command("b just_before_read_loop")
 416         self.gdb.c()
 417         read_loop = self.gdb.p("&read_loop")
 418         self.gdb.command("rwatch data");
 419         self.gdb.c()
 420         # Accept hitting the breakpoint before or after the load instruction.
 421         self.assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4])
 422         self.assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
 423
 424     def test_store_address(self):
 425         self.gdb.command("watch *((&data)+3)");
 426         output = self.gdb.c()
 427         self.assertIn("write_loop", output)
 428         self.assertEqual(self.gdb.p("$a0"),
 429                 self.gdb.p("(&data)+3"))
 430         self.exit()
 431
 432     def test_store_address_instant(self):
 433         """Test a store address breakpoint on the first instruction executed out
 434         of debug mode."""
 435         self.gdb.command("b just_before_write_loop")
 436         self.gdb.c()
 437         write_loop = self.gdb.p("&write_loop")
 438         self.gdb.command("watch data");
 439         self.gdb.c()
 440         # Accept hitting the breakpoint before or after the store instruction.
 441         self.assertIn(self.gdb.p("$pc"), [write_loop, write_loop + 4])
 442         self.assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
 443
 444     def test_dmode(self):
 445         self.gdb.command("hbreak handle_trap")
 446         self.gdb.p("$pc=write_valid")
 447         output = self.gdb.c()
 448         self.assertIn("handle_trap", output)
 449         self.assertIn("mcause=2", output)
 450         self.assertIn("mepc=%d" % self.gdb.p("&write_invalid_illegal"), output)
 451
 452 class RegsTest(DeleteServer):
 453     def setUp(self):
 454         self.binary = target.compile("programs/regs.S")
 455         self.server = target.server()
 456         self.gdb = gdb(target, self.server.port, self.binary)
 457         self.gdb.load()
 458         self.gdb.b("main")
 459         self.gdb.b("handle_trap")
 460         self.gdb.c()
 461
 462     def test_write_gprs(self):
 463         regs = [("x%d" % n) for n in range(2, 32)]
 464
 465         self.gdb.p("$pc=write_regs")
 466         for i, r in enumerate(regs):
 467             self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17))
 468         self.gdb.p("$x1=data")
 469         self.gdb.command("b all_done")
 470         output = self.gdb.c()
 471         self.assertIn("Breakpoint ", output)
 472
 473         # Just to get this data in the log.
 474         self.gdb.command("x/30gx data")
 475         self.gdb.command("info registers")
 476         for n in range(len(regs)):
 477             self.assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
 478                     ((0xdeadbeef<<n)+17) & ((1<<target.xlen)-1))
 479
 480     def test_write_csrs(self):
 481         # As much a test of gdb as of the simulator.
 482         self.gdb.p("$mscratch=0")
 483         self.gdb.stepi()
 484         self.assertEqual(self.gdb.p("$mscratch"), 0)
 485         self.gdb.p("$mscratch=123")
 486         self.gdb.stepi()
 487         self.assertEqual(self.gdb.p("$mscratch"), 123)
 488
 489         self.gdb.command("p $pc=write_regs")
 490         self.gdb.command("p $a0=data")
 491         self.gdb.command("b all_done")
 492         self.gdb.command("c")
 493
 494         self.assertEqual(123, self.gdb.p("$mscratch"))
 495         self.assertEqual(123, self.gdb.p("$x1"))
 496         self.assertEqual(123, self.gdb.p("$csr832"))
 497
 498 class DownloadTest(DeleteServer):
 499     def setUp(self):
 500         length = min(2**20, target.ram_size - 2048)
 501         download_c = tempfile.NamedTemporaryFile(prefix="download_", suffix=".c")
 502         download_c.write("#include <stdint.h>\n")
 503         download_c.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n")
 504         download_c.write("uint32_t length = %d;\n" % length)
 505         download_c.write("uint8_t d[%d] = {\n" % length)
 506         self.crc = 0
 507         for i in range(length / 16):
 508             download_c.write("  /* 0x%04x */ " % (i * 16));
 509             for _ in range(16):
 510                 value = random.randrange(1<<8)
 511                 download_c.write("%d, " % value)
 512                 self.crc = binascii.crc32("%c" % value, self.crc)
 513             download_c.write("\n");
 514         download_c.write("};\n");
 515         download_c.write("uint8_t *data = &d[0];\n");
 516         download_c.write("uint32_t main() { return crc32a(data, length); }\n")
 517         download_c.flush()
 518
 519         if self.crc < 0:
 520             self.crc += 2**32
 521
 522         self.binary = target.compile(download_c.name, "programs/checksum.c")
 523         self.server = target.server()
 524         self.gdb = gdb(target, self.server.port, self.binary)
 525
 526     def test_download(self):
 527         output = self.gdb.load()
 528         self.gdb.command("b _exit")
 529         self.gdb.c()
 530         self.assertEqual(self.gdb.p("status"), self.crc)
 531
 532 class MprvTest(DeleteServer):
 533     def setUp(self):
 534         self.binary = target.compile("programs/mprv.S")
 535         self.server = target.server()
 536         self.gdb = gdb(target, self.server.port, self.binary)
 537         self.gdb.load()
 538
 539     def test_mprv(self):
 540         """Test that the debugger can access memory when MPRV is set."""
 541         self.gdb.c(wait=False)
 542         time.sleep(0.5)
 543         self.gdb.interrupt()
 544         output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
 545         self.assertIn("0xbead", output)
 546
 547 class PrivTest(DeleteServer):
 548     def setUp(self):
 549         self.binary = target.compile("programs/priv.S")
 550         self.server = target.server()
 551         self.gdb = gdb(target, self.server.port, self.binary)
 552         self.gdb.load()
 553
 554         misa = self.gdb.p("$misa")
 555         self.supported = set()
 556         if misa & (1<<20):
 557             self.supported.add(0)
 558         if misa & (1<<18):
 559             self.supported.add(1)
 560         if misa & (1<<7):
 561             self.supported.add(2)
 562         self.supported.add(3)
 563
 564     def test_rw(self):
 565         """Test reading/writing priv."""
 566         for privilege in range(4):
 567             self.gdb.p("$priv=%d" % privilege)
 568             self.gdb.stepi()
 569             actual = self.gdb.p("$priv")
 570             self.assertIn(actual, self.supported)
 571             if privilege in self.supported:
 572                 self.assertEqual(actual, privilege)
 573
 574     def test_change(self):
 575         """Test that the core's privilege level actually changes."""
 576
 577         if 0 not in self.supported:
 578             # TODO: return not applicable
 579             return
 580
 581         self.gdb.b("main")
 582         self.gdb.c()
 583
 584         # Machine mode
 585         self.gdb.p("$priv=3")
 586         main = self.gdb.p("$pc")
 587         self.gdb.stepi()
 588         self.assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main+4))
 589
 590         # User mode
 591         self.gdb.p("$priv=0")
 592         self.gdb.stepi()
 593         # Should have taken an exception, so be nowhere near main.
 594         pc = self.gdb.p("$pc")
 595         self.assertTrue(pc < main or pc > main + 0x100)
 596
 597 class Target(object):
 598     directory = None
 599     timeout_sec = 2
 600
 601     def server(self):
 602         raise NotImplementedError
 603
 604     def compile(self, *sources):
 605         binary_name = "%s_%s-%d" % (
 606                 self.name,
 607                 os.path.basename(os.path.splitext(sources[0])[0]),
 608                 self.xlen)
 609         if parsed.isolate:
 610             self.temporary_binary = tempfile.NamedTemporaryFile(
 611                     prefix=binary_name + "_")
 612             binary_name = self.temporary_binary.name
 613         testlib.compile(sources +
 614                 ("programs/entry.S", "programs/init.c",
 615                     "-I", "../env",
 616                     "-T", "targets/%s/link.lds" % (self.directory or self.name),
 617                     "-nostartfiles",
 618                     "-mcmodel=medany",
 619                     "-o", binary_name),
 620                 xlen=self.xlen)
 621         return binary_name
 622
 623 class SpikeTarget(Target):
 624     directory = "spike"
 625     ram = 0x80010000
 626     ram_size = 5 * 1024 * 1024
 627     instruction_hardware_breakpoint_count = 4
 628     reset_vector = 0x1000
 629
 630 class Spike64Target(SpikeTarget):
 631     name = "spike64"
 632     xlen = 64
 633
 634     def server(self):
 635         return testlib.Spike(parsed.cmd, halted=True)
 636
 637 class Spike32Target(SpikeTarget):
 638     name = "spike32"
 639     xlen = 32
 640
 641     def server(self):
 642         return testlib.Spike(parsed.cmd, halted=True, xlen=32)
 643
 644 class FreedomE300Target(Target):
 645     name = "freedom-e300"
 646     xlen = 32
 647     ram = 0x80000000
 648     ram_size = 16 * 1024
 649     instruction_hardware_breakpoint_count = 2
 650
 651     def server(self):
 652         return testlib.Openocd(cmd=parsed.cmd,
 653                 config="targets/%s/openocd.cfg" % self.name)
 654
 655 class FreedomE300SimTarget(Target):
 656     name = "freedom-e300-sim"
 657     xlen = 32
 658     timeout_sec = 240
 659     ram = 0x80000000
 660     ram_size = 256 * 1024 * 1024
 661     instruction_hardware_breakpoint_count = 2
 662
 663     def server(self):
 664         sim = testlib.VcsSim(simv=parsed.run, debug=False)
 665         openocd = testlib.Openocd(cmd=parsed.cmd,
 666                             config="targets/%s/openocd.cfg" % self.name,
 667                             otherProcess = sim)
 668         time.sleep(20)
 669         return openocd
 670
 671 class FreedomU500Target(Target):
 672     name = "freedom-u500"
 673     xlen = 64
 674     ram = 0x80000000
 675     ram_size = 16 * 1024
 676     instruction_hardware_breakpoint_count = 2
 677
 678     def server(self):
 679         return testlib.Openocd(cmd=parsed.cmd,
 680                 config="targets/%s/openocd.cfg" % self.name)
 681
 682 class FreedomU500SimTarget(Target):
 683     name = "freedom-u500-sim"
 684     xlen = 64
 685     timeout_sec = 240
 686     ram = 0x80000000
 687     ram_size = 256 * 1024 * 1024
 688     instruction_hardware_breakpoint_count = 2
 689
 690     def server(self):
 691         sim = testlib.VcsSim(simv=parsed.run, debug=False)
 692         openocd = testlib.Openocd(cmd=parsed.cmd,
 693                             config="targets/%s/openocd.cfg" % self.name,
 694                             otherProcess = sim)
 695         time.sleep(20)
 696         return openocd
 697
 698 targets = [
 699         Spike32Target,
 700         Spike64Target,
 701         FreedomE300Target,
 702         FreedomU500Target,
 703         FreedomE300SimTarget,
 704         FreedomU500SimTarget]
 705
 706 def main():
 707     parser = argparse.ArgumentParser(
 708             epilog="""
 709             Example command line from the real world:
 710             Run all RegsTest cases against a physical FPGA, with custom openocd command:
 711             ./gdbserver.py --freedom-e-300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest
 712             """)
 713     group = parser.add_mutually_exclusive_group(required=True)
 714     for t in targets:
 715         group.add_argument("--%s" % t.name, action="store_const", const=t,
 716                 dest="target")
 717     parser.add_argument("--run",
 718                         help="The command to use to start the actual target (e.g. simulation)")
 719     parser.add_argument("--cmd",
 720             help="The command to use to start the debug server.")
 721     parser.add_argument("--gdb",
 722             help="The command to use to start gdb.")
 723
 724     xlen_group = parser.add_mutually_exclusive_group()
 725     xlen_group.add_argument("--32", action="store_const", const=32, dest="xlen",
 726             help="Force the target to be 32-bit.")
 727     xlen_group.add_argument("--64", action="store_const", const=64, dest="xlen",
 728             help="Force the target to be 64-bit.")
 729
 730     parser.add_argument("--isolate", action="store_true",
 731             help="Try to run in such a way that multiple instances can run at "
 732             "the same time. This may make it harder to debug a failure if it "
 733             "does occur.")
 734
 735     parser.add_argument("unittest", nargs="*")
 736     global parsed
 737     parsed = parser.parse_args()
 738
 739     global target
 740     target = parsed.target()
 741
 742     if parsed.xlen:
 743         target.xlen = parsed.xlen
 744
 745     unittest.main(argv=[sys.argv[0]] + parsed.unittest)
 746
 747 # TROUBLESHOOTING TIPS
 748 # If a particular test fails, run just that one test, eg.:
 749 # ./gdbserver.py MprvTest.test_mprv
 750 # Then inspect gdb.log and spike.log to see what happened in more detail.
 751
 752 if __name__ == '__main__':
 753     sys.exit(main())