2aa589a079401b2a32373b585991155f62e18fc0
[riscv-tests.git] / 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_load_address(self):
397 self.gdb.command("rwatch *((&data)+1)");
398 output = self.gdb.c()
399 self.assertIn("read_loop", output)
400 self.assertEqual(self.gdb.p("$a0"),
401 self.gdb.p("(&data)+1"))
402 self.exit()
403
404 def test_store_address(self):
405 self.gdb.command("watch *((&data)+3)");
406 output = self.gdb.c()
407 self.assertIn("write_loop", output)
408 self.assertEqual(self.gdb.p("$a0"),
409 self.gdb.p("(&data)+3"))
410 self.exit()
411
412 def test_dmode(self):
413 self.gdb.command("hbreak handle_trap")
414 self.gdb.p("$pc=write_valid")
415 output = self.gdb.c()
416 self.assertIn("handle_trap", output)
417 self.assertIn("mcause=2", output)
418 self.assertIn("mepc=%d" % self.gdb.p("&write_invalid_illegal"), output)
419
420 class RegsTest(DeleteServer):
421 def setUp(self):
422 self.binary = target.compile("programs/regs.S")
423 self.server = target.server()
424 self.gdb = gdb(target, self.server.port, self.binary)
425 self.gdb.load()
426 self.gdb.b("main")
427 self.gdb.b("handle_trap")
428 self.gdb.c()
429
430 def test_write_gprs(self):
431 regs = [("x%d" % n) for n in range(2, 32)]
432
433 self.gdb.p("$pc=write_regs")
434 for i, r in enumerate(regs):
435 self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17))
436 self.gdb.p("$x1=data")
437 self.gdb.command("b all_done")
438 output = self.gdb.c()
439 self.assertIn("Breakpoint ", output)
440
441 # Just to get this data in the log.
442 self.gdb.command("x/30gx data")
443 self.gdb.command("info registers")
444 for n in range(len(regs)):
445 self.assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
446 ((0xdeadbeef<<n)+17) & ((1<<target.xlen)-1))
447
448 def test_write_csrs(self):
449 # As much a test of gdb as of the simulator.
450 self.gdb.p("$mscratch=0")
451 self.gdb.stepi()
452 self.assertEqual(self.gdb.p("$mscratch"), 0)
453 self.gdb.p("$mscratch=123")
454 self.gdb.stepi()
455 self.assertEqual(self.gdb.p("$mscratch"), 123)
456
457 self.gdb.command("p $pc=write_regs")
458 self.gdb.command("p $a0=data")
459 self.gdb.command("b all_done")
460 self.gdb.command("c")
461
462 self.assertEqual(123, self.gdb.p("$mscratch"))
463 self.assertEqual(123, self.gdb.p("$x1"))
464 self.assertEqual(123, self.gdb.p("$csr832"))
465
466 class DownloadTest(DeleteServer):
467 def setUp(self):
468 length = min(2**20, target.ram_size - 2048)
469 download_c = tempfile.NamedTemporaryFile(prefix="download_", suffix=".c")
470 download_c.write("#include <stdint.h>\n")
471 download_c.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n")
472 download_c.write("uint32_t length = %d;\n" % length)
473 download_c.write("uint8_t d[%d] = {\n" % length)
474 self.crc = 0
475 for i in range(length / 16):
476 download_c.write(" /* 0x%04x */ " % (i * 16));
477 for _ in range(16):
478 value = random.randrange(1<<8)
479 download_c.write("%d, " % value)
480 self.crc = binascii.crc32("%c" % value, self.crc)
481 download_c.write("\n");
482 download_c.write("};\n");
483 download_c.write("uint8_t *data = &d[0];\n");
484 download_c.write("uint32_t main() { return crc32a(data, length); }\n")
485 download_c.flush()
486
487 if self.crc < 0:
488 self.crc += 2**32
489
490 self.binary = target.compile(download_c.name, "programs/checksum.c")
491 self.server = target.server()
492 self.gdb = gdb(target, self.server.port, self.binary)
493
494 def test_download(self):
495 output = self.gdb.load()
496 self.gdb.command("b _exit")
497 self.gdb.c()
498 self.assertEqual(self.gdb.p("status"), self.crc)
499
500 class MprvTest(DeleteServer):
501 def setUp(self):
502 self.binary = target.compile("programs/mprv.S")
503 self.server = target.server()
504 self.gdb = gdb(target, self.server.port, self.binary)
505 self.gdb.load()
506
507 def test_mprv(self):
508 """Test that the debugger can access memory when MPRV is set."""
509 self.gdb.c(wait=False)
510 time.sleep(0.5)
511 self.gdb.interrupt()
512 output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
513 self.assertIn("0xbead", output)
514
515 class PrivTest(DeleteServer):
516 def setUp(self):
517 self.binary = target.compile("programs/priv.S")
518 self.server = target.server()
519 self.gdb = gdb(target, self.server.port, self.binary)
520 self.gdb.load()
521
522 misa = self.gdb.p("$misa")
523 self.supported = set()
524 if misa & (1<<20):
525 self.supported.add(0)
526 if misa & (1<<18):
527 self.supported.add(1)
528 if misa & (1<<7):
529 self.supported.add(2)
530 self.supported.add(3)
531
532 def test_rw(self):
533 """Test reading/writing priv."""
534 for privilege in range(4):
535 self.gdb.p("$priv=%d" % privilege)
536 self.gdb.stepi()
537 actual = self.gdb.p("$priv")
538 self.assertIn(actual, self.supported)
539 if privilege in self.supported:
540 self.assertEqual(actual, privilege)
541
542 def test_change(self):
543 """Test that the core's privilege level actually changes."""
544
545 if 0 not in self.supported:
546 # TODO: return not applicable
547 return
548
549 self.gdb.b("main")
550 self.gdb.c()
551
552 # Machine mode
553 self.gdb.p("$priv=3")
554 main = self.gdb.p("$pc")
555 self.gdb.stepi()
556 self.assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main+4))
557
558 # User mode
559 self.gdb.p("$priv=0")
560 self.gdb.stepi()
561 # Should have taken an exception, so be nowhere near main.
562 pc = self.gdb.p("$pc")
563 self.assertTrue(pc < main or pc > main + 0x100)
564
565 class Target(object):
566 directory = None
567 timeout_sec = 2
568
569 def server(self):
570 raise NotImplementedError
571
572 def compile(self, *sources):
573 binary_name = "%s_%s-%d" % (
574 self.name,
575 os.path.basename(os.path.splitext(sources[0])[0]),
576 self.xlen)
577 if parsed.isolate:
578 self.temporary_binary = tempfile.NamedTemporaryFile(
579 prefix=binary_name + "_")
580 binary_name = self.temporary_binary.name
581 testlib.compile(sources +
582 ("programs/entry.S", "programs/init.c",
583 "-I", "../env",
584 "-T", "targets/%s/link.lds" % (self.directory or self.name),
585 "-nostartfiles",
586 "-mcmodel=medany",
587 "-o", binary_name),
588 xlen=self.xlen)
589 return binary_name
590
591 class SpikeTarget(Target):
592 directory = "spike"
593 ram = 0x80010000
594 ram_size = 5 * 1024 * 1024
595 instruction_hardware_breakpoint_count = 4
596 reset_vector = 0x1000
597
598 class Spike64Target(SpikeTarget):
599 name = "spike64"
600 xlen = 64
601
602 def server(self):
603 return testlib.Spike(parsed.cmd, halted=True)
604
605 class Spike32Target(SpikeTarget):
606 name = "spike32"
607 xlen = 32
608
609 def server(self):
610 return testlib.Spike(parsed.cmd, halted=True, xlen=32)
611
612 class FreedomE300Target(Target):
613 name = "freedom-e300"
614 xlen = 32
615 ram = 0x80000000
616 ram_size = 16 * 1024
617 instruction_hardware_breakpoint_count = 2
618
619 def server(self):
620 return testlib.Openocd(cmd=parsed.cmd,
621 config="targets/%s/openocd.cfg" % self.name)
622
623 class FreedomE300SimTarget(Target):
624 name = "freedom-e300-sim"
625 xlen = 32
626 timeout_sec = 240
627 ram = 0x80000000
628 ram_size = 256 * 1024 * 1024
629 instruction_hardware_breakpoint_count = 2
630
631 def server(self):
632 sim = testlib.VcsSim(simv=parsed.run, debug=False)
633 openocd = testlib.Openocd(cmd=parsed.cmd,
634 config="targets/%s/openocd.cfg" % self.name,
635 otherProcess = sim)
636 time.sleep(20)
637 return openocd
638
639 class FreedomU500Target(Target):
640 name = "freedom-u500"
641 xlen = 64
642 ram = 0x80000000
643 ram_size = 16 * 1024
644 instruction_hardware_breakpoint_count = 2
645
646 def server(self):
647 return testlib.Openocd(cmd=parsed.cmd,
648 config="targets/%s/openocd.cfg" % self.name)
649
650 class FreedomU500SimTarget(Target):
651 name = "freedom-u500-sim"
652 xlen = 64
653 timeout_sec = 240
654 ram = 0x80000000
655 ram_size = 256 * 1024 * 1024
656 instruction_hardware_breakpoint_count = 2
657
658 def server(self):
659 sim = testlib.VcsSim(simv=parsed.run, debug=False)
660 openocd = testlib.Openocd(cmd=parsed.cmd,
661 config="targets/%s/openocd.cfg" % self.name,
662 otherProcess = sim)
663 time.sleep(20)
664 return openocd
665
666 targets = [
667 Spike32Target,
668 Spike64Target,
669 FreedomE300Target,
670 FreedomU500Target,
671 FreedomE300SimTarget,
672 FreedomU500SimTarget]
673
674 def main():
675 parser = argparse.ArgumentParser(
676 epilog="""
677 Example command line from the real world:
678 Run all RegsTest cases against a physical FPGA, with custom openocd command:
679 ./gdbserver.py --freedom-e-300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest
680 """)
681 group = parser.add_mutually_exclusive_group(required=True)
682 for t in targets:
683 group.add_argument("--%s" % t.name, action="store_const", const=t,
684 dest="target")
685 parser.add_argument("--run",
686 help="The command to use to start the actual target (e.g. simulation)")
687 parser.add_argument("--cmd",
688 help="The command to use to start the debug server.")
689 parser.add_argument("--gdb",
690 help="The command to use to start gdb.")
691
692 xlen_group = parser.add_mutually_exclusive_group()
693 xlen_group.add_argument("--32", action="store_const", const=32, dest="xlen",
694 help="Force the target to be 32-bit.")
695 xlen_group.add_argument("--64", action="store_const", const=64, dest="xlen",
696 help="Force the target to be 64-bit.")
697
698 parser.add_argument("--isolate", action="store_true",
699 help="Try to run in such a way that multiple instances can run at "
700 "the same time. This may make it harder to debug a failure if it "
701 "does occur.")
702
703 parser.add_argument("unittest", nargs="*")
704 global parsed
705 parsed = parser.parse_args()
706
707 global target
708 target = parsed.target()
709
710 if parsed.xlen:
711 target.xlen = parsed.xlen
712
713 unittest.main(argv=[sys.argv[0]] + parsed.unittest)
714
715 # TROUBLESHOOTING TIPS
716 # If a particular test fails, run just that one test, eg.:
717 # ./gdbserver.py MprvTest.test_mprv
718 # Then inspect gdb.log and spike.log to see what happened in more detail.
719
720 if __name__ == '__main__':
721 sys.exit(main())