use crate::common::{ DebugAddrBase, DebugAddrIndex, DebugRngListsBase, DebugRngListsIndex, DwarfFileType, Encoding, RangeListsOffset, SectionId, }; use crate::constants; use crate::endianity::Endianity; use crate::read::{ lists::ListsHeader, DebugAddr, EndianSlice, Error, Reader, ReaderOffset, ReaderOffsetId, Result, Section, }; /// The raw contents of the `.debug_ranges` section. #[derive(Debug, Default, Clone, Copy)] pub struct DebugRanges { pub(crate) section: R, } impl<'input, Endian> DebugRanges> where Endian: Endianity, { /// Construct a new `DebugRanges` instance from the data in the `.debug_ranges` /// section. /// /// It is the caller's responsibility to read the `.debug_ranges` section and /// present it as a `&[u8]` slice. That means using some ELF loader on /// Linux, a Mach-O loader on macOS, etc. /// /// ``` /// use gimli::{DebugRanges, LittleEndian}; /// /// # let buf = [0x00, 0x01, 0x02, 0x03]; /// # let read_debug_ranges_section_somehow = || &buf; /// let debug_ranges = DebugRanges::new(read_debug_ranges_section_somehow(), LittleEndian); /// ``` pub fn new(section: &'input [u8], endian: Endian) -> Self { Self::from(EndianSlice::new(section, endian)) } } impl Section for DebugRanges { fn id() -> SectionId { SectionId::DebugRanges } fn reader(&self) -> &R { &self.section } } impl From for DebugRanges { fn from(section: R) -> Self { DebugRanges { section } } } /// The `DebugRngLists` struct represents the contents of the /// `.debug_rnglists` section. #[derive(Debug, Default, Clone, Copy)] pub struct DebugRngLists { section: R, } impl<'input, Endian> DebugRngLists> where Endian: Endianity, { /// Construct a new `DebugRngLists` instance from the data in the /// `.debug_rnglists` section. /// /// It is the caller's responsibility to read the `.debug_rnglists` /// section and present it as a `&[u8]` slice. That means using some ELF /// loader on Linux, a Mach-O loader on macOS, etc. /// /// ``` /// use gimli::{DebugRngLists, LittleEndian}; /// /// # let buf = [0x00, 0x01, 0x02, 0x03]; /// # let read_debug_rnglists_section_somehow = || &buf; /// let debug_rnglists = /// DebugRngLists::new(read_debug_rnglists_section_somehow(), LittleEndian); /// ``` pub fn new(section: &'input [u8], endian: Endian) -> Self { Self::from(EndianSlice::new(section, endian)) } } impl Section for DebugRngLists { fn id() -> SectionId { SectionId::DebugRngLists } fn reader(&self) -> &R { &self.section } } impl From for DebugRngLists { fn from(section: R) -> Self { DebugRngLists { section } } } #[allow(unused)] pub(crate) type RngListsHeader = ListsHeader; impl DebugRngListsBase where Offset: ReaderOffset, { /// Returns a `DebugRngListsBase` with the default value of DW_AT_rnglists_base /// for the given `Encoding` and `DwarfFileType`. pub fn default_for_encoding_and_file( encoding: Encoding, file_type: DwarfFileType, ) -> DebugRngListsBase { if encoding.version >= 5 && file_type == DwarfFileType::Dwo { // In .dwo files, the compiler omits the DW_AT_rnglists_base attribute (because there is // only a single unit in the file) but we must skip past the header, which the attribute // would normally do for us. DebugRngListsBase(Offset::from_u8(RngListsHeader::size_for_encoding(encoding))) } else { DebugRngListsBase(Offset::from_u8(0)) } } } /// The DWARF data found in `.debug_ranges` and `.debug_rnglists` sections. #[derive(Debug, Default, Clone, Copy)] pub struct RangeLists { debug_ranges: DebugRanges, debug_rnglists: DebugRngLists, } impl RangeLists { /// Construct a new `RangeLists` instance from the data in the `.debug_ranges` and /// `.debug_rnglists` sections. pub fn new(debug_ranges: DebugRanges, debug_rnglists: DebugRngLists) -> RangeLists { RangeLists { debug_ranges, debug_rnglists, } } /// Return the `.debug_ranges` section. pub fn debug_ranges(&self) -> &DebugRanges { &self.debug_ranges } /// Replace the `.debug_ranges` section. /// /// This is useful for `.dwo` files when using the GNU split-dwarf extension to DWARF 4. pub fn set_debug_ranges(&mut self, debug_ranges: DebugRanges) { self.debug_ranges = debug_ranges; } /// Return the `.debug_rnglists` section. pub fn debug_rnglists(&self) -> &DebugRngLists { &self.debug_rnglists } } impl RangeLists { /// Create a `RangeLists` that references the data in `self`. /// /// This is useful when `R` implements `Reader` but `T` does not. /// /// ## Example Usage /// /// ```rust,no_run /// # let load_section = || unimplemented!(); /// // Read the DWARF section into a `Vec` with whatever object loader you're using. /// let owned_section: gimli::RangeLists> = load_section(); /// // Create a reference to the DWARF section. /// let section = owned_section.borrow(|section| { /// gimli::EndianSlice::new(§ion, gimli::LittleEndian) /// }); /// ``` pub fn borrow<'a, F, R>(&'a self, mut borrow: F) -> RangeLists where F: FnMut(&'a T) -> R, { RangeLists { debug_ranges: borrow(&self.debug_ranges.section).into(), debug_rnglists: borrow(&self.debug_rnglists.section).into(), } } } impl RangeLists { /// Iterate over the `Range` list entries starting at the given offset. /// /// The `unit_version` and `address_size` must match the compilation unit that the /// offset was contained in. /// /// The `base_address` should be obtained from the `DW_AT_low_pc` attribute in the /// `DW_TAG_compile_unit` entry for the compilation unit that contains this range list. /// /// Can be [used with /// `FallibleIterator`](./index.html#using-with-fallibleiterator). pub fn ranges( &self, offset: RangeListsOffset, unit_encoding: Encoding, base_address: u64, debug_addr: &DebugAddr, debug_addr_base: DebugAddrBase, ) -> Result> { Ok(RngListIter::new( self.raw_ranges(offset, unit_encoding)?, base_address, debug_addr.clone(), debug_addr_base, )) } /// Iterate over the `RawRngListEntry`ies starting at the given offset. /// /// The `unit_encoding` must match the compilation unit that the /// offset was contained in. /// /// This iterator does not perform any processing of the range entries, /// such as handling base addresses. /// /// Can be [used with /// `FallibleIterator`](./index.html#using-with-fallibleiterator). pub fn raw_ranges( &self, offset: RangeListsOffset, unit_encoding: Encoding, ) -> Result> { let (mut input, format) = if unit_encoding.version <= 4 { (self.debug_ranges.section.clone(), RangeListsFormat::Bare) } else { (self.debug_rnglists.section.clone(), RangeListsFormat::Rle) }; input.skip(offset.0)?; Ok(RawRngListIter::new(input, unit_encoding, format)) } /// Returns the `.debug_rnglists` offset at the given `base` and `index`. /// /// The `base` must be the `DW_AT_rnglists_base` value from the compilation unit DIE. /// This is an offset that points to the first entry following the header. /// /// The `index` is the value of a `DW_FORM_rnglistx` attribute. /// /// The `unit_encoding` must match the compilation unit that the /// index was contained in. pub fn get_offset( &self, unit_encoding: Encoding, base: DebugRngListsBase, index: DebugRngListsIndex, ) -> Result> { let format = unit_encoding.format; let input = &mut self.debug_rnglists.section.clone(); input.skip(base.0)?; input.skip(R::Offset::from_u64( index.0.into_u64() * u64::from(format.word_size()), )?)?; input .read_offset(format) .map(|x| RangeListsOffset(base.0 + x)) } /// Call `Reader::lookup_offset_id` for each section, and return the first match. pub fn lookup_offset_id(&self, id: ReaderOffsetId) -> Option<(SectionId, R::Offset)> { self.debug_ranges .lookup_offset_id(id) .or_else(|| self.debug_rnglists.lookup_offset_id(id)) } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum RangeListsFormat { /// The bare range list format used before DWARF 5. Bare, /// The DW_RLE encoded range list format used in DWARF 5. Rle, } /// A raw iterator over an address range list. /// /// This iterator does not perform any processing of the range entries, /// such as handling base addresses. #[derive(Debug)] pub struct RawRngListIter { input: R, encoding: Encoding, format: RangeListsFormat, } /// A raw entry in .debug_rnglists #[derive(Clone, Debug)] pub enum RawRngListEntry { /// A range from DWARF version <= 4. AddressOrOffsetPair { /// Start of range. May be an address or an offset. begin: u64, /// End of range. May be an address or an offset. end: u64, }, /// DW_RLE_base_address BaseAddress { /// base address addr: u64, }, /// DW_RLE_base_addressx BaseAddressx { /// base address addr: DebugAddrIndex, }, /// DW_RLE_startx_endx StartxEndx { /// start of range begin: DebugAddrIndex, /// end of range end: DebugAddrIndex, }, /// DW_RLE_startx_length StartxLength { /// start of range begin: DebugAddrIndex, /// length of range length: u64, }, /// DW_RLE_offset_pair OffsetPair { /// start of range begin: u64, /// end of range end: u64, }, /// DW_RLE_start_end StartEnd { /// start of range begin: u64, /// end of range end: u64, }, /// DW_RLE_start_length StartLength { /// start of range begin: u64, /// length of range length: u64, }, } impl RawRngListEntry { /// Parse a range entry from `.debug_rnglists` fn parse>( input: &mut R, encoding: Encoding, format: RangeListsFormat, ) -> Result> { Ok(match format { RangeListsFormat::Bare => { let range = RawRange::parse(input, encoding.address_size)?; if range.is_end() { None } else if range.is_base_address(encoding.address_size) { Some(RawRngListEntry::BaseAddress { addr: range.end }) } else { Some(RawRngListEntry::AddressOrOffsetPair { begin: range.begin, end: range.end, }) } } RangeListsFormat::Rle => match constants::DwRle(input.read_u8()?) { constants::DW_RLE_end_of_list => None, constants::DW_RLE_base_addressx => Some(RawRngListEntry::BaseAddressx { addr: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), }), constants::DW_RLE_startx_endx => Some(RawRngListEntry::StartxEndx { begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), end: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), }), constants::DW_RLE_startx_length => Some(RawRngListEntry::StartxLength { begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), length: input.read_uleb128()?, }), constants::DW_RLE_offset_pair => Some(RawRngListEntry::OffsetPair { begin: input.read_uleb128()?, end: input.read_uleb128()?, }), constants::DW_RLE_base_address => Some(RawRngListEntry::BaseAddress { addr: input.read_address(encoding.address_size)?, }), constants::DW_RLE_start_end => Some(RawRngListEntry::StartEnd { begin: input.read_address(encoding.address_size)?, end: input.read_address(encoding.address_size)?, }), constants::DW_RLE_start_length => Some(RawRngListEntry::StartLength { begin: input.read_address(encoding.address_size)?, length: input.read_uleb128()?, }), _ => { return Err(Error::InvalidAddressRange); } }, }) } } impl RawRngListIter { /// Construct a `RawRngListIter`. fn new(input: R, encoding: Encoding, format: RangeListsFormat) -> RawRngListIter { RawRngListIter { input, encoding, format, } } /// Advance the iterator to the next range. pub fn next(&mut self) -> Result>> { if self.input.is_empty() { return Ok(None); } match RawRngListEntry::parse(&mut self.input, self.encoding, self.format) { Ok(range) => { if range.is_none() { self.input.empty(); } Ok(range) } Err(e) => { self.input.empty(); Err(e) } } } } #[cfg(feature = "fallible-iterator")] impl fallible_iterator::FallibleIterator for RawRngListIter { type Item = RawRngListEntry; type Error = Error; fn next(&mut self) -> ::core::result::Result, Self::Error> { RawRngListIter::next(self) } } /// An iterator over an address range list. /// /// This iterator internally handles processing of base addresses and different /// entry types. Thus, it only returns range entries that are valid /// and already adjusted for the base address. #[derive(Debug)] pub struct RngListIter { raw: RawRngListIter, base_address: u64, debug_addr: DebugAddr, debug_addr_base: DebugAddrBase, } impl RngListIter { /// Construct a `RngListIter`. fn new( raw: RawRngListIter, base_address: u64, debug_addr: DebugAddr, debug_addr_base: DebugAddrBase, ) -> RngListIter { RngListIter { raw, base_address, debug_addr, debug_addr_base, } } #[inline] fn get_address(&self, index: DebugAddrIndex) -> Result { self.debug_addr .get_address(self.raw.encoding.address_size, self.debug_addr_base, index) } /// Advance the iterator to the next range. pub fn next(&mut self) -> Result> { loop { let raw_range = match self.raw.next()? { Some(range) => range, None => return Ok(None), }; let range = self.convert_raw(raw_range)?; if range.is_some() { return Ok(range); } } } /// Return the next raw range. /// /// The raw range should be passed to `convert_range`. #[doc(hidden)] pub fn next_raw(&mut self) -> Result>> { self.raw.next() } /// Convert a raw range into a range, and update the state of the iterator. /// /// The raw range should have been obtained from `next_raw`. #[doc(hidden)] pub fn convert_raw(&mut self, raw_range: RawRngListEntry) -> Result> { let mask = !0 >> (64 - self.raw.encoding.address_size * 8); let tombstone = if self.raw.encoding.version <= 4 { mask - 1 } else { mask }; let range = match raw_range { RawRngListEntry::BaseAddress { addr } => { self.base_address = addr; return Ok(None); } RawRngListEntry::BaseAddressx { addr } => { self.base_address = self.get_address(addr)?; return Ok(None); } RawRngListEntry::StartxEndx { begin, end } => { let begin = self.get_address(begin)?; let end = self.get_address(end)?; Range { begin, end } } RawRngListEntry::StartxLength { begin, length } => { let begin = self.get_address(begin)?; let end = begin.wrapping_add(length) & mask; Range { begin, end } } RawRngListEntry::AddressOrOffsetPair { begin, end } | RawRngListEntry::OffsetPair { begin, end } => { if self.base_address == tombstone { return Ok(None); } let mut range = Range { begin, end }; range.add_base_address(self.base_address, self.raw.encoding.address_size); range } RawRngListEntry::StartEnd { begin, end } => Range { begin, end }, RawRngListEntry::StartLength { begin, length } => { let end = begin.wrapping_add(length) & mask; Range { begin, end } } }; if range.begin == tombstone { return Ok(None); } if range.begin > range.end { self.raw.input.empty(); return Err(Error::InvalidAddressRange); } Ok(Some(range)) } } #[cfg(feature = "fallible-iterator")] impl fallible_iterator::FallibleIterator for RngListIter { type Item = Range; type Error = Error; fn next(&mut self) -> ::core::result::Result, Self::Error> { RngListIter::next(self) } } /// A raw address range from the `.debug_ranges` section. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub(crate) struct RawRange { /// The beginning address of the range. pub begin: u64, /// The first address past the end of the range. pub end: u64, } impl RawRange { /// Check if this is a range end entry. #[inline] pub fn is_end(&self) -> bool { self.begin == 0 && self.end == 0 } /// Check if this is a base address selection entry. /// /// A base address selection entry changes the base address that subsequent /// range entries are relative to. #[inline] pub fn is_base_address(&self, address_size: u8) -> bool { self.begin == !0 >> (64 - address_size * 8) } /// Parse an address range entry from `.debug_ranges` or `.debug_loc`. #[inline] pub fn parse(input: &mut R, address_size: u8) -> Result { let begin = input.read_address(address_size)?; let end = input.read_address(address_size)?; let range = RawRange { begin, end }; Ok(range) } } /// An address range from the `.debug_ranges`, `.debug_rnglists`, or `.debug_aranges` sections. #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct Range { /// The beginning address of the range. pub begin: u64, /// The first address past the end of the range. pub end: u64, } impl Range { /// Add a base address to this range. #[inline] pub(crate) fn add_base_address(&mut self, base_address: u64, address_size: u8) { let mask = !0 >> (64 - address_size * 8); self.begin = base_address.wrapping_add(self.begin) & mask; self.end = base_address.wrapping_add(self.end) & mask; } } #[cfg(test)] mod tests { use super::*; use crate::common::Format; use crate::endianity::LittleEndian; use crate::test_util::GimliSectionMethods; use test_assembler::{Endian, Label, LabelMaker, Section}; #[test] fn test_rnglists_32() { let tombstone = !0u32; let encoding = Encoding { format: Format::Dwarf32, version: 5, address_size: 4, }; let section = Section::with_endian(Endian::Little) .L32(0x0300_0000) .L32(0x0301_0300) .L32(0x0301_0400) .L32(0x0301_0500) .L32(tombstone) .L32(0x0301_0600); let buf = section.get_contents().unwrap(); let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian)); let debug_addr_base = DebugAddrBase(0); let start = Label::new(); let first = Label::new(); let size = Label::new(); #[rustfmt::skip] let section = Section::with_endian(Endian::Little) // Header .mark(&start) .L32(&size) .L16(encoding.version) .L8(encoding.address_size) .L8(0) .L32(0) .mark(&first) // An OffsetPair using the unit base address. .L8(4).uleb(0x10200).uleb(0x10300) // A base address selection followed by an OffsetPair. .L8(5).L32(0x0200_0000) .L8(4).uleb(0x10400).uleb(0x10500) // An empty OffsetPair followed by a normal OffsetPair. .L8(4).uleb(0x10600).uleb(0x10600) .L8(4).uleb(0x10800).uleb(0x10900) // A StartEnd .L8(6).L32(0x201_0a00).L32(0x201_0b00) // A StartLength .L8(7).L32(0x201_0c00).uleb(0x100) // An OffsetPair that starts at 0. .L8(4).uleb(0).uleb(1) // An OffsetPair that starts and ends at 0. .L8(4).uleb(0).uleb(0) // An OffsetPair that ends at -1. .L8(5).L32(0) .L8(4).uleb(0).uleb(0xffff_ffff) // A BaseAddressx + OffsetPair .L8(1).uleb(0) .L8(4).uleb(0x10100).uleb(0x10200) // A StartxEndx .L8(2).uleb(1).uleb(2) // A StartxLength .L8(3).uleb(3).uleb(0x100) // Tombstone entries, all of which should be ignored. // A BaseAddressx that is a tombstone. .L8(1).uleb(4) .L8(4).uleb(0x11100).uleb(0x11200) // A BaseAddress that is a tombstone. .L8(5).L32(tombstone) .L8(4).uleb(0x11300).uleb(0x11400) // A StartxEndx that is a tombstone. .L8(2).uleb(4).uleb(5) // A StartxLength that is a tombstone. .L8(3).uleb(4).uleb(0x100) // A StartEnd that is a tombstone. .L8(6).L32(tombstone).L32(0x201_1500) // A StartLength that is a tombstone. .L8(7).L32(tombstone).uleb(0x100) // A StartEnd (not ignored) .L8(6).L32(0x201_1600).L32(0x201_1700) // A range end. .L8(0) // Some extra data. .L32(0xffff_ffff); size.set_const((§ion.here() - &start - 4) as u64); let buf = section.get_contents().unwrap(); let debug_ranges = DebugRanges::new(&[], LittleEndian); let debug_rnglists = DebugRngLists::new(&buf, LittleEndian); let rnglists = RangeLists::new(debug_ranges, debug_rnglists); let offset = RangeListsOffset((&first - &start) as usize); let mut ranges = rnglists .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) .unwrap(); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0101_0200, end: 0x0101_0300, })) ); // A base address selection followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0400, end: 0x0201_0500, })) ); // An empty range followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0600, end: 0x0201_0600, })) ); assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0800, end: 0x0201_0900, })) ); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0a00, end: 0x0201_0b00, })) ); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0c00, end: 0x0201_0d00, })) ); // A range that starts at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0001, })) ); // A range that starts and ends at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0000, })) ); // A range that ends at -1. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0000_0000, end: 0xffff_ffff, })) ); // A BaseAddressx + OffsetPair assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0100, end: 0x0301_0200, })) ); // A StartxEndx assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0300, end: 0x0301_0400, })) ); // A StartxLength assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0500, end: 0x0301_0600, })) ); // A StartEnd range following the tombstones assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_1600, end: 0x0201_1700, })) ); // A range end. assert_eq!(ranges.next(), Ok(None)); // An offset at the end of buf. let mut ranges = rnglists .ranges( RangeListsOffset(buf.len()), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Ok(None)); } #[test] fn test_rnglists_64() { let tombstone = !0u64; let encoding = Encoding { format: Format::Dwarf64, version: 5, address_size: 8, }; let section = Section::with_endian(Endian::Little) .L64(0x0300_0000) .L64(0x0301_0300) .L64(0x0301_0400) .L64(0x0301_0500) .L64(tombstone) .L64(0x0301_0600); let buf = section.get_contents().unwrap(); let debug_addr = &DebugAddr::from(EndianSlice::new(&buf, LittleEndian)); let debug_addr_base = DebugAddrBase(0); let start = Label::new(); let first = Label::new(); let size = Label::new(); #[rustfmt::skip] let section = Section::with_endian(Endian::Little) // Header .mark(&start) .L32(0xffff_ffff) .L64(&size) .L16(encoding.version) .L8(encoding.address_size) .L8(0) .L32(0) .mark(&first) // An OffsetPair using the unit base address. .L8(4).uleb(0x10200).uleb(0x10300) // A base address selection followed by an OffsetPair. .L8(5).L64(0x0200_0000) .L8(4).uleb(0x10400).uleb(0x10500) // An empty OffsetPair followed by a normal OffsetPair. .L8(4).uleb(0x10600).uleb(0x10600) .L8(4).uleb(0x10800).uleb(0x10900) // A StartEnd .L8(6).L64(0x201_0a00).L64(0x201_0b00) // A StartLength .L8(7).L64(0x201_0c00).uleb(0x100) // An OffsetPair that starts at 0. .L8(4).uleb(0).uleb(1) // An OffsetPair that starts and ends at 0. .L8(4).uleb(0).uleb(0) // An OffsetPair that ends at -1. .L8(5).L64(0) .L8(4).uleb(0).uleb(0xffff_ffff) // A BaseAddressx + OffsetPair .L8(1).uleb(0) .L8(4).uleb(0x10100).uleb(0x10200) // A StartxEndx .L8(2).uleb(1).uleb(2) // A StartxLength .L8(3).uleb(3).uleb(0x100) // Tombstone entries, all of which should be ignored. // A BaseAddressx that is a tombstone. .L8(1).uleb(4) .L8(4).uleb(0x11100).uleb(0x11200) // A BaseAddress that is a tombstone. .L8(5).L64(tombstone) .L8(4).uleb(0x11300).uleb(0x11400) // A StartxEndx that is a tombstone. .L8(2).uleb(4).uleb(5) // A StartxLength that is a tombstone. .L8(3).uleb(4).uleb(0x100) // A StartEnd that is a tombstone. .L8(6).L64(tombstone).L64(0x201_1500) // A StartLength that is a tombstone. .L8(7).L64(tombstone).uleb(0x100) // A StartEnd (not ignored) .L8(6).L64(0x201_1600).L64(0x201_1700) // A range end. .L8(0) // Some extra data. .L32(0xffff_ffff); size.set_const((§ion.here() - &start - 12) as u64); let buf = section.get_contents().unwrap(); let debug_ranges = DebugRanges::new(&[], LittleEndian); let debug_rnglists = DebugRngLists::new(&buf, LittleEndian); let rnglists = RangeLists::new(debug_ranges, debug_rnglists); let offset = RangeListsOffset((&first - &start) as usize); let mut ranges = rnglists .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) .unwrap(); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0101_0200, end: 0x0101_0300, })) ); // A base address selection followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0400, end: 0x0201_0500, })) ); // An empty range followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0600, end: 0x0201_0600, })) ); assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0800, end: 0x0201_0900, })) ); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0a00, end: 0x0201_0b00, })) ); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0c00, end: 0x0201_0d00, })) ); // A range that starts at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0001, })) ); // A range that starts and ends at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0000, })) ); // A range that ends at -1. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0000_0000, end: 0xffff_ffff, })) ); // A BaseAddressx + OffsetPair assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0100, end: 0x0301_0200, })) ); // A StartxEndx assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0300, end: 0x0301_0400, })) ); // A StartxLength assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0301_0500, end: 0x0301_0600, })) ); // A StartEnd range following the tombstones assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_1600, end: 0x0201_1700, })) ); // A range end. assert_eq!(ranges.next(), Ok(None)); // An offset at the end of buf. let mut ranges = rnglists .ranges( RangeListsOffset(buf.len()), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Ok(None)); } #[test] fn test_raw_range() { let range = RawRange { begin: 0, end: 0xffff_ffff, }; assert!(!range.is_end()); assert!(!range.is_base_address(4)); assert!(!range.is_base_address(8)); let range = RawRange { begin: 0, end: 0 }; assert!(range.is_end()); assert!(!range.is_base_address(4)); assert!(!range.is_base_address(8)); let range = RawRange { begin: 0xffff_ffff, end: 0, }; assert!(!range.is_end()); assert!(range.is_base_address(4)); assert!(!range.is_base_address(8)); let range = RawRange { begin: 0xffff_ffff_ffff_ffff, end: 0, }; assert!(!range.is_end()); assert!(!range.is_base_address(4)); assert!(range.is_base_address(8)); } #[test] fn test_ranges_32() { let tombstone = !0u32 - 1; let start = Label::new(); let first = Label::new(); #[rustfmt::skip] let section = Section::with_endian(Endian::Little) // A range before the offset. .mark(&start) .L32(0x10000).L32(0x10100) .mark(&first) // A normal range. .L32(0x10200).L32(0x10300) // A base address selection followed by a normal range. .L32(0xffff_ffff).L32(0x0200_0000) .L32(0x10400).L32(0x10500) // An empty range followed by a normal range. .L32(0x10600).L32(0x10600) .L32(0x10800).L32(0x10900) // A range that starts at 0. .L32(0).L32(1) // A range that ends at -1. .L32(0xffff_ffff).L32(0x0000_0000) .L32(0).L32(0xffff_ffff) // A normal range with tombstone. .L32(tombstone).L32(tombstone) // A base address selection with tombstone followed by a normal range. .L32(0xffff_ffff).L32(tombstone) .L32(0x10a00).L32(0x10b00) // A range end. .L32(0).L32(0) // Some extra data. .L32(0); let buf = section.get_contents().unwrap(); let debug_ranges = DebugRanges::new(&buf, LittleEndian); let debug_rnglists = DebugRngLists::new(&[], LittleEndian); let rnglists = RangeLists::new(debug_ranges, debug_rnglists); let offset = RangeListsOffset((&first - &start) as usize); let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian)); let debug_addr_base = DebugAddrBase(0); let encoding = Encoding { format: Format::Dwarf32, version: 4, address_size: 4, }; let mut ranges = rnglists .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) .unwrap(); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0101_0200, end: 0x0101_0300, })) ); // A base address selection followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0400, end: 0x0201_0500, })) ); // An empty range followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0600, end: 0x0201_0600, })) ); assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0800, end: 0x0201_0900, })) ); // A range that starts at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0001, })) ); // A range that ends at -1. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0000_0000, end: 0xffff_ffff, })) ); // A range end. assert_eq!(ranges.next(), Ok(None)); // An offset at the end of buf. let mut ranges = rnglists .ranges( RangeListsOffset(buf.len()), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Ok(None)); } #[test] fn test_ranges_64() { let tombstone = !0u64 - 1; let start = Label::new(); let first = Label::new(); #[rustfmt::skip] let section = Section::with_endian(Endian::Little) // A range before the offset. .mark(&start) .L64(0x10000).L64(0x10100) .mark(&first) // A normal range. .L64(0x10200).L64(0x10300) // A base address selection followed by a normal range. .L64(0xffff_ffff_ffff_ffff).L64(0x0200_0000) .L64(0x10400).L64(0x10500) // An empty range followed by a normal range. .L64(0x10600).L64(0x10600) .L64(0x10800).L64(0x10900) // A range that starts at 0. .L64(0).L64(1) // A range that ends at -1. .L64(0xffff_ffff_ffff_ffff).L64(0x0000_0000) .L64(0).L64(0xffff_ffff_ffff_ffff) // A normal range with tombstone. .L64(tombstone).L64(tombstone) // A base address selection with tombstone followed by a normal range. .L64(0xffff_ffff_ffff_ffff).L64(tombstone) .L64(0x10a00).L64(0x10b00) // A range end. .L64(0).L64(0) // Some extra data. .L64(0); let buf = section.get_contents().unwrap(); let debug_ranges = DebugRanges::new(&buf, LittleEndian); let debug_rnglists = DebugRngLists::new(&[], LittleEndian); let rnglists = RangeLists::new(debug_ranges, debug_rnglists); let offset = RangeListsOffset((&first - &start) as usize); let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian)); let debug_addr_base = DebugAddrBase(0); let encoding = Encoding { format: Format::Dwarf64, version: 4, address_size: 8, }; let mut ranges = rnglists .ranges(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) .unwrap(); // A normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0101_0200, end: 0x0101_0300, })) ); // A base address selection followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0400, end: 0x0201_0500, })) ); // An empty range followed by a normal range. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0600, end: 0x0201_0600, })) ); assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0201_0800, end: 0x0201_0900, })) ); // A range that starts at 0. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0200_0000, end: 0x0200_0001, })) ); // A range that ends at -1. assert_eq!( ranges.next(), Ok(Some(Range { begin: 0x0, end: 0xffff_ffff_ffff_ffff, })) ); // A range end. assert_eq!(ranges.next(), Ok(None)); // An offset at the end of buf. let mut ranges = rnglists .ranges( RangeListsOffset(buf.len()), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Ok(None)); } #[test] fn test_ranges_invalid() { #[rustfmt::skip] let section = Section::with_endian(Endian::Little) // An invalid range. .L32(0x20000).L32(0x10000) // An invalid range after wrapping. .L32(0x20000).L32(0xff01_0000); let buf = section.get_contents().unwrap(); let debug_ranges = DebugRanges::new(&buf, LittleEndian); let debug_rnglists = DebugRngLists::new(&[], LittleEndian); let rnglists = RangeLists::new(debug_ranges, debug_rnglists); let debug_addr = &DebugAddr::from(EndianSlice::new(&[], LittleEndian)); let debug_addr_base = DebugAddrBase(0); let encoding = Encoding { format: Format::Dwarf32, version: 4, address_size: 4, }; // An invalid range. let mut ranges = rnglists .ranges( RangeListsOffset(0x0), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Err(Error::InvalidAddressRange)); // An invalid range after wrapping. let mut ranges = rnglists .ranges( RangeListsOffset(0x8), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) .unwrap(); assert_eq!(ranges.next(), Err(Error::InvalidAddressRange)); // An invalid offset. match rnglists.ranges( RangeListsOffset(buf.len() + 1), encoding, 0x0100_0000, debug_addr, debug_addr_base, ) { Err(Error::UnexpectedEof(_)) => {} otherwise => panic!("Unexpected result: {:?}", otherwise), } } #[test] fn test_get_offset() { for format in vec![Format::Dwarf32, Format::Dwarf64] { let encoding = Encoding { format, version: 5, address_size: 4, }; let zero = Label::new(); let length = Label::new(); let start = Label::new(); let first = Label::new(); let end = Label::new(); let mut section = Section::with_endian(Endian::Little) .mark(&zero) .initial_length(format, &length, &start) .D16(encoding.version) .D8(encoding.address_size) .D8(0) .D32(20) .mark(&first); for i in 0..20 { section = section.word(format.word_size(), 1000 + i); } section = section.mark(&end); length.set_const((&end - &start) as u64); let section = section.get_contents().unwrap(); let debug_ranges = DebugRanges::from(EndianSlice::new(&[], LittleEndian)); let debug_rnglists = DebugRngLists::from(EndianSlice::new(§ion, LittleEndian)); let ranges = RangeLists::new(debug_ranges, debug_rnglists); let base = DebugRngListsBase((&first - &zero) as usize); assert_eq!( ranges.get_offset(encoding, base, DebugRngListsIndex(0)), Ok(RangeListsOffset(base.0 + 1000)) ); assert_eq!( ranges.get_offset(encoding, base, DebugRngListsIndex(19)), Ok(RangeListsOffset(base.0 + 1019)) ); } } }