omnizip 0.4.7-aarch64-linux

data/lib/omnizip/filters/bcj_arm64.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Filters
+    # BCJ filter for 64-bit ARM (AArch64) executables.
+    #
+    # This filter preprocesses ARM64 machine code by converting relative
+    # addresses in B/BL (0x94) and ADRP (0x90) instructions to absolute
+    # addresses. ARM64 uses 4-byte aligned instructions with little-endian
+    # encoding.
+    #
+    # The filter improves compression by making branch targets and
+    # page-aligned addresses position-independent.
+    class BcjArm64 < Omnizip::Filter
+      # B/BL instruction base opcode
+      OPCODE_B_BL = 0x94000000
+
+      # B/BL instruction mask
+      MASK_B_BL = 0xFC000000
+
+      # ADRP instruction base opcode
+      OPCODE_ADRP = 0x90000000
+
+      # ADRP instruction mask for variant detection
+      MASK_ADRP = 0x9F000000
+
+      # Size of ARM64 instruction (4 bytes)
+      INSTRUCTION_SIZE = 4
+
+      # Encode (preprocess) ARM64 executable data for compression.
+      #
+      # Scans for B/BL (0x94xxxxxx) and ADRP (0x90xxxxxx) instructions
+      # and converts relative addresses to absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_le(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for B/BL instruction (0x94xxxxxx)
+          if (instruction & MASK_B_BL) == OPCODE_B_BL
+            # Extract 26-bit offset, sign-extend, and convert
+            offset = sign_extend_26(instruction & 0x03FFFFFF)
+            absolute = (offset << 2) + pc
+            new_instruction = OPCODE_B_BL | ((absolute >> 2) & 0x03FFFFFF)
+            write_uint32_le(result, i, new_instruction)
+            i += INSTRUCTION_SIZE
+            next
+          end
+
+          # Check for ADRP instruction (0x90xxxxxx or 0xB0xxxxxx variants)
+          if (instruction & MASK_ADRP) == OPCODE_ADRP
+            # Extract immlo (bits [30:29]) and immhi (bits [23:5])
+            immlo = (instruction >> 29) & 0x3
+            immhi = (instruction >> 5) & 0x7FFFF
+
+            # Combine into 21-bit offset
+            offset = (immhi << 2) | immlo
+
+            # Sign-extend 21-bit to full integer
+            offset = sign_extend_21(offset)
+
+            # Convert to absolute address (page-aligned, << 12)
+            absolute = (offset << 12) + (pc & ~0xFFF)
+
+            # Encode back
+            absolute >>= 12
+            new_immlo = absolute & 0x3
+            new_immhi = (absolute >> 2) & 0x7FFFF
+
+            new_instruction = (instruction & 0x9F00001F) |
+              (new_immlo << 29) |
+              (new_immhi << 5)
+            write_uint32_le(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      # Decode (postprocess) ARM64 executable data after decompression.
+      #
+      # Reverses the encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_le(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for B/BL instruction
+          if (instruction & MASK_B_BL) == OPCODE_B_BL
+            # Extract absolute address and convert to relative offset
+            absolute = (instruction & 0x03FFFFFF) << 2
+            offset = (absolute - pc) >> 2
+            new_instruction = OPCODE_B_BL | (offset & 0x03FFFFFF)
+            write_uint32_le(result, i, new_instruction)
+            i += INSTRUCTION_SIZE
+            next
+          end
+
+          # Check for ADRP instruction
+          if (instruction & MASK_ADRP) == OPCODE_ADRP
+            # Extract immlo and immhi
+            immlo = (instruction >> 29) & 0x3
+            immhi = (instruction >> 5) & 0x7FFFF
+
+            # Combine into absolute page address
+            absolute = ((immhi << 2) | immlo) << 12
+
+            # Convert to relative offset
+            offset = (absolute - (pc & ~0xFFF)) >> 12
+
+            # Encode back as 21-bit value
+            new_immlo = offset & 0x3
+            new_immhi = (offset >> 2) & 0x7FFFF
+
+            new_instruction = (instruction & 0x9F00001F) |
+              (new_immlo << 29) |
+              (new_immhi << 5)
+            write_uint32_le(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ-ARM64",
+            description: "Branch converter for 64-bit ARM (AArch64) " \
+                         "executables",
+            architecture: "ARM64 / AArch64",
+            alignment: 4,
+            endian: "little",
+          }
+        end
+      end
+
+      private
+
+      # Extract an unsigned 32-bit little-endian integer from data.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Starting position
+      # @return [Integer] Unsigned 32-bit integer
+      def extract_uint32_le(data, offset)
+        bytes = data.byteslice(offset, INSTRUCTION_SIZE).bytes
+        bytes[0] |
+          (bytes[1] << 8) |
+          (bytes[2] << 16) |
+          (bytes[3] << 24)
+      end
+
+      # Write an unsigned 32-bit little-endian integer to data.
+      #
+      # @param data [String] Binary data (modified in place)
+      # @param offset [Integer] Starting position
+      # @param value [Integer] 32-bit integer to write
+      # @return [void]
+      def write_uint32_le(data, offset, value)
+        value &= 0xFFFFFFFF
+        data.setbyte(offset, value & 0xFF)
+        data.setbyte(offset + 1, (value >> 8) & 0xFF)
+        data.setbyte(offset + 2, (value >> 16) & 0xFF)
+        data.setbyte(offset + 3, (value >> 24) & 0xFF)
+      end
+
+      # Sign-extend a 26-bit value to 32-bit.
+      #
+      # @param value [Integer] 26-bit value
+      # @return [Integer] Sign-extended integer
+      # rubocop:disable Naming/VariableNumber
+      def sign_extend_26(value)
+        # rubocop:enable Naming/VariableNumber
+        if value.anybits?(0x02000000)
+          value | 0xFC000000
+        else
+          value
+        end
+      end
+
+      # Sign-extend a 21-bit value to 32-bit.
+      #
+      # @param value [Integer] 21-bit value
+      # @return [Integer] Sign-extended integer
+      # rubocop:disable Naming/VariableNumber
+      def sign_extend_21(value)
+        # rubocop:enable Naming/VariableNumber
+        if value.anybits?(0x100000)
+          value | 0xFFE00000
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/filters/bcj_ia64.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Filters
+    # BCJ filter for IA-64 (Itanium) executables.
+    #
+    # This filter preprocesses Itanium machine code by converting
+    # relative addresses in branch instructions. IA-64 uses a complex
+    # VLIW (Very Long Instruction Word) architecture with 16-byte
+    # instruction bundles containing 3 instructions plus a template.
+    #
+    # The filter improves compression by making branch targets
+    # position-independent.
+    class BcjIa64 < Omnizip::Filter
+      # Size of IA-64 instruction bundle (16 bytes, little-endian)
+      BUNDLE_SIZE = 16
+
+      # Template lookup table for instruction slot positions
+      # Each bit pattern indicates which slots may contain branch instr
+      TEMPLATE_MASKS = 0x334B0000
+
+      # Encode (preprocess) IA-64 executable data for compression.
+      #
+      # Scans 16-byte instruction bundles for branch instructions and
+      # converts relative addresses to absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < BUNDLE_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(BUNDLE_SIZE - 1)
+        i = 0
+        pc = (position >> 4) << 1
+
+        while i < size
+          # Check template byte for slots with potential branches
+          template = result.getbyte(i) & 0x1E
+          mask = (TEMPLATE_MASKS >> template) & 3
+          pc += 2
+
+          i += BUNDLE_SIZE
+          next if mask.zero?
+
+          # Process each marked slot
+          process_bundle_slots(result, i - BUNDLE_SIZE, mask, pc, true)
+        end
+
+        result
+      end
+
+      # Decode (postprocess) IA-64 executable data after decompression.
+      #
+      # Reverses the encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < BUNDLE_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(BUNDLE_SIZE - 1)
+        i = 0
+        pc = (position >> 4) << 1
+
+        while i < size
+          # Check template byte for slots with potential branches
+          template = result.getbyte(i) & 0x1E
+          mask = (TEMPLATE_MASKS >> template) & 3
+          pc += 2
+
+          i += BUNDLE_SIZE
+          next if mask.zero?
+
+          # Process each marked slot
+          process_bundle_slots(result, i - BUNDLE_SIZE, mask, pc, false)
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ-IA64",
+            description: "Branch converter for IA-64 (Itanium) " \
+                         "executables",
+            architecture: "IA-64 / Itanium",
+            alignment: 16,
+            endian: "little",
+            complexity: "high",
+          }
+        end
+      end
+
+      private
+
+      # Process instruction slots within a bundle.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Bundle offset
+      # @param mask [Integer] Slot mask
+      # @param pc [Integer] Program counter
+      # @param encoding [Boolean] True for encoding, false for decoding
+      # @return [void]
+      # rubocop:disable Naming/MethodParameterName
+      def process_bundle_slots(data, offset, mask, pc, encoding)
+        # rubocop:enable Naming/MethodParameterName
+        slot_offset = 0
+
+        3.times do
+          break if mask.zero?
+
+          if mask.anybits?(1)
+            process_slot(data, offset + 1 + slot_offset, pc, encoding)
+          end
+
+          mask >>= 1
+          slot_offset += 5
+        end
+      end
+
+      # Process a single instruction slot.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Slot offset within bundle
+      # @param pc [Integer] Program counter
+      # @param encoding [Boolean] True for encoding, false for decoding
+      # @return [void]
+      # rubocop:disable Naming/MethodParameterName
+      def process_slot(data, offset, pc, encoding)
+        # rubocop:enable Naming/MethodParameterName
+        # Extract slot data (5 bytes forming a 41-bit instruction)
+        bytes = data.byteslice(offset, 5).bytes
+        instruction = bytes[0] |
+          (bytes[1] << 8) |
+          (bytes[2] << 16) |
+          (bytes[3] << 24) |
+          (bytes[4] << 32)
+
+        # Check if this is a branch instruction
+        # Opcode check: bits 37-40 should be 0x5 (B-type instruction)
+        opcode = (instruction >> 37) & 0xF
+        return unless opcode == 5
+
+        # Extract 25-bit target address from bits 13-37
+        target = (instruction >> 13) & 0x1FFFFFF
+
+        # Apply address conversion
+        new_target = if encoding
+                       # Convert relative to absolute
+                       (target + pc) & 0x1FFFFFF
+                     else
+                       # Convert absolute to relative
+                       (target - pc) & 0x1FFFFFF
+                     end
+
+        # Reconstruct instruction with new target
+        instruction = (instruction & ~(0x1FFFFFF << 13)) |
+          (new_target << 13)
+
+        # Write back the modified instruction
+        data.setbyte(offset, instruction & 0xFF)
+        data.setbyte(offset + 1, (instruction >> 8) & 0xFF)
+        data.setbyte(offset + 2, (instruction >> 16) & 0xFF)
+        data.setbyte(offset + 3, (instruction >> 24) & 0xFF)
+        data.setbyte(offset + 4, (instruction >> 32) & 0xFF)
+      end
+    end
+  end
+end

data/lib/omnizip/filters/bcj_ppc.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2024 Ribose Inc.
+#
+# This file is part of Omnizip.
+#
+# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
+# Based on the 7-Zip LZMA SDK by Igor Pavlov.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# See the COPYING file for the complete text of the license.
+#
+
+module Omnizip
+  module Filters
+    # BCJ filter for PowerPC executables.
+    #
+    # This filter preprocesses PowerPC machine code by converting
+    # relative addresses in B/BL (Branch/Branch and Link) instructions
+    # to absolute addresses. PowerPC uses 4-byte aligned instructions
+    # with big-endian encoding.
+    #
+    # The filter improves compression by making branch targets
+    # position-independent.
+    class BcjPpc < Omnizip::Filter
+      # PPC B/BL instruction base (0x48000000)
+      OPCODE_BASE = 0x48000000
+
+      # Mask for checking B/BL instructions
+      OPCODE_MASK = 0xFC000003
+
+      # Expected pattern for B/BL with link bit (0x48000001)
+      OPCODE_PATTERN = 0x48000001
+
+      # Size of PPC instruction (4 bytes, big-endian)
+      INSTRUCTION_SIZE = 4
+
+      # Offset mask (26-bit offset in instruction)
+      OFFSET_MASK = 0x03FFFFFC
+
+      # Encode (preprocess) PowerPC executable data for compression.
+      #
+      # Scans for B/BL instructions (0x48xxxxxx) and converts relative
+      # addresses to absolute addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Encoded binary data
+      def encode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_be(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for B/BL instruction (0x48xxxxxx with proper flags)
+          if (instruction & OPCODE_MASK) == OPCODE_PATTERN
+            # Extract 24-bit offset (bits 6-29), sign-extend
+            offset = instruction & OFFSET_MASK
+            offset = sign_extend_26(offset)
+
+            # Convert to absolute address
+            absolute = offset + pc
+
+            # Encode back
+            new_instruction = OPCODE_BASE | (absolute & OFFSET_MASK) | 1
+            write_uint32_be(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      # Decode (postprocess) PowerPC executable data after decompression.
+      #
+      # Reverses the encoding by converting absolute addresses back to
+      # relative addresses.
+      #
+      # @param data [String] Binary executable data
+      # @param position [Integer] Current stream position
+      # @return [String] Decoded binary data
+      def decode(data, position = 0)
+        return data.dup if data.bytesize < INSTRUCTION_SIZE
+
+        result = data.b
+        size = data.bytesize & ~(INSTRUCTION_SIZE - 1)
+        i = 0
+        pc = position - INSTRUCTION_SIZE
+
+        while i < size
+          instruction = extract_uint32_be(result, i)
+          pc += INSTRUCTION_SIZE
+
+          # Check for B/BL instruction
+          if (instruction & OPCODE_MASK) == OPCODE_PATTERN
+            # Extract absolute address
+            absolute = instruction & OFFSET_MASK
+
+            # Convert to relative offset
+            offset = absolute - pc
+
+            # Encode back
+            new_instruction = OPCODE_BASE | (offset & OFFSET_MASK) | 1
+            write_uint32_be(result, i, new_instruction)
+          end
+
+          i += INSTRUCTION_SIZE
+        end
+
+        result
+      end
+
+      class << self
+        # Get metadata about this filter.
+        #
+        # @return [Hash] Filter metadata
+        def metadata
+          {
+            name: "BCJ-PPC",
+            description: "Branch converter for PowerPC executables",
+            architecture: "PowerPC",
+            alignment: 4,
+            endian: "big",
+          }
+        end
+      end
+
+      private
+
+      # Extract an unsigned 32-bit big-endian integer from data.
+      #
+      # @param data [String] Binary data
+      # @param offset [Integer] Starting position
+      # @return [Integer] Unsigned 32-bit integer
+      def extract_uint32_be(data, offset)
+        bytes = data.byteslice(offset, INSTRUCTION_SIZE).bytes
+        (bytes[0] << 24) |
+          (bytes[1] << 16) |
+          (bytes[2] << 8) |
+          bytes[3]
+      end
+
+      # Write an unsigned 32-bit big-endian integer to data.
+      #
+      # @param data [String] Binary data (modified in place)
+      # @param offset [Integer] Starting position
+      # @param value [Integer] 32-bit integer to write
+      # @return [void]
+      def write_uint32_be(data, offset, value)
+        value &= 0xFFFFFFFF
+        data.setbyte(offset, (value >> 24) & 0xFF)
+        data.setbyte(offset + 1, (value >> 16) & 0xFF)
+        data.setbyte(offset + 2, (value >> 8) & 0xFF)
+        data.setbyte(offset + 3, value & 0xFF)
+      end
+
+      # Sign-extend a 26-bit value to 32-bit.
+      #
+      # The offset in PPC B/BL instructions is 26 bits (bits 6-31),
+      # but bit 0-1 are always 0 (4-byte aligned).
+      #
+      # @param value [Integer] 26-bit value
+      # @return [Integer] Sign-extended integer
+      # rubocop:disable Naming/VariableNumber
+      def sign_extend_26(value)
+        # rubocop:enable Naming/VariableNumber
+        # Check if bit 25 is set (sign bit for 26-bit number)
+        if value.anybits?(0x02000000)
+          value | 0xFC000000
+        else
+          value
+        end
+      end
+    end
+  end
+end