object/read/xcoff/
section.rs

Help
1use core::fmt::Debug;
2use core::{iter, result, slice, str};
3
4use crate::endian::BigEndian as BE;
5use crate::pod::Pod;
6use crate::read::{
7    self, CompressedData, CompressedFileRange, Error, ObjectSection, ReadError, ReadRef,
8    RelocationMap, Result, SectionFlags, SectionIndex, SectionKind,
9};
10use crate::xcoff;
11
12use super::{AuxHeader, FileHeader, Rel, XcoffFile, XcoffRelocationIterator};
13
14/// An iterator for the sections in an [`XcoffFile32`](super::XcoffFile32).
15pub type XcoffSectionIterator32<'data, 'file, R = &'data [u8]> =
16    XcoffSectionIterator<'data, 'file, xcoff::FileHeader32, R>;
17/// An iterator for the sections in an [`XcoffFile64`](super::XcoffFile64).
18pub type XcoffSectionIterator64<'data, 'file, R = &'data [u8]> =
19    XcoffSectionIterator<'data, 'file, xcoff::FileHeader64, R>;
20
21/// An iterator for the sections in an [`XcoffFile`].
22#[derive(Debug)]
23pub struct XcoffSectionIterator<'data, 'file, Xcoff, R = &'data [u8]>
24where
25    Xcoff: FileHeader,
26    R: ReadRef<'data>,
27{
28    pub(super) file: &'file XcoffFile<'data, Xcoff, R>,
29    pub(super) iter: iter::Enumerate<slice::Iter<'data, Xcoff::SectionHeader>>,
30}
31
32impl<'data, 'file, Xcoff, R> Iterator for XcoffSectionIterator<'data, 'file, Xcoff, R>
33where
34    Xcoff: FileHeader,
35    R: ReadRef<'data>,
36{
37    type Item = XcoffSection<'data, 'file, Xcoff, R>;
38
39    fn next(&mut self) -> Option<Self::Item> {
40        self.iter.next().map(|(index, section)| XcoffSection {
41            index: SectionIndex(index + 1),
42            file: self.file,
43            section,
44        })
45    }
46}
47
48/// A section in an [`XcoffFile32`](super::XcoffFile32).
49pub type XcoffSection32<'data, 'file, R = &'data [u8]> =
50    XcoffSection<'data, 'file, xcoff::FileHeader32, R>;
51/// A section in an [`XcoffFile64`](super::XcoffFile64).
52pub type XcoffSection64<'data, 'file, R = &'data [u8]> =
53    XcoffSection<'data, 'file, xcoff::FileHeader64, R>;
54
55/// A section in an [`XcoffFile`].
56///
57/// Most functionality is provided by the [`ObjectSection`] trait implementation.
58#[derive(Debug)]
59pub struct XcoffSection<'data, 'file, Xcoff, R = &'data [u8]>
60where
61    Xcoff: FileHeader,
62    R: ReadRef<'data>,
63{
64    pub(super) file: &'file XcoffFile<'data, Xcoff, R>,
65    pub(super) section: &'data Xcoff::SectionHeader,
66    pub(super) index: SectionIndex,
67}
68
69impl<'data, 'file, Xcoff: FileHeader, R: ReadRef<'data>> XcoffSection<'data, 'file, Xcoff, R> {
70    /// Get the XCOFF file containing this section.
71    pub fn xcoff_file(&self) -> &'file XcoffFile<'data, Xcoff, R> {
72        self.file
73    }
74
75    /// Get the raw XCOFF section header.
76    pub fn xcoff_section(&self) -> &'data Xcoff::SectionHeader {
77        self.section
78    }
79
80    /// Get the raw XCOFF relocation entries for this section.
81    pub fn xcoff_relocations(&self) -> Result<&'data [Xcoff::Rel]> {
82        self.section.relocations(self.file.data)
83    }
84
85    fn bytes(&self) -> Result<&'data [u8]> {
86        self.section
87            .data(self.file.data)
88            .read_error("Invalid XCOFF section offset or size")
89    }
90}
91
92impl<'data, 'file, Xcoff, R> read::private::Sealed for XcoffSection<'data, 'file, Xcoff, R>
93where
94    Xcoff: FileHeader,
95    R: ReadRef<'data>,
96{
97}
98
99impl<'data, 'file, Xcoff, R> ObjectSection<'data> for XcoffSection<'data, 'file, Xcoff, R>
100where
101    Xcoff: FileHeader,
102    R: ReadRef<'data>,
103{
104    type RelocationIterator = XcoffRelocationIterator<'data, 'file, Xcoff, R>;
105
106    fn index(&self) -> SectionIndex {
107        self.index
108    }
109
110    fn address(&self) -> u64 {
111        self.section.s_paddr().into()
112    }
113
114    fn size(&self) -> u64 {
115        self.section.s_size().into()
116    }
117
118    fn align(&self) -> u64 {
119        // The default section alignment is 4.
120        if let Some(aux_header) = self.file.aux_header {
121            match self.kind() {
122                SectionKind::Text => aux_header.o_algntext().into(),
123                SectionKind::Data => aux_header.o_algndata().into(),
124                _ => 4,
125            }
126        } else {
127            4
128        }
129    }
130
131    fn file_range(&self) -> Option<(u64, u64)> {
132        self.section.file_range()
133    }
134
135    fn data(&self) -> Result<&'data [u8]> {
136        self.bytes()
137    }
138
139    fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
140        Ok(read::util::data_range(
141            self.bytes()?,
142            self.address(),
143            address,
144            size,
145        ))
146    }
147
148    fn compressed_file_range(&self) -> Result<CompressedFileRange> {
149        Ok(CompressedFileRange::none(self.file_range()))
150    }
151
152    fn compressed_data(&self) -> Result<CompressedData<'data>> {
153        self.data().map(CompressedData::none)
154    }
155
156    fn name_bytes(&self) -> read::Result<&'data [u8]> {
157        Ok(self.section.name())
158    }
159
160    fn name(&self) -> read::Result<&'data str> {
161        let name = self.name_bytes()?;
162        str::from_utf8(name)
163            .ok()
164            .read_error("Non UTF-8 XCOFF section name")
165    }
166
167    fn segment_name_bytes(&self) -> Result<Option<&[u8]>> {
168        Ok(None)
169    }
170
171    fn segment_name(&self) -> Result<Option<&str>> {
172        Ok(None)
173    }
174
175    fn kind(&self) -> SectionKind {
176        let section_type = self.section.s_flags() as u16;
177        if section_type & xcoff::STYP_TEXT != 0 {
178            SectionKind::Text
179        } else if section_type & xcoff::STYP_DATA != 0 {
180            SectionKind::Data
181        } else if section_type & xcoff::STYP_TDATA != 0 {
182            SectionKind::Tls
183        } else if section_type & xcoff::STYP_BSS != 0 {
184            SectionKind::UninitializedData
185        } else if section_type & xcoff::STYP_TBSS != 0 {
186            SectionKind::UninitializedTls
187        } else if section_type & (xcoff::STYP_DEBUG | xcoff::STYP_DWARF) != 0 {
188            SectionKind::Debug
189        } else if section_type & (xcoff::STYP_LOADER | xcoff::STYP_OVRFLO) != 0 {
190            SectionKind::Metadata
191        } else if section_type
192            & (xcoff::STYP_INFO | xcoff::STYP_EXCEPT | xcoff::STYP_PAD | xcoff::STYP_TYPCHK)
193            != 0
194        {
195            SectionKind::Other
196        } else {
197            SectionKind::Unknown
198        }
199    }
200
201    fn relocations(&self) -> Self::RelocationIterator {
202        let rel = self.xcoff_relocations().unwrap_or(&[]);
203        XcoffRelocationIterator {
204            file: self.file,
205            relocations: rel.iter(),
206        }
207    }
208
209    fn relocation_map(&self) -> read::Result<RelocationMap> {
210        RelocationMap::new(self.file, self)
211    }
212
213    fn flags(&self) -> SectionFlags {
214        SectionFlags::Xcoff {
215            s_flags: self.section.s_flags(),
216        }
217    }
218
219    fn uncompressed_data(&self) -> Result<alloc::borrow::Cow<'data, [u8]>> {
220        self.compressed_data()?.decompress()
221    }
222}
223
224/// The table of section headers in an XCOFF file.
225///
226/// Returned by [`FileHeader::sections`].
227#[derive(Debug, Clone, Copy)]
228pub struct SectionTable<'data, Xcoff: FileHeader> {
229    sections: &'data [Xcoff::SectionHeader],
230}
231
232impl<'data, Xcoff> Default for SectionTable<'data, Xcoff>
233where
234    Xcoff: FileHeader,
235{
236    fn default() -> Self {
237        Self { sections: &[] }
238    }
239}
240
241impl<'data, Xcoff> SectionTable<'data, Xcoff>
242where
243    Xcoff: FileHeader,
244{
245    /// Parse the section table.
246    ///
247    /// `data` must be the entire file data.
248    /// `offset` must be after the optional file header.
249    pub fn parse<R: ReadRef<'data>>(header: &Xcoff, data: R, offset: &mut u64) -> Result<Self> {
250        let section_num = header.f_nscns();
251        if section_num == 0 {
252            return Ok(SectionTable::default());
253        }
254        let sections = data
255            .read_slice(offset, section_num as usize)
256            .read_error("Invalid XCOFF section headers")?;
257        Ok(SectionTable { sections })
258    }
259
260    /// Iterate over the section headers.
261    #[inline]
262    pub fn iter(&self) -> slice::Iter<'data, Xcoff::SectionHeader> {
263        self.sections.iter()
264    }
265
266    /// Return true if the section table is empty.
267    #[inline]
268    pub fn is_empty(&self) -> bool {
269        self.sections.is_empty()
270    }
271
272    /// The number of section headers.
273    #[inline]
274    pub fn len(&self) -> usize {
275        self.sections.len()
276    }
277
278    /// Return the section header at the given index.
279    ///
280    /// The index is 1-based.
281    pub fn section(&self, index: SectionIndex) -> read::Result<&'data Xcoff::SectionHeader> {
282        self.sections
283            .get(index.0.wrapping_sub(1))
284            .read_error("Invalid XCOFF section index")
285    }
286}
287
288/// A trait for generic access to [`xcoff::SectionHeader32`] and [`xcoff::SectionHeader64`].
289#[allow(missing_docs)]
290pub trait SectionHeader: Debug + Pod {
291    type Word: Into<u64>;
292    type HalfWord: Into<u32>;
293    type Xcoff: FileHeader<SectionHeader = Self, Word = Self::Word>;
294    type Rel: Rel<Word = Self::Word>;
295
296    fn s_name(&self) -> &[u8; 8];
297    fn s_paddr(&self) -> Self::Word;
298    fn s_vaddr(&self) -> Self::Word;
299    fn s_size(&self) -> Self::Word;
300    fn s_scnptr(&self) -> Self::Word;
301    fn s_relptr(&self) -> Self::Word;
302    fn s_lnnoptr(&self) -> Self::Word;
303    fn s_nreloc(&self) -> Self::HalfWord;
304    fn s_nlnno(&self) -> Self::HalfWord;
305    fn s_flags(&self) -> u32;
306
307    /// Return the section name.
308    fn name(&self) -> &[u8] {
309        let sectname = &self.s_name()[..];
310        match memchr::memchr(b'\0', sectname) {
311            Some(end) => &sectname[..end],
312            None => sectname,
313        }
314    }
315
316    /// Return the offset and size of the section in the file.
317    fn file_range(&self) -> Option<(u64, u64)> {
318        Some((self.s_scnptr().into(), self.s_size().into()))
319    }
320
321    /// Return the section data.
322    ///
323    /// Returns `Ok(&[])` if the section has no data.
324    /// Returns `Err` for invalid values.
325    fn data<'data, R: ReadRef<'data>>(&self, data: R) -> result::Result<&'data [u8], ()> {
326        if let Some((offset, size)) = self.file_range() {
327            data.read_bytes_at(offset, size)
328        } else {
329            Ok(&[])
330        }
331    }
332
333    /// Read the relocations.
334    fn relocations<'data, R: ReadRef<'data>>(&self, data: R) -> read::Result<&'data [Self::Rel]>;
335}
336
337impl SectionHeader for xcoff::SectionHeader32 {
338    type Word = u32;
339    type HalfWord = u16;
340    type Xcoff = xcoff::FileHeader32;
341    type Rel = xcoff::Rel32;
342
343    fn s_name(&self) -> &[u8; 8] {
344        &self.s_name
345    }
346
347    fn s_paddr(&self) -> Self::Word {
348        self.s_paddr.get(BE)
349    }
350
351    fn s_vaddr(&self) -> Self::Word {
352        self.s_vaddr.get(BE)
353    }
354
355    fn s_size(&self) -> Self::Word {
356        self.s_size.get(BE)
357    }
358
359    fn s_scnptr(&self) -> Self::Word {
360        self.s_scnptr.get(BE)
361    }
362
363    fn s_relptr(&self) -> Self::Word {
364        self.s_relptr.get(BE)
365    }
366
367    fn s_lnnoptr(&self) -> Self::Word {
368        self.s_lnnoptr.get(BE)
369    }
370
371    fn s_nreloc(&self) -> Self::HalfWord {
372        self.s_nreloc.get(BE)
373    }
374
375    fn s_nlnno(&self) -> Self::HalfWord {
376        self.s_nlnno.get(BE)
377    }
378
379    fn s_flags(&self) -> u32 {
380        self.s_flags.get(BE)
381    }
382
383    /// Read the relocations in a XCOFF32 file.
384    ///
385    /// `data` must be the entire file data.
386    fn relocations<'data, R: ReadRef<'data>>(&self, data: R) -> read::Result<&'data [Self::Rel]> {
387        let reloc_num = self.s_nreloc() as usize;
388        // TODO: If more than 65,534 relocation entries are required, the field value will be 65535,
389        // and an STYP_OVRFLO section header will contain the actual count of relocation entries in
390        // the s_paddr field.
391        if reloc_num == 65535 {
392            return Err(Error("Overflow section is not supported yet."));
393        }
394        data.read_slice_at(self.s_relptr().into(), reloc_num)
395            .read_error("Invalid XCOFF relocation offset or number")
396    }
397}
398
399impl SectionHeader for xcoff::SectionHeader64 {
400    type Word = u64;
401    type HalfWord = u32;
402    type Xcoff = xcoff::FileHeader64;
403    type Rel = xcoff::Rel64;
404
405    fn s_name(&self) -> &[u8; 8] {
406        &self.s_name
407    }
408
409    fn s_paddr(&self) -> Self::Word {
410        self.s_paddr.get(BE)
411    }
412
413    fn s_vaddr(&self) -> Self::Word {
414        self.s_vaddr.get(BE)
415    }
416
417    fn s_size(&self) -> Self::Word {
418        self.s_size.get(BE)
419    }
420
421    fn s_scnptr(&self) -> Self::Word {
422        self.s_scnptr.get(BE)
423    }
424
425    fn s_relptr(&self) -> Self::Word {
426        self.s_relptr.get(BE)
427    }
428
429    fn s_lnnoptr(&self) -> Self::Word {
430        self.s_lnnoptr.get(BE)
431    }
432
433    fn s_nreloc(&self) -> Self::HalfWord {
434        self.s_nreloc.get(BE)
435    }
436
437    fn s_nlnno(&self) -> Self::HalfWord {
438        self.s_nlnno.get(BE)
439    }
440
441    fn s_flags(&self) -> u32 {
442        self.s_flags.get(BE)
443    }
444
445    /// Read the relocations in a XCOFF64 file.
446    ///
447    /// `data` must be the entire file data.
448    fn relocations<'data, R: ReadRef<'data>>(&self, data: R) -> read::Result<&'data [Self::Rel]> {
449        data.read_slice_at(self.s_relptr(), self.s_nreloc() as usize)
450            .read_error("Invalid XCOFF relocation offset or number")
451    }
452}
object/read/xcoff/section.rs

object/read/xcoff/
section.rs
