13 from testlib
import assertEqual
, assertNotEqual
, assertIn
, assertNotIn
14 from testlib
import assertGreater
, assertRegexpMatches
, assertLess
15 from testlib
import GdbTest
17 MSTATUS_UIE
= 0x00000001
18 MSTATUS_SIE
= 0x00000002
19 MSTATUS_HIE
= 0x00000004
20 MSTATUS_MIE
= 0x00000008
21 MSTATUS_UPIE
= 0x00000010
22 MSTATUS_SPIE
= 0x00000020
23 MSTATUS_HPIE
= 0x00000040
24 MSTATUS_MPIE
= 0x00000080
25 MSTATUS_SPP
= 0x00000100
26 MSTATUS_HPP
= 0x00000600
27 MSTATUS_MPP
= 0x00001800
28 MSTATUS_FS
= 0x00006000
29 MSTATUS_XS
= 0x00018000
30 MSTATUS_MPRV
= 0x00020000
31 MSTATUS_PUM
= 0x00040000
32 MSTATUS_MXR
= 0x00080000
33 MSTATUS_VM
= 0x1F000000
34 MSTATUS32_SD
= 0x80000000
35 MSTATUS64_SD
= 0x8000000000000000
37 # pylint: disable=abstract-method
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 def readable_binary_string(s
):
65 return "".join("%02x" % ord(c
) for c
in s
)
67 class SimpleRegisterTest(GdbTest
):
68 def check_reg(self
, name
):
69 a
= random
.randrange(1<<self
.target
.xlen
)
70 b
= random
.randrange(1<<self
.target
.xlen
)
71 self
.gdb
.p("$%s=0x%x" % (name
, a
))
73 assertEqual(self
.gdb
.p("$%s" % name
), a
)
74 self
.gdb
.p("$%s=0x%x" % (name
, b
))
76 assertEqual(self
.gdb
.p("$%s" % name
), b
)
80 self
.gdb
.command("p *((int*) 0x%x)=0x13" % self
.target
.ram
)
81 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 4))
82 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 8))
83 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 12))
84 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 16))
85 self
.gdb
.p("$pc=0x%x" % self
.target
.ram
)
87 class SimpleS0Test(SimpleRegisterTest
):
91 class SimpleS1Test(SimpleRegisterTest
):
95 class SimpleT0Test(SimpleRegisterTest
):
99 class SimpleT1Test(SimpleRegisterTest
):
103 class SimpleF18Test(SimpleRegisterTest
):
104 def check_reg(self
, name
):
105 self
.gdb
.p_raw("$mstatus=$mstatus | 0x00006000")
109 self
.gdb
.p_raw("$%s=%f" % (name
, a
))
111 assertLess(abs(float(self
.gdb
.p_raw("$%s" % name
)) - a
), .001)
112 self
.gdb
.p_raw("$%s=%f" % (name
, b
))
114 assertLess(abs(float(self
.gdb
.p_raw("$%s" % name
)) - b
), .001)
116 def early_applicable(self
):
117 return self
.target
.extensionSupported('F')
120 self
.check_reg("f18")
122 class SimpleMemoryTest(GdbTest
):
123 def access_test(self
, size
, data_type
):
124 assertEqual(self
.gdb
.p("sizeof(%s)" % data_type
), size
)
125 a
= 0x86753095555aaaa & ((1<<(size
*8))-1)
126 b
= 0xdeadbeef12345678 & ((1<<(size
*8))-1)
127 addrA
= self
.target
.ram
128 addrB
= self
.target
.ram
+ self
.target
.ram_size
- size
129 self
.gdb
.p("*((%s*)0x%x) = 0x%x" % (data_type
, addrA
, a
))
130 self
.gdb
.p("*((%s*)0x%x) = 0x%x" % (data_type
, addrB
, b
))
131 assertEqual(self
.gdb
.p("*((%s*)0x%x)" % (data_type
, addrA
)), a
)
132 assertEqual(self
.gdb
.p("*((%s*)0x%x)" % (data_type
, addrB
)), b
)
134 class MemTest8(SimpleMemoryTest
):
136 self
.access_test(1, 'char')
138 class MemTest16(SimpleMemoryTest
):
140 self
.access_test(2, 'short')
142 class MemTest32(SimpleMemoryTest
):
144 self
.access_test(4, 'int')
146 class MemTest64(SimpleMemoryTest
):
148 self
.access_test(8, 'long long')
150 # FIXME: I'm not passing back invalid addresses correctly in read/write memory.
151 #class MemTestReadInvalid(SimpleMemoryTest):
153 # # This test relies on 'gdb_report_data_abort enable' being executed in
154 # # the openocd.cfg file.
156 # self.gdb.p("*((int*)0xdeadbeef)")
157 # assert False, "Read should have failed."
158 # except testlib.CannotAccess as e:
159 # assertEqual(e.address, 0xdeadbeef)
160 # self.gdb.p("*((int*)0x%x)" % self.target.ram)
162 #class MemTestWriteInvalid(SimpleMemoryTest):
164 # # This test relies on 'gdb_report_data_abort enable' being executed in
165 # # the openocd.cfg file.
167 # self.gdb.p("*((int*)0xdeadbeef)=8675309")
168 # assert False, "Write should have failed."
169 # except testlib.CannotAccess as e:
170 # assertEqual(e.address, 0xdeadbeef)
171 # self.gdb.p("*((int*)0x%x)=6874742" % self.target.ram)
173 class MemTestBlock(GdbTest
):
177 a
= tempfile
.NamedTemporaryFile(suffix
=".ihex")
179 for i
in range(length
/ line_length
):
180 line_data
= "".join(["%c" % random
.randrange(256)
181 for _
in range(line_length
)])
183 a
.write(ihex_line(i
* line_length
, 0, line_data
))
186 self
.gdb
.command("restore %s 0x%x" % (a
.name
, self
.target
.ram
))
187 for offset
in range(0, length
, 19*4) + [length
-4]:
188 value
= self
.gdb
.p("*((int*)0x%x)" % (self
.target
.ram
+ offset
))
189 written
= ord(data
[offset
]) | \
190 (ord(data
[offset
+1]) << 8) | \
191 (ord(data
[offset
+2]) << 16) | \
192 (ord(data
[offset
+3]) << 24)
193 assertEqual(value
, written
)
195 b
= tempfile
.NamedTemporaryFile(suffix
=".ihex")
196 self
.gdb
.command("dump ihex memory %s 0x%x 0x%x" % (b
.name
,
197 self
.target
.ram
, self
.target
.ram
+ length
))
199 record_type
, address
, line_data
= ihex_parse(line
)
201 assertEqual(readable_binary_string(line_data
),
202 readable_binary_string(
203 data
[address
:address
+len(line_data
)]))
205 class InstantHaltTest(GdbTest
):
207 """Assert that reset is really resetting what it should."""
208 self
.gdb
.command("monitor reset halt")
209 self
.gdb
.command("flushregs")
210 threads
= self
.gdb
.threads()
214 pcs
.append(self
.gdb
.p("$pc"))
216 assertEqual(self
.target
.reset_vector
, pc
)
217 # mcycle and minstret have no defined reset value.
218 mstatus
= self
.gdb
.p("$mstatus")
219 assertEqual(mstatus
& (MSTATUS_MIE | MSTATUS_MPRV |
222 class InstantChangePc(GdbTest
):
224 """Change the PC right as we come out of reset."""
226 self
.gdb
.command("monitor reset halt")
227 self
.gdb
.command("flushregs")
228 self
.gdb
.command("p *((int*) 0x%x)=0x13" % self
.target
.ram
)
229 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 4))
230 self
.gdb
.command("p *((int*) 0x%x)=0x13" % (self
.target
.ram
+ 8))
231 self
.gdb
.p("$pc=0x%x" % self
.target
.ram
)
233 assertEqual((self
.target
.ram
+ 4), self
.gdb
.p("$pc"))
235 assertEqual((self
.target
.ram
+ 8), self
.gdb
.p("$pc"))
237 class DebugTest(GdbTest
):
238 # Include malloc so that gdb can make function calls. I suspect this malloc
239 # will silently blow through the memory set aside for it, so be careful.
240 compile_args
= ("programs/debug.c", "programs/checksum.c",
241 "programs/tiny-malloc.c", "-DDEFINE_MALLOC", "-DDEFINE_FREE")
247 def exit(self
, expected_result
=0xc86455d4):
248 output
= self
.gdb
.c()
249 assertIn("Breakpoint", output
)
250 assertIn("_exit", output
)
251 assertEqual(self
.gdb
.p("status"), expected_result
)
253 class DebugCompareSections(DebugTest
):
255 output
= self
.gdb
.command("compare-sections")
257 for line
in output
.splitlines():
258 if line
.startswith("Section"):
259 assert line
.endswith("matched.")
261 assertGreater(matched
, 1)
263 class DebugFunctionCall(DebugTest
):
265 self
.gdb
.b("main:start")
267 assertEqual(self
.gdb
.p('fib(6)'), 8)
268 assertEqual(self
.gdb
.p('fib(7)'), 13)
271 class DebugChangeString(DebugTest
):
273 text
= "This little piggy went to the market."
274 self
.gdb
.b("main:start")
276 self
.gdb
.p('fox = "%s"' % text
)
277 self
.exit(0x43b497b8)
279 class DebugTurbostep(DebugTest
):
281 """Single step a bunch of times."""
282 self
.gdb
.b("main:start")
284 self
.gdb
.command("p i=0")
290 pc
= self
.gdb
.p("$pc")
291 assertNotEqual(last_pc
, pc
)
292 if last_pc
and pc
> last_pc
and pc
- last_pc
<= 4:
297 # Some basic sanity that we're not running between breakpoints or
299 assertGreater(jumps
, 1)
300 assertGreater(advances
, 5)
302 class DebugExit(DebugTest
):
306 class DebugSymbols(DebugTest
):
310 output
= self
.gdb
.c()
311 assertIn(", main ", output
)
312 output
= self
.gdb
.c()
313 assertIn(", rot13 ", output
)
315 class DebugBreakpoint(DebugTest
):
318 # The breakpoint should be hit exactly 2 times.
320 output
= self
.gdb
.c()
322 assertIn("Breakpoint ", output
)
323 assertIn("rot13 ", output
)
326 class Hwbp1(DebugTest
):
328 if self
.target
.instruction_hardware_breakpoint_count
< 1:
329 return 'not_applicable'
331 if not self
.target
.honors_tdata1_hmode
:
332 # Run to main before setting the breakpoint, because startup code
333 # will otherwise clear the trigger that we set.
337 self
.gdb
.hbreak("rot13")
338 # The breakpoint should be hit exactly 2 times.
340 output
= self
.gdb
.c()
342 assertRegexpMatches(output
, r
"[bB]reakpoint")
343 assertIn("rot13 ", output
)
346 class Hwbp2(DebugTest
):
348 if self
.target
.instruction_hardware_breakpoint_count
< 2:
349 return 'not_applicable'
351 self
.gdb
.hbreak("main")
352 self
.gdb
.hbreak("rot13")
353 # We should hit 3 breakpoints.
354 for expected
in ("main", "rot13", "rot13"):
355 output
= self
.gdb
.c()
357 assertRegexpMatches(output
, r
"[bB]reakpoint")
358 assertIn("%s " % expected
, output
)
361 class TooManyHwbp(DebugTest
):
364 self
.gdb
.hbreak("*rot13 + %d" % (i
* 4))
366 output
= self
.gdb
.c()
367 assertIn("Cannot insert hardware breakpoint", output
)
368 # Clean up, otherwise the hardware breakpoints stay set and future
370 self
.gdb
.command("D")
372 class Registers(DebugTest
):
374 # Get to a point in the code where some registers have actually been
379 # Try both forms to test gdb.
380 for cmd
in ("info all-registers", "info registers all"):
381 output
= self
.gdb
.command(cmd
)
382 for reg
in ('zero', 'ra', 'sp', 'gp', 'tp'):
383 assertIn(reg
, output
)
386 # mcpuid is one of the few registers that should have the high bit set
388 # Leave this commented out until gdb and spike agree on the encoding of
389 # mcpuid (which is going to be renamed to misa in any case).
390 #assertRegexpMatches(output, ".*mcpuid *0x80")
393 # The instret register should always be changing.
396 # instret = self.gdb.p("$instret")
397 # assertNotEqual(instret, last_instret)
398 # last_instret = instret
403 class UserInterrupt(DebugTest
):
405 """Sending gdb ^C while the program is running should cause it to
407 self
.gdb
.b("main:start")
410 self
.gdb
.c(wait
=False)
412 output
= self
.gdb
.interrupt()
413 assert "main" in output
414 assertGreater(self
.gdb
.p("j"), 10)
418 class MulticoreTest(GdbTest
):
419 compile_args
= ("programs/infinite_loop.S", )
425 threads
= self
.gdb
.threads()
427 return 'not_applicable'
431 self
.gdb
.p("$pc=_start")
436 for t
in self
.gdb
.threads():
437 assertIn("main", t
.frame
)
438 self
.gdb
.command("delete breakpoints")
440 # Run through the entire loop.
441 self
.gdb
.b("main_end")
445 for t
in self
.gdb
.threads():
446 assertIn("main_end", t
.frame
)
447 # Check register values.
449 hart_id
= self
.gdb
.p("$x1")
450 assertNotIn(hart_id
, hart_ids
)
451 hart_ids
.append(hart_id
)
452 for n
in range(2, 32):
453 value
= self
.gdb
.p("$x%d" % n
)
454 assertEqual(value
, hart_ids
[-1] + n
- 1)
456 # Confirmed that we read different register values for different harts.
457 # Write a new value to x1, and run through the add sequence again.
461 self
.gdb
.p("$x1=0x%x" % (int(t
.id) * 0x800))
462 self
.gdb
.p("$pc=main_post_csrr")
464 for t
in self
.gdb
.threads():
465 assertIn("main_end", t
.frame
)
466 # Check register values.
468 for n
in range(1, 32):
469 value
= self
.gdb
.p("$x%d" % n
)
470 assertEqual(value
, int(t
.id) * 0x800 + n
- 1)
472 class StepTest(GdbTest
):
473 compile_args
= ("programs/step.S", )
481 main_address
= self
.gdb
.p("$pc")
482 if self
.target
.extensionSupported("c"):
483 sequence
= (4, 8, 0xc, 0xe, 0x14, 0x18, 0x22, 0x1c, 0x24, 0x24)
485 sequence
= (4, 8, 0xc, 0x10, 0x18, 0x1c, 0x28, 0x20, 0x2c, 0x2c)
486 for expected
in sequence
:
488 pc
= self
.gdb
.p("$pc")
489 assertEqual("%x" % (pc
- main_address
), "%x" % expected
)
491 class TriggerTest(GdbTest
):
492 compile_args
= ("programs/trigger.S", )
500 output
= self
.gdb
.c()
501 assertIn("Breakpoint", output
)
502 assertIn("_exit", output
)
504 class TriggerExecuteInstant(TriggerTest
):
505 """Test an execute breakpoint on the first instruction executed out of
508 main_address
= self
.gdb
.p("$pc")
509 self
.gdb
.command("hbreak *0x%x" % (main_address
+ 4))
511 assertEqual(self
.gdb
.p("$pc"), main_address
+4)
513 # FIXME: Triggers aren't quite working yet
514 #class TriggerLoadAddress(TriggerTest):
516 # self.gdb.command("rwatch *((&data)+1)")
517 # output = self.gdb.c()
518 # assertIn("read_loop", output)
519 # assertEqual(self.gdb.p("$a0"),
520 # self.gdb.p("(&data)+1"))
523 class TriggerLoadAddressInstant(TriggerTest
):
524 """Test a load address breakpoint on the first instruction executed out of
527 self
.gdb
.command("b just_before_read_loop")
529 read_loop
= self
.gdb
.p("&read_loop")
530 self
.gdb
.command("rwatch data")
532 # Accept hitting the breakpoint before or after the load instruction.
533 assertIn(self
.gdb
.p("$pc"), [read_loop
, read_loop
+ 4])
534 assertEqual(self
.gdb
.p("$a0"), self
.gdb
.p("&data"))
536 # FIXME: Triggers aren't quite working yet
537 #class TriggerStoreAddress(TriggerTest):
539 # self.gdb.command("watch *((&data)+3)")
540 # output = self.gdb.c()
541 # assertIn("write_loop", output)
542 # assertEqual(self.gdb.p("$a0"),
543 # self.gdb.p("(&data)+3"))
546 class TriggerStoreAddressInstant(TriggerTest
):
548 """Test a store address breakpoint on the first instruction executed out
550 self
.gdb
.command("b just_before_write_loop")
552 write_loop
= self
.gdb
.p("&write_loop")
553 self
.gdb
.command("watch data")
555 # Accept hitting the breakpoint before or after the store instruction.
556 assertIn(self
.gdb
.p("$pc"), [write_loop
, write_loop
+ 4])
557 assertEqual(self
.gdb
.p("$a0"), self
.gdb
.p("&data"))
559 class TriggerDmode(TriggerTest
):
560 def early_applicable(self
):
561 return self
.target
.honors_tdata1_hmode
563 def check_triggers(self
, tdata1_lsbs
, tdata2
):
564 dmode
= 1 << (self
.target
.xlen
-5)
568 if self
.target
.xlen
== 32:
570 elif self
.target
.xlen
== 64:
571 xlen_type
= 'long long'
573 raise NotImplementedError
578 tdata1
= self
.gdb
.p("((%s *)&data)[%d]" % (xlen_type
, 2*i
))
581 tdata2
= self
.gdb
.p("((%s *)&data)[%d]" % (xlen_type
, 2*i
+1))
586 assertEqual(tdata1
& 0xffff, tdata1_lsbs
)
587 assertEqual(tdata2
, tdata2
)
590 assertEqual(dmode_count
, 1)
595 self
.gdb
.command("hbreak write_load_trigger")
596 self
.gdb
.b("clear_triggers")
597 self
.gdb
.p("$pc=write_store_trigger")
598 output
= self
.gdb
.c()
599 assertIn("write_load_trigger", output
)
600 self
.check_triggers((1<<6) |
(1<<1), 0xdeadbee0)
601 output
= self
.gdb
.c()
602 assertIn("clear_triggers", output
)
603 self
.check_triggers((1<<6) |
(1<<0), 0xfeedac00)
605 class RegsTest(GdbTest
):
606 compile_args
= ("programs/regs.S", )
610 self
.gdb
.b("handle_trap")
613 class WriteGprs(RegsTest
):
615 regs
= [("x%d" % n
) for n
in range(2, 32)]
617 self
.gdb
.p("$pc=write_regs")
618 for i
, r
in enumerate(regs
):
619 self
.gdb
.p("$%s=%d" % (r
, (0xdeadbeef<<i
)+17))
620 self
.gdb
.p("$x1=data")
621 self
.gdb
.command("b all_done")
622 output
= self
.gdb
.c()
623 assertIn("Breakpoint ", output
)
625 # Just to get this data in the log.
626 self
.gdb
.command("x/30gx data")
627 self
.gdb
.command("info registers")
628 for n
in range(len(regs
)):
629 assertEqual(self
.gdb
.x("data+%d" % (8*n
), 'g'),
630 ((0xdeadbeef<<n
)+17) & ((1<<self
.target
.xlen
)-1))
632 class WriteCsrs(RegsTest
):
634 # As much a test of gdb as of the simulator.
635 self
.gdb
.p("$mscratch=0")
637 assertEqual(self
.gdb
.p("$mscratch"), 0)
638 self
.gdb
.p("$mscratch=123")
640 assertEqual(self
.gdb
.p("$mscratch"), 123)
642 self
.gdb
.p("$pc=write_regs")
643 self
.gdb
.p("$x1=data")
644 self
.gdb
.command("b all_done")
645 self
.gdb
.command("c")
647 assertEqual(123, self
.gdb
.p("$mscratch"))
648 assertEqual(123, self
.gdb
.p("$x1"))
649 assertEqual(123, self
.gdb
.p("$csr832"))
651 class DownloadTest(GdbTest
):
653 # pylint: disable=attribute-defined-outside-init
654 length
= min(2**10, self
.target
.ram_size
- 2048)
655 self
.download_c
= tempfile
.NamedTemporaryFile(prefix
="download_",
656 suffix
=".c", delete
=False)
657 self
.download_c
.write("#include <stdint.h>\n")
658 self
.download_c
.write(
659 "unsigned int crc32a(uint8_t *message, unsigned int size);\n")
660 self
.download_c
.write("uint32_t length = %d;\n" % length
)
661 self
.download_c
.write("uint8_t d[%d] = {\n" % length
)
663 assert length
% 16 == 0
664 for i
in range(length
/ 16):
665 self
.download_c
.write(" /* 0x%04x */ " % (i
* 16))
667 value
= random
.randrange(1<<8)
668 self
.download_c
.write("0x%02x, " % value
)
669 self
.crc
= binascii
.crc32("%c" % value
, self
.crc
)
670 self
.download_c
.write("\n")
671 self
.download_c
.write("};\n")
672 self
.download_c
.write("uint8_t *data = &d[0];\n")
673 self
.download_c
.write(
674 "uint32_t main() { return crc32a(data, length); }\n")
675 self
.download_c
.flush()
680 self
.binary
= self
.target
.compile(self
.download_c
.name
,
681 "programs/checksum.c")
682 self
.gdb
.command("file %s" % self
.binary
)
686 self
.gdb
.command("b _exit")
687 self
.gdb
.c(timeout
=60)
688 assertEqual(self
.gdb
.p("status"), self
.crc
)
689 os
.unlink(self
.download_c
.name
)
691 # FIXME: PRIV isn't implemented in the current OpenOCD
692 #class MprvTest(GdbTest):
693 # compile_args = ("programs/mprv.S", )
698 # """Test that the debugger can access memory when MPRV is set."""
699 # self.gdb.c(wait=False)
701 # self.gdb.interrupt()
702 # output = self.gdb.command("p/x *(int*)(((char*)&data)-0x80000000)")
703 # assertIn("0xbead", output)
705 #class PrivTest(GdbTest):
706 # compile_args = ("programs/priv.S", )
708 # # pylint: disable=attribute-defined-outside-init
711 # misa = self.target.misa
712 # self.supported = set()
714 # self.supported.add(0)
716 # self.supported.add(1)
718 # self.supported.add(2)
719 # self.supported.add(3)
721 #class PrivRw(PrivTest):
723 # """Test reading/writing priv."""
724 # for privilege in range(4):
725 # self.gdb.p("$priv=%d" % privilege)
727 # actual = self.gdb.p("$priv")
728 # assertIn(actual, self.supported)
729 # if privilege in self.supported:
730 # assertEqual(actual, privilege)
732 #class PrivChange(PrivTest):
734 # """Test that the core's privilege level actually changes."""
736 # if 0 not in self.supported:
737 # return 'not_applicable'
743 # self.gdb.p("$priv=3")
744 # main_address = self.gdb.p("$pc")
746 # assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4))
749 # self.gdb.p("$priv=0")
751 # # Should have taken an exception, so be nowhere near main.
752 # pc = self.gdb.p("$pc")
753 # assertTrue(pc < main_address or pc > main_address + 0x100)
757 parser
= argparse
.ArgumentParser(
758 description
="Test that gdb can talk to a RISC-V target.",
760 Example command line from the real world:
761 Run all RegsTest cases against a physical FPGA, with custom openocd command:
762 ./gdbserver.py --freedom-e300 --server_cmd "$HOME/SiFive/openocd/src/openocd -s $HOME/SiFive/openocd/tcl -d" Simple
764 targets
.add_target_options(parser
)
766 testlib
.add_test_run_options(parser
)
768 # TODO: remove global
769 global parsed
# pylint: disable=global-statement
770 parsed
= parser
.parse_args()
771 target
= targets
.target(parsed
)
774 target
.xlen
= parsed
.xlen
776 module
= sys
.modules
[__name__
]
778 return testlib
.run_all_tests(module
, target
, parsed
)
780 # TROUBLESHOOTING TIPS
781 # If a particular test fails, run just that one test, eg.:
782 # ./gdbserver.py MprvTest.test_mprv
783 # Then inspect gdb.log and spike.log to see what happened in more detail.
785 if __name__
== '__main__':