| use crate::common::{ |
| DebugAddrBase, DebugAddrIndex, DebugLocListsBase, DebugLocListsIndex, DwarfFileType, Encoding, |
| LocationListsOffset, SectionId, |
| }; |
| use crate::constants; |
| use crate::endianity::Endianity; |
| use crate::read::{ |
| lists::ListsHeader, DebugAddr, EndianSlice, Error, Expression, Range, RawRange, Reader, |
| ReaderOffset, ReaderOffsetId, Result, Section, |
| }; |
| |
| /// The raw contents of the `.debug_loc` section. |
| #[derive(Debug, Default, Clone, Copy)] |
| pub struct DebugLoc<R> { |
| pub(crate) section: R, |
| } |
| |
| impl<'input, Endian> DebugLoc<EndianSlice<'input, Endian>> |
| where |
| Endian: Endianity, |
| { |
| /// Construct a new `DebugLoc` instance from the data in the `.debug_loc` |
| /// section. |
| /// |
| /// It is the caller's responsibility to read the `.debug_loc` 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::{DebugLoc, LittleEndian}; |
| /// |
| /// # let buf = [0x00, 0x01, 0x02, 0x03]; |
| /// # let read_debug_loc_section_somehow = || &buf; |
| /// let debug_loc = DebugLoc::new(read_debug_loc_section_somehow(), LittleEndian); |
| /// ``` |
| pub fn new(section: &'input [u8], endian: Endian) -> Self { |
| Self::from(EndianSlice::new(section, endian)) |
| } |
| } |
| |
| impl<R> Section<R> for DebugLoc<R> { |
| fn id() -> SectionId { |
| SectionId::DebugLoc |
| } |
| |
| fn reader(&self) -> &R { |
| &self.section |
| } |
| } |
| |
| impl<R> From<R> for DebugLoc<R> { |
| fn from(section: R) -> Self { |
| DebugLoc { section } |
| } |
| } |
| |
| /// The `DebugLocLists` struct represents the DWARF data |
| /// found in the `.debug_loclists` section. |
| #[derive(Debug, Default, Clone, Copy)] |
| pub struct DebugLocLists<R> { |
| section: R, |
| } |
| |
| impl<'input, Endian> DebugLocLists<EndianSlice<'input, Endian>> |
| where |
| Endian: Endianity, |
| { |
| /// Construct a new `DebugLocLists` instance from the data in the `.debug_loclists` |
| /// section. |
| /// |
| /// It is the caller's responsibility to read the `.debug_loclists` 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::{DebugLocLists, LittleEndian}; |
| /// |
| /// # let buf = [0x00, 0x01, 0x02, 0x03]; |
| /// # let read_debug_loclists_section_somehow = || &buf; |
| /// let debug_loclists = DebugLocLists::new(read_debug_loclists_section_somehow(), LittleEndian); |
| /// ``` |
| pub fn new(section: &'input [u8], endian: Endian) -> Self { |
| Self::from(EndianSlice::new(section, endian)) |
| } |
| } |
| |
| impl<R> Section<R> for DebugLocLists<R> { |
| fn id() -> SectionId { |
| SectionId::DebugLocLists |
| } |
| |
| fn reader(&self) -> &R { |
| &self.section |
| } |
| } |
| |
| impl<R> From<R> for DebugLocLists<R> { |
| fn from(section: R) -> Self { |
| DebugLocLists { section } |
| } |
| } |
| |
| pub(crate) type LocListsHeader = ListsHeader; |
| |
| impl<Offset> DebugLocListsBase<Offset> |
| where |
| Offset: ReaderOffset, |
| { |
| /// Returns a `DebugLocListsBase` with the default value of DW_AT_loclists_base |
| /// for the given `Encoding` and `DwarfFileType`. |
| pub fn default_for_encoding_and_file( |
| encoding: Encoding, |
| file_type: DwarfFileType, |
| ) -> DebugLocListsBase<Offset> { |
| if encoding.version >= 5 && file_type == DwarfFileType::Dwo { |
| // In .dwo files, the compiler omits the DW_AT_loclists_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. |
| DebugLocListsBase(Offset::from_u8(LocListsHeader::size_for_encoding(encoding))) |
| } else { |
| DebugLocListsBase(Offset::from_u8(0)) |
| } |
| } |
| } |
| |
| /// The DWARF data found in `.debug_loc` and `.debug_loclists` sections. |
| #[derive(Debug, Default, Clone, Copy)] |
| pub struct LocationLists<R> { |
| debug_loc: DebugLoc<R>, |
| debug_loclists: DebugLocLists<R>, |
| } |
| |
| impl<R> LocationLists<R> { |
| /// Construct a new `LocationLists` instance from the data in the `.debug_loc` and |
| /// `.debug_loclists` sections. |
| pub fn new(debug_loc: DebugLoc<R>, debug_loclists: DebugLocLists<R>) -> LocationLists<R> { |
| LocationLists { |
| debug_loc, |
| debug_loclists, |
| } |
| } |
| } |
| |
| impl<T> LocationLists<T> { |
| /// Create a `LocationLists` 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::LocationLists<Vec<u8>> = 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) -> LocationLists<R> |
| where |
| F: FnMut(&'a T) -> R, |
| { |
| LocationLists { |
| debug_loc: borrow(&self.debug_loc.section).into(), |
| debug_loclists: borrow(&self.debug_loclists.section).into(), |
| } |
| } |
| } |
| |
| impl<R: Reader> LocationLists<R> { |
| /// Iterate over the `LocationListEntry`s starting at the given offset. |
| /// |
| /// The `unit_encoding` 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 location |
| /// list. |
| /// |
| /// Can be [used with |
| /// `FallibleIterator`](./index.html#using-with-fallibleiterator). |
| pub fn locations( |
| &self, |
| offset: LocationListsOffset<R::Offset>, |
| unit_encoding: Encoding, |
| base_address: u64, |
| debug_addr: &DebugAddr<R>, |
| debug_addr_base: DebugAddrBase<R::Offset>, |
| ) -> Result<LocListIter<R>> { |
| Ok(LocListIter::new( |
| self.raw_locations(offset, unit_encoding)?, |
| base_address, |
| debug_addr.clone(), |
| debug_addr_base, |
| )) |
| } |
| |
| /// Similar to `locations`, but with special handling for .dwo files. |
| /// This should only been used when this `LocationLists` was loaded from a |
| /// .dwo file. |
| pub fn locations_dwo( |
| &self, |
| offset: LocationListsOffset<R::Offset>, |
| unit_encoding: Encoding, |
| base_address: u64, |
| debug_addr: &DebugAddr<R>, |
| debug_addr_base: DebugAddrBase<R::Offset>, |
| ) -> Result<LocListIter<R>> { |
| Ok(LocListIter::new( |
| self.raw_locations_dwo(offset, unit_encoding)?, |
| base_address, |
| debug_addr.clone(), |
| debug_addr_base, |
| )) |
| } |
| |
| /// Iterate over the raw `LocationListEntry`s 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 location entries, |
| /// such as handling base addresses. |
| /// |
| /// Can be [used with |
| /// `FallibleIterator`](./index.html#using-with-fallibleiterator). |
| pub fn raw_locations( |
| &self, |
| offset: LocationListsOffset<R::Offset>, |
| unit_encoding: Encoding, |
| ) -> Result<RawLocListIter<R>> { |
| let (mut input, format) = if unit_encoding.version <= 4 { |
| (self.debug_loc.section.clone(), LocListsFormat::Bare) |
| } else { |
| (self.debug_loclists.section.clone(), LocListsFormat::Lle) |
| }; |
| input.skip(offset.0)?; |
| Ok(RawLocListIter::new(input, unit_encoding, format)) |
| } |
| |
| /// Similar to `raw_locations`, but with special handling for .dwo files. |
| /// This should only been used when this `LocationLists` was loaded from a |
| /// .dwo file. |
| pub fn raw_locations_dwo( |
| &self, |
| offset: LocationListsOffset<R::Offset>, |
| unit_encoding: Encoding, |
| ) -> Result<RawLocListIter<R>> { |
| let mut input = if unit_encoding.version <= 4 { |
| // In the GNU split dwarf extension the locations are present in the |
| // .debug_loc section but are encoded with the DW_LLE values used |
| // for the DWARF 5 .debug_loclists section. |
| self.debug_loc.section.clone() |
| } else { |
| self.debug_loclists.section.clone() |
| }; |
| input.skip(offset.0)?; |
| Ok(RawLocListIter::new( |
| input, |
| unit_encoding, |
| LocListsFormat::Lle, |
| )) |
| } |
| |
| /// Returns the `.debug_loclists` offset at the given `base` and `index`. |
| /// |
| /// The `base` must be the `DW_AT_loclists_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_loclistx` attribute. |
| pub fn get_offset( |
| &self, |
| unit_encoding: Encoding, |
| base: DebugLocListsBase<R::Offset>, |
| index: DebugLocListsIndex<R::Offset>, |
| ) -> Result<LocationListsOffset<R::Offset>> { |
| let format = unit_encoding.format; |
| let input = &mut self.debug_loclists.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| LocationListsOffset(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_loc |
| .lookup_offset_id(id) |
| .or_else(|| self.debug_loclists.lookup_offset_id(id)) |
| } |
| } |
| |
| #[derive(Debug, Clone, Copy, PartialEq, Eq)] |
| enum LocListsFormat { |
| /// The bare location list format used before DWARF 5. |
| Bare, |
| /// The DW_LLE encoded range list format used in DWARF 5 and the non-standard GNU |
| /// split dwarf extension. |
| Lle, |
| } |
| |
| /// A raw iterator over a location list. |
| /// |
| /// This iterator does not perform any processing of the location entries, |
| /// such as handling base addresses. |
| #[derive(Debug)] |
| pub struct RawLocListIter<R: Reader> { |
| input: R, |
| encoding: Encoding, |
| format: LocListsFormat, |
| } |
| |
| /// A raw entry in .debug_loclists. |
| #[derive(Clone, Debug)] |
| pub enum RawLocListEntry<R: Reader> { |
| /// A location 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, |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_base_address |
| BaseAddress { |
| /// base address |
| addr: u64, |
| }, |
| /// DW_LLE_base_addressx |
| BaseAddressx { |
| /// base address |
| addr: DebugAddrIndex<R::Offset>, |
| }, |
| /// DW_LLE_startx_endx |
| StartxEndx { |
| /// start of range |
| begin: DebugAddrIndex<R::Offset>, |
| /// end of range |
| end: DebugAddrIndex<R::Offset>, |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_startx_length |
| StartxLength { |
| /// start of range |
| begin: DebugAddrIndex<R::Offset>, |
| /// length of range |
| length: u64, |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_offset_pair |
| OffsetPair { |
| /// start of range |
| begin: u64, |
| /// end of range |
| end: u64, |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_default_location |
| DefaultLocation { |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_start_end |
| StartEnd { |
| /// start of range |
| begin: u64, |
| /// end of range |
| end: u64, |
| /// expression |
| data: Expression<R>, |
| }, |
| /// DW_LLE_start_length |
| StartLength { |
| /// start of range |
| begin: u64, |
| /// length of range |
| length: u64, |
| /// expression |
| data: Expression<R>, |
| }, |
| } |
| |
| fn parse_data<R: Reader>(input: &mut R, encoding: Encoding) -> Result<Expression<R>> { |
| if encoding.version >= 5 { |
| let len = R::Offset::from_u64(input.read_uleb128()?)?; |
| Ok(Expression(input.split(len)?)) |
| } else { |
| // In the GNU split-dwarf extension this is a fixed 2 byte value. |
| let len = R::Offset::from_u16(input.read_u16()?); |
| Ok(Expression(input.split(len)?)) |
| } |
| } |
| |
| impl<R: Reader> RawLocListEntry<R> { |
| /// Parse a location list entry from `.debug_loclists` |
| fn parse(input: &mut R, encoding: Encoding, format: LocListsFormat) -> Result<Option<Self>> { |
| Ok(match format { |
| LocListsFormat::Bare => { |
| let range = RawRange::parse(input, encoding.address_size)?; |
| if range.is_end() { |
| None |
| } else if range.is_base_address(encoding.address_size) { |
| Some(RawLocListEntry::BaseAddress { addr: range.end }) |
| } else { |
| let len = R::Offset::from_u16(input.read_u16()?); |
| let data = Expression(input.split(len)?); |
| Some(RawLocListEntry::AddressOrOffsetPair { |
| begin: range.begin, |
| end: range.end, |
| data, |
| }) |
| } |
| } |
| LocListsFormat::Lle => match constants::DwLle(input.read_u8()?) { |
| constants::DW_LLE_end_of_list => None, |
| constants::DW_LLE_base_addressx => Some(RawLocListEntry::BaseAddressx { |
| addr: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), |
| }), |
| constants::DW_LLE_startx_endx => Some(RawLocListEntry::StartxEndx { |
| begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), |
| end: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), |
| data: parse_data(input, encoding)?, |
| }), |
| constants::DW_LLE_startx_length => Some(RawLocListEntry::StartxLength { |
| begin: DebugAddrIndex(input.read_uleb128().and_then(R::Offset::from_u64)?), |
| length: if encoding.version >= 5 { |
| input.read_uleb128()? |
| } else { |
| // In the GNU split-dwarf extension this is a fixed 4 byte value. |
| input.read_u32()? as u64 |
| }, |
| data: parse_data(input, encoding)?, |
| }), |
| constants::DW_LLE_offset_pair => Some(RawLocListEntry::OffsetPair { |
| begin: input.read_uleb128()?, |
| end: input.read_uleb128()?, |
| data: parse_data(input, encoding)?, |
| }), |
| constants::DW_LLE_default_location => Some(RawLocListEntry::DefaultLocation { |
| data: parse_data(input, encoding)?, |
| }), |
| constants::DW_LLE_base_address => Some(RawLocListEntry::BaseAddress { |
| addr: input.read_address(encoding.address_size)?, |
| }), |
| constants::DW_LLE_start_end => Some(RawLocListEntry::StartEnd { |
| begin: input.read_address(encoding.address_size)?, |
| end: input.read_address(encoding.address_size)?, |
| data: parse_data(input, encoding)?, |
| }), |
| constants::DW_LLE_start_length => Some(RawLocListEntry::StartLength { |
| begin: input.read_address(encoding.address_size)?, |
| length: input.read_uleb128()?, |
| data: parse_data(input, encoding)?, |
| }), |
| _ => { |
| return Err(Error::InvalidAddressRange); |
| } |
| }, |
| }) |
| } |
| } |
| |
| impl<R: Reader> RawLocListIter<R> { |
| /// Construct a `RawLocListIter`. |
| fn new(input: R, encoding: Encoding, format: LocListsFormat) -> RawLocListIter<R> { |
| RawLocListIter { |
| input, |
| encoding, |
| format, |
| } |
| } |
| |
| /// Advance the iterator to the next location. |
| pub fn next(&mut self) -> Result<Option<RawLocListEntry<R>>> { |
| if self.input.is_empty() { |
| return Ok(None); |
| } |
| |
| match RawLocListEntry::parse(&mut self.input, self.encoding, self.format) { |
| Ok(entry) => { |
| if entry.is_none() { |
| self.input.empty(); |
| } |
| Ok(entry) |
| } |
| Err(e) => { |
| self.input.empty(); |
| Err(e) |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "fallible-iterator")] |
| impl<R: Reader> fallible_iterator::FallibleIterator for RawLocListIter<R> { |
| type Item = RawLocListEntry<R>; |
| type Error = Error; |
| |
| fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> { |
| RawLocListIter::next(self) |
| } |
| } |
| |
| /// An iterator over a location list. |
| /// |
| /// This iterator internally handles processing of base address selection entries |
| /// and list end entries. Thus, it only returns location entries that are valid |
| /// and already adjusted for the base address. |
| #[derive(Debug)] |
| pub struct LocListIter<R: Reader> { |
| raw: RawLocListIter<R>, |
| base_address: u64, |
| debug_addr: DebugAddr<R>, |
| debug_addr_base: DebugAddrBase<R::Offset>, |
| } |
| |
| impl<R: Reader> LocListIter<R> { |
| /// Construct a `LocListIter`. |
| fn new( |
| raw: RawLocListIter<R>, |
| base_address: u64, |
| debug_addr: DebugAddr<R>, |
| debug_addr_base: DebugAddrBase<R::Offset>, |
| ) -> LocListIter<R> { |
| LocListIter { |
| raw, |
| base_address, |
| debug_addr, |
| debug_addr_base, |
| } |
| } |
| |
| #[inline] |
| fn get_address(&self, index: DebugAddrIndex<R::Offset>) -> Result<u64> { |
| self.debug_addr |
| .get_address(self.raw.encoding.address_size, self.debug_addr_base, index) |
| } |
| |
| /// Advance the iterator to the next location. |
| pub fn next(&mut self) -> Result<Option<LocationListEntry<R>>> { |
| loop { |
| let raw_loc = match self.raw.next()? { |
| Some(loc) => loc, |
| None => return Ok(None), |
| }; |
| |
| let loc = self.convert_raw(raw_loc)?; |
| if loc.is_some() { |
| return Ok(loc); |
| } |
| } |
| } |
| |
| /// Return the next raw location. |
| /// |
| /// The raw location should be passed to `convert_raw`. |
| #[doc(hidden)] |
| pub fn next_raw(&mut self) -> Result<Option<RawLocListEntry<R>>> { |
| self.raw.next() |
| } |
| |
| /// Convert a raw location into a location, and update the state of the iterator. |
| /// |
| /// The raw location should have been obtained from `next_raw`. |
| #[doc(hidden)] |
| pub fn convert_raw( |
| &mut self, |
| raw_loc: RawLocListEntry<R>, |
| ) -> Result<Option<LocationListEntry<R>>> { |
| let mask = !0 >> (64 - self.raw.encoding.address_size * 8); |
| let tombstone = if self.raw.encoding.version <= 4 { |
| mask - 1 |
| } else { |
| mask |
| }; |
| |
| let (range, data) = match raw_loc { |
| RawLocListEntry::BaseAddress { addr } => { |
| self.base_address = addr; |
| return Ok(None); |
| } |
| RawLocListEntry::BaseAddressx { addr } => { |
| self.base_address = self.get_address(addr)?; |
| return Ok(None); |
| } |
| RawLocListEntry::StartxEndx { begin, end, data } => { |
| let begin = self.get_address(begin)?; |
| let end = self.get_address(end)?; |
| (Range { begin, end }, data) |
| } |
| RawLocListEntry::StartxLength { |
| begin, |
| length, |
| data, |
| } => { |
| let begin = self.get_address(begin)?; |
| let end = begin.wrapping_add(length) & mask; |
| (Range { begin, end }, data) |
| } |
| RawLocListEntry::DefaultLocation { data } => ( |
| Range { |
| begin: 0, |
| end: u64::max_value(), |
| }, |
| data, |
| ), |
| RawLocListEntry::AddressOrOffsetPair { begin, end, data } |
| | RawLocListEntry::OffsetPair { begin, end, data } => { |
| 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, data) |
| } |
| RawLocListEntry::StartEnd { begin, end, data } => (Range { begin, end }, data), |
| RawLocListEntry::StartLength { |
| begin, |
| length, |
| data, |
| } => { |
| let end = begin.wrapping_add(length) & mask; |
| (Range { begin, end }, data) |
| } |
| }; |
| |
| if range.begin == tombstone { |
| return Ok(None); |
| } |
| |
| if range.begin > range.end { |
| self.raw.input.empty(); |
| return Err(Error::InvalidLocationAddressRange); |
| } |
| |
| Ok(Some(LocationListEntry { range, data })) |
| } |
| } |
| |
| #[cfg(feature = "fallible-iterator")] |
| impl<R: Reader> fallible_iterator::FallibleIterator for LocListIter<R> { |
| type Item = LocationListEntry<R>; |
| type Error = Error; |
| |
| fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> { |
| LocListIter::next(self) |
| } |
| } |
| |
| /// A location list entry from the `.debug_loc` or `.debug_loclists` sections. |
| #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
| pub struct LocationListEntry<R: Reader> { |
| /// The address range that this location is valid for. |
| pub range: Range, |
| |
| /// The data containing a single location description. |
| pub data: Expression<R>, |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use crate::common::Format; |
| use crate::endianity::LittleEndian; |
| use crate::read::{EndianSlice, Range}; |
| use crate::test_util::GimliSectionMethods; |
| use test_assembler::{Endian, Label, LabelMaker, Section}; |
| |
| #[test] |
| fn test_loclists_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) |
| // OffsetPair |
| .L8(4).uleb(0x10200).uleb(0x10300).uleb(4).L32(2) |
| // A base address selection followed by an OffsetPair. |
| .L8(6).L32(0x0200_0000) |
| .L8(4).uleb(0x10400).uleb(0x10500).uleb(4).L32(3) |
| // An empty OffsetPair followed by a normal OffsetPair. |
| .L8(4).uleb(0x10600).uleb(0x10600).uleb(4).L32(4) |
| .L8(4).uleb(0x10800).uleb(0x10900).uleb(4).L32(5) |
| // A StartEnd |
| .L8(7).L32(0x201_0a00).L32(0x201_0b00).uleb(4).L32(6) |
| // A StartLength |
| .L8(8).L32(0x201_0c00).uleb(0x100).uleb(4).L32(7) |
| // An OffsetPair that starts at 0. |
| .L8(4).uleb(0).uleb(1).uleb(4).L32(8) |
| // An OffsetPair that ends at -1. |
| .L8(6).L32(0) |
| .L8(4).uleb(0).uleb(0xffff_ffff).uleb(4).L32(9) |
| // A DefaultLocation |
| .L8(5).uleb(4).L32(10) |
| // A BaseAddressx + OffsetPair |
| .L8(1).uleb(0) |
| .L8(4).uleb(0x10100).uleb(0x10200).uleb(4).L32(11) |
| // A StartxEndx |
| .L8(2).uleb(1).uleb(2).uleb(4).L32(12) |
| // A StartxLength |
| .L8(3).uleb(3).uleb(0x100).uleb(4).L32(13) |
| |
| // Tombstone entries, all of which should be ignored. |
| // A BaseAddressx that is a tombstone. |
| .L8(1).uleb(4) |
| .L8(4).uleb(0x11100).uleb(0x11200).uleb(4).L32(20) |
| // A BaseAddress that is a tombstone. |
| .L8(6).L32(tombstone) |
| .L8(4).uleb(0x11300).uleb(0x11400).uleb(4).L32(21) |
| // A StartxEndx that is a tombstone. |
| .L8(2).uleb(4).uleb(5).uleb(4).L32(22) |
| // A StartxLength that is a tombstone. |
| .L8(3).uleb(4).uleb(0x100).uleb(4).L32(23) |
| // A StartEnd that is a tombstone. |
| .L8(7).L32(tombstone).L32(0x201_1500).uleb(4).L32(24) |
| // A StartLength that is a tombstone. |
| .L8(8).L32(tombstone).uleb(0x100).uleb(4).L32(25) |
| // A StartEnd (not ignored) |
| .L8(7).L32(0x201_1600).L32(0x201_1700).uleb(4).L32(26) |
| |
| // 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_loc = DebugLoc::new(&[], LittleEndian); |
| let debug_loclists = DebugLocLists::new(&buf, LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| let offset = LocationListsOffset((&first - &start) as usize); |
| let mut locations = loclists |
| .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) |
| .unwrap(); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0101_0200, |
| end: 0x0101_0300, |
| }, |
| data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A base address selection followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0400, |
| end: 0x0201_0500, |
| }, |
| data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // An empty location range followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0600, |
| end: 0x0201_0600, |
| }, |
| data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0800, |
| end: 0x0201_0900, |
| }, |
| data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0a00, |
| end: 0x0201_0b00, |
| }, |
| data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0c00, |
| end: 0x0201_0d00, |
| }, |
| data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that starts at 0. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0200_0000, |
| end: 0x0200_0001, |
| }, |
| data: Expression(EndianSlice::new(&[8, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that ends at -1. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0000_0000, |
| end: 0xffff_ffff, |
| }, |
| data: Expression(EndianSlice::new(&[9, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A DefaultLocation. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0, |
| end: u64::max_value(), |
| }, |
| data: Expression(EndianSlice::new(&[10, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A BaseAddressx + OffsetPair |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0100, |
| end: 0x0301_0200, |
| }, |
| data: Expression(EndianSlice::new(&[11, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartxEndx |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0300, |
| end: 0x0301_0400, |
| }, |
| data: Expression(EndianSlice::new(&[12, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartxLength |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0500, |
| end: 0x0301_0600, |
| }, |
| data: Expression(EndianSlice::new(&[13, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartEnd location following the tombstones |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_1600, |
| end: 0x0201_1700, |
| }, |
| data: Expression(EndianSlice::new(&[26, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location list end. |
| assert_eq!(locations.next(), Ok(None)); |
| |
| // An offset at the end of buf. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(buf.len()), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Ok(None)); |
| } |
| |
| #[test] |
| fn test_loclists_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) |
| // OffsetPair |
| .L8(4).uleb(0x10200).uleb(0x10300).uleb(4).L32(2) |
| // A base address selection followed by an OffsetPair. |
| .L8(6).L64(0x0200_0000) |
| .L8(4).uleb(0x10400).uleb(0x10500).uleb(4).L32(3) |
| // An empty OffsetPair followed by a normal OffsetPair. |
| .L8(4).uleb(0x10600).uleb(0x10600).uleb(4).L32(4) |
| .L8(4).uleb(0x10800).uleb(0x10900).uleb(4).L32(5) |
| // A StartEnd |
| .L8(7).L64(0x201_0a00).L64(0x201_0b00).uleb(4).L32(6) |
| // A StartLength |
| .L8(8).L64(0x201_0c00).uleb(0x100).uleb(4).L32(7) |
| // An OffsetPair that starts at 0. |
| .L8(4).uleb(0).uleb(1).uleb(4).L32(8) |
| // An OffsetPair that ends at -1. |
| .L8(6).L64(0) |
| .L8(4).uleb(0).uleb(0xffff_ffff).uleb(4).L32(9) |
| // A DefaultLocation |
| .L8(5).uleb(4).L32(10) |
| // A BaseAddressx + OffsetPair |
| .L8(1).uleb(0) |
| .L8(4).uleb(0x10100).uleb(0x10200).uleb(4).L32(11) |
| // A StartxEndx |
| .L8(2).uleb(1).uleb(2).uleb(4).L32(12) |
| // A StartxLength |
| .L8(3).uleb(3).uleb(0x100).uleb(4).L32(13) |
| |
| // Tombstone entries, all of which should be ignored. |
| // A BaseAddressx that is a tombstone. |
| .L8(1).uleb(4) |
| .L8(4).uleb(0x11100).uleb(0x11200).uleb(4).L32(20) |
| // A BaseAddress that is a tombstone. |
| .L8(6).L64(tombstone) |
| .L8(4).uleb(0x11300).uleb(0x11400).uleb(4).L32(21) |
| // A StartxEndx that is a tombstone. |
| .L8(2).uleb(4).uleb(5).uleb(4).L32(22) |
| // A StartxLength that is a tombstone. |
| .L8(3).uleb(4).uleb(0x100).uleb(4).L32(23) |
| // A StartEnd that is a tombstone. |
| .L8(7).L64(tombstone).L64(0x201_1500).uleb(4).L32(24) |
| // A StartLength that is a tombstone. |
| .L8(8).L64(tombstone).uleb(0x100).uleb(4).L32(25) |
| // A StartEnd (not ignored) |
| .L8(7).L64(0x201_1600).L64(0x201_1700).uleb(4).L32(26) |
| |
| // 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_loc = DebugLoc::new(&[], LittleEndian); |
| let debug_loclists = DebugLocLists::new(&buf, LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| let offset = LocationListsOffset((&first - &start) as usize); |
| let mut locations = loclists |
| .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) |
| .unwrap(); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0101_0200, |
| end: 0x0101_0300, |
| }, |
| data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A base address selection followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0400, |
| end: 0x0201_0500, |
| }, |
| data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // An empty location range followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0600, |
| end: 0x0201_0600, |
| }, |
| data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0800, |
| end: 0x0201_0900, |
| }, |
| data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0a00, |
| end: 0x0201_0b00, |
| }, |
| data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0c00, |
| end: 0x0201_0d00, |
| }, |
| data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that starts at 0. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0200_0000, |
| end: 0x0200_0001, |
| }, |
| data: Expression(EndianSlice::new(&[8, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that ends at -1. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0000_0000, |
| end: 0xffff_ffff, |
| }, |
| data: Expression(EndianSlice::new(&[9, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A DefaultLocation. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0, |
| end: u64::max_value(), |
| }, |
| data: Expression(EndianSlice::new(&[10, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A BaseAddressx + OffsetPair |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0100, |
| end: 0x0301_0200, |
| }, |
| data: Expression(EndianSlice::new(&[11, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartxEndx |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0300, |
| end: 0x0301_0400, |
| }, |
| data: Expression(EndianSlice::new(&[12, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartxLength |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0301_0500, |
| end: 0x0301_0600, |
| }, |
| data: Expression(EndianSlice::new(&[13, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A StartEnd location following the tombstones |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_1600, |
| end: 0x0201_1700, |
| }, |
| data: Expression(EndianSlice::new(&[26, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location list end. |
| assert_eq!(locations.next(), Ok(None)); |
| |
| // An offset at the end of buf. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(buf.len()), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Ok(None)); |
| } |
| |
| #[test] |
| fn test_location_list_32() { |
| let tombstone = !0u32 - 1; |
| let start = Label::new(); |
| let first = Label::new(); |
| #[rustfmt::skip] |
| let section = Section::with_endian(Endian::Little) |
| // A location before the offset. |
| .mark(&start) |
| .L32(0x10000).L32(0x10100).L16(4).L32(1) |
| .mark(&first) |
| // A normal location. |
| .L32(0x10200).L32(0x10300).L16(4).L32(2) |
| // A base address selection followed by a normal location. |
| .L32(0xffff_ffff).L32(0x0200_0000) |
| .L32(0x10400).L32(0x10500).L16(4).L32(3) |
| // An empty location range followed by a normal location. |
| .L32(0x10600).L32(0x10600).L16(4).L32(4) |
| .L32(0x10800).L32(0x10900).L16(4).L32(5) |
| // A location range that starts at 0. |
| .L32(0).L32(1).L16(4).L32(6) |
| // A location range that ends at -1. |
| .L32(0xffff_ffff).L32(0x0000_0000) |
| .L32(0).L32(0xffff_ffff).L16(4).L32(7) |
| // A normal location with tombstone. |
| .L32(tombstone).L32(tombstone).L16(4).L32(8) |
| // A base address selection with tombstone followed by a normal location. |
| .L32(0xffff_ffff).L32(tombstone) |
| .L32(0x10a00).L32(0x10b00).L16(4).L32(9) |
| // A location list end. |
| .L32(0).L32(0) |
| // Some extra data. |
| .L32(0); |
| |
| let buf = section.get_contents().unwrap(); |
| let debug_loc = DebugLoc::new(&buf, LittleEndian); |
| let debug_loclists = DebugLocLists::new(&[], LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| let offset = LocationListsOffset((&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 locations = loclists |
| .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) |
| .unwrap(); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0101_0200, |
| end: 0x0101_0300, |
| }, |
| data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A base address selection followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0400, |
| end: 0x0201_0500, |
| }, |
| data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // An empty location range followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0600, |
| end: 0x0201_0600, |
| }, |
| data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0800, |
| end: 0x0201_0900, |
| }, |
| data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that starts at 0. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0200_0000, |
| end: 0x0200_0001, |
| }, |
| data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that ends at -1. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0000_0000, |
| end: 0xffff_ffff, |
| }, |
| data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location list end. |
| assert_eq!(locations.next(), Ok(None)); |
| |
| // An offset at the end of buf. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(buf.len()), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Ok(None)); |
| } |
| |
| #[test] |
| fn test_location_list_64() { |
| let tombstone = !0u64 - 1; |
| let start = Label::new(); |
| let first = Label::new(); |
| #[rustfmt::skip] |
| let section = Section::with_endian(Endian::Little) |
| // A location before the offset. |
| .mark(&start) |
| .L64(0x10000).L64(0x10100).L16(4).L32(1) |
| .mark(&first) |
| // A normal location. |
| .L64(0x10200).L64(0x10300).L16(4).L32(2) |
| // A base address selection followed by a normal location. |
| .L64(0xffff_ffff_ffff_ffff).L64(0x0200_0000) |
| .L64(0x10400).L64(0x10500).L16(4).L32(3) |
| // An empty location range followed by a normal location. |
| .L64(0x10600).L64(0x10600).L16(4).L32(4) |
| .L64(0x10800).L64(0x10900).L16(4).L32(5) |
| // A location range that starts at 0. |
| .L64(0).L64(1).L16(4).L32(6) |
| // A location range that ends at -1. |
| .L64(0xffff_ffff_ffff_ffff).L64(0x0000_0000) |
| .L64(0).L64(0xffff_ffff_ffff_ffff).L16(4).L32(7) |
| // A normal location with tombstone. |
| .L64(tombstone).L64(tombstone).L16(4).L32(8) |
| // A base address selection with tombstone followed by a normal location. |
| .L64(0xffff_ffff_ffff_ffff).L64(tombstone) |
| .L64(0x10a00).L64(0x10b00).L16(4).L32(9) |
| // A location list end. |
| .L64(0).L64(0) |
| // Some extra data. |
| .L64(0); |
| |
| let buf = section.get_contents().unwrap(); |
| let debug_loc = DebugLoc::new(&buf, LittleEndian); |
| let debug_loclists = DebugLocLists::new(&[], LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| let offset = LocationListsOffset((&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 locations = loclists |
| .locations(offset, encoding, 0x0100_0000, debug_addr, debug_addr_base) |
| .unwrap(); |
| |
| // A normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0101_0200, |
| end: 0x0101_0300, |
| }, |
| data: Expression(EndianSlice::new(&[2, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A base address selection followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0400, |
| end: 0x0201_0500, |
| }, |
| data: Expression(EndianSlice::new(&[3, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // An empty location range followed by a normal location. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0600, |
| end: 0x0201_0600, |
| }, |
| data: Expression(EndianSlice::new(&[4, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0201_0800, |
| end: 0x0201_0900, |
| }, |
| data: Expression(EndianSlice::new(&[5, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that starts at 0. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0200_0000, |
| end: 0x0200_0001, |
| }, |
| data: Expression(EndianSlice::new(&[6, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location range that ends at -1. |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0, |
| end: 0xffff_ffff_ffff_ffff, |
| }, |
| data: Expression(EndianSlice::new(&[7, 0, 0, 0], LittleEndian)), |
| })) |
| ); |
| |
| // A location list end. |
| assert_eq!(locations.next(), Ok(None)); |
| |
| // An offset at the end of buf. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(buf.len()), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Ok(None)); |
| } |
| |
| #[test] |
| fn test_locations_invalid() { |
| #[rustfmt::skip] |
| let section = Section::with_endian(Endian::Little) |
| // An invalid location range. |
| .L32(0x20000).L32(0x10000).L16(4).L32(1) |
| // An invalid range after wrapping. |
| .L32(0x20000).L32(0xff01_0000).L16(4).L32(2); |
| |
| let buf = section.get_contents().unwrap(); |
| let debug_loc = DebugLoc::new(&buf, LittleEndian); |
| let debug_loclists = DebugLocLists::new(&[], LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| 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 location range. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(0x0), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Err(Error::InvalidLocationAddressRange)); |
| |
| // An invalid location range after wrapping. |
| let mut locations = loclists |
| .locations( |
| LocationListsOffset(14), |
| encoding, |
| 0x0100_0000, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!(locations.next(), Err(Error::InvalidLocationAddressRange)); |
| |
| // An invalid offset. |
| match loclists.locations( |
| LocationListsOffset(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_loc = DebugLoc::from(EndianSlice::new(&[], LittleEndian)); |
| let debug_loclists = DebugLocLists::from(EndianSlice::new(§ion, LittleEndian)); |
| let locations = LocationLists::new(debug_loc, debug_loclists); |
| |
| let base = DebugLocListsBase((&first - &zero) as usize); |
| assert_eq!( |
| locations.get_offset(encoding, base, DebugLocListsIndex(0)), |
| Ok(LocationListsOffset(base.0 + 1000)) |
| ); |
| assert_eq!( |
| locations.get_offset(encoding, base, DebugLocListsIndex(19)), |
| Ok(LocationListsOffset(base.0 + 1019)) |
| ); |
| } |
| } |
| |
| #[test] |
| fn test_loclists_gnu_v4_split_dwarf() { |
| #[rustfmt::skip] |
| let buf = [ |
| 0x03, // DW_LLE_startx_length |
| 0x00, // ULEB encoded b7 |
| 0x08, 0x00, 0x00, 0x00, // Fixed 4 byte length of 8 |
| 0x03, 0x00, // Fixed two byte length of the location |
| 0x11, 0x00, // DW_OP_constu 0 |
| 0x9f, // DW_OP_stack_value |
| // Padding data |
| //0x99, 0x99, 0x99, 0x99 |
| ]; |
| let data_buf = [0x11, 0x00, 0x9f]; |
| let expected_data = EndianSlice::new(&data_buf, LittleEndian); |
| let debug_loc = DebugLoc::new(&buf, LittleEndian); |
| let debug_loclists = DebugLocLists::new(&[], LittleEndian); |
| let loclists = LocationLists::new(debug_loc, debug_loclists); |
| let debug_addr = |
| &DebugAddr::from(EndianSlice::new(&[0x01, 0x02, 0x03, 0x04], LittleEndian)); |
| let debug_addr_base = DebugAddrBase(0); |
| let encoding = Encoding { |
| format: Format::Dwarf32, |
| version: 4, |
| address_size: 4, |
| }; |
| |
| // An invalid location range. |
| let mut locations = loclists |
| .locations_dwo( |
| LocationListsOffset(0x0), |
| encoding, |
| 0, |
| debug_addr, |
| debug_addr_base, |
| ) |
| .unwrap(); |
| assert_eq!( |
| locations.next(), |
| Ok(Some(LocationListEntry { |
| range: Range { |
| begin: 0x0403_0201, |
| end: 0x0403_0209 |
| }, |
| data: Expression(expected_data), |
| })) |
| ); |
| } |
| } |
