diff --git a/lib/std/debug.zig b/lib/std/debug.zig index b600f7245a..c6ee812c19 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -30,10 +30,8 @@ pub const LineInfo = struct { line: u64, column: u64, file_name: []const u8, - allocator: ?mem.Allocator, - pub fn deinit(self: LineInfo) void { - const allocator = self.allocator orelse return; + pub fn deinit(self: LineInfo, allocator: mem.Allocator) void { allocator.free(self.file_name); } }; @@ -43,9 +41,9 @@ pub const SymbolInfo = struct { compile_unit_name: []const u8 = "???", line_info: ?LineInfo = null, - pub fn deinit(self: @This()) void { + pub fn deinit(self: @This(), allocator: mem.Allocator) void { if (self.line_info) |li| { - li.deinit(); + li.deinit(allocator); } } }; @@ -695,7 +693,7 @@ pub fn printSourceAtAddress(debug_info: *DebugInfo, out_stream: anytype, address }; const symbol_info = try module.getSymbolAtAddress(address); - defer symbol_info.deinit(); + defer symbol_info.deinit(debug_info.allocator); return printLineInfo( out_stream, @@ -1568,10 +1566,17 @@ pub const ModuleDebugInfo = switch (native_os) { if (o_file_di.findCompileUnit(relocated_address_o)) |compile_unit| { return SymbolInfo{ .symbol_name = o_file_di.getSymbolName(relocated_address_o) orelse "???", - .compile_unit_name = compile_unit.die.getAttrString(o_file_di, DW.AT.name) catch |err| switch (err) { + .compile_unit_name = compile_unit.die.getAttrString( + o_file_di, + DW.AT.name, + ) catch |err| switch (err) { error.MissingDebugInfo, error.InvalidDebugInfo => "???", }, - .line_info = o_file_di.getLineNumberInfo(compile_unit.*, relocated_address_o + addr_off) catch |err| switch (err) { + .line_info = o_file_di.getLineNumberInfo( + self.allocator(), + compile_unit.*, + relocated_address_o + addr_off, + ) catch |err| switch (err) { error.MissingDebugInfo, error.InvalidDebugInfo => null, else => return err, }, diff --git a/lib/std/dwarf.zig b/lib/std/dwarf.zig index 506f9eeef8..ac7cdc761c 100644 --- a/lib/std/dwarf.zig +++ b/lib/std/dwarf.zig @@ -7,8 +7,6 @@ const mem = std.mem; const math = std.math; const leb = @import("leb128.zig"); -const ArrayList = std.ArrayList; - pub const TAG = @import("dwarf/TAG.zig"); pub const AT = @import("dwarf/AT.zig"); pub const OP = @import("dwarf/OP.zig"); @@ -157,6 +155,12 @@ const PcRange = struct { const Func = struct { pc_range: ?PcRange, name: ?[]const u8, + + fn deinit(func: *Func, allocator: mem.Allocator) void { + if (func.name) |name| { + allocator.free(name); + } + } }; const CompileUnit = struct { @@ -166,19 +170,30 @@ const CompileUnit = struct { pc_range: ?PcRange, }; -const AbbrevTable = ArrayList(AbbrevTableEntry); +const AbbrevTable = std.ArrayList(AbbrevTableEntry); const AbbrevTableHeader = struct { // offset from .debug_abbrev offset: u64, table: AbbrevTable, + + fn deinit(header: *AbbrevTableHeader) void { + for (header.table.items) |*entry| { + entry.deinit(); + } + header.table.deinit(); + } }; const AbbrevTableEntry = struct { has_children: bool, abbrev_code: u64, tag_id: u64, - attrs: ArrayList(AbbrevAttr), + attrs: std.ArrayList(AbbrevAttr), + + fn deinit(entry: *AbbrevTableEntry) void { + entry.attrs.deinit(); + } }; const AbbrevAttr = struct { @@ -213,15 +228,22 @@ const Constant = struct { }; const Die = struct { + // Arena for Die's Attr's and FormValue's. + arena: std.heap.ArenaAllocator, tag_id: u64, has_children: bool, - attrs: ArrayList(Attr), + attrs: std.ArrayListUnmanaged(Attr) = .{}, const Attr = struct { id: u64, value: FormValue, }; + fn deinit(self: *Die, allocator: mem.Allocator) void { + self.arena.deinit(); + self.attrs.deinit(allocator); + } + fn getAttr(self: *const Die, id: u64) ?*const FormValue { for (self.attrs.items) |*attr| { if (attr.id == id) return &attr.value; @@ -292,7 +314,6 @@ const LineNumberProgram = struct { default_is_stmt: bool, target_address: u64, include_dirs: []const []const u8, - file_entries: *ArrayList(FileEntry), prev_valid: bool, prev_address: u64, @@ -323,7 +344,7 @@ const LineNumberProgram = struct { self.prev_end_sequence = undefined; } - pub fn init(is_stmt: bool, include_dirs: []const []const u8, file_entries: *ArrayList(FileEntry), target_address: u64) LineNumberProgram { + pub fn init(is_stmt: bool, include_dirs: []const []const u8, target_address: u64) LineNumberProgram { return LineNumberProgram{ .address = 0, .file = 1, @@ -333,7 +354,6 @@ const LineNumberProgram = struct { .basic_block = false, .end_sequence = false, .include_dirs = include_dirs, - .file_entries = file_entries, .default_is_stmt = is_stmt, .target_address = target_address, .prev_valid = false, @@ -347,24 +367,28 @@ const LineNumberProgram = struct { }; } - pub fn checkLineMatch(self: *LineNumberProgram) !?debug.LineInfo { + pub fn checkLineMatch( + self: *LineNumberProgram, + allocator: mem.Allocator, + file_entries: []const FileEntry, + ) !?debug.LineInfo { if (self.prev_valid and self.target_address >= self.prev_address and self.target_address < self.address) { const file_entry = if (self.prev_file == 0) { return error.MissingDebugInfo; - } else if (self.prev_file - 1 >= self.file_entries.items.len) { + } else if (self.prev_file - 1 >= file_entries.len) { return error.InvalidDebugInfo; - } else &self.file_entries.items[self.prev_file - 1]; + } else &file_entries[self.prev_file - 1]; const dir_name = if (file_entry.dir_index >= self.include_dirs.len) { return error.InvalidDebugInfo; } else self.include_dirs[file_entry.dir_index]; - const file_name = try fs.path.join(self.file_entries.allocator, &[_][]const u8{ dir_name, file_entry.file_name }); - errdefer self.file_entries.allocator.free(file_name); + + const file_name = try fs.path.join(allocator, &[_][]const u8{ dir_name, file_entry.file_name }); + return debug.LineInfo{ .line = if (self.prev_line >= 0) @intCast(u64, self.prev_line) else 0, .column = self.prev_column, .file_name = file_name, - .allocator = self.file_entries.allocator, }; } @@ -419,8 +443,7 @@ fn parseFormValueBlock(allocator: mem.Allocator, in_stream: anytype, endian: std return parseFormValueBlockLen(allocator, in_stream, block_len); } -fn parseFormValueConstant(allocator: mem.Allocator, in_stream: anytype, signed: bool, endian: std.builtin.Endian, comptime size: i32) !FormValue { - _ = allocator; +fn parseFormValueConstant(in_stream: anytype, signed: bool, endian: std.builtin.Endian, comptime size: i32) !FormValue { // TODO: Please forgive me, I've worked around zig not properly spilling some intermediate values here. // `nosuspend` should be removed from all the function calls once it is fixed. return FormValue{ @@ -447,8 +470,7 @@ fn parseFormValueConstant(allocator: mem.Allocator, in_stream: anytype, signed: } // TODO the nosuspends here are workarounds -fn parseFormValueRef(allocator: mem.Allocator, in_stream: anytype, endian: std.builtin.Endian, size: i32) !FormValue { - _ = allocator; +fn parseFormValueRef(in_stream: anytype, endian: std.builtin.Endian, size: i32) !FormValue { return FormValue{ .Ref = switch (size) { 1 => try nosuspend in_stream.readInt(u8, endian), @@ -472,13 +494,13 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en const block_len = try nosuspend leb.readULEB128(usize, in_stream); return parseFormValueBlockLen(allocator, in_stream, block_len); }, - FORM.data1 => parseFormValueConstant(allocator, in_stream, false, endian, 1), - FORM.data2 => parseFormValueConstant(allocator, in_stream, false, endian, 2), - FORM.data4 => parseFormValueConstant(allocator, in_stream, false, endian, 4), - FORM.data8 => parseFormValueConstant(allocator, in_stream, false, endian, 8), + FORM.data1 => parseFormValueConstant(in_stream, false, endian, 1), + FORM.data2 => parseFormValueConstant(in_stream, false, endian, 2), + FORM.data4 => parseFormValueConstant(in_stream, false, endian, 4), + FORM.data8 => parseFormValueConstant(in_stream, false, endian, 8), FORM.udata, FORM.sdata => { const signed = form_id == FORM.sdata; - return parseFormValueConstant(allocator, in_stream, signed, endian, -1); + return parseFormValueConstant(in_stream, signed, endian, -1); }, FORM.exprloc => { const size = try nosuspend leb.readULEB128(usize, in_stream); @@ -489,11 +511,11 @@ fn parseFormValue(allocator: mem.Allocator, in_stream: anytype, form_id: u64, en FORM.flag_present => FormValue{ .Flag = true }, FORM.sec_offset => FormValue{ .SecOffset = try readAddress(in_stream, endian, is_64) }, - FORM.ref1 => parseFormValueRef(allocator, in_stream, endian, 1), - FORM.ref2 => parseFormValueRef(allocator, in_stream, endian, 2), - FORM.ref4 => parseFormValueRef(allocator, in_stream, endian, 4), - FORM.ref8 => parseFormValueRef(allocator, in_stream, endian, 8), - FORM.ref_udata => parseFormValueRef(allocator, in_stream, endian, -1), + FORM.ref1 => parseFormValueRef(in_stream, endian, 1), + FORM.ref2 => parseFormValueRef(in_stream, endian, 2), + FORM.ref4 => parseFormValueRef(in_stream, endian, 4), + FORM.ref8 => parseFormValueRef(in_stream, endian, 8), + FORM.ref_udata => parseFormValueRef(in_stream, endian, -1), FORM.ref_addr => FormValue{ .RefAddr = try readAddress(in_stream, endian, is_64) }, FORM.ref_sig8 => FormValue{ .Ref = try nosuspend in_stream.readInt(u64, endian) }, @@ -536,12 +558,24 @@ pub const DwarfInfo = struct { debug_line_str: ?[]const u8, debug_ranges: ?[]const u8, // Filled later by the initializer - abbrev_table_list: ArrayList(AbbrevTableHeader) = undefined, - compile_unit_list: ArrayList(CompileUnit) = undefined, - func_list: ArrayList(Func) = undefined, + abbrev_table_list: std.ArrayListUnmanaged(AbbrevTableHeader) = .{}, + compile_unit_list: std.ArrayListUnmanaged(CompileUnit) = .{}, + func_list: std.ArrayListUnmanaged(Func) = .{}, - pub fn allocator(self: DwarfInfo) mem.Allocator { - return self.abbrev_table_list.allocator; + pub fn deinit(di: *DwarfInfo, allocator: mem.Allocator) void { + for (di.abbrev_table_list.items) |*abbrev| { + abbrev.deinit(); + } + di.abbrev_table_list.deinit(allocator); + for (di.compile_unit_list.items) |*cu| { + cu.die.deinit(allocator); + allocator.destroy(cu.die); + } + di.compile_unit_list.deinit(allocator); + for (di.func_list.items) |*func| { + func.deinit(allocator); + } + di.func_list.deinit(allocator); } pub fn getSymbolName(di: *DwarfInfo, address: u64) ?[]const u8 { @@ -556,12 +590,16 @@ pub const DwarfInfo = struct { return null; } - fn scanAllFunctions(di: *DwarfInfo) !void { + fn scanAllFunctions(di: *DwarfInfo, allocator: mem.Allocator) !void { var stream = io.fixedBufferStream(di.debug_info); const in = &stream.reader(); const seekable = &stream.seekableStream(); var this_unit_offset: u64 = 0; + var tmp_arena = std.heap.ArenaAllocator.init(allocator); + defer tmp_arena.deinit(); + const arena = tmp_arena.allocator(); + while (this_unit_offset < try seekable.getEndPos()) { try seekable.seekTo(this_unit_offset); @@ -580,26 +618,30 @@ pub const DwarfInfo = struct { const unit_type = try in.readInt(u8, di.endian); if (unit_type != UT.compile) return error.InvalidDebugInfo; address_size = try in.readByte(); - debug_abbrev_offset = if (is_64) try in.readInt(u64, di.endian) else try in.readInt(u32, di.endian); + debug_abbrev_offset = if (is_64) + try in.readInt(u64, di.endian) + else + try in.readInt(u32, di.endian); }, else => { - debug_abbrev_offset = if (is_64) try in.readInt(u64, di.endian) else try in.readInt(u32, di.endian); + debug_abbrev_offset = if (is_64) + try in.readInt(u64, di.endian) + else + try in.readInt(u32, di.endian); address_size = try in.readByte(); }, } if (address_size != @sizeOf(usize)) return error.InvalidDebugInfo; const compile_unit_pos = try seekable.getPos(); - const abbrev_table = try di.getAbbrevTable(debug_abbrev_offset); + const abbrev_table = try di.getAbbrevTable(allocator, debug_abbrev_offset); try seekable.seekTo(compile_unit_pos); const next_unit_pos = this_unit_offset + next_offset; while ((try seekable.getPos()) < next_unit_pos) { - const die_obj = (try di.parseDie(in, abbrev_table, is_64)) orelse continue; - defer die_obj.attrs.deinit(); - + const die_obj = (try di.parseDie(arena, in, abbrev_table, is_64)) orelse continue; const after_die_offset = try seekable.getPos(); switch (die_obj.tag_id) { @@ -607,23 +649,33 @@ pub const DwarfInfo = struct { const fn_name = x: { var depth: i32 = 3; var this_die_obj = die_obj; - // Prenvent endless loops + // Prevent endless loops while (depth > 0) : (depth -= 1) { if (this_die_obj.getAttr(AT.name)) |_| { const name = try this_die_obj.getAttrString(di, AT.name); - break :x name; + break :x try allocator.dupe(u8, name); } else if (this_die_obj.getAttr(AT.abstract_origin)) |_| { // Follow the DIE it points to and repeat const ref_offset = try this_die_obj.getAttrRef(AT.abstract_origin); if (ref_offset > next_offset) return error.InvalidDebugInfo; try seekable.seekTo(this_unit_offset + ref_offset); - this_die_obj = (try di.parseDie(in, abbrev_table, is_64)) orelse return error.InvalidDebugInfo; + this_die_obj = (try di.parseDie( + arena, + in, + abbrev_table, + is_64, + )) orelse return error.InvalidDebugInfo; } else if (this_die_obj.getAttr(AT.specification)) |_| { // Follow the DIE it points to and repeat const ref_offset = try this_die_obj.getAttrRef(AT.specification); if (ref_offset > next_offset) return error.InvalidDebugInfo; try seekable.seekTo(this_unit_offset + ref_offset); - this_die_obj = (try di.parseDie(in, abbrev_table, is_64)) orelse return error.InvalidDebugInfo; + this_die_obj = (try di.parseDie( + arena, + in, + abbrev_table, + is_64, + )) orelse return error.InvalidDebugInfo; } else { break :x null; } @@ -656,7 +708,7 @@ pub const DwarfInfo = struct { } }; - try di.func_list.append(Func{ + try di.func_list.append(allocator, Func{ .name = fn_name, .pc_range = pc_range, }); @@ -671,7 +723,7 @@ pub const DwarfInfo = struct { } } - fn scanAllCompileUnits(di: *DwarfInfo) !void { + fn scanAllCompileUnits(di: *DwarfInfo, allocator: mem.Allocator) !void { var stream = io.fixedBufferStream(di.debug_info); const in = &stream.reader(); const seekable = &stream.seekableStream(); @@ -695,22 +747,30 @@ pub const DwarfInfo = struct { const unit_type = try in.readInt(u8, di.endian); if (unit_type != UT.compile) return error.InvalidDebugInfo; address_size = try in.readByte(); - debug_abbrev_offset = if (is_64) try in.readInt(u64, di.endian) else try in.readInt(u32, di.endian); + debug_abbrev_offset = if (is_64) + try in.readInt(u64, di.endian) + else + try in.readInt(u32, di.endian); }, else => { - debug_abbrev_offset = if (is_64) try in.readInt(u64, di.endian) else try in.readInt(u32, di.endian); + debug_abbrev_offset = if (is_64) + try in.readInt(u64, di.endian) + else + try in.readInt(u32, di.endian); address_size = try in.readByte(); }, } if (address_size != @sizeOf(usize)) return error.InvalidDebugInfo; const compile_unit_pos = try seekable.getPos(); - const abbrev_table = try di.getAbbrevTable(debug_abbrev_offset); + const abbrev_table = try di.getAbbrevTable(allocator, debug_abbrev_offset); try seekable.seekTo(compile_unit_pos); - const compile_unit_die = try di.allocator().create(Die); - compile_unit_die.* = (try di.parseDie(in, abbrev_table, is_64)) orelse return error.InvalidDebugInfo; + const compile_unit_die = try allocator.create(Die); + errdefer allocator.destroy(compile_unit_die); + compile_unit_die.* = (try di.parseDie(allocator, in, abbrev_table, is_64)) orelse + return error.InvalidDebugInfo; if (compile_unit_die.tag_id != TAG.compile_unit) return error.InvalidDebugInfo; @@ -738,7 +798,7 @@ pub const DwarfInfo = struct { } }; - try di.compile_unit_list.append(CompileUnit{ + try di.compile_unit_list.append(allocator, CompileUnit{ .version = version, .is_64 = is_64, .pc_range = pc_range, @@ -797,27 +857,33 @@ pub const DwarfInfo = struct { /// Gets an already existing AbbrevTable given the abbrev_offset, or if not found, /// seeks in the stream and parses it. - fn getAbbrevTable(di: *DwarfInfo, abbrev_offset: u64) !*const AbbrevTable { + fn getAbbrevTable(di: *DwarfInfo, allocator: mem.Allocator, abbrev_offset: u64) !*const AbbrevTable { for (di.abbrev_table_list.items) |*header| { if (header.offset == abbrev_offset) { return &header.table; } } - try di.abbrev_table_list.append(AbbrevTableHeader{ + try di.abbrev_table_list.append(allocator, AbbrevTableHeader{ .offset = abbrev_offset, - .table = try di.parseAbbrevTable(abbrev_offset), + .table = try di.parseAbbrevTable(allocator, abbrev_offset), }); return &di.abbrev_table_list.items[di.abbrev_table_list.items.len - 1].table; } - fn parseAbbrevTable(di: *DwarfInfo, offset: u64) !AbbrevTable { + fn parseAbbrevTable(di: *DwarfInfo, allocator: mem.Allocator, offset: u64) !AbbrevTable { var stream = io.fixedBufferStream(di.debug_abbrev); const in = &stream.reader(); const seekable = &stream.seekableStream(); try seekable.seekTo(offset); - var result = AbbrevTable.init(di.allocator()); - errdefer result.deinit(); + var result = AbbrevTable.init(allocator); + errdefer { + for (result.items) |*entry| { + entry.attrs.deinit(); + } + result.deinit(); + } + while (true) { const abbrev_code = try leb.readULEB128(u64, in); if (abbrev_code == 0) return result; @@ -825,7 +891,7 @@ pub const DwarfInfo = struct { .abbrev_code = abbrev_code, .tag_id = try leb.readULEB128(u64, in), .has_children = (try in.readByte()) == CHILDREN.yes, - .attrs = ArrayList(AbbrevAttr).init(di.allocator()), + .attrs = std.ArrayList(AbbrevAttr).init(allocator), }); const attrs = &result.items[result.items.len - 1].attrs; @@ -844,21 +910,34 @@ pub const DwarfInfo = struct { } } - fn parseDie(di: *DwarfInfo, in_stream: anytype, abbrev_table: *const AbbrevTable, is_64: bool) !?Die { + fn parseDie( + di: *DwarfInfo, + allocator: mem.Allocator, + in_stream: anytype, + abbrev_table: *const AbbrevTable, + is_64: bool, + ) !?Die { const abbrev_code = try leb.readULEB128(u64, in_stream); if (abbrev_code == 0) return null; const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return error.InvalidDebugInfo; var result = Die{ + // Lives as long as the Die. + .arena = std.heap.ArenaAllocator.init(allocator), .tag_id = table_entry.tag_id, .has_children = table_entry.has_children, - .attrs = ArrayList(Die.Attr).init(di.allocator()), }; - try result.attrs.resize(table_entry.attrs.items.len); + try result.attrs.resize(allocator, table_entry.attrs.items.len); for (table_entry.attrs.items) |attr, i| { result.attrs.items[i] = Die.Attr{ .id = attr.attr_id, - .value = try parseFormValue(di.allocator(), in_stream, attr.form_id, di.endian, is_64), + .value = try parseFormValue( + result.arena.allocator(), + in_stream, + attr.form_id, + di.endian, + is_64, + ), }; if (attr.form_id == FORM.implicit_const) { result.attrs.items[i].value.Const.payload = @bitCast(u64, attr.payload); @@ -867,7 +946,12 @@ pub const DwarfInfo = struct { return result; } - pub fn getLineNumberInfo(di: *DwarfInfo, compile_unit: CompileUnit, target_address: u64) !debug.LineInfo { + pub fn getLineNumberInfo( + di: *DwarfInfo, + allocator: mem.Allocator, + compile_unit: CompileUnit, + target_address: u64, + ) !debug.LineInfo { var stream = io.fixedBufferStream(di.debug_line); const in = &stream.reader(); const seekable = &stream.seekableStream(); @@ -906,8 +990,8 @@ pub const DwarfInfo = struct { const opcode_base = try in.readByte(); - const standard_opcode_lengths = try di.allocator().alloc(u8, opcode_base - 1); - defer di.allocator().free(standard_opcode_lengths); + const standard_opcode_lengths = try allocator.alloc(u8, opcode_base - 1); + defer allocator.free(standard_opcode_lengths); { var i: usize = 0; @@ -916,19 +1000,28 @@ pub const DwarfInfo = struct { } } - var include_directories = ArrayList([]const u8).init(di.allocator()); + var tmp_arena = std.heap.ArenaAllocator.init(allocator); + defer tmp_arena.deinit(); + const arena = tmp_arena.allocator(); + + var include_directories = std.ArrayList([]const u8).init(arena); try include_directories.append(compile_unit_cwd); + while (true) { - const dir = try in.readUntilDelimiterAlloc(di.allocator(), 0, math.maxInt(usize)); + const dir = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize)); if (dir.len == 0) break; try include_directories.append(dir); } - var file_entries = ArrayList(FileEntry).init(di.allocator()); - var prog = LineNumberProgram.init(default_is_stmt, include_directories.items, &file_entries, target_address); + var file_entries = std.ArrayList(FileEntry).init(arena); + var prog = LineNumberProgram.init( + default_is_stmt, + include_directories.items, + target_address, + ); while (true) { - const file_name = try in.readUntilDelimiterAlloc(di.allocator(), 0, math.maxInt(usize)); + const file_name = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize)); if (file_name.len == 0) break; const dir_index = try leb.readULEB128(usize, in); const mtime = try leb.readULEB128(usize, in); @@ -955,7 +1048,7 @@ pub const DwarfInfo = struct { switch (sub_op) { LNE.end_sequence => { prog.end_sequence = true; - if (try prog.checkLineMatch()) |info| return info; + if (try prog.checkLineMatch(allocator, file_entries.items)) |info| return info; prog.reset(); }, LNE.set_address => { @@ -963,7 +1056,7 @@ pub const DwarfInfo = struct { prog.address = addr; }, LNE.define_file => { - const file_name = try in.readUntilDelimiterAlloc(di.allocator(), 0, math.maxInt(usize)); + const file_name = try in.readUntilDelimiterAlloc(arena, 0, math.maxInt(usize)); const dir_index = try leb.readULEB128(usize, in); const mtime = try leb.readULEB128(usize, in); const len_bytes = try leb.readULEB128(usize, in); @@ -986,12 +1079,12 @@ pub const DwarfInfo = struct { const inc_line = @as(i32, line_base) + @as(i32, adjusted_opcode % line_range); prog.line += inc_line; prog.address += inc_addr; - if (try prog.checkLineMatch()) |info| return info; + if (try prog.checkLineMatch(allocator, file_entries.items)) |info| return info; prog.basic_block = false; } else { switch (opcode) { LNS.copy => { - if (try prog.checkLineMatch()) |info| return info; + if (try prog.checkLineMatch(allocator, file_entries.items)) |info| return info; prog.basic_block = false; }, LNS.advance_pc => { @@ -1068,13 +1161,8 @@ pub const DwarfInfo = struct { }; /// Initialize DWARF info. The caller has the responsibility to initialize most -/// the DwarfInfo fields before calling. These fields can be left undefined: -/// * abbrev_table_list -/// * compile_unit_list +/// the DwarfInfo fields before calling. pub fn openDwarfDebugInfo(di: *DwarfInfo, allocator: mem.Allocator) !void { - di.abbrev_table_list = ArrayList(AbbrevTableHeader).init(allocator); - di.compile_unit_list = ArrayList(CompileUnit).init(allocator); - di.func_list = ArrayList(Func).init(allocator); - try di.scanAllFunctions(); - try di.scanAllCompileUnits(); + try di.scanAllFunctions(allocator); + try di.scanAllCompileUnits(allocator); } diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig index c8ebb4b8b5..6bbc8cd9a4 100644 --- a/src/link/MachO/Object.zig +++ b/src/link/MachO/Object.zig @@ -131,9 +131,7 @@ const DebugInfo = struct { allocator.free(self.debug_line); allocator.free(self.debug_line_str); allocator.free(self.debug_ranges); - self.inner.abbrev_table_list.deinit(); - self.inner.compile_unit_list.deinit(); - self.inner.func_list.deinit(); + self.inner.deinit(allocator); } };