diff --git a/src/common/section.rs b/src/common/section.rs index e362456..23e2a37 100644 --- a/src/common/section.rs +++ b/src/common/section.rs @@ -14,7 +14,7 @@ pub struct SectionInfo<'data> { pub enum Section<'data> { Text(SectionInfo<'data>), - Data(SectionInfo<'data>), + Data(SectionInfo<'data>, bool), // readonly bool Bss(SectionInfo<'data>), } @@ -22,7 +22,7 @@ impl Section<'_> { pub fn size(&self) -> Result { match self { Section::Text(s) => Ok(s.size), - Section::Data(s) => Ok(s.size), + Section::Data(s, _) => Ok(s.size), Section::Bss(s) => Ok(s.size), } } @@ -34,8 +34,10 @@ impl<'data> TryFrom<(&str, SectionInfo<'data>)> for Section<'data> { fn try_from(value: (&str, SectionInfo<'data>)) -> Result { if value.0.starts_with(".text") { Ok(Section::Text(value.1)) - } else if value.0.starts_with(".rodata") || value.0.starts_with(".data") { - Ok(Section::Data(value.1)) + } else if value.0.starts_with(".rodata") { + Ok(Section::Data(value.1, true)) + } else if value.0.starts_with(".data") { + Ok(Section::Data(value.1, false)) } else if value.0.starts_with(".bss") { Ok(Section::Bss(value.1)) } else { @@ -60,7 +62,8 @@ impl Display for Section<'_> { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { Section::Text(s) => writeln!(f, "TEXT {}", s), - Section::Data(s) => writeln!(f, "DATA {}", s), + Section::Data(s, false) => writeln!(f, "DATA {}", s), + Section::Data(s, true) => writeln!(f, "RO-DATA {}", s), Section::Bss(s) => writeln!(f, "BSS {}", s), } } diff --git a/src/common/storage.rs b/src/common/storage.rs index 97d4d75..99ebd83 100644 --- a/src/common/storage.rs +++ b/src/common/storage.rs @@ -21,7 +21,7 @@ impl Storage { } pub fn destination(&self) -> Result { - let mut dest = canonicalize(&self.origin).map_err(|e| Error::from(e))?; + let mut dest = canonicalize(&self.origin)?; if !dest.pop() { let err = std::io::Error::new(ErrorKind::Other, "Destination path invalid"); Err(Error::IOError(Box::new(err))) diff --git a/src/formats/elf.rs b/src/formats/elf.rs index 4cfdb88..ddd8ade 100644 --- a/src/formats/elf.rs +++ b/src/formats/elf.rs @@ -4,6 +4,7 @@ use crate::linker::Linker; mod object; mod output; +mod segment; use elf_utilities::file::ELF64; pub use object::*; @@ -17,7 +18,7 @@ impl Linker<'_> { } impl<'data> Lazy<&'data str, ELF64> for Symbol<'data> { - fn value(&self, src: &ELF64) -> Result<&'data str, Error> { + fn value(&self, _src: &ELF64) -> Result<&'data str, Error> { Err(Error::InvalidSectionData) // TODO } diff --git a/src/formats/elf/output.rs b/src/formats/elf/output.rs index 2004c64..347053c 100644 --- a/src/formats/elf/output.rs +++ b/src/formats/elf/output.rs @@ -1,27 +1,27 @@ -use std::path::PathBuf; +use std::{fs::File, io::BufWriter, io::Write, mem::size_of, path::PathBuf}; use elf_utilities::{ - file::{ELF64Dumper, ELF64}, - section::Section64, - segment::{Segment64, Type}, + file::ELF64, + header::Ehdr64, + section::{build_string_table, Contents64, Section64, Shdr64}, + segment::{Phdr64, PF_R, PF_W, PF_X}, }; use crate::{ - common::{Output, Section, SectionInfo}, + common::{Output, Section}, error::Error, }; +use super::segment::*; use super::ElfObject; pub struct ElfOutput<'data> { destination: PathBuf, - dump: ELF64Dumper, - text: Vec>, - data: Vec>, - bss: Vec>, + file: ELF64, + segment_data: SegmentData<'data>, } -impl ElfOutput<'_> { +impl<'data> ElfOutput<'data> { pub fn new(destination: PathBuf) -> Self { use elf_utilities::header::{Class, Data, Machine, Type, Version, OSABI}; @@ -36,55 +36,119 @@ impl ElfOutput<'_> { Self { destination, - dump: ELF64Dumper::new(elf), - text: Vec::new(), - data: Vec::new(), - bss: Vec::new(), + file: elf, + segment_data: SegmentData::new(), } } pub fn from_object(object: &ElfObject, destination: PathBuf) -> Self { - use elf_utilities::header::Type; - let other = object.elf(); - let mut elf = ELF64::default(); - elf.ehdr = other.ehdr.clone(); - elf.ehdr.set_elf_type(Type::Exec); - Self { destination, - dump: ELF64Dumper::new(elf), - text: Vec::new(), - data: Vec::new(), - bss: Vec::new(), + file: elf_bin_from_object(other), + segment_data: SegmentData::new(), } } - fn populate_section_data(&mut self) -> Result { - use elf_utilities::section::{Contents64, Shdr64, Type}; + fn populate_sections(&mut self) -> Result { + let mut names = Vec::new(); + let mut names_len = 0usize; + let mut result = 0u64; + + for (name, sections) in self.segment_data.iter_mut() { + let mut data = Vec::new(); - let mut data = Vec::new(); + for t in sections.iter_mut() { + if let Some(iter) = &mut t.data { + data.extend(iter.as_mut()); + } + } - for t in self.text.iter_mut() { - if let Some(iter) = &mut t.data { - data.extend(iter.as_mut()); + if data.is_empty() { + continue; } + + result += data.len() as u64; + names_len += name.len(); + names.push(name); + let section = Section64 { + name: name.into(), + header: make_section_header(&name, names_len, data.len()), + contents: Contents64::Raw(data), + }; + self.file.add_section(section); } - let mut header = Shdr64::default(); - header.set_type(Type::ProgBits); - header.sh_entsize = data.len() as u64; + let name = ".shstrtab"; + names_len += name.len(); + names.push(name); + let string_table = build_string_table(names, true); + result += string_table.len() as u64; + let section = Section64 { + name: name.into(), + header: make_section_header(&name, names_len, string_table.len()), + contents: Contents64::Raw(string_table), + }; + self.file.add_section(section); + + Ok(result) + } + + fn populate_segment(&mut self, offset: &mut u64, size: u64, which: SegmentType) -> u64 { + use elf_utilities::segment::{Segment64, Type}; + + if size == 0 { + return 0; + } - let sec64 = Section64 { - name: ".text".into(), - header, - contents: Contents64::Raw(data), + let mut segment = Segment64 { + header: Phdr64::default(), }; + segment.header.set_type(Type::Load); + segment.header.p_filesz = size; + segment.header.p_memsz = size; + segment.header.p_offset = *offset; + + match which { + SegmentType::Text => segment.header.p_flags = PF_R | PF_X, + SegmentType::Data => segment.header.p_flags = PF_R | PF_W, + SegmentType::Bss => { + segment.header.p_flags = PF_R; + segment.header.p_memsz = 0; + } + } + + self.file.segments.push(segment); + self.file.ehdr.e_phnum += 1; + self.file.ehdr.e_phentsize = size_of::() as u16; - self.dump.file.add_section(sec64); + *offset += size; - Ok(0) + size + } + + fn populate_segments(&mut self) -> Result { + let mut offset = 0u64; + let mut result = 0u64; + // program header/segments + // contains .text + .rodata as one segment + result += self.populate_segment( + &mut offset, + self.segment_data.program_size(), + SegmentType::Text, + ); + // contains .data as one segment + result += self.populate_segment( + &mut offset, + self.segment_data.data_size(), + SegmentType::Data, + ); + // contains .bss as one segment + result += + self.populate_segment(&mut offset, self.segment_data.bss_size(), SegmentType::Bss); + + Ok(result) } } @@ -94,24 +158,28 @@ impl<'data> Output<'data> for ElfOutput<'data> { } fn append_section(&mut self, section: Section<'data>) -> Result<(), Error> { - match section { - Section::Text(si) => self.text.push(si), - Section::Data(si) => self.data.push(si), - Section::Bss(si) => self.bss.push(si), - } - - Ok(()) + self.segment_data.append_section(section) } fn finalize(mut self) -> Result { use std::io::Error as IOError; use std::io::ErrorKind; - self.populate_section_data()?; - let mut segment = Segment64::default(); - segment.header.set_type(Type::Load); - self.dump.file.segments.push(segment); - self.dump.file.finalize(); + const EHS: u64 = size_of::() as u64; + const PHS: u64 = size_of::() as u64; + const SHS: u16 = size_of::() as u16; + + let segment_data_size = self.populate_sections()?; + self.populate_segments()?; + + self.file.ehdr.e_phentsize = PHS as u16; + self.file.ehdr.e_shentsize = SHS; + self.file.ehdr.e_phoff = EHS; // TODO: align + self.file.ehdr.e_shoff = self.file.ehdr.e_phoff + + u64::from(self.file.ehdr.e_phnum * self.file.ehdr.e_phentsize) + + segment_data_size; + self.file.ehdr.e_shnum = self.file.sections.len() as u16; + self.file.ehdr.e_entry = 0x100; // TODO let str_path = self.destination.to_str().ok_or_else(|| { let ioe = IOError::new(ErrorKind::Other, "Path expansion fail"); @@ -119,10 +187,80 @@ impl<'data> Output<'data> for ElfOutput<'data> { Error::IOError(boxed) })?; - self.dump - .generate_elf_file(str_path, 0o755) - .map_err(|e| Error::IOError(e))?; + let mut writer = file_writer(str_path, 0o755)?; + let mut offset = 0; + + offset += writer.write(&self.file.ehdr.to_le_bytes())?; + + // write program header table + for seg in self.file.segments.iter_mut() { + seg.header.p_offset = offset as u64; + offset += writer.write(&seg.header.to_le_bytes())?; + } + + // write section/segment data + for sec in self.file.sections.iter_mut() { + sec.header.sh_offset = offset as u64; + offset += writer.write(&sec.to_le_bytes())?; + } + + // write section header table + for sec in self.file.sections.iter() { + eprintln!("NAme index: {}", sec.header.sh_name); + offset += writer.write(&sec.header.to_le_bytes())?; + } + writer.flush()?; Ok(self.destination) } } + +fn file_writer(output_filename: &str, permission: u32) -> Result, Error> { + use std::os::unix::fs::OpenOptionsExt; + + let file = std::fs::OpenOptions::new() + .create(true) + .read(true) + .write(true) + .mode(permission) + .open(output_filename)?; + + Ok(BufWriter::new(file)) +} + +// init new ELF64 from an object file meant as executable output +fn elf_bin_from_object(other: &ELF64) -> ELF64 { + use elf_utilities::header::Type; + + let mut elf = ELF64::default(); + elf.ehdr.set_elf_type(Type::Exec); + elf.ehdr.e_ehsize = other.ehdr.e_ehsize; + elf.ehdr.e_version = other.ehdr.e_version; + elf.ehdr.e_ident = other.ehdr.e_ident; + elf.ehdr.e_machine = other.ehdr.e_machine; + + elf +} + +fn make_section_header(name: &str, names_len: usize, size: usize) -> Shdr64 { + use elf_utilities::section::Type; + + let mut h = Shdr64::default(); + match name { + ".shstrtab" => h.set_type(Type::StrTab), + ".bss" => h.set_type(Type::NoBits), + _ => h.set_type(Type::ProgBits), + } + + // section index used for name and section indexing (currently same) + let idx = 1 + (names_len as u32); // add 0 at start + // name index + h.sh_name = idx; + // link index + h.sh_link = 0; //idx; + h.sh_size = size as u64; + // TODO + // h.sh_offset = offset; + + h +} diff --git a/src/formats/elf/segment.rs b/src/formats/elf/segment.rs new file mode 100644 index 0000000..241b467 --- /dev/null +++ b/src/formats/elf/segment.rs @@ -0,0 +1,83 @@ +use crate::common::Section; +use crate::common::SectionInfo; +use crate::error::Error; + +const SI_TEXT: usize = 0; +const SI_RODATA: usize = 1; +const SI_DATA: usize = 2; +const SI_BSS: usize = 3; + +pub enum SegmentType { + Text = SI_TEXT as isize, + Data = SI_DATA as isize, + Bss = SI_BSS as isize, +} + +const SEGMENT_NAMES: [&str; 4] = [".text", ".rodata", ".data", ".bss"]; + +pub struct SegmentData<'data>([Vec>; 4]); + +impl<'data> SegmentData<'data> { + pub fn new() -> Self { + Self([Vec::new(), Vec::new(), Vec::new(), Vec::new()]) + } + + pub fn append_section(&mut self, section: Section<'data>) -> Result<(), Error> { + match section { + Section::Text(si) => self.0[SI_TEXT].push(si), + Section::Data(si, false) => self.0[SI_DATA].push(si), + Section::Data(si, true) => self.0[SI_RODATA].push(si), + Section::Bss(si) => self.0[SI_BSS].push(si), + } + + Ok(()) + } + + pub fn iter_mut( + &mut self, + ) -> impl Iterator>)> { + self.0 + .iter_mut() + .enumerate() + .map(|(i, s)| (SEGMENT_NAMES[i], s)) + } + + // .text + .rodata + pub fn program_size(&self) -> u64 { + let text_iter = self.0[SI_TEXT].iter(); + let rodata_iter = self.0[SI_RODATA].iter(); + + let mut result = 0u64; + for section in text_iter.chain(rodata_iter) { + result += section.size + } + + result + } + + // data + pub fn data_size(&self) -> u64 { + let mut result = 0u64; + for section in self.0[SI_DATA].iter() { + result += section.size + } + + result + } + + // bss + pub fn bss_size(&self) -> u64 { + let mut result = 0u64; + for section in self.0[SI_BSS].iter() { + result += section.size + } + + result + } +} + +impl Default for SegmentData<'_> { + fn default() -> Self { + Self::new() + } +}