object 0.39.1

A unified interface for reading and writing object file formats.
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

use crate::read::{Bytes, ReadError, Result};

/// Iterator over the function starts in a `LC_FUNCTION_STARTS` load command.
#[derive(Debug, Default, Clone, Copy)]
pub struct FunctionStartsIterator<'data> {
    data: Bytes<'data>,
    addr: u64,
}

impl<'data> FunctionStartsIterator<'data> {
    pub(super) fn new(data: &'data [u8], addr: u64) -> Self {
        FunctionStartsIterator {
            data: Bytes(data),
            addr,
        }
    }
}

impl<'data> FunctionStartsIterator<'data> {
    /// Returns the next function start address.
    pub fn next(&mut self) -> Result<Option<u64>> {
        if self.data.is_empty() {
            return Ok(None);
        }

        let result = self.parse();
        if result.is_err() {
            self.data = Bytes(&[]);
        }
        result
    }

    fn parse(&mut self) -> Result<Option<u64>> {
        let delta = self
            .data
            .read_uleb128()
            .read_error("Invalid ULEB128 in LC_FUNCTION_STARTS")?;
        if delta == 0 {
            self.data = Bytes(&[]);
            return Ok(None);
        }

        self.addr = self
            .addr
            .checked_add(delta)
            .read_error("Address overflow in LC_FUNCTION_STARTS")?;
        Ok(Some(self.addr))
    }
}

impl<'data> Iterator for FunctionStartsIterator<'data> {
    type Item = Result<u64>;

    fn next(&mut self) -> Option<Self::Item> {
        self.next().transpose()
    }
}