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