zelf 0.1.0

A zero-allocation ELF parser.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::context::PropU32;
use crate::context::*;
use crate::utils::*;
use core::marker::PhantomData;

#[derive(Debug, Clone)]
pub enum ParseGroupError {
    BrokenHeader,
    BrokenEntry,
}

/// Group section.
#[derive(Debug, Clone, Copy)]
pub struct Group<'a, T: Context> {
    header: &'a GroupHeader<T>,
    entries: &'a [GroupEntry<T>],
}

impl<'a, T: Context> Group<'a, T> {
    pub fn parse(content: &'a [u8]) -> Result<Self, ParseGroupError> {
        use ParseGroupError::*;
        let mut offset = 0usize;
        let header = read(content, offset).ok_or(BrokenHeader)?;
        offset += core::mem::size_of::<GroupHeader<T>>();
        let entries = read_s::<GroupEntry<T>>(&content[offset..]).ok_or(BrokenEntry)?;
        Ok(Self { header, entries })
    }
    pub fn header(&self) -> &'a GroupHeader<T> {
        self.header
    }
    pub fn entries(&self) -> &'a [GroupEntry<T>] {
        self.entries
    }
}

#[repr(C)]
#[derive(Debug, Clone)]
pub struct GroupHeader<T: Context> {
    pub flags: PropU32,
    pub _maker: PhantomData<T>,
}

impl<T: Context> GroupHeader<T> {
    pub fn flags(&self) -> u32 {
        T::interpret(self.flags)
    }
}

unsafe impl<T: Context> Pod for GroupHeader<T> {}

#[repr(C)]
#[derive(Debug, Clone)]
pub struct GroupEntry<T: Context> {
    pub index: PropU32,
    pub _maker: PhantomData<T>,
}

impl<T: Context> GroupEntry<T> {
    pub fn index(&self) -> u32 {
        T::interpret(self.index)
    }
}

unsafe impl<T: Context> Pod for GroupEntry<T> {}

#[derive(Debug, Clone, Copy, From, Into, BitAnd, BitOr, BitXor, LowerHex)]
pub struct GroupFlags(pub u32);

impl GroupFlags {
    pub const COMDAT: Self = Self(0x1);
    pub const MASKOS: Self = Self(0x0ff00000);
    pub const MASKPROCESSOR: Self = Self(0xf0000000);
}