| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/third_party/rust/object/src/build/ (Browser von der Mozilla Stiftung Version 136.0.1©) Datei vom 10.2.2025 mit Größe 116 kB |
|
Impressum elf.rs
Interaktion und |
|
|
Spracherkennung für: .rs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen] //! This module provides a [`Builder`] for reading, modifying, and then writing ELF files.
use alloc::vec::Vec; use core::convert::TryInto; use core::fmt; use core::marker::PhantomData; #[cfg(not(feature = "std"))] use hashbrown::HashMap; #[cfg(feature = "std")] use std::collections::HashMap; use crate::build::{ByteString, Bytes, Error, Id, IdPrivate, Item, Result, Table}; use crate::elf; use crate::read::elf::{Dyn, FileHeader, ProgramHeader, Rela, SectionHeader, Sym}; use crate::read::{self, FileKind, ReadRef}; use crate::write; use crate::Endianness; /// A builder for reading, modifying, and then writing ELF files. /// /// Public fields are available for modifying the values that will be written. /// Methods are available to add elements to tables, and elements can be deleted /// from tables by setting the `delete` field in the element. #[derive(Debug)] pub struct Builder<'data> { /// The endianness. /// /// Used to set the data encoding when writing the ELF file. pub endian: Endianness, /// Whether file is 64-bit. /// /// Use to set the file class when writing the ELF file. pub is_64: bool, /// The alignment of [`elf::PT_LOAD`] segments. /// /// This is an informational field and is not used when writing the ELF file. /// It can optionally be used when calling [`Segments::add_load_segment`]. /// /// It is determined heuristically when reading the ELF file. Currently, /// if all load segments have the same alignment, that alignment is used, /// otherwise it is set to 1. pub load_align: u64, /// The file header. pub header: Header, /// The segment table. pub segments: Segments<'data>, /// The section table. pub sections: Sections<'data>, /// The symbol table. pub symbols: Symbols<'data>, /// The dynamic symbol table. pub dynamic_symbols: DynamicSymbols<'data>, /// The base version for the GNU version definitions. /// /// This will be written as a version definition with index 1. pub version_base: Option<ByteString<'data>>, /// The GNU version definitions and dependencies. pub versions: Versions<'data>, /// The filenames used in the GNU version definitions. pub version_files: VersionFiles<'data>, /// The bucket count parameter for the hash table. pub hash_bucket_count: u32, /// The bloom shift parameter for the GNU hash table. pub gnu_hash_bloom_shift: u32, /// The bloom count parameter for the GNU hash table. pub gnu_hash_bloom_count: u32, /// The bucket count parameter for the GNU hash table. pub gnu_hash_bucket_count: u32, marker: PhantomData<()>, } impl<'data> Builder<'data> { /// Create a new ELF builder. pub fn new(endian: Endianness, is_64: bool) -> Self { Self { endian, is_64, load_align: 1, header: Header::default(), segments: Segments::new(), sections: Sections::new(), symbols: Symbols::new(), dynamic_symbols: Symbols::new(), version_base: None, versions: Versions::new(), version_files: VersionFiles::new(), hash_bucket_count: 0, gnu_hash_bloom_shift: 0, gnu_hash_bloom_count: 0, gnu_hash_bucket_count: 0, marker: PhantomData, } } /// Read the ELF file from file data. pub fn read<R: ReadRef<'data>>(data: R) -> Result<Self> { match FileKind::parse(data)? { FileKind::Elf32 => Self::read32(data), FileKind::Elf64 => Self::read64(data), #[allow(unreachable_patterns)] _ => Err(Error::new("Not an ELF file")), } } /// Read a 32-bit ELF file from file data. pub fn read32<R: ReadRef<'data>>(data: R) -> Result<Self> { Self::read_file::<elf::FileHeader32<Endianness>, R>(data) } /// Read a 64-bit ELF file from file data. pub fn read64<R: ReadRef<'data>>(data: R) -> Result<Self> { Self::read_file::<elf::FileHeader64<Endianness>, R>(data) } fn read_file<Elf, R>(data: R) -> Result<Self> where Elf: FileHeader<Endian = Endianness>, R: ReadRef<'data>, { let header = Elf::parse(data)?; let endian = header.endian()?; let is_mips64el = header.is_mips64el(endian); let section_strings_index = header.section_strings_index(endian, data)?; let segments = header.program_headers(endian, data)?; let sections = header.sections(endian, data)?; let symbols = sections.symbols(endian, data, elf::SHT_SYMTAB)?; let dynamic_symbols = sections.symbols(endian, data, elf::SHT_DYNSYM)?; let mut builder = Builder { endian, is_64: header.is_type_64(), load_align: 0, header: Header { os_abi: header.e_ident().os_abi, abi_version: header.e_ident().abi_version, e_type: header.e_type(endian), e_machine: header.e_machine(endian), e_entry: header.e_entry(endian).into(), e_flags: header.e_flags(endian), e_phoff: header.e_phoff(endian).into(), }, segments: Segments::new(), sections: Sections::new(), symbols: Symbols::new(), dynamic_symbols: Symbols::new(), version_base: None, versions: Versions::new(), version_files: VersionFiles::new(), hash_bucket_count: 0, gnu_hash_bloom_shift: 0, gnu_hash_bloom_count: 0, gnu_hash_bucket_count: 0, marker: PhantomData, }; for segment in segments { if segment.p_type(endian) == elf::PT_LOAD { let p_align = segment.p_align(endian).into(); if builder.load_align == 0 { builder.load_align = p_align; } else if builder.load_align != p_align { builder.load_align = 1; } } let id = builder.segments.next_id(); builder.segments.push(Segment { id, delete: false, p_type: segment.p_type(endian), p_flags: segment.p_flags(endian), p_offset: segment.p_offset(endian).into(), p_vaddr: segment.p_vaddr(endian).into(), p_paddr: segment.p_paddr(endian).into(), p_filesz: segment.p_filesz(endian).into(), p_memsz: segment.p_memsz(endian).into(), p_align: segment.p_align(endian).into(), sections: Vec::new(), marker: PhantomData, }); } if builder.load_align == 0 { builder.load_align = 1; } for (index, section) in sections.enumerate().skip(1) { let id = SectionId(index.0 - 1); let relocations = if let Some((rels, link)) = section.rel(endian, data)? { Self::read_relocations( index, endian, is_mips64el, section, rels, link, &symbols, &dynamic_symbols, )? } else if let Some((rels, link)) = section.rela(endian, data)? { Self::read_relocations( index, endian, is_mips64el, section, rels, link, &symbols, &dynamic_symbols, )? } else { SectionData::Data(Bytes::default()) }; if let Some(hash) = section.hash_header(endian, data)? { builder.hash_bucket_count = hash.bucket_count.get(endian); } if let Some(hash) = section.gnu_hash_header(endian, data)? { builder.gnu_hash_bloom_shift = hash.bloom_shift.get(endian); builder.gnu_hash_bloom_count = hash.bloom_count.get(endian); builder.gnu_hash_bucket_count = hash.bucket_count.get(endian); } let data = match section.sh_type(endian) { elf::SHT_NOBITS => SectionData::UninitializedData(section.sh_size(endian).into()), elf::SHT_PROGBITS | elf::SHT_INIT_ARRAY | elf::SHT_FINI_ARRAY | elf::SHT_PREINIT_ARRAY => SectionData::Data(section.data(endian, data)?.into()), elf::SHT_REL | elf::SHT_RELA => relocations, elf::SHT_SYMTAB => { if index == symbols.section() { SectionData::Symbol } else { return Err(Error(format!( "Unsupported SHT_SYMTAB section at index {}", index ))); } } elf::SHT_SYMTAB_SHNDX => { if index == symbols.shndx_section() { SectionData::SymbolSectionIndex } else { return Err(Error(format!( "Unsupported SHT_SYMTAB_SHNDX section at index {}", index ))); } } elf::SHT_DYNSYM => { if index == dynamic_symbols.section() { SectionData::DynamicSymbol } else { return Err(Error(format!( "Unsupported SHT_DYNSYM section at index {}", index ))); } } elf::SHT_STRTAB => { if index == symbols.string_section() { SectionData::String } else if index == dynamic_symbols.string_section() { SectionData::DynamicString } else if index == section_strings_index { SectionData::SectionString } else { return Err(Error(format!( "Unsupported SHT_STRTAB section at index {}", index ))); } } elf::SHT_NOTE => SectionData::Note(section.data(endian, data)?.into()), elf::SHT_DYNAMIC => { let (dyns, link) = section.dynamic(endian, data)?.unwrap(); let dynamic_strings = sections.strings(endian, data, link)?; Self::read_dynamics::<Elf, _>(endian, dyns, dynamic_strings)? } elf::SHT_GNU_ATTRIBUTES => { let attributes = section.attributes(endian, data)?; Self::read_attributes(index, attributes, sections.len(), symbols.len())? } elf::SHT_HASH => SectionData::Hash, elf::SHT_GNU_HASH => SectionData::GnuHash, elf::SHT_GNU_VERSYM => SectionData::GnuVersym, elf::SHT_GNU_VERDEF => SectionData::GnuVerdef, elf::SHT_GNU_VERNEED => SectionData::GnuVerneed, other => match (builder.header.e_machine, other) { (elf::EM_ARM, elf::SHT_ARM_ATTRIBUTES) | (elf::EM_AARCH64, elf::SHT_AARCH64_ATTRIBUTES) | (elf::EM_CSKY, elf::SHT_CSKY_ATTRIBUTES) | (elf::EM_RISCV, elf::SHT_RISCV_ATTRIBUTES) => { let attributes = section.attributes(endian, data)?; Self::read_attributes(index, attributes, sections.len(), symbols.len())? } // Some section types that we can't parse but that are safe to copy. // Lots of types missing, add as needed. We can't default to copying // everything because some types are not safe to copy. (elf::EM_ARM, elf::SHT_ARM_EXIDX) | (elf::EM_IA_64, elf::SHT_IA_64_UNWIND) | (elf::EM_MIPS, elf::SHT_MIPS_REGINFO) | (elf::EM_MIPS, elf::SHT_MIPS_DWARF) | (elf::EM_X86_64, elf::SHT_X86_64_UNWIND) => { SectionData::Data(section.data(endian, data)?.into()) } _ => return Err(Error(format!("Unsupported section type {:x}", other))), }, }; let sh_flags = section.sh_flags(endian).into(); let sh_link = section.sh_link(endian); let sh_link_section = if sh_link == 0 { None } else { if sh_link as usize >= sections.len() { return Err(Error(format!( "Invalid sh_link {} in section at index {}", sh_link, index ))); } Some(SectionId(sh_link as usize - 1)) }; let sh_info = section.sh_info(endian); let sh_info_section = if sh_info == 0 || sh_flags & u64::from(elf::SHF_INFO_LINK) == 0 { None } else { if sh_info as usize >= sections.len() { return Err(Error(format!( "Invalid sh_info link {} in section at index {}", sh_info, index ))); } Some(SectionId(sh_info as usize - 1)) }; let sh_flags = section.sh_flags(endian).into(); let sh_addr = section.sh_addr(endian).into(); if sh_flags & u64::from(elf::SHF_ALLOC) != 0 { for segment in &mut builder.segments { if segment.contains_address(sh_addr) { segment.sections.push(id); } } } builder.sections.push(Section { id, delete: false, name: sections.section_name(endian, section)?.into(), sh_type: section.sh_type(endian), sh_flags, sh_addr, sh_offset: section.sh_offset(endian).into(), sh_size: section.sh_size(endian).into(), sh_link_section, sh_info, sh_info_section, sh_addralign: section.sh_addralign(endian).into(), sh_entsize: section.sh_entsize(endian).into(), data, }); } Self::read_symbols( endian, &symbols, &mut builder.symbols, builder.sections.len(), )?; Self::read_symbols( endian, &dynamic_symbols, &mut builder.dynamic_symbols, builder.sections.len(), )?; builder.read_gnu_versions(endian, data, §ions, &dynamic_symbols)?; Ok(builder) } #[allow(clippy::too_many_arguments)] fn read_relocations<Elf, Rel, R>( index: read::SectionIndex, endian: Elf::Endian, is_mips64el: bool, section: &'data Elf::SectionHeader, rels: &'data [Rel], link: read::SectionIndex, symbols: &read::elf::SymbolTable<'data, Elf, R>, dynamic_symbols: &read::elf::SymbolTable<'data, Elf, R>, ) -> Result<SectionData<'data>> where Elf: FileHeader<Endian = Endianness>, Rel: Copy + Into<Elf::Rela>, R: ReadRef<'data>, { if link == dynamic_symbols.section() { Self::read_relocations_impl::<Elf, Rel, true>( index, endian, is_mips64el, rels, dynamic_symbols.len(), ) .map(SectionData::DynamicRelocation) } else if link.0 == 0 || section.sh_flags(endian).into() & u64::from(elf::SHF_ALLOC) ! // If there's no link, then none of the relocations may reference symbols. // Assume that these are dynamic relocations, but don't use the dynamic // symbol table when parsing. // // Additionally, sometimes there is an allocated section that links to // the static symbol table. We don't currently support this case in general, // but if none of the relocation entries reference a symbol then it is // safe to treat it as a dynamic relocation section. // // For both of these cases, if there is a reference to a symbol then // an error will be returned when parsing the relocations. Self::read_relocations_impl::<Elf, Rel, true>(index, endian, is_mips64el, rels, 0) .map(SectionData::DynamicRelocation) } else if link == symbols.section() { Self::read_relocations_impl::<Elf, Rel, false>( index, endian, is_mips64el, rels, symbols.len(), ) .map(SectionData::Relocation) } else { return Err(Error(format!( "Invalid sh_link {} in relocation section at index {}", link.0, index, ))); } } fn read_relocations_impl<Elf, Rel, const DYNAMIC: bool>( index: read::SectionIndex, endian: Elf::Endian, is_mips64el: bool, rels: &'data [Rel], symbols_len: usize, ) -> Result<Vec<Relocation<DYNAMIC>>> where Elf: FileHeader<Endian = Endianness>, Rel: Copy + Into<Elf::Rela>, { let mut relocations = Vec::new(); for rel in rels { let rel = (*rel).into(); let symbol = if let Some(symbol) = rel.symbol(endian, is_mips64el) { if symbol.0 >= symbols_len { return Err(Error(format!( "Invalid symbol index {} in relocation section at index {}", symbol, index, ))); } Some(SymbolId(symbol.0 - 1)) } else { None }; relocations.push(Relocation { r_offset: rel.r_offset(endian).into(), symbol, r_type: rel.r_type(endian, is_mips64el), r_addend: rel.r_addend(endian).into(), }); } Ok(relocations) } fn read_dynamics<Elf, R>( endian: Elf::Endian, dyns: &'data [Elf::Dyn], strings: read::StringTable<'data, R>, ) -> Result<SectionData<'data>> where Elf: FileHeader<Endian = Endianness>, R: ReadRef<'data>, { let mut dynamics = Vec::with_capacity(dyns.len()); for d in dyns { let tag = d.d_tag(endian).into().try_into().map_err(|_| { Error(format!( "Unsupported dynamic tag 0x{:x}", d.d_tag(endian).into() )) })?; if tag == elf::DT_NULL { break; } let val = d.d_val(endian).into(); dynamics.push(if d.is_string(endian) { let val = strings .get(val.try_into().map_err(|_| { Error(format!("Unsupported dynamic string 0x{:x}", val)) })?) .map_err(|_| Error(format!("Invalid dynamic string 0x{:x}", val)))?; Dynamic::String { tag, val: val.into(), } } else { match tag { elf::DT_SYMTAB | elf::DT_STRTAB | elf::DT_STRSZ | elf::DT_HASH | elf::DT_GNU_HASH | elf::DT_VERSYM | elf::DT_VERDEF | elf::DT_VERDEFNUM | elf::DT_VERNEED | elf::DT_VERNEEDNUM => Dynamic::Auto { tag }, _ => Dynamic::Integer { tag, val }, } }); } Ok(SectionData::Dynamic(dynamics)) } fn read_symbols<Elf, R, const DYNAMIC: bool>( endian: Elf::Endian, symbols: &read::elf::SymbolTable<'data, Elf, R>, builder_symbols: &mut Symbols<'data, DYNAMIC>, sections_len: usize, ) -> Result<()> where Elf: FileHeader<Endian = Endianness>, R: ReadRef<'data>, { for (index, symbol) in symbols.enumerate().skip(1) { let id = SymbolId(index.0 - 1); let section = if let Some(section_index) = symbols.symbol_section(endian, symbol, index)? { let section_id = section_index.0.wrapping_sub(1); if section_id >= sections_len { return Err(Error::new("Invalid symbol section index")); } Some(SectionId(section_id)) } else { None }; builder_symbols.push(Symbol { id, delete: false, name: symbols.symbol_name(endian, symbol)?.into(), section, st_info: symbol.st_info(), st_other: symbol.st_other(), st_shndx: symbol.st_shndx(endian), st_value: symbol.st_value(endian).into(), st_size: symbol.st_size(endian).into(), version: VersionId::local(), version_hidden: false, }); } Ok(()) } fn read_attributes<Elf>( index: read::SectionIndex, attributes: read::elf::AttributesSection<'data, Elf>, sections_len: usize, symbols_len: usize, ) -> Result<SectionData<'data>> where Elf: FileHeader<Endian = Endianness>, { let mut builder_attributes = AttributesSection::new(); let mut subsections = attributes.subsections()?; while let Some(subsection) = subsections.next()? { let mut builder_subsection = AttributesSubsection::new(subsection.vendor().into()); let mut subsubsections = subsection.subsubsections(); while let Some(subsubsection) = subsubsections.next()? { let tag = match subsubsection.tag() { elf::Tag_File => AttributeTag::File, elf::Tag_Section => { let mut tag_sections = Vec::new(); let mut indices = subsubsection.indices(); while let Some(index) = indices.next()? { let index = index as usize; if index >= sections_len { return Err(Error(format!( "Invalid section index {} in attribute", index ))); } tag_sections.push(SectionId(index - 1)); } AttributeTag::Section(tag_sections) } elf::Tag_Symbol => { let mut tag_symbols = Vec::new(); let mut indices = subsubsection.indices(); while let Some(index) = indices.next()? { let index = index as usize; if index >= symbols_len { return Err(Error(format!( "Invalid symbol index {} in attribute", index ))); } tag_symbols.push(SymbolId(index - 1)); } AttributeTag::Symbol(tag_symbols) } tag => { return Err(Error(format!( "Unsupported attribute tag 0x{:x} in section at index {}", tag, index, ))) } }; let data = subsubsection.attributes_data().into(); builder_subsection .subsubsections .push(AttributesSubsubsection { tag, data }); } builder_attributes.subsections.push(builder_subsection); } Ok(SectionData::Attributes(builder_attributes)) } fn read_gnu_versions<Elf, R>( &mut self, endian: Elf::Endian, data: R, sections: &read::elf::SectionTable<'data, Elf, R>, dynamic_symbols: &read::elf::SymbolTable<'data, Elf, R>, ) -> Result<()> where Elf: FileHeader<Endian = Endianness>, R: ReadRef<'data>, { let strings = dynamic_symbols.strings(); let mut ids = HashMap::new(); ids.insert(0, VersionId::local()); ids.insert(1, VersionId::global()); if let Some((mut verdefs, link)) = sections.gnu_verdef(endian, data)? { if link != dynamic_symbols.string_section() { return Err(Error::new("Invalid SHT_GNU_VERDEF section")); } while let Some((verdef, mut verdauxs)) = verdefs.next()? { let flags = verdef.vd_flags.get(endian); if flags & elf::VER_FLG_BASE != 0 { if flags != elf::VER_FLG_BASE || verdef.vd_ndx.get(endian) != 1 || verdef.vd_cnt.get(endian) != 1 { return Err(Error::new("Unsupported VER_FLG_BASE in SHT_GNU_VERDEF")); } if self.version_base.is_some() { return Err(Error::new("Duplicate VER_FLG_BASE in SHT_GNU_VERDEF")); } let verdaux = verdauxs.next()?.ok_or_else(|| { Error::new("Missing name for VER_FLG_BASE in SHT_GNU_VERDEF") })?; self.version_base = Some(verdaux.name(endian, strings)?.into()); continue; } let index = verdef.vd_ndx.get(endian) & elf::VERSYM_VERSION; let id = self.versions.next_id(); if ids.insert(index, id).is_some() { return Err(Error(format!("Duplicate SHT_GNU_VERDEF index {}", index))); } let mut names = Vec::new(); while let Some(verdaux) = verdauxs.next()? { names.push(verdaux.name(endian, strings)?.into()); } let data = VersionData::Def(VersionDef { flags, names }); self.versions.push(Version { id, delete: false, data, }); } } if let Some((mut verneeds, link)) = sections.gnu_verneed(endian, data)? { if link != dynamic_symbols.string_section() { return Err(Error::new("Invalid SHT_GNU_VERNEED section")); } while let Some((verneed, mut vernauxs)) = verneeds.next()? { let file = VersionFileId(self.version_files.len()); self.version_files.push(VersionFile { id: file, delete: false, name: verneed.file(endian, strings)?.into(), }); while let Some(vernaux) = vernauxs.next()? { let index = vernaux.vna_other.get(endian) & elf::VERSYM_VERSION; let id = self.versions.next_id(); if ids.insert(index, id).is_some() { return Err(Error(format!("Duplicate SHT_GNU_VERNEED index {}", index))); } let data = VersionData::Need(VersionNeed { flags: vernaux.vna_flags.get(endian), name: vernaux.name(endian, strings)?.into(), file, }); self.versions.push(Version { id, delete: false, data, }); } } } if let Some((versyms, link)) = sections.gnu_versym(endian, data)? { if versyms.len() != dynamic_symbols.len() || link != dynamic_symbols.section() { return Err(Error::new("Invalid SHT_GNU_VERSYM section")); } for (id, versym) in versyms.iter().skip(1).enumerate() { let index = versym.0.get(endian); let symbol = self.dynamic_symbols.get_mut(SymbolId(id)); symbol.version = *ids .get(&(index & elf::VERSYM_VERSION)) .ok_or_else(|| Error(format!("Invalid SHT_GNU_VERSYM index {:x}", index)))?; symbol.version_hidden = index & elf::VERSYM_HIDDEN != 0; } } Ok(()) } /// Write the ELF file to the buffer. pub fn write(mut self, buffer: &mut dyn write::WritableBuffer) -> Result<()> { struct SectionOut { id: SectionId, name: Option<write::StringId>, offset: usize, attributes: Vec<u8>, } struct SymbolOut { id: SymbolId, name: Option<write::StringId>, } struct DynamicSymbolOut { id: DynamicSymbolId, name: Option<write::StringId>, hash: Option<u32>, gnu_hash: Option<u32>, } #[derive(Default, Clone)] struct VersionFileOut { versions: Vec<VersionId>, } // TODO: require the caller to do this? self.delete_orphans(); self.delete_unused_versions(); let mut writer = write::elf::Writer::new(self.endian, self.is_64, buffer); // Find metadata sections, and assign section indices. let mut shstrtab_id = None; let mut symtab_id = None; let mut symtab_shndx_id = None; let mut strtab_id = None; let mut dynsym_id = None; let mut dynstr_id = None; let mut hash_id = None; let mut gnu_hash_id = None; let mut gnu_versym_id = None; let mut gnu_verdef_id = None; let mut gnu_verneed_id = None; let mut out_sections = Vec::with_capacity(self.sections.len()); let mut out_sections_index = vec![None; self.sections.len()]; if !self.sections.is_empty() { writer.reserve_null_section_index(); } for section in &self.sections { let index = match §ion.data { SectionData::Data(_) | SectionData::UninitializedData(_) | SectionData::Relocation(_) | SectionData::DynamicRelocation(_) | SectionData::Note(_) | SectionData::Dynamic(_) | SectionData::Attributes(_) => writer.reserve_section_index(), SectionData::SectionString => { if shstrtab_id.is_some() { return Err(Error::new("Multiple .shstrtab sections")); } shstrtab_id = Some(section.id); writer.reserve_shstrtab_section_index_with_name(§ion.name) } SectionData::Symbol => { if symtab_id.is_some() { return Err(Error::new("Multiple .symtab sections")); } symtab_id = Some(section.id); writer.reserve_symtab_section_index_with_name(§ion.name) } SectionData::SymbolSectionIndex => { if symtab_shndx_id.is_some() { return Err(Error::new("Multiple .symtab_shndx sections")); } symtab_shndx_id = Some(section.id); writer.reserve_symtab_shndx_section_index_with_name(§ion.name) } SectionData::String => { if strtab_id.is_some() { return Err(Error::new("Multiple .strtab sections")); } strtab_id = Some(section.id); writer.reserve_strtab_section_index_with_name(§ion.name) } SectionData::DynamicSymbol => { if dynsym_id.is_some() { return Err(Error::new("Multiple .dynsym sections")); } dynsym_id = Some(section.id); writer.reserve_dynsym_section_index_with_name(§ion.name) } SectionData::DynamicString => { if dynstr_id.is_some() { return Err(Error::new("Multiple .dynstr sections")); } dynstr_id = Some(section.id); writer.reserve_dynstr_section_index_with_name(§ion.name) } SectionData::Hash => { if hash_id.is_some() { return Err(Error::new("Multiple .hash sections")); } hash_id = Some(section.id); writer.reserve_hash_section_index_with_name(§ion.name) } SectionData::GnuHash => { if gnu_hash_id.is_some() { return Err(Error::new("Multiple .gnu.hash sections")); } gnu_hash_id = Some(section.id); writer.reserve_gnu_hash_section_index_with_name(§ion.name) } SectionData::GnuVersym => { if gnu_versym_id.is_some() { return Err(Error::new("Multiple .gnu.version sections")); } gnu_versym_id = Some(section.id); writer.reserve_gnu_versym_section_index_with_name(§ion.name) } SectionData::GnuVerdef => { if gnu_verdef_id.is_some() { return Err(Error::new("Multiple .gnu.version_d sections")); } gnu_verdef_id = Some(section.id); writer.reserve_gnu_verdef_section_index_with_name(§ion.name) } SectionData::GnuVerneed => { if gnu_verneed_id.is_some() { return Err(Error::new("Multiple .gnu.version_r sections")); } gnu_verneed_id = Some(section.id); writer.reserve_gnu_verneed_section_index_with_name(§ion.name) } }; out_sections_index[section.id.0] = Some(index); let name = if section.name.is_empty() { None } else { Some(writer.add_section_name(§ion.name)) }; out_sections.push(SectionOut { id: section.id, name, offset: 0, attributes: Vec::new(), }); } // Assign dynamic strings. for section in &self.sections { if let SectionData::Dynamic(dynamics) = §ion.data { for dynamic in dynamics { if let Dynamic::String { val, .. } = dynamic { writer.add_dynamic_string(val); } } } } // Assign dynamic symbol indices. let mut out_dynsyms = Vec::with_capacity(self.dynamic_symbols.len()); // Local symbols must come before global. let local_symbols = self .dynamic_symbols .into_iter() .filter(|symbol| symbol.st_bind() == elf::STB_LOCAL); let global_symbols = self .dynamic_symbols .into_iter() .filter(|symbol| symbol.st_bind() != elf::STB_LOCAL); for symbol in local_symbols.chain(global_symbols) { let mut name = None; let mut hash = None; let mut gnu_hash = None; if !symbol.name.is_empty() { name = Some(writer.add_dynamic_string(&symbol.name)); if hash_id.is_some() { hash = Some(elf::hash(&symbol.name)); } if gnu_hash_id.is_some() && (symbol.section.is_some() || symbol.st_shndx != elf::SHN_UNDEF) { gnu_hash = Some(elf::gnu_hash(&symbol.name)); } } out_dynsyms.push(DynamicSymbolOut { id: symbol.id, name, hash, gnu_hash, }); } let num_local_dynamic = out_dynsyms .iter() .take_while(|sym| self.dynamic_symbols.get(sym.id).st_bind() == elf::STB_LOCAL) .count(); // We must sort for GNU hash before allocating symbol indices. let mut gnu_hash_symbol_count = 0; if gnu_hash_id.is_some() { if self.gnu_hash_bucket_count == 0 { return Err(Error::new(".gnu.hash bucket count is zero")); } // TODO: recalculate bucket_count? out_dynsyms[num_local_dynamic..].sort_by_key(|sym| match sym.gnu_hash { None => (0, 0), Some(hash) => (1, hash % self.gnu_hash_bucket_count), }); gnu_hash_symbol_count = out_dynsyms .iter() .skip(num_local_dynamic) .skip_while(|sym| sym.gnu_hash.is_none()) .count() as u32; } let mut out_dynsyms_index = vec![None; self.dynamic_symbols.len()]; if dynsym_id.is_some() { writer.reserve_null_dynamic_symbol_index(); } for out_dynsym in &mut out_dynsyms { out_dynsyms_index[out_dynsym.id.0] = Some(writer.reserve_dynamic_symbol_index()); } // Hash parameters. let hash_index_base = 1; // Null symbol. let hash_chain_count = hash_index_base + out_dynsyms.len() as u32; // GNU hash parameters. let gnu_hash_index_base = if gnu_hash_symbol_count == 0 { 0 } else { out_dynsyms.len() as u32 - gnu_hash_symbol_count }; let gnu_hash_symbol_base = gnu_hash_index_base + 1; // Null symbol. // Assign symbol indices. let mut out_syms = Vec::with_capacity(self.symbols.len()); // Local symbols must come before global. let local_symbols = self .symbols .into_iter() .filter(|symbol| symbol.st_bind() == elf::STB_LOCAL); let global_symbols = self .symbols .into_iter() .filter(|symbol| symbol.st_bind() != elf::STB_LOCAL); for symbol in local_symbols.chain(global_symbols) { let name = if symbol.name.is_empty() { None } else { Some(writer.add_string(&symbol.name)) }; out_syms.push(SymbolOut { id: symbol.id, name, }); } let num_local = out_syms .iter() .take_while(|sym| self.symbols.get(sym.id).st_bind() == elf::STB_LOCAL) .count(); let mut out_syms_index = vec![None; self.symbols.len()]; if symtab_id.is_some() { writer.reserve_null_symbol_index(); } for out_sym in out_syms.iter_mut() { out_syms_index[out_sym.id.0] = Some(writer.reserve_symbol_index(None)); } // Count the versions and add version strings. let mut verdef_count = 0; let mut verdaux_count = 0; let mut verdef_shared_base = false; let mut verneed_count = 0; let mut vernaux_count = 0; let mut out_version_files = vec![VersionFileOut::default(); self.version_files.len()] if let Some(version_base) = &self.version_base { verdef_count += 1; verdaux_count += 1; writer.add_dynamic_string(version_base); } for version in &self.versions { match &version.data { VersionData::Def(def) => { if def.is_shared(verdef_count, self.version_base.as_ref()) { verdef_shared_base = true; } else { verdaux_count += def.names.len(); for name in &def.names { writer.add_dynamic_string(name); } } verdef_count += 1; } VersionData::Need(need) => { vernaux_count += 1; writer.add_dynamic_string(&need.name); out_version_files[need.file.0].versions.push(version.id); } } } for file in &self.version_files { verneed_count += 1; writer.add_dynamic_string(&file.name); } // Build the attributes sections. for out_section in &mut out_sections { let SectionData::Attributes(attributes) = &self.sections.get(out_section.id).data else { continue; }; if attributes.subsections.is_empty() { continue; } let mut writer = writer.attributes_writer(); for subsection in &attributes.subsections { writer.start_subsection(&subsection.vendor); for subsubsection in &subsection.subsubsections { writer.start_subsubsection(subsubsection.tag.tag()); match &subsubsection.tag { AttributeTag::File => {} AttributeTag::Section(sections) => { for id in sections { if let Some(index) = out_sections_index[id.0] { writer.write_subsubsection_index(index.0); } } writer.write_subsubsection_index(0); } AttributeTag::Symbol(symbols) => { for id in symbols { if let Some(index) = out_syms_index[id.0] { writer.write_subsubsection_index(index.0); } } writer.write_subsubsection_index(0); } } writer.write_subsubsection_attributes(&subsubsection.data); writer.end_subsubsection(); } writer.end_subsection(); } out_section.attributes = writer.data(); } // TODO: support section headers in strtab if shstrtab_id.is_none() && !out_sections.is_empty() { return Err(Error::new(".shstrtab section is needed but not present")); } if symtab_id.is_none() && !out_syms.is_empty() { return Err(Error::new(".symtab section is needed but not present")); } if symtab_shndx_id.is_none() && writer.symtab_shndx_needed() { return Err(Error::new( ".symtab.shndx section is needed but not present", )); } else if symtab_shndx_id.is_some() { writer.require_symtab_shndx(); } if strtab_id.is_none() && writer.strtab_needed() { return Err(Error::new(".strtab section is needed but not present")); } else if strtab_id.is_some() { writer.require_strtab(); } if dynsym_id.is_none() && !out_dynsyms.is_empty() { return Err(Error::new(".dynsym section is needed but not present")); } if dynstr_id.is_none() && writer.dynstr_needed() { return Err(Error::new(".dynstr section is needed but not present")); } else if dynstr_id.is_some() { writer.require_dynstr(); } if gnu_verdef_id.is_none() && verdef_count > 0 { return Err(Error::new( ".gnu.version_d section is needed but not present", )); } if gnu_verneed_id.is_none() && verneed_count > 0 { return Err(Error::new( ".gnu.version_r section is needed but not present", )); } // Start reserving file ranges. writer.reserve_file_header(); let mut dynsym_addr = None; let mut dynstr_addr = None; let mut hash_addr = None; let mut gnu_hash_addr = None; let mut versym_addr = None; let mut verdef_addr = None; let mut verneed_addr = None; if !self.segments.is_empty() { // TODO: support program headers in other locations. if self.header.e_phoff != writer.reserved_len() as u64 { return Err(Error(format!( "Unsupported e_phoff value 0x{:x}", self.header.e_phoff ))); } writer.reserve_program_headers(self.segments.count() as u32); } let mut alloc_sections = Vec::new(); if !self.segments.is_empty() { // Reserve alloc sections at original offsets. alloc_sections = out_sections .iter() .enumerate() .filter_map(|(index, out_section)| { let section = self.sections.get(out_section.id); if section.is_alloc() { Some(index) } else { None } }) .collect(); // The data for alloc sections may need to be written in a different order // from their section headers. alloc_sections.sort_by_key(|index| { let section = &self.sections.get(out_sections[*index].id); // Empty sections need to come before other sections at the same offset. (section.sh_offset, section.sh_size) }); for index in &alloc_sections { let out_section = &mut out_sections[*index]; let section = &self.sections.get(out_section.id); if section.sh_type == elf::SHT_NOBITS { // sh_offset is meaningless for SHT_NOBITS, so preserve the input // value without checking it. out_section.offset = section.sh_offset as usize; continue; } if section.sh_offset < writer.reserved_len() as u64 { return Err(Error(format!( "Unsupported sh_offset value 0x{:x} for section '{}', expected at least 0x{:x}", section.sh_offset, section.name, writer.reserved_len(), ))); } // The input sh_offset needs to be preserved so that offsets in program // headers are correct. writer.reserve_until(section.sh_offset as usize); out_section.offset = match §ion.data { SectionData::Data(data) => { writer.reserve(data.len(), section.sh_addralign as usize) } SectionData::DynamicRelocation(relocations) => writer .reserve_relocations(relocations.len(), section.sh_type == elf::SHT_RELA), SectionData::Note(data) => { writer.reserve(data.len(), section.sh_addralign as usize) } SectionData::Dynamic(dynamics) => writer.reserve_dynamics(1 + dynamics.len()), SectionData::DynamicSymbol => { dynsym_addr = Some(section.sh_addr); writer.reserve_dynsym() } SectionData::DynamicString => { dynstr_addr = Some(section.sh_addr); writer.reserve_dynstr() } SectionData::Hash => { hash_addr = Some(section.sh_addr); writer.reserve_hash(self.hash_bucket_count, hash_chain_count) } SectionData::GnuHash => { gnu_hash_addr = Some(section.sh_addr); writer.reserve_gnu_hash( self.gnu_hash_bloom_count, self.gnu_hash_bucket_count, gnu_hash_symbol_count, ) } SectionData::GnuVersym => { versym_addr = Some(section.sh_addr); writer.reserve_gnu_versym() } SectionData::GnuVerdef => { verdef_addr = Some(section.sh_addr); writer.reserve_gnu_verdef(verdef_count, verdaux_count) } SectionData::GnuVerneed => { verneed_addr = Some(section.sh_addr); writer.reserve_gnu_verneed(verneed_count, vernaux_count) } _ => { return Err(Error(format!( "Unsupported alloc section type {:x} for section '{}'", section.sh_type, section.name, ))); } }; if out_section.offset as u64 != section.sh_offset { return Err(Error(format!( "Unaligned sh_offset value 0x{:x} for section '{}', expected 0x{:x}", section.sh_offset, section.name, out_section.offset, ))); } } } // Reserve non-alloc sections at any offset. for out_section in &mut out_sections { let section = self.sections.get(out_section.id); if !self.segments.is_empty() && section.is_alloc() { continue; } out_section.offset = match §ion.data { SectionData::Data(data) => { writer.reserve(data.len(), section.sh_addralign as usize) } SectionData::UninitializedData(_) => writer.reserved_len(), SectionData::Note(data) => { writer.reserve(data.len(), section.sh_addralign as usize) } SectionData::Attributes(_) => { writer.reserve(out_section.attributes.len(), section.sh_addralign as usize) } // These are handled elsewhere. SectionData::Relocation(_) | SectionData::SectionString | SectionData::Symbol | SectionData::SymbolSectionIndex | SectionData::String => { continue; } _ => { return Err(Error(format!( "Unsupported non-alloc section type {:x}", section.sh_type ))); } }; } writer.reserve_symtab(); writer.reserve_symtab_shndx(); writer.reserve_strtab(); // Reserve non-alloc relocations. for out_section in &mut out_sections { let section = self.sections.get(out_section.id); if !self.segments.is_empty() && section.is_alloc() { continue; } let SectionData::Relocation(relocations) = §ion.data else { continue; }; out_section.offset = writer.reserve_relocations(relocations.len(), section.sh_type == elf::SHT_RELA); } writer.reserve_shstrtab(); writer.reserve_section_headers(); // Start writing. writer.write_file_header(&write::elf::FileHeader { os_abi: self.header.os_abi, abi_version: self.header.abi_version, e_type: self.header.e_type, e_machine: self.header.e_machine, e_entry: self.header.e_entry, e_flags: self.header.e_flags, })?; if !self.segments.is_empty() { writer.write_align_program_headers(); for segment in &self.segments { writer.write_program_header(&write::elf::ProgramHeader { p_type: segment.p_type, p_flags: segment.p_flags, p_offset: segment.p_offset, p_vaddr: segment.p_vaddr, p_paddr: segment.p_paddr, p_filesz: segment.p_filesz, p_memsz: segment.p_memsz, p_align: segment.p_align, }); } } // Write alloc sections. if !self.segments.is_empty() { for index in &alloc_sections { let out_section = &mut out_sections[*index]; let section = self.sections.get(out_section.id); if section.sh_type == elf::SHT_NOBITS { continue; } writer.pad_until(out_section.offset); match §ion.data { SectionData::Data(data) => { writer.write(data); } SectionData::DynamicRelocation(relocations) => { for rel in relocations { let r_sym = if let Some(symbol) = rel.symbol { out_dynsyms_index[symbol.0].unwrap().0 } else { 0 }; writer.write_relocation( section.sh_type == elf::SHT_RELA, &write::elf::Rel { r_offset: rel.r_offset, r_sym, r_type: rel.r_type, r_addend: rel.r_addend, }, ); } } SectionData::Note(data) => { writer.write(data); } SectionData::Dynamic(dynamics) => { for d in dynamics { match *d { Dynamic::Auto { tag } => { // TODO: support more values let val = match tag { elf::DT_SYMTAB => dynsym_addr.ok_or(Error::new( "Missing .dynsym section for DT_SYMTAB", ))?, elf::DT_STRTAB => dynstr_addr.ok_or(Error::new( "Missing .dynstr section for DT_STRTAB", ))?, elf::DT_STRSZ => writer.dynstr_len() as u64, elf::DT_HASH => hash_addr.ok_or(Error::new( "Missing .hash section for DT_HASH", ))?, elf::DT_GNU_HASH => gnu_hash_addr.ok_or(Error::new( "Missing .gnu.hash section for DT_GNU_HASH", ))?, elf::DT_VERSYM => versym_addr.ok_or(Error::new( "Missing .gnu.version section for DT_VERSYM", ))?, elf::DT_VERDEF => verdef_addr.ok_or(Error::new( "Missing .gnu.version_d section for DT_VERDEF", ))?, elf::DT_VERDEFNUM => verdef_count as u64, elf::DT_VERNEED => verneed_addr.ok_or(Error::new( "Missing .gnu.version_r section for DT_VERNEED", ))?, elf::DT_VERNEEDNUM => verneed_count as u64, _ => { return Err(Error(format!( "Cannot generate value for dynamic tag 0x{:x}", tag ))) } }; writer.write_dynamic(tag, val); } Dynamic::Integer { tag, val } => { writer.write_dynamic(tag, val); } Dynamic::String { tag, ref val } => { let val = writer.get_dynamic_string(val); writer.write_dynamic_string(tag, val); } } } writer.write_dynamic(elf::DT_NULL, 0); } SectionData::DynamicSymbol => { writer.write_null_dynamic_symbol(); for out_dynsym in &out_dynsyms { let symbol = self.dynamic_symbols.get(out_dynsym.id); let section = symbol.section.map(|id| out_sections_index[id.0].unwrap()); writer.write_dynamic_symbol(&write::elf::Sym { name: out_dynsym.name, section, st_info: symbol.st_info, st_other: symbol.st_other, st_shndx: symbol.st_shndx, st_value: symbol.st_value, st_size: symbol.st_size, }); } } SectionData::DynamicString => { writer.write_dynstr(); } SectionData::Hash => { if self.hash_bucket_count == 0 { return Err(Error::new(".hash bucket count is zero")); } writer.write_hash(self.hash_bucket_count, hash_chain_count, |index| { out_dynsyms .get(index.checked_sub(hash_index_base)? as usize)? .hash }); } SectionData::GnuHash => { if self.gnu_hash_bucket_count == 0 { return Err(Error::new(".gnu.hash bucket count is zero")); } writer.write_gnu_hash( gnu_hash_symbol_base, self.gnu_hash_bloom_shift, self.gnu_hash_bloom_count, self.gnu_hash_bucket_count, gnu_hash_symbol_count, |index| { out_dynsyms[(gnu_hash_index_base + index) as usize] .gnu_hash .unwrap() }, ); } SectionData::GnuVersym => { writer.write_null_gnu_versym(); for out_dynsym in &out_dynsyms { let symbol = self.dynamic_symbols.get(out_dynsym.id); let mut index = symbol.version.0 as u16; if symbol.version_hidden { index |= elf::VERSYM_HIDDEN; } writer.write_gnu_versym(index); } } SectionData::GnuVerdef => { writer.write_align_gnu_verdef(); if let Some(version_base) = &self.version_base { let verdef = write::elf::Verdef { version: elf::VER_DEF_CURRENT, flags: elf::VER_FLG_BASE, index: 1, aux_count: 1, name: writer.get_dynamic_string(version_base), }; if verdef_shared_base { writer.write_gnu_verdef_shared(&verdef); } else { writer.write_gnu_verdef(&verdef); } } for version in &self.versions { if let VersionData::Def(def) = &version.data { let mut names = def.names.iter(); let name = names.next().ok_or_else(|| { Error(format!("Missing SHT_GNU_VERDEF name {}", version.id.0)) })?; writer.write_gnu_verdef(&write::elf::Verdef { version: elf::VER_DEF_CURRENT, flags: def.flags, index: version.id.0 as u16, aux_count: def.names.len() as u16, name: writer.get_dynamic_string(name), }); for name in names { writer.write_gnu_verdaux(writer.get_dynamic_string(name)); } } } } SectionData::GnuVerneed => { writer.write_align_gnu_verneed(); for file in &self.version_files { let out_file = &out_version_files[file.id.0]; if out_file.versions.is_empty() { continue; } writer.write_gnu_verneed(&write::elf::Verneed { version: elf::VER_NEED_CURRENT, aux_count: out_file.versions.len() as u16, file: writer.get_dynamic_string(&file.name), }); for id in &out_file.versions { let version = self.versions.get(*id); // This will always match. if let VersionData::Need(need) = &version.data { debug_assert_eq!(*id, version.id); writer.write_gnu_vernaux(&write::elf::Vernaux { flags: need.flags, index: version.id.0 as u16, name: writer.get_dynamic_string(&need.name), }); } } } } _ => { return Err(Error(format!( "Unsupported alloc section type {:x}", section.sh_type ))); } } } } // Write non-alloc sections. for out_section in &mut out_sections { let section = self.sections.get(out_section.id); if !self.segments.is_empty() && section.is_alloc() { continue; } match §ion.data { SectionData::Data(data) => { writer.write_align(section.sh_addralign as usize); debug_assert_eq!(out_section.offset, writer.len()); writer.write(data); } SectionData::UninitializedData(_) => { // Nothing to do. } SectionData::Note(data) => { writer.write_align(section.sh_addralign as usize); debug_assert_eq!(out_section.offset, writer.len()); writer.write(data); } SectionData::Attributes(_) => { writer.write_align(section.sh_addralign as usize); debug_assert_eq!(out_section.offset, writer.len()); writer.write(&out_section.attributes); } // These are handled elsewhere. SectionData::Relocation(_) | SectionData::SectionString | SectionData::Symbol | SectionData::SymbolSectionIndex | SectionData::String => {} _ => { return Err(Error(format!( "Unsupported non-alloc section type {:x}", section.sh_type ))); } } } writer.write_null_symbol(); for out_sym in &out_syms { let symbol = self.symbols.get(out_sym.id); let section = symbol.section.map(|id| out_sections_index[id.0].unwrap()); writer.write_symbol(&write::elf::Sym { name: out_sym.name, section, st_info: symbol.st_info, st_other: symbol.st_other, st_shndx: symbol.st_shndx, st_value: symbol.st_value, st_size: symbol.st_size, }); } writer.write_symtab_shndx(); writer.write_strtab(); // Write non-alloc relocations. for section in &self.sections { if !self.segments.is_empty() && section.is_alloc() { continue; } let SectionData::Relocation(relocations) = §ion.data else { continue; }; writer.write_align_relocation(); for rel in relocations { let r_sym = if let Some(id) = rel.symbol { out_syms_index[id.0].unwrap().0 } else { 0 }; writer.write_relocation( section.sh_type == elf::SHT_RELA, &write::elf::Rel { r_offset: rel.r_offset, r_sym, r_type: rel.r_type, r_addend: rel.r_addend, }, ); } } writer.write_shstrtab(); writer.write_null_section_header(); for out_section in &out_sections { let section = self.sections.get(out_section.id); match §ion.data { SectionData::Data(_) | SectionData::UninitializedData(_) | SectionData::Relocation(_) | SectionData::DynamicRelocation(_) | SectionData::Note(_) | SectionData::Dynamic(_) | SectionData::Attributes(_) => { let sh_size = match §ion.data { SectionData::Data(data) => data.len() as u64, SectionData::UninitializedData(len) => *len, SectionData::Relocation(relocations) => { (relocations.len() * self.class().rel_size(section.sh_type == elf::SHT_RELA)) as u64 } SectionData::DynamicRelocation(relocations) => { (relocations.len() * self.class().rel_size(section.sh_type == elf::SHT_RELA)) as u64 } SectionData::Note(data) => data.len() as u64, SectionData::Dynamic(dynamics) => { ((1 + dynamics.len()) * self.class().dyn_size()) as u64 } SectionData::Attributes(_) => out_section.attributes.len() as u64, _ => { return Err(Error(format!( "Unimplemented size for section type {:x}", section.sh_type ))) } }; let sh_link = if let Some(id) = section.sh_link_section { if let Some(index) = out_sections_index[id.0] { index.0 } else { return Err(Error(format!( "Invalid sh_link from section '{}' to deleted section '{}'", section.name, self.sections.get(id).name, ))); } } else { 0 }; let sh_info = if let Some(id) = section.sh_info_section { if let Some(index) = out_sections_index[id.0] { index.0 } else { return Err(Error(format!( "Invalid sh_info link from section '{}' to deleted section '{}'", section.name, self.sections.get(id).name, ))); } } else { section.sh_info }; writer.write_section_header(&write::elf::SectionHeader { name: out_section.name, sh_type: section.sh_type, sh_flags: section.sh_flags, sh_addr: section.sh_addr, sh_offset: out_section.offset as u64, sh_size, sh_link, sh_info, sh_addralign: section.sh_addralign, sh_entsize: section.sh_entsize, }); } SectionData::SectionString => { writer.write_shstrtab_section_header(); } SectionData::Symbol => { writer.write_symtab_section_header(1 + num_local as u32); } SectionData::SymbolSectionIndex => { writer.write_symtab_shndx_section_header(); } SectionData::String => { writer.write_strtab_section_header(); } SectionData::DynamicString => { writer.write_dynstr_section_header(section.sh_addr); } SectionData::DynamicSymbol => { writer .write_dynsym_section_header(section.sh_addr, 1 + num_local_dynamic as u32); } SectionData::Hash => { writer.write_hash_section_header(section.sh_addr); } SectionData::GnuHash => { writer.write_gnu_hash_section_header(section.sh_addr); } SectionData::GnuVersym => { writer.write_gnu_versym_section_header(section.sh_addr); } SectionData::GnuVerdef => { writer.write_gnu_verdef_section_header(section.sh_addr); } SectionData::GnuVerneed => { writer.write_gnu_verneed_section_header(section.sh_addr); } } } debug_assert_eq!(writer.reserved_len(), writer.len()); Ok(()) } /// Delete segments, symbols, relocations, and dynamics that refer /// to deleted items. /// /// This calls `delete_orphan_segments`, `delete_orphan_symbols`, /// `delete_orphan_relocations`, and `delete_orphan_dynamics`. pub fn delete_orphans(&mut self) { self.delete_orphan_segments(); self.delete_orphan_symbols(); self.delete_orphan_relocations(); self.delete_orphan_dynamics(); } /// Set the delete flag for segments that only refer to deleted sections. pub fn delete_orphan_segments(&mut self) { let sections = &self.sections; for segment in &mut self.segments { // We only delete segments that have become empty due to section deletions. if segment.sections.is_empty() { continue; } segment.sections.retain(|id| !sections.get(*id).delete); segment.delete = segment.sections.is_empty(); } } /// Set the delete flag for symbols that refer to deleted sections. pub fn delete_orphan_symbols(&mut self) { for symbol in &mut self.symbols { if let Some(section) = symbol.section { if self.sections.get_mut(section).delete { symbol.delete = true; } } } for symbol in &mut self.dynamic_symbols { if let Some(section) = symbol.section { if self.sections.get_mut(section).delete { symbol.delete = true; } } } } /// Delete relocations that refer to deleted symbols. pub fn delete_orphan_relocations(&mut self) { let symbols = &self.symbols; let dynamic_symbols = &self.dynamic_symbols; for section in &mut self.sections { match &mut section.data { SectionData::Relocation(relocations) => { relocations.retain(|relocation| match relocation.symbol { None => true, Some(id) => !symbols.get(id).delete, }); } SectionData::DynamicRelocation(relocations) => { relocations.retain(|relocation| match relocation.symbol { None => true, Some(id) => !dynamic_symbols.get(id).delete, }); } _ => {} } } } /// Delete dynamic entries that refer to deleted sections. pub fn delete_orphan_dynamics(&mut self) { let mut have_dynsym = false; let mut have_dynstr = false; let mut have_hash = false; let mut have_gnu_hash = false; let mut have_versym = false; let mut have_verdef = false; let mut have_verneed = false; for section in &self.sections { match §ion.data { SectionData::DynamicSymbol => have_dynsym = true, SectionData::DynamicString => have_dynstr = true, SectionData::Hash => have_hash = true, SectionData::GnuHash => have_gnu_hash = true, SectionData::GnuVersym => have_versym = true, SectionData::GnuVerdef => have_verdef = true, SectionData::GnuVerneed => have_verneed = true, _ => {} } } for section in &mut self.sections { if let SectionData::Dynamic(dynamics) = &mut section.data { dynamics.retain(|dynamic| match dynamic { Dynamic::Auto { tag: elf::DT_SYMTAB, } => have_dynsym, Dynamic::Auto { tag: elf::DT_STRTAB, } | Dynamic::Auto { tag: elf::DT_STRSZ } => have_dynstr, Dynamic::Auto { tag: elf::DT_HASH } => have_hash, Dynamic::Auto { tag: elf::DT_GNU_HASH, } => have_gnu_hash, Dynamic::Auto { tag: elf::DT_VERSYM, } => have_versym, Dynamic::Auto { tag: elf::DT_VERNEED, } | Dynamic::Auto { tag: elf::DT_VERNEEDNUM, } => have_verneed, Dynamic::Auto { tag: elf::DT_VERDEF, } | Dynamic::Auto { tag: elf::DT_VERDEFNUM, } => have_verdef, _ => true, }); } } } /// Delete unused GNU version entries. pub fn delete_unused_versions(&mut self) { let mut version_used = vec![false; self.versions.len() + VERSION_ID_BASE]; for symbol in &self.dynamic_symbols { version_used[symbol.version.0] = true; } let mut version_file_used = vec![false; self.version_files.len()]; for version in &mut self.versions { if !version_used[version.id.0] { version.delete = true; continue; } if let VersionData::Need(need) = &version.data { version_file_used[need.file.0] = true; } } for file in &mut self.version_files { if !version_file_used[file.id.0] { file.delete = true; } } } /// Return the ELF file class that will be written. /// /// This can be useful for calculating sizes. pub fn class(&self) -> write::elf::Class { write::elf::Class { is_64: self.is_64 } } /// Calculate the size of the file header. pub fn file_header_size(&self) -> usize { self.class().file_header_size() } /// Calculate the size of the program headers. pub fn program_headers_size(&self) -> usize { self.segments.count() * self.class().program_header_size() } /// Calculate the size of the dynamic symbol table. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`]. pub fn dynamic_symbol_size(&self) -> usize { (1 + self.dynamic_symbols.count()) * self.class().sym_size() } /// Calculate the size of the dynamic string table. /// /// This adds all of the currently used dynamic strings to a string table, /// calculates the size of the string table, and discards the string table. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn dynamic_string_size(&self) -> usize { let mut dynstr = write::string::StringTable::default(); for section in &self.sections { if let SectionData::Dynamic(dynamics) = §ion.data { for dynamic in dynamics { if let Dynamic::String { val, .. } = dynamic { dynstr.add(val); } } } } for symbol in &self.dynamic_symbols { dynstr.add(&symbol.name); } if let Some(version_base) = &self.version_base { dynstr.add(version_base); } for version in &self.versions { match &version.data { VersionData::Def(def) => { for name in &def.names { dynstr.add(name); } } VersionData::Need(need) => { dynstr.add(&need.name); } } } for file in &self.version_files { dynstr.add(&file.name); } dynstr.size(1) } /// Calculate the size of the hash table. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`]. pub fn hash_size(&self) -> usize { let chain_count = 1 + self.dynamic_symbols.count(); self.class() .hash_size(self.hash_bucket_count, chain_count as u32) } /// Calculate the size of the GNU hash table. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`]. pub fn gnu_hash_size(&self) -> usize { let symbol_count = self.dynamic_symbols.count_defined(); self.class().gnu_hash_size( self.gnu_hash_bloom_count, self.gnu_hash_bucket_count, symbol_count as u32, ) } /// Calculate the size of the GNU symbol version section. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn gnu_versym_size(&self) -> usize { let symbol_count = 1 + self.dynamic_symbols.count(); self.class().gnu_versym_size(symbol_count) } /// Calculate the size of the GNU version definition section. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn gnu_verdef_size(&self) -> usize { let mut verdef_count = 0; let mut verdaux_count = 0; if self.version_base.is_some() { verdef_count += 1; verdaux_count += 1; } for version in &self.versions { if let VersionData::Def(def) = &version.data { if !def.is_shared(verdef_count, self.version_base.as_ref()) { verdaux_count += def.names.len(); } verdef_count += 1; } } self.class().gnu_verdef_size(verdef_count, verdaux_count) } /// Calculate the size of the GNU version dependency section. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn gnu_verneed_size(&self) -> usize { let verneed_count = self.version_files.count(); let mut vernaux_count = 0; for version in &self.versions { if let VersionData::Need(_) = &version.data { vernaux_count += 1; } } self.class().gnu_verneed_size(verneed_count, vernaux_count) } /// Calculate the memory size of a section. /// /// Returns 0 for sections that are deleted or aren't allocated. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn section_size(&self, section: &Section<'_>) -> usize { if section.delete || !section.is_alloc() { return 0; } match §ion.data { SectionData::Data(data) => data.len(), SectionData::UninitializedData(len) => *len as usize, SectionData::Relocation(relocations) => { relocations.len() * self.class().rel_size(section.sh_type == elf::SHT_RELA) } SectionData::DynamicRelocation(relocations) => { relocations.len() * self.class().rel_size(section.sh_type == elf::SHT_RELA) } SectionData::Note(data) => data.len(), SectionData::Dynamic(dynamics) => (1 + dynamics.len()) * self.class().dyn_size(), SectionData::DynamicString => self.dynamic_string_size(), SectionData::DynamicSymbol => self.dynamic_symbol_size(), SectionData::Hash => self.hash_size(), SectionData::GnuHash => self.gnu_hash_size(), SectionData::GnuVersym => self.gnu_versym_size(), SectionData::GnuVerdef => self.gnu_verdef_size(), SectionData::GnuVerneed => self.gnu_verneed_size(), // None of these should be allocated. SectionData::SectionString | SectionData::Symbol | SectionData::SymbolSectionIndex | SectionData::String | SectionData::Attributes(_) => 0, } } /// Set the `sh_size` field for every allocated section. /// /// This is useful to call prior to doing memory layout. /// /// To get an accurate result, you may need to first call /// [`Self::delete_orphan_symbols`] and [`Self::delete_unused_versions`]. pub fn set_section_sizes(&mut self) { for id in (0..self.sections.len()).map(SectionId) { let section = self.sections.get(id); if section.delete || !section.is_alloc() { continue; } self.sections.get_mut(id).sh_size = self.section_size(section) as u64; } } /// Find the section containing the dynamic table. /// /// This uses the `PT_DYNAMIC` program header to find the dynamic section. pub fn dynamic_section(&self) -> Option<SectionId> { let segment = self .segments .iter() .find(|segment| segment.p_type == elf::PT_DYNAMIC)?; // TODO: handle multiple sections in the segment? segment.sections.iter().copied().next() } /// Find the dynamic table entries. /// /// This uses the `PT_DYNAMIC` program header to find the dynamic section, pub fn dynamic_data(&self) -> Option<&[Dynamic<'data>]> { let section = self.dynamic_section()?; match &self.sections.get(section).data { SectionData::Dynamic(dynamics) => Some(dynamics), _ => None, } } /// Find the dynamic table entries. /// /// This uses the `PT_DYNAMIC` program header to find the dynamic section, pub fn dynamic_data_mut(&mut self) -> Option<&mut Vec<Dynamic<'data>>> { let section = self.dynamic_section()?; match &mut self.sections.get_mut(section).data { SectionData::Dynamic(dynamics) => Some(dynamics), _ => None, } } /// Find the section containing the interpreter path. /// /// This uses the `PT_INTERP` program header to find the interp section. pub fn interp_section(&self) -> Option<SectionId> { let segment = self .segments .iter() .find(|segment| segment.p_type == elf::PT_INTERP)?; // TODO: handle multiple sections in the segment? segment.sections.iter().copied().next() } /// Find the interpreter path. /// /// This uses the `PT_INTERP` program header to find the interp section. pub fn interp_data(&self) -> Option<&[u8]> { let section = self.interp_section()?; match &self.sections.get(section).data { SectionData::Data(data) => Some(data), _ => None, } } /// Find the interpreter path. /// /// This uses the `PT_INTERP` program header to find the interp section. pub fn interp_data_mut(&mut self) -> Option<&mut Bytes<'data>> { let section = self.interp_section()?; match &mut self.sections.get_mut(section).data { SectionData::Data(data) => Some(data), _ => None, } } } /// ELF file header. /// /// This corresponds to fields in [`elf::FileHeader32`] or [`elf::FileHeader64`]. /// This only contains the ELF file header fields that can be modified. /// The other fields are automatically calculated. #[derive(Debug, Default)] pub struct Header { /// The OS ABI field in the file header. /// /// One of the `ELFOSABI*` constants. pub os_abi: u8, /// The ABI version field in the file header. /// /// The meaning of this field depends on the `os_abi` value. pub abi_version: u8, /// The object file type in the file header. /// /// One of the `ET_*` constants. pub e_type: u16, /// The architecture in the file header. /// /// One of the `EM_*` constants. pub e_machine: u16, /// Entry point virtual address in the file header. pub e_entry: u64, /// The processor-specific flags in the file header. /// /// A combination of the `EF_*` constants. pub e_flags: u32, /// The file offset of the program header table. /// /// Writing will fail if the program header table cannot be placed at this offset. pub e_phoff: u64, } /// An ID for referring to a segment in [`Segments`]. #[derive(Clone, Copy, PartialEq, Eq)] pub struct SegmentId(usize); impl fmt::Debug for SegmentId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "SegmentId({})", self.0) } } impl Id for SegmentId { fn index(&self) -> usize { self.0 } } impl IdPrivate for SegmentId { fn new(id: usize) -> Self { SegmentId(id) } } /// A segment in [`Segments`]. /// /// This corresponds to [`elf::ProgramHeader32`] or [`elf::ProgramHeader64`]. #[derive(Debug)] pub struct Segment<'data> { id: SegmentId, /// Ignore this segment when writing the ELF file. pub delete: bool, /// The `p_type` field in the ELF program header. /// /// One of the `PT_*` constants. pub p_type: u32, /// The `p_flags` field in the ELF program header. /// /// A combination of the `PF_*` constants. pub p_flags: u32, /// The `p_offset` field in the ELF program header. /// /// This is the file offset of the data in the segment. This should /// correspond to the file offset of the sections that are placed in /// this segment. Currently there is no support for section data /// that is not contained in sections. pub p_offset: u64, /// The `p_vaddr` field in the ELF program header. pub p_vaddr: u64, /// The `p_paddr` field in the ELF program header. pub p_paddr: u64, /// The `p_filesz` field in the ELF program header. pub p_filesz: u64, /// The `p_memsz` field in the ELF program header. pub p_memsz: u64, /// The `p_align` field in the ELF program header. pub p_align: u64, /// The sections contained in this segment. pub sections: Vec<SectionId>, // Might need to add reference to data if no sections. marker: PhantomData<&'data ()>, } impl<'data> Item for Segment<'data> { type Id = SegmentId; fn is_deleted(&self) -> bool { self.delete } } impl<'data> Segment<'data> { /// The ID used for referring to this segment. pub fn id(&self) -> SegmentId { self.id } /// Returns true if the segment type is `PT_LOAD`. pub fn is_load(&self) -> bool { self.p_type == elf::PT_LOAD } /// Returns true if the segment contains the given file offset. pub fn contains_offset(&self, offset: u64) -> bool { offset >= self.p_offset && offset - self.p_offset < self.p_filesz } /// Return the address corresponding to the given file offset. /// /// This will return a meaningless value if `contains_offset` is false. pub fn address_from_offset(&self, offset: u64) -> u64 { self.p_vaddr .wrapping_add(offset.wrapping_sub(self.p_offset)) } /// Returns true if the segment contains the given address. pub fn contains_address(&self, address: u64) -> bool { address >= self.p_vaddr && address - self.p_vaddr < self.p_memsz } /// Remove all sections from the segment, and set its size to zero. pub fn remove_sections(&mut self) { self.p_filesz = 0; self.p_memsz = 0; self.sections.clear(); } /// Add a section to the segment. /// /// If this is a [`elf::PT_LOAD`] segment, then the file offset and address of the /// section is changed to be at the end of the segment. /// /// The segment's file and address ranges are extended to include the section. /// This uses the `sh_size` field of the section, not the size of the section data. /// /// The section's id is added to the segment's list of sections. pub fn append_section(&mut self, section: &mut Section<'_>) { debug_assert_eq!(self.p_filesz, self.p_memsz); if self.p_type == elf::PT_LOAD { let align = section.sh_addralign; let offset = (self.p_offset + self.p_filesz + (align - 1)) & !(align - 1); let addr = (self.p_paddr + self.p_memsz + (align - 1)) & !(align - 1); section.sh_offset = offset; section.sh_addr = addr; } self.append_section_range(section); self.sections.push(section.id); } /// Extend this segment's file and address ranges to include the given section. /// /// If the segment's `p_memsz` is zero, then this signifies that the segment /// has no file or address range yet. In this case, the segment's file and address /// ranges are set equal to the section. Otherwise, the segment's file and address /// ranges are extended to include the section. /// /// This uses the `sh_size` field of the section, not the size of the section data. pub fn append_section_range(&mut self, section: &Section<'_>) { let section_filesize = if section.sh_type == elf::SHT_NOBITS { 0 } else { section.sh_size }; if self.p_memsz == 0 { self.p_offset = section.sh_offset; self.p_filesz = section_filesize; self.p_vaddr = section.sh_addr; self.p_paddr = section.sh_addr; self.p_memsz = section.sh_size; } else { if self.p_offset > section.sh_offset { self.p_offset = section.sh_offset; } let filesz = section.sh_offset + section_filesize - self.p_offset; if self.p_filesz < filesz { self.p_filesz = filesz; } if self.p_vaddr > section.sh_addr { self.p_vaddr = section.sh_addr; self.p_paddr = section.sh_addr; } let memsz = section.sh_addr + section.sh_size - self.p_vaddr; if self.p_memsz < memsz { self.p_memsz = memsz; } } } /// Recalculate the file and address ranges of the segment. /// /// Resets the segment's file and address ranges to zero, and then /// calls `append_section_range` for each section in the segment. pub fn recalculate_ranges(&mut self, sections: &Sections<'data>) { self.p_offset = 0; self.p_filesz = 0; self.p_vaddr = 0; self.p_paddr = 0; self.p_memsz = 0; let ids = core::mem::take(&mut self.sections); for id in &ids { let section = sections.get(*id); self.append_section_range(section); } self.sections = ids; } } /// A segment table. pub type Segments<'data> = Table<Segment<'data>>; impl<'data> Segments<'data> { /// Add a new segment to the table. pub fn add(&mut self) -> &mut Segment<'data> { let id = self.next_id(); self.push(Segment { id, delete: false, p_type: 0, p_flags: 0, p_offset: 0, p_vaddr: 0, p_paddr: 0, p_filesz: 0, p_memsz: 0, p_align: 0, sections: Vec::new(), marker: PhantomData, }); self.get_mut(id) } /// Find a `PT_LOAD` segment containing the given offset. pub fn find_load_segment_from_offset(&self, offset: u64) -> Option<&Segment<'data>> { self.iter() .find(|segment| segment.is_load() && segment.contains_offset(offset)) } /// Add a new `PT_LOAD` segment to the table. /// /// The file offset and address will be derived from the current maximum for any segment. /// The address will be chosen so that `p_paddr % align == p_offset % align`. /// You may wish to use [`Builder::load_align`] for the alignment. pub fn add_load_segment(&mut self, flags: u32, align: u64) -> &mut Segment<'data> { let mut max_offset = 0; let mut max_addr = 0; for segment in &*self { let offset = segment.p_offset + segment.p_filesz; if max_offset < offset { max_offset = offset; } let addr = segment.p_vaddr + segment.p_memsz; if max_addr < addr { max_addr = addr; } } // No alignment is required for the segment file offset because sections // will add their alignment to the file offset when they are added. let offset = max_offset; // The address must be chosen so that addr % align == offset % align. let addr = ((max_addr + (align - 1)) & !(align - 1)) + (offset & (align - 1)); let segment = self.add(); segment.p_type = elf::PT_LOAD; segment.p_flags = flags; segment.p_offset = offset; segment.p_vaddr = addr; segment.p_paddr = addr; segment.p_align = align; segment } /// Add a copy of a segment to the table. /// /// This will copy the segment type, flags and alignment. /// /// Additionally, if the segment type is `PT_LOAD`, then the file offset and address /// will be set as in `add_load_segment`. pub fn copy(&mut self, id: SegmentId) -> &mut Segment<'data> { let segment = self.get(id); let p_type = segment.p_type; let p_flags = segment.p_flags; let p_align = segment.p_align; if p_type == elf::PT_LOAD { self.add_load_segment(p_flags, p_align) } else { let segment = self.add(); segment.p_type = p_type; segment.p_flags = p_flags; segment.p_align = p_align; segment } } } /// An ID for referring to a section in [`Sections`]. #[derive(Clone, Copy, PartialEq, Eq)] pub struct SectionId(usize); impl fmt::Debug for SectionId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "SectionId({})", self.0) } } impl Id for SectionId { fn index(&self) -> usize { self.0 } } impl IdPrivate for SectionId { fn new(id: usize) -> Self { SectionId(id) } } /// A section in [`Sections`]. /// /// This corresponds to [`elf::SectionHeader32`] or [`elf::SectionHeader64`]. #[derive(Debug)] pub struct Section<'data> { id: SectionId, /// Ignore this section when writing the ELF file. pub delete: bool, /// The name of the section. /// /// This is automatically added to the section header string table, /// and the resulting string table offset is used to set the `sh_name` /// field in the ELF section header. pub name: ByteString<'data>, /// The `sh_type` field in the ELF section header. /// /// One of the `SHT_*` constants. pub sh_type: u32, /// The `sh_flags` field in the ELF section header. /// /// A combination of the `SHF_*` constants. pub sh_flags: u64, /// The `sh_addr` field in the ELF section header. pub sh_addr: u64, /// The `sh_offset` field in the ELF section header. /// /// This is the file offset of the data in the section. /// Writing will fail if the data cannot be placed at this offset. /// /// This is only used for sections that have `SHF_ALLOC` set. /// For other sections, the section data is written at the next available /// offset. pub sh_offset: u64, /// The `sh_size` field in the ELF section header. /// /// This size is not used when writing. The size of the `data` field is /// used instead. pub sh_size: u64, /// The ID of the section linked to by the `sh_link` field in the ELF section header. pub sh_link_section: Option<SectionId>, /// The `sh_info` field in the ELF section header. /// /// Only used if `sh_info_section` is `None`. pub sh_info: u32, /// The ID of the section linked to by the `sh_info` field in the ELF section header. pub sh_info_section: Option<SectionId>, /// The `sh_addralign` field in the ELF section header. pub sh_addralign: u64, /// The `sh_entsize` field in the ELF section header. pub sh_entsize: u64, /// The section data. pub data: SectionData<'data>, } impl<'data> Item for Section<'data> { type Id = SectionId; fn is_deleted(&self) -> bool { self.delete } } impl<'data> Section<'data> { /// The ID used for referring to this section. pub fn id(&self) -> SectionId { self.id } /// Returns true if the section flags include `SHF_ALLOC`. pub fn is_alloc(&self) -> bool { self.sh_flags & u64::from(elf::SHF_ALLOC) != 0 } /// Return the segment permission flags that are equivalent to the section flags. pub fn p_flags(&self) -> u32 { let mut p_flags = elf::PF_R; if self.sh_flags & u64::from(elf::SHF_WRITE) != 0 { p_flags |= elf::PF_W; } if self.sh_flags & u64::from(elf::SHF_EXECINSTR) != 0 { p_flags |= elf::PF_X; } p_flags } } /// The data for a [`Section`]. #[derive(Debug, Clone)] pub enum SectionData<'data> { /// The section contains the given raw data bytes. Data(Bytes<'data>), /// The section contains uninitialised data bytes of the given length. UninitializedData(u64), /// The section contains relocations. Relocation(Vec<Relocation>), /// The section contains dynamic relocations. DynamicRelocation(Vec<DynamicRelocation>), /// The section contains notes. // TODO: parse notes Note(Bytes<'data>), /// The section contains dynamic entries. Dynamic(Vec<Dynamic<'data>>), /// The section contains attributes. /// /// This may be GNU attributes or other vendor-specific attributes. Attributes(AttributesSection<'data>), /// The section contains the strings for the section headers. SectionString, /// The section contains the symbol table. Symbol, /// The section contains the extended section index for the symbol table. SymbolSectionIndex, /// The section contains the strings for symbol table. String, /// The section contains the dynamic symbol table. DynamicSymbol, /// The section contains the dynamic string table. DynamicString, /// The section contains the hash table. Hash, /// The section contains the GNU hash table. GnuHash, /// The section contains the GNU symbol versions. GnuVersym, /// The section contains the GNU version definitions. GnuVerdef, /// The section contains the GNU version dependencies. GnuVerneed, } /// A section table. pub type Sections<'data> = Table<Section<'data>>; impl<'data> Sections<'data> { /// Add a new section to the table. pub fn add(&mut self) -> &mut Section<'data> { let id = self.next_id(); self.push(Section { id, delete: false, name: ByteString::default(), sh_type: 0, sh_flags: 0, sh_addr: 0, sh_offset: 0, sh_size: 0, sh_link_section: None, sh_info: 0, sh_info_section: None, sh_addralign: 0, sh_entsize: 0, data: SectionData::Data(Bytes::default()), }) } /// Add a copy of a section to the table. /// /// This will set the file offset of the copy to zero. /// [`Segment::append_section`] can be used to assign a valid file offset and a new address. pub fn copy(&mut self, id: SectionId) -> &mut Section<'data> { let section = self.get(id); let id = self.next_id(); let name = section.name.clone(); let sh_type = section.sh_type; let sh_flags = section.sh_flags; let sh_addr = section.sh_addr; let sh_size = section.sh_size; let sh_link_section = section.sh_link_section; let sh_info = section.sh_info; let sh_info_section = section.sh_info_section; let sh_addralign = section.sh_addralign; let sh_entsize = section.sh_entsize; let data = section.data.clone(); self.push(Section { id, delete: false, name, sh_type, sh_flags, sh_addr, sh_offset: 0, sh_size, sh_link_section, sh_info, sh_info_section, sh_addralign, sh_entsize, data, }) } } /// An ID for referring to a symbol in [`Symbols`]. #[derive(Clone, Copy, PartialEq, Eq)] pub struct SymbolId<const DYNAMIC: bool = false>(usize); impl<const DYNAMIC: bool> fmt::Debug for SymbolId<DYNAMIC> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) } } impl<const DYNAMIC: bool> Id for SymbolId<DYNAMIC> { fn index(&self) -> usize { self.0 } } impl<const DYNAMIC: bool> IdPrivate for SymbolId<DYNAMIC> { fn new(id: usize) -> Self { SymbolId(id) } } /// A symbol in [`Symbols`]. /// /// This corresponds to [`elf::Sym32`] or [`elf::Sym64`]. #[derive(Debug)] pub struct Symbol<'data, const DYNAMIC: bool = false> { id: SymbolId<DYNAMIC>, /// Ignore this symbol when writing the ELF file. pub delete: bool, /// The name of the symbol. pub name: ByteString<'data>, /// The section referenced by the symbol. /// /// Used to set the `st_shndx` field in the ELF symbol. pub section: Option<SectionId>, /// The `st_info` field in the ELF symbol. pub st_info: u8, /// The `st_other` field in the ELF symbol. pub st_other: u8, /// The `st_shndx` field in the ELF symbol. /// /// Only used if `Self::section` is `None`. pub st_shndx: u16, /// The `st_value` field in the ELF symbol. pub st_value: u64, /// The `st_size` field in the ELF symbol. pub st_size: u64, /// GNU version for dynamic symbols. pub version: VersionId, /// Set the [`elf::VERSYM_HIDDEN`] flag for this symbol. pub version_hidden: bool, } impl<'data, const DYNAMIC: bool> Item for Symbol<'data, DYNAMIC> { type Id = SymbolId<DYNAMIC>; fn is_deleted(&self) -> bool { self.delete } } impl<'data, const DYNAMIC: bool> Symbol<'data, DYNAMIC> { /// The ID used for referring to this symbol. pub fn id(&self) -> SymbolId<DYNAMIC> { self.id } /// Get the `st_bind` component of the `st_info` field. #[inline] pub fn st_bind(&self) -> u8 { self.st_info >> 4 } /// Get the `st_type` component of the `st_info` field. #[inline] pub fn st_type(&self) -> u8 { self.st_info & 0xf } /// Set the `st_info` field given the `st_bind` and `st_type` components. #[inline] pub fn set_st_info(&mut self, st_bind: u8, st_type: u8) { self.st_info = (st_bind << 4) + (st_type & 0xf); } } /// A symbol table. pub type Symbols<'data, const DYNAMIC: bool = false> = Table<Symbol<'data, DYNAMIC>>; impl<'data, const DYNAMIC: bool> Symbols<'data, DYNAMIC> { /// Number of defined symbols. pub fn count_defined(&self) -> usize { self.into_iter() .filter(|symbol| symbol.st_shndx != elf::SHN_UNDEF) .count() } /// Add a new symbol to the table. pub fn add(&mut self) -> &mut Symbol<'data, DYNAMIC> { let id = self.next_id(); self.push(Symbol { id, delete: false, name: ByteString::default(), section: None, st_info: 0, st_other: 0, st_shndx: 0, st_value: 0, st_size: 0, version: VersionId::local(), version_hidden: false, }) } } /// A relocation stored in a [`Section`]. /// /// This corresponds to [`elf::Rel32`], [`elf::Rela32`], [`elf::Rel64`] or [`elf::Rela64 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct Relocation<const DYNAMIC: bool = false> { /// The `r_offset` field in the ELF relocation. pub r_offset: u64, /// The symbol referenced by the ELF relocation. pub symbol: Option<SymbolId<DYNAMIC>>, /// The `r_type` field in the ELF relocation. pub r_type: u32, /// The `r_addend` field in the ELF relocation. /// /// Only used if the section type is `SHT_RELA`. pub r_addend: i64, } /// A dynamic symbol ID. pub type DynamicSymbolId = SymbolId<true>; /// A dynamic symbol. pub type DynamicSymbol<'data> = Symbol<'data, true>; /// A dynamic symbol table. pub type DynamicSymbols<'data> = Symbols<'data, true>; /// A dynamic relocation. pub type DynamicRelocation = Relocation<true>; /// An entry in the dynamic section. /// /// This corresponds to [`elf::Dyn32`] or [`elf::Dyn64`]. #[derive(Debug, Clone, PartialEq, Eq)] pub enum Dynamic<'data> { /// The value is an automatically generated integer. /// /// Writing will fail if the value cannot be automatically generated. Auto { /// The `d_tag` field in the dynamic entry. /// /// One of the `DT_*` values. tag: u32, }, /// The value is an integer. Integer { /// The `d_tag` field in the dynamic entry. /// /// One of the `DT_*` values. tag: u32, /// The `d_val` field in the dynamic entry. val: u64, }, /// The value is a string. String { /// The `d_tag` field in the dynamic entry. /// /// One of the `DT_*` values. tag: u32, /// The string value. /// /// This will be stored in the dynamic string section. val: ByteString<'data>, }, } impl<'data> Dynamic<'data> { /// The `d_tag` field in the dynamic entry. /// /// One of the `DT_*` values. pub fn tag(&self) -> u32 { match self { Dynamic::Auto { tag } => *tag, Dynamic::Integer { tag, .. } => *tag, Dynamic::String { tag, .. } => *tag, } } } /// An ID for referring to a filename in [`VersionFiles`]. #[derive(Clone, Copy, PartialEq, Eq)] pub struct VersionFileId(usize); impl fmt::Debug for VersionFileId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "VersionFileId({})", self.0) } } impl Id for VersionFileId { fn index(&self) -> usize { self.0 } } impl IdPrivate for VersionFileId { fn new(id: usize) -> Self { VersionFileId(id) } } /// A filename used for GNU versioning. /// /// Stored in [`VersionFiles`]. #[derive(Debug)] pub struct VersionFile<'data> { id: VersionFileId, /// Ignore this file when writing the ELF file. pub delete: bool, /// The filename. pub name: ByteString<'data>, } impl<'data> Item for VersionFile<'data> { type Id = VersionFileId; fn is_deleted(&self) -> bool { self.delete } } impl<'data> VersionFile<'data> { /// The ID used for referring to this filename. pub fn id(&self) -> VersionFileId { self.id } } /// A table of filenames used for GNU versioning. pub type VersionFiles<'data> = Table<VersionFile<'data>>; impl<'data> VersionFiles<'data> { /// Add a new filename to the table. pub fn add(&mut self, name: ByteString<'data>) -> VersionFileId { let id = self.next_id(); self.push(VersionFile { id, name, delete: false, }); id } } const VERSION_ID_BASE: usize = 2; /// An ID for referring to a version in [`Versions`]. #[derive(Clone, Copy, PartialEq, Eq)] pub struct VersionId(usize); impl fmt::Debug for VersionId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "VersionId({})", self.0) } } impl Id for VersionId { fn index(&self) -> usize { self.0 - VERSION_ID_BASE } } impl IdPrivate for VersionId { fn new(id: usize) -> Self { VersionId(VERSION_ID_BASE + id) } } impl VersionId { /// Return `True` if this is a special version that does not exist in the version table. pub fn is_special(&self) -> bool { self.0 < VERSION_ID_BASE } /// Return the ID for a version index of [`elf::VER_NDX_LOCAL`]. pub fn local() -> Self { VersionId(elf::VER_NDX_LOCAL as usize) } /// Return the ID for a version index of [`elf::VER_NDX_GLOBAL`]. pub fn global() -> Self { VersionId(elf::VER_NDX_GLOBAL as usize) } } /// A version for a symbol. #[derive(Debug)] pub struct Version<'data> { id: VersionId, /// The data for this version. pub data: VersionData<'data>, /// Ignore this version when writing the ELF file. pub delete: bool, } impl<'data> Item for Version<'data> { type Id = VersionId; fn is_deleted(&self) -> bool { self.delete } } impl<'data> Version<'data> { /// The ID used for referring to this version. pub fn id(&self) -> VersionId { self.id } } /// The data for a version for a symbol. #[derive(Debug)] pub enum VersionData<'data> { /// The version for a defined symbol. Def(VersionDef<'data>), /// The version for an undefined symbol. Need(VersionNeed<'data>), } /// A GNU version definition. #[derive(Debug)] pub struct VersionDef<'data> { /// The names for the version. /// /// This usually has two elements. The first element is the name of this /// version, and the second element is the name of the previous version /// in the tree of versions. pub names: Vec<ByteString<'data>>, /// The version flags. /// /// A combination of the `VER_FLG_*` constants. pub flags: u16, } impl<'data> VersionDef<'data> { /// Optimise for the common case where the first version is the same as the base version. fn is_shared(&self, index: usize, base: Option<&ByteString<'_>>) -> bool { index == 1 && self.names.len() == 1 && self.names.first() == base } } /// A GNU version dependency. #[derive(Debug)] pub struct VersionNeed<'data> { /// The filename of the library providing this version. pub file: VersionFileId, /// The name of the version. pub name: ByteString<'data>, /// The version flags. /// /// A combination of the `VER_FLG_*` constants. pub flags: u16, } /// A table of versions that are referenced by symbols. pub type Versions<'data> = Table<Version<'data>>; impl<'data> Versions<'data> { /// Add a version. pub fn add(&mut self, data: VersionData<'data>) -> VersionId { let id = self.next_id(); self.push(Version { id, data, delete: false, }); id } } /// The contents of an attributes section. #[derive(Debug, Default, Clone)] pub struct AttributesSection<'data> { /// The subsections. pub subsections: Vec<AttributesSubsection<'data>>, } impl<'data> AttributesSection<'data> { /// Create a new attributes section. pub fn new() -> Self { Self::default() } } /// A subsection of an attributes section. #[derive(Debug, Clone)] pub struct AttributesSubsection<'data> { /// The vendor namespace for these attributes. pub vendor: ByteString<'data>, /// The sub-subsections. pub subsubsections: Vec<AttributesSubsubsection<'data>>, } impl<'data> AttributesSubsection<'data> { /// Create a new subsection. pub fn new(vendor: ByteString<'data>) -> Self { AttributesSubsection { vendor, subsubsections: Vec::new(), } } } /// A sub-subsection in an attributes section. #[derive(Debug, Clone)] pub struct AttributesSubsubsection<'data> { /// The sub-subsection tag. pub tag: AttributeTag, /// The data containing the attributes. pub data: Bytes<'data>, } /// The tag for a sub-subsection in an attributes section. #[derive(Debug, Clone, PartialEq, Eq)] pub enum AttributeTag { /// The attributes apply to the whole file. /// /// Correspeonds to [`elf::Tag_File`]. File, /// The attributes apply to the given sections. /// /// Correspeonds to [`elf::Tag_Section`]. Section(Vec<SectionId>), /// The attributes apply to the given symbols. /// /// Correspeonds to [`elf::Tag_Symbol`]. Symbol(Vec<SymbolId>), } impl AttributeTag { /// Return the corresponding `elf::Tag_*` value for this tag. pub fn tag(&self) -> u8 { match self { AttributeTag::File => elf::Tag_File, AttributeTag::Section(_) => elf::Tag_Section, AttributeTag::Symbol(_) => elf::Tag_Symbol, } } } [Seitenstruktur0.79Druckenetwas mehr zur Ethik2026-04-28] |
2026-05-26