diff options
Diffstat (limited to 'debug')
-rwxr-xr-x | debug/gdbserver.py | 286 | ||||
-rwxr-xr-x | debug/openocd.py | 14 |
2 files changed, 151 insertions, 149 deletions
diff --git a/debug/gdbserver.py b/debug/gdbserver.py index 2e5a18e..e30305d 100755 --- a/debug/gdbserver.py +++ b/debug/gdbserver.py @@ -41,7 +41,7 @@ MSTATUS64_SD = 0x8000000000000000 def ihex_line(address, record_type, data): assert len(data) < 128 - line = ":%02X%04X%02X" % (len(data), address, record_type) + line = f":{len(data):02X}{address:04X}{record_type:02X}" check = len(data) check += address % 256 check += address >> 8 @@ -49,8 +49,8 @@ def ihex_line(address, record_type, data): for char in data: value = ord(char) check += value - line += "%02X" % value - line += "%02X\n" % ((256-check)%256) + line += f"{value:02X}" + line += f"{(256 - check) % 256:02X}\n" return line def srec_parse(line): @@ -66,17 +66,17 @@ def srec_parse(line): # Any higher bits were chopped off. address = int(line[4:12], 16) for i in range(6, count+1): - data += "%c" % int(line[2*i:2*i+2], 16) + data += f"{int(line[2 * i:2 * i + 2], 16):c}" # Ignore the checksum. return 3, address, data elif typ == b'S7': # ignore execution start field return 7, 0, 0 else: - raise TestFailed("Unsupported SREC type %r." % typ) + raise TestFailed(f"Unsupported SREC type {typ!r}.") def readable_binary_string(s): - return "".join("%02x" % ord(c) for c in s) + return "".join(f"{ord(c):02x}" for c in s) class InfoTest(GdbTest): def test(self): @@ -99,16 +99,16 @@ class SimpleRegisterTest(GdbTest): def check_reg(self, name, alias): a = random.randrange(1<<self.hart.xlen) b = random.randrange(1<<self.hart.xlen) - self.gdb.p("$%s=0x%x" % (name, a)) - assertEqual(self.gdb.p("$%s" % alias), a) + self.gdb.p(f"${name}=0x{a:x}") + assertEqual(self.gdb.p(f"${alias}"), a) self.gdb.stepi() - assertEqual(self.gdb.p("$%s" % name), a) - assertEqual(self.gdb.p("$%s" % alias), a) - self.gdb.p("$%s=0x%x" % (alias, b)) - assertEqual(self.gdb.p("$%s" % name), b) + assertEqual(self.gdb.p(f"${name}"), a) + assertEqual(self.gdb.p(f"${alias}"), a) + self.gdb.p(f"${alias}=0x{b:x}") + assertEqual(self.gdb.p(f"${name}"), b) self.gdb.stepi() - assertEqual(self.gdb.p("$%s" % name), b) - assertEqual(self.gdb.p("$%s" % alias), b) + assertEqual(self.gdb.p(f"${name}"), b) + assertEqual(self.gdb.p(f"${alias}"), b) def setup(self): self.write_nop_program(5) @@ -140,11 +140,11 @@ class SimpleV13Test(SimpleRegisterTest): written[name] = {} for i in range(vlenb // byte_count): written[name][i] = random.randrange(256 ** byte_count) - self.gdb.p("$v13.%s[%d]=0x%x" % (name, i, written[name][i])) + self.gdb.p(f"$v13.{name}[{i}]=0x{written[name][i]:x}") self.gdb.stepi() self.gdb.p("$v13") for i in range(vlenb // byte_count): - assertEqual(self.gdb.p("$v13.%s[%d]" % (name, i)), + assertEqual(self.gdb.p(f"$v13.{name}[{i}]"), written[name][i]) else: output = self.gdb.p_raw("$v13") @@ -154,22 +154,22 @@ class SimpleF18Test(SimpleRegisterTest): def check_reg(self, name, alias): if self.hart.extensionSupported('F'): mstatus_fs = 0x00006000 - self.gdb.p("$mstatus=$mstatus|0x%x" % mstatus_fs) + self.gdb.p(f"$mstatus=$mstatus|0x{mstatus_fs:x}") self.gdb.stepi() a = random.random() b = random.random() - self.gdb.p_fpr("$%s=%f" % (name, a)) - assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - a), .001) + self.gdb.p_fpr(f"${name}={a:f}") + assertLess(abs((self.gdb.p_fpr(f"${alias}")) - a), .001) self.gdb.stepi() - assertLess(abs((self.gdb.p_fpr("$%s" % name)) - a), .001) - assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - a), .001) - self.gdb.p_fpr("$%s=%f" % (alias, b)) - assertLess(abs((self.gdb.p_fpr("$%s" % name)) - b), .001) + assertLess(abs((self.gdb.p_fpr(f"${name}")) - a), .001) + assertLess(abs((self.gdb.p_fpr(f"${alias}")) - a), .001) + self.gdb.p_fpr(f"${alias}={b:f}") + assertLess(abs((self.gdb.p_fpr(f"${name}")) - b), .001) self.gdb.stepi() - assertLess(abs((self.gdb.p_fpr("$%s" % name)) - b), .001) - assertLess(abs((self.gdb.p_fpr("$%s" % alias)) - b), .001) + assertLess(abs((self.gdb.p_fpr(f"${name}")) - b), .001) + assertLess(abs((self.gdb.p_fpr(f"${alias}")) - b), .001) - size = self.gdb.p("sizeof($%s)" % name) + size = self.gdb.p(f"sizeof(${name})") if self.hart.extensionSupported('D'): assertEqual(size, 8) else: @@ -209,7 +209,7 @@ class CustomRegisterTest(SimpleRegisterTest): # Now test writing magic = 6667 - self.gdb.p("$custom12345=%d" % (12345 + magic)) + self.gdb.p(f"$custom12345={12345 + magic}") self.gdb.stepi() self.check_custom(magic) @@ -229,15 +229,15 @@ class SimpleNoExistTest(GdbTest): class SimpleMemoryTest(GdbTest): def access_test(self, size, data_type): - assertEqual(self.gdb.p("sizeof(%s)" % data_type), size) + assertEqual(self.gdb.p(f"sizeof({data_type})"), size) a = 0x86753095555aaaa & ((1<<(size*8))-1) b = 0xdeadbeef12345678 & ((1<<(size*8))-1) addrA = self.hart.ram addrB = self.hart.ram + self.hart.ram_size - size - self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, addrA, a)) - self.gdb.p("*((%s*)0x%x) = 0x%x" % (data_type, addrB, b)) - assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, addrA)), a) - assertEqual(self.gdb.p("*((%s*)0x%x)" % (data_type, addrB)), b) + self.gdb.p(f"*(({data_type}*)0x{addrA:x}) = 0x{a:x}") + self.gdb.p(f"*(({data_type}*)0x{addrB:x}) = 0x{b:x}") + assertEqual(self.gdb.p(f"*(({data_type}*)0x{addrA:x})"), a) + assertEqual(self.gdb.p(f"*(({data_type}*)0x{addrB:x})"), b) class MemTest8(SimpleMemoryTest): def test(self): @@ -262,16 +262,16 @@ class MemTestReadInvalid(SimpleMemoryTest): self.write_nop_program(2) self.gdb.p("$s0=0x12345678") - self.gdb.p("*((int*)0x%x)=0xabcdef" % good_address) + self.gdb.p(f"*((int*)0x{good_address:x})=0xabcdef") # This test relies on 'gdb_report_data_abort enable' being executed in # the openocd.cfg file. try: - self.gdb.p("*((int*)0x%x)" % bad_address) + self.gdb.p(f"*((int*)0x{bad_address:x})") assert False, "Read should have failed." except testlib.CannotAccess as e: assertEqual(e.address, bad_address) self.gdb.stepi() # Don't let gdb cache register read - assertEqual(self.gdb.p("*((int*)0x%x)" % good_address), 0xabcdef) + assertEqual(self.gdb.p(f"*((int*)0x{good_address:x})"), 0xabcdef) assertEqual(self.gdb.p("$s0"), 0x12345678) #class MemTestWriteInvalid(SimpleMemoryTest): @@ -293,8 +293,8 @@ class MemTestBlockReadInvalid(GdbTest): return self.target.invalid_memory_returns_zero def test(self): - self.gdb.p("*((int*)0x%x) = 0xdeadbeef" % (self.hart.ram + 0)) - self.gdb.p("*((int*)0x%x) = 0x12345678" % (self.hart.ram + 4)) + self.gdb.p(f"*((int*)0x{self.hart.ram + 0:x}) = 0xdeadbeef") + self.gdb.p(f"*((int*)0x{self.hart.ram + 4:x}) = 0x12345678") # read before start of memory self.memory_test(self.hart.ram - 8, @@ -311,10 +311,10 @@ class MemTestBlockReadInvalid(GdbTest): self.hart.ram + 8, self.real_values) - self.gdb.p("*((int*)0x%x) = 0xdeadbeef" % - (self.hart.ram + self.hart.ram_size - 8)) - self.gdb.p("*((int*)0x%x) = 0x12345678" % - (self.hart.ram + self.hart.ram_size - 4)) + self.gdb.p(f"*((int*)0x{self.hart.ram + self.hart.ram_size - 8:x}) = " + "0xdeadbeef") + self.gdb.p(f"*((int*)0x{self.hart.ram + self.hart.ram_size - 4:x}) = " + "0x12345678") # read before end of memory self.memory_test(self.hart.ram + self.hart.ram_size - 8, @@ -332,12 +332,12 @@ class MemTestBlockReadInvalid(GdbTest): self.zero_values) def memory_test(self, start_addr, end_addr, expected_values): - dump = tempfile.NamedTemporaryFile(suffix=".simdata") - self.gdb.command("dump verilog memory %s 0x%x 0x%x" % - (dump.name, start_addr, end_addr)) - self.gdb.command("shell cat %s" % dump.name) - line = dump.readline() - line = dump.readline() + with tempfile.NamedTemporaryFile(suffix=".simdata") as dump: + self.gdb.command(f"dump verilog memory {dump.name} " + f"0x{start_addr:x} 0x{end_addr:x}") + self.gdb.command(f"shell cat {dump.name}") + line = dump.readline() + line = dump.readline() assertEqual(line.strip(), expected_values) class MemTestBlock(GdbTest): @@ -347,7 +347,7 @@ class MemTestBlock(GdbTest): def write(self, temporary_file): data = "" for i in range(self.length // self.line_length): - line_data = "".join(["%c" % random.randrange(256) + line_data = "".join([f"{random.randrange(256):c}" for _ in range(self.line_length)]) data += line_data temporary_file.write(ihex_line(i * self.line_length, 0, @@ -358,7 +358,7 @@ class MemTestBlock(GdbTest): def spot_check_memory(self, data): increment = 19 * 4 for offset in list(range(0, self.length, increment)) + [self.length-4]: - value = self.gdb.p("*((int*)0x%x)" % (self.hart.ram + offset)) + value = self.gdb.p(f"*((int*)0x{self.hart.ram + offset:x})") written = ord(data[offset]) | \ (ord(data[offset+1]) << 8) | \ (ord(data[offset+2]) << 16) | \ @@ -366,33 +366,33 @@ class MemTestBlock(GdbTest): assertEqual(value, written) def test_block(self, extra_delay): - a = tempfile.NamedTemporaryFile(suffix=".ihex") - data = self.write(a) + with tempfile.NamedTemporaryFile(suffix=".ihex") as a: + data = self.write(a) - self.gdb.command("shell cat %s" % a.name) - self.gdb.command("restore %s 0x%x" % (a.name, self.hart.ram), - reset_delays=50 + extra_delay) + self.gdb.command(f"shell cat {a.name}") + self.gdb.command(f"restore {a.name} 0x{self.hart.ram:x}", + reset_delays=50 + extra_delay) self.spot_check_memory(data) - b = tempfile.NamedTemporaryFile(suffix=".srec") - self.gdb.command("dump srec memory %s 0x%x 0x%x" % (b.name, - self.hart.ram, self.hart.ram + self.length), ops=self.length / 32, - reset_delays=100 + extra_delay) - self.gdb.command("shell cat %s" % b.name) - highest_seen = 0 - for line in b: - record_type, address, line_data = srec_parse(line) - if record_type == 3: - offset = address - (self.hart.ram & 0xffffffff) - written_data = data[offset:offset+len(line_data)] - highest_seen += len(line_data) - if line_data != written_data: - raise TestFailed( - "Data mismatch at 0x%x (offset 0x%x); wrote %s but " - "read %s" % ( - self.hart.ram + offset, offset, - readable_binary_string(written_data), - readable_binary_string(line_data))) + with tempfile.NamedTemporaryFile(suffix=".srec") as b: + self.gdb.command(f"dump srec memory {b.name} 0x{self.hart.ram:x} " + f"0x{self.hart.ram + self.length:x}", + ops=self.length / 32, + reset_delays=100 + extra_delay) + self.gdb.command(f"shell cat {b.name}") + highest_seen = 0 + for line in b: + record_type, address, line_data = srec_parse(line) + if record_type == 3: + offset = address - (self.hart.ram & 0xffffffff) + written_data = data[offset:offset+len(line_data)] + highest_seen += len(line_data) + if line_data != written_data: + raise TestFailed( + f"Data mismatch at 0x{self.hart.ram + offset:x} " + f"(offset 0x{offset:x}); " + f"wrote {readable_binary_string(written_data)} but " + f"read {readable_binary_string(line_data)}") assertEqual(highest_seen, self.length) # Run memory block tests with different reset delays, so hopefully we hit busy @@ -422,7 +422,7 @@ class DisconnectTest(GdbTest): if regname in ("mcycle", "minstret", "instret", "cycle"): continue assertEqual(old_values[regname], new_values[regname], - "Register %s didn't match" % regname) + f"Register {regname} didn't match") class InstantHaltTest(GdbTest): def test(self): @@ -447,10 +447,10 @@ class InstantChangePc(GdbTest): # 0x13 is nop self.gdb.command("monitor reset halt") self.gdb.command("flushregs") - self.gdb.command("p *((int*) 0x%x)=0x13" % self.hart.ram) - self.gdb.command("p *((int*) 0x%x)=0x13" % (self.hart.ram + 4)) - self.gdb.command("p *((int*) 0x%x)=0x13" % (self.hart.ram + 8)) - self.gdb.p("$pc=0x%x" % self.hart.ram) + self.gdb.command(f"p *((int*) 0x{self.hart.ram:x})=0x13") + self.gdb.command(f"p *((int*) 0x{self.hart.ram + 4:x})=0x13") + self.gdb.command(f"p *((int*) 0x{self.hart.ram + 8:x})=0x13") + self.gdb.p(f"$pc=0x{self.hart.ram:x}") self.gdb.stepi() assertEqual((self.hart.ram + 4), self.gdb.p("$pc")) self.gdb.stepi() @@ -479,7 +479,7 @@ class ProgramHwWatchpoint(ProgramTest): output = self.gdb.c() assertIn("Breakpoint", output) assertIn("main", output) - self.gdb.command("delete %d" % mainbp) + self.gdb.command(f"delete {mainbp}") self.gdb.watch("counter == 5") # Watchpoint hits when counter becomes 5. output = self.gdb.c() @@ -556,7 +556,7 @@ class DebugChangeString(DebugTest): text = "This little piggy went to the market." self.gdb.b("main:start") self.gdb.c() - self.gdb.p('fox = "%s"' % text) + self.gdb.p(f'fox = "{text}"') self.exit(0x43b497b8) class DebugTurbostep(DebugTest): @@ -580,7 +580,7 @@ class DebugTurbostep(DebugTest): jumps += 1 last_pc = pc end = time.time() - print("%.2f seconds/step" % ((end - start) / count)) + print(f"{(end - start) / count:.2f} seconds/step") # Some basic sanity that we're not running between breakpoints or # something. assertGreater(jumps, 1) @@ -595,11 +595,11 @@ class DebugSymbols(DebugTest): bp = self.gdb.b("main") output = self.gdb.c() assertIn(", main ", output) - self.gdb.command("delete %d" % bp) + self.gdb.command(f"delete {bp}") bp = self.gdb.b("rot13") output = self.gdb.c() assertIn(", rot13 ", output) - self.gdb.command("delete %d" % bp) + self.gdb.command(f"delete {bp}") class DebugBreakpoint(DebugTest): def test(self): @@ -696,11 +696,11 @@ class HwbpManual(DebugTest): tselect = 0 while True: - self.gdb.p("$tselect=%d" % tselect) + self.gdb.p(f"$tselect={tselect}") value = self.gdb.p("$tselect") if value != tselect: raise TestNotApplicable - self.gdb.p("$tdata1=0x%x" % tdata1) + self.gdb.p(f"$tdata1=0x{tdata1:x}") value = self.gdb.p("$tselect") if value == tdata1: break @@ -739,7 +739,7 @@ class Hwbp2(DebugTest): output = self.gdb.c() self.gdb.p("$pc") assertRegex(output, r"[bB]reakpoint") - assertIn("%s " % expected, output) + assertIn(f"{expected} ", output) self.gdb.command("delete") self.gdb.b("_exit") self.exit() @@ -747,7 +747,7 @@ class Hwbp2(DebugTest): class TooManyHwbp(DebugTest): def test(self): for i in range(30): - self.gdb.hbreak("*rot13 + %d" % (i * 4)) + self.gdb.hbreak(f"*rot13 + {i * 4}") output = self.gdb.c(checkOutput=False) assertIn("Cannot insert hardware breakpoint", output) @@ -846,8 +846,8 @@ class MemorySampleTest(DebugTest): previous_value = value total_samples += 1 if end and total_samples > 0: - print("%d samples/second" % (1000 * end[1] / (end[0] - - first_timestamp))) + samples_per_second = 1000 * end[1] / (end[0] - first_timestamp) + print(f"{samples_per_second} samples/second") else: raise Exception("No samples collected.") @@ -875,8 +875,7 @@ class MemorySampleSingle(MemorySampleTest): def test(self): addr = self.gdb.p("&j") sizeof_j = self.gdb.p("sizeof(j)") - self.gdb.command("monitor riscv memory_sample 0 0x%x %d" % ( - addr, sizeof_j)) + self.gdb.command(f"monitor riscv memory_sample 0 0x{addr:x} {sizeof_j}") raw_samples = self.collect_samples() self.check_incrementing_samples(raw_samples, addr) @@ -889,10 +888,10 @@ class MemorySampleMixed(MemorySampleTest): def test(self): addr = {} for i, name in enumerate(("j", "i32", "i64")): - addr[name] = self.gdb.p("&%s" % name) - sizeof = self.gdb.p("sizeof(%s)" % name) - self.gdb.command("monitor riscv memory_sample %d 0x%x %d" % ( - i, addr[name], sizeof)) + addr[name] = self.gdb.p(f"&{name}") + sizeof = self.gdb.p(f"sizeof({name})") + self.gdb.command(f"monitor riscv memory_sample {i} " + f"0x{addr[name]:x} {sizeof}") raw_samples = self.collect_samples() self.check_incrementing_samples(raw_samples, addr["j"], @@ -909,8 +908,8 @@ class RepeatReadTest(DebugTest): self.gdb.c() mtime_addr = 0x02000000 + 0xbff8 count = 1024 - output = self.gdb.command("monitor riscv repeat_read %d 0x%x 4" % - (count, mtime_addr)) + output = self.gdb.command( + f"monitor riscv repeat_read {count} 0x{mtime_addr:x} 4") values = [] for line in output.splitlines(): # Ignore warnings @@ -930,8 +929,8 @@ class RepeatReadTest(DebugTest): assertGreater(values[i], values[i-1]) assertLess(values[i], values[i-1] + slop) - output = self.gdb.command("monitor riscv repeat_read 0 0x%x 4" % - mtime_addr) + output = self.gdb.command( + f"monitor riscv repeat_read 0 0x{mtime_addr:x} 4") assertEqual(output, "") class Semihosting(GdbSingleHartTest): @@ -955,18 +954,20 @@ class Semihosting(GdbSingleHartTest): return output def test(self): - temp = tempfile.NamedTemporaryFile(suffix=".data") + with tempfile.NamedTemporaryFile(suffix=".data") as temp: + self.gdb.b("main:begin") + self.gdb.c() + self.gdb.p(f'filename="{temp.name}"', ops=3) + self.exit() - self.gdb.b("main:begin") - self.gdb.c() - self.gdb.p('filename="%s"' % temp.name, ops=3) - self.exit() + with open(temp.name, "r", encoding='utf-8') as fd: + contents = fd.readlines() - contents = open(temp.name, "r").readlines() assertIn("Hello, world!\n", contents) # stdout should end up in the OpenOCD log - log = open(self.server.logname).read() + with open(self.server.logname, "r", encoding='utf-8') as fd: + log = fd.read() assertIn("Do re mi fa so la ti do!", log) class SemihostingFileio(Semihosting): @@ -975,16 +976,16 @@ class SemihostingFileio(Semihosting): super().setup() def test(self): - temp = tempfile.NamedTemporaryFile(suffix=".data") - - self.gdb.b("main:begin") - self.gdb.c() - self.gdb.p('filename="%s"' % temp.name, ops=3) - output = self.exit() - # stdout should end up in gdb's CLI - assertIn("Do re mi fa so la ti do!", output) + with tempfile.NamedTemporaryFile(suffix=".data") as temp: + self.gdb.b("main:begin") + self.gdb.c() + self.gdb.p(f'filename="{temp.name}"', ops=3) + output = self.exit() + # stdout should end up in gdb's CLI + assertIn("Do re mi fa so la ti do!", output) - contents = open(temp.name, "r").readlines() + with open(temp.name, "r", encoding='utf-8') as fd: + contents = fd.readlines() assertIn("Hello, world!\n", contents) class InterruptTest(GdbSingleHartTest): @@ -1068,7 +1069,7 @@ class MulticoreRegTest(GdbTest): assertNotIn((hart.system, hart_id), hart_ids) hart_ids.add((hart.system, hart_id)) for n in range(2, 32): - value = self.gdb.p("$x%d" % n) + value = self.gdb.p(f"$x{n}") assertEqual(value, (hart_id << 8) + n - 1) # Confirmed that we read different register values for different harts. @@ -1076,7 +1077,7 @@ class MulticoreRegTest(GdbTest): for hart in self.target.harts: self.gdb.select_hart(hart) - self.gdb.p("$x1=0x%x" % (hart.index * 0x1000)) + self.gdb.p(f"$x1=0x{hart.index * 4096:x}") self.gdb.p("$pc=main_post_csrr") self.gdb.c() for hart in self.target.harts: @@ -1084,7 +1085,7 @@ class MulticoreRegTest(GdbTest): assertIn("main", self.gdb.where()) # Check register values. for n in range(1, 32): - value = self.gdb.p("$x%d" % n) + value = self.gdb.p(f"$x{n}") assertEqual(value, hart.index * 0x1000 + n - 1) #class MulticoreRunHaltStepiTest(GdbTest): @@ -1268,7 +1269,7 @@ class StepTest(GdbSingleHartTest): for expected in sequence: self.gdb.stepi() pc = self.gdb.p("$pc") - assertEqual("%x" % (pc - main_address), "%x" % expected) + assertEqual(f"{pc - main_address:x}", f"{expected:x}") class JumpHbreak(GdbSingleHartTest): """'jump' resumes execution at location. Execution stops again immediately @@ -1313,7 +1314,7 @@ class TriggerExecuteInstant(TriggerTest): debug mode.""" def test(self): main_address = self.gdb.p("$pc") - self.gdb.command("hbreak *0x%x" % (main_address + 4)) + self.gdb.command(f"hbreak *0x{main_address + 4:x}") self.gdb.c() assertEqual(self.gdb.p("$pc"), main_address+4) @@ -1336,7 +1337,7 @@ class TriggerLoadAddressInstant(TriggerTest): read_loop = self.gdb.p("&read_loop") read_again = self.gdb.p("&read_again") data = self.gdb.p("&data") - self.gdb.command("rwatch *0x%x" % data) + self.gdb.command(f"rwatch *0x{data:x}") self.gdb.c() # Accept hitting the breakpoint before or after the load instruction. assertIn(self.gdb.p("$pc"), [read_loop, read_loop + 4]) @@ -1364,7 +1365,7 @@ class TriggerStoreAddressInstant(TriggerTest): self.gdb.c() write_loop = self.gdb.p("&write_loop") data = self.gdb.p("&data") - self.gdb.command("watch *0x%x" % data) + self.gdb.command(f"watch *0x{data:x}") self.gdb.c() # Accept hitting the breakpoint before or after the store instruction. @@ -1391,10 +1392,10 @@ class TriggerDmode(TriggerTest): dmode_count = 0 i = 0 for i in range(16): - tdata1 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i)) + tdata1 = self.gdb.p(f"(({xlen_type} *)&data)[{2*i}]") if tdata1 == 0: break - tdata2 = self.gdb.p("((%s *)&data)[%d]" % (xlen_type, 2*i+1)) + tdata2 = self.gdb.p(f"(({xlen_type} *)&data)[{2*i+1}]") if tdata1 & dmode: dmode_count += 1 @@ -1432,19 +1433,19 @@ class RegsTest(GdbSingleHartTest): output = self.gdb.c() assertIn("Breakpoint ", output) assertIn("main", output) - self.gdb.command("delete %d" % main_bp) + self.gdb.command(f"delete {main_bp}") self.gdb.b("handle_trap") class WriteGprs(RegsTest): def test(self): if self.hart.extensionSupported('E'): - regs = [("x%d" % n) for n in range(2, 16)] + regs = [(f"x{n}") for n in range(2, 16)] else: - regs = [("x%d" % n) for n in range(2, 32)] + regs = [(f"x{n}") for n in range(2, 32)] self.gdb.p("$pc=write_regs") for i, r in enumerate(regs): - self.gdb.p("$%s=%d" % (r, (0xdeadbeef<<i)+17)) + self.gdb.p(f"${r}={(0xdeadbeef<<i)+17}") self.gdb.p("$x1=&data") self.gdb.command("b all_done") output = self.gdb.c() @@ -1454,7 +1455,7 @@ class WriteGprs(RegsTest): self.gdb.command("x/30gx &data") self.gdb.command("info registers") for n in range(len(regs)): - assertEqual(self.gdb.x("(char*)(&data)+%d" % (8*n), 'g'), + assertEqual(self.gdb.x(f"(char*)(&data)+{8*n}", 'g'), ((0xdeadbeef<<n)+17) & ((1<<self.hart.xlen)-1)) class WriteCsrs(RegsTest): @@ -1486,6 +1487,7 @@ class DownloadTest(GdbTest): # line above that allows for more data runs into some error I don't # have time to track down right now. #length = min(2**14, max(2**10, self.hart.ram_size - 2048)) + # pylint: disable-next=consider-using-with self.download_c = tempfile.NamedTemporaryFile(prefix="download_", suffix=".c", delete=False) self.download_c.write(b"#include <stdint.h>\n") @@ -1496,10 +1498,10 @@ class DownloadTest(GdbTest): self.crc = 0 assert length % 16 == 0 for i in range(length // 16): - self.download_c.write((" /* 0x%04x */ " % (i * 16)).encode()) + self.download_c.write(f" /* 0x{i * 16:04x} */ ".encode()) for _ in range(16): value = random.randrange(1<<8) - self.download_c.write(("0x%02x, " % value).encode()) + self.download_c.write(f"0x{value:02x}, ".encode()) self.crc = binascii.crc32(struct.pack("B", value), self.crc) self.download_c.write(b"\n") self.download_c.write(b"};\n") @@ -1518,7 +1520,7 @@ class DownloadTest(GdbTest): compiled[key] = self.target.compile(hart, self.download_c.name, "programs/checksum.c") self.gdb.select_hart(hart) - self.gdb.command("file %s" % compiled.get(key)) + self.gdb.command(f"file {compiled.get(key)}") self.gdb.select_hart(self.hart) @@ -1575,7 +1577,7 @@ class PrivRw(PrivTest): """Test reading/writing priv.""" self.write_nop_program(4) for privilege in range(4): - self.gdb.p("$priv=%d" % privilege) + self.gdb.p(f"$priv={privilege}") self.gdb.stepi() actual = self.gdb.p("$priv") assertIn(actual, self.supported) @@ -1596,7 +1598,7 @@ class PrivChange(PrivTest): self.gdb.p("$priv=3") main_address = self.gdb.p("$pc") self.gdb.stepi() - assertEqual("%x" % self.gdb.p("$pc"), "%x" % (main_address+4)) + assertEqual(f"{self.gdb.p('$pc'):x}", f"{main_address + 4:x}") # User mode self.gdb.p("$priv=0") @@ -1630,7 +1632,7 @@ class TranslateTest(GdbSingleHartTest): else: satp = mode << 60 try: - self.gdb.p("$satp=0x%x" % satp) + self.gdb.p(f"$satp=0x{satp:x}") except testlib.CouldNotFetch as cnf: raise TestNotApplicable from cnf readback = self.gdb.p("$satp") @@ -1722,10 +1724,10 @@ class VectorTest(GdbSingleHartTest): for regname in ('$vl', '$vtype'): value = self.gdb.p(regname) assertNotEqual(value, 0) - self.gdb.p("%s=0" % regname) + self.gdb.p(f"{regname}=0") self.gdb.command("flushregs") assertEqual(self.gdb.p(regname), 0) - self.gdb.p("%s=0x%x" % (regname, value)) + self.gdb.p(f"{regname}=0x{value:x}") self.gdb.command("flushregs") assertEqual(self.gdb.p(regname), value) @@ -1795,7 +1797,7 @@ class FreeRtosTest(GdbTest): return True def test(self): - self.gdb.command("file %s" % self.target.freertos_binary) + self.gdb.command(f"file {self.target.freertos_binary}") self.gdb.load() output = self.gdb.command("monitor riscv_freertos_stacking mainline") @@ -1804,7 +1806,7 @@ class FreeRtosTest(GdbTest): # through gdb. It only works when spike loads the ELF file itself. bp = self.gdb.b("main") self.gdb.c() - self.gdb.command("delete %d" % bp) + self.gdb.command(f"delete {bp}") self.gdb.p("*((int*) &use_htif) = 0") # Need this, otherwise gdb complains that there is no current active # thread. @@ -1813,11 +1815,11 @@ class FreeRtosTest(GdbTest): bp = self.gdb.b("prvQueueReceiveTask") self.gdb.c() - self.gdb.command("delete %d" % bp) + self.gdb.command(f"delete {bp}") bp = self.gdb.b("prvQueueSendTask") self.gdb.c() - self.gdb.command("delete %d" % bp) + self.gdb.command(f"delete {bp}") # Now we know for sure at least 2 threads have executed. @@ -1833,7 +1835,7 @@ class FreeRtosTest(GdbTest): assertIn("ucHeap", output) self.gdb.command("info reg mstatus") values[thread.id] = self.gdb.p("$s11") - self.gdb.p("$s11=0x%x" % (values[thread.id] ^ int(thread.id))) + self.gdb.p(f"$s11=0x{values[thread.id] ^ int(thread.id):x}") # Test that writing worked self.gdb.stepi() diff --git a/debug/openocd.py b/debug/openocd.py index 1b7c8fd..54b970f 100755 --- a/debug/openocd.py +++ b/debug/openocd.py @@ -25,7 +25,7 @@ class OpenOcdTest(testlib.BaseTest): def write_nops(self, count): for address in range(self.target.ram, self.target.ram + 4 * count, 4): # 0x13 is nop - self.cli.command("mww 0x%x 0x13" % address) + self.cli.command(f"mww 0x{address:x} 0x13") class RegTest(OpenOcdTest): def test(self): @@ -35,7 +35,7 @@ class RegTest(OpenOcdTest): assertIn("x18", regs) self.cli.command("reg x18 0x11782") - self.cli.command("step 0x%x" % self.target.ram) + self.cli.command(f"step 0x{self.target.ram:x}") assertEqual(self.cli.reg("x18"), 0x11782) @@ -43,7 +43,7 @@ class StepTest(OpenOcdTest): def test(self): self.write_nops(4) - self.cli.command("step 0x%x" % self.target.ram) + self.cli.command("step 0x{self.target.ram:x}") for i in range(4): pc = self.cli.reg("pc") assertEqual(pc, self.target.ram + 4 * (i+1)) @@ -53,16 +53,16 @@ class ResumeTest(OpenOcdTest): def test(self): self.write_nops(16) - self.cli.command("bp 0x%x 4" % (self.target.ram + 12)) - self.cli.command("bp 0x%x 4" % (self.target.ram + 24)) + self.cli.command(f"bp 0x{self.target.ram + 12:x} 4") + self.cli.command(f"bp 0x{self.target.ram + 24:x} 4") - self.cli.command("resume 0x%x" % self.target.ram) + self.cli.command(f"resume 0x{self.target.ram:x}") assertEqual(self.cli.reg("pc"), self.target.ram + 12) self.cli.command("resume") assertEqual(self.cli.reg("pc"), self.target.ram + 24) - self.cli.command("resume 0x%x" % self.target.ram) + self.cli.command(f"resume 0x{self.target.ram:x}") assertEqual(self.cli.reg("pc"), self.target.ram + 12) def main(): |