// SPDX-License-Identifier: MPL-2.0 // (c) Hare authors use bufio; use endian; use errors; use io; use memio; use strings; use types; export type table_reader = struct { src: *memio::stream, orig_length: size, length: size, is64: bool, }; // Creates a new DWARF table reader. // // If "read_length" is true, this function will read the length from the start // of the table. Returns [[io::EOF]] immediately if there is insufficient data // available in the provided I/O handle. // // The reader will return [[io::underread]] if the DWARF table is truncated. fn new_table_reader( in: *memio::stream, read_length: bool, ) (table_reader | io::EOF | io::error) = { let rd = table_reader { src = in, orig_length = types::SIZE_MAX, length = types::SIZE_MAX, is64 = false, }; if (read_length) { const word = match (read_uword(&rd)) { case let uw: u32 => yield uw; case io::underread => return io::EOF; case let err: io::error => return err; }; if (word == 0xffffffff) { rd.is64 = true; const long = match (read_ulong(&rd)) { case let ul: u64 => yield ul; case let err: io::error => if (err is io::underread) { return io::EOF; }; return err; }; rd.length = long: size; } else if (word >= 0xfffffff0) { // Reserved value return errors::invalid; } else { rd.length = word: size; }; }; rd.orig_length = rd.length; return rd; }; fn read_iseof(rd: *table_reader) bool = rd.length == 0; fn read_advance(rd: *table_reader, nbyte: size) (void | io::error) = { if (rd.length < nbyte) { return 0: io::underread; }; rd.length -= nbyte; }; // Aligns the reader on a given alignment. This function is needed because both // binutils and LLVM inexplicably add padding to .debug_aranges to align the // first tuple on the address size * 2, despite the fact that this is mentioned // nowhere in the DWARF specification and in fact section 7.25 specifically // states that DWARF data is not aligned. It took me 6 hours to figure this out. fn read_align(rd: *table_reader, alignment: size) (void | io::error) = { let cur = rd.orig_length - rd.length + size(u32); if (rd.is64) { cur += size(u64); }; const offs = alignment - (cur % alignment); if (offs == 0) { return; }; let buf: [128]u8 = [0...]; io::readall(rd.src, buf[..offs])?; rd.length -= offs; }; // Returns the current location of the reader from the start of the section. fn read_tell(rd: *table_reader) size = { const offs = rd.orig_length - rd.length; if (rd.is64) { return offs + size(u32) + size(u64); } else { return offs + size(u32); }; }; fn read_sbyte(rd: *table_reader) (i8 | io::error) = { read_advance(rd, size(i8))?; match (bufio::read_byte(rd.src)?) { case let byte: u8 => return byte: i8; case io::EOF => return 0: io::underread; }; }; fn read_ubyte(rd: *table_reader) (u8 | io::error) = { read_advance(rd, size(u8))?; match (bufio::read_byte(rd.src)?) { case let byte: u8 => return byte; case io::EOF => return 0: io::underread; }; }; fn read_uhalf(rd: *table_reader) (u16 | io::error) = { read_advance(rd, size(u16))?; let buf: [size(u16)]u8 = [0...]; match (io::readall(rd.src, buf)?) { case io::EOF => return 0: io::underread; case size => return endian::host.getu16(buf); }; }; fn read_uword(rd: *table_reader) (u32 | io::error) = { read_advance(rd, size(u32))?; let buf: [size(u32)]u8 = [0...]; match (io::readall(rd.src, buf)?) { case io::EOF => return 0: io::underread; case size => return endian::host.getu32(buf); }; }; fn read_ulong(rd: *table_reader) (u64 | io::error) = { read_advance(rd, size(u64))?; let buf: [size(u64)]u8 = [0...]; match (io::readall(rd.src, buf)?) { case io::EOF => return 0u64: io::underread: io::error; case size => return endian::host.getu64(buf); }; }; fn read_secword(rd: *table_reader) (u64 | io::error) = { if (rd.is64) { return read_ulong(rd)?; } else { return read_uword(rd)?: u64; }; }; fn read_uleb128(rd: *table_reader) (u64 | io::error) = { let bits = 0u64, val = 0u64; for (true) { const x = read_ubyte(rd)?; val |= (x & ~0x80) << bits; if (x & 0x80 == 0) break; bits += 7; }; return val; }; fn read_sleb128(rd: *table_reader) (i64 | io::error) = { let bits = 0u64, uval = 0u64; for (true) { const x = read_ubyte(rd)?; uval |= (x & ~0x80) << bits; bits += 7; if (x & 0x80 == 0) break; }; let val = uval: i64; let bits = bits: i64; if (val & (1 << (bits-1)) != 0) { val |= -1 << bits; }; return val; }; // Borrowed from underlying source fn read_slice(rd: *table_reader, amt: size) ([]u8 | io::error) = { match (memio::borrowedread(rd.src, amt)) { case let sl: []u8 => rd.length -= len(sl); return sl; case io::EOF => return 0: io::underread; }; }; // Borrowed from underlying source fn read_string(rd: *table_reader) (const str | io::error) = { // XXX: Leaks, should probably borrow from memio match (bufio::read_tok(rd.src, 0)?) { case let data: []u8 => rd.length -= len(data) + 1; return strings::fromutf8(data)!; case io::EOF => return 0: io::underread; }; };