| ... | @@ -217,13 +217,170 @@ pub const Instruction = union(Opcode) { | ... | @@ -217,13 +217,170 @@ pub const Instruction = union(Opcode) { |
| 217 | .restore_state => {}, | 217 | .restore_state => {}, |
| 218 | .def_cfa => |i| { | 218 | .def_cfa => |i| { |
| 219 | try abi.writeRegisterName(writer, arch, i.operands.register); | 219 | try abi.writeRegisterName(writer, arch, i.operands.register); |
| 220 | try writer.print(" +{}", .{ i.operands.offset }); | 220 | try writer.print(" {}", .{ fmtOffset(@intCast(i64, i.operands.offset)) }); |
| 221 | }, | 221 | }, |
| 222 | .def_cfa_register => {}, | 222 | .def_cfa_register => {}, |
| 223 | .def_cfa_offset => {}, | 223 | .def_cfa_offset => |i| { |
| | 224 | try writer.print("{}", .{ fmtOffset(@intCast(i64, i.operands.offset)) }); |
| | 225 | }, |
| 224 | .def_cfa_expression => |i| { | 226 | .def_cfa_expression => |i| { |
| 225 | try writer.print("TODO parse expressions: {x}", .{ std.fmt.fmtSliceHexLower(i.operands.block) }); | 227 | try writer.print("TODO(parse expressions data {x})", .{ std.fmt.fmtSliceHexLower(i.operands.block) }); |
| | 228 | }, |
| | 229 | .expression => {}, |
| | 230 | .offset_extended_sf => {}, |
| | 231 | .def_cfa_sf => {}, |
| | 232 | .def_cfa_offset_sf => {}, |
| | 233 | .val_offset => {}, |
| | 234 | .val_offset_sf => {}, |
| | 235 | .val_expression => {}, |
| | 236 | } |
| | 237 | } |
| | 238 | |
| | 239 | }; |
| | 240 | |
| | 241 | |
| | 242 | fn formatOffset(data: i64, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void { |
| | 243 | _ = fmt; |
| | 244 | if (data >= 0) try writer.writeByte('+'); |
| | 245 | return std.fmt.formatInt(data, 10, .lower, options, writer); |
| | 246 | } |
| | 247 | |
| | 248 | fn fmtOffset(offset: i64) std.fmt.Formatter(formatOffset) { |
| | 249 | return .{ .data = offset }; |
| | 250 | } |
| | 251 | |
| | 252 | /// See section 6.4.1 of the DWARF5 specification |
| | 253 | pub const VirtualMachine = struct { |
| | 254 | |
| | 255 | const RegisterRule = union(enum) { |
| | 256 | undefined: void, |
| | 257 | same_value: void, |
| | 258 | offset: i64, |
| | 259 | val_offset: i64, |
| | 260 | register: u8, |
| | 261 | expression: []const u8, |
| | 262 | val_expression: []const u8, |
| | 263 | architectural: void, |
| | 264 | }; |
| | 265 | |
| | 266 | const Column = struct { |
| | 267 | register: u8 = undefined, |
| | 268 | rule: RegisterRule = .{ .undefined = {} }, |
| | 269 | |
| | 270 | pub fn writeRule(self: Column, writer: anytype, is_cfa: bool, arch: ?std.Target.Cpu.Arch) !void { |
| | 271 | if (is_cfa) { |
| | 272 | try writer.writeAll("CFA"); |
| | 273 | } else { |
| | 274 | try abi.writeRegisterName(writer, arch, self.register); |
| | 275 | } |
| | 276 | |
| | 277 | try writer.writeByte('='); |
| | 278 | switch (self.rule) { |
| | 279 | .undefined => {}, |
| | 280 | .same_value => try writer.writeAll("S"), |
| | 281 | .offset => |offset| { |
| | 282 | if (is_cfa) { |
| | 283 | try abi.writeRegisterName(writer, arch, self.register); |
| | 284 | try writer.print("{}", .{ fmtOffset(offset) }); |
| | 285 | } else { |
| | 286 | try writer.print("[CFA{}]", .{ fmtOffset(offset) }); |
| | 287 | } |
| | 288 | }, |
| | 289 | .val_offset => |offset| { |
| | 290 | if (is_cfa) { |
| | 291 | try abi.writeRegisterName(writer, arch, self.register); |
| | 292 | try writer.print("{}", .{ fmtOffset(offset) }); |
| | 293 | } else { |
| | 294 | try writer.print("CFA{}", .{ fmtOffset(offset) }); |
| | 295 | } |
| | 296 | }, |
| | 297 | .register => |register| try abi.writeRegisterName(writer, arch, register), |
| | 298 | .expression => try writer.writeAll("TODO(expression)"), |
| | 299 | .val_expression => try writer.writeAll("TODO(val_expression)"), |
| | 300 | .architectural => try writer.writeAll("TODO(architectural)"), |
| | 301 | } |
| | 302 | } |
| | 303 | }; |
| | 304 | |
| | 305 | pub const Row = struct { |
| | 306 | /// Offset from pc_begin |
| | 307 | offset: u64 = 0, |
| | 308 | cfa: Column = .{}, |
| | 309 | /// Index into `columns` of the first column in this row |
| | 310 | columns_start: usize = undefined, |
| | 311 | columns_len: u8 = 0, |
| | 312 | }; |
| | 313 | |
| | 314 | rows: std.ArrayListUnmanaged(Row) = .{}, |
| | 315 | columns: std.ArrayListUnmanaged(Column) = .{}, |
| | 316 | current_row: Row = .{}, |
| | 317 | |
| | 318 | pub fn reset(self: *VirtualMachine) void { |
| | 319 | self.rows.clearRetainingCapacity(); |
| | 320 | self.columns.clearRetainingCapacity(); |
| | 321 | self.current_row = .{}; |
| | 322 | } |
| | 323 | |
| | 324 | pub fn deinit(self: *VirtualMachine, allocator: std.mem.Allocator) void { |
| | 325 | self.rows.deinit(allocator); |
| | 326 | self.columns.deinit(allocator); |
| | 327 | self.* = undefined; |
| | 328 | } |
| | 329 | |
| | 330 | pub fn getColumns(self: VirtualMachine, row: Row) []Column { |
| | 331 | return self.columns.items[row.columns_start..][0..row.columns_len]; |
| | 332 | } |
| | 333 | |
| | 334 | fn getOrAddColumn(self: *VirtualMachine, allocator: std.mem.Allocator, register: u8) !*Column { |
| | 335 | for (self.getColumns(self.current_row)) |*c| { |
| | 336 | if (c.register == register) return c; |
| | 337 | } |
| | 338 | |
| | 339 | if (self.current_row.columns_len == 0) { |
| | 340 | self.current_row.columns_start = self.columns.items.len; |
| | 341 | } |
| | 342 | self.current_row.columns_len += 1; |
| | 343 | |
| | 344 | const column = try self.columns.addOne(allocator); |
| | 345 | column.* = .{ |
| | 346 | .register = register, |
| | 347 | }; |
| | 348 | |
| | 349 | return column; |
| | 350 | } |
| | 351 | |
| | 352 | pub fn step(self: *VirtualMachine, allocator: std.mem.Allocator, cie: dwarf.CommonInformationEntry, instruction: Instruction) !void { |
| | 353 | switch (instruction) { |
| | 354 | inline .advance_loc, .advance_loc1, .advance_loc2, .advance_loc4 => |i| { |
| | 355 | self.current_row.offset += i.operands.delta; |
| | 356 | }, |
| | 357 | .offset => |i| { |
| | 358 | const column = try self.getOrAddColumn(allocator, i.operands.register); |
| | 359 | column.rule = .{ .offset = @intCast(i64, i.operands.offset) * cie.data_alignment_factor }; |
| | 360 | }, |
| | 361 | .restore => {}, |
| | 362 | .nop => {}, |
| | 363 | .set_loc => {}, |
| | 364 | .offset_extended => {}, |
| | 365 | .restore_extended => {}, |
| | 366 | .undefined => {}, |
| | 367 | .same_value => {}, |
| | 368 | .register => {}, |
| | 369 | .remember_state => {}, |
| | 370 | .restore_state => {}, |
| | 371 | .def_cfa => |i| { |
| | 372 | self.current_row.cfa = .{ |
| | 373 | .register = i.operands.register, |
| | 374 | .rule = .{ .offset = @intCast(i64, i.operands.offset) }, |
| | 375 | }; |
| | 376 | }, |
| | 377 | .def_cfa_register => {}, |
| | 378 | .def_cfa_offset => |i| { |
| | 379 | self.current_row.cfa.rule = .{ |
| | 380 | .offset = @intCast(i64, i.operands.offset) |
| | 381 | }; |
| 226 | }, | 382 | }, |
| | 383 | .def_cfa_expression => {}, |
| 227 | .expression => {}, | 384 | .expression => {}, |
| 228 | .offset_extended_sf => {}, | 385 | .offset_extended_sf => {}, |
| 229 | .def_cfa_sf => {}, | 386 | .def_cfa_sf => {}, |
Casey Banner <kcbanner@gmail.com> 2023-05-08 02:28:39-04:00
lib