gimli/write/

abbrev.rs

use alloc::vec::Vec;
use core::ops::{Deref, DerefMut};

use crate::common::{DebugAbbrevOffset, SectionId};
use crate::constants;
use crate::write::{FnvIndexSet, Result, Section, Writer};

/// A table of abbreviations that will be stored in a `.debug_abbrev` section.
// Requirements:
// - values are `Abbreviation`
// - insertion returns an abbreviation code for use in writing a DIE
// - inserting a duplicate returns the code of the existing value
#[derive(Debug, Default)]
pub(crate) struct AbbreviationTable {
    abbrevs: FnvIndexSet<Abbreviation>,
}

impl AbbreviationTable {
    /// Add an abbreviation to the table and return its code.
    pub fn add(&mut self, abbrev: Abbreviation) -> u64 {
        let (code, _) = self.abbrevs.insert_full(abbrev);
        // Code must be non-zero
        (code + 1) as u64
    }

    /// Write the abbreviation table to the `.debug_abbrev` section.
    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {
        for (code, abbrev) in self.abbrevs.iter().enumerate() {
            w.write_uleb128((code + 1) as u64)?;
            abbrev.write(w)?;
        }
        // Null abbreviation code
        w.write_u8(0)
    }
}

/// An abbreviation describes the shape of a `DebuggingInformationEntry`'s type:
/// its tag type, whether it has children, and its set of attributes.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct Abbreviation {
    tag: constants::DwTag,
    has_children: bool,
    attributes: Vec<AttributeSpecification>,
}

impl Abbreviation {
    /// Construct a new `Abbreviation`.
    #[inline]
    pub fn new(
        tag: constants::DwTag,
        has_children: bool,
        attributes: Vec<AttributeSpecification>,
    ) -> Abbreviation {
        Abbreviation {
            tag,
            has_children,
            attributes,
        }
    }

    /// Write the abbreviation to the `.debug_abbrev` section.
    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {
        w.write_uleb128(self.tag.0.into())?;
        w.write_u8(if self.has_children {
            constants::DW_CHILDREN_yes.0
        } else {
            constants::DW_CHILDREN_no.0
        })?;
        for attr in &self.attributes {
            attr.write(w)?;
        }
        // Null name and form
        w.write_u8(0)?;
        w.write_u8(0)
    }
}

/// The description of an attribute in an abbreviated type.
// TODO: support implicit const
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct AttributeSpecification {
    name: constants::DwAt,
    form: constants::DwForm,
    implicit_const_value: i64,
}

impl AttributeSpecification {
    /// Construct a new `AttributeSpecification`.
    #[inline]
    pub fn new(
        name: constants::DwAt,
        form: constants::DwForm,
        implicit_const_value: Option<i64>,
    ) -> AttributeSpecification {
        debug_assert_eq!(
            form == constants::DW_FORM_implicit_const,
            implicit_const_value.is_some()
        );
        AttributeSpecification {
            name,
            form,
            implicit_const_value: implicit_const_value.unwrap_or(0),
        }
    }

    /// Write the attribute specification to the `.debug_abbrev` section.
    #[inline]
    pub fn write<W: Writer>(&self, w: &mut DebugAbbrev<W>) -> Result<()> {
        w.write_uleb128(self.name.0.into())?;
        w.write_uleb128(self.form.0.into())?;
        if self.form == constants::DW_FORM_implicit_const {
            w.write_sleb128(self.implicit_const_value)?;
        }
        Ok(())
    }
}

define_section!(
    DebugAbbrev,
    DebugAbbrevOffset,
    "A writable `.debug_abbrev` section."
);

#[cfg(test)]
#[cfg(feature = "read")]
mod tests {
    use super::*;
    use crate::LittleEndian;
    use crate::constants;
    use crate::read;
    use crate::write::EndianVec;

    #[test]
    fn test_abbreviation_table() {
        let mut abbrevs = AbbreviationTable::default();
        let abbrev1 = Abbreviation::new(
            constants::DW_TAG_subprogram,
            false,
            vec![AttributeSpecification::new(
                constants::DW_AT_name,
                constants::DW_FORM_string,
                None,
            )],
        );
        let abbrev2 = Abbreviation::new(
            constants::DW_TAG_compile_unit,
            true,
            vec![
                AttributeSpecification::new(
                    constants::DW_AT_producer,
                    constants::DW_FORM_strp,
                    None,
                ),
                AttributeSpecification::new(
                    constants::DW_AT_language,
                    constants::DW_FORM_data2,
                    None,
                ),
            ],
        );
        let code1 = abbrevs.add(abbrev1.clone());
        assert_eq!(code1, 1);
        let code2 = abbrevs.add(abbrev2.clone());
        assert_eq!(code2, 2);
        assert_eq!(abbrevs.add(abbrev1.clone()), code1);
        assert_eq!(abbrevs.add(abbrev2.clone()), code2);

        let mut debug_abbrev = DebugAbbrev::from(EndianVec::new(LittleEndian));
        let debug_abbrev_offset = debug_abbrev.offset();
        assert_eq!(debug_abbrev_offset, DebugAbbrevOffset(0));
        abbrevs.write(&mut debug_abbrev).unwrap();
        assert_eq!(debug_abbrev.offset(), DebugAbbrevOffset(17));

        let read_debug_abbrev = read::DebugAbbrev::new(debug_abbrev.slice(), LittleEndian);
        let read_abbrevs = read_debug_abbrev
            .abbreviations(debug_abbrev_offset)
            .unwrap();

        let read_abbrev1 = read_abbrevs.get(code1).unwrap();
        assert_eq!(abbrev1.tag, read_abbrev1.tag());
        assert_eq!(abbrev1.has_children, read_abbrev1.has_children());
        assert_eq!(abbrev1.attributes.len(), read_abbrev1.attributes().len());
        assert_eq!(
            abbrev1.attributes[0].name,
            read_abbrev1.attributes()[0].name()
        );
        assert_eq!(
            abbrev1.attributes[0].form,
            read_abbrev1.attributes()[0].form()
        );

        let read_abbrev2 = read_abbrevs.get(code2).unwrap();
        assert_eq!(abbrev2.tag, read_abbrev2.tag());
        assert_eq!(abbrev2.has_children, read_abbrev2.has_children());
        assert_eq!(abbrev2.attributes.len(), read_abbrev2.attributes().len());
        assert_eq!(
            abbrev2.attributes[0].name,
            read_abbrev2.attributes()[0].name()
        );
        assert_eq!(
            abbrev2.attributes[0].form,
            read_abbrev2.attributes()[0].form()
        );
        assert_eq!(
            abbrev2.attributes[1].name,
            read_abbrev2.attributes()[1].name()
        );
        assert_eq!(
            abbrev2.attributes[1].form,
            read_abbrev2.attributes()[1].form()
        );
    }
}