Remove the dependency on xmas_elf (#821)

Author: jessebraham

Cargo.lock

@@ -56,7 +56,6 @@ strum           = { version = "0.26.3", features = ["derive"] }
 thiserror       = "2.0.10"
 toml            = { version = "0.8.19", optional = true }
 update-informer = { version = "1.2.0", optional = true }
-xmas-elf        = "0.9.1"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.169"

espflash/Cargo.toml

@@ -25,8 +25,8 @@ use esp_idf_part::{DataType, Partition, PartitionTable};
 use indicatif::{style::ProgressStyle, HumanCount, ProgressBar};
 use log::{debug, info, warn};
 use miette::{IntoDiagnostic, Result, WrapErr};
+use object::read::elf::ElfFile32 as ElfFile;
 use serialport::{FlowControl, SerialPortInfo, SerialPortType, UsbPortInfo};
-use xmas_elf::ElfFile;
 
 use self::{
     config::Config,
@@ -35,7 +35,7 @@ use self::{
 };
 use crate::{
     connection::reset::{ResetAfterOperation, ResetBeforeOperation},
-    error::{ElfError, Error, MissingPartition, MissingPartitionTable},
+    error::{Error, MissingPartition, MissingPartitionTable},
     flasher::{
         FlashData,
         FlashFrequency,
@@ -607,9 +607,7 @@ pub fn save_elf_as_image(
     skip_padding: bool,
     xtal_freq: XtalFrequency,
 ) -> Result<()> {
-    let elf = ElfFile::new(elf_data)
-        .map_err(ElfError::from)
-        .into_diagnostic()?;
+    let elf = ElfFile::parse(elf_data).into_diagnostic()?;
 
     if merge {
         // To get a chip revision, the connection is needed

espflash/src/cli/mod.rs

@@ -181,7 +181,7 @@ pub enum Error {
         code(espflash::invalid_elf),
         help("Try running `cargo clean` and rebuilding the image")
     )]
-    InvalidElf(#[from] ElfError),
+    InvalidElf(#[from] object::Error),
 
     #[error("The bootloader returned an error")]
     #[cfg(feature = "serialport")]
@@ -492,17 +492,6 @@ impl From<String> for MissingPartition {
 )]
 pub struct MissingPartitionTable;
 
-/// Invalid ELF file error
-#[derive(Debug, Error)]
-#[error("{0}")]
-pub struct ElfError(&'static str);
-
-impl From<&'static str> for ElfError {
-    fn from(err: &'static str) -> Self {
-        ElfError(err)
-    }
-}
-
 #[cfg(feature = "serialport")]
 pub(crate) trait ResultExt {
     /// Mark an error as having occurred during the flashing stage

espflash/src/error.rs

@@ -13,12 +13,12 @@ use esp_idf_part::PartitionTable;
 use log::{debug, info, warn};
 #[cfg(feature = "serialport")]
 use md5::{Digest, Md5};
+#[cfg(feature = "serialport")]
+use object::{read::elf::ElfFile32 as ElfFile, Endianness};
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "serialport")]
 use serialport::UsbPortInfo;
 use strum::{Display, EnumIter, IntoEnumIterator, VariantNames};
-#[cfg(feature = "serialport")]
-use xmas_elf::ElfFile;
 
 #[cfg(feature = "serialport")]
 pub(crate) use self::stubs::{FLASH_SECTOR_SIZE, FLASH_WRITE_SIZE};
@@ -32,7 +32,7 @@ use crate::{
         Connection,
         Port,
     },
-    error::{ConnectionError, ElfError, ResultExt as _},
+    error::{ConnectionError, ResultExt as _},
     flasher::stubs::{
         FlashStub,
         CHIP_DETECT_MAGIC_REG_ADDR,
@@ -1011,13 +1011,13 @@ impl Flasher {
         elf_data: &[u8],
         mut progress: Option<&mut dyn ProgressCallbacks>,
     ) -> Result<(), Error> {
-        let elf = ElfFile::new(elf_data).map_err(ElfError::from)?;
+        let elf = ElfFile::parse(elf_data)?;
         if rom_segments(self.chip, &elf).next().is_some() {
             return Err(Error::ElfNotRamLoadable);
         }
 
         let mut target = self.chip.ram_target(
-            Some(elf.header.pt2.entry_point() as u32),
+            Some(elf.elf_header().e_entry.get(Endianness::Little)),
             self.chip
                 .into_target()
                 .max_ram_block_size(&mut self.connection)?,
@@ -1041,7 +1041,7 @@ impl Flasher {
         mut progress: Option<&mut dyn ProgressCallbacks>,
         xtal_freq: XtalFrequency,
     ) -> Result<(), Error> {
-        let elf = ElfFile::new(elf_data).map_err(ElfError::from)?;
+        let elf = ElfFile::parse(elf_data)?;
 
         let mut target =
             self.chip

espflash/src/flasher/mod.rs

@@ -4,8 +4,8 @@ use std::{borrow::Cow, io::Write, iter::once, mem::size_of};
 
 use bytemuck::{bytes_of, from_bytes, Pod, Zeroable};
 use esp_idf_part::{AppType, DataType, Partition, PartitionTable, SubType, Type};
+use object::{read::elf::ElfFile32 as ElfFile, Endianness};
 use sha2::{Digest, Sha256};
-use xmas_elf::ElfFile;
 
 use super::{ram_segments, rom_segments, Segment};
 use crate::{
@@ -190,7 +190,7 @@ impl<'a> IdfBootloaderFormat<'a> {
         // write the header of the app
         // use the same settings as the bootloader
         // just update the entry point
-        header.entry = elf.header.pt2.entry_point() as u32;
+        header.entry = elf.elf_header().e_entry.get(Endianness::Little);
         header.wp_pin = WP_PIN_DISABLED;
         header.chip_id = params.chip_id;
         header.min_chip_rev_full = flash_data.min_chip_rev;

espflash/src/image_format/esp_idf.rs

@@ -8,9 +8,12 @@ use std::{
     ops::AddAssign,
 };
 
-use xmas_elf::{
-    sections::{SectionData, ShType},
-    ElfFile,
+use object::{
+    elf::SHT_PROGBITS,
+    read::elf::{ElfFile32 as ElfFile, SectionHeader},
+    Endianness,
+    Object as _,
+    ObjectSection as _,
 };
 
 pub use self::esp_idf::IdfBootloaderFormat;
@@ -163,19 +166,18 @@ pub(crate) fn rom_segments<'a>(
 
 fn segments<'a>(elf: &'a ElfFile<'a>) -> Box<dyn Iterator<Item = Segment<'a>> + 'a> {
     Box::new(
-        elf.section_iter()
-            .filter(|header| {
-                header.size() > 0
-                    && header.get_type() == Ok(ShType::ProgBits)
-                    && header.offset() > 0
-                    && header.address() > 0
+        elf.sections()
+            .filter(|section| {
+                let header = section.elf_section_header();
+
+                section.size() > 0
+                    && header.sh_type(Endianness::Little) == SHT_PROGBITS
+                    && header.sh_offset.get(Endianness::Little) > 0
+                    && section.address() > 0
             })
-            .flat_map(move |header| {
-                let addr = header.address() as u32;
-                match header.get_data(elf) {
-                    Ok(SectionData::Undefined(data)) => Some(Segment::new(addr, data)),
-                    _ => None,
-                }
+            .flat_map(move |section| match section.data() {
+                Ok(data) => Some(Segment::new(section.address() as u32, data)),
+                _ => None,
             }),
     )
 }

espflash/src/image_format/mod.rs

@@ -1,6 +1,6 @@
 use std::ops::Range;
 
-use xmas_elf::ElfFile;
+use object::read::elf::ElfFile32 as ElfFile;
 
 #[cfg(feature = "serialport")]
 use crate::{connection::Connection, targets::bytes_to_mac_addr};

espflash/src/targets/esp32.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, ops::Range};
 
 use log::debug;
-use xmas_elf::ElfFile;
+use object::read::elf::ElfFile32 as ElfFile;
 
 #[cfg(feature = "serialport")]
 use crate::{connection::Connection, targets::bytes_to_mac_addr};

espflash/src/targets/esp32c2.rs

@@ -1,6 +1,6 @@
 use std::ops::Range;
 
-use xmas_elf::ElfFile;
+use object::read::elf::ElfFile32 as ElfFile;
 
 #[cfg(feature = "serialport")]
 use crate::connection::Connection;