src/arch/i386/prefix/unnrv2b.S

   1 /*
   2  * Copyright (C) 1996-2002 Markus Franz Xaver Johannes Oberhumer
   3  *
   4  * This file is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of
   7  * the License, or (at your option) any later version.
   8  *
   9  * Originally this code was part of ucl the data compression library
  10  * for upx the ``Ultimate Packer of eXecutables''.
  11  *
  12  * - Converted to gas assembly, and refitted to work with etherboot.
  13  *   Eric Biederman 20 Aug 2002
  14  *
  15  * - Structure modified to be a subroutine call rather than an
  16  *   executable prefix.
  17  *   Michael Brown 30 Mar 2004
  18  *
  19  * - Modified to be compilable as either 16-bit or 32-bit code.
  20  *   Michael Brown 9 Mar 2005
  21  */
  22
  23 FILE_LICENCE ( GPL2_OR_LATER )
  24
  25 /****************************************************************************
  26  * This file provides the decompress() and decompress16() functions
  27  * which can be called in order to decompress an image compressed with
  28  * the nrv2b utility in src/util.
  29  *
  30  * These functions are designed to be called by the prefix.  They are
  31  * position-independent code.
  32  *
  33  * The same basic assembly code is used to compile both
  34  * decompress() and decompress16().
  35  ****************************************************************************
  36  */
  37
  38         .text
  39         .arch i386
  40         .section ".prefix.lib", "ax", @progbits
  41
  42 #ifdef CODE16
  43 /****************************************************************************
  44  * decompress16 (real-mode near call, position independent)
  45  *
  46  * Decompress data in 16-bit mode
  47  *
  48  * Parameters (passed via registers):
  49  *   %ds:%esi - Start of compressed input data
  50  *   %es:%edi - Start of output buffer
  51  * Returns:
  52  *   %ds:%esi - End of compressed input data
  53  *   %es:%edi - End of decompressed output data
  54  *   All other registers are preserved
  55  *
  56  * NOTE: It would be possible to build a smaller version of the
  57  * decompression code for -DKEEP_IT_REAL by using
  58  *    #define REG(x) x
  59  * to use 16-bit registers where possible.  This would impose limits
  60  * that the compressed data size must be in the range [1,65533-%si]
  61  * and the uncompressed data size must be in the range [1,65536-%di]
  62  * (where %si and %di are the input values for those registers).  Note
  63  * particularly that the lower limit is 1, not 0, and that the upper
  64  * limit on the input (compressed) data really is 65533, since the
  65  * algorithm may read up to three bytes beyond the end of the input
  66  * data, since it reads dwords.
  67  ****************************************************************************
  68  */
  69
  70 #define REG(x) e ## x
  71 #define ADDR32 addr32
  72
  73         .code16
  74         .globl  decompress16
  75 decompress16:
  76
  77 #else /* CODE16 */
  78
  79 /****************************************************************************
  80  * decompress (32-bit protected-mode near call, position independent)
  81  *
  82  * Parameters (passed via registers):
  83  *   %ds:%esi - Start of compressed input data
  84  *   %es:%edi - Start of output buffer
  85  * Returns:
  86  *   %ds:%esi - End of compressed input data
  87  *   %es:%edi - End of decompressed output data
  88  *   All other registers are preserved
  89  ****************************************************************************
  90  */
  91
  92 #define REG(x) e ## x
  93 #define ADDR32
  94
  95         .code32
  96         .globl  decompress
  97 decompress:
  98
  99 #endif /* CODE16 */
 100
 101 #define xAX     REG(ax)
 102 #define xCX     REG(cx)
 103 #define xBP     REG(bp)
 104 #define xSI     REG(si)
 105 #define xDI     REG(di)
 106
 107         /* Save registers */
 108         push    %xAX
 109         pushl   %ebx
 110         push    %xCX
 111         push    %xBP
 112         /* Do the decompression */
 113         cld
 114         xor     %xBP, %xBP
 115         dec     %xBP            /* last_m_off = -1 */
 116         jmp     dcl1_n2b
 117
 118 decompr_literals_n2b:
 119         ADDR32 movsb
 120 decompr_loop_n2b:
 121         addl    %ebx, %ebx
 122         jnz     dcl2_n2b
 123 dcl1_n2b:
 124         call    getbit32
 125 dcl2_n2b:
 126         jc      decompr_literals_n2b
 127         xor     %xAX, %xAX
 128         inc     %xAX            /* m_off = 1 */
 129 loop1_n2b:
 130         call    getbit1
 131         adc     %xAX, %xAX      /* m_off = m_off*2 + getbit() */
 132         call    getbit1
 133         jnc     loop1_n2b       /* while(!getbit()) */
 134         sub     $3, %xAX
 135         jb      decompr_ebpeax_n2b      /* if (m_off == 2) goto decompr_ebpeax_n2b ? */
 136         shl     $8, %xAX
 137         ADDR32 movb (%xSI), %al /* m_off = (m_off - 3)*256 + src[ilen++] */
 138         inc     %xSI
 139         xor     $-1, %xAX
 140         jz      decompr_end_n2b /* if (m_off == 0xffffffff) goto decomp_end_n2b */
 141         mov     %xAX, %xBP      /* last_m_off = m_off ?*/
 142 decompr_ebpeax_n2b:
 143         xor     %xCX, %xCX
 144         call    getbit1
 145         adc     %xCX, %xCX      /* m_len = getbit() */
 146         call    getbit1
 147         adc     %xCX, %xCX      /* m_len = m_len*2 + getbit()) */
 148         jnz     decompr_got_mlen_n2b    /* if (m_len == 0) goto decompr_got_mlen_n2b */
 149         inc     %xCX            /* m_len++ */
 150 loop2_n2b:
 151         call    getbit1
 152         adc     %xCX, %xCX      /* m_len = m_len*2 + getbit() */
 153         call    getbit1
 154         jnc     loop2_n2b       /* while(!getbit()) */
 155         inc     %xCX
 156         inc     %xCX            /* m_len += 2 */
 157 decompr_got_mlen_n2b:
 158         cmp     $-0xd00, %xBP
 159         adc     $1, %xCX        /* m_len = m_len + 1 + (last_m_off > 0xd00) */
 160         push    %xSI
 161         ADDR32 lea (%xBP,%xDI), %xSI    /* m_pos = dst + olen + -m_off  */
 162         rep
 163         es ADDR32 movsb         /* dst[olen++] = *m_pos++ while(m_len > 0) */
 164         pop     %xSI
 165         jmp     decompr_loop_n2b
 166
 167
 168 getbit1:
 169         addl    %ebx, %ebx
 170         jnz     1f
 171 getbit32:
 172         ADDR32 movl (%xSI), %ebx
 173         sub     $-4, %xSI       /* sets carry flag */
 174         adcl    %ebx, %ebx
 175 1:
 176         ret
 177
 178 decompr_end_n2b:
 179         /* Restore registers and return */
 180         pop     %xBP
 181         pop     %xCX
 182         popl    %ebx
 183         pop     %xAX
 184         ret