d1a4e751238df26827a312d58e76a7e7b612ace4
[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 def ihex_line(address, record_type, data):
14 assert len(data) < 128
15 line = ":%02X%04X%02X" % (len(data), address, record_type)
16 check = len(data)
17 check += address % 256
18 check += address >> 8
19 check += record_type
20 for char in data:
21 value = ord(char)
22 check += value
23 line += "%02X" % value
24 line += "%02X\n" % ((256-check)%256)
25 return line
26
27 def ihex_parse(line):
28 assert line.startswith(":")
29 line = line[1:]
30 data_len = int(line[:2], 16)
31 address = int(line[2:6], 16)
32 record_type = int(line[6:8], 16)
33 data = ""
34 for i in range(data_len):
35 data += "%c" % int(line[8+2*i:10+2*i], 16)
36 return record_type, address, data
37
38 class DeleteServer(unittest.TestCase):
39 def tearDown(self):
40 del self.server
41
42 class SimpleRegisterTest(DeleteServer):
43 def setUp(self):
44 self.server = target.server()
45 self.gdb = testlib.Gdb()
46 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
47
48 # 0x13 is nop
49 self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
50 self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
51 self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
52 self.gdb.p("$pc=0x%x" % target.ram)
53
54 def check_reg(self, name):
55 a = random.randrange(1<<target.xlen)
56 b = random.randrange(1<<target.xlen)
57 self.gdb.p("$%s=0x%x" % (name, a))
58 self.gdb.stepi()
59 self.assertEqual(self.gdb.p("$%s" % name), a)
60 self.gdb.p("$%s=0x%x" % (name, b))
61 self.gdb.stepi()
62 self.assertEqual(self.gdb.p("$%s" % name), b)
63
64 def test_s0(self):
65 # S0 is saved/restored in DSCRATCH
66 self.check_reg("s0")
67
68 def test_s1(self):
69 # S1 is saved/restored in Debug RAM
70 self.check_reg("s1")
71
72 def test_t0(self):
73 # T0 is not saved/restored at all
74 self.check_reg("t2")
75
76 def test_t2(self):
77 # T2 is not saved/restored at all
78 self.check_reg("t2")
79
80 class SimpleMemoryTest(DeleteServer):
81 def setUp(self):
82 self.server = target.server()
83 self.gdb = testlib.Gdb()
84 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
85
86 def access_test(self, size, data_type):
87 a = 0x86753095555aaaa & ((1<<(size*8))-1)
88 b = 0xdeadbeef12345678 & ((1<<(size*8))-1)
89 self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram, a))
90 self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, target.ram + size, b))
91 self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram)), a)
92 self.assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, target.ram + size)), b)
93
94 def test_8(self):
95 self.access_test(1, 'char')
96
97 def test_16(self):
98 self.access_test(2, 'short')
99
100 def test_32(self):
101 self.access_test(4, 'long')
102
103 def test_64(self):
104 self.access_test(8, 'long long')
105
106 def test_block(self):
107 length = 1024
108 line_length = 16
109 fd = file("write.ihex", "w")
110 data = ""
111 for i in range(length / line_length):
112 line_data = "".join(["%c" % random.randrange(256) for _ in range(line_length)])
113 data += line_data
114 fd.write(ihex_line(i * line_length, 0, line_data))
115 fd.close()
116
117 self.gdb.command("restore write.ihex 0x%x" % target.ram)
118 for offset in range(0, length, 19*4) + [length-4]:
119 value = self.gdb.p("*((long*)0x%x)" % (target.ram + offset))
120 written = ord(data[offset]) | \
121 (ord(data[offset+1]) << 8) | \
122 (ord(data[offset+2]) << 16) | \
123 (ord(data[offset+3]) << 24)
124 self.assertEqual(value, written)
125
126 self.gdb.command("dump ihex memory read.ihex 0x%x 0x%x" % (target.ram,
127 target.ram + length))
128 for line in file("read.ihex"):
129 record_type, address, line_data = ihex_parse(line)
130 if (record_type == 0):
131 self.assertEqual(line_data, data[address:address+len(line_data)])
132
133 class InstantHaltTest(DeleteServer):
134 def setUp(self):
135 self.server = target.server()
136 self.gdb = testlib.Gdb()
137 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
138
139 def test_instant_halt(self):
140 self.assertEqual(0x1000, self.gdb.p("$pc"))
141 # For some reason instret resets to 0.
142 self.assertLess(self.gdb.p("$instret"), 8)
143 self.gdb.stepi()
144 self.assertNotEqual(0x1000, self.gdb.p("$pc"))
145
146 def test_change_pc(self):
147 """Change the PC right as we come out of reset."""
148 # 0x13 is nop
149 self.gdb.command("p *((int*) 0x%x)=0x13" % target.ram)
150 self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 4))
151 self.gdb.command("p *((int*) 0x%x)=0x13" % (target.ram + 8))
152 self.gdb.p("$pc=0x%x" % target.ram)
153 self.gdb.stepi()
154 self.assertEqual((target.ram + 4), self.gdb.p("$pc"))
155 self.gdb.stepi()
156 self.assertEqual((target.ram + 4), self.gdb.p("$pc"))
157
158 class DebugTest(DeleteServer):
159 def setUp(self):
160 self.binary = target.compile("programs/debug.c", "programs/checksum.c")
161 self.server = target.server()
162 self.gdb = testlib.Gdb()
163 self.gdb.command("file %s" % self.binary)
164 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
165 self.gdb.load()
166 self.gdb.b("_exit")
167
168 def exit(self):
169 output = self.gdb.c()
170 self.assertIn("Breakpoint", output)
171 #TODO self.assertIn("_exit", output)
172 #TODO self.assertEqual(self.gdb.p("status"), 0xc86455d4)
173 # Use a0 until gdb can resolve "status"
174 self.assertEqual(self.gdb.p("$a0") & 0xffffffff, 0xc86455d4)
175
176 def test_turbostep(self):
177 """Single step a bunch of times."""
178 self.gdb.command("p i=0");
179 last_pc = None
180 for _ in range(100):
181 self.gdb.stepi()
182 pc = self.gdb.command("p $pc")
183 self.assertNotEqual(last_pc, pc)
184 last_pc = pc
185
186 def test_exit(self):
187 self.exit()
188
189 def test_breakpoint(self):
190 self.gdb.b("rot13")
191 # The breakpoint should be hit exactly 2 times.
192 for i in range(2):
193 output = self.gdb.c()
194 self.gdb.p("$pc")
195 self.assertIn("Breakpoint ", output)
196 #TODO self.assertIn("rot13 ", output)
197 self.exit()
198
199 def test_registers(self):
200 # Get to a point in the code where some registers have actually been
201 # used.
202 self.gdb.b("rot13")
203 self.gdb.c()
204 self.gdb.c()
205 # Try both forms to test gdb.
206 for cmd in ("info all-registers", "info registers all"):
207 output = self.gdb.command(cmd)
208 self.assertNotIn("Could not", output)
209 for reg in ('zero', 'ra', 'sp', 'gp', 'tp'):
210 self.assertIn(reg, output)
211
212 #TODO
213 # mcpuid is one of the few registers that should have the high bit set
214 # (for rv64).
215 # Leave this commented out until gdb and spike agree on the encoding of
216 # mcpuid (which is going to be renamed to misa in any case).
217 #self.assertRegexpMatches(output, ".*mcpuid *0x80")
218
219 #TODO:
220 # The instret register should always be changing.
221 #last_instret = None
222 #for _ in range(5):
223 # instret = self.gdb.p("$instret")
224 # self.assertNotEqual(instret, last_instret)
225 # last_instret = instret
226 # self.gdb.stepi()
227
228 self.exit()
229
230 def test_interrupt(self):
231 """Sending gdb ^C while the program is running should cause it to halt."""
232 self.gdb.b("main:start")
233 self.gdb.c()
234 self.gdb.p("i=123");
235 self.gdb.c(wait=False)
236 time.sleep(0.1)
237 output = self.gdb.interrupt()
238 #TODO: assert "main" in output
239 self.assertGreater(self.gdb.p("j"), 10)
240 self.gdb.p("i=0");
241 self.exit()
242
243 class RegsTest(DeleteServer):
244 def setUp(self):
245 self.binary = target.compile("programs/regs.S")
246 self.server = target.server()
247 self.gdb = testlib.Gdb()
248 self.gdb.command("file %s" % self.binary)
249 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
250 self.gdb.load()
251 self.gdb.b("main")
252 self.gdb.b("handle_trap")
253 self.gdb.c()
254
255 def test_write_gprs(self):
256 regs = [("x%d" % n) for n in range(2, 32)]
257
258 self.gdb.p("$pc=write_regs")
259 for i, r in enumerate(regs):
260 self.gdb.command("p $%s=%d" % (r, (0xdeadbeef<<i)+17))
261 self.gdb.command("p $x1=data")
262 self.gdb.command("b all_done")
263 output = self.gdb.c()
264 self.assertIn("Breakpoint ", output)
265
266 # Just to get this data in the log.
267 self.gdb.command("x/30gx data")
268 self.gdb.command("info registers")
269 for n in range(len(regs)):
270 self.assertEqual(self.gdb.x("data+%d" % (8*n), 'g'),
271 ((0xdeadbeef<<n)+17) & ((1<<target.xlen)-1))
272
273 def test_write_csrs(self):
274 # As much a test of gdb as of the simulator.
275 self.gdb.p("$mscratch=0")
276 self.gdb.stepi()
277 self.assertEqual(self.gdb.p("$mscratch"), 0)
278 self.gdb.p("$mscratch=123")
279 self.gdb.stepi()
280 self.assertEqual(self.gdb.p("$mscratch"), 123)
281
282 self.gdb.command("p $pc=write_regs")
283 self.gdb.command("p $a0=data")
284 self.gdb.command("b all_done")
285 self.gdb.command("c")
286
287 self.assertEqual(123, self.gdb.p("$mscratch"))
288 self.assertEqual(123, self.gdb.p("$x1"))
289 self.assertEqual(123, self.gdb.p("$csr832"))
290
291 class DownloadTest(DeleteServer):
292 def setUp(self):
293 length = 2**20
294 fd = file("download.c", "w")
295 fd.write("#include <stdint.h>\n")
296 fd.write("unsigned int crc32a(uint8_t *message, unsigned int size);\n")
297 fd.write("uint32_t length = %d;\n" % length)
298 fd.write("uint8_t d[%d] = {\n" % length)
299 self.crc = 0
300 for i in range(length / 16):
301 fd.write(" /* 0x%04x */ " % (i * 16));
302 for _ in range(16):
303 value = random.randrange(1<<8)
304 fd.write("%d, " % value)
305 self.crc = binascii.crc32("%c" % value, self.crc)
306 fd.write("\n");
307 fd.write("};\n");
308 fd.write("uint8_t *data = &d[0];\n");
309 fd.write("uint32_t main() { return crc32a(data, length); }\n")
310 fd.close()
311
312 if self.crc < 0:
313 self.crc += 2**32
314
315 self.binary = target.compile("download.c", "programs/checksum.c")
316 self.server = target.server()
317 self.gdb = testlib.Gdb()
318 self.gdb.command("file %s" % self.binary)
319 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
320
321 def test_download(self):
322 output = self.gdb.load()
323 self.gdb.command("b _exit")
324 self.gdb.c()
325 self.assertEqual(self.gdb.p("status"), self.crc)
326
327 class MprvTest(DeleteServer):
328 def setUp(self):
329 self.binary = target.compile("programs/mprv.S")
330 self.server = target.server()
331 self.gdb = testlib.Gdb()
332 self.gdb.command("file %s" % self.binary)
333 self.gdb.command("target extended-remote localhost:%d" % self.server.port)
334 self.gdb.load()
335
336 def test_mprv(self):
337 """Test that the debugger can access memory when MPRV is set."""
338 self.gdb.c(wait=False)
339 self.gdb.interrupt()
340 output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
341 self.assertIn("0xbead", output)
342
343 class Target(object):
344 directory = None
345
346 def server(self):
347 raise NotImplementedError
348
349 def compile(self, *sources):
350 return testlib.compile(sources +
351 ("programs/entry.S", "programs/init.c",
352 "-I", "../env",
353 "-T", "targets/%s/link.lds" % (self.directory or self.name),
354 "-nostartfiles",
355 "-mcmodel=medany"), xlen=self.xlen)
356
357 class Spike64Target(Target):
358 name = "spike"
359 xlen = 64
360 ram = 0x80010000
361
362 def server(self):
363 return testlib.Spike(parsed.cmd, halted=True)
364
365 class Spike32Target(Target):
366 name = "spike32"
367 directory = "spike"
368 xlen = 32
369 ram = 0x80010000
370
371 def server(self):
372 return testlib.Spike(parsed.cmd, halted=True, xlen=32)
373
374 class MicroSemiTarget(Target):
375 name = "m2gl_m2s"
376 xlen = 32
377 ram = 0x80000000
378
379 def server(self):
380 return testlib.Openocd(cmd=parsed.cmd,
381 config="targets/%s/openocd.cfg" % self.name)
382
383 targets = [
384 Spike32Target,
385 Spike64Target,
386 MicroSemiTarget
387 ]
388
389 def main():
390 parser = argparse.ArgumentParser(
391 epilog="""
392 Example command line from the real world:
393 Run all RegsTest cases against a MicroSemi m2gl_m2s board, with custom openocd command:
394 ./gdbserver.py --m2gl_m2s --cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" -- -vf RegsTest
395 """)
396 group = parser.add_mutually_exclusive_group(required=True)
397 for t in targets:
398 group.add_argument("--%s" % t.name, action="store_const", const=t,
399 dest="target")
400 parser.add_argument("--cmd",
401 help="The command to use to start the debug server.")
402 parser.add_argument("unittest", nargs="*")
403 global parsed
404 parsed = parser.parse_args()
405
406 global target
407 target = parsed.target()
408 unittest.main(argv=[sys.argv[0]] + parsed.unittest)
409
410 # TROUBLESHOOTING TIPS
411 # If a particular test fails, run just that one test, eg.:
412 # ./tests/gdbserver.py MprvTest.test_mprv
413 # Then inspect gdb.log and spike.log to see what happened in more detail.
414
415 if __name__ == '__main__':
416 sys.exit(main())