PyNerva 0.0.5__py3-none-any.whl

nervapy/formats/elf/symbol.py

@@ -0,0 +1,281 @@
+# 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 SymbolBinding(IntEnum):
+    local = 0
+    global_ = 1
+    weak = 2
+
+
+class SymbolType:
+    # No type specified (e.g. an absolute symbol)
+    unspecified = 0
+    # Data object
+    data_object = 1
+    # Function entry point
+    function = 2
+    # Symbol associated with a section
+    section = 3
+    # Source file associated with the object file
+    file = 4
+
+
+class Symbol:
+    def __init__(self):
+        # Symbol name
+        self.name = None
+        # Value of the symbol (typically offset from the section)
+        self.value = None
+        # Size of the data object (0 if size is unknown or meaningless)
+        self.size = 0
+        # Binding attribute
+        self.binding = 0
+        # Type attribute
+        self.type = 0
+        # The relevant section in the section header table
+        self.section = None
+
+    @staticmethod
+    def get_entry_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.elf_bitness in [32, 64]
+
+        return {32: 16, 64: 24}[abi.elf_bitness]
+
+    def encode(self, encoder, name_index_map, section_index_map):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert encoder.bitness in [32, 64]
+        assert self.name in name_index_map
+        from nervapy.formats.elf.section import SectionIndex
+
+        assert (
+            self.section is None
+            or isinstance(self.section, SectionIndex)
+            or self.section in section_index_map
+        )
+
+        name_index = name_index_map[self.name]
+        section_index = SectionIndex.absolute
+        if self.section is not None:
+            if isinstance(self.section, SectionIndex):
+                section_index = self.section
+            else:
+                section_index = section_index_map[self.section]
+        if encoder.bitness == 32:
+            return (
+                encoder.uint32(name_index)
+                + encoder.uint32(self.value)
+                + encoder.uint32(self.size)
+                + encoder.uint8((self.binding << 4) | (self.type & 0xF))
+                + encoder.uint8(0)
+                + encoder.uint16(section_index)
+            )
+        else:
+            return (
+                encoder.uint32(name_index)
+                + encoder.uint8((self.binding << 4) | (self.type & 0xF))
+                + encoder.uint8(0)
+                + encoder.uint16(section_index)
+                + encoder.uint64(self.value)
+                + encoder.uint64(self.size)
+            )
+
+
+class RelocationType(IntEnum):
+    x86_32 = 1
+    x86_pc32 = 2
+    x86_got32 = 3
+    x86_plt32 = 4
+    x86_copy = 5
+    x86_glob_dat = 6
+    x86_jmp_slot = 7
+    x86_relative = 8
+    x86_gotoff = 9
+    x86_gotpc = 10
+
+    x86_64_64 = 1
+    x86_64_pc32 = 2
+    x86_64_got32 = 3
+    x86_64_plt32 = 4
+    x86_64_copy = 5
+    x86_64_glob_dat = 6
+    x86_64_jump_slot = 7
+    x86_64_relative = 8
+    x86_64_gotpcrel = 9
+    x86_64_32 = 10
+    x86_64_32s = 11
+    x86_64_16 = 12
+    x86_64_pc16 = 13
+    x86_64_8 = 14
+    x86_64_pc8 = 15
+    x86_64_dtpmod64 = 16
+    x86_64_dtpoff64 = 17
+    x86_64_tpoff64 = 18
+    x86_64_tlsgd = 19
+    x86_64_tlsld = 20
+    x86_64_dtpoff32 = 21
+    x86_64_gottpoff = 22
+    x86_64_tpoff32 = 23
+    x86_64_pc64 = 24
+    x86_64_gotoff64 = 25
+    x86_64_gotpc32 = 26
+    x86_64_got64 = 27
+    x86_64_gotpcrel64 = 28
+    x86_64_gotpc64 = 29
+    x86_64_gotplt64 = 30
+    x86_64_pltoff64 = 31
+    x86_64_size32 = 32
+    x86_64_size64 = 33
+    x86_64_gotpc32_tlsdesc = 34
+    x86_64_tlsdesc_call = 35
+    x86_64_tlsdesc = 36
+    x86_64_irelative = 37
+
+    arm_abs32 = 2
+    arm_rel32 = 3
+    arm_ldr_pc_g0 = 4
+    arm_abs16 = 5
+    arm_abs12 = 6
+    arm_thm_abs5 = 7
+    arm_abs8 = 8
+    arm_sbrel32 = 9
+    arm_thm_call = 10
+    arm_thm_pc8 = 11
+    arm_brel_adj = 12
+    arm_tls_desc = 13
+    arm_tls_dtpmod32 = 17
+    arm_tls_dtpoff32 = 18
+    arm_tls_tpoff32 = 19
+    arm_copy = 20
+    arm_glob_dat = 21
+    arm_jump_slot = 22
+    arm_relative = 23
+    arm_gotoff32 = 24
+    arm_base_prel = 25
+    arm_got_brel = 26
+    arm_plt32 = 27
+    arm_call = 28
+    arm_jump24 = 29
+    arm_thm_jump24 = 30
+    arm_base_abs = 31
+    arm_target1 = 38
+    arm_v4bx = 40
+    arm_target2 = 41
+    arm_prel31 = 42
+    arm_movw_abs_nc = 43
+    arm_movt_abs = 44
+    arm_movw_prel_nc = 45
+    arm_movt_prel = 46
+    arm_thm_movw_abs_nc = 47
+    arm_thm_movt_abs = 48
+    arm_thm_movw_prel_nc = 49
+    arm_thm_movt_prel = 50
+    arm_thm_jump19 = 51
+    arm_thm_jump6 = 52
+    arm_thm_alu_prel_11_0 = 53
+    arm_thm_pc12 = 54
+    arm_abs32_noi = 55
+    arm_rel32_noi = 56
+    arm_alu_pc_g0_nc = 57
+    arm_alu_pc_g0 = 58
+    arm_alu_pc_g1_nc = 59
+    arm_alu_pc_g1 = 60
+    arm_alu_pc_g2 = 61
+    arm_ldr_pc_g1 = 62
+    arm_ldr_pc_g2 = 63
+    arm_ldrs_pc_g0 = 64
+    arm_ldrs_pc_g1 = 65
+    arm_ldrs_pc_g2 = 66
+    arm_ldc_pc_g0 = 67
+    arm_ldc_pc_g1 = 68
+    arm_ldc_pc_g2 = 69
+    arm_alu_sb_g0_nc = 70
+    arm_alu_sb_g0 = 71
+    arm_alu_sb_g1_nc = 72
+    arm_alu_sb_g1 = 73
+    arm_alu_sb_g2 = 74
+    arm_ldr_sb_g0 = 75
+    arm_ldr_sb_g1 = 76
+    arm_ldr_sb_g2 = 77
+    arm_ldrs_sb_g0 = 78
+    arm_ldrs_sb_g1 = 79
+    arm_ldrs_sb_g2 = 80
+    arm_ldc_sb_g0 = 81
+    arm_ldc_sb_g1 = 82
+    arm_ldc_sb_g2 = 83
+    arm_movw_brel_nc = 84
+    arm_movt_brel = 85
+    arm_movw_brel = 86
+    arm_thm_movw_brel_nc = 87
+    arm_thm_movt_brel = 88
+    arm_thm_movw_brel = 89
+    arm_tls_gotdesc = 90
+    arm_tls_call = 91
+    arm_tls_descseq = 92
+    arm_thm_tls_call = 93
+    arm_plt32_abs = 94
+    arm_got_abs = 95
+    arm_got_prel = 96
+    arm_got_brel12 = 97
+    arm_gotoff12 = 98
+    arm_gotrelax = 99
+    arm_thm_jump11 = 102
+    arm_thm_jump8 = 103
+    arm_tls_gd32 = 104
+    arm_tls_ldm32 = 105
+    arm_tls_ldo32 = 106
+    arm_tls_ie32 = 107
+    arm_tls_le32 = 108
+    arm_tls_ldo12 = 109
+    arm_tls_le12 = 110
+    arm_tls_ie12gp = 111
+    arm_thm_tls_descseq16 = 129
+    arm_thm_tls_descseq32 = 130
+    arm_thm_got_brel12 = 131
+
+
+class RelocationWithAddend:
+    def __init__(self, type, offset, symbol, addend):
+        from nervapy.util import is_sint64, is_uint64
+
+        assert isinstance(type, RelocationType)
+        assert is_uint64(offset)
+        assert isinstance(symbol, Symbol)
+        assert is_sint64(addend)
+
+        self.type = type
+        self.offset = offset
+        self.symbol = symbol
+        self.addend = addend
+
+    @staticmethod
+    def get_entry_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.elf_bitness in [32, 64]
+
+        return {32: 12, 64: 24}[abi.elf_bitness]
+
+    def encode(self, encoder, symbol_index_map):
+        import nervapy.encoder
+
+        assert isinstance(encoder, nervapy.encoder.Encoder)
+        assert encoder.bitness in [32, 64]
+        assert self.symbol in symbol_index_map
+
+        symbol_index = symbol_index_map[self.symbol]
+        info = (symbol_index << 32) | self.type
+
+        return (
+            encoder.unsigned_offset(self.offset)
+            + encoder.unsigned_offset(info)
+            + encoder.signed_offset(self.addend)
+        )

nervapy/formats/macho/__init__.py

@@ -0,0 +1,2 @@
+# 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.

nervapy/formats/macho/file.py

@@ -0,0 +1,123 @@
+# 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
+    # Fixed VM shared library (?)
+    fixed_vm_library = 3
+    # Core dump file
+    core_dump = 4
+    # Preloaded executable file
+    preloaded_executable = 5
+    # Dynamically bound shared library
+    dynamic_library = 6
+    # Dynamic linker (dyld)
+    dynamic_linker = 7
+    # Dynamically bound bundle file
+    dynamic_bundle = 8
+    # Shared library stub for build-time linking (no section content)
+    dynamic_library_stub = 9
+    # Companion file with debug sections only
+    debug_symbols = 10
+    # Kernel-mode driver
+    kext_bundle = 11
+
+
+class CpuType(IntEnum):
+    x86 = 0x00000007
+    x86_64 = 0x01000007
+    arm = 0x0000000C
+    arm64 = 0x0100000C
+    ppc = 0x00000012
+    ppc64 = 0x01000012
+
+    abi64 = 0x01000000
+
+
+class PPCCpuSubType(IntEnum):
+    all = 0
+    # PowerPC G3
+    powerpc750 = 9
+    # PowerPC G4
+    powerpc7400 = 10
+    # PowerPC G4+
+    powerpc7450 = 11
+    # PowerPC G5
+    powerpc970 = 100
+
+
+class X86CpuSubType(IntEnum):
+    all = 3
+
+
+class ARMCpuSubType(IntEnum):
+    all = 0
+    # ARM 1176
+    v6 = 6
+    # ARM Cortex-A8
+    v7 = 9
+    # Cortex-A9 (ARMv7 + MP extension + NEON-HP, de-facto useless, removed from Clang)
+    v7f = 10
+    # Swift (ARMv7 + MP extension + VFPv4/NEONv2 + DIV)
+    v7s = 11
+    # Marvell Kirkwood (ARMv7 + XScale extension + WMMXv2 + Armada extension, no NEON)
+    v7k = 12
+    # Cyclone
+    v8 = 13
+
+
+class ARM64CpuSubType(IntEnum):
+    all = 0
+    # Cyclone
+    v8 = 1
+
+
+class MachHeader:
+    def __init__(self, abi):
+        import nervapy.arm
+        import nervapy.x86_64
+
+        self.abi = abi
+        self.size = {4: 28, 8: 32}[abi.pointer_size]
+        if abi == nervapy.x86_64.abi.system_v_x86_64_abi:
+            # 64-bit
+            self.magic = 0xFEEDFACF
+            self.cpu_type = CpuType.x86_64
+            self.cpu_subtype = X86CpuSubType.all
+        else:
+            raise ValueError("Unsupported ABI: %s" % str(abi))
+        self.file_type = FileType.object
+        self.commands_count = 0
+        self.commands_size = 0
+        self.flags = 0
+
+    @staticmethod
+    def get_size(abi):
+        from nervapy.abi import ABI
+
+        assert isinstance(abi, ABI)
+        assert abi.pointer_size in [4, 8]
+
+        return {4: 24, 8: 32}[abi.pointer_size]
+
+    def encode(self, encoder):
+        bytes = (
+            encoder.uint32(self.magic)
+            + encoder.uint32(self.cpu_type)
+            + encoder.uint32(self.cpu_subtype)
+            + encoder.uint32(self.file_type)
+            + encoder.uint32(self.commands_count)
+            + encoder.uint32(self.commands_size)
+            + encoder.uint32(self.flags)
+        )
+        if self.abi.pointer_size == 8:
+            bytes += bytearray(4)
+        return bytes

nervapy/formats/macho/image.py

@@ -0,0 +1,143 @@
+# 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):
+        from nervapy.formats.macho.section import (ConstSection, Segment,
+                                                   StringTable, SymbolTable,
+                                                   TextSection)
+
+        self.abi = abi
+        self.segments = list()
+
+        self.text_segment = Segment("__TEXT")
+        self.add_segment(self.text_segment)
+
+        self.text_section = TextSection()
+        self.text_segment.add_section(self.text_section)
+
+        self.const_section = ConstSection()
+        self.text_segment.add_section(self.const_section)
+
+        self.string_table = StringTable()
+        self.symbol_table = SymbolTable(self.string_table)
+
+    def add_segment(self, segment):
+        from nervapy.formats.macho.section import Segment
+
+        assert isinstance(segment, Segment)
+
+        self.segments.append(segment)
+
+    def encode(self):
+        from nervapy.encoder import Encoder
+        from nervapy.formats.macho.file import MachHeader
+        from nervapy.formats.macho.symbol import Relocation
+        from nervapy.util import roundup
+
+        bitness = {4: 32, 8: 64}[self.abi.pointer_size]
+        encoder = Encoder(self.abi.endianness, bitness)
+
+        mach_header = MachHeader(self.abi)
+        mach_header.commands_size = self.symbol_table.command_size
+        mach_header.commands_count = 1
+        for segment in self.segments:
+            mach_header.commands_size += segment.get_command_size(self.abi)
+            mach_header.commands_count += 1
+
+        symbol_offset_map = dict()
+        section_offset_map = dict()
+        section_address_map = dict()
+        section_relocations_map = dict()
+
+        # Layout the commands
+        data_offset = mach_header.get_size(self.abi)
+        for segment in self.segments:
+            data_offset += segment.get_command_size(self.abi)
+        data_offset += self.symbol_table.command_size
+
+        # Layout section data
+        data_address = 0
+        for segment in self.segments:
+            for section in segment.sections:
+                data_offset = roundup(data_offset, section.alignment)
+                data_address = roundup(data_address, section.alignment)
+                section_offset_map[section] = data_offset
+                section_address_map[section] = data_address
+                data_offset += section.content_size
+                data_address += section.content_size
+        data_offset = roundup(data_offset, self.abi.pointer_size)
+
+        # Layout the relocations
+        for segment in self.segments:
+            for section in segment.sections:
+                if section.relocations:
+                    section_relocations_map[section] = data_offset
+                    data_offset += Relocation.size * len(section.relocations)
+
+        # Layout the symbols
+        for symbol in self.symbol_table.symbols:
+            symbol_offset_map[symbol] = data_offset
+            data_offset += symbol.get_entry_size(self.abi)
+
+        # Layout the strings
+        string_table_offset = data_offset
+
+        # Create map: section->index
+        section_index = 1
+        section_index_map = dict()
+        for segment in self.segments:
+            for section in segment.sections:
+                section_index_map[section] = section_index
+                section_index += 1
+
+        # Create map: symbol->index
+        symbol_index_map = {
+            symbol: index for index, symbol in enumerate(self.symbol_table.symbols)
+        }
+
+        # Write Mach-O header
+        data = mach_header.encode(encoder)
+
+        # Write commands
+        for segment in self.segments:
+            data += segment.encode_command(
+                encoder,
+                section_offset_map,
+                section_address_map,
+                section_relocations_map,
+            )
+        data += self.symbol_table.encode_command(
+            encoder, symbol_offset_map, string_table_offset
+        )
+
+        # Write section data
+        for segment in self.segments:
+            for section in segment.sections:
+                padding = bytearray(roundup(len(data), section.alignment) - len(data))
+                data += padding + section.content
+        padding = bytearray(roundup(len(data), self.abi.pointer_size) - len(data))
+        data += padding
+
+        # Write relocations
+        for segment in self.segments:
+            for section in segment.sections:
+                for relocation in section.relocations:
+                    data += relocation.encode(
+                        encoder, section_index_map, symbol_index_map
+                    )
+
+        # Write symbols
+        for symbol in self.symbol_table.symbols:
+            data += symbol.encode(
+                encoder,
+                self.string_table.string_index_map,
+                section_index_map,
+                section_address_map,
+            )
+
+        # Write string table
+        data += self.string_table.encode()
+
+        return data