560 lines
14 KiB
NASM
560 lines
14 KiB
NASM
;
|
||
; 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_7fff(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]
|
||
wmask equ dword ptr [esp+NbStack-52]
|
||
match_start_ptr equ dword ptr [esp+NbStack-56]
|
||
nice_match equ dword ptr [esp+NbStack-60]
|
||
scan 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 (NbStack-24)
|
||
|
||
.386p
|
||
|
||
name gvmatch
|
||
.MODEL FLAT
|
||
|
||
|
||
|
||
; all the +4 offsets are due to the addition of pending_buf_size (in zlib
|
||
; in the deflate_state structure since the asm code was first written
|
||
; (if you compile with zlib 1.0.4 or older, remove the +4).
|
||
; Note : these value are good with a 8 bytes boundary pack structure
|
||
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
|
||
|
||
IFDEF NOUNDERLINE
|
||
public longest_match_7fff
|
||
; public match_init
|
||
ELSE
|
||
public _longest_match_7fff
|
||
; public _match_init
|
||
ENDIF
|
||
|
||
MAX_MATCH equ 258
|
||
MIN_MATCH equ 3
|
||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
||
|
||
|
||
|
||
IFDEF NOUNDERLINE
|
||
;match_init proc near
|
||
; ret
|
||
;match_init endp
|
||
ELSE
|
||
;_match_init proc near
|
||
; ret
|
||
;_match_init endp
|
||
ENDIF
|
||
|
||
|
||
IFDEF NOUNDERLINE
|
||
longest_match_7fff proc near
|
||
ELSE
|
||
_longest_match_7fff proc near
|
||
ENDIF
|
||
|
||
mov edx,[esp+4]
|
||
|
||
|
||
|
||
push ebp
|
||
push edi
|
||
push esi
|
||
push ebx
|
||
|
||
sub esp,NbStackAdd
|
||
|
||
; initialize or check the variables used in match.asm.
|
||
mov ebp,edx
|
||
|
||
; chain_length = s->max_chain_length
|
||
; if (prev_length>=good_match) chain_length >>= 2
|
||
mov edx,[ebp+dep_chain_length]
|
||
mov ebx,[ebp+dep_prev_length]
|
||
cmp [ebp+dep_good_match],ebx
|
||
ja noshr
|
||
shr edx,2
|
||
noshr:
|
||
; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
|
||
inc edx
|
||
mov edi,[ebp+dep_nice_match]
|
||
mov chain_length,edx
|
||
mov eax,[ebp+dep_lookahead]
|
||
cmp eax,edi
|
||
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||
jae nolookaheadnicematch
|
||
mov edi,eax
|
||
nolookaheadnicematch:
|
||
; best_len = s->prev_length
|
||
mov best_len,ebx
|
||
|
||
; window = s->window
|
||
mov esi,[ebp+dep_window]
|
||
mov ecx,[ebp+dep_strstart]
|
||
mov window,esi
|
||
|
||
mov nice_match,edi
|
||
; scan = window + strstart
|
||
add esi,ecx
|
||
mov scan,esi
|
||
; dx = *window
|
||
mov dx,word ptr [esi]
|
||
; bx = *(window+best_len-1)
|
||
mov bx,word ptr [esi+ebx-1]
|
||
add esi,MAX_MATCH-1
|
||
; scan_start = *scan
|
||
mov scan_start,dx
|
||
; strend = scan + MAX_MATCH-1
|
||
mov strend,esi
|
||
; bx = scan_end = *(window+best_len-1)
|
||
|
||
; 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
|
||
|
||
; prev = s->prev
|
||
mov edx,[ebp+dep_prev]
|
||
mov prev,edx
|
||
|
||
;
|
||
mov edx,dword ptr [ebp+dep_match_start]
|
||
mov bp,scan_start
|
||
mov eax,cur_match
|
||
mov match_start,edx
|
||
|
||
mov edx,window
|
||
mov edi,edx
|
||
add edi,best_len
|
||
mov esi,prev
|
||
dec edi
|
||
; windowlen = window + best_len -1
|
||
mov windowlen,edi
|
||
|
||
jmp beginloop2
|
||
align 4
|
||
|
||
; here, in the loop
|
||
; eax = ax = cur_match
|
||
; ecx = limit
|
||
; bx = scan_end
|
||
; bp = scan_start
|
||
; edi = windowlen (window + best_len -1)
|
||
; esi = prev
|
||
|
||
|
||
;// here; chain_length <=16
|
||
normalbeg0add16:
|
||
add chain_length,16
|
||
jz exitloop
|
||
normalbeg0:
|
||
cmp word ptr[edi+eax],bx
|
||
je normalbeg2noroll
|
||
rcontlabnoroll:
|
||
; cur_match = prev[cur_match & wmask]
|
||
and eax,7fffh
|
||
mov ax,word ptr[esi+eax*2]
|
||
; if cur_match > limit, go to exitloop
|
||
cmp ecx,eax
|
||
jnb exitloop
|
||
; if --chain_length != 0, go to exitloop
|
||
dec chain_length
|
||
jnz normalbeg0
|
||
jmp exitloop
|
||
|
||
normalbeg2noroll:
|
||
; if (scan_start==*(cur_match+window)) goto normalbeg2
|
||
cmp bp,word ptr[edx+eax]
|
||
jne rcontlabnoroll
|
||
jmp normalbeg2
|
||
|
||
contloop3:
|
||
mov edi,windowlen
|
||
|
||
; cur_match = prev[cur_match & wmask]
|
||
and eax,7fffh
|
||
mov ax,word ptr[esi+eax*2]
|
||
; if cur_match > limit, go to exitloop
|
||
cmp ecx,eax
|
||
jnbexitloopshort1:
|
||
jnb exitloop
|
||
; if --chain_length != 0, go to exitloop
|
||
|
||
|
||
; begin the main loop
|
||
beginloop2:
|
||
sub chain_length,16+1
|
||
; if chain_length <=16, don't use the unrolled loop
|
||
jna normalbeg0add16
|
||
|
||
do16:
|
||
cmp word ptr[edi+eax],bx
|
||
je normalbeg2dc0
|
||
|
||
maccn MACRO lab
|
||
and eax,7fffh
|
||
mov ax,word ptr[esi+eax*2]
|
||
cmp ecx,eax
|
||
jnb exitloop
|
||
cmp word ptr[edi+eax],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 short normalbeg2dc11
|
||
|
||
rcontloop11:
|
||
maccn short normalbeg2dc12
|
||
|
||
rcontloop12:
|
||
maccn short normalbeg2dc13
|
||
|
||
rcontloop13:
|
||
maccn short normalbeg2dc14
|
||
|
||
rcontloop14:
|
||
maccn short normalbeg2dc15
|
||
|
||
rcontloop15:
|
||
and eax,7fffh
|
||
mov ax,word ptr[esi+eax*2]
|
||
cmp ecx,eax
|
||
jnb exitloop
|
||
|
||
sub chain_length,16
|
||
ja do16
|
||
jmp normalbeg0add16
|
||
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
|
||
normbeg MACRO rcontlab,valsub
|
||
; if we are here, we know that *(match+best_len-1) == scan_end
|
||
cmp bp,word ptr[edx+eax]
|
||
; if (match != scan_start) goto rcontlab
|
||
jne rcontlab
|
||
; calculate the good chain_length, and we'll compare scan and match string
|
||
add chain_length,16-valsub
|
||
jmp iseq
|
||
ENDM
|
||
|
||
|
||
normalbeg2dc11:
|
||
normbeg rcontloop11,11
|
||
|
||
normalbeg2dc12:
|
||
normbeg short rcontloop12,12
|
||
|
||
normalbeg2dc13:
|
||
normbeg short rcontloop13,13
|
||
|
||
normalbeg2dc14:
|
||
normbeg short rcontloop14,14
|
||
|
||
normalbeg2dc15:
|
||
normbeg short rcontloop15,15
|
||
|
||
normalbeg2dc10:
|
||
normbeg rcontloop10,10
|
||
|
||
normalbeg2dc9:
|
||
normbeg rcontloop9,9
|
||
|
||
normalbeg2dc8:
|
||
normbeg rcontloop8,8
|
||
|
||
normalbeg2dc7:
|
||
normbeg rcontloop7,7
|
||
|
||
normalbeg2dc6:
|
||
normbeg rcontloop6,6
|
||
|
||
normalbeg2dc5:
|
||
normbeg rcontloop5,5
|
||
|
||
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:
|
||
mov edi,window
|
||
|
||
cmp bp,word ptr[edi+eax]
|
||
jne contloop3 ; if *(ushf*)match != scan_start, continue
|
||
|
||
iseq:
|
||
; if we are here, we know that *(match+best_len-1) == scan_end
|
||
; and (match == scan_start)
|
||
|
||
mov edi,edx
|
||
mov esi,scan ; esi = scan
|
||
add edi,eax ; edi = window + cur_match = match
|
||
|
||
mov edx,[esi+3] ; compare manually dword at match+3
|
||
xor edx,[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 dl,dl
|
||
je eq1rr
|
||
mov esi,3
|
||
jmp trfinval
|
||
eq1rr:
|
||
or dx,dx
|
||
je eq1
|
||
|
||
mov esi,4
|
||
jmp trfinval
|
||
eq1:
|
||
and edx,0ffffffh
|
||
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 edx,[edi-4]
|
||
xor edx,[esi]
|
||
|
||
or dl,dl
|
||
jnz trfin
|
||
inc esi
|
||
|
||
or dx,dx
|
||
jnz trfin
|
||
inc esi
|
||
|
||
and edx,0ffffffh
|
||
jnz trfin
|
||
inc esi
|
||
|
||
trfin:
|
||
sub esi,scan ; esi = len
|
||
trfinval:
|
||
; here we have finised compare, and esi contain len of equal string
|
||
cmp esi,best_len ; if len > best_len, go newbestlen
|
||
ja short newbestlen
|
||
; now we restore edx, ecx and esi, for the big loop
|
||
mov esi,prev
|
||
mov ecx,limit
|
||
mov edx,window
|
||
jmp contloop3
|
||
|
||
newbestlen:
|
||
mov best_len,esi ; len become best_len
|
||
|
||
mov match_start,eax ; save new position as match_start
|
||
cmp esi,nice_match ; if best_len >= nice_match, exit
|
||
jae exitloop
|
||
mov ecx,scan
|
||
mov edx,window ; restore edx=window
|
||
add ecx,esi
|
||
add esi,edx
|
||
|
||
dec esi
|
||
mov windowlen,esi ; windowlen = window + best_len-1
|
||
mov bx,[ecx-1] ; bx = *(scan+best_len-1) = scan_end
|
||
|
||
; now we restore ecx and esi, for the big loop :
|
||
mov esi,prev
|
||
mov ecx,limit
|
||
jmp contloop3
|
||
|
||
exitloop:
|
||
; exit : s->match_start=match_start
|
||
mov ebx,match_start
|
||
mov ebp,str_s
|
||
mov ecx,best_len
|
||
mov dword ptr [ebp+dep_match_start],ebx
|
||
mov eax,dword ptr [ebp+dep_lookahead]
|
||
cmp ecx,eax
|
||
ja minexlo
|
||
mov eax,ecx
|
||
minexlo:
|
||
; return min(best_len,s->lookahead)
|
||
|
||
; restore stack and register ebx,esi,edi,ebp
|
||
add esp,NbStackAdd
|
||
|
||
pop ebx
|
||
pop esi
|
||
pop edi
|
||
pop ebp
|
||
ret
|
||
InfoAuthor:
|
||
; please don't remove this string !
|
||
; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
|
||
db 0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
|
||
|
||
|
||
|
||
IFDEF NOUNDERLINE
|
||
longest_match_7fff endp
|
||
ELSE
|
||
_longest_match_7fff endp
|
||
ENDIF
|
||
|
||
|
||
IFDEF NOUNDERLINE
|
||
cpudetect32 proc near
|
||
ELSE
|
||
_cpudetect32 proc near
|
||
ENDIF
|
||
|
||
|
||
pushfd ; push original EFLAGS
|
||
pop eax ; get original EFLAGS
|
||
mov ecx, eax ; save original EFLAGS
|
||
xor eax, 40000h ; flip AC bit in EFLAGS
|
||
push eax ; save new EFLAGS value on stack
|
||
popfd ; replace current EFLAGS value
|
||
pushfd ; get new EFLAGS
|
||
pop eax ; store new EFLAGS in EAX
|
||
xor eax, ecx ; can<61>t toggle AC bit, processor=80386
|
||
jz end_cpu_is_386 ; jump if 80386 processor
|
||
push ecx
|
||
popfd ; restore AC bit in EFLAGS first
|
||
|
||
pushfd
|
||
pushfd
|
||
pop ecx
|
||
|
||
mov eax, ecx ; get original EFLAGS
|
||
xor eax, 200000h ; flip ID bit in EFLAGS
|
||
push eax ; save new EFLAGS value on stack
|
||
popfd ; replace current EFLAGS value
|
||
pushfd ; get new EFLAGS
|
||
pop eax ; store new EFLAGS in EAX
|
||
popfd ; restore original EFLAGS
|
||
xor eax, ecx ; can<61>t toggle ID bit,
|
||
je is_old_486 ; processor=old
|
||
|
||
mov eax,1
|
||
db 0fh,0a2h ;CPUID
|
||
|
||
exitcpudetect:
|
||
ret
|
||
|
||
end_cpu_is_386:
|
||
mov eax,0300h
|
||
jmp exitcpudetect
|
||
|
||
is_old_486:
|
||
mov eax,0400h
|
||
jmp exitcpudetect
|
||
|
||
IFDEF NOUNDERLINE
|
||
cpudetect32 endp
|
||
ELSE
|
||
_cpudetect32 endp
|
||
ENDIF
|
||
|
||
_TEXT ends
|
||
end
|