Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 629 insertions, 0 deletions

diff --git a/third_party/rust/object/src/read/xcoff/file.rs b/third_party/rust/object/src/read/xcoff/file.rs
new file mode 100644
index 0000000000..bac9e70756
--- /dev/null
+++ b/third_party/rust/object/src/read/xcoff/file.rs
@@ -0,0 +1,629 @@
+use core::fmt::Debug;
+use core::mem;
+
+use alloc::vec::Vec;
+
+use crate::read::{self, Error, NoDynamicRelocationIterator, Object, ReadError, ReadRef, Result};
+
+use crate::{
+    xcoff, Architecture, BigEndian as BE, FileFlags, ObjectKind, ObjectSection, Pod, SectionIndex,
+    SymbolIndex,
+};
+
+use super::{
+    CsectAux, FileAux, SectionHeader, SectionTable, Symbol, SymbolTable, XcoffComdat,
+    XcoffComdatIterator, XcoffSection, XcoffSectionIterator, XcoffSegment, XcoffSegmentIterator,
+    XcoffSymbol, XcoffSymbolIterator, XcoffSymbolTable,
+};
+
+/// A 32-bit XCOFF object file.
+pub type XcoffFile32<'data, R = &'data [u8]> = XcoffFile<'data, xcoff::FileHeader32, R>;
+/// A 64-bit XCOFF object file.
+pub type XcoffFile64<'data, R = &'data [u8]> = XcoffFile<'data, xcoff::FileHeader64, R>;
+
+/// A partially parsed XCOFF file.
+///
+/// Most of the functionality of this type is provided by the `Object` trait implementation.
+#[derive(Debug)]
+pub struct XcoffFile<'data, Xcoff, R = &'data [u8]>
+where
+    Xcoff: FileHeader,
+    R: ReadRef<'data>,
+{
+    pub(super) data: R,
+    pub(super) header: &'data Xcoff,
+    pub(super) aux_header: Option<&'data Xcoff::AuxHeader>,
+    pub(super) sections: SectionTable<'data, Xcoff>,
+    pub(super) symbols: SymbolTable<'data, Xcoff, R>,
+}
+
+impl<'data, Xcoff, R> XcoffFile<'data, Xcoff, R>
+where
+    Xcoff: FileHeader,
+    R: ReadRef<'data>,
+{
+    /// Parse the raw XCOFF file data.
+    pub fn parse(data: R) -> Result<Self> {
+        let mut offset = 0;
+        let header = Xcoff::parse(data, &mut offset)?;
+        let aux_header = header.aux_header(data, &mut offset)?;
+        let sections = header.sections(data, &mut offset)?;
+        let symbols = header.symbols(data)?;
+
+        Ok(XcoffFile {
+            data,
+            header,
+            aux_header,
+            sections,
+            symbols,
+        })
+    }
+
+    /// Returns the raw data.
+    pub fn data(&self) -> R {
+        self.data
+    }
+
+    /// Returns the raw XCOFF file header.
+    pub fn raw_header(&self) -> &'data Xcoff {
+        self.header
+    }
+}
+
+impl<'data, Xcoff, R> read::private::Sealed for XcoffFile<'data, Xcoff, R>
+where
+    Xcoff: FileHeader,
+    R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Xcoff, R> Object<'data, 'file> for XcoffFile<'data, Xcoff, R>
+where
+    'data: 'file,
+    Xcoff: FileHeader,
+    R: 'file + ReadRef<'data>,
+{
+    type Segment = XcoffSegment<'data, 'file, Xcoff, R>;
+    type SegmentIterator = XcoffSegmentIterator<'data, 'file, Xcoff, R>;
+    type Section = XcoffSection<'data, 'file, Xcoff, R>;
+    type SectionIterator = XcoffSectionIterator<'data, 'file, Xcoff, R>;
+    type Comdat = XcoffComdat<'data, 'file, Xcoff, R>;
+    type ComdatIterator = XcoffComdatIterator<'data, 'file, Xcoff, R>;
+    type Symbol = XcoffSymbol<'data, 'file, Xcoff, R>;
+    type SymbolIterator = XcoffSymbolIterator<'data, 'file, Xcoff, R>;
+    type SymbolTable = XcoffSymbolTable<'data, 'file, Xcoff, R>;
+    type DynamicRelocationIterator = NoDynamicRelocationIterator;
+
+    fn architecture(&self) -> crate::Architecture {
+        if self.is_64() {
+            Architecture::PowerPc64
+        } else {
+            Architecture::PowerPc
+        }
+    }
+
+    fn is_little_endian(&self) -> bool {
+        false
+    }
+
+    fn is_64(&self) -> bool {
+        self.header.is_type_64()
+    }
+
+    fn kind(&self) -> ObjectKind {
+        let flags = self.header.f_flags();
+        if flags & xcoff::F_EXEC != 0 {
+            ObjectKind::Executable
+        } else if flags & xcoff::F_SHROBJ != 0 {
+            ObjectKind::Dynamic
+        } else if flags & xcoff::F_RELFLG == 0 {
+            ObjectKind::Relocatable
+        } else {
+            ObjectKind::Unknown
+        }
+    }
+
+    fn segments(&'file self) -> XcoffSegmentIterator<'data, 'file, Xcoff, R> {
+        XcoffSegmentIterator { file: self }
+    }
+
+    fn section_by_name_bytes(
+        &'file self,
+        section_name: &[u8],
+    ) -> Option<XcoffSection<'data, 'file, Xcoff, R>> {
+        self.sections()
+            .find(|section| section.name_bytes() == Ok(section_name))
+    }
+
+    fn section_by_index(
+        &'file self,
+        index: SectionIndex,
+    ) -> Result<XcoffSection<'data, 'file, Xcoff, R>> {
+        let section = self.sections.section(index)?;
+        Ok(XcoffSection {
+            file: self,
+            section,
+            index,
+        })
+    }
+
+    fn sections(&'file self) -> XcoffSectionIterator<'data, 'file, Xcoff, R> {
+        XcoffSectionIterator {
+            file: self,
+            iter: self.sections.iter().enumerate(),
+        }
+    }
+
+    fn comdats(&'file self) -> XcoffComdatIterator<'data, 'file, Xcoff, R> {
+        XcoffComdatIterator { file: self }
+    }
+
+    fn symbol_table(&'file self) -> Option<XcoffSymbolTable<'data, 'file, Xcoff, R>> {
+        if self.symbols.is_empty() {
+            return None;
+        }
+        Some(XcoffSymbolTable {
+            symbols: &self.symbols,
+            file: self,
+        })
+    }
+
+    fn symbol_by_index(
+        &'file self,
+        index: SymbolIndex,
+    ) -> Result<XcoffSymbol<'data, 'file, Xcoff, R>> {
+        let symbol = self.symbols.symbol(index.0)?;
+        Ok(XcoffSymbol {
+            symbols: &self.symbols,
+            index,
+            symbol,
+            file: self,
+        })
+    }
+
+    fn symbols(&'file self) -> XcoffSymbolIterator<'data, 'file, Xcoff, R> {
+        XcoffSymbolIterator {
+            symbols: &self.symbols,
+            index: 0,
+            file: self,
+        }
+    }
+
+    fn dynamic_symbol_table(&'file self) -> Option<XcoffSymbolTable<'data, 'file, Xcoff, R>> {
+        None
+    }
+
+    fn dynamic_symbols(&'file self) -> XcoffSymbolIterator<'data, 'file, Xcoff, R> {
+        // TODO: return the symbols in the STYP_LOADER section.
+        XcoffSymbolIterator {
+            file: self,
+            symbols: &self.symbols,
+            // Hack: don't return any.
+            index: self.symbols.len(),
+        }
+    }
+
+    fn dynamic_relocations(&'file self) -> Option<Self::DynamicRelocationIterator> {
+        // TODO: return the relocations in the STYP_LOADER section.
+        None
+    }
+
+    fn imports(&self) -> Result<alloc::vec::Vec<crate::Import<'data>>> {
+        // TODO: return the imports in the STYP_LOADER section.
+        Ok(Vec::new())
+    }
+
+    fn exports(&self) -> Result<alloc::vec::Vec<crate::Export<'data>>> {
+        // TODO: return the exports in the STYP_LOADER section.
+        Ok(Vec::new())
+    }
+
+    fn has_debug_symbols(&self) -> bool {
+        self.section_by_name(".debug").is_some() || self.section_by_name(".dwinfo").is_some()
+    }
+
+    fn relative_address_base(&'file self) -> u64 {
+        0
+    }
+
+    fn entry(&'file self) -> u64 {
+        if let Some(aux_header) = self.aux_header {
+            aux_header.o_entry().into()
+        } else {
+            0
+        }
+    }
+
+    fn flags(&self) -> FileFlags {
+        FileFlags::Xcoff {
+            f_flags: self.header.f_flags(),
+        }
+    }
+}
+
+/// A trait for generic access to `FileHeader32` and `FileHeader64`.
+#[allow(missing_docs)]
+pub trait FileHeader: Debug + Pod {
+    type Word: Into<u64>;
+    type AuxHeader: AuxHeader<Word = Self::Word>;
+    type SectionHeader: SectionHeader<Word = Self::Word>;
+    type Symbol: Symbol<Word = Self::Word>;
+    type FileAux: FileAux;
+    type CsectAux: CsectAux;
+
+    /// Return true if this type is a 64-bit header.
+    fn is_type_64(&self) -> bool;
+
+    fn f_magic(&self) -> u16;
+    fn f_nscns(&self) -> u16;
+    fn f_timdat(&self) -> u32;
+    fn f_symptr(&self) -> Self::Word;
+    fn f_nsyms(&self) -> u32;
+    fn f_opthdr(&self) -> u16;
+    fn f_flags(&self) -> u16;
+
+    // Provided methods.
+
+    /// Read the file header.
+    ///
+    /// Also checks that the magic field in the file header is a supported format.
+    fn parse<'data, R: ReadRef<'data>>(data: R, offset: &mut u64) -> Result<&'data Self> {
+        let header = data
+            .read::<Self>(offset)
+            .read_error("Invalid XCOFF header size or alignment")?;
+        if !header.is_supported() {
+            return Err(Error("Unsupported XCOFF header"));
+        }
+        Ok(header)
+    }
+
+    fn is_supported(&self) -> bool {
+        (self.is_type_64() && self.f_magic() == xcoff::MAGIC_64)
+            || (!self.is_type_64() && self.f_magic() == xcoff::MAGIC_32)
+    }
+
+    /// Read the auxiliary file header.
+    fn aux_header<'data, R: ReadRef<'data>>(
+        &self,
+        data: R,
+        offset: &mut u64,
+    ) -> Result<Option<&'data Self::AuxHeader>> {
+        let aux_header_size = self.f_opthdr();
+        if self.f_flags() & xcoff::F_EXEC == 0 {
+            // No auxiliary header is required for an object file that is not an executable.
+            // TODO: Some AIX programs generate auxiliary headers for 32-bit object files
+            // that end after the data_start field.
+            *offset += u64::from(aux_header_size);
+            return Ok(None);
+        }
+        // Executables, however, must have auxiliary headers that include the
+        // full structure definitions.
+        if aux_header_size != mem::size_of::<Self::AuxHeader>() as u16 {
+            *offset += u64::from(aux_header_size);
+            return Ok(None);
+        }
+        let aux_header = data
+            .read::<Self::AuxHeader>(offset)
+            .read_error("Invalid XCOFF auxiliary header size")?;
+        Ok(Some(aux_header))
+    }
+
+    /// Read the section table.
+    #[inline]
+    fn sections<'data, R: ReadRef<'data>>(
+        &self,
+        data: R,
+        offset: &mut u64,
+    ) -> Result<SectionTable<'data, Self>> {
+        SectionTable::parse(self, data, offset)
+    }
+
+    /// Return the symbol table.
+    #[inline]
+    fn symbols<'data, R: ReadRef<'data>>(&self, data: R) -> Result<SymbolTable<'data, Self, R>> {
+        SymbolTable::parse(*self, data)
+    }
+}
+
+impl FileHeader for xcoff::FileHeader32 {
+    type Word = u32;
+    type AuxHeader = xcoff::AuxHeader32;
+    type SectionHeader = xcoff::SectionHeader32;
+    type Symbol = xcoff::Symbol32;
+    type FileAux = xcoff::FileAux32;
+    type CsectAux = xcoff::CsectAux32;
+
+    fn is_type_64(&self) -> bool {
+        false
+    }
+
+    fn f_magic(&self) -> u16 {
+        self.f_magic.get(BE)
+    }
+
+    fn f_nscns(&self) -> u16 {
+        self.f_nscns.get(BE)
+    }
+
+    fn f_timdat(&self) -> u32 {
+        self.f_timdat.get(BE)
+    }
+
+    fn f_symptr(&self) -> Self::Word {
+        self.f_symptr.get(BE)
+    }
+
+    fn f_nsyms(&self) -> u32 {
+        self.f_nsyms.get(BE)
+    }
+
+    fn f_opthdr(&self) -> u16 {
+        self.f_opthdr.get(BE)
+    }
+
+    fn f_flags(&self) -> u16 {
+        self.f_flags.get(BE)
+    }
+}
+
+impl FileHeader for xcoff::FileHeader64 {
+    type Word = u64;
+    type AuxHeader = xcoff::AuxHeader64;
+    type SectionHeader = xcoff::SectionHeader64;
+    type Symbol = xcoff::Symbol64;
+    type FileAux = xcoff::FileAux64;
+    type CsectAux = xcoff::CsectAux64;
+
+    fn is_type_64(&self) -> bool {
+        true
+    }
+
+    fn f_magic(&self) -> u16 {
+        self.f_magic.get(BE)
+    }
+
+    fn f_nscns(&self) -> u16 {
+        self.f_nscns.get(BE)
+    }
+
+    fn f_timdat(&self) -> u32 {
+        self.f_timdat.get(BE)
+    }
+
+    fn f_symptr(&self) -> Self::Word {
+        self.f_symptr.get(BE)
+    }
+
+    fn f_nsyms(&self) -> u32 {
+        self.f_nsyms.get(BE)
+    }
+
+    fn f_opthdr(&self) -> u16 {
+        self.f_opthdr.get(BE)
+    }
+
+    fn f_flags(&self) -> u16 {
+        self.f_flags.get(BE)
+    }
+}
+
+#[allow(missing_docs)]
+pub trait AuxHeader: Debug + Pod {
+    type Word: Into<u64>;
+
+    fn o_vstamp(&self) -> u16;
+    fn o_tsize(&self) -> Self::Word;
+    fn o_dsize(&self) -> Self::Word;
+    fn o_bsize(&self) -> Self::Word;
+    fn o_entry(&self) -> Self::Word;
+    fn o_text_start(&self) -> Self::Word;
+    fn o_data_start(&self) -> Self::Word;
+    fn o_toc(&self) -> Self::Word;
+    fn o_snentry(&self) -> u16;
+    fn o_sntext(&self) -> u16;
+    fn o_sndata(&self) -> u16;
+    fn o_sntoc(&self) -> u16;
+    fn o_snloader(&self) -> u16;
+    fn o_snbss(&self) -> u16;
+    fn o_sntdata(&self) -> u16;
+    fn o_sntbss(&self) -> u16;
+    fn o_algntext(&self) -> u16;
+    fn o_algndata(&self) -> u16;
+    fn o_maxstack(&self) -> Self::Word;
+    fn o_maxdata(&self) -> Self::Word;
+    fn o_textpsize(&self) -> u8;
+    fn o_datapsize(&self) -> u8;
+    fn o_stackpsize(&self) -> u8;
+}
+
+impl AuxHeader for xcoff::AuxHeader32 {
+    type Word = u32;
+
+    fn o_vstamp(&self) -> u16 {
+        self.o_vstamp.get(BE)
+    }
+
+    fn o_tsize(&self) -> Self::Word {
+        self.o_tsize.get(BE)
+    }
+
+    fn o_dsize(&self) -> Self::Word {
+        self.o_dsize.get(BE)
+    }
+
+    fn o_bsize(&self) -> Self::Word {
+        self.o_bsize.get(BE)
+    }
+
+    fn o_entry(&self) -> Self::Word {
+        self.o_entry.get(BE)
+    }
+
+    fn o_text_start(&self) -> Self::Word {
+        self.o_text_start.get(BE)
+    }
+
+    fn o_data_start(&self) -> Self::Word {
+        self.o_data_start.get(BE)
+    }
+
+    fn o_toc(&self) -> Self::Word {
+        self.o_toc.get(BE)
+    }
+
+    fn o_snentry(&self) -> u16 {
+        self.o_snentry.get(BE)
+    }
+
+    fn o_sntext(&self) -> u16 {
+        self.o_sntext.get(BE)
+    }
+
+    fn o_sndata(&self) -> u16 {
+        self.o_sndata.get(BE)
+    }
+
+    fn o_sntoc(&self) -> u16 {
+        self.o_sntoc.get(BE)
+    }
+
+    fn o_snloader(&self) -> u16 {
+        self.o_snloader.get(BE)
+    }
+
+    fn o_snbss(&self) -> u16 {
+        self.o_snbss.get(BE)
+    }
+
+    fn o_sntdata(&self) -> u16 {
+        self.o_sntdata.get(BE)
+    }
+
+    fn o_sntbss(&self) -> u16 {
+        self.o_sntbss.get(BE)
+    }
+
+    fn o_algntext(&self) -> u16 {
+        self.o_algntext.get(BE)
+    }
+
+    fn o_algndata(&self) -> u16 {
+        self.o_algndata.get(BE)
+    }
+
+    fn o_maxstack(&self) -> Self::Word {
+        self.o_maxstack.get(BE)
+    }
+
+    fn o_maxdata(&self) -> Self::Word {
+        self.o_maxdata.get(BE)
+    }
+
+    fn o_textpsize(&self) -> u8 {
+        self.o_textpsize
+    }
+
+    fn o_datapsize(&self) -> u8 {
+        self.o_datapsize
+    }
+
+    fn o_stackpsize(&self) -> u8 {
+        self.o_stackpsize
+    }
+}
+
+impl AuxHeader for xcoff::AuxHeader64 {
+    type Word = u64;
+
+    fn o_vstamp(&self) -> u16 {
+        self.o_vstamp.get(BE)
+    }
+
+    fn o_tsize(&self) -> Self::Word {
+        self.o_tsize.get(BE)
+    }
+
+    fn o_dsize(&self) -> Self::Word {
+        self.o_dsize.get(BE)
+    }
+
+    fn o_bsize(&self) -> Self::Word {
+        self.o_bsize.get(BE)
+    }
+
+    fn o_entry(&self) -> Self::Word {
+        self.o_entry.get(BE)
+    }
+
+    fn o_text_start(&self) -> Self::Word {
+        self.o_text_start.get(BE)
+    }
+
+    fn o_data_start(&self) -> Self::Word {
+        self.o_data_start.get(BE)
+    }
+
+    fn o_toc(&self) -> Self::Word {
+        self.o_toc.get(BE)
+    }
+
+    fn o_snentry(&self) -> u16 {
+        self.o_snentry.get(BE)
+    }
+
+    fn o_sntext(&self) -> u16 {
+        self.o_sntext.get(BE)
+    }
+
+    fn o_sndata(&self) -> u16 {
+        self.o_sndata.get(BE)
+    }
+
+    fn o_sntoc(&self) -> u16 {
+        self.o_sntoc.get(BE)
+    }
+
+    fn o_snloader(&self) -> u16 {
+        self.o_snloader.get(BE)
+    }
+
+    fn o_snbss(&self) -> u16 {
+        self.o_snbss.get(BE)
+    }
+
+    fn o_sntdata(&self) -> u16 {
+        self.o_sntdata.get(BE)
+    }
+
+    fn o_sntbss(&self) -> u16 {
+        self.o_sntbss.get(BE)
+    }
+
+    fn o_algntext(&self) -> u16 {
+        self.o_algntext.get(BE)
+    }
+
+    fn o_algndata(&self) -> u16 {
+        self.o_algndata.get(BE)
+    }
+
+    fn o_maxstack(&self) -> Self::Word {
+        self.o_maxstack.get(BE)
+    }
+
+    fn o_maxdata(&self) -> Self::Word {
+        self.o_maxdata.get(BE)
+    }
+
+    fn o_textpsize(&self) -> u8 {
+        self.o_textpsize
+    }
+
+    fn o_datapsize(&self) -> u8 {
+        self.o_datapsize
+    }
+
+    fn o_stackpsize(&self) -> u8 {
+        self.o_stackpsize
+    }
+}