Initial vendor packages
Signed-off-by: Valentin Popov <valentin@popov.link>
This commit is contained in:
535
vendor/gimli/src/read/index.rs
vendored
Normal file
535
vendor/gimli/src/read/index.rs
vendored
Normal file
@ -0,0 +1,535 @@
|
||||
use core::slice;
|
||||
|
||||
use crate::common::SectionId;
|
||||
use crate::constants;
|
||||
use crate::endianity::Endianity;
|
||||
use crate::read::{EndianSlice, Error, Reader, ReaderOffset, Result, Section};
|
||||
|
||||
/// The data in the `.debug_cu_index` section of a `.dwp` file.
|
||||
///
|
||||
/// This section contains the compilation unit index.
|
||||
#[derive(Debug, Default, Clone, Copy)]
|
||||
pub struct DebugCuIndex<R> {
|
||||
section: R,
|
||||
}
|
||||
|
||||
impl<'input, Endian> DebugCuIndex<EndianSlice<'input, Endian>>
|
||||
where
|
||||
Endian: Endianity,
|
||||
{
|
||||
/// Construct a new `DebugCuIndex` instance from the data in the `.debug_cu_index`
|
||||
/// section.
|
||||
pub fn new(section: &'input [u8], endian: Endian) -> Self {
|
||||
Self::from(EndianSlice::new(section, endian))
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> Section<R> for DebugCuIndex<R> {
|
||||
fn id() -> SectionId {
|
||||
SectionId::DebugCuIndex
|
||||
}
|
||||
|
||||
fn reader(&self) -> &R {
|
||||
&self.section
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> From<R> for DebugCuIndex<R> {
|
||||
fn from(section: R) -> Self {
|
||||
DebugCuIndex { section }
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: Reader> DebugCuIndex<R> {
|
||||
/// Parse the index header.
|
||||
pub fn index(self) -> Result<UnitIndex<R>> {
|
||||
UnitIndex::parse(self.section)
|
||||
}
|
||||
}
|
||||
|
||||
/// The data in the `.debug_tu_index` section of a `.dwp` file.
|
||||
///
|
||||
/// This section contains the type unit index.
|
||||
#[derive(Debug, Default, Clone, Copy)]
|
||||
pub struct DebugTuIndex<R> {
|
||||
section: R,
|
||||
}
|
||||
|
||||
impl<'input, Endian> DebugTuIndex<EndianSlice<'input, Endian>>
|
||||
where
|
||||
Endian: Endianity,
|
||||
{
|
||||
/// Construct a new `DebugTuIndex` instance from the data in the `.debug_tu_index`
|
||||
/// section.
|
||||
pub fn new(section: &'input [u8], endian: Endian) -> Self {
|
||||
Self::from(EndianSlice::new(section, endian))
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> Section<R> for DebugTuIndex<R> {
|
||||
fn id() -> SectionId {
|
||||
SectionId::DebugTuIndex
|
||||
}
|
||||
|
||||
fn reader(&self) -> &R {
|
||||
&self.section
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> From<R> for DebugTuIndex<R> {
|
||||
fn from(section: R) -> Self {
|
||||
DebugTuIndex { section }
|
||||
}
|
||||
}
|
||||
|
||||
impl<R: Reader> DebugTuIndex<R> {
|
||||
/// Parse the index header.
|
||||
pub fn index(self) -> Result<UnitIndex<R>> {
|
||||
UnitIndex::parse(self.section)
|
||||
}
|
||||
}
|
||||
|
||||
const SECTION_COUNT_MAX: u8 = 8;
|
||||
|
||||
/// The partially parsed index from a `DebugCuIndex` or `DebugTuIndex`.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct UnitIndex<R: Reader> {
|
||||
version: u16,
|
||||
section_count: u32,
|
||||
unit_count: u32,
|
||||
slot_count: u32,
|
||||
hash_ids: R,
|
||||
hash_rows: R,
|
||||
// Only `section_count` values are valid.
|
||||
sections: [SectionId; SECTION_COUNT_MAX as usize],
|
||||
offsets: R,
|
||||
sizes: R,
|
||||
}
|
||||
|
||||
impl<R: Reader> UnitIndex<R> {
|
||||
fn parse(mut input: R) -> Result<UnitIndex<R>> {
|
||||
if input.is_empty() {
|
||||
return Ok(UnitIndex {
|
||||
version: 5,
|
||||
section_count: 0,
|
||||
unit_count: 0,
|
||||
slot_count: 0,
|
||||
hash_ids: input.clone(),
|
||||
hash_rows: input.clone(),
|
||||
sections: [SectionId::DebugAbbrev; SECTION_COUNT_MAX as usize],
|
||||
offsets: input.clone(),
|
||||
sizes: input.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
// GNU split-dwarf extension to DWARF 4 uses a 32-bit version,
|
||||
// but DWARF 5 uses a 16-bit version followed by 16-bit padding.
|
||||
let mut original_input = input.clone();
|
||||
let version;
|
||||
if input.read_u32()? == 2 {
|
||||
version = 2
|
||||
} else {
|
||||
version = original_input.read_u16()?;
|
||||
if version != 5 {
|
||||
return Err(Error::UnknownVersion(version.into()));
|
||||
}
|
||||
}
|
||||
|
||||
let section_count = input.read_u32()?;
|
||||
let unit_count = input.read_u32()?;
|
||||
let slot_count = input.read_u32()?;
|
||||
if slot_count == 0 || slot_count & (slot_count - 1) != 0 || slot_count <= unit_count {
|
||||
return Err(Error::InvalidIndexSlotCount);
|
||||
}
|
||||
|
||||
let hash_ids = input.split(R::Offset::from_u64(u64::from(slot_count) * 8)?)?;
|
||||
let hash_rows = input.split(R::Offset::from_u64(u64::from(slot_count) * 4)?)?;
|
||||
|
||||
let mut sections = [SectionId::DebugAbbrev; SECTION_COUNT_MAX as usize];
|
||||
if section_count > SECTION_COUNT_MAX.into() {
|
||||
return Err(Error::InvalidIndexSectionCount);
|
||||
}
|
||||
for i in 0..section_count {
|
||||
let section = input.read_u32()?;
|
||||
sections[i as usize] = if version == 2 {
|
||||
match constants::DwSectV2(section) {
|
||||
constants::DW_SECT_V2_INFO => SectionId::DebugInfo,
|
||||
constants::DW_SECT_V2_TYPES => SectionId::DebugTypes,
|
||||
constants::DW_SECT_V2_ABBREV => SectionId::DebugAbbrev,
|
||||
constants::DW_SECT_V2_LINE => SectionId::DebugLine,
|
||||
constants::DW_SECT_V2_LOC => SectionId::DebugLoc,
|
||||
constants::DW_SECT_V2_STR_OFFSETS => SectionId::DebugStrOffsets,
|
||||
constants::DW_SECT_V2_MACINFO => SectionId::DebugMacinfo,
|
||||
constants::DW_SECT_V2_MACRO => SectionId::DebugMacro,
|
||||
_ => return Err(Error::UnknownIndexSection),
|
||||
}
|
||||
} else {
|
||||
match constants::DwSect(section) {
|
||||
constants::DW_SECT_INFO => SectionId::DebugInfo,
|
||||
constants::DW_SECT_ABBREV => SectionId::DebugAbbrev,
|
||||
constants::DW_SECT_LINE => SectionId::DebugLine,
|
||||
constants::DW_SECT_LOCLISTS => SectionId::DebugLocLists,
|
||||
constants::DW_SECT_STR_OFFSETS => SectionId::DebugStrOffsets,
|
||||
constants::DW_SECT_MACRO => SectionId::DebugMacro,
|
||||
constants::DW_SECT_RNGLISTS => SectionId::DebugRngLists,
|
||||
_ => return Err(Error::UnknownIndexSection),
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
let offsets = input.split(R::Offset::from_u64(
|
||||
u64::from(unit_count) * u64::from(section_count) * 4,
|
||||
)?)?;
|
||||
let sizes = input.split(R::Offset::from_u64(
|
||||
u64::from(unit_count) * u64::from(section_count) * 4,
|
||||
)?)?;
|
||||
|
||||
Ok(UnitIndex {
|
||||
version,
|
||||
section_count,
|
||||
unit_count,
|
||||
slot_count,
|
||||
hash_ids,
|
||||
hash_rows,
|
||||
sections,
|
||||
offsets,
|
||||
sizes,
|
||||
})
|
||||
}
|
||||
|
||||
/// Find `id` in the index hash table, and return the row index.
|
||||
///
|
||||
/// `id` may be a compilation unit ID if this index is from `.debug_cu_index`,
|
||||
/// or a type signature if this index is from `.debug_tu_index`.
|
||||
pub fn find(&self, id: u64) -> Option<u32> {
|
||||
if self.slot_count == 0 {
|
||||
return None;
|
||||
}
|
||||
let mask = u64::from(self.slot_count - 1);
|
||||
let mut hash1 = id & mask;
|
||||
let hash2 = ((id >> 32) & mask) | 1;
|
||||
for _ in 0..self.slot_count {
|
||||
// The length of these arrays was validated in `UnitIndex::parse`.
|
||||
let mut hash_ids = self.hash_ids.clone();
|
||||
hash_ids.skip(R::Offset::from_u64(hash1 * 8).ok()?).ok()?;
|
||||
let hash_id = hash_ids.read_u64().ok()?;
|
||||
if hash_id == id {
|
||||
let mut hash_rows = self.hash_rows.clone();
|
||||
hash_rows.skip(R::Offset::from_u64(hash1 * 4).ok()?).ok()?;
|
||||
let hash_row = hash_rows.read_u32().ok()?;
|
||||
return Some(hash_row);
|
||||
}
|
||||
if hash_id == 0 {
|
||||
return None;
|
||||
}
|
||||
hash1 = (hash1 + hash2) & mask;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Return the section offsets and sizes for the given row index.
|
||||
pub fn sections(&self, mut row: u32) -> Result<UnitIndexSectionIterator<R>> {
|
||||
if row == 0 {
|
||||
return Err(Error::InvalidIndexRow);
|
||||
}
|
||||
row -= 1;
|
||||
if row >= self.unit_count {
|
||||
return Err(Error::InvalidIndexRow);
|
||||
}
|
||||
let mut offsets = self.offsets.clone();
|
||||
offsets.skip(R::Offset::from_u64(
|
||||
u64::from(row) * u64::from(self.section_count) * 4,
|
||||
)?)?;
|
||||
let mut sizes = self.sizes.clone();
|
||||
sizes.skip(R::Offset::from_u64(
|
||||
u64::from(row) * u64::from(self.section_count) * 4,
|
||||
)?)?;
|
||||
Ok(UnitIndexSectionIterator {
|
||||
sections: self.sections[..self.section_count as usize].iter(),
|
||||
offsets,
|
||||
sizes,
|
||||
})
|
||||
}
|
||||
|
||||
/// Return the version.
|
||||
pub fn version(&self) -> u16 {
|
||||
self.version
|
||||
}
|
||||
|
||||
/// Return the number of sections.
|
||||
pub fn section_count(&self) -> u32 {
|
||||
self.section_count
|
||||
}
|
||||
|
||||
/// Return the number of units.
|
||||
pub fn unit_count(&self) -> u32 {
|
||||
self.unit_count
|
||||
}
|
||||
|
||||
/// Return the number of slots.
|
||||
pub fn slot_count(&self) -> u32 {
|
||||
self.slot_count
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator over the section offsets and sizes for a row in a `UnitIndex`.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct UnitIndexSectionIterator<'index, R: Reader> {
|
||||
sections: slice::Iter<'index, SectionId>,
|
||||
offsets: R,
|
||||
sizes: R,
|
||||
}
|
||||
|
||||
impl<'index, R: Reader> Iterator for UnitIndexSectionIterator<'index, R> {
|
||||
type Item = UnitIndexSection;
|
||||
|
||||
fn next(&mut self) -> Option<UnitIndexSection> {
|
||||
let section = *self.sections.next()?;
|
||||
// The length of these arrays was validated in `UnitIndex::parse`.
|
||||
let offset = self.offsets.read_u32().ok()?;
|
||||
let size = self.sizes.read_u32().ok()?;
|
||||
Some(UnitIndexSection {
|
||||
section,
|
||||
offset,
|
||||
size,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Information about a unit's contribution to a section in a `.dwp` file.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct UnitIndexSection {
|
||||
/// The section kind.
|
||||
pub section: SectionId,
|
||||
/// The base offset of the unit's contribution to the section.
|
||||
pub offset: u32,
|
||||
/// The size of the unit's contribution to the section.
|
||||
pub size: u32,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::endianity::BigEndian;
|
||||
use test_assembler::{Endian, Section};
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
let buf = EndianSlice::new(&[], BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert!(index.find(0).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_2() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D32(2).D32(0).D32(0).D32(1)
|
||||
// Slots.
|
||||
.D64(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert_eq!(index.version, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_5() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D16(5).D16(0).D32(0).D32(0).D32(1)
|
||||
// Slots.
|
||||
.D64(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert_eq!(index.version, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_5_invalid() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D32(5).D32(0).D32(0).D32(1)
|
||||
// Slots.
|
||||
.D64(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
assert!(UnitIndex::parse(buf).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_2_sections() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D32(2).D32(8).D32(1).D32(2)
|
||||
// Slots.
|
||||
.D64(0).D64(0).D32(0).D32(0)
|
||||
// Sections.
|
||||
.D32(constants::DW_SECT_V2_INFO.0)
|
||||
.D32(constants::DW_SECT_V2_TYPES.0)
|
||||
.D32(constants::DW_SECT_V2_ABBREV.0)
|
||||
.D32(constants::DW_SECT_V2_LINE.0)
|
||||
.D32(constants::DW_SECT_V2_LOC.0)
|
||||
.D32(constants::DW_SECT_V2_STR_OFFSETS.0)
|
||||
.D32(constants::DW_SECT_V2_MACINFO.0)
|
||||
.D32(constants::DW_SECT_V2_MACRO.0)
|
||||
// Offsets.
|
||||
.D32(11).D32(12).D32(13).D32(14).D32(15).D32(16).D32(17).D32(18)
|
||||
// Sizes.
|
||||
.D32(21).D32(22).D32(23).D32(24).D32(25).D32(26).D32(27).D32(28);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert_eq!(index.section_count, 8);
|
||||
assert_eq!(
|
||||
index.sections,
|
||||
[
|
||||
SectionId::DebugInfo,
|
||||
SectionId::DebugTypes,
|
||||
SectionId::DebugAbbrev,
|
||||
SectionId::DebugLine,
|
||||
SectionId::DebugLoc,
|
||||
SectionId::DebugStrOffsets,
|
||||
SectionId::DebugMacinfo,
|
||||
SectionId::DebugMacro,
|
||||
]
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
let expect = [
|
||||
UnitIndexSection { section: SectionId::DebugInfo, offset: 11, size: 21 },
|
||||
UnitIndexSection { section: SectionId::DebugTypes, offset: 12, size: 22 },
|
||||
UnitIndexSection { section: SectionId::DebugAbbrev, offset: 13, size: 23 },
|
||||
UnitIndexSection { section: SectionId::DebugLine, offset: 14, size: 24 },
|
||||
UnitIndexSection { section: SectionId::DebugLoc, offset: 15, size: 25 },
|
||||
UnitIndexSection { section: SectionId::DebugStrOffsets, offset: 16, size: 26 },
|
||||
UnitIndexSection { section: SectionId::DebugMacinfo, offset: 17, size: 27 },
|
||||
UnitIndexSection { section: SectionId::DebugMacro, offset: 18, size: 28 },
|
||||
];
|
||||
let mut sections = index.sections(1).unwrap();
|
||||
for section in &expect {
|
||||
assert_eq!(*section, sections.next().unwrap());
|
||||
}
|
||||
assert!(sections.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_version_5_sections() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D16(5).D16(0).D32(7).D32(1).D32(2)
|
||||
// Slots.
|
||||
.D64(0).D64(0).D32(0).D32(0)
|
||||
// Sections.
|
||||
.D32(constants::DW_SECT_INFO.0)
|
||||
.D32(constants::DW_SECT_ABBREV.0)
|
||||
.D32(constants::DW_SECT_LINE.0)
|
||||
.D32(constants::DW_SECT_LOCLISTS.0)
|
||||
.D32(constants::DW_SECT_STR_OFFSETS.0)
|
||||
.D32(constants::DW_SECT_MACRO.0)
|
||||
.D32(constants::DW_SECT_RNGLISTS.0)
|
||||
// Offsets.
|
||||
.D32(11).D32(12).D32(13).D32(14).D32(15).D32(16).D32(17)
|
||||
// Sizes.
|
||||
.D32(21).D32(22).D32(23).D32(24).D32(25).D32(26).D32(27);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert_eq!(index.section_count, 7);
|
||||
assert_eq!(
|
||||
index.sections[..7],
|
||||
[
|
||||
SectionId::DebugInfo,
|
||||
SectionId::DebugAbbrev,
|
||||
SectionId::DebugLine,
|
||||
SectionId::DebugLocLists,
|
||||
SectionId::DebugStrOffsets,
|
||||
SectionId::DebugMacro,
|
||||
SectionId::DebugRngLists,
|
||||
]
|
||||
);
|
||||
#[rustfmt::skip]
|
||||
let expect = [
|
||||
UnitIndexSection { section: SectionId::DebugInfo, offset: 11, size: 21 },
|
||||
UnitIndexSection { section: SectionId::DebugAbbrev, offset: 12, size: 22 },
|
||||
UnitIndexSection { section: SectionId::DebugLine, offset: 13, size: 23 },
|
||||
UnitIndexSection { section: SectionId::DebugLocLists, offset: 14, size: 24 },
|
||||
UnitIndexSection { section: SectionId::DebugStrOffsets, offset: 15, size: 25 },
|
||||
UnitIndexSection { section: SectionId::DebugMacro, offset: 16, size: 26 },
|
||||
UnitIndexSection { section: SectionId::DebugRngLists, offset: 17, size: 27 },
|
||||
];
|
||||
let mut sections = index.sections(1).unwrap();
|
||||
for section in &expect {
|
||||
assert_eq!(*section, sections.next().unwrap());
|
||||
}
|
||||
assert!(sections.next().is_none());
|
||||
|
||||
assert!(index.sections(0).is_err());
|
||||
assert!(index.sections(2).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_hash() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D16(5).D16(0).D32(2).D32(3).D32(4)
|
||||
// Slots.
|
||||
.D64(0xffff_fff2_ffff_fff1)
|
||||
.D64(0xffff_fff0_ffff_fff1)
|
||||
.D64(0xffff_fff1_ffff_fff1)
|
||||
.D64(0)
|
||||
.D32(3).D32(1).D32(2).D32(0)
|
||||
// Sections.
|
||||
.D32(constants::DW_SECT_INFO.0)
|
||||
.D32(constants::DW_SECT_ABBREV.0)
|
||||
// Offsets.
|
||||
.D32(0).D32(0).D32(0).D32(0).D32(0).D32(0)
|
||||
// Sizes.
|
||||
.D32(0).D32(0).D32(0).D32(0).D32(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let buf = EndianSlice::new(&buf, BigEndian);
|
||||
let index = UnitIndex::parse(buf).unwrap();
|
||||
assert_eq!(index.version(), 5);
|
||||
assert_eq!(index.slot_count(), 4);
|
||||
assert_eq!(index.unit_count(), 3);
|
||||
assert_eq!(index.section_count(), 2);
|
||||
assert_eq!(index.find(0xffff_fff0_ffff_fff1), Some(1));
|
||||
assert_eq!(index.find(0xffff_fff1_ffff_fff1), Some(2));
|
||||
assert_eq!(index.find(0xffff_fff2_ffff_fff1), Some(3));
|
||||
assert_eq!(index.find(0xffff_fff3_ffff_fff1), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_cu_index() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D16(5).D16(0).D32(0).D32(0).D32(1)
|
||||
// Slots.
|
||||
.D64(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let cu_index = DebugCuIndex::new(&buf, BigEndian);
|
||||
let index = cu_index.index().unwrap();
|
||||
assert_eq!(index.version, 5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tu_index() {
|
||||
#[rustfmt::skip]
|
||||
let section = Section::with_endian(Endian::Big)
|
||||
// Header.
|
||||
.D16(5).D16(0).D32(0).D32(0).D32(1)
|
||||
// Slots.
|
||||
.D64(0).D32(0);
|
||||
let buf = section.get_contents().unwrap();
|
||||
let tu_index = DebugTuIndex::new(&buf, BigEndian);
|
||||
let index = tu_index.index().unwrap();
|
||||
assert_eq!(index.version, 5);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user