use alloc::string::String;
use alloc::vec::Vec;
use crate::error::Result;
use crate::ident::{ElfClass, Endian};
use crate::reader::ReadAt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SectionType(pub u32);
impl SectionType {
pub const NULL: Self = Self(0);
pub const PROGBITS: Self = Self(1);
pub const SYMTAB: Self = Self(2);
pub const STRTAB: Self = Self(3);
pub const RELA: Self = Self(4);
pub const HASH: Self = Self(5);
pub const DYNAMIC: Self = Self(6);
pub const NOTE: Self = Self(7);
pub const NOBITS: Self = Self(8);
pub const REL: Self = Self(9);
pub const SHLIB: Self = Self(10);
pub const DYNSYM: Self = Self(11);
pub const INIT_ARRAY: Self = Self(14);
pub const FINI_ARRAY: Self = Self(15);
pub const PREINIT_ARRAY: Self = Self(16);
pub const GROUP: Self = Self(17);
pub const SYMTAB_SHNDX: Self = Self(18);
pub const RELR: Self = Self(19);
pub const GNU_HASH: Self = Self(0x6fff_fff6);
pub const GNU_VERDEF: Self = Self(0x6fff_fffd);
pub const GNU_VERNEED: Self = Self(0x6fff_fffe);
pub const GNU_VERSYM: Self = Self(0x6fff_ffff);
#[must_use]
pub const fn value(self) -> u32 {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct SectionFlags(pub u64);
impl SectionFlags {
pub const WRITE: u64 = 1;
pub const ALLOC: u64 = 2;
pub const EXECINSTR: u64 = 4;
#[must_use]
pub const fn value(self) -> u64 {
self.0
}
#[must_use]
pub const fn is_alloc(self) -> bool {
self.0 & Self::ALLOC != 0
}
#[must_use]
pub const fn is_writable(self) -> bool {
self.0 & Self::WRITE != 0
}
#[must_use]
pub const fn is_executable(self) -> bool {
self.0 & Self::EXECINSTR != 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SectionHeader {
pub name_index: u32,
pub r#type: SectionType,
pub flags: SectionFlags,
pub addr: u64,
pub offset: u64,
pub size: u64,
pub link: u32,
pub info: u32,
pub addralign: u64,
pub entsize: u64,
}
impl SectionHeader {
#[must_use]
pub const fn size(class: ElfClass) -> u64 {
match class {
ElfClass::Elf32 => 40,
ElfClass::Elf64 => 64,
}
}
pub fn parse<R: ReadAt>(
reader: &R,
offset: u64,
endian: Endian,
class: ElfClass,
) -> Result<Self> {
match class {
ElfClass::Elf64 => Ok(Self {
name_index: reader.read_u32_at(offset, endian)?,
r#type: SectionType(reader.read_u32_at(offset + 4, endian)?),
flags: SectionFlags(reader.read_u64_at(offset + 8, endian)?),
addr: reader.read_u64_at(offset + 16, endian)?,
offset: reader.read_u64_at(offset + 24, endian)?,
size: reader.read_u64_at(offset + 32, endian)?,
link: reader.read_u32_at(offset + 40, endian)?,
info: reader.read_u32_at(offset + 44, endian)?,
addralign: reader.read_u64_at(offset + 48, endian)?,
entsize: reader.read_u64_at(offset + 56, endian)?,
}),
ElfClass::Elf32 => Ok(Self {
name_index: reader.read_u32_at(offset, endian)?,
r#type: SectionType(reader.read_u32_at(offset + 4, endian)?),
flags: SectionFlags(u64::from(reader.read_u32_at(offset + 8, endian)?)),
addr: u64::from(reader.read_u32_at(offset + 12, endian)?),
offset: u64::from(reader.read_u32_at(offset + 16, endian)?),
size: u64::from(reader.read_u32_at(offset + 20, endian)?),
link: reader.read_u32_at(offset + 24, endian)?,
info: reader.read_u32_at(offset + 28, endian)?,
addralign: u64::from(reader.read_u32_at(offset + 32, endian)?),
entsize: u64::from(reader.read_u32_at(offset + 36, endian)?),
}),
}
}
pub fn write(&self, out: &mut Vec<u8>, endian: Endian, class: ElfClass) {
match class {
ElfClass::Elf64 => {
out.extend_from_slice(&endian.u32_bytes(self.name_index));
out.extend_from_slice(&endian.u32_bytes(self.r#type.0));
out.extend_from_slice(&endian.u64_bytes(self.flags.0));
out.extend_from_slice(&endian.u64_bytes(self.addr));
out.extend_from_slice(&endian.u64_bytes(self.offset));
out.extend_from_slice(&endian.u64_bytes(self.size));
out.extend_from_slice(&endian.u32_bytes(self.link));
out.extend_from_slice(&endian.u32_bytes(self.info));
out.extend_from_slice(&endian.u64_bytes(self.addralign));
out.extend_from_slice(&endian.u64_bytes(self.entsize));
}
ElfClass::Elf32 => {
out.extend_from_slice(&endian.u32_bytes(self.name_index));
out.extend_from_slice(&endian.u32_bytes(self.r#type.0));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.flags.0)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.addr)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.offset)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.size)));
out.extend_from_slice(&endian.u32_bytes(self.link));
out.extend_from_slice(&endian.u32_bytes(self.info));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.addralign)));
out.extend_from_slice(&endian.u32_bytes(crate::low32(self.entsize)));
}
}
}
#[must_use]
pub const fn is_nobits(&self) -> bool {
self.r#type.0 == SectionType::NOBITS.0
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Section {
pub header: SectionHeader,
pub name: String,
pub data: Vec<u8>,
}
impl Section {
#[must_use]
pub const fn new(header: SectionHeader, name: String, data: Vec<u8>) -> Self {
Self { header, name, data }
}
#[must_use]
pub const fn flags(&self) -> SectionFlags {
self.header.flags
}
#[must_use]
pub const fn section_type(&self) -> SectionType {
self.header.r#type
}
#[must_use]
pub const fn contains_vaddr(&self, vaddr: u64) -> bool {
self.header.flags.is_alloc()
&& vaddr >= self.header.addr
&& vaddr < self.header.addr.saturating_add(self.header.size)
}
}