You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
465 lines
10 KiB
465 lines
10 KiB
; |
|
; 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 |
|
|
|
; all the +4 offsets are due to the addition of pending_buf_size |
|
; in the deflate_state structure since the asm code was first written |
|
dep_chain_length equ 70h+4 |
|
dep_window equ 2ch+4 |
|
dep_strstart equ 60h+4 |
|
dep_prev_length equ 6ch+4 |
|
dep_nice_match equ 84h+4 |
|
dep_w_size equ 20h+4 |
|
dep_prev equ 34h+4 |
|
dep_w_mask equ 28h+4 |
|
dep_good_match equ 80h+4 |
|
dep_match_start equ 64h+4 |
|
dep_lookahead equ 68h+4 |
|
|
|
|
|
_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
|
|
|