| /* |
| * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>. |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation; either version 2 of the |
| * License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| * 02110-1301, USA. |
| * |
| * You can also choose to distribute this program under the terms of |
| * the Unmodified Binary Distribution Licence (as given in the file |
| * COPYING.UBDL), provided that you have satisfied its requirements. |
| */ |
| |
| FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); |
| |
| /**************************************************************************** |
| * |
| * This file provides the decompress() and decompress16() functions |
| * which can be called in order to decompress an LZMA-compressed |
| * image. The code is modelled on the public-domain "XZ Embedded" |
| * implementation as used by the Linux kernel. Symbol names are |
| * chosen to match the XZ Embedded implementation where possible, for |
| * ease of reference. |
| * |
| * This code is optimised for size rather than speed, since the amount |
| * of data to be decompressed is trivially small by modern standards. |
| * |
| * The same basic assembly code is used to compile both decompress() |
| * and decompress16(). |
| * |
| * Note that these functions require large amounts of stack space. |
| * |
| **************************************************************************** |
| */ |
| |
| .text |
| .arch i486 |
| .section ".prefix.lib", "ax", @progbits |
| |
| #ifdef CODE16 |
| #define ADDR16 |
| #define ADDR32 addr32 |
| #define decompress decompress16 |
| .code16 |
| #else /* CODE16 */ |
| #define ADDR16 addr16 |
| #define ADDR32 |
| .code32 |
| #endif /* CODE16 */ |
| |
| #define CRCPOLY 0xedb88320 |
| #define CRCSEED 0xffffffff |
| |
| /**************************************************************************** |
| * Debugging |
| **************************************************************************** |
| * |
| * This code will usually run in 16-bit protected mode, in which case |
| * only the 0xe9 debug port (present on some virtual machines) can be |
| * used. |
| * |
| * To debug on real hardware, build with DEBUG=libprefix. This will |
| * cause this code to be called in flat real mode, and so DEBUG_INT10 |
| * may be used. |
| */ |
| |
| /* Enable debugging via 0xe9 debug port */ |
| #define DEBUG_E9 0 |
| |
| /* Enable debugging via BIOS INT 10 (works only when in flat real mode) */ |
| #define DEBUG_INT10 0 |
| |
| #if ( DEBUG_E9 || DEBUG_INT10 ) |
| .macro print_character, reg |
| pushfl |
| pushw %ax |
| pushw %bx |
| pushw %bp |
| movb \reg, %al |
| movw $0x0007, %bx |
| movb $0x0e, %ah |
| #if DEBUG_E9 |
| outb %al, $0xe9 |
| #endif |
| #if DEBUG_INT10 |
| cmpb $('\n'), %al |
| jne L\@ |
| int $0x10 |
| movb $('\r'), %al |
| L\@: int $0x10 |
| #endif |
| popw %bp |
| popw %bx |
| popw %ax |
| popfl |
| .endm |
| |
| .macro print_hex_nibble |
| pushfl |
| pushw %ax |
| cmpb $10, %al |
| sbb $0x69, %al |
| das |
| print_character %al |
| popw %ax |
| popfl |
| .endm |
| |
| .macro print_hex_byte, reg |
| pushfl |
| pushw %ax |
| movb \reg, %al |
| pushw %ax |
| shrb $4, %al |
| print_hex_nibble |
| popw %ax |
| andb $0x0f, %al |
| print_hex_nibble |
| popw %ax |
| popfl |
| .endm |
| |
| .macro print_hex_word, reg |
| pushw %ax |
| movw \reg, %ax |
| print_hex_byte %ah |
| print_hex_byte %al |
| popw %ax |
| .endm |
| |
| .macro print_hex_dword, reg |
| pushl %eax |
| movl \reg, %eax |
| rorl $16, %eax |
| print_hex_word %ax |
| rorl $16, %eax |
| print_hex_word %ax |
| popl %eax |
| .endm |
| #else |
| .macro print_character, char |
| .endm |
| .macro print_hex_byte, reg |
| .endm |
| .macro print_hex_word, reg |
| .endm |
| .macro print_hex_dword, reg |
| .endm |
| #endif |
| |
| /**************************************************************************** |
| * LZMA parameters and data structures |
| **************************************************************************** |
| */ |
| |
| /* LZMA decompressor states (as used in XZ Embedded) */ |
| #define STATE_LIT_LIT 0x00 |
| #define STATE_MATCH_LIT_LIT 0x01 |
| #define STATE_REP_LIT_LIT 0x02 |
| #define STATE_SHORTREP_LIT_LIT 0x03 |
| #define STATE_MATCH_LIT 0x04 |
| #define STATE_REP_LIT 0x05 |
| #define STATE_SHORTREP_LIT 0x06 |
| #define STATE_LIT_MATCH 0x07 |
| #define STATE_LIT_LONGREP 0x08 |
| #define STATE_LIT_SHORTREP 0x09 |
| #define STATE_NONLIT_MATCH 0x0a |
| #define STATE_NONLIT_REP 0x0b |
| |
| /* LZMA maximum decompressor state in which most recent symbol was a literal */ |
| #define STATE_LIT_MAX 0x06 |
| |
| /* LZMA number of literal context bits ("lc=" parameter) */ |
| #define LZMA_LC 2 |
| |
| .struct 0 |
| lzma_len_dec: |
| choice: .word 0 |
| choice2: .word 0 |
| low: .rept ( 1 << 3 ) |
| .word 0 |
| .endr |
| mid: .rept ( 1 << 3 ) |
| .word 0 |
| .endr |
| high: .rept ( 1 << 8 ) |
| .word 0 |
| .endr |
| .equ sizeof__lzma_len_dec, . - lzma_len_dec |
| .previous |
| |
| .struct 0 |
| lzma_dec: |
| out_start: .long 0 |
| rc_code: .long 0 |
| rc_range: .long 0 |
| len: .word 0 |
| reps: |
| rep0: .long 0 |
| rep1: .long 0 |
| rep2: .long 0 |
| rep3: .long 0 |
| probs: |
| is_match: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| is_rep: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| is_rep0: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| is_rep1: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| is_rep2: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| is_rep0_long: .word 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 |
| dist_slot: .rept ( 4 * ( 1 << 6 ) ) |
| .word 0 |
| .endr |
| dist_special: .rept ( ( 1 << ( 14 / 2 ) ) - 14 ) |
| .word 0 |
| .endr |
| dist_align: .rept ( 1 << 4 ) |
| .word 0 |
| .endr |
| match_len_dec: .space sizeof__lzma_len_dec |
| rep_len_dec: .space sizeof__lzma_len_dec |
| literal: .rept ( ( 1 << LZMA_LC ) * 0x300 ) |
| .word 0 |
| .endr |
| .balign 4 |
| .equ sizeof__lzma_dec, . - lzma_dec |
| .previous |
| |
| /* Some binutils versions seem not to handle .struct/.previous */ |
| .section ".prefix.lib", "ax", @progbits |
| |
| /***************************************************************************** |
| * Normalise range encoder |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %eax : current range |
| ***************************************************************************** |
| */ |
| rc_normalise: |
| /* Check if rc_range is less than 1<<24 */ |
| testb $0xff, (rc_range+3)(%ebp) |
| jnz 1f |
| /* If it is, shift in a new byte from the compressed input data */ |
| shll $8, rc_range(%ebp) |
| shll $8, rc_code(%ebp) |
| ADDR32 lodsb |
| movb %al, (rc_code+0)(%ebp) |
| 1: /* Return current range */ |
| movl rc_range(%ebp), %eax |
| ret |
| .size rc_normalise, . - rc_normalise |
| |
| /***************************************************************************** |
| * Decode single range-encoded bit using a probability estimate |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %ebx : probability estimate pointer (offset from %ebp) |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * CF : decoded bit |
| * ZF : inverse of decoded bit |
| * Corrupts: |
| * none |
| ***************************************************************************** |
| */ |
| rc_bit: |
| /* Preserve registers */ |
| pushl %eax |
| pushl %edx |
| /* Perform normalisation */ |
| call rc_normalise |
| /* Calculate bound in %eax and probability estimate in %dx */ |
| shrl $11, %eax |
| movzwl (%ebp,%ebx), %edx |
| mul %edx /* will zero %edx */ |
| movw (%ebp,%ebx), %dx |
| /* Compare code against bound */ |
| cmpl %eax, rc_code(%ebp) |
| jae 2f |
| 1: /* Code is less than bound */ |
| movl %eax, rc_range(%ebp) |
| negw %dx |
| addw $(1<<11), %dx |
| shrw $5, %dx |
| addw %dx, (%ebp,%ebx) |
| xorw %ax, %ax /* Clear CF, set ZF */ |
| jmp 99f |
| 2: /* Code is greater than or equal to bound */ |
| subl %eax, rc_range(%ebp) |
| subl %eax, rc_code(%ebp) |
| shrw $5, %dx |
| subw %dx, (%ebp,%ebx) |
| incw %dx /* Clear ZF (%dx is 11-bit; can never wrap) */ |
| stc /* Set CF */ |
| 99: /* Restore registers and return */ |
| popl %edx |
| popl %eax |
| ret |
| .size rc_bit, . - rc_bit |
| |
| /***************************************************************************** |
| * Decode MSB-first bittree |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %ebx : probability estimate set pointer (offset from %ebp) |
| * %cx : number of bits to decode |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %eax : decoded bittree |
| * Corrupts: |
| * none |
| ***************************************************************************** |
| */ |
| rc_bittree: |
| /* Preserve registers */ |
| pushl %edi |
| pushw %cx |
| movl %ebx, %edi |
| /* Initialise registers */ |
| movl $1, %eax |
| 1: /* Decode bit */ |
| leaw (%edi,%eax,2), %bx /* high word always zero anyway */ |
| call rc_bit |
| rclw %ax |
| ADDR16 loop 1b |
| /* Restore registers, clear unwanted high bit of result, and return */ |
| movl %edi, %ebx |
| popw %cx |
| popl %edi |
| btrw %cx, %ax |
| ret |
| .size rc_bittree, . - rc_bittree |
| |
| /***************************************************************************** |
| * Decode LSB-first bittree |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %ebx : probability estimate set pointer (offset from %ebp) |
| * %cx : number of bits to decode |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %eax : decoded bittree |
| * Corrupts: |
| * none |
| ***************************************************************************** |
| */ |
| rc_bittree_reverse: |
| /* Preserve registers */ |
| pushw %cx |
| /* Decode bittree */ |
| call rc_bittree |
| 1: /* Reverse result */ |
| rcrb %al |
| rclb %ah |
| ADDR16 loop 1b |
| shrw $8, %ax |
| /* Restore registers and return */ |
| popw %cx |
| ret |
| .size rc_bittree_reverse, . - rc_bittree_reverse |
| |
| /***************************************************************************** |
| * Decode MSB-first bittree with optional match byte |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %ebx : probability estimate set pointer (offset from %ebp) |
| * %cl : match byte |
| * %ch : 1 to use match byte, 0 to ignore match byte |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %eax : decoded bittree |
| * Corrupts: |
| * none |
| ***************************************************************************** |
| */ |
| rc_bittree_match: |
| /* Preserve registers */ |
| pushl %edi |
| pushw %cx |
| pushw %dx |
| movl %ebx, %edi |
| /* Initialise registers */ |
| movl $1, %eax |
| 1: /* Decode bit */ |
| rolb $1, %cl |
| movw %cx, %dx |
| andb %dh, %dl /* match_bit in %dl */ |
| movw %dx, %bx |
| addb %bl, %bh |
| xorb %bl, %bl |
| addw %ax, %bx /* offset + match_bit + symbol */ |
| leaw (%edi,%ebx,2), %bx /* high word always zero anyway */ |
| call rc_bit |
| rclw %ax |
| movb %al, %dh |
| notb %dh |
| xorb %dh, %dl |
| andb %dl, %ch /* offset &= ( match_bit ^ bit ) */ |
| testb %ah, %ah |
| jz 1b |
| /* Restore registers, clear unwanted high bit of result, and return */ |
| movl %edi, %ebx |
| popw %dx |
| popw %cx |
| popl %edi |
| xorb %ah, %ah |
| ret |
| .size rc_bittree_match, . - rc_bittree_match |
| |
| /***************************************************************************** |
| * Decode direct bits (no probability estimates) |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %cx : number of bits to decode |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %eax : decoded bits |
| * Corrupts: |
| * none |
| ***************************************************************************** |
| */ |
| rc_direct: |
| /* Preserve registers */ |
| pushl %ebx |
| pushw %cx |
| pushl %edx |
| /* Initialise registers */ |
| xorl %edx, %edx |
| 1: /* Perform normalisation */ |
| call rc_normalise |
| /* Decode bit */ |
| shrl $1, %eax |
| movl %eax, rc_range(%ebp) |
| movl rc_code(%ebp), %ebx |
| subl %eax, %ebx |
| js 2f |
| movl %ebx, rc_code(%ebp) |
| 2: rcll %ebx |
| rcll %edx |
| xorb $1, %dl |
| ADDR16 loop 1b |
| /* Restore registers and return */ |
| movl %edx, %eax |
| popl %edx |
| popw %cx |
| popl %ebx |
| ret |
| .size rc_direct, . - rc_direct |
| |
| /***************************************************************************** |
| * Decode an LZMA literal |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %es:%edi : uncompressed output data pointer (updated) |
| * %edx : LZMA state |
| * CF : end of payload marker found (always zero) |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| ***************************************************************************** |
| * |
| * Literals are coded as an eight-bit tree, using a match byte if the |
| * previous symbol was not a literal. |
| * |
| */ |
| lzma_literal: |
| /* Get most recent output byte, if available */ |
| xorl %ebx, %ebx |
| cmpl %edi, out_start(%ebp) |
| je 1f |
| movb %es:-1(%edi), %bh |
| 1: /* Locate probability estimate set */ |
| shrb $( 8 - LZMA_LC ), %bh |
| shlb $1, %bh |
| leaw literal(%ebx,%ebx,2), %bx |
| /* Get match byte, if applicable */ |
| xorw %cx, %cx |
| cmpb $STATE_LIT_MAX, %dl |
| jbe 1f |
| movl rep0(%ebp), %eax |
| notl %eax |
| movb %es:(%edi,%eax), %cl |
| movb $1, %ch |
| 1: /* Decode bittree */ |
| call rc_bittree_match |
| /* Store output byte */ |
| ADDR32 stosb |
| print_hex_byte %al |
| print_character $(' ') |
| /* Update LZMA state */ |
| subb $3, %dl |
| jns 1f |
| xorb %dl, %dl |
| 1: cmpb $7, %dl |
| jb 1f |
| subb $3, %dl |
| 1: /* Clear CF and return */ |
| clc |
| ret |
| .size lzma_literal, . - lzma_literal |
| |
| /***************************************************************************** |
| * Decode an LZMA length |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %ebx : length parameter pointer (offset from %ebp) |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * Corrupts: |
| * %ebx |
| ***************************************************************************** |
| * |
| * Lengths are encoded as: |
| * |
| * "0" + 3 bits : lengths 2-9 ("low") |
| * "10" + 3 bits : lengths 10-17 ("mid") |
| * "11" + 8 bits : lengths 18-273 ("high") |
| */ |
| lzma_len: |
| /* Preserve registers */ |
| pushl %eax |
| pushl %ecx |
| pushl %edi |
| movl %ebx, %edi |
| /* Start by assuming three bits and a base length of 2 */ |
| movw $3, %cx |
| movw $2, len(%ebp) |
| /* Check low-length choice bit */ |
| leal choice(%edi), %ebx |
| call rc_bit |
| leal low(%edi), %ebx |
| jz 1f |
| /* Check high-length choice bit */ |
| leal choice2(%edi), %ebx |
| call rc_bit |
| leal mid(%edi), %ebx |
| movb $10, len(%ebp) |
| jz 1f |
| leal high(%edi), %ebx |
| movb $8, %cl |
| movb $18, len(%ebp) |
| 1: /* Get encoded length */ |
| call rc_bittree |
| addw %ax, len(%ebp) |
| /* Restore registers and return */ |
| movl %edi, %ebx |
| popl %edi |
| popl %ecx |
| popl %eax |
| ret |
| .size lzma_len, . - lzma_len |
| |
| /***************************************************************************** |
| * Copy (possibly repeated) matched data |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %es:%edi : uncompressed output data pointer |
| * %cl : repeated match distance index (for repeated matches) |
| * %eax : match distance (for non-repeated matches) |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %es:%edi : uncompressed output data pointer |
| * CF : match distance is out of range |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| ***************************************************************************** |
| */ |
| match: /* Update repeated match list */ |
| print_character $('[') |
| movl $3, %ecx |
| jmp 1f |
| match_rep: |
| print_character $('[') |
| print_character $('R') |
| print_hex_byte %cl |
| print_character $('=') |
| movzbl %cl, %ecx |
| movl reps(%ebp,%ecx,4), %eax |
| jcxz 2f |
| 1: movl (reps-4)(%ebp,%ecx,4), %ebx |
| movl %ebx, reps(%ebp,%ecx,4) |
| loop 1b |
| movl %eax, rep0(%ebp) |
| 2: /* Preserve registers */ |
| pushl %esi |
| /* Get stored match length */ |
| movzwl len(%ebp), %ecx |
| print_hex_dword %eax |
| print_character $('+') |
| print_hex_word %cx |
| print_character $(']') |
| print_character $(' ') |
| /* Abort with CF set if match distance is out of range */ |
| movl out_start(%ebp), %esi |
| negl %esi |
| leal -1(%edi,%esi), %esi |
| cmpl %eax, %esi |
| jc 99f |
| /* Perform copy */ |
| notl %eax |
| leal (%edi,%eax), %esi |
| ADDR32 es rep movsb |
| 99: /* Restore registers and return */ |
| popl %esi |
| ret |
| .size match, . - match |
| |
| /***************************************************************************** |
| * Decode an LZMA match |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * CF : end of payload marker found |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| ***************************************************************************** |
| * |
| * Matches are encoded as an LZMA length followed by a 6-bit "distance |
| * slot" code, 0-26 fixed-probability bits, and 0-5 context encoded |
| * bits. |
| */ |
| lzma_match: |
| /* Preserve registers */ |
| pushl %edi |
| /* Update LZMA state */ |
| cmpb $STATE_LIT_MAX, %dl |
| movb $STATE_LIT_MATCH, %dl |
| jbe 1f |
| movb $STATE_NONLIT_MATCH, %dl |
| 1: /* Decode length */ |
| movl $match_len_dec, %ebx |
| call lzma_len |
| /* Decode distance slot */ |
| movw len(%ebp), %bx |
| subw $2, %bx |
| cmpw $4, %bx |
| jb 1f |
| movw $3, %bx |
| 1: shlw $7, %bx |
| addw $dist_slot, %bx |
| movw $6, %cx |
| call rc_bittree |
| /* Distance slots 0-3 are literal distances */ |
| cmpb $4, %al |
| jb 99f |
| /* Determine initial bits: 10/11 for even/odd distance codes */ |
| movl %eax, %edi |
| andw $1, %di |
| orw $2, %di |
| /* Determine number of context-encoded bits */ |
| movw %ax, %cx |
| shrb $1, %cl |
| decb %cl |
| /* Select context to be used in absence of fixed-probability bits */ |
| movl %edi, %ebx |
| shlw %cl, %bx |
| subw %ax, %bx |
| leaw (dist_special-2)(%ebx,%ebx), %bx |
| /* Decode fixed-probability bits, if any */ |
| cmpb $6, %cl |
| jb 1f |
| subb $4, %cl |
| shll %cl, %edi |
| call rc_direct |
| orl %eax, %edi |
| /* Select context to be used in presence of fixed-probability bits */ |
| movb $4, %cl |
| movl $dist_align, %ebx |
| 1: /* Decode context-encoded bits */ |
| shll %cl, %edi |
| call rc_bittree_reverse |
| orl %edi, %eax |
| 99: /* Restore registers and tail-call */ |
| popl %edi |
| jmp match |
| .size lzma_match, . - lzma_match |
| |
| /***************************************************************************** |
| * Decode an LZMA repeated match |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * CF : end of payload marker found |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| ***************************************************************************** |
| * |
| * Repeated matches are encoded as: |
| * |
| * "00" : shortrep0 (implicit length 1) |
| * "01" + len : longrep0 |
| * "10" + len : longrep1 |
| * "110" + len : longrep2 |
| * "111" + len : longrep3 |
| */ |
| lzma_rep_match: |
| /* Initially assume longrep0 */ |
| movw $(STATE_LIT_LONGREP << 8), %cx |
| /* Get is_rep0 bit */ |
| leal is_rep0(,%edx,2), %ebx |
| call rc_bit |
| jnz 1f |
| /* Get is_rep0_long bit */ |
| leal is_rep0_long(,%edx,2), %ebx |
| call rc_bit |
| jnz 98f |
| movw $1, len(%ebp) |
| movb $STATE_LIT_SHORTREP, %ch |
| jmp 99f |
| 1: /* Get is_rep1 bit */ |
| incb %cl |
| leal is_rep1(,%edx,2), %ebx |
| call rc_bit |
| jz 98f |
| /* Get is_rep2 bit */ |
| incb %cl |
| leal is_rep2(,%edx,2), %ebx |
| call rc_bit |
| adcb $0, %cl |
| 98: /* Decode length */ |
| movl $rep_len_dec, %ebx |
| call lzma_len |
| 99: /* Update LZMA state */ |
| cmpb $STATE_LIT_MAX, %dl |
| movb %ch, %dl |
| jbe 1f |
| movb $STATE_NONLIT_REP, %dl |
| 1: /* Tail call */ |
| jmp match_rep |
| .size lzma_match, . - lzma_match |
| |
| /***************************************************************************** |
| * Decode one LZMA symbol |
| * |
| * Parameters: |
| * %ss:%ebp : LZMA parameter block |
| * %ds:%esi : compressed input data pointer |
| * %es:%edi : uncompressed output data pointer |
| * %edx : LZMA state |
| * Returns: |
| * %ds:%esi : compressed input data pointer (possibly updated) |
| * %es:%edi : uncompressed output data pointer (updated) |
| * %edx : LZMA state |
| * CF : end of payload marker found |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| ***************************************************************************** |
| */ |
| lzma_decode: |
| /* Get is_match bit */ |
| leal is_match(,%edx,2), %ebx |
| call rc_bit |
| jz lzma_literal |
| /* Get is_rep bit */ |
| leal is_rep(,%edx,2), %ebx |
| call rc_bit |
| jz lzma_match |
| jmp lzma_rep_match |
| .size lzma_decode, . - lzma_decode |
| |
| /**************************************************************************** |
| * Undo effect of branch-call-jump (BCJ) filter |
| * |
| * Parameters: |
| * %es:%esi : start of uncompressed output data (note %es) |
| * %es:%edi : end of uncompressed output data |
| * Returns: |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| * %edx |
| * %esi |
| ***************************************************************************** |
| */ |
| bcj_filter: |
| /* Store (negative) start of data in %edx */ |
| movl %esi, %edx |
| negl %edx |
| /* Calculate limit in %ecx */ |
| leal -5(%edi,%edx), %ecx |
| 1: /* Calculate offset in %ebx */ |
| leal (%esi,%edx), %ebx |
| /* Check for end of data */ |
| cmpl %ecx, %ebx |
| ja 99f |
| /* Check for an opcode which would be followed by a rel32 address */ |
| ADDR32 es lodsb |
| andb $0xfe, %al |
| cmpb $0xe8, %al |
| jne 1b |
| /* Get current jump target value in %eax */ |
| ADDR32 es lodsl |
| /* Convert absolute addresses in the range [0,limit) back to |
| * relative addresses in the range [-offset,limit-offset). |
| */ |
| cmpl %ecx, %eax |
| jae 2f |
| subl %ebx,%es:-4(%esi) |
| 2: /* Convert negative numbers in the range [-offset,0) back to |
| * positive numbers in the range [limit-offset,limit). |
| */ |
| notl %eax /* Range is now [0,offset) */ |
| cmpl %ebx, %eax |
| jae 1b |
| addl %ecx,%es:-4(%esi) |
| jmp 1b |
| 99: /* Return */ |
| ret |
| .size bcj_filter, . - bcj_filter |
| |
| /**************************************************************************** |
| * Verify CRC32 |
| * |
| * Parameters: |
| * %ds:%esi : Start of compressed input data |
| * %edx : Length of compressed input data (including CRC) |
| * Returns: |
| * CF clear if CRC32 is zero |
| * All other registers are preserved |
| * Corrupts: |
| * %eax |
| * %ebx |
| * %ecx |
| * %edx |
| * %esi |
| **************************************************************************** |
| */ |
| verify_crc32: |
| /* Calculate CRC */ |
| addl %esi, %edx |
| movl $CRCSEED, %ebx |
| 1: ADDR32 lodsb |
| xorb %al, %bl |
| movw $8, %cx |
| 2: rcrl %ebx |
| jnc 3f |
| xorl $CRCPOLY, %ebx |
| 3: ADDR16 loop 2b |
| cmpl %esi, %edx |
| jne 1b |
| /* Set CF if result is nonzero */ |
| testl %ebx, %ebx |
| jz 1f |
| stc |
| 1: /* Return */ |
| ret |
| .size verify_crc32, . - verify_crc32 |
| |
| /**************************************************************************** |
| * decompress (real-mode or 16/32-bit protected-mode near call) |
| * |
| * Decompress data |
| * |
| * Parameters (passed via registers): |
| * %ds:%esi : Start of compressed input data |
| * %es:%edi : Start of output buffer |
| * Returns: |
| * %ds:%esi - End of compressed input data |
| * %es:%edi - End of decompressed output data |
| * CF set if CRC32 was incorrect |
| * All other registers are preserved |
| * |
| * NOTE: It would be possible to build a smaller version of the |
| * decompression code for -DKEEP_IT_REAL by using 16-bit registers |
| * where possible. |
| **************************************************************************** |
| */ |
| .globl decompress |
| decompress: |
| /* Preserve registers */ |
| pushl %eax |
| pushl %ebx |
| pushl %ecx |
| pushl %edx |
| pushl %ebp |
| /* Verify CRC32 */ |
| ADDR32 lodsl |
| movl %eax, %edx |
| pushl %esi |
| call verify_crc32 |
| popl %esi |
| jc 99f |
| /* Allocate parameter block */ |
| subl $sizeof__lzma_dec, %esp |
| movl %esp, %ebp |
| /* Zero parameter block and set all probabilities to 0.5 */ |
| pushl %edi |
| pushw %es |
| pushw %ss |
| popw %es |
| movl %ebp, %edi |
| xorl %eax, %eax |
| movl $( sizeof__lzma_dec / 4 ), %ecx |
| ADDR32 rep stosl |
| leal probs(%ebp), %edi |
| movw $( ( 1 << 11 ) / 2 ), %ax |
| movl $( ( sizeof__lzma_dec - probs ) / 2 ), %ecx |
| ADDR32 rep stosw |
| popw %es |
| popl %edi |
| /* Initialise remaining parameters */ |
| movl %edi, out_start(%ebp) |
| print_character $('\n') |
| ADDR32 lodsb /* discard initial byte */ |
| print_hex_byte %al |
| ADDR32 lodsl |
| bswapl %eax |
| print_hex_dword %eax |
| print_character $('\n') |
| movl %eax, rc_code(%ebp) |
| decl rc_range(%ebp) |
| movl $STATE_LIT_LIT, %edx |
| 1: /* Decompress until we reach end of buffer */ |
| call lzma_decode |
| jnc 1b |
| call rc_normalise |
| print_character $('\n') |
| /* Undo BCJ filter */ |
| pushl %esi |
| movl out_start(%ebp), %esi |
| call bcj_filter |
| popl %esi |
| /* Skip CRC */ |
| ADDR32 lodsl |
| /* Free parameter block (and clear CF) */ |
| addl $sizeof__lzma_dec, %esp |
| 99: /* Restore registers and return */ |
| popl %ebp |
| popl %edx |
| popl %ecx |
| popl %ebx |
| popl %eax |
| ret |
| |
| /* Specify minimum amount of stack space required */ |
| .globl _min_decompress_stack |
| .equ _min_decompress_stack, ( sizeof__lzma_dec + 512 /* margin */ ) |
