311 lines
12 KiB
Zig
311 lines
12 KiB
Zig
const std = @import("std");
|
|
|
|
const Allocator = std.mem.Allocator;
|
|
const Emulator = @import("lib.zig").Emulator;
|
|
const State = @import("State.zig");
|
|
const Server = @import("Server.zig");
|
|
|
|
const Self = @This();
|
|
const log = std.log.scoped(.Packet);
|
|
pub const max_len: usize = 0x1000;
|
|
|
|
contents: []const u8,
|
|
|
|
pub fn from(allocator: Allocator, str: []const u8) !Self {
|
|
var tokens = std.mem.tokenize(u8, str, "$#");
|
|
const contents = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
const chksum_str = tokens.next() orelse return error.MissingCheckSum;
|
|
const chksum = std.fmt.parseInt(u8, chksum_str, 16) catch return error.InvalidChecksum;
|
|
|
|
if (!Self.verify(contents, chksum)) return error.ChecksumMismatch;
|
|
|
|
return .{ .contents = try allocator.dupe(u8, contents) };
|
|
}
|
|
|
|
const String = union(enum) {
|
|
alloc: []const u8,
|
|
static: []const u8,
|
|
|
|
pub fn inner(self: *const @This()) []const u8 {
|
|
return switch (self.*) {
|
|
.static => |str| str,
|
|
.alloc => |str| str,
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: *@This(), allocator: Allocator) void {
|
|
switch (self.*) {
|
|
.alloc => |string| allocator.free(string),
|
|
.static => {},
|
|
}
|
|
|
|
self.* = undefined;
|
|
}
|
|
};
|
|
|
|
pub fn parse(self: *Self, allocator: Allocator, state: *Server.State, emu: *Emulator) !String {
|
|
switch (self.contents[0]) {
|
|
// Required
|
|
'?' => return .{ .static = "T05" }, // FIXME: which errno?
|
|
'g' => {
|
|
const r = emu.registers();
|
|
const cpsr = emu.cpsr();
|
|
|
|
const reg_len = @sizeOf(u32) * 2; // Every byte is represented by 2 characters
|
|
const ret = try allocator.alloc(u8, r.len * reg_len + reg_len); // r0 -> r15 + CPSR
|
|
|
|
{
|
|
var i: u32 = 0;
|
|
while (i < r.len + 1) : (i += 1) {
|
|
var reg: u32 = if (i < r.len) r[i] else cpsr;
|
|
if (i == 15) reg -|= if (cpsr >> 5 & 1 == 1) 4 else 8; // PC is ahead
|
|
|
|
// writes the formatted integer to the buffer, returns a slice to the buffer but we ignore that
|
|
// GDB also expects the bytes to be in the opposite order for whatever reason
|
|
_ = std.fmt.bufPrintIntToSlice(ret[i * 8 ..][0..8], @byteSwap(reg), 16, .lower, .{ .fill = '0', .width = 8 });
|
|
}
|
|
}
|
|
|
|
return .{ .alloc = ret };
|
|
},
|
|
'G' => @panic("TODO: Register Write"),
|
|
'm' => {
|
|
var tokens = std.mem.tokenize(u8, self.contents[1..], ",");
|
|
const addr_str = tokens.next() orelse return error.InvalidPacket;
|
|
const length_str = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
const addr = try std.fmt.parseInt(u32, addr_str, 16);
|
|
const len = try std.fmt.parseInt(u32, length_str, 16);
|
|
|
|
const ret = try allocator.alloc(u8, len * 2);
|
|
|
|
{
|
|
var i: u32 = 0;
|
|
while (i < len) : (i += 1) {
|
|
// writes the formatted integer to the buffer, returns a slice to the buffer but we ignore that
|
|
_ = std.fmt.bufPrintIntToSlice(ret[i * 2 ..][0..2], emu.read(addr + i), 16, .lower, .{ .fill = '0', .width = 2 });
|
|
}
|
|
}
|
|
|
|
return .{ .alloc = ret };
|
|
},
|
|
'M' => {
|
|
var tokens = std.mem.tokenize(u8, self.contents[1..], ",:");
|
|
|
|
const addr_str = tokens.next() orelse return error.InvalidPacket;
|
|
const length_str = tokens.next() orelse return error.InvalidPacket;
|
|
const bytes = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
const addr = try std.fmt.parseInt(u32, addr_str, 16);
|
|
const len = try std.fmt.parseInt(u32, length_str, 16);
|
|
|
|
{
|
|
var i: u32 = 0;
|
|
while (i < len) : (i += 1) {
|
|
const str = bytes[2 * i ..][0..2];
|
|
const value = try std.fmt.parseInt(u8, str, 16);
|
|
|
|
emu.write(addr + i, value);
|
|
}
|
|
}
|
|
|
|
return .{ .static = "OK" };
|
|
},
|
|
'c' => {
|
|
switch (emu.contd()) {
|
|
.SingleStep => unreachable,
|
|
.Trap => |r| switch (r) {
|
|
.HwBkpt => return .{ .static = "T05 hwbreak:;" },
|
|
.SwBkpt => return .{ .static = "T05 swbreak:;" },
|
|
},
|
|
}
|
|
},
|
|
's' => {
|
|
// var tokens = std.mem.tokenize(u8, self.contents[1..], " ");
|
|
// const addr = if (tokens.next()) |s| try std.fmt.parseInt(u32, s, 16) else null;
|
|
|
|
switch (emu.step()) {
|
|
.SingleStep => return .{ .static = "T05" },
|
|
.Trap => |r| switch (r) {
|
|
.HwBkpt => return .{ .static = "T05 hwbreak:;" },
|
|
.SwBkpt => return .{ .static = "T05 swbreak:;" },
|
|
},
|
|
}
|
|
},
|
|
|
|
// Breakpoints
|
|
'z' => {
|
|
var tokens = std.mem.tokenize(u8, self.contents[2..], ",");
|
|
|
|
const addr_str = tokens.next() orelse return error.InvalidPacket;
|
|
const addr = try std.fmt.parseInt(u32, addr_str, 16);
|
|
|
|
switch (self.contents[1]) {
|
|
'0' => {
|
|
emu.removeBkpt(.Software, addr);
|
|
return .{ .static = "OK" };
|
|
},
|
|
'1' => {
|
|
emu.removeBkpt(.Hardware, addr);
|
|
return .{ .static = "OK" };
|
|
},
|
|
'2' => return .{ .static = "" }, // TODO: Remove Write Watchpoint
|
|
'3' => return .{ .static = "" }, // TODO: Remove Read Watchpoint
|
|
'4' => return .{ .static = "" }, // TODO: Remove Access Watchpoint
|
|
else => return .{ .static = "" },
|
|
}
|
|
},
|
|
'Z' => {
|
|
var tokens = std.mem.tokenize(u8, self.contents[2..], ",");
|
|
const addr_str = tokens.next() orelse return error.InvalidPacket;
|
|
const kind_str = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
const addr = try std.fmt.parseInt(u32, addr_str, 16);
|
|
const kind = try std.fmt.parseInt(u32, kind_str, 16);
|
|
|
|
switch (self.contents[1]) {
|
|
'0' => {
|
|
try emu.addBkpt(.Software, addr, kind);
|
|
return .{ .static = "OK" };
|
|
},
|
|
'1' => {
|
|
emu.addBkpt(.Hardware, addr, kind) catch |e| {
|
|
switch (e) {
|
|
error.OutOfSpace => return .{ .static = "E22" }, // FIXME: which errno?
|
|
else => return e,
|
|
}
|
|
};
|
|
|
|
return .{ .static = "OK" };
|
|
},
|
|
'2' => return .{ .static = "" }, // TODO: Insert Write Watchpoint
|
|
'3' => return .{ .static = "" }, // TODO: Insert Read Watchpoint
|
|
'4' => return .{ .static = "" }, // TODO: Insert Access Watchpoint
|
|
else => return .{ .static = "" },
|
|
}
|
|
},
|
|
|
|
// TODO: Figure out the difference between 'M' and 'X'
|
|
'D' => {
|
|
log.info("Disconnecting...", .{});
|
|
|
|
state.should_quit = true;
|
|
return .{ .static = "OK" };
|
|
},
|
|
'H' => return .{ .static = "" },
|
|
'v' => {
|
|
if (!substr(self.contents[1..], "MustReplyEmpty")) {
|
|
log.warn("Unimplemented: {s}", .{self.contents});
|
|
}
|
|
|
|
return .{ .static = "" };
|
|
},
|
|
'q' => {
|
|
if (self.contents[1] == 'C' and self.contents.len == 2) return .{ .static = "QC1" };
|
|
|
|
if (substr(self.contents[1..], "fThreadInfo")) return .{ .static = "m1" };
|
|
if (substr(self.contents[1..], "sThreadInfo")) return .{ .static = "l" };
|
|
if (substr(self.contents[1..], "Attached")) return .{ .static = "1" }; // Tell GDB we're attached to a process
|
|
|
|
if (substr(self.contents[1..], "Supported")) {
|
|
const format = "PacketSize={x:};swbreak+;hwbreak+;qXfer:features:read+;qXfer:memory-map:read+";
|
|
// TODO: Anything else?
|
|
|
|
const ret = try std.fmt.allocPrint(allocator, format, .{Self.max_len});
|
|
return .{ .alloc = ret };
|
|
}
|
|
|
|
if (substr(self.contents[1..], "Xfer:features:read")) {
|
|
var tokens = std.mem.tokenize(u8, self.contents[1..], ":,");
|
|
_ = tokens.next(); // Xfer
|
|
_ = tokens.next(); // features
|
|
_ = tokens.next(); // read
|
|
|
|
const annex = tokens.next() orelse return error.InvalidPacket;
|
|
const offset_str = tokens.next() orelse return error.InvalidPacket;
|
|
const length_str = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
if (std.mem.eql(u8, annex, "target.xml")) {
|
|
const offset = try std.fmt.parseInt(usize, offset_str, 16);
|
|
const length = try std.fmt.parseInt(usize, length_str, 16);
|
|
|
|
// + 2 to account for the "m " in the response
|
|
// subtract offset so that the allocated buffer isn't
|
|
// larger than it needs to be TODO: Test this?
|
|
const len = @min(length, (state.target_xml.len + 1) - offset);
|
|
const ret = try allocator.alloc(u8, len);
|
|
|
|
ret[0] = if (ret.len < length) 'l' else 'm';
|
|
@memcpy(ret[1..], state.target_xml[offset..]);
|
|
|
|
return .{ .alloc = ret };
|
|
} else {
|
|
log.err("Unexpected Annex: {s}", .{annex});
|
|
return .{ .static = "E9999" };
|
|
}
|
|
|
|
return .{ .static = "" };
|
|
}
|
|
|
|
if (substr(self.contents[1..], "Xfer:memory-map:read")) {
|
|
var tokens = std.mem.tokenize(u8, self.contents[1..], ":,");
|
|
_ = tokens.next(); // Xfer
|
|
_ = tokens.next(); // memory-map
|
|
_ = tokens.next(); // read
|
|
const offset_str = tokens.next() orelse return error.InvalidPacket;
|
|
const length_str = tokens.next() orelse return error.InvalidPacket;
|
|
|
|
const offset = try std.fmt.parseInt(usize, offset_str, 16);
|
|
const length = try std.fmt.parseInt(usize, length_str, 16);
|
|
|
|
// see above
|
|
const len = @min(length, (state.memmap_xml.len + 1) - offset);
|
|
const ret = try allocator.alloc(u8, len);
|
|
|
|
ret[0] = if (ret.len < length) 'l' else 'm';
|
|
@memcpy(ret[1..], state.memmap_xml[offset..]);
|
|
|
|
return .{ .alloc = ret };
|
|
}
|
|
|
|
log.warn("Unimplemented: {s}", .{self.contents});
|
|
return .{ .static = "" };
|
|
},
|
|
else => {
|
|
log.warn("Unknown: {s}", .{self.contents});
|
|
|
|
return .{ .static = "" };
|
|
},
|
|
}
|
|
}
|
|
|
|
fn substr(haystack: []const u8, needle: []const u8) bool {
|
|
return std.mem.indexOf(u8, haystack, needle) != null;
|
|
}
|
|
|
|
pub fn deinit(self: *Self, allocator: Allocator) void {
|
|
allocator.free(self.contents);
|
|
self.* = undefined;
|
|
}
|
|
|
|
pub fn checksum(input: []const u8) u8 {
|
|
var sum: usize = 0;
|
|
for (input) |char| sum += char;
|
|
|
|
return @truncate(sum);
|
|
}
|
|
|
|
fn verify(input: []const u8, chksum: u8) bool {
|
|
return Self.checksum(input) == chksum;
|
|
}
|
|
|
|
const Signal = enum(u32) {
|
|
Hup = 1, // Hangup
|
|
Int, // Interrupt
|
|
Quit, // Quit
|
|
Ill, // Illegal Instruction
|
|
Trap, // Trace/Breakponit trap
|
|
Abrt, // Aborted
|
|
};
|