chore: cherry pick #112 (skip parse dynamic sections) (#116)

Cargo.toml

@@ -18,6 +18,7 @@ detect-asm = []
 byteorder = "1"
 bytes = "0.5.4"
 goblin = "0.2.0"
+scroll = "0.10"
 ckb-vm-definitions = { path = "definitions", version = "0.19.1" }
 derive_more = "0.99.2"
 

src/machine/aot/mod.rs

@@ -10,8 +10,10 @@ use super::super::{
 };
 use bytes::Bytes;
 use emitter::Emitter;
-use goblin::elf::{section_header::SHF_EXECINSTR, Elf};
+use goblin::container::Ctx;
+use goblin::elf::{section_header::SHF_EXECINSTR, Header, SectionHeader};
 use memmap::{Mmap, MmapMut};
+use scroll::Pread;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 
@@ -93,12 +95,25 @@ struct LabelGatheringMachine {
 
 impl LabelGatheringMachine {
     pub fn load(program: &Bytes) -> Result<Self, Error> {
-        let elf = Elf::parse(program).map_err(|_e| Error::ParseError)?;
-        if elf.section_headers.len() > MAXIMUM_SECTIONS {
+        let header = program.pread::<Header>(0).map_err(|_e| Error::ParseError)?;
+        let container = header.container().map_err(|_e| Error::InvalidElfBits)?;
+        let endianness = header.endianness().map_err(|_e| Error::InvalidElfBits)?;
+        if <Self as CoreMachine>::REG::BITS != if container.is_big() { 64 } else { 32 } {
+            return Err(Error::InvalidElfBits);
+        }
+        let ctx = Ctx::new(container, endianness);
+        let section_headers = SectionHeader::parse(
+            program,
+            header.e_shoff as usize,
+            header.e_shnum as usize,
+            ctx,
+        )
+        .map_err(|_e| Error::ParseError)?;
+
+        if section_headers.len() > MAXIMUM_SECTIONS {
             return Err(Error::LimitReached);
         }
-        let mut sections: Vec<(u64, u64)> = elf
-            .section_headers
+        let mut sections: Vec<(u64, u64)> = section_headers
             .iter()
             .filter_map(|section_header| {
                 if section_header.sh_flags & u64::from(SHF_EXECINSTR) != 0 {

src/machine/mod.rs

@@ -14,22 +14,12 @@ use super::{
     Error, DEFAULT_STACK_SIZE, RISCV_GENERAL_REGISTER_NUMBER, RISCV_MAX_MEMORY,
 };
 use bytes::Bytes;
+use goblin::container::Ctx;
 use goblin::elf::program_header::{PF_R, PF_W, PF_X, PT_LOAD};
-use goblin::elf::{Elf, Header};
+use goblin::elf::{Header, ProgramHeader};
+use scroll::Pread;
 use std::fmt::{self, Display};
 
-fn elf_bits(header: &Header) -> Option<u8> {
-    // This is documented in ELF specification, we are exacting ELF file
-    // class part here.
-    // Right now we are only supporting 32 and 64 bits, in the future we
-    // might add 128 bits support.
-    match header.e_ident[4] {
-        1 => Some(32),
-        2 => Some(64),
-        _ => None,
-    }
-}
-
 // Converts goblin's ELF flags into RISC-V flags
 fn convert_flags(p_flags: u32) -> Result<u8, Error> {
     let readable = p_flags & PF_R != 0;
@@ -97,13 +87,22 @@ pub trait SupportMachine: CoreMachine {
     }
 
     fn load_elf(&mut self, program: &Bytes, update_pc: bool) -> Result<u64, Error> {
-        let elf = Elf::parse(program).map_err(|_e| Error::ParseError)?;
-        let bits = elf_bits(&elf.header).ok_or(Error::InvalidElfBits)?;
-        if bits != Self::REG::BITS {
+        let header = program.pread::<Header>(0).map_err(|_e| Error::ParseError)?;
+        let container = header.container().map_err(|_e| Error::InvalidElfBits)?;
+        let endianness = header.endianness().map_err(|_e| Error::InvalidElfBits)?;
+        if Self::REG::BITS != if container.is_big() { 64 } else { 32 } {
             return Err(Error::InvalidElfBits);
         }
+        let ctx = Ctx::new(container, endianness);
+        let program_headers = ProgramHeader::parse(
+            program,
+            header.e_phoff as usize,
+            header.e_phnum as usize,
+            ctx,
+        )
+        .map_err(|_e| Error::ParseError)?;
         let mut bytes: u64 = 0;
-        for program_header in &elf.program_headers {
+        for program_header in program_headers {
             if program_header.p_type == PT_LOAD {
                 let aligned_start = round_page_down(program_header.p_vaddr);
                 let padding_start = program_header.p_vaddr.wrapping_sub(aligned_start);
@@ -130,7 +129,7 @@ pub trait SupportMachine: CoreMachine {
             }
         }
         if update_pc {
-            self.set_pc(Self::REG::from_u64(elf.header.e_entry));
+            self.set_pc(Self::REG::from_u64(header.e_entry));
         }
         Ok(bytes)
     }