object/read/xcoff/
file.rs

Help
1use core::fmt::Debug;
2use core::mem;
3
4use alloc::vec::Vec;
5
6use crate::endian::BigEndian as BE;
7use crate::pod::Pod;
8use crate::read::{
9    self, Architecture, Error, Export, FileFlags, Import, NoDynamicRelocationIterator, Object,
10    ObjectKind, ObjectSection, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
11};
12use crate::xcoff;
13
14use super::{
15    CsectAux, FileAux, Rel, SectionHeader, SectionTable, Symbol, SymbolTable, XcoffComdat,
16    XcoffComdatIterator, XcoffSection, XcoffSectionIterator, XcoffSegment, XcoffSegmentIterator,
17    XcoffSymbol, XcoffSymbolIterator, XcoffSymbolTable,
18};
19
20/// A 32-bit XCOFF object file.
21///
22/// This is a file that starts with [`xcoff::FileHeader32`], and corresponds
23/// to [`crate::FileKind::Xcoff32`].
24pub type XcoffFile32<'data, R = &'data [u8]> = XcoffFile<'data, xcoff::FileHeader32, R>;
25/// A 64-bit XCOFF object file.
26///
27/// This is a file that starts with [`xcoff::FileHeader64`], and corresponds
28/// to [`crate::FileKind::Xcoff64`].
29pub type XcoffFile64<'data, R = &'data [u8]> = XcoffFile<'data, xcoff::FileHeader64, R>;
30
31/// A partially parsed XCOFF file.
32///
33/// Most functionality is provided by the [`Object`] trait implementation.
34#[derive(Debug)]
35pub struct XcoffFile<'data, Xcoff, R = &'data [u8]>
36where
37    Xcoff: FileHeader,
38    R: ReadRef<'data>,
39{
40    pub(super) data: R,
41    pub(super) header: &'data Xcoff,
42    pub(super) aux_header: Option<&'data Xcoff::AuxHeader>,
43    pub(super) sections: SectionTable<'data, Xcoff>,
44    pub(super) symbols: SymbolTable<'data, Xcoff, R>,
45}
46
47impl<'data, Xcoff, R> XcoffFile<'data, Xcoff, R>
48where
49    Xcoff: FileHeader,
50    R: ReadRef<'data>,
51{
52    /// Parse the raw XCOFF file data.
53    pub fn parse(data: R) -> Result<Self> {
54        let mut offset = 0;
55        let header = Xcoff::parse(data, &mut offset)?;
56        let aux_header = header.aux_header(data, &mut offset)?;
57        let sections = header.sections(data, &mut offset)?;
58        let symbols = header.symbols(data)?;
59
60        Ok(XcoffFile {
61            data,
62            header,
63            aux_header,
64            sections,
65            symbols,
66        })
67    }
68
69    /// Returns the raw data.
70    pub fn data(&self) -> R {
71        self.data
72    }
73
74    /// Returns the raw XCOFF file header.
75    #[deprecated(note = "Use `xcoff_header` instead")]
76    pub fn raw_header(&self) -> &'data Xcoff {
77        self.header
78    }
79
80    /// Get the raw XCOFF file header.
81    pub fn xcoff_header(&self) -> &'data Xcoff {
82        self.header
83    }
84
85    /// Get the raw XCOFF auxiliary header.
86    pub fn xcoff_aux_header(&self) -> Option<&'data Xcoff::AuxHeader> {
87        self.aux_header
88    }
89
90    /// Get the XCOFF section table.
91    pub fn xcoff_section_table(&self) -> &SectionTable<'data, Xcoff> {
92        &self.sections
93    }
94
95    /// Get the XCOFF symbol table.
96    pub fn xcoff_symbol_table(&self) -> &SymbolTable<'data, Xcoff, R> {
97        &self.symbols
98    }
99}
100
101impl<'data, Xcoff, R> read::private::Sealed for XcoffFile<'data, Xcoff, R>
102where
103    Xcoff: FileHeader,
104    R: ReadRef<'data>,
105{
106}
107
108impl<'data, Xcoff, R> Object<'data> for XcoffFile<'data, Xcoff, R>
109where
110    Xcoff: FileHeader,
111    R: ReadRef<'data>,
112{
113    type Segment<'file>
114        = XcoffSegment<'data, 'file, Xcoff, R>
115    where
116        Self: 'file,
117        'data: 'file;
118    type SegmentIterator<'file>
119        = XcoffSegmentIterator<'data, 'file, Xcoff, R>
120    where
121        Self: 'file,
122        'data: 'file;
123    type Section<'file>
124        = XcoffSection<'data, 'file, Xcoff, R>
125    where
126        Self: 'file,
127        'data: 'file;
128    type SectionIterator<'file>
129        = XcoffSectionIterator<'data, 'file, Xcoff, R>
130    where
131        Self: 'file,
132        'data: 'file;
133    type Comdat<'file>
134        = XcoffComdat<'data, 'file, Xcoff, R>
135    where
136        Self: 'file,
137        'data: 'file;
138    type ComdatIterator<'file>
139        = XcoffComdatIterator<'data, 'file, Xcoff, R>
140    where
141        Self: 'file,
142        'data: 'file;
143    type Symbol<'file>
144        = XcoffSymbol<'data, 'file, Xcoff, R>
145    where
146        Self: 'file,
147        'data: 'file;
148    type SymbolIterator<'file>
149        = XcoffSymbolIterator<'data, 'file, Xcoff, R>
150    where
151        Self: 'file,
152        'data: 'file;
153    type SymbolTable<'file>
154        = XcoffSymbolTable<'data, 'file, Xcoff, R>
155    where
156        Self: 'file,
157        'data: 'file;
158    type DynamicRelocationIterator<'file>
159        = NoDynamicRelocationIterator
160    where
161        Self: 'file,
162        'data: 'file;
163
164    fn architecture(&self) -> Architecture {
165        if self.is_64() {
166            Architecture::PowerPc64
167        } else {
168            Architecture::PowerPc
169        }
170    }
171
172    fn is_little_endian(&self) -> bool {
173        false
174    }
175
176    fn is_64(&self) -> bool {
177        self.header.is_type_64()
178    }
179
180    fn kind(&self) -> ObjectKind {
181        let flags = self.header.f_flags();
182        if flags & xcoff::F_EXEC != 0 {
183            ObjectKind::Executable
184        } else if flags & xcoff::F_SHROBJ != 0 {
185            ObjectKind::Dynamic
186        } else if flags & xcoff::F_RELFLG == 0 {
187            ObjectKind::Relocatable
188        } else {
189            ObjectKind::Unknown
190        }
191    }
192
193    fn segments(&self) -> XcoffSegmentIterator<'data, '_, Xcoff, R> {
194        XcoffSegmentIterator { file: self }
195    }
196
197    fn section_by_name_bytes<'file>(
198        &'file self,
199        section_name: &[u8],
200    ) -> Option<XcoffSection<'data, 'file, Xcoff, R>> {
201        self.sections()
202            .find(|section| section.name_bytes() == Ok(section_name))
203    }
204
205    fn section_by_index(&self, index: SectionIndex) -> Result<XcoffSection<'data, '_, Xcoff, R>> {
206        let section = self.sections.section(index)?;
207        Ok(XcoffSection {
208            file: self,
209            section,
210            index,
211        })
212    }
213
214    fn sections(&self) -> XcoffSectionIterator<'data, '_, Xcoff, R> {
215        XcoffSectionIterator {
216            file: self,
217            iter: self.sections.iter().enumerate(),
218        }
219    }
220
221    fn comdats(&self) -> XcoffComdatIterator<'data, '_, Xcoff, R> {
222        XcoffComdatIterator { file: self }
223    }
224
225    fn symbol_table(&self) -> Option<XcoffSymbolTable<'data, '_, Xcoff, R>> {
226        if self.symbols.is_empty() {
227            return None;
228        }
229        Some(XcoffSymbolTable {
230            symbols: &self.symbols,
231            file: self,
232        })
233    }
234
235    fn symbol_by_index(&self, index: SymbolIndex) -> Result<XcoffSymbol<'data, '_, Xcoff, R>> {
236        let symbol = self.symbols.symbol(index)?;
237        Ok(XcoffSymbol {
238            symbols: &self.symbols,
239            index,
240            symbol,
241            file: self,
242        })
243    }
244
245    fn symbols(&self) -> XcoffSymbolIterator<'data, '_, Xcoff, R> {
246        XcoffSymbolIterator {
247            file: self,
248            symbols: self.symbols.iter(),
249        }
250    }
251
252    fn dynamic_symbol_table<'file>(
253        &'file self,
254    ) -> Option<XcoffSymbolTable<'data, 'file, Xcoff, R>> {
255        None
256    }
257
258    fn dynamic_symbols(&self) -> XcoffSymbolIterator<'data, '_, Xcoff, R> {
259        // TODO: return the symbols in the STYP_LOADER section.
260        XcoffSymbolIterator {
261            file: self,
262            symbols: self.symbols.iter_none(),
263        }
264    }
265
266    fn dynamic_relocations(&self) -> Option<Self::DynamicRelocationIterator<'_>> {
267        // TODO: return the relocations in the STYP_LOADER section.
268        None
269    }
270
271    fn imports(&self) -> Result<alloc::vec::Vec<Import<'data>>> {
272        // TODO: return the imports in the STYP_LOADER section.
273        Ok(Vec::new())
274    }
275
276    fn exports(&self) -> Result<alloc::vec::Vec<Export<'data>>> {
277        // TODO: return the exports in the STYP_LOADER section.
278        Ok(Vec::new())
279    }
280
281    fn has_debug_symbols(&self) -> bool {
282        self.section_by_name(".debug").is_some() || self.section_by_name(".dwinfo").is_some()
283    }
284
285    fn relative_address_base(&self) -> u64 {
286        0
287    }
288
289    fn entry(&self) -> u64 {
290        if let Some(aux_header) = self.aux_header {
291            aux_header.o_entry().into()
292        } else {
293            0
294        }
295    }
296
297    fn flags(&self) -> FileFlags {
298        FileFlags::Xcoff {
299            f_flags: self.header.f_flags(),
300        }
301    }
302}
303
304/// A trait for generic access to [`xcoff::FileHeader32`] and [`xcoff::FileHeader64`].
305#[allow(missing_docs)]
306pub trait FileHeader: Debug + Pod {
307    type Word: Into<u64>;
308    type AuxHeader: AuxHeader<Word = Self::Word>;
309    type SectionHeader: SectionHeader<Word = Self::Word, Rel = Self::Rel>;
310    type Symbol: Symbol<Word = Self::Word>;
311    type FileAux: FileAux;
312    type CsectAux: CsectAux;
313    type Rel: Rel<Word = Self::Word>;
314
315    /// Return true if this type is a 64-bit header.
316    fn is_type_64(&self) -> bool;
317
318    fn f_magic(&self) -> u16;
319    fn f_nscns(&self) -> u16;
320    fn f_timdat(&self) -> u32;
321    fn f_symptr(&self) -> Self::Word;
322    fn f_nsyms(&self) -> u32;
323    fn f_opthdr(&self) -> u16;
324    fn f_flags(&self) -> u16;
325
326    // Provided methods.
327
328    /// Read the file header.
329    ///
330    /// Also checks that the magic field in the file header is a supported format.
331    fn parse<'data, R: ReadRef<'data>>(data: R, offset: &mut u64) -> Result<&'data Self> {
332        let header = data
333            .read::<Self>(offset)
334            .read_error("Invalid XCOFF header size or alignment")?;
335        if !header.is_supported() {
336            return Err(Error("Unsupported XCOFF header"));
337        }
338        Ok(header)
339    }
340
341    fn is_supported(&self) -> bool {
342        (self.is_type_64() && self.f_magic() == xcoff::MAGIC_64)
343            || (!self.is_type_64() && self.f_magic() == xcoff::MAGIC_32)
344    }
345
346    /// Read the auxiliary file header.
347    fn aux_header<'data, R: ReadRef<'data>>(
348        &self,
349        data: R,
350        offset: &mut u64,
351    ) -> Result<Option<&'data Self::AuxHeader>> {
352        let aux_header_size = self.f_opthdr();
353        if self.f_flags() & xcoff::F_EXEC == 0 {
354            // No auxiliary header is required for an object file that is not an executable.
355            // TODO: Some AIX programs generate auxiliary headers for 32-bit object files
356            // that end after the data_start field.
357            *offset += u64::from(aux_header_size);
358            return Ok(None);
359        }
360        // Executables, however, must have auxiliary headers that include the
361        // full structure definitions.
362        if aux_header_size != mem::size_of::<Self::AuxHeader>() as u16 {
363            *offset += u64::from(aux_header_size);
364            return Ok(None);
365        }
366        let aux_header = data
367            .read::<Self::AuxHeader>(offset)
368            .read_error("Invalid XCOFF auxiliary header size")?;
369        Ok(Some(aux_header))
370    }
371
372    /// Read the section table.
373    #[inline]
374    fn sections<'data, R: ReadRef<'data>>(
375        &self,
376        data: R,
377        offset: &mut u64,
378    ) -> Result<SectionTable<'data, Self>> {
379        SectionTable::parse(self, data, offset)
380    }
381
382    /// Return the symbol table.
383    #[inline]
384    fn symbols<'data, R: ReadRef<'data>>(&self, data: R) -> Result<SymbolTable<'data, Self, R>> {
385        SymbolTable::parse(*self, data)
386    }
387}
388
389impl FileHeader for xcoff::FileHeader32 {
390    type Word = u32;
391    type AuxHeader = xcoff::AuxHeader32;
392    type SectionHeader = xcoff::SectionHeader32;
393    type Symbol = xcoff::Symbol32;
394    type FileAux = xcoff::FileAux32;
395    type CsectAux = xcoff::CsectAux32;
396    type Rel = xcoff::Rel32;
397
398    fn is_type_64(&self) -> bool {
399        false
400    }
401
402    fn f_magic(&self) -> u16 {
403        self.f_magic.get(BE)
404    }
405
406    fn f_nscns(&self) -> u16 {
407        self.f_nscns.get(BE)
408    }
409
410    fn f_timdat(&self) -> u32 {
411        self.f_timdat.get(BE)
412    }
413
414    fn f_symptr(&self) -> Self::Word {
415        self.f_symptr.get(BE)
416    }
417
418    fn f_nsyms(&self) -> u32 {
419        self.f_nsyms.get(BE)
420    }
421
422    fn f_opthdr(&self) -> u16 {
423        self.f_opthdr.get(BE)
424    }
425
426    fn f_flags(&self) -> u16 {
427        self.f_flags.get(BE)
428    }
429}
430
431impl FileHeader for xcoff::FileHeader64 {
432    type Word = u64;
433    type AuxHeader = xcoff::AuxHeader64;
434    type SectionHeader = xcoff::SectionHeader64;
435    type Symbol = xcoff::Symbol64;
436    type FileAux = xcoff::FileAux64;
437    type CsectAux = xcoff::CsectAux64;
438    type Rel = xcoff::Rel64;
439
440    fn is_type_64(&self) -> bool {
441        true
442    }
443
444    fn f_magic(&self) -> u16 {
445        self.f_magic.get(BE)
446    }
447
448    fn f_nscns(&self) -> u16 {
449        self.f_nscns.get(BE)
450    }
451
452    fn f_timdat(&self) -> u32 {
453        self.f_timdat.get(BE)
454    }
455
456    fn f_symptr(&self) -> Self::Word {
457        self.f_symptr.get(BE)
458    }
459
460    fn f_nsyms(&self) -> u32 {
461        self.f_nsyms.get(BE)
462    }
463
464    fn f_opthdr(&self) -> u16 {
465        self.f_opthdr.get(BE)
466    }
467
468    fn f_flags(&self) -> u16 {
469        self.f_flags.get(BE)
470    }
471}
472
473/// A trait for generic access to [`xcoff::AuxHeader32`] and [`xcoff::AuxHeader64`].
474#[allow(missing_docs)]
475pub trait AuxHeader: Debug + Pod {
476    type Word: Into<u64>;
477
478    fn o_mflag(&self) -> u16;
479    fn o_vstamp(&self) -> u16;
480    fn o_tsize(&self) -> Self::Word;
481    fn o_dsize(&self) -> Self::Word;
482    fn o_bsize(&self) -> Self::Word;
483    fn o_entry(&self) -> Self::Word;
484    fn o_text_start(&self) -> Self::Word;
485    fn o_data_start(&self) -> Self::Word;
486    fn o_toc(&self) -> Self::Word;
487    fn o_snentry(&self) -> u16;
488    fn o_sntext(&self) -> u16;
489    fn o_sndata(&self) -> u16;
490    fn o_sntoc(&self) -> u16;
491    fn o_snloader(&self) -> u16;
492    fn o_snbss(&self) -> u16;
493    fn o_algntext(&self) -> u16;
494    fn o_algndata(&self) -> u16;
495    fn o_modtype(&self) -> u16;
496    fn o_cpuflag(&self) -> u8;
497    fn o_cputype(&self) -> u8;
498    fn o_maxstack(&self) -> Self::Word;
499    fn o_maxdata(&self) -> Self::Word;
500    fn o_debugger(&self) -> u32;
501    fn o_textpsize(&self) -> u8;
502    fn o_datapsize(&self) -> u8;
503    fn o_stackpsize(&self) -> u8;
504    fn o_flags(&self) -> u8;
505    fn o_sntdata(&self) -> u16;
506    fn o_sntbss(&self) -> u16;
507    fn o_x64flags(&self) -> Option<u16>;
508}
509
510impl AuxHeader for xcoff::AuxHeader32 {
511    type Word = u32;
512
513    fn o_mflag(&self) -> u16 {
514        self.o_mflag.get(BE)
515    }
516
517    fn o_vstamp(&self) -> u16 {
518        self.o_vstamp.get(BE)
519    }
520
521    fn o_tsize(&self) -> Self::Word {
522        self.o_tsize.get(BE)
523    }
524
525    fn o_dsize(&self) -> Self::Word {
526        self.o_dsize.get(BE)
527    }
528
529    fn o_bsize(&self) -> Self::Word {
530        self.o_bsize.get(BE)
531    }
532
533    fn o_entry(&self) -> Self::Word {
534        self.o_entry.get(BE)
535    }
536
537    fn o_text_start(&self) -> Self::Word {
538        self.o_text_start.get(BE)
539    }
540
541    fn o_data_start(&self) -> Self::Word {
542        self.o_data_start.get(BE)
543    }
544
545    fn o_toc(&self) -> Self::Word {
546        self.o_toc.get(BE)
547    }
548
549    fn o_snentry(&self) -> u16 {
550        self.o_snentry.get(BE)
551    }
552
553    fn o_sntext(&self) -> u16 {
554        self.o_sntext.get(BE)
555    }
556
557    fn o_sndata(&self) -> u16 {
558        self.o_sndata.get(BE)
559    }
560
561    fn o_sntoc(&self) -> u16 {
562        self.o_sntoc.get(BE)
563    }
564
565    fn o_snloader(&self) -> u16 {
566        self.o_snloader.get(BE)
567    }
568
569    fn o_snbss(&self) -> u16 {
570        self.o_snbss.get(BE)
571    }
572
573    fn o_algntext(&self) -> u16 {
574        self.o_algntext.get(BE)
575    }
576
577    fn o_algndata(&self) -> u16 {
578        self.o_algndata.get(BE)
579    }
580
581    fn o_modtype(&self) -> u16 {
582        self.o_modtype.get(BE)
583    }
584
585    fn o_cpuflag(&self) -> u8 {
586        self.o_cpuflag
587    }
588
589    fn o_cputype(&self) -> u8 {
590        self.o_cputype
591    }
592
593    fn o_maxstack(&self) -> Self::Word {
594        self.o_maxstack.get(BE)
595    }
596
597    fn o_maxdata(&self) -> Self::Word {
598        self.o_maxdata.get(BE)
599    }
600
601    fn o_debugger(&self) -> u32 {
602        self.o_debugger.get(BE)
603    }
604
605    fn o_textpsize(&self) -> u8 {
606        self.o_textpsize
607    }
608
609    fn o_datapsize(&self) -> u8 {
610        self.o_datapsize
611    }
612
613    fn o_stackpsize(&self) -> u8 {
614        self.o_stackpsize
615    }
616
617    fn o_flags(&self) -> u8 {
618        self.o_flags
619    }
620
621    fn o_sntdata(&self) -> u16 {
622        self.o_sntdata.get(BE)
623    }
624
625    fn o_sntbss(&self) -> u16 {
626        self.o_sntbss.get(BE)
627    }
628
629    fn o_x64flags(&self) -> Option<u16> {
630        None
631    }
632}
633
634impl AuxHeader for xcoff::AuxHeader64 {
635    type Word = u64;
636
637    fn o_mflag(&self) -> u16 {
638        self.o_mflag.get(BE)
639    }
640
641    fn o_vstamp(&self) -> u16 {
642        self.o_vstamp.get(BE)
643    }
644
645    fn o_tsize(&self) -> Self::Word {
646        self.o_tsize.get(BE)
647    }
648
649    fn o_dsize(&self) -> Self::Word {
650        self.o_dsize.get(BE)
651    }
652
653    fn o_bsize(&self) -> Self::Word {
654        self.o_bsize.get(BE)
655    }
656
657    fn o_entry(&self) -> Self::Word {
658        self.o_entry.get(BE)
659    }
660
661    fn o_text_start(&self) -> Self::Word {
662        self.o_text_start.get(BE)
663    }
664
665    fn o_data_start(&self) -> Self::Word {
666        self.o_data_start.get(BE)
667    }
668
669    fn o_toc(&self) -> Self::Word {
670        self.o_toc.get(BE)
671    }
672
673    fn o_snentry(&self) -> u16 {
674        self.o_snentry.get(BE)
675    }
676
677    fn o_sntext(&self) -> u16 {
678        self.o_sntext.get(BE)
679    }
680
681    fn o_sndata(&self) -> u16 {
682        self.o_sndata.get(BE)
683    }
684
685    fn o_sntoc(&self) -> u16 {
686        self.o_sntoc.get(BE)
687    }
688
689    fn o_snloader(&self) -> u16 {
690        self.o_snloader.get(BE)
691    }
692
693    fn o_snbss(&self) -> u16 {
694        self.o_snbss.get(BE)
695    }
696
697    fn o_algntext(&self) -> u16 {
698        self.o_algntext.get(BE)
699    }
700
701    fn o_algndata(&self) -> u16 {
702        self.o_algndata.get(BE)
703    }
704
705    fn o_modtype(&self) -> u16 {
706        self.o_modtype.get(BE)
707    }
708
709    fn o_cpuflag(&self) -> u8 {
710        self.o_cpuflag
711    }
712
713    fn o_cputype(&self) -> u8 {
714        self.o_cputype
715    }
716
717    fn o_maxstack(&self) -> Self::Word {
718        self.o_maxstack.get(BE)
719    }
720
721    fn o_maxdata(&self) -> Self::Word {
722        self.o_maxdata.get(BE)
723    }
724
725    fn o_debugger(&self) -> u32 {
726        self.o_debugger.get(BE)
727    }
728
729    fn o_textpsize(&self) -> u8 {
730        self.o_textpsize
731    }
732
733    fn o_datapsize(&self) -> u8 {
734        self.o_datapsize
735    }
736
737    fn o_stackpsize(&self) -> u8 {
738        self.o_stackpsize
739    }
740
741    fn o_flags(&self) -> u8 {
742        self.o_flags
743    }
744
745    fn o_sntdata(&self) -> u16 {
746        self.o_sntdata.get(BE)
747    }
748
749    fn o_sntbss(&self) -> u16 {
750        self.o_sntbss.get(BE)
751    }
752
753    fn o_x64flags(&self) -> Option<u16> {
754        Some(self.o_x64flags.get(BE))
755    }
756}
object/read/xcoff/file.rs

object/read/xcoff/
file.rs
