feat(relocation):introduce the SupportLazy trait

Author: weizhiao

src/image/kinds/dylib.rs

@@ -12,7 +12,7 @@ use crate::{
     loader::LoadHook,
     os::Mmap,
     parse_ehdr_error,
-    relocation::{Relocatable, RelocationHandler, Relocator, SymbolLookup},
+    relocation::{Relocatable, RelocationHandler, Relocator, SupportLazy, SymbolLookup},
     tls::TlsResolver,
 };
 use alloc::vec::Vec;
@@ -32,6 +32,8 @@ where
     pub(crate) inner: DynamicImage<D>,
 }
 
+impl<D: 'static> SupportLazy for RawDylib<D> {}
+
 impl<D> Debug for RawDylib<D> {
     /// Formats the [`RawDylib`] for debugging purposes.
     ///
@@ -248,7 +250,10 @@ where
             return Err(parse_ehdr_error("file type mismatch"));
         }
 
-        let phdrs = self.buf.prepare_phdrs(&ehdr, &mut object)?;
+        let phdrs = self
+            .buf
+            .prepare_phdrs(&ehdr, &mut object)?
+            .unwrap_or_default();
 
         // Load the relocated common part
         let builder = self.inner.create_builder::<M, Tls>(ehdr, phdrs, object)?;

src/image/kinds/exec.rs

@@ -1,3 +1,4 @@
+use crate::relocation::SupportLazy;
 use crate::sync::Arc;
 /// Executable file handling
 ///
@@ -133,6 +134,8 @@ where
     pub(crate) inner: ExecImageInner<D>,
 }
 
+impl<D: 'static> SupportLazy for RawExec<D> {}
+
 pub(crate) enum ExecImageInner<D>
 where
     D: 'static,
@@ -260,7 +263,10 @@ where
             return Err(parse_ehdr_error("file type mismatch"));
         }
 
-        let phdrs = self.buf.prepare_phdrs(&ehdr, &mut object)?;
+        let phdrs = self
+            .buf
+            .prepare_phdrs(&ehdr, &mut object)?
+            .unwrap_or_default();
         let has_dynamic = phdrs.iter().any(|phdr| phdr.p_type == PT_DYNAMIC);
 
         let res = if has_dynamic {

src/image/kinds/object.rs

@@ -59,7 +59,10 @@ where
         log::debug!("Loading object: {}", object.file_name());
 
         let ehdr = self.buf.prepare_ehdr(&mut object)?;
-        let shdrs = self.buf.prepare_shdrs_mut(&ehdr, &mut object)?;
+        let shdrs = self
+            .buf
+            .prepare_shdrs_mut(&ehdr, &mut object)?
+            .ok_or_else(|| crate::parse_ehdr_error("object file must have section headers"))?;
         let builder = self
             .inner
             .create_object_builder::<M, Tls>(ehdr, shdrs, object)?;

src/image/mod.rs

@@ -280,7 +280,7 @@ impl<M: Mmap, H: LoadHook, D: Default + 'static> Loader<M, H, D> {
             elf::abi::ET_REL => Ok(RawElf::Object(self.load_object_impl(object)?)),
             elf::abi::ET_EXEC => Ok(RawElf::Exec(self.load_exec_impl(object)?)),
             elf::abi::ET_DYN => {
-                let phdrs = self.read_phdr(&mut object, &ehdr)?;
+                let phdrs = self.read_phdr(&mut object, &ehdr)?.unwrap_or_default();
                 let has_dynamic = phdrs.iter().any(|p| p.p_type == PT_DYNAMIC);
                 let is_pie = phdrs.iter().any(|p| p.p_type == PT_INTERP) || !has_dynamic;
                 if is_pie {

src/loader.rs

@@ -33,37 +33,43 @@ impl ElfBuf {
         &mut self,
         ehdr: &ElfHeader,
         object: &mut impl ElfReader,
-    ) -> Result<&[ElfPhdr]> {
+    ) -> Result<Option<&[ElfPhdr]>> {
         let (phdr_start, phdr_end) = ehdr.phdr_range();
         let size = phdr_end - phdr_start;
+        if size == 0 {
+            return Ok(None);
+        }
         if size > self.buf.len() {
             self.buf.resize(size, 0);
         }
         object.read(&mut self.buf[..size], phdr_start)?;
         unsafe {
-            Ok(core::slice::from_raw_parts(
+            Ok(Some(core::slice::from_raw_parts(
                 self.buf.as_ptr().cast::<ElfPhdr>(),
                 (phdr_end - phdr_start) / size_of::<ElfPhdr>(),
-            ))
+            )))
         }
     }
 
     pub(crate) fn prepare_shdrs_mut(
         &mut self,
         ehdr: &ElfHeader,
         object: &mut impl ElfReader,
-    ) -> Result<&mut [ElfShdr]> {
+    ) -> Result<Option<&mut [ElfShdr]>> {
         let (shdr_start, shdr_end) = ehdr.shdr_range();
         let size = shdr_end - shdr_start;
+        if size == 0 {
+            return Ok(None);
+        }
         if size > self.buf.len() {
             self.buf.resize(size, 0);
         }
         object.read(&mut self.buf[..size], shdr_start)?;
         unsafe {
-            Ok(core::slice::from_raw_parts_mut(
+            Ok(Some(core::slice::from_raw_parts_mut(
                 self.buf.as_mut_ptr().cast::<ElfShdr>(),
                 (shdr_end - shdr_start) / size_of::<ElfShdr>(),
-            ))
+            )))
         }
     }
 }
@@ -413,7 +419,7 @@ where
         &mut self,
         object: &mut impl ElfReader,
         ehdr: &ElfHeader,
-    ) -> Result<&[ElfPhdr]> {
+    ) -> Result<Option<&[ElfPhdr]>> {
         self.buf.prepare_phdrs(ehdr, object)
     }
 }

src/relocation/mod.rs

@@ -27,4 +27,4 @@ pub(crate) use utils::{
 };
 
 pub use crate::tls::TlsResolver;
-pub use traits::{RelocationContext, RelocationHandler, SymbolLookup};
+pub use traits::{RelocationContext, RelocationHandler, SupportLazy, SymbolLookup};

src/relocation/static.rs

@@ -9,7 +9,6 @@ use crate::{
 };
 use alloc::{boxed::Box, vec::Vec};
 
-
 pub(crate) struct StaticRelocation {
     relocation: Box<[&'static [ElfRelType]]>,
 }
@@ -70,7 +69,8 @@ impl<D: 'static> RawObject<D> {
 
         #[cfg(feature = "log")]
         log::trace!("[{}] Executing init functions", self.core.name());
-        self.init.call(&LifecycleContext::new(None, self.init_array));
+        self.init
+            .call(&LifecycleContext::new(None, self.init_array));
 
         #[cfg(feature = "log")]
         log::info!("Relocation completed for {}", self.core.name());

src/relocation/traits.rs

@@ -201,6 +201,9 @@ impl<H: RelocationHandler + ?Sized> RelocationHandler for Arc<H> {
     }
 }
 
+/// A marker trait for objects that support lazy binding.
+pub trait SupportLazy {}
+
 /// A trait for objects that can be relocated.
 ///
 /// Types implementing this trait can undergo symbol resolution and address fixup.

src/relocation/utils.rs

@@ -3,7 +3,7 @@ use crate::{
     elf::{ElfRelType, ElfSymbol, SymbolInfo, SymbolTable},
     image::{ElfCore, LoadedCore},
     relocate_error,
-    relocation::{Relocatable, RelocationContext, RelocationHandler, SymbolLookup},
+    relocation::{Relocatable, RelocationContext, RelocationHandler, SupportLazy, SymbolLookup},
     sync::Arc,
     tls::TlsDescDynamicArg,
 };
@@ -330,6 +330,39 @@ where
         }
     }
 
+    /// Executes the relocation process.
+    ///
+    /// This method consumes the relocator and returns the relocated ELF object.
+    /// All configured symbol lookups, handlers, and options are applied.
+    ///
+    /// # Returns
+    /// * `Ok(T::Output)` - The successfully relocated ELF object.
+    /// * `Err(Error)` - If relocation fails for any reason.
+    pub fn relocate(self) -> Result<T::Output>
+    where
+        D: 'static,
+    {
+        self.object.relocate(
+            self.scope,
+            &self.pre_find,
+            &self.post_find,
+            &self.pre_handler,
+            &self.post_handler,
+            self.lazy,
+            self.lazy_scope,
+        )
+    }
+}
+
+impl<T, PreS, PostS, LazyS, PreH, PostH, D> Relocator<T, PreS, PostS, LazyS, PreH, PostH, D>
+where
+    T: Relocatable<D> + SupportLazy,
+    PreS: SymbolLookup,
+    PostS: SymbolLookup,
+    LazyS: SymbolLookup + Send + Sync + 'static,
+    PreH: RelocationHandler,
+    PostH: RelocationHandler,
+{
     /// Enables or disables lazy binding.
     ///
     /// When enabled, some relocations (typically PLT entries) will be resolved
@@ -359,29 +392,6 @@ where
             lazy_scope: Some(scope),
         }
     }
-
-    /// Executes the relocation process.
-    ///
-    /// This method consumes the relocator and returns the relocated ELF object.
-    /// All configured symbol lookups, handlers, and options are applied.
-    ///
-    /// # Returns
-    /// * `Ok(T::Output)` - The successfully relocated ELF object.
-    /// * `Err(Error)` - If relocation fails for any reason.
-    pub fn relocate(self) -> Result<T::Output>
-    where
-        D: 'static,
-    {
-        self.object.relocate(
-            self.scope,
-            &self.pre_find,
-            &self.post_find,
-            &self.pre_handler,
-            &self.post_handler,
-            self.lazy,
-            self.lazy_scope,
-        )
-    }
 }
 
 /// A wrapper type for relocation values, providing type safety and arithmetic operations.