Function create_section_reader

plugins/dwarf/shared/src/lib.rs:92–192

(
    section_id: SectionId,
    view: &'a BinaryView,
    endian: Endian,
    dwo_file: bool,
)

}

pub fn create_section_reader<'a, Endian: 'a + Endianity>(
    section_id: SectionId,
    view: &'a BinaryView,
    endian: Endian,
    dwo_file: bool,
) -> Result<EndianRcSlice<Endian>, Error> {
    let section_name = if dwo_file && section_id.dwo_name().is_some() {
        section_id.dwo_name().unwrap()
    } else {
        section_id.name()
    };

    if let Some(section) = view.section_by_name(section_name) {
        // TODO : This is kinda broke....should add rust wrappers for some of this
        if let Some(symbol) = view
            .symbols()
            .iter()
            .find(|symbol| symbol.full_name().as_str() == "__elf_section_headers")
        {
            if let Some(data_var) = view
                .data_variables()
                .iter()
                .find(|var| var.address == symbol.address())
            {
                // TODO : This should eventually be wrapped by some DataView sorta thingy thing, like how python does it
                let data_type = &data_var.ty.contents;
                let data = view.read_vec(data_var.address, data_type.width() as usize);
                let element_type = data_type.element_type().unwrap().contents;

                if let Some(current_section_header) = data
                    .chunks(element_type.width() as usize)
                    .find(|section_header| {
                        if view.address_size() == 4 {
                            endian.read_u32(&section_header[16..20]) as u64 == section.start()
                        } else {
                            endian.read_u64(&section_header[24..32]) == section.start()
                        }
                    })
                {
                    let section_flags = if view.address_size() == 4 {
                        endian.read_u32(&current_section_header[8..12]) as u64
                    } else {
                        endian.read_u64(&current_section_header[8..16])
                    };
                    // If the section has the compressed bit set
                    if (section_flags & 2048) != 0 {
                        // Get section, trim header, decompress, return
                        let compressed_header_size = view.address_size() * 3;

                        let offset = section.start() + compressed_header_size as u64;
                        let len = section.len() - compressed_header_size;

                        let ch_type_vec = view.read_vec(section.start(), 4);
                        let ch_type = endian.read_u32(&ch_type_vec);

                        if let Ok(buffer) = view.read_buffer(offset, len) {
                            match ch_type {
                                1 => {