elf_loader 0.15.0

A no_std-friendly ELF loader, runtime linker, and JIT linker for Rust.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#[cfg(feature = "tls")]
mod enabled {
    use super::super::defs::{TlsDescDynamicArg, TlsModuleId, TlsTpOffset};
    use crate::relocation::RelocAddr;
    use alloc::{boxed::Box, vec::Vec};

    #[derive(Default)]
    pub(crate) struct TlsDescArgs(Vec<Box<TlsDescDynamicArg>>);

    impl TlsDescArgs {
        pub(crate) fn push(&mut self, arg: Box<TlsDescDynamicArg>) {
            self.0.push(arg);
        }
    }

    /// TLS runtime state attached to a loaded ELF core.
    ///
    /// This keeps TLS-specific bookkeeping out of `CoreInner`, so TLS state can
    /// collapse to an empty implementation when the `tls` feature is disabled.
    pub(crate) struct CoreTlsState {
        mod_id: Option<TlsModuleId>,
        tp_offset: Option<TlsTpOffset>,
        tls_get_addr: RelocAddr,
        unregister: fn(TlsModuleId),
        desc_args: Box<[Box<TlsDescDynamicArg>]>,
    }

    impl CoreTlsState {
        pub(crate) fn new(
            mod_id: Option<TlsModuleId>,
            tp_offset: Option<TlsTpOffset>,
            tls_get_addr: RelocAddr,
            unregister: fn(TlsModuleId),
        ) -> Self {
            Self {
                mod_id,
                tp_offset,
                tls_get_addr,
                unregister,
                desc_args: Box::new([]),
            }
        }

        #[inline]
        pub(crate) fn mod_id(&self) -> Option<TlsModuleId> {
            self.mod_id
        }

        #[inline]
        pub(crate) fn tp_offset(&self) -> Option<TlsTpOffset> {
            self.tp_offset
        }

        #[inline]
        pub(crate) fn tls_get_addr(&self) -> RelocAddr {
            self.tls_get_addr
        }

        #[inline]
        pub(crate) fn cleanup(&self) {
            if let Some(mod_id) = self.mod_id {
                (self.unregister)(mod_id);
            }
        }

        pub(crate) fn set_desc_args(&mut self, args: TlsDescArgs) {
            self.desc_args = args.0.into_boxed_slice();
        }
    }
}

#[cfg(not(feature = "tls"))]
mod disabled {
    use super::super::defs::{TlsModuleId, TlsTpOffset};
    use crate::relocation::RelocAddr;

    #[derive(Default)]
    pub(crate) struct TlsDescArgs;

    /// TLS runtime state attached to a loaded ELF core.
    ///
    /// This keeps TLS-specific bookkeeping out of `CoreInner`, so TLS state can
    /// collapse to an empty implementation when the `tls` feature is disabled.
    pub(crate) struct CoreTlsState;

    impl CoreTlsState {
        pub(crate) fn new(
            _mod_id: Option<TlsModuleId>,
            _tp_offset: Option<TlsTpOffset>,
            _tls_get_addr: RelocAddr,
            _unregister: fn(TlsModuleId),
        ) -> Self {
            Self
        }

        #[inline]
        pub(crate) fn mod_id(&self) -> Option<TlsModuleId> {
            None
        }

        #[inline]
        pub(crate) fn tp_offset(&self) -> Option<TlsTpOffset> {
            None
        }

        #[inline]
        pub(crate) fn tls_get_addr(&self) -> RelocAddr {
            RelocAddr::null()
        }

        #[inline]
        pub(crate) fn cleanup(&self) {}

        pub(crate) fn set_desc_args(&mut self, _args: TlsDescArgs) {}
    }
}

#[cfg(feature = "tls")]
pub(crate) use enabled::{CoreTlsState, TlsDescArgs};

#[cfg(not(feature = "tls"))]
pub(crate) use disabled::{CoreTlsState, TlsDescArgs};