zlib 1.0.7v1.0.7

1 files changed, 464 insertions, 0 deletions

diff --git a/contrib/asm386/gvmat32.asm b/contrib/asm386/gvmat32.asm
new file mode 100644
index 0000000..b175871
--- /dev/null
+++ b/contrib/asm386/gvmat32.asm
@@ -0,0 +1,464 @@
+;
+; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
+; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
+; File written by Gilles Vollant, by modifiying the longest_match
+;  from Jean-loup Gailly in deflate.c
+; It need wmask == 0x7fff
+;     (assembly code is faster with a fixed wmask)
+;
+; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
+;   I compile with : "ml /coff /Zi /c gvmat32.asm"
+;
+; uInt longest_match_gvasm(IPos cur_match,int* match_start_ptr,uInt scan_end,
+;                          uInt scan_start,ush* prev,uch* window,int best_len,
+;                          IPos limit,uInt chain_length,uch* scanrp,
+;                          uInt nice_match);
+
+;uInt longest_match(s, cur_match)
+;    deflate_state *s;
+;    IPos cur_match;                             /* current match */
+
+        NbStack         equ     76
+        cur_match       equ     dword ptr[esp+NbStack-0]
+        str_s           equ     dword ptr[esp+NbStack-4]
+        ; 5 dword on top (ret,ebp,esi,edi,ebx)
+        adrret          equ     dword ptr[esp+NbStack-8]
+        pushebp         equ     dword ptr[esp+NbStack-12]
+        pushedi         equ     dword ptr[esp+NbStack-16]
+        pushesi         equ     dword ptr[esp+NbStack-20]
+        pushebx         equ     dword ptr[esp+NbStack-24]
+
+        chain_length    equ dword ptr [esp+NbStack-28]
+        limit           equ dword ptr [esp+NbStack-32]
+        best_len        equ dword ptr [esp+NbStack-36]
+        window          equ dword ptr [esp+NbStack-40]
+        prev            equ dword ptr [esp+NbStack-44]
+        scan_start      equ  word ptr [esp+NbStack-48]
+        scan_end        equ  word ptr [esp+NbStack-52]
+        match_start_ptr equ dword ptr [esp+NbStack-56]
+        nice_match      equ dword ptr [esp+NbStack-60]
+        scanrp          equ dword ptr [esp+NbStack-64]
+
+        windowlen       equ dword ptr [esp+NbStack-68]
+        match_start     equ dword ptr [esp+NbStack-72]
+        strend                  equ dword ptr [esp+NbStack-76]
+        NbStackAdd              equ     (76-24)
+
+    .386p
+
+    name    gvmatch
+    .MODEL  FLAT
+
+
+@lmtype                         TYPEDEF         PROTO C :PTR , :SDWORD
+longest_match_c         PROTO           @lmtype
+
+        dep_max_chain_length    equ     70h
+        dep_window                              equ     2ch
+        dep_strstart                    equ     60h
+        dep_prev_length                 equ 6ch
+        dep_nice_match                  equ 84h
+        dep_w_size                              equ     20h
+        dep_prev                                equ     34h
+        dep_w_mask                              equ     28h
+        dep_good_match                  equ 80h
+        dep_match_start                 equ     64h
+        dep_lookahead                   equ     68h
+
+
+_TEXT   segment
+    public  _longest_match_asm7fff
+
+    MAX_MATCH           equ 258
+        MIN_MATCH               equ 3
+        MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
+
+; initialize or check the variables used in match.asm.
+
+
+; -----------------------------------------------------------------------
+; Set match_start to the longest match starting at the given string and
+; return its length. Matches shorter or equal to prev_length are discarded,
+; in which case the result is equal to prev_length and match_start is
+; garbage.
+; IN assertions: cur_match is the head of the hash chain for the current
+;   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+
+; int longest_match(cur_match)
+
+_longest_match_asm7fff proc near
+
+
+
+            ; return address
+
+                mov             eax,[esp+4]
+                mov             bx,[eax+dep_w_mask]
+                cmp             bx,7fffh
+                jnz             longest_match_c
+
+            push    ebp             
+            push    edi             
+            push    esi             
+            push    ebx             
+
+            sub     esp,NbStackAdd
+
+                ;//mov          ebp,str_s
+                mov             ebp,eax
+
+                mov             eax,[ebp+dep_max_chain_length]
+                mov             ebx,[ebp+dep_prev_length]
+                cmp             [ebp+dep_good_match],ebx        ; if prev_length>=good_match chain_length >>= 2
+                ja              noshr           
+                shr             eax,2
+noshr:
+                mov             edi,[ebp+dep_nice_match]
+                mov             chain_length,eax
+                mov             edx,[ebp+dep_lookahead]
+                cmp             edx,edi
+;if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+                jae             nolookaheadnicematch
+                mov             edi,edx
+nolookaheadnicematch:
+                mov             best_len,ebx
+
+
+                mov             esi,[ebp+dep_window]
+                mov             ecx,[ebp+dep_strstart]
+                mov             window,esi
+                
+                mov             nice_match,edi
+                add             esi,ecx
+                mov             scanrp,esi
+                mov             ax,word ptr [esi]
+                mov             bx,word ptr [esi+ebx-1]
+                add             esi,MAX_MATCH-1
+                mov             scan_start,ax
+                mov             strend,esi
+                mov             scan_end,bx
+
+;    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+;        s->strstart - (IPos)MAX_DIST(s) : NIL;
+
+                mov             esi,[ebp+dep_w_size]
+                sub             esi,MIN_LOOKAHEAD
+                ; here esi = MAX_DIST(s)
+                sub             ecx,esi
+                ja              nodist
+                xor             ecx,ecx
+nodist:
+                mov             limit,ecx
+
+
+
+
+                mov             eax,[ebp+dep_prev]
+                mov             prev,eax
+
+            mov     ebx,dword ptr [ebp+dep_match_start]
+            mov     bp,scan_start
+            mov     edx,cur_match
+            mov     match_start,ebx
+
+            mov     bx,scan_end
+            mov     eax,window
+                mov             edi,eax
+            add     edi,best_len
+            mov     esi,prev
+                dec     edi
+            mov     windowlen,edi
+            
+            jmp     beginloop2
+            align   4
+
+; here, in the loop
+;;;;       eax = chain_length
+;       edx = dx = cur_match
+;       ecx = limit
+;        bx = scan_end
+;        bp = scan_start
+;       edi = windowlen (window + best_len)
+;       esi = prev
+
+
+;// here; eax <=16
+normalbeg0add16: 
+                add             chain_length,16
+                jz              exitloop
+normalbeg0: 
+            cmp     word ptr[edi+edx-0],bx
+            je      normalbeg2
+            and     edx,7fffh
+            mov     dx,word ptr[esi+edx*2]
+            cmp     ecx,edx
+            jnb     exitloop
+            dec     chain_length
+                jnz             normalbeg0
+;jnbexitloopshort1:
+                jmp     exitloop
+
+contloop3:
+            mov     edi,windowlen
+
+; cur_match = prev[cur_match & wmask]
+            and         edx,7fffh
+            mov     dx,word ptr[esi+edx*2]
+; if cur_match > limit, go to exitloop
+            cmp     ecx,edx
+jnbexitloopshort1:
+            jnb     exitloop
+; if --chain_length != 0, go to exitloop
+
+beginloop2:
+                sub             chain_length,16+1
+                jna     normalbeg0add16
+
+do16:
+            cmp     word ptr[edi+edx],bx
+            je      normalbeg2dc0
+
+maccn   MACRO   lab
+            and     edx,7fffh
+            mov     dx,word ptr[esi+edx*2]
+            cmp     ecx,edx
+            jnb     exitloop
+            cmp     word ptr[edi+edx-0],bx
+            je      lab
+                ENDM
+
+rcontloop0:
+                maccn normalbeg2dc1
+
+rcontloop1:
+                maccn normalbeg2dc2
+
+rcontloop2:
+                maccn normalbeg2dc3
+
+rcontloop3:
+                maccn normalbeg2dc4
+
+rcontloop4:
+                maccn normalbeg2dc5
+
+rcontloop5:
+                maccn normalbeg2dc6
+
+rcontloop6:
+                maccn normalbeg2dc7
+
+rcontloop7:
+                maccn normalbeg2dc8
+
+rcontloop8:
+                maccn normalbeg2dc9
+
+rcontloop9:
+                maccn normalbeg2dc10
+
+rcontloop10:
+                maccn normalbeg2dc11
+
+rcontloop11:
+                maccn short normalbeg2dc12
+
+rcontloop12:
+                maccn short normalbeg2dc13
+
+rcontloop13:
+                maccn short normalbeg2dc14
+
+rcontloop14:
+                maccn short normalbeg2dc15
+
+rcontloop15:
+            and     edx,7fffh
+            mov     dx,word ptr[esi+edx*2]
+            cmp     ecx,edx
+            jnb     short exitloopshort
+
+                sub             chain_length,16
+                ja              do16
+                jmp             normalbeg0add16
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+exitloopshort:
+                jmp             exitloop                  
+
+normbeg MACRO   rcontlab,valsub
+            cmp     bp,word ptr[eax+edx]
+                jne             rcontlab
+                add     chain_length,16-valsub
+                jmp             iseq
+                ENDM
+
+normalbeg2dc12:
+                normbeg rcontloop12,12
+
+normalbeg2dc13:
+                normbeg rcontloop13,13
+
+normalbeg2dc14:
+                normbeg rcontloop14,14
+
+normalbeg2dc15:
+                normbeg rcontloop15,15
+
+normalbeg2dc11:
+                normbeg rcontloop11,11
+
+normalbeg2dc10:
+                normbeg rcontloop10,10
+
+
+normalbeg2dc9:
+                normbeg rcontloop9,9
+
+normalbeg2dc8:
+                normbeg rcontloop8,8
+
+normalbeg2dc7:
+                normbeg rcontloop7,7
+
+normalbeg2dc5:
+                normbeg rcontloop5,5
+
+
+
+
+
+normalbeg2dc6:
+                normbeg rcontloop6,6
+
+normalbeg2dc4:
+                normbeg rcontloop4,4
+
+normalbeg2dc3:
+                normbeg rcontloop3,3
+
+normalbeg2dc2:
+                normbeg rcontloop2,2
+
+normalbeg2dc1:
+                normbeg rcontloop1,1
+
+normalbeg2dc0:
+                normbeg rcontloop0,0
+
+
+; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
+
+normalbeg2:
+
+                         ; 10 nop here take 10% time
+                mov             edi,window
+                  ;mov     chain_length,eax    ; now, we need eax...
+                                        
+            cmp     bp,word ptr[edi+edx]
+            jne     contloop3                   ; if *(ushf*)match != scan_start, continue
+
+iseq:
+
+                mov             edi,eax
+            mov     esi,scanrp                  ; esi = scan    
+            add     edi,edx                             ; edi = window + cur_match = match
+
+                       
+            mov     eax,[esi+3]                                 ; compare manually dword at match+3
+            xor     eax,[edi+3]                 ;       and scan +3
+
+            jz      begincompare                ; if equal, go to long compare
+
+                        ; we will determine the unmatch byte and calculate len (in esi)
+                or              al,al
+                je              eq1rr
+            mov     esi,3
+            jmp     trfinval
+eq1rr:
+            or      ax,ax                               
+            je      eq1
+
+            mov     esi,4
+            jmp     trfinval
+eq1:
+            shl     eax,8
+            jz      eq11
+            mov     esi,5
+            jmp     trfinval
+eq11:
+            mov     esi,6
+            jmp     trfinval
+
+begincompare:
+                ; here we now scan and match begin same
+            add     edi,6
+            add     esi,6
+            mov     ecx,(MAX_MATCH-(2+4))/4     ;//; scan for at most MAX_MATCH bytes
+            repe    cmpsd                                               ;//; loop until mismatch
+
+            je      trfin                                               ; go to trfin if not unmatch
+                        ; we determine the unmatch byte
+            sub     esi,4
+            mov     eax,[edi-4]
+            xor     eax,[esi]
+            or      al,al
+
+            jnz     trfin
+            inc     esi
+
+            or      ax,ax
+            jnz     trfin
+            inc     esi
+
+            shl     eax,8           
+            jnz     trfin
+            inc     esi
+
+trfin:      
+            sub     esi,scanrp          ; esi = len
+trfinval:
+            cmp     esi,best_len        ; if len <= best_len, go contloop2
+            jbe     contloop2
+
+            mov     best_len,esi        ; len become best_len
+
+            mov     match_start,edx
+            cmp     esi,nice_match ;//; if esi >= nice_match, exit
+            mov     ecx,scanrp
+            jae     exitloop
+            add     esi,window
+            add     ecx,best_len
+                        dec             esi
+            mov     windowlen,esi
+            mov     bx,[ecx-1]
+
+
+; now we restore eax, ecx and esi, for the big loop :
+contloop2:
+            mov     esi,prev
+            mov     ecx,limit
+            ;mov     eax,chain_length
+                mov             eax,window
+            jmp     contloop3
+
+exitloop:        
+            mov     ebx,match_start
+                mov             ebp,str_s
+            mov     dword ptr [ebp+dep_match_start],ebx
+            mov     eax,best_len
+            add     esp,NbStackAdd
+
+
+            pop     ebx
+            pop     esi
+            pop     edi
+            pop     ebp 
+            ret
+
+_longest_match_asm7fff endp
+
+_TEXT   ends
+end
+                                        
\ No newline at end of file