Pull port number from VCS output and pass to OpenOCD.
[riscv-tests.git] / debug / gdbserver.py
1 #!/usr/bin/env python
2
3 import argparse
4 import binascii
5 import os
6 import random
7 import re
8 import sys
9 import tempfile
10 import time
11 import traceback
12
13 import testlib
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 def header(title):
90 dashes = '-' * (36 - len(title))
91 before = dashes[:len(dashes)/2]
92 after = dashes[len(dashes)/2:]
93 print "%s[ %s ]%s" % (before, title, after)
94
95 class GdbTest(object):
96 compiled = {}
97
98 def __init__(self, target):
99 self.target = target
100 self.server = None
101 self.binary = None
102 self.gdb = None
103
104 def setUp(self):
105 pass
106
107 def run(self):
108 """
109 If compile_args is set, compile a program and set self.binary.
110
111 Call setUp().
112
113 Then call test() and return the result, displaying relevant information
114 if an exception is raised.
115 """
116 self.server = self.target.server()
117
118 print "Running", type(self).__name__, "...",
119 sys.stdout.flush()
120
121 start = time.time()
122
123 compile_args = getattr(self, 'compile_args', None)
124 if compile_args:
125 if compile_args not in GdbTest.compiled:
126 try:
127 # pylint: disable=star-args
128 GdbTest.compiled[compile_args] = \
129 self.target.compile(*compile_args)
130 except Exception: # pylint: disable=broad-except
131 print "exception while compiling in %.2fs" % (
132 time.time() - start)
133 print "=" * 40
134 header("Traceback")
135 traceback.print_exc(file=sys.stdout)
136 print "/" * 40
137 return "exception"
138 self.binary = GdbTest.compiled.get(compile_args)
139
140 self.gdb = gdb(self.target, self.server.port, self.binary)
141
142 try:
143 self.setUp()
144 result = self.test() # pylint: disable=no-member
145 except Exception as e: # pylint: disable=broad-except
146 if isinstance(e, TestFailed):
147 result = "fail"
148 else:
149 result = "exception"
150 print "%s in %.2fs" % (result, time.time() - start)
151 print "=" * 40
152 if isinstance(e, TestFailed):
153 header("Message")
154 print e.message
155 header("Traceback")
156 traceback.print_exc(file=sys.stdout)
157 header("gdb.log")
158 print open("gdb.log", "r").read()
159 header(self.server.logname)
160 print open(self.server.logname, "r").read()
161 print "/" * 40
162 return result
163
164 finally:
165 del self.server
166 del self.gdb
167
168 if not result:
169 result = 'pass'
170 print "%s in %.2fs" % (result, time.time() - start)
171 return result
172
173 class TestFailed(Exception):
174 def __init__(self, message):
175 Exception.__init__(self)
176 self.message = message
177
178 def run_all_tests(target, tests, fail_fast):
179 good_results = set(('pass', 'not_applicable'))
180
181 results = {}
182 module = sys.modules[__name__]
183 for name in dir(module):
184 definition = getattr(module, name)
185 if type(definition) == type and hasattr(definition, 'test') and \
186 (not tests or any(test in name for test in tests)):
187 instance = definition(target)
188 result = instance.run()
189 results.setdefault(result, []).append(name)
190 if result not in good_results and fail_fast:
191 break
192
193 print ":" * 40
194
195 result = 0
196 for key, value in results.iteritems():
197 print "%d tests returned %s" % (len(value), key)
198 if key not in good_results:
199 result = 1
200 for test in value:
201 print " ", test
202
203 return result
204
205 def assertEqual(a, b):
206 if a != b:
207 raise TestFailed("%r != %r" % (a, b))
208
209 def assertNotEqual(a, b):
210 if a == b:
211 raise TestFailed("%r == %r" % (a, b))
212
213 def assertIn(a, b):
214 if a not in b:
215 raise TestFailed("%r not in %r" % (a, b))
216
217 def assertNotIn(a, b):
218 if a in b:
219 raise TestFailed("%r in %r" % (a, b))
220
221 def assertGreater(a, b):
222 if not a > b:
223 raise TestFailed("%r not greater than %r" % (a, b))
224
225 def assertTrue(a):
226 if not a:
227 raise TestFailed("%r is not True" % a)
228
229 def assertRegexpMatches(text, regexp):
230 if not re.search(regexp, text):
231 raise TestFailed("can't find %r in %r" % (regexp, text))
232
233 class SimpleRegisterTest(GdbTest):
234 def check_reg(self, name):
235 a = random.randrange(1<<self.target.xlen)
236 b = random.randrange(1<<self.target.xlen)
237 self.gdb.p("$%s=0x%x" % (name, a))
238 self.gdb.stepi()
239 assertEqual(self.gdb.p("$%s" % name), a)
240 self.gdb.p("$%s=0x%x" % (name, b))
241 self.gdb.stepi()
242 assertEqual(self.gdb.p("$%s" % name), b)
243
244 def setUp(self):
245 # 0x13 is nop
246 self.gdb.command("p *((int*) 0x%x)=0x13" % self.target.ram)
247 self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 4))
248 self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 8))
249 self.gdb.p("$pc=0x%x" % self.target.ram)
250
251 class SimpleS0Test(SimpleRegisterTest):
252 def test(self):
253 self.check_reg("s0")
254
255 class SimpleS1Test(SimpleRegisterTest):
256 def test(self):
257 self.check_reg("s1")
258
259 class SimpleT0Test(SimpleRegisterTest):
260 def test(self):
261 self.check_reg("t0")
262
263 class SimpleT1Test(SimpleRegisterTest):
264 def test(self):
265 self.check_reg("t1")
266
267 class SimpleMemoryTest(GdbTest):
268 def access_test(self, size, data_type):
269 assertEqual(self.gdb.p("sizeof(%s)" % data_type), size)
270 a = 0x86753095555aaaa & ((1<<(size*8))-1)
271 b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
272 self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, self.target.ram, a))
273 self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, self.target.ram + size,
274 b))
275 assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, self.target.ram)),
276 a)
277 assertEqual(self.gdb.p("*((%s*)0x%x)" % (
278 data_type, self.target.ram + size)), b)
279
280 class MemTest8(SimpleMemoryTest):
281 def test(self):
282 self.access_test(1, 'char')
283
284 class MemTest16(SimpleMemoryTest):
285 def test(self):
286 self.access_test(2, 'short')
287
288 class MemTest32(SimpleMemoryTest):
289 def test(self):
290 self.access_test(4, 'int')
291
292 class MemTest64(SimpleMemoryTest):
293 def test(self):
294 self.access_test(8, 'long long')
295
296 class MemTestReadInvalid(SimpleMemoryTest):
297 def test(self):
298 # This test relies on 'gdb_report_data_abort enable' being executed in
299 # the openocd.cfg file.
300 try:
301 self.gdb.p("*((int*)0xdeadbeef)")
302 assert False, "Read should have failed."
303 except testlib.CannotAccess as e:
304 assertEqual(e.address, 0xdeadbeef)
305 self.gdb.p("*((int*)0x%x)" % self.target.ram)
306
307 class MemTestWriteInvalid(SimpleMemoryTest):
308 def test(self):
309 # This test relies on 'gdb_report_data_abort enable' being executed in
310 # the openocd.cfg file.
311 try:
312 self.gdb.p("*((int*)0xdeadbeef)=8675309")
313 assert False, "Write should have failed."
314 except testlib.CannotAccess as e:
315 assertEqual(e.address, 0xdeadbeef)
316 self.gdb.p("*((int*)0x%x)=6874742" % self.target.ram)
317
318 class MemTestBlock(GdbTest):
319 def test(self):
320 length = 1024
321 line_length = 16
322 a = tempfile.NamedTemporaryFile(suffix=".ihex")
323 data = ""
324 for i in range(length / line_length):
325 line_data = "".join(["%c" % random.randrange(256)
326 for _ in range(line_length)])
327 data += line_data
328 a.write(ihex_line(i * line_length, 0, line_data))
329 a.flush()
330
331 self.gdb.command("restore %s 0x%x" % (a.name, self.target.ram))
332 for offset in range(0, length, 19*4) + [length-4]:
333 value = self.gdb.p("*((int*)0x%x)" % (self.target.ram + offset))
334 written = ord(data[offset]) | \
335 (ord(data[offset+1]) << 8) | \
336 (ord(data[offset+2]) << 16) | \
337 (ord(data[offset+3]) << 24)
338 assertEqual(value, written)
339
340 b = tempfile.NamedTemporaryFile(suffix=".ihex")
341 self.gdb.command("dump ihex memory %s 0x%x 0x%x" % (b.name,
342 self.target.ram, self.target.ram + length))
343 for line in b:
344 record_type, address, line_data = ihex_parse(line)
345 if record_type == 0:
346 assertEqual(readable_binary_string(line_data),
347 readable_binary_string(
348 data[address:address+len(line_data)]))
349
350 class InstantHaltTest(GdbTest):
351 def test(self):
352 assertEqual(self.target.reset_vector, self.gdb.p("$pc"))
353 # mcycle and minstret have no defined reset value.
354 mstatus = self.gdb.p("$mstatus")
355 assertEqual(mstatus & (MSTATUS_MIE | MSTATUS_MPRV |
356 MSTATUS_VM), 0)
357
358 class InstantChangePc(GdbTest):
359 def test(self):
360 """Change the PC right as we come out of reset."""
361 # 0x13 is nop
362 self.gdb.command("p *((int*) 0x%x)=0x13" % self.target.ram)
363 self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 4))
364 self.gdb.command("p *((int*) 0x%x)=0x13" % (self.target.ram + 8))
365 self.gdb.p("$pc=0x%x" % self.target.ram)
366 self.gdb.stepi()
367 assertEqual((self.target.ram + 4), self.gdb.p("$pc"))
368 self.gdb.stepi()
369 assertEqual((self.target.ram + 8), self.gdb.p("$pc"))
370
371 class DebugTest(GdbTest):
372 # Include malloc so that gdb can make function calls. I suspect this malloc
373 # will silently blow through the memory set aside for it, so be careful.
374 compile_args = ("programs/debug.c", "programs/checksum.c",
375 "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
376
377 def setUp(self):
378 self.gdb.load()
379 self.gdb.b("_exit")
380
381 def exit(self, expected_result=0xc86455d4):
382 output = self.gdb.c()
383 assertIn("Breakpoint", output)
384 assertIn("_exit", output)
385 assertEqual(self.gdb.p("status"), expected_result)
386
387 class DebugFunctionCall(DebugTest):
388 def test(self):
389 self.gdb.b("main:start")
390 self.gdb.c()
391 assertEqual(self.gdb.p('fib(6)'), 8)
392 assertEqual(self.gdb.p('fib(7)'), 13)
393 self.exit()
394
395 class DebugChangeString(DebugTest):
396 def test(self):
397 text = "This little piggy went to the market."
398 self.gdb.b("main:start")
399 self.gdb.c()
400 self.gdb.p('fox = "%s"' % text)
401 self.exit(0x43b497b8)
402
403 class DebugTurbostep(DebugTest):
404 def test(self):
405 """Single step a bunch of times."""
406 self.gdb.b("main:start")
407 self.gdb.c()
408 self.gdb.command("p i=0")
409 last_pc = None
410 advances = 0
411 jumps = 0
412 for _ in range(100):
413 self.gdb.stepi()
414 pc = self.gdb.p("$pc")
415 assertNotEqual(last_pc, pc)
416 if last_pc and pc > last_pc and pc - last_pc <= 4:
417 advances += 1
418 else:
419 jumps += 1
420 last_pc = pc
421 # Some basic sanity that we're not running between breakpoints or
422 # something.
423 assertGreater(jumps, 10)
424 assertGreater(advances, 50)
425
426 class DebugExit(DebugTest):
427 def test(self):
428 self.exit()
429
430 class DebugSymbols(DebugTest):
431 def test(self):
432 self.gdb.b("main")
433 self.gdb.b("rot13")
434 output = self.gdb.c()
435 assertIn(", main ", output)
436 output = self.gdb.c()
437 assertIn(", rot13 ", output)
438
439 class DebugBreakpoint(DebugTest):
440 def test(self):
441 self.gdb.b("rot13")
442 # The breakpoint should be hit exactly 2 times.
443 for _ in range(2):
444 output = self.gdb.c()
445 self.gdb.p("$pc")
446 assertIn("Breakpoint ", output)
447 assertIn("rot13 ", output)
448 self.exit()
449
450 class Hwbp1(DebugTest):
451 def test(self):
452 if self.target.instruction_hardware_breakpoint_count < 1:
453 return 'not_applicable'
454
455 self.gdb.hbreak("rot13")
456 # The breakpoint should be hit exactly 2 times.
457 for _ in range(2):
458 output = self.gdb.c()
459 self.gdb.p("$pc")
460 assertRegexpMatches(output, r"[bB]reakpoint")
461 assertIn("rot13 ", output)
462 self.exit()
463
464 class Hwbp2(DebugTest):
465 def test(self):
466 if self.target.instruction_hardware_breakpoint_count < 2:
467 return 'not_applicable'
468
469 self.gdb.hbreak("main")
470 self.gdb.hbreak("rot13")
471 # We should hit 3 breakpoints.
472 for expected in ("main", "rot13", "rot13"):
473 output = self.gdb.c()
474 self.gdb.p("$pc")
475 assertRegexpMatches(output, r"[bB]reakpoint")
476 assertIn("%s " % expected, output)
477 self.exit()
478
479 class TooManyHwbp(DebugTest):
480 def run(self):
481 for i in range(30):
482 self.gdb.hbreak("*rot13 + %d" % (i * 4))
483
484 output = self.gdb.c()
485 assertIn("Cannot insert hardware breakpoint", output)
486 # Clean up, otherwise the hardware breakpoints stay set and future
487 # tests may fail.
488 self.gdb.command("D")
489
490 class Registers(DebugTest):
491 def test(self):
492 # Get to a point in the code where some registers have actually been
493 # used.
494 self.gdb.b("rot13")
495 self.gdb.c()
496 self.gdb.c()
497 # Try both forms to test gdb.
498 for cmd in ("info all-registers", "info registers all"):
499 output = self.gdb.command(cmd)
500 assertNotIn("Could not", output)
501 for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
502 assertIn(reg, output)
503
504 #TODO
505 # mcpuid is one of the few registers that should have the high bit set
506 # (for rv64).
507 # Leave this commented out until gdb and spike agree on the encoding of
508 # mcpuid (which is going to be renamed to misa in any case).
509 #assertRegexpMatches(output, ".*mcpuid *0x80")
510
511 #TODO:
512 # The instret register should always be changing.
513 #last_instret = None
514 #for _ in range(5):
515 # instret = self.gdb.p("$instret")
516 # assertNotEqual(instret, last_instret)
517 # last_instret = instret
518 # self.gdb.stepi()
519
520 self.exit()
521
522 class UserInterrupt(DebugTest):
523 def test(self):
524 """Sending gdb ^C while the program is running should cause it to
525 halt."""
526 self.gdb.b("main:start")
527 self.gdb.c()
528 self.gdb.p("i=123")
529 self.gdb.c(wait=False)
530 time.sleep(0.1)
531 output = self.gdb.interrupt()
532 assert "main" in output
533 assertGreater(self.gdb.p("j"), 10)
534 self.gdb.p("i=0")
535 self.exit()
536
537 class StepTest(GdbTest):
538 compile_args = ("programs/step.S", )
539
540 def setUp(self):
541 self.gdb.load()
542 self.gdb.b("main")
543 self.gdb.c()
544
545 def test(self):
546 main_address = self.gdb.p("$pc")
547 for expected in (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c):
548 self.gdb.stepi()
549 pc = self.gdb.p("$pc")
550 assertEqual("%x" % pc, "%x" % (expected + main_address))
551
552 class TriggerTest(GdbTest):
553 compile_args = ("programs/trigger.S", )
554 def setUp(self):
555 self.gdb.load()
556 self.gdb.b("_exit")
557 self.gdb.b("main")
558 self.gdb.c()
559
560 def exit(self):
561 output = self.gdb.c()
562 assertIn("Breakpoint", output)
563 assertIn("_exit", output)
564
565 class TriggerExecuteInstant(TriggerTest):
566 """Test an execute breakpoint on the first instruction executed out of
567 debug mode."""
568 def test(self):
569 main_address = self.gdb.p("$pc")
570 self.gdb.command("hbreak *0x%x" % (main_address + 4))
571 self.gdb.c()
572 assertEqual(self.gdb.p("$pc"), main_address+4)
573
574 class TriggerLoadAddress(TriggerTest):
575 def test(self):
576 self.gdb.command("rwatch *((&data)+1)")
577 output = self.gdb.c()
578 assertIn("read_loop", output)
579 assertEqual(self.gdb.p("$a0"),
580 self.gdb.p("(&data)+1"))
581 self.exit()
582
583 class TriggerLoadAddressInstant(TriggerTest):
584 """Test a load address breakpoint on the first instruction executed out of
585 debug mode."""
586 def test(self):
587 self.gdb.command("b just_before_read_loop")
588 self.gdb.c()
589 read_loop = self.gdb.p("&read_loop")
590 self.gdb.command("rwatch data")
591 self.gdb.c()
592 # Accept hitting the breakpoint before or after the load instruction.
593 assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4])
594 assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
595
596 class TriggerStoreAddress(TriggerTest):
597 def test(self):
598 self.gdb.command("watch *((&data)+3)")
599 output = self.gdb.c()
600 assertIn("write_loop", output)
601 assertEqual(self.gdb.p("$a0"),
602 self.gdb.p("(&data)+3"))
603 self.exit()
604
605 class TriggerStoreAddressInstant(TriggerTest):
606 def test(self):
607 """Test a store address breakpoint on the first instruction executed out
608 of debug mode."""
609 self.gdb.command("b just_before_write_loop")
610 self.gdb.c()
611 write_loop = self.gdb.p("&write_loop")
612 self.gdb.command("watch data")
613 self.gdb.c()
614 # Accept hitting the breakpoint before or after the store instruction.
615 assertIn(self.gdb.p("$pc"), [write_loop, write_loop + 4])
616 assertEqual(self.gdb.p("$a0"), self.gdb.p("&data"))
617
618 class TriggerDmode(TriggerTest):
619 def check_triggers(self, tdata1_lsbs, tdata2):
620 dmode = 1 << (self.target.xlen-5)
621
622 triggers = []
623
624 if self.target.xlen == 32:
625 xlen_type = 'int'
626 elif self.target.xlen == 64:
627 xlen_type = 'long long'
628 else:
629 raise NotImplementedError
630
631 dmode_count = 0
632 i = 0
633 for i in range(16):
634 tdata1 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i))
635 if tdata1 == 0:
636 break
637 tdata2 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i+1))
638
639 if tdata1 & dmode:
640 dmode_count += 1
641 else:
642 assertEqual(tdata1 & 0xffff, tdata1_lsbs)
643 assertEqual(tdata2, tdata2)
644
645 assertGreater(i, 1)
646 assertEqual(dmode_count, 1)
647
648 return triggers
649
650 def test(self):
651 self.gdb.command("hbreak write_load_trigger")
652 self.gdb.b("clear_triggers")
653 self.gdb.p("$pc=write_store_trigger")
654 output = self.gdb.c()
655 assertIn("write_load_trigger", output)
656 self.check_triggers((1<<6) | (1<<1), 0xdeadbee0)
657 output = self.gdb.c()
658 assertIn("clear_triggers", output)
659 self.check_triggers((1<<6) | (1<<0), 0xfeedac00)
660
661 class RegsTest(GdbTest):
662 compile_args = ("programs/regs.S", )
663 def setUp(self):
664 self.gdb.load()
665 self.gdb.b("main")
666 self.gdb.b("handle_trap")
667 self.gdb.c()
668
669 class WriteGprs(RegsTest):
670 def test(self):
671 regs = [("x%d" % n) for n in range(2, 32)]
672
673 self.gdb.p("$pc=write_regs")
674 for i, r in enumerate(regs):
675 self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17))
676 self.gdb.p("$x1=data")
677 self.gdb.command("b all_done")
678 output = self.gdb.c()
679 assertIn("Breakpoint ", output)
680
681 # Just to get this data in the log.
682 self.gdb.command("x/30gx data")
683 self.gdb.command("info registers")
684 for n in range(len(regs)):
685 assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
686 ((0xdeadbeef<<n)+17) & ((1<<self.target.xlen)-1))
687
688 class WriteCsrs(RegsTest):
689 def test(self):
690 # As much a test of gdb as of the simulator.
691 self.gdb.p("$mscratch=0")
692 self.gdb.stepi()
693 assertEqual(self.gdb.p("$mscratch"), 0)
694 self.gdb.p("$mscratch=123")
695 self.gdb.stepi()
696 assertEqual(self.gdb.p("$mscratch"), 123)
697
698 self.gdb.command("p $pc=write_regs")
699 self.gdb.command("p $a0=data")
700 self.gdb.command("b all_done")
701 self.gdb.command("c")
702
703 assertEqual(123, self.gdb.p("$mscratch"))
704 assertEqual(123, self.gdb.p("$x1"))
705 assertEqual(123, self.gdb.p("$csr832"))
706
707 class DownloadTest(GdbTest):
708 def setUp(self):
709 length = min(2**20, self.target.ram_size - 2048)
710 download_c = tempfile.NamedTemporaryFile(prefix="download_",
711 suffix=".c")
712 download_c.write("#include <stdint.h>\n")
713 download_c.write(
714 "unsigned int crc32a(uint8_t *message, unsigned int size);\n")
715 download_c.write("uint32_t length = %d;\n" % length)
716 download_c.write("uint8_t d[%d] = {\n" % length)
717 self.crc = 0
718 for i in range(length / 16):
719 download_c.write(" /* 0x%04x */ " % (i * 16))
720 for _ in range(16):
721 value = random.randrange(1<<8)
722 download_c.write("%d, " % value)
723 self.crc = binascii.crc32("%c" % value, self.crc)
724 download_c.write("\n")
725 download_c.write("};\n")
726 download_c.write("uint8_t *data = &d[0];\n")
727 download_c.write("uint32_t main() { return crc32a(data, length); }\n")
728 download_c.flush()
729
730 if self.crc < 0:
731 self.crc += 2**32
732
733 self.binary = self.target.compile(download_c.name,
734 "programs/checksum.c")
735 self.gdb.command("file %s" % self.binary)
736
737 def test(self):
738 self.gdb.load()
739 self.gdb.command("b _exit")
740 self.gdb.c()
741 assertEqual(self.gdb.p("status"), self.crc)
742
743 class MprvTest(GdbTest):
744 compile_args = ("programs/mprv.S", )
745 def setUp(self):
746 self.gdb.load()
747
748 def test(self):
749 """Test that the debugger can access memory when MPRV is set."""
750 self.gdb.c(wait=False)
751 time.sleep(0.5)
752 self.gdb.interrupt()
753 output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
754 assertIn("0xbead", output)
755
756 class PrivTest(GdbTest):
757 compile_args = ("programs/priv.S", )
758 def setUp(self):
759 self.gdb.load()
760
761 misa = self.gdb.p("$misa")
762 self.supported = set()
763 if misa & (1<<20):
764 self.supported.add(0)
765 if misa & (1<<18):
766 self.supported.add(1)
767 if misa & (1<<7):
768 self.supported.add(2)
769 self.supported.add(3)
770
771 class PrivRw(PrivTest):
772 def test(self):
773 """Test reading/writing priv."""
774 for privilege in range(4):
775 self.gdb.p("$priv=%d" % privilege)
776 self.gdb.stepi()
777 actual = self.gdb.p("$priv")
778 assertIn(actual, self.supported)
779 if privilege in self.supported:
780 assertEqual(actual, privilege)
781
782 class PrivChange(PrivTest):
783 def test(self):
784 """Test that the core's privilege level actually changes."""
785
786 if 0 not in self.supported:
787 return 'not_applicable'
788
789 self.gdb.b("main")
790 self.gdb.c()
791
792 # Machine mode
793 self.gdb.p("$priv=3")
794 main_address = self.gdb.p("$pc")
795 self.gdb.stepi()
796 assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
797
798 # User mode
799 self.gdb.p("$priv=0")
800 self.gdb.stepi()
801 # Should have taken an exception, so be nowhere near main.
802 pc = self.gdb.p("$pc")
803 assertTrue(pc < main_address or pc > main_address + 0x100)
804
805 class Target(object):
806 name = "name"
807 xlen = 0
808 directory = None
809 timeout_sec = 2
810 temporary_files = []
811 temporary_binary = None
812
813 def server(self):
814 raise NotImplementedError
815
816 def compile(self, *sources):
817 binary_name = "%s_%s-%d" % (
818 self.name,
819 os.path.basename(os.path.splitext(sources[0])[0]),
820 self.xlen)
821 if parsed.isolate:
822 self.temporary_binary = tempfile.NamedTemporaryFile(
823 prefix=binary_name + "_")
824 binary_name = self.temporary_binary.name
825 Target.temporary_files.append(self.temporary_binary)
826 testlib.compile(sources +
827 ("programs/entry.S", "programs/init.c",
828 "-I", "../env",
829 "-T", "targets/%s/link.lds" % (self.directory or self.name),
830 "-nostartfiles",
831 "-mcmodel=medany",
832 "-o", binary_name),
833 xlen=self.xlen)
834 return binary_name
835
836 class SpikeTarget(Target):
837 directory = "spike"
838 ram = 0x80010000
839 ram_size = 5 * 1024 * 1024
840 instruction_hardware_breakpoint_count = 4
841 reset_vector = 0x1000
842
843 class Spike64Target(SpikeTarget):
844 name = "spike64"
845 xlen = 64
846
847 def server(self):
848 return testlib.Spike(parsed.cmd, halted=True)
849
850 class Spike32Target(SpikeTarget):
851 name = "spike32"
852 xlen = 32
853
854 def server(self):
855 return testlib.Spike(parsed.cmd, halted=True, xlen=32)
856
857 class FreedomE300Target(Target):
858 name = "freedom-e300"
859 xlen = 32
860 ram = 0x80000000
861 ram_size = 16 * 1024
862 instruction_hardware_breakpoint_count = 2
863
864 def server(self):
865 return testlib.Openocd(cmd=parsed.cmd,
866 config="targets/%s/openocd.cfg" % self.name)
867
868 class FreedomE300SimTarget(Target):
869 name = "freedom-e300-sim"
870 xlen = 32
871 timeout_sec = 240
872 ram = 0x80000000
873 ram_size = 256 * 1024 * 1024
874 instruction_hardware_breakpoint_count = 2
875
876 def server(self):
877 sim = testlib.VcsSim(simv=parsed.run, debug=False)
878 openocd = testlib.Openocd(cmd=parsed.cmd,
879 config="targets/%s/openocd.cfg" % self.name,
880 otherProcess=sim)
881 time.sleep(20)
882 return openocd
883
884 class FreedomU500Target(Target):
885 name = "freedom-u500"
886 xlen = 64
887 ram = 0x80000000
888 ram_size = 16 * 1024
889 instruction_hardware_breakpoint_count = 2
890
891 def server(self):
892 return testlib.Openocd(cmd=parsed.cmd,
893 config="targets/%s/openocd.cfg" % self.name)
894
895 class FreedomU500SimTarget(Target):
896 name = "freedom-u500-sim"
897 xlen = 64
898 timeout_sec = 240
899 ram = 0x80000000
900 ram_size = 256 * 1024 * 1024
901 instruction_hardware_breakpoint_count = 2
902
903 def server(self):
904 sim = testlib.VcsSim(simv=parsed.run, debug=False)
905 openocd = testlib.Openocd(cmd=parsed.cmd,
906 config="targets/%s/openocd.cfg" % self.name,
907 otherProcess=sim)
908 time.sleep(20)
909 return openocd
910
911 targets = [
912 Spike32Target,
913 Spike64Target,
914 FreedomE300Target,
915 FreedomU500Target,
916 FreedomE300SimTarget,
917 FreedomU500SimTarget]
918
919 parsed = None
920 def main():
921 parser = argparse.ArgumentParser(
922 epilog="""
923 Example command line from the real world:
924 Run all RegsTest cases against a physical FPGA, with custom openocd command:
925 ./gdbserver.py --freedom-e300 --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" RegsTest
926 """)
927 group = parser.add_mutually_exclusive_group(required=True)
928 for t in targets:
929 group.add_argument("--%s" % t.name, action="store_const", const=t,
930 dest="target")
931 parser.add_argument("--run",
932 help="The command to use to start the actual target (e.g. "
933 "simulation)")
934 parser.add_argument("--cmd",
935 help="The command to use to start the debug server.")
936 parser.add_argument("--gdb",
937 help="The command to use to start gdb.")
938
939 xlen_group = parser.add_mutually_exclusive_group()
940 xlen_group.add_argument("--32", action="store_const", const=32, dest="xlen",
941 help="Force the target to be 32-bit.")
942 xlen_group.add_argument("--64", action="store_const", const=64, dest="xlen",
943 help="Force the target to be 64-bit.")
944
945 parser.add_argument("--isolate", action="store_true",
946 help="Try to run in such a way that multiple instances can run at "
947 "the same time. This may make it harder to debug a failure if it "
948 "does occur.")
949
950 parser.add_argument("--fail-fast", "-f", action="store_true",
951 help="Exit as soon as any test fails.")
952
953 parser.add_argument("test", nargs='*',
954 help="Run only tests that are named here.")
955
956 # TODO: remove global
957 global parsed # pylint: disable=global-statement
958 parsed = parser.parse_args()
959
960 target = parsed.target()
961 if parsed.xlen:
962 target.xlen = parsed.xlen
963
964 return run_all_tests(target, parsed.test, parsed.fail_fast)
965
966 # TROUBLESHOOTING TIPS
967 # If a particular test fails, run just that one test, eg.:
968 # ./gdbserver.py MprvTest.test_mprv
969 # Then inspect gdb.log and spike.log to see what happened in more detail.
970
971 if __name__ == '__main__':
972 sys.exit(main())