// SPDX-License-Identifier: MPL-2.0 // (c) Hare authors use errors; use debug::image; use format::elf; use io; use memio; def INFO_VERSION: u16 = 4; export type debug_info_reader = struct { image: *image::image, abbrev: abbrev_table, strings: (string_table | void), mem: *memio::stream, rd: *table_reader, }; // Reads the debug info from a DWARF image. Returns a [[debug_info_reader]], // call [[debug_info_next]] to retrieve the next DIE. // // Pass the return value to [[debug_info_finish]] after you're done with it. export fn read_debug_info( image: *image::image, offs: u64, ) (debug_info_reader | void | io::error | nomem) = { const sec = match (image::section_byname(image, ".debug_info")) { case let sec: *elf::section64 => yield sec; case null => return; }; let ok = false; const memrd = alloc(image::section_reader(image, sec))?; defer if (!ok) free(memrd); io::seek(memrd, offs: io::off, io::whence::SET)?; const rd = match (new_table_reader(memrd, true)) { case let rd: table_reader => yield alloc(rd)?; case io::EOF => return; }; defer if (!ok) free(rd); const ver = read_uhalf(rd)!; const abbrev_offs = read_secword(rd)!; const asize = read_ubyte(rd)!; assert(ver <= INFO_VERSION, "debug::dwarf: unsupported .debug_info version"); assert(asize == 8, "debug::dwarf: unsupported address size in .debug_info"); const abbrevs = match (load_abbrevs(image, abbrev_offs)?) { case let tab: abbrev_table => yield tab; case void => return; }; ok = true; return debug_info_reader { image = image, abbrev = abbrevs, strings = load_strings(image)?, mem = memrd, rd = rd, }; }; // Returns the next debug info [[entry]] (DIE) from a [[debug_info_reader]]. // Pass the return value to [[entry_finish]] when done. export fn debug_info_next(di: *debug_info_reader) (entry | io::EOF | nomem) = { if (read_iseof(di.rd)) { return io::EOF; }; let code = read_uleb128(di.rd)!; for (code == 0) { if (read_iseof(di.rd)) { return io::EOF; }; code = read_uleb128(di.rd)!; }; const ref = get_abbrev(&di.abbrev, code); assert(ref != null, "debug::dwarf: unknown abbreviated tag"); match (read_die(di, di.rd, ref as *abbrev)) { case io::error => abort(); case nomem => return nomem; case let ent: entry => return ent; }; }; // Frees resources associated with a [[debug_info_reader]]. export fn debug_info_finish(di: *debug_info_reader) void = { free(di.mem); free(di.rd); }; // A debug entry. export type entry = struct { tag: u32, children: bool, fields: []field, }; // Frees resources associated with an [[entry]]. export fn entry_finish(ent: *entry) void = { free(ent.fields); }; // A debug [[entry]] field. export type field = struct { attr: u32, form: u32, union { address: uintptr, block: []u8, constant: u64, string: const str, flag: bool, reference: u64, exprloc: []u8, ptr: u64, }, }; fn read_die( ir: *debug_info_reader, rd: *table_reader, abbrev: *abbrev, ) (entry | io::error) = { let fields: []field = []; let ok = false; defer if (!ok) { fields = []; free(fields); }; for (const abf &.. abbrev.fields) { let field = field { attr = abf.attr, form = abf.form, ... }; let form = abf.form; for (form == DW_FORM_indirect) { form = read_uleb128(rd)?: u32; }; // NOTE: Only supports up to DWARF 4 forms for now switch (form) { case DW_FORM_addr => field.address = read_ulong(rd)?: uintptr; case DW_FORM_block => field.block = read_slice(rd, read_uleb128(rd)?)?; case DW_FORM_block1 => field.block = read_slice(rd, read_ubyte(rd)?)?; case DW_FORM_block2 => field.block = read_slice(rd, read_uhalf(rd)?)?; case DW_FORM_block4 => field.block = read_slice(rd, read_uword(rd)?)?; case DW_FORM_data1 => field.constant = read_ubyte(rd)?; case DW_FORM_data2 => field.constant = read_uhalf(rd)?; case DW_FORM_data4 => field.constant = read_uword(rd)?; case DW_FORM_data8 => field.constant = read_ulong(rd)?; case DW_FORM_udata => field.constant = read_uleb128(rd)?; case DW_FORM_sdata => field.constant = read_sleb128(rd)?: u64; case DW_FORM_string => field.string = read_string(rd)?; case DW_FORM_strp => // TODO: Look up in .debug_strings const offs = read_secword(rd)?; match (ir.strings) { case let tab: string_table => field.string = get_strp(&tab, offs); case void => field.string = "(unknown)"; }; case DW_FORM_flag => field.flag = read_ubyte(rd)? != 0; case DW_FORM_flag_present => field.flag = true; case DW_FORM_ref_addr => field.reference = read_secword(rd)?; case DW_FORM_ref1 => field.reference = read_ubyte(rd)?; case DW_FORM_ref2 => field.reference = read_uhalf(rd)?; case DW_FORM_ref4 => field.reference = read_uword(rd)?; case DW_FORM_ref8 => field.reference = read_ulong(rd)?; case DW_FORM_ref_udata => field.reference = read_uleb128(rd)?; case DW_FORM_ref_sig8 => field.reference = read_ulong(rd)?; case DW_FORM_sec_offset => field.reference = read_secword(rd)?; case DW_FORM_exprloc => field.exprloc = read_slice(rd, read_uleb128(rd)?)?; case DW_FORM_indirect => abort(); case => return errors::unsupported; }; append(fields, field)?; }; ok = true; return entry { tag = abbrev.tag, children = abbrev.has_children, fields = fields, }; };