PyNerva 0.0.7__py3-none-any.whl

nervapy/formats/elf/file.py

@@ -0,0 +1,178 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from enum import IntEnum
+
+
+class FileType(IntEnum):
+    # No file type
+    null = 0
+    # Relocatable file
+    object = 1
+    # Executable file
+    executable = 2
+    # Shared object file
+    dynamic_shared_object = 3
+    # Core dump file
+    core_dump = 4
+
+
+class MachineType(IntEnum):
+    # Not specified
+    unspecified = 0
+    # SPARC
+    sparc = 2
+    # IA32 (x86)
+    x86 = 3
+    # MIPS
+    mips = 8
+    # 32-bit subset of SPARC V9
+    sparc32plus = 18
+    # IBM POWER and PowerPC
+    ppc = 20
+    # IBM PowerPC 64
+    ppc64 = 21
+    # ARM
+    arm = 40
+    # SPARC V9 (64-bit)
+    sparc64 = 43
+    # IA64 (Itanium)
+    ia64 = 50
+    # x86-64 (AMD64, Intel64, x64)
+    x86_64 = 62
+    # Intel Knights Ferry
+    l1om = 180
+    # Intel Knights Corner
+    k1om = 181
+    # ARMv8 AArch64
+    arm64 = 183
+    # ATI/AMD GPU code (for any GPU arch)
+    cal = 125
+    # nVidia CUDA GPU code (for any GPU arch)
+    cuda = 190
+    # HSAIL code (32-bit ELF)
+    hsail32 = 0xAF5A
+    # HSAIL code (64-bit ELF)
+    hsail64 = 0xAF5B
+
+
+class FormatVersion(IntEnum):
+    # Invalid version
+    invalid = 0
+    # Current version
+    current = 1
+
+
+class ElfClass(IntEnum):
+    # Invalid class
+    invalid = 0
+    # 32-bit ELF
+    class32 = 1
+    # 64-bit ELF
+    class64 = 2
+
+
+class DataEncoding(IntEnum):
+    # Invalid data encoding
+    invalid = 0
+    # Least significant byte first (Little-Endian)
+    little_endian = 1
+    # Most significant byte first (Big-Endian)
+    big_endian = 2
+
+
+class OSABI(IntEnum):
+    # No extensions or unspecified
+    none = 0
+    # GNU Linux
+    gnu = 3
+    # FreeBSD
+    freebsd = 9
+    # ATI/AMD GPU ABI
+    cal = 100
+
+
+class FileIdentification:
+    def __init__(self, abi):
+        self.abi = abi
+        self.file_version = FormatVersion.current
+
+    @property
+    def as_bytearray(self):
+        identification = bytearray(16)
+        identification[0] = 0x7F
+        identification[1] = ord("E")
+        identification[2] = ord("L")
+        identification[3] = ord("F")
+        identification[4] = self.abi.elf_class
+        identification[5] = self.abi.elf_data_encoding
+        identification[6] = self.file_version
+        return identification
+
+
+class FileHeader:
+    def __init__(self, abi):
+        import nervapy.abi
+        import nervapy.formats.elf.section
+
+        if not isinstance(abi, nervapy.abi.ABI):
+            raise TypeError("ABI %s must be represented by an ABI object" % str(abi))
+        if not abi.is_elf_compatible:
+            raise ValueError("ABI %s is not compatible with ELF" % str(abi))
+        self.abi = abi
+
+        self.identification = FileIdentification(self.abi)
+        if self.abi.elf_class == ElfClass.class32:
+            # Size of ELF32 file header, in bytes
+            self.file_header_size = 52
+            # Size of program header, in bytes. All program headers have the same size.
+            self.program_header_entry_size = 32
+            # Size of a section header, in bytes. All sections have the same size.
+            self.section_header_entry_size = 40
+        else:
+            # Size of ELF64 file header, in bytes
+            self.file_header_size = 64
+            # Size of program header, in bytes. All program headers have the same size.
+            self.program_header_entry_size = 56
+            # Size of a section header, in bytes. All sections have the same size.
+            self.section_header_entry_size = 64
+
+        self.size = self.file_header_size
+        self.file_type = FileType.object
+        self.file_version = FormatVersion.current
+        self.entry_address = None
+        self.program_header_table_offset = None
+        self.section_header_table_offset = None
+        self.flags = 0
+        # Number of program headers in the program header table.
+        self.program_header_entries_count = 0
+        # Number of section headers in the section header table.
+        self.section_header_entries_count = 0
+        # Index of the section header for a section which contains section name string table.
+        # Usually this section is called ".shstrtab"
+        self.section_name_string_table_index = (
+            nervapy.formats.elf.section.SectionIndex.undefined
+        )
+
+    @property
+    def as_bytearray(self):
+        import nervapy.encoder
+
+        encoder = nervapy.encoder.Encoder(self.abi.endianness, self.abi.elf_bitness)
+
+        return (
+            self.identification.as_bytearray
+            + encoder.uint16(self.file_type)
+            + encoder.uint16(self.abi.elf_machine_type)
+            + encoder.uint32(self.file_version)
+            + encoder.unsigned_offset(self.entry_address or 0)
+            + encoder.unsigned_offset(self.program_header_table_offset or 0)
+            + encoder.unsigned_offset(self.section_header_table_offset or 0)
+            + encoder.uint32(self.flags)
+            + encoder.uint16(self.file_header_size)
+            + encoder.uint16(self.program_header_entry_size)
+            + encoder.uint16(self.program_header_entries_count)
+            + encoder.uint16(self.section_header_entry_size)
+            + encoder.uint16(self.section_header_entries_count)
+            + encoder.uint16(self.section_name_string_table_index)
+        )

nervapy/formats/elf/image.py

@@ -0,0 +1,106 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+
+class Image:
+    def __init__(self, abi, source=None):
+        from nervapy.formats.elf.section import (SectionIndex, StringSection,
+                                                 SymbolSection, null_section)
+        from nervapy.formats.elf.symbol import (Symbol, SymbolBinding,
+                                                SymbolType)
+
+        self.abi = abi
+        self.shstrtab = StringSection(".shstrtab")
+        self.strtab = StringSection(".strtab")
+        self.symtab = SymbolSection(string_table=self.strtab)
+        self.sections = [null_section, self.shstrtab, self.strtab, self.symtab]
+        self._section_names = set(
+            [self.shstrtab.name, self.strtab.name, self.symtab.name]
+        )
+        if source:
+            source_symbol = Symbol()
+            source_symbol.value = 0
+            source_symbol.binding = SymbolBinding.local
+            source_symbol.type = SymbolType.file
+            source_symbol.name = source
+            source_symbol.size = 0
+            source_symbol.section = SectionIndex.absolute
+            self.symtab.add(source_symbol)
+
+    def add_section(self, section):
+        from nervapy.formats.elf.section import Section
+
+        if not isinstance(section, Section):
+            raise TypeError("%s is not a Section object" % str(section))
+        if section.name is not None and section.name in self._section_names:
+            raise ValueError(
+                "Section %s is already present in the image" % section.name
+            )
+        self.sections.append(section)
+        self._section_names.add(section.name)
+
+    def find_section(self, section_name):
+        for section in self.sections:
+            if section.name == section_name:
+                return section
+
+    @property
+    def as_bytearray(self):
+        import six
+
+        from nervapy.formats.elf.file import FileHeader
+        from nervapy.formats.elf.section import (Section, StringSection,
+                                                 SymbolSection)
+        from nervapy.util import roundup
+
+        file_header = FileHeader(self.abi)
+        file_header.section_header_table_offset = file_header.size
+        file_header.section_header_entries_count = len(self.sections)
+        file_header.section_name_string_table_index = 1
+        data = file_header.as_bytearray
+
+        # Collect strings from sections
+        for section in self.sections:
+            self.shstrtab.add(section.name)
+            if isinstance(section, StringSection):
+                pass
+            elif isinstance(section, SymbolSection):
+                for symbol in six.iterkeys(section.symbol_index_map):
+                    self.strtab.add(symbol.name)
+
+        # Layout sections
+        data_offset = file_header.size + Section.get_header_size(self.abi) * len(
+            self.sections
+        )
+        section_offsets = []
+        for section in self.sections:
+            if section.alignment != 0:
+                data_offset = roundup(data_offset, section.alignment)
+            section_offsets.append(data_offset)
+            data_offset += section.get_content_size(self.abi)
+
+        from nervapy.encoder import Encoder
+
+        encoder = Encoder(self.abi.endianness, self.abi.elf_bitness)
+
+        section_index_map = {
+            section: index for index, section in enumerate(self.sections)
+        }
+        # Write section headers
+        for section, offset in zip(self.sections, section_offsets):
+            data += section.encode_header(
+                encoder, self.shstrtab._string_index_map, section_index_map, offset
+            )
+
+        # Write section content
+        for section in self.sections:
+            padding = bytearray(roundup(len(data), section.alignment) - len(data))
+            data += padding
+            data += section.encode_content(
+                encoder,
+                self.strtab._string_index_map,
+                section_index_map,
+                self.symtab.symbol_index_map,
+            )
+
+        return data

nervapy/formats/elf/section.py

@@ -0,0 +1,422 @@
+# This file is part of PeachPy package and is licensed under the Simplified BSD license.
+#    See license.rst for the full text of the license.
+
+from enum import IntEnum
+
+
+class SectionFlags(IntEnum):
+    # Section contains writable data during process execution
+    writable = 0x1
+    # Section occupies memory during process execution
+    allocate = 0x2
+    # Section contains executable data machine instructions
+    executable = 0x4
+
+
+class SectionType(IntEnum):
+    # Nil section
+    null = 0
+    # Program-specific content
+    program_bits = 1
+    # Symbol table
+    symbol_table = 2
+    # String table
+    string_table = 3
+    # Relocations with explicit addend
+    relocations_with_addend = 4
+    # Hash table for symbols used in dynamic linking
+    symbol_hash_table = 5
+    # Information for dynamic linking
+    dynamic_linking_info = 6
+    # Free-form note
+    note = 7
+    # Program-specific zero-initialized content
+    no_bits = 8
+    # Relocations without explicit addends
+    relocations = 9
+    # Minimal symbol table for dynamic linking
+    dynamic_symbol_table = 11
+
+
+class SectionIndex(IntEnum):
+    absolute = 0xFFF1
+    common = 0xFFF2
+    undefined = 0x0000
+
+
+class Section(object):
+    def __init__(self, name, type, allocate=False, writable=False, executable=False):
+        # Section name
+        self.name = name
+        # Type of the section content
+        self._type = SectionType.null
+        self.type = type  # Check the type object in property setter
+        # Properties of section content
+        self.flags = 0
+        if allocate:
+            self.flags |= SectionFlags.allocate
+        if writable:
+            self.flags |= SectionFlags.writable
+        if executable:
+            self.flags |= SectionFlags.executable
+        # Section address alignment. Only powers of 2 are allowed. Value 0 or 1 mean no alignment restrictions.
+        self._alignment = 1
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type):
+        if not isinstance(type, SectionType):
+            raise TypeError("Section type %s is not a SectionType enum" % str(type))
+        self._type = type
+
+    @property
+    def alignment(self):
+        return self._alignment
+
+    @alignment.setter
+    def alignment(self, alignment):
+        from nervapy.util import is_uint32
+
+        if not is_uint32(alignment):
+            raise TypeError(
+                "Section alignment %s is not representable as a 32-bit unsigned integer"
+                % str(alignment)
+            )
+        if alignment & (alignment - 1) != 0:
+            raise ValueError("Section alignment %d is not a power of 2" % alignment)
+        if alignment == 0:
+            alignment = 1
+        self._alignment = alignment
+
+    @staticmethod
+    def get_header_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.elf_bitness in [32, 64]
+
+        return {32: 40, 64: 64}[abi.elf_bitness]
+
+    def get_content_size(self, abi):
+        return 0
+
+    def encode_header(
+        self,
+        encoder,
+        name_index_map,
+        section_index_map,
+        offset,
+        address=None,
+        link_section=None,
+        info=None,
+        content_size=0,
+        entry_size=0,
+    ):
+        import nervapy.encoder
+        from nervapy.util import is_uint32, is_uint64
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert isinstance(name_index_map, dict)
+        assert section_index_map is None or isinstance(section_index_map, dict)
+        assert offset is None or is_uint64(offset)
+        assert address is None or is_uint64(address)
+        assert link_section is None or isinstance(link_section, Section)
+        assert info is None or is_uint64(info)
+        assert is_uint64(content_size)
+        assert is_uint32(entry_size)
+
+        assert encoder.bitness in [32, 64]
+        if encoder.bitness == 32:
+            assert offset is None or is_uint32(offset)
+            assert address is None or is_uint32(address)
+        assert self.name is None or self.name in name_index_map
+        assert section_index_map is not None or link_section is None
+
+        name_index = name_index_map.get(self.name, 0)
+        if address is None:
+            address = 0
+        if offset is None:
+            offset = 0
+        link = 0
+        if link_section is not None:
+            link = section_index_map[link_section]
+        if info is None:
+            info = 0
+        return (
+            encoder.uint32(name_index)
+            + encoder.uint32(self.type)
+            + encoder.unsigned_offset(self.flags)
+            + encoder.unsigned_offset(address)
+            + encoder.unsigned_offset(offset)
+            + encoder.unsigned_offset(content_size)
+            + encoder.uint32(link)
+            + encoder.uint32(info)
+            + encoder.unsigned_offset(self.alignment)
+            + encoder.unsigned_offset(entry_size)
+        )
+
+    def encode_content(
+        self, encoder, name_index_map, section_index_map, symbol_index_map
+    ):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert isinstance(name_index_map, dict)
+        assert section_index_map is None or isinstance(section_index_map, dict)
+        assert symbol_index_map is None or isinstance(symbol_index_map, dict)
+
+        assert encoder.bitness in [32, 64]
+
+        return bytearray()
+
+
+null_section = Section(None, SectionType.null)
+
+
+class ProgramBitsSection(Section):
+    def __init__(self, name, allocate=True, writable=False, executable=False):
+        super(ProgramBitsSection, self).__init__(
+            name, SectionType.program_bits, allocate, writable, executable
+        )
+        self.content = bytearray()
+
+    def get_content_size(self, abi):
+        return len(self.content)
+
+    def encode_header(
+        self, encoder, name_index_map, section_index_map, offset, address=None
+    ):
+        return super(ProgramBitsSection, self).encode_header(
+            encoder,
+            name_index_map,
+            section_index_map,
+            offset,
+            address=address,
+            content_size=len(self.content),
+        )
+
+    def encode_content(
+        self, encoder, name_index_map, section_index_map, symbol_index_map
+    ):
+        super(ProgramBitsSection, self).encode_content(
+            encoder, name_index_map, section_index_map, symbol_index_map
+        )
+        return self.content
+
+
+class TextSection(ProgramBitsSection):
+    def __init__(self, name=".text"):
+        super(TextSection, self).__init__(name, executable=True)
+
+
+class DataSection(ProgramBitsSection):
+    def __init__(self, name=".data"):
+        super(DataSection, self).__init__(name, writable=True)
+
+
+class ReadOnlyDataSection(ProgramBitsSection):
+    def __init__(self, name=".rodata"):
+        super(ReadOnlyDataSection, self).__init__(name)
+
+
+class StringSection(Section):
+    def __init__(self, name=".strtab"):
+        super(StringSection, self).__init__(name, SectionType.string_table)
+        self._string_index_map = dict()
+        self.content_size = 0
+
+    def add(self, string):
+        if not string:
+            return 0
+        elif string in self._string_index_map:
+            return self._string_index_map[string]
+        else:
+            import codecs
+
+            if self.content_size == 0:
+                self.content_size = 1
+            string_index = self.content_size
+            self._string_index_map[string] = string_index
+            string_bytes = codecs.encode(string, "utf-8")
+            self.content_size += len(string_bytes) + 1
+            return string_index
+
+    def get_content_size(self, abi):
+        return self.content_size
+
+    def encode_header(self, encoder, name_index_map, section_index_map, offset):
+        return super(StringSection, self).encode_header(
+            encoder,
+            name_index_map,
+            section_index_map,
+            offset,
+            content_size=self.content_size,
+        )
+
+    def encode_content(
+        self, encoder, name_index_map, section_index_map, symbol_index_map
+    ):
+        super(StringSection, self).encode_content(
+            encoder, name_index_map, section_index_map, symbol_index_map
+        )
+        if self.content_size != 0:
+            import codecs
+
+            bytes = b"\x00"
+            for string in sorted(
+                self._string_index_map, key=self._string_index_map.get
+            ):
+                bytes += codecs.encode(string, "utf8") + b"\x00"
+            return bytes
+        else:
+            return bytearray()
+
+
+class SymbolSection(Section):
+    def __init__(self, name=".symtab", string_table=None):
+        super(SymbolSection, self).__init__(name, SectionType.symbol_table)
+        self._symbols_set = set()
+        self._local_symbols = list()
+        self._nonlocal_symbols = list()
+        self._string_table = string_table
+
+    @property
+    def symbol_index_map(self):
+        symbol_index_map = {
+            symbol: index for index, symbol in enumerate(self._local_symbols)
+        }
+        local_symbols_count = len(self._local_symbols)
+        symbol_index_map.update(
+            {
+                symbol: local_symbols_count + index
+                for index, symbol in enumerate(self._nonlocal_symbols)
+            }
+        )
+        return symbol_index_map
+
+    def add(self, symbol):
+        from nervapy.formats.elf.symbol import Symbol, SymbolBinding
+
+        assert isinstance(symbol, Symbol)
+
+        if symbol in self._symbols_set:
+            raise ValueError(
+                "Symbol %s is already present in the section %s"
+                % (str(symbol), self.name)
+            )
+        self._symbols_set.add(symbol)
+        if symbol.binding == SymbolBinding.local:
+            self._local_symbols.append(symbol)
+        else:
+            self._nonlocal_symbols.append(symbol)
+
+    def get_content_size(self, abi):
+        from nervapy.abi import ABI
+        from nervapy.formats.elf.symbol import Symbol
+
+        assert isinstance(abi, ABI)
+        assert abi.elf_bitness in [32, 64]
+
+        entry_size = Symbol.get_entry_size(abi)
+        return entry_size * (len(self._local_symbols) + len(self._nonlocal_symbols))
+
+    def encode_header(self, encoder, name_index_map, section_index_map, offset):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert encoder.bitness in [32, 64]
+
+        entry_size = {32: 16, 64: 24}[encoder.bitness]
+        symbols_count = len(self._local_symbols) + len(self._nonlocal_symbols)
+        return super(SymbolSection, self).encode_header(
+            encoder,
+            name_index_map,
+            section_index_map,
+            offset,
+            link_section=self._string_table,
+            info=len(self._local_symbols),
+            content_size=symbols_count * entry_size,
+            entry_size=entry_size,
+        )
+
+    def encode_content(
+        self, encoder, name_index_map, section_index_map, symbol_index_map
+    ):
+        super(SymbolSection, self).encode_content(
+            encoder, name_index_map, section_index_map, symbol_index_map
+        )
+
+        # Local symbols must be encoded before non-local symbols. Thus, need to separate the two classes
+        content = bytearray()
+
+        # Step 1: encode local symbols
+        for symbol in self._local_symbols:
+            content += symbol.encode(encoder, name_index_map, section_index_map)
+        # Step 2: encode non-local symbols
+        for symbol in self._nonlocal_symbols:
+            content += symbol.encode(encoder, name_index_map, section_index_map)
+
+        return content
+
+
+class RelocationsWithAddendSection(Section):
+    def __init__(self, reference_section, symbol_table):
+        super(RelocationsWithAddendSection, self).__init__(
+            ".rela" + reference_section.name, SectionType.relocations_with_addend
+        )
+        self.reference_section = reference_section
+        self.symbol_table = symbol_table
+
+        self.relocations = list()
+
+    def add(self, relocation):
+        from nervapy.formats.elf.symbol import RelocationWithAddend
+
+        assert isinstance(relocation, RelocationWithAddend)
+
+        self.relocations.append(relocation)
+
+    def get_content_size(self, abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.elf_bitness in [32, 64]
+
+        entry_size = {32: 12, 64: 24}[abi.elf_bitness]
+        return entry_size * len(self.relocations)
+
+    def encode_header(self, encoder, name_index_map, section_index_map, offset):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert encoder.bitness in [32, 64]
+
+        entry_size = {32: 16, 64: 24}[encoder.bitness]
+        relocations_count = len(self.relocations)
+        reference_section_index = section_index_map[self.reference_section]
+        return super(RelocationsWithAddendSection, self).encode_header(
+            encoder,
+            name_index_map,
+            section_index_map,
+            offset,
+            link_section=self.symbol_table,
+            info=reference_section_index,
+            content_size=relocations_count * entry_size,
+            entry_size=entry_size,
+        )
+
+    def encode_content(
+        self, encoder, name_index_map, section_index_map, symbol_index_map
+    ):
+        super(RelocationsWithAddendSection, self).encode_content(
+            encoder, name_index_map, section_index_map, symbol_index_map
+        )
+
+        content = bytearray()
+        for relocation in self.relocations:
+            content += relocation.encode(encoder, symbol_index_map)
+
+        return content