13 MSTATUS_UIE
= 0x00000001
14 MSTATUS_SIE
= 0x00000002
15 MSTATUS_HIE
= 0x00000004
16 MSTATUS_MIE
= 0x00000008
17 MSTATUS_UPIE
= 0x00000010
18 MSTATUS_SPIE
= 0x00000020
19 MSTATUS_HPIE
= 0x00000040
20 MSTATUS_MPIE
= 0x00000080
21 MSTATUS_SPP
= 0x00000100
22 MSTATUS_HPP
= 0x00000600
23 MSTATUS_MPP
= 0x00001800
24 MSTATUS_FS
= 0x00006000
25 MSTATUS_XS
= 0x00018000
26 MSTATUS_MPRV
= 0x00020000
27 MSTATUS_PUM
= 0x00040000
28 MSTATUS_MXR
= 0x00080000
29 MSTATUS_VM
= 0x1F000000
30 MSTATUS32_SD
= 0x80000000
31 MSTATUS64_SD
= 0x8000000000000000
35 return testlib
.Gdb(parsed
.gdb
)
39 def ihex_line(address
, record_type
, data
):
40 assert len(data
) < 128
41 line
= ":%02X%04X%02X" % (len(data
), address
, record_type
)
43 check
+= address
% 256
49 line
+= "%02X" % value
50 line
+= "%02X\n" % ((256-check
)%256)
54 assert line
.startswith(":")
56 data_len
= int(line
[:2], 16)
57 address
= int(line
[2:6], 16)
58 record_type
= int(line
[6:8], 16)
60 for i
in range(data_len
):
61 data
+= "%c" % int(line
[8+2*i
:10+2*i
], 16)
62 return record_type
, address
, data
64 class DeleteServer(unittest
.TestCase
):
68 class SimpleRegisterTest(DeleteServer
):
70 self
.server
= target
.server()
72 # For now gdb has to be told what the architecture is when it's not
74 self
.gdb
.command("set arch riscv:rv%d" % target
.xlen
)
76 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
79 self
.gdb
.command("p *((int*) 0x%x)=0x13" % target
.ram
)
80 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (target
.ram
+ 4))
81 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (target
.ram
+ 8))
82 self
.gdb
.p("$pc=0x%x" % target
.ram
)
84 def check_reg(self
, name
):
85 a
= random
.randrange(1<<target
.xlen
)
86 b
= random
.randrange(1<<target
.xlen
)
87 self
.gdb
.p("$%s=0x%x" % (name
, a
))
89 self
.assertEqual(self
.gdb
.p("$%s" % name
), a
)
90 self
.gdb
.p("$%s=0x%x" % (name
, b
))
92 self
.assertEqual(self
.gdb
.p("$%s" % name
), b
)
95 # S0 is saved/restored in DSCRATCH
99 # S1 is saved/restored in Debug RAM
103 # T0 is not saved/restored at all
107 # T2 is not saved/restored at all
110 class SimpleMemoryTest(DeleteServer
):
112 self
.server
= target
.server()
114 self
.gdb
.command("set arch riscv:rv%d" % target
.xlen
)
115 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
117 def access_test(self
, size
, data_type
):
118 self
.assertEqual(self
.gdb
.p("sizeof(%s)" % data_type
),
120 a
= 0x86753095555aaaa & ((1<<(size
*8))-1)
121 b
= 0xdeadbeef12345678 & ((1<<(size
*8))-1)
122 self
.gdb
.p("*((%s*)0x%x) = 0x%x" % (data_type
, target
.ram
, a
))
123 self
.gdb
.p("*((%s*)0x%x) = 0x%x" % (data_type
, target
.ram
+ size
, b
))
124 self
.assertEqual(self
.gdb
.p("*((%s*)0x%x)" % (data_type
, target
.ram
)), a
)
125 self
.assertEqual(self
.gdb
.p("*((%s*)0x%x)" % (data_type
, target
.ram
+ size
)), b
)
128 self
.access_test(1, 'char')
131 self
.access_test(2, 'short')
134 self
.access_test(4, 'int')
137 self
.access_test(8, 'long long')
139 def test_block(self
):
142 a
= tempfile
.NamedTemporaryFile(suffix
=".ihex")
144 for i
in range(length
/ line_length
):
145 line_data
= "".join(["%c" % random
.randrange(256) for _
in range(line_length
)])
147 a
.write(ihex_line(i
* line_length
, 0, line_data
))
150 self
.gdb
.command("restore %s 0x%x" % (a
.name
, target
.ram
))
151 for offset
in range(0, length
, 19*4) + [length
-4]:
152 value
= self
.gdb
.p("*((int*)0x%x)" % (target
.ram
+ offset
))
153 written
= ord(data
[offset
]) | \
154 (ord(data
[offset
+1]) << 8) | \
155 (ord(data
[offset
+2]) << 16) | \
156 (ord(data
[offset
+3]) << 24)
157 self
.assertEqual(value
, written
)
159 b
= tempfile
.NamedTemporaryFile(suffix
=".ihex")
160 self
.gdb
.command("dump ihex memory %s 0x%x 0x%x" % (b
.name
, target
.ram
,
161 target
.ram
+ length
))
163 record_type
, address
, line_data
= ihex_parse(line
)
164 if (record_type
== 0):
165 self
.assertEqual(line_data
, data
[address
:address
+len(line_data
)])
167 class InstantHaltTest(DeleteServer
):
169 self
.server
= target
.server()
171 self
.gdb
.command("set arch riscv:rv%d" % target
.xlen
)
172 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
174 def test_instant_halt(self
):
175 self
.assertEqual(target
.reset_vector
, self
.gdb
.p("$pc"))
176 # mcycle and minstret have no defined reset value.
177 mstatus
= self
.gdb
.p("$mstatus")
178 self
.assertEqual(mstatus
& (MSTATUS_MIE | MSTATUS_MPRV |
181 def test_change_pc(self
):
182 """Change the PC right as we come out of reset."""
184 self
.gdb
.command("p *((int*) 0x%x)=0x13" % target
.ram
)
185 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (target
.ram
+ 4))
186 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (target
.ram
+ 8))
187 self
.gdb
.p("$pc=0x%x" % target
.ram
)
189 self
.assertEqual((target
.ram
+ 4), self
.gdb
.p("$pc"))
191 self
.assertEqual((target
.ram
+ 8), self
.gdb
.p("$pc"))
193 class DebugTest(DeleteServer
):
195 # Include malloc so that gdb can make function calls. I suspect this
196 # malloc will silently blow through the memory set aside for it, so be
198 self
.binary
= target
.compile("programs/debug.c", "programs/checksum.c",
199 "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
200 self
.server
= target
.server()
202 self
.gdb
.command("file %s" % self
.binary
)
203 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
207 def exit(self
, expected_result
= 0xc86455d4):
208 output
= self
.gdb
.c()
209 self
.assertIn("Breakpoint", output
)
210 self
.assertIn("_exit", output
)
211 self
.assertEqual(self
.gdb
.p("status"), expected_result
)
213 def test_function_call(self
):
214 self
.gdb
.b("main:start")
216 text
= "Howdy, Earth!"
217 gdb_length
= self
.gdb
.p('strlen("%s")' % text
)
218 self
.assertEqual(gdb_length
, len(text
))
221 def test_change_string(self
):
222 text
= "This little piggy went to the market."
223 self
.gdb
.b("main:start")
225 self
.gdb
.p('fox = "%s"' % text
)
226 self
.exit(0x43b497b8)
228 def test_turbostep(self
):
229 """Single step a bunch of times."""
230 self
.gdb
.command("p i=0");
236 pc
= self
.gdb
.p("$pc")
237 self
.assertNotEqual(last_pc
, pc
)
238 if (last_pc
and pc
> last_pc
and pc
- last_pc
<= 4):
243 # Some basic sanity that we're not running between breakpoints or
245 self
.assertGreater(jumps
, 10)
246 self
.assertGreater(advances
, 50)
251 def test_symbols(self
):
254 output
= self
.gdb
.c()
255 self
.assertIn(", main ", output
)
256 output
= self
.gdb
.c()
257 self
.assertIn(", rot13 ", output
)
259 def test_breakpoint(self
):
261 # The breakpoint should be hit exactly 2 times.
263 output
= self
.gdb
.c()
265 self
.assertIn("Breakpoint ", output
)
266 #TODO self.assertIn("rot13 ", output)
269 def test_hwbp_1(self
):
270 if target
.instruction_hardware_breakpoint_count
< 1:
273 self
.gdb
.hbreak("rot13")
274 # The breakpoint should be hit exactly 2 times.
276 output
= self
.gdb
.c()
278 self
.assertIn("Breakpoint ", output
)
279 #TODO self.assertIn("rot13 ", output)
282 def test_hwbp_2(self
):
283 if target
.instruction_hardware_breakpoint_count
< 2:
286 self
.gdb
.hbreak("main")
287 self
.gdb
.hbreak("rot13")
288 # We should hit 3 breakpoints.
290 output
= self
.gdb
.c()
292 self
.assertIn("Breakpoint ", output
)
293 #TODO self.assertIn("rot13 ", output)
296 def test_too_many_hwbp(self
):
298 self
.gdb
.hbreak("*rot13 + %d" % (i
* 4))
300 output
= self
.gdb
.c()
301 self
.assertIn("Cannot insert hardware breakpoint", output
)
302 # Clean up, otherwise the hardware breakpoints stay set and future
304 self
.gdb
.command("D")
306 def test_registers(self
):
307 # Get to a point in the code where some registers have actually been
312 # Try both forms to test gdb.
313 for cmd
in ("info all-registers", "info registers all"):
314 output
= self
.gdb
.command(cmd
)
315 self
.assertNotIn("Could not", output
)
316 for reg
in ('zero', 'ra', 'sp', 'gp', 'tp'):
317 self
.assertIn(reg
, output
)
320 # mcpuid is one of the few registers that should have the high bit set
322 # Leave this commented out until gdb and spike agree on the encoding of
323 # mcpuid (which is going to be renamed to misa in any case).
324 #self.assertRegexpMatches(output, ".*mcpuid *0x80")
327 # The instret register should always be changing.
330 # instret = self.gdb.p("$instret")
331 # self.assertNotEqual(instret, last_instret)
332 # last_instret = instret
337 def test_interrupt(self
):
338 """Sending gdb ^C while the program is running should cause it to halt."""
339 self
.gdb
.b("main:start")
342 self
.gdb
.c(wait
=False)
344 output
= self
.gdb
.interrupt()
345 #TODO: assert "main" in output
346 self
.assertGreater(self
.gdb
.p("j"), 10)
350 class StepTest(DeleteServer
):
352 self
.binary
= target
.compile("programs/step.S")
353 self
.server
= target
.server()
355 self
.gdb
.command("file %s" % self
.binary
)
356 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
362 main
= self
.gdb
.p("$pc")
363 for expected
in (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c):
365 pc
= self
.gdb
.p("$pc")
366 self
.assertEqual("%x" % pc
, "%x" % (expected
+ main
))
368 class RegsTest(DeleteServer
):
370 self
.binary
= target
.compile("programs/regs.S")
371 self
.server
= target
.server()
373 self
.gdb
.command("file %s" % self
.binary
)
374 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
377 self
.gdb
.b("handle_trap")
380 def test_write_gprs(self
):
381 regs
= [("x%d" % n
) for n
in range(2, 32)]
383 self
.gdb
.p("$pc=write_regs")
384 for i
, r
in enumerate(regs
):
385 self
.gdb
.command("p $%s=%d" % (r
, (0xdeadbeef<<i
)+17))
386 self
.gdb
.command("p $x1=data")
387 self
.gdb
.command("b all_done")
388 output
= self
.gdb
.c()
389 self
.assertIn("Breakpoint ", output
)
391 # Just to get this data in the log.
392 self
.gdb
.command("x/30gx data")
393 self
.gdb
.command("info registers")
394 for n
in range(len(regs
)):
395 self
.assertEqual(self
.gdb
.x("data+%d" % (8*n
), 'g'),
396 ((0xdeadbeef<<n
)+17) & ((1<<target
.xlen
)-1))
398 def test_write_csrs(self
):
399 # As much a test of gdb as of the simulator.
400 self
.gdb
.p("$mscratch=0")
402 self
.assertEqual(self
.gdb
.p("$mscratch"), 0)
403 self
.gdb
.p("$mscratch=123")
405 self
.assertEqual(self
.gdb
.p("$mscratch"), 123)
407 self
.gdb
.command("p $pc=write_regs")
408 self
.gdb
.command("p $a0=data")
409 self
.gdb
.command("b all_done")
410 self
.gdb
.command("c")
412 self
.assertEqual(123, self
.gdb
.p("$mscratch"))
413 self
.assertEqual(123, self
.gdb
.p("$x1"))
414 self
.assertEqual(123, self
.gdb
.p("$csr832"))
416 class DownloadTest(DeleteServer
):
418 length
= min(2**20, target
.ram_size
- 2048)
419 download_c
= tempfile
.NamedTemporaryFile(prefix
="download_", suffix
=".c")
420 download_c
.write("#include <stdint.h>\n")
421 download_c
.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n")
422 download_c
.write("uint32_t length = %d;\n" % length
)
423 download_c
.write("uint8_t d[%d] = {\n" % length
)
425 for i
in range(length
/ 16):
426 download_c
.write(" /* 0x%04x */ " % (i
* 16));
428 value
= random
.randrange(1<<8)
429 download_c
.write("%d, " % value
)
430 self
.crc
= binascii
.crc32("%c" % value
, self
.crc
)
431 download_c
.write("\n");
432 download_c
.write("};\n");
433 download_c
.write("uint8_t *data = &d[0];\n");
434 download_c
.write("uint32_t main() { return crc32a(data, length); }\n")
440 self
.binary
= target
.compile(download_c
.name
, "programs/checksum.c")
441 self
.server
= target
.server()
443 self
.gdb
.command("file %s" % self
.binary
)
444 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
446 def test_download(self
):
447 output
= self
.gdb
.load()
448 self
.gdb
.command("b _exit")
450 self
.assertEqual(self
.gdb
.p("status"), self
.crc
)
452 class MprvTest(DeleteServer
):
454 self
.binary
= target
.compile("programs/mprv.S")
455 self
.server
= target
.server()
457 self
.gdb
.command("file %s" % self
.binary
)
458 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
462 """Test that the debugger can access memory when MPRV is set."""
463 self
.gdb
.c(wait
=False)
466 output
= self
.gdb
.command("p/x *(int*)(((char*)&data)-0x80000000)")
467 self
.assertIn("0xbead", output
)
469 class PrivTest(DeleteServer
):
471 self
.binary
= target
.compile("programs/priv.S")
472 self
.server
= target
.server()
474 self
.gdb
.command("file %s" % self
.binary
)
475 self
.gdb
.command("target extended-remote localhost:%d" % self
.server
.port
)
478 misa
= self
.gdb
.p("$misa")
479 self
.supported
= set()
481 self
.supported
.add(0)
483 self
.supported
.add(1)
485 self
.supported
.add(2)
486 self
.supported
.add(3)
489 """Test reading/writing priv."""
490 for privilege
in range(4):
491 self
.gdb
.p("$priv=%d" % privilege
)
493 actual
= self
.gdb
.p("$priv")
494 self
.assertIn(actual
, self
.supported
)
495 if privilege
in self
.supported
:
496 self
.assertEqual(actual
, privilege
)
498 def test_change(self
):
499 """Test that the core's privilege level actually changes."""
501 if 0 not in self
.supported
:
502 # TODO: return not applicable
509 self
.gdb
.p("$priv=3")
510 main
= self
.gdb
.p("$pc")
512 self
.assertEqual("%x" % self
.gdb
.p("$pc"), "%x" % (main
+4))
515 self
.gdb
.p("$priv=0")
517 # Should have taken an exception, so be nowhere near main.
518 pc
= self
.gdb
.p("$pc")
519 self
.assertTrue(pc
< main
or pc
> main
+ 0x100)
521 class Target(object):
525 raise NotImplementedError
527 def compile(self
, *sources
):
528 binary_name
= "%s_%s" % (
530 os
.path
.basename(os
.path
.splitext(sources
[0])[0]))
532 self
.temporary_binary
= tempfile
.NamedTemporaryFile(
533 prefix
=binary_name
+ "_")
534 binary_name
= self
.temporary_binary
.name
535 testlib
.compile(sources
+
536 ("programs/entry.S", "programs/init.c",
538 "-T", "targets/%s/link.lds" % (self
.directory
or self
.name
),
545 class SpikeTarget(Target
):
548 ram_size
= 5 * 1024 * 1024
549 instruction_hardware_breakpoint_count
= 0
550 reset_vector
= 0x1000
552 class Spike64Target(SpikeTarget
):
557 return testlib
.Spike(parsed
.cmd
, halted
=True)
559 class Spike32Target(SpikeTarget
):
564 return testlib
.Spike(parsed
.cmd
, halted
=True, xlen
=32)
566 class FreedomE300Target(Target
):
567 name
= "freedom-e300"
571 instruction_hardware_breakpoint_count
= 2
574 return testlib
.Openocd(cmd
=parsed
.cmd
,
575 config
="targets/%s/openocd.cfg" % self
.name
)
584 parser
= argparse
.ArgumentParser(
586 Example command line from the real world:
587 Run all RegsTest cases against a MicroSemi m2gl_m2s board, with custom openocd command:
588 ./gdbserver.py --m2gl_m2s --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest
590 group
= parser
.add_mutually_exclusive_group(required
=True)
592 group
.add_argument("--%s" % t
.name
, action
="store_const", const
=t
,
594 parser
.add_argument("--cmd",
595 help="The command to use to start the debug server.")
596 parser
.add_argument("--gdb",
597 help="The command to use to start gdb.")
598 parser
.add_argument("--isolate", action
="store_true",
599 help="Try to run in such a way that multiple instances can run at "
600 "the same time. This may make it harder to debug a failure if it "
602 parser
.add_argument("unittest", nargs
="*")
604 parsed
= parser
.parse_args()
607 target
= parsed
.target()
608 unittest
.main(argv
=[sys
.argv
[0]] + parsed
.unittest
)
610 # TROUBLESHOOTING TIPS
611 # If a particular test fails, run just that one test, eg.:
612 # ./tests/gdbserver.py MprvTest.test_mprv
613 # Then inspect gdb.log and spike.log to see what happened in more detail.
615 if __name__
== '__main__':