| 1 | ;
|
|---|
| 2 | ; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
|
|---|
| 3 | ; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
|
|---|
| 4 | ; File written by Gilles Vollant, by modifiying the longest_match
|
|---|
| 5 | ; from Jean-loup Gailly in deflate.c
|
|---|
| 6 | ; It need wmask == 0x7fff
|
|---|
| 7 | ; (assembly code is faster with a fixed wmask)
|
|---|
| 8 | ;
|
|---|
| 9 | ; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
|
|---|
| 10 | ; I compile with : "ml /coff /Zi /c gvmat32.asm"
|
|---|
| 11 | ;
|
|---|
| 12 |
|
|---|
| 13 | ;uInt longest_match_7fff(s, cur_match)
|
|---|
| 14 | ; deflate_state *s;
|
|---|
| 15 | ; IPos cur_match; /* current match */
|
|---|
| 16 |
|
|---|
| 17 | NbStack equ 76
|
|---|
| 18 | cur_match equ dword ptr[esp+NbStack-0]
|
|---|
| 19 | str_s equ dword ptr[esp+NbStack-4]
|
|---|
| 20 | ; 5 dword on top (ret,ebp,esi,edi,ebx)
|
|---|
| 21 | adrret equ dword ptr[esp+NbStack-8]
|
|---|
| 22 | pushebp equ dword ptr[esp+NbStack-12]
|
|---|
| 23 | pushedi equ dword ptr[esp+NbStack-16]
|
|---|
| 24 | pushesi equ dword ptr[esp+NbStack-20]
|
|---|
| 25 | pushebx equ dword ptr[esp+NbStack-24]
|
|---|
| 26 |
|
|---|
| 27 | chain_length equ dword ptr [esp+NbStack-28]
|
|---|
| 28 | limit equ dword ptr [esp+NbStack-32]
|
|---|
| 29 | best_len equ dword ptr [esp+NbStack-36]
|
|---|
| 30 | window equ dword ptr [esp+NbStack-40]
|
|---|
| 31 | prev equ dword ptr [esp+NbStack-44]
|
|---|
| 32 | scan_start equ word ptr [esp+NbStack-48]
|
|---|
| 33 | wmask equ dword ptr [esp+NbStack-52]
|
|---|
| 34 | match_start_ptr equ dword ptr [esp+NbStack-56]
|
|---|
| 35 | nice_match equ dword ptr [esp+NbStack-60]
|
|---|
| 36 | scan equ dword ptr [esp+NbStack-64]
|
|---|
| 37 |
|
|---|
| 38 | windowlen equ dword ptr [esp+NbStack-68]
|
|---|
| 39 | match_start equ dword ptr [esp+NbStack-72]
|
|---|
| 40 | strend equ dword ptr [esp+NbStack-76]
|
|---|
| 41 | NbStackAdd equ (NbStack-24)
|
|---|
| 42 |
|
|---|
| 43 | .386p
|
|---|
| 44 |
|
|---|
| 45 | name gvmatch
|
|---|
| 46 | .MODEL FLAT
|
|---|
| 47 |
|
|---|
| 48 |
|
|---|
| 49 |
|
|---|
| 50 | ; all the +4 offsets are due to the addition of pending_buf_size (in zlib
|
|---|
| 51 | ; in the deflate_state structure since the asm code was first written
|
|---|
| 52 | ; (if you compile with zlib 1.0.4 or older, remove the +4).
|
|---|
| 53 | ; Note : these value are good with a 8 bytes boundary pack structure
|
|---|
| 54 | dep_chain_length equ 70h+4
|
|---|
| 55 | dep_window equ 2ch+4
|
|---|
| 56 | dep_strstart equ 60h+4
|
|---|
| 57 | dep_prev_length equ 6ch+4
|
|---|
| 58 | dep_nice_match equ 84h+4
|
|---|
| 59 | dep_w_size equ 20h+4
|
|---|
| 60 | dep_prev equ 34h+4
|
|---|
| 61 | dep_w_mask equ 28h+4
|
|---|
| 62 | dep_good_match equ 80h+4
|
|---|
| 63 | dep_match_start equ 64h+4
|
|---|
| 64 | dep_lookahead equ 68h+4
|
|---|
| 65 |
|
|---|
| 66 |
|
|---|
| 67 | _TEXT segment
|
|---|
| 68 |
|
|---|
| 69 | IFDEF NOUNDERLINE
|
|---|
| 70 | public longest_match_7fff
|
|---|
| 71 | public longest_match_686
|
|---|
| 72 | ; public match_init
|
|---|
| 73 | ELSE
|
|---|
| 74 | public _longest_match_7fff
|
|---|
| 75 | public _longest_match_686
|
|---|
| 76 | ; public _match_init
|
|---|
| 77 | ENDIF
|
|---|
| 78 |
|
|---|
| 79 | MAX_MATCH equ 258
|
|---|
| 80 | MIN_MATCH equ 3
|
|---|
| 81 | MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
|---|
| 82 |
|
|---|
| 83 |
|
|---|
| 84 |
|
|---|
| 85 | IFDEF NOUNDERLINE
|
|---|
| 86 | ;match_init proc near
|
|---|
| 87 | ; ret
|
|---|
| 88 | ;match_init endp
|
|---|
| 89 | ELSE
|
|---|
| 90 | ;_match_init proc near
|
|---|
| 91 | ; ret
|
|---|
| 92 | ;_match_init endp
|
|---|
| 93 | ENDIF
|
|---|
| 94 |
|
|---|
| 95 |
|
|---|
| 96 | IFDEF NOUNDERLINE
|
|---|
| 97 | longest_match_7fff proc near
|
|---|
| 98 | ELSE
|
|---|
| 99 | _longest_match_7fff proc near
|
|---|
| 100 | ENDIF
|
|---|
| 101 |
|
|---|
| 102 | mov edx,[esp+4]
|
|---|
| 103 |
|
|---|
| 104 |
|
|---|
| 105 |
|
|---|
| 106 | push ebp
|
|---|
| 107 | push edi
|
|---|
| 108 | push esi
|
|---|
| 109 | push ebx
|
|---|
| 110 |
|
|---|
| 111 | sub esp,NbStackAdd
|
|---|
| 112 |
|
|---|
| 113 | ; initialize or check the variables used in match.asm.
|
|---|
| 114 | mov ebp,edx
|
|---|
| 115 |
|
|---|
| 116 | ; chain_length = s->max_chain_length
|
|---|
| 117 | ; if (prev_length>=good_match) chain_length >>= 2
|
|---|
| 118 | mov edx,[ebp+dep_chain_length]
|
|---|
| 119 | mov ebx,[ebp+dep_prev_length]
|
|---|
| 120 | cmp [ebp+dep_good_match],ebx
|
|---|
| 121 | ja noshr
|
|---|
| 122 | shr edx,2
|
|---|
| 123 | noshr:
|
|---|
| 124 | ; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
|
|---|
| 125 | inc edx
|
|---|
| 126 | mov edi,[ebp+dep_nice_match]
|
|---|
| 127 | mov chain_length,edx
|
|---|
| 128 | mov eax,[ebp+dep_lookahead]
|
|---|
| 129 | cmp eax,edi
|
|---|
| 130 | ; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
|---|
| 131 | jae nolookaheadnicematch
|
|---|
| 132 | mov edi,eax
|
|---|
| 133 | nolookaheadnicematch:
|
|---|
| 134 | ; best_len = s->prev_length
|
|---|
| 135 | mov best_len,ebx
|
|---|
| 136 |
|
|---|
| 137 | ; window = s->window
|
|---|
| 138 | mov esi,[ebp+dep_window]
|
|---|
| 139 | mov ecx,[ebp+dep_strstart]
|
|---|
| 140 | mov window,esi
|
|---|
| 141 |
|
|---|
| 142 | mov nice_match,edi
|
|---|
| 143 | ; scan = window + strstart
|
|---|
| 144 | add esi,ecx
|
|---|
| 145 | mov scan,esi
|
|---|
| 146 | ; dx = *window
|
|---|
| 147 | mov dx,word ptr [esi]
|
|---|
| 148 | ; bx = *(window+best_len-1)
|
|---|
| 149 | mov bx,word ptr [esi+ebx-1]
|
|---|
| 150 | add esi,MAX_MATCH-1
|
|---|
| 151 | ; scan_start = *scan
|
|---|
| 152 | mov scan_start,dx
|
|---|
| 153 | ; strend = scan + MAX_MATCH-1
|
|---|
| 154 | mov strend,esi
|
|---|
| 155 | ; bx = scan_end = *(window+best_len-1)
|
|---|
| 156 |
|
|---|
| 157 | ; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
|---|
| 158 | ; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
|---|
| 159 |
|
|---|
| 160 | mov esi,[ebp+dep_w_size]
|
|---|
| 161 | sub esi,MIN_LOOKAHEAD
|
|---|
| 162 | ; here esi = MAX_DIST(s)
|
|---|
| 163 | sub ecx,esi
|
|---|
| 164 | ja nodist
|
|---|
| 165 | xor ecx,ecx
|
|---|
| 166 | nodist:
|
|---|
| 167 | mov limit,ecx
|
|---|
| 168 |
|
|---|
| 169 | ; prev = s->prev
|
|---|
| 170 | mov edx,[ebp+dep_prev]
|
|---|
| 171 | mov prev,edx
|
|---|
| 172 |
|
|---|
| 173 | ;
|
|---|
| 174 | mov edx,dword ptr [ebp+dep_match_start]
|
|---|
| 175 | mov bp,scan_start
|
|---|
| 176 | mov eax,cur_match
|
|---|
| 177 | mov match_start,edx
|
|---|
| 178 |
|
|---|
| 179 | mov edx,window
|
|---|
| 180 | mov edi,edx
|
|---|
| 181 | add edi,best_len
|
|---|
| 182 | mov esi,prev
|
|---|
| 183 | dec edi
|
|---|
| 184 | ; windowlen = window + best_len -1
|
|---|
| 185 | mov windowlen,edi
|
|---|
| 186 |
|
|---|
| 187 | jmp beginloop2
|
|---|
| 188 | align 4
|
|---|
| 189 |
|
|---|
| 190 | ; here, in the loop
|
|---|
| 191 | ; eax = ax = cur_match
|
|---|
| 192 | ; ecx = limit
|
|---|
| 193 | ; bx = scan_end
|
|---|
| 194 | ; bp = scan_start
|
|---|
| 195 | ; edi = windowlen (window + best_len -1)
|
|---|
| 196 | ; esi = prev
|
|---|
| 197 |
|
|---|
| 198 |
|
|---|
| 199 | ;// here; chain_length <=16
|
|---|
| 200 | normalbeg0add16:
|
|---|
| 201 | add chain_length,16
|
|---|
| 202 | jz exitloop
|
|---|
| 203 | normalbeg0:
|
|---|
| 204 | cmp word ptr[edi+eax],bx
|
|---|
| 205 | je normalbeg2noroll
|
|---|
| 206 | rcontlabnoroll:
|
|---|
| 207 | ; cur_match = prev[cur_match & wmask]
|
|---|
| 208 | and eax,7fffh
|
|---|
| 209 | mov ax,word ptr[esi+eax*2]
|
|---|
| 210 | ; if cur_match > limit, go to exitloop
|
|---|
| 211 | cmp ecx,eax
|
|---|
| 212 | jnb exitloop
|
|---|
| 213 | ; if --chain_length != 0, go to exitloop
|
|---|
| 214 | dec chain_length
|
|---|
| 215 | jnz normalbeg0
|
|---|
| 216 | jmp exitloop
|
|---|
| 217 |
|
|---|
| 218 | normalbeg2noroll:
|
|---|
| 219 | ; if (scan_start==*(cur_match+window)) goto normalbeg2
|
|---|
| 220 | cmp bp,word ptr[edx+eax]
|
|---|
| 221 | jne rcontlabnoroll
|
|---|
| 222 | jmp normalbeg2
|
|---|
| 223 |
|
|---|
| 224 | contloop3:
|
|---|
| 225 | mov edi,windowlen
|
|---|
| 226 |
|
|---|
| 227 | ; cur_match = prev[cur_match & wmask]
|
|---|
| 228 | and eax,7fffh
|
|---|
| 229 | mov ax,word ptr[esi+eax*2]
|
|---|
| 230 | ; if cur_match > limit, go to exitloop
|
|---|
| 231 | cmp ecx,eax
|
|---|
| 232 | jnbexitloopshort1:
|
|---|
| 233 | jnb exitloop
|
|---|
| 234 | ; if --chain_length != 0, go to exitloop
|
|---|
| 235 |
|
|---|
| 236 |
|
|---|
| 237 | ; begin the main loop
|
|---|
| 238 | beginloop2:
|
|---|
| 239 | sub chain_length,16+1
|
|---|
| 240 | ; if chain_length <=16, don't use the unrolled loop
|
|---|
| 241 | jna normalbeg0add16
|
|---|
| 242 |
|
|---|
| 243 | do16:
|
|---|
| 244 | cmp word ptr[edi+eax],bx
|
|---|
| 245 | je normalbeg2dc0
|
|---|
| 246 |
|
|---|
| 247 | maccn MACRO lab
|
|---|
| 248 | and eax,7fffh
|
|---|
| 249 | mov ax,word ptr[esi+eax*2]
|
|---|
| 250 | cmp ecx,eax
|
|---|
| 251 | jnb exitloop
|
|---|
| 252 | cmp word ptr[edi+eax],bx
|
|---|
| 253 | je lab
|
|---|
| 254 | ENDM
|
|---|
| 255 |
|
|---|
| 256 | rcontloop0:
|
|---|
| 257 | maccn normalbeg2dc1
|
|---|
| 258 |
|
|---|
| 259 | rcontloop1:
|
|---|
| 260 | maccn normalbeg2dc2
|
|---|
| 261 |
|
|---|
| 262 | rcontloop2:
|
|---|
| 263 | maccn normalbeg2dc3
|
|---|
| 264 |
|
|---|
| 265 | rcontloop3:
|
|---|
| 266 | maccn normalbeg2dc4
|
|---|
| 267 |
|
|---|
| 268 | rcontloop4:
|
|---|
| 269 | maccn normalbeg2dc5
|
|---|
| 270 |
|
|---|
| 271 | rcontloop5:
|
|---|
| 272 | maccn normalbeg2dc6
|
|---|
| 273 |
|
|---|
| 274 | rcontloop6:
|
|---|
| 275 | maccn normalbeg2dc7
|
|---|
| 276 |
|
|---|
| 277 | rcontloop7:
|
|---|
| 278 | maccn normalbeg2dc8
|
|---|
| 279 |
|
|---|
| 280 | rcontloop8:
|
|---|
| 281 | maccn normalbeg2dc9
|
|---|
| 282 |
|
|---|
| 283 | rcontloop9:
|
|---|
| 284 | maccn normalbeg2dc10
|
|---|
| 285 |
|
|---|
| 286 | rcontloop10:
|
|---|
| 287 | maccn short normalbeg2dc11
|
|---|
| 288 |
|
|---|
| 289 | rcontloop11:
|
|---|
| 290 | maccn short normalbeg2dc12
|
|---|
| 291 |
|
|---|
| 292 | rcontloop12:
|
|---|
| 293 | maccn short normalbeg2dc13
|
|---|
| 294 |
|
|---|
| 295 | rcontloop13:
|
|---|
| 296 | maccn short normalbeg2dc14
|
|---|
| 297 |
|
|---|
| 298 | rcontloop14:
|
|---|
| 299 | maccn short normalbeg2dc15
|
|---|
| 300 |
|
|---|
| 301 | rcontloop15:
|
|---|
| 302 | and eax,7fffh
|
|---|
| 303 | mov ax,word ptr[esi+eax*2]
|
|---|
| 304 | cmp ecx,eax
|
|---|
| 305 | jnb exitloop
|
|---|
| 306 |
|
|---|
| 307 | sub chain_length,16
|
|---|
| 308 | ja do16
|
|---|
| 309 | jmp normalbeg0add16
|
|---|
| 310 |
|
|---|
| 311 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|---|
| 312 |
|
|---|
| 313 | normbeg MACRO rcontlab,valsub
|
|---|
| 314 | ; if we are here, we know that *(match+best_len-1) == scan_end
|
|---|
| 315 | cmp bp,word ptr[edx+eax]
|
|---|
| 316 | ; if (match != scan_start) goto rcontlab
|
|---|
| 317 | jne rcontlab
|
|---|
| 318 | ; calculate the good chain_length, and we'll compare scan and match string
|
|---|
| 319 | add chain_length,16-valsub
|
|---|
| 320 | jmp iseq
|
|---|
| 321 | ENDM
|
|---|
| 322 |
|
|---|
| 323 |
|
|---|
| 324 | normalbeg2dc11:
|
|---|
| 325 | normbeg rcontloop11,11
|
|---|
| 326 |
|
|---|
| 327 | normalbeg2dc12:
|
|---|
| 328 | normbeg short rcontloop12,12
|
|---|
| 329 |
|
|---|
| 330 | normalbeg2dc13:
|
|---|
| 331 | normbeg short rcontloop13,13
|
|---|
| 332 |
|
|---|
| 333 | normalbeg2dc14:
|
|---|
| 334 | normbeg short rcontloop14,14
|
|---|
| 335 |
|
|---|
| 336 | normalbeg2dc15:
|
|---|
| 337 | normbeg short rcontloop15,15
|
|---|
| 338 |
|
|---|
| 339 | normalbeg2dc10:
|
|---|
| 340 | normbeg rcontloop10,10
|
|---|
| 341 |
|
|---|
| 342 | normalbeg2dc9:
|
|---|
| 343 | normbeg rcontloop9,9
|
|---|
| 344 |
|
|---|
| 345 | normalbeg2dc8:
|
|---|
| 346 | normbeg rcontloop8,8
|
|---|
| 347 |
|
|---|
| 348 | normalbeg2dc7:
|
|---|
| 349 | normbeg rcontloop7,7
|
|---|
| 350 |
|
|---|
| 351 | normalbeg2dc6:
|
|---|
| 352 | normbeg rcontloop6,6
|
|---|
| 353 |
|
|---|
| 354 | normalbeg2dc5:
|
|---|
| 355 | normbeg rcontloop5,5
|
|---|
| 356 |
|
|---|
| 357 | normalbeg2dc4:
|
|---|
| 358 | normbeg rcontloop4,4
|
|---|
| 359 |
|
|---|
| 360 | normalbeg2dc3:
|
|---|
| 361 | normbeg rcontloop3,3
|
|---|
| 362 |
|
|---|
| 363 | normalbeg2dc2:
|
|---|
| 364 | normbeg rcontloop2,2
|
|---|
| 365 |
|
|---|
| 366 | normalbeg2dc1:
|
|---|
| 367 | normbeg rcontloop1,1
|
|---|
| 368 |
|
|---|
| 369 | normalbeg2dc0:
|
|---|
| 370 | normbeg rcontloop0,0
|
|---|
| 371 |
|
|---|
| 372 |
|
|---|
| 373 | ; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
|
|---|
| 374 |
|
|---|
| 375 | normalbeg2:
|
|---|
| 376 | mov edi,window
|
|---|
| 377 |
|
|---|
| 378 | cmp bp,word ptr[edi+eax]
|
|---|
| 379 | jne contloop3 ; if *(ushf*)match != scan_start, continue
|
|---|
| 380 |
|
|---|
| 381 | iseq:
|
|---|
| 382 | ; if we are here, we know that *(match+best_len-1) == scan_end
|
|---|
| 383 | ; and (match == scan_start)
|
|---|
| 384 |
|
|---|
| 385 | mov edi,edx
|
|---|
| 386 | mov esi,scan ; esi = scan
|
|---|
| 387 | add edi,eax ; edi = window + cur_match = match
|
|---|
| 388 |
|
|---|
| 389 | mov edx,[esi+3] ; compare manually dword at match+3
|
|---|
| 390 | xor edx,[edi+3] ; and scan +3
|
|---|
| 391 |
|
|---|
| 392 | jz begincompare ; if equal, go to long compare
|
|---|
| 393 |
|
|---|
| 394 | ; we will determine the unmatch byte and calculate len (in esi)
|
|---|
| 395 | or dl,dl
|
|---|
| 396 | je eq1rr
|
|---|
| 397 | mov esi,3
|
|---|
| 398 | jmp trfinval
|
|---|
| 399 | eq1rr:
|
|---|
| 400 | or dx,dx
|
|---|
| 401 | je eq1
|
|---|
| 402 |
|
|---|
| 403 | mov esi,4
|
|---|
| 404 | jmp trfinval
|
|---|
| 405 | eq1:
|
|---|
| 406 | and edx,0ffffffh
|
|---|
| 407 | jz eq11
|
|---|
| 408 | mov esi,5
|
|---|
| 409 | jmp trfinval
|
|---|
| 410 | eq11:
|
|---|
| 411 | mov esi,6
|
|---|
| 412 | jmp trfinval
|
|---|
| 413 |
|
|---|
| 414 | begincompare:
|
|---|
| 415 | ; here we now scan and match begin same
|
|---|
| 416 | add edi,6
|
|---|
| 417 | add esi,6
|
|---|
| 418 | mov ecx,(MAX_MATCH-(2+4))/4 ; scan for at most MAX_MATCH bytes
|
|---|
| 419 | repe cmpsd ; loop until mismatch
|
|---|
| 420 |
|
|---|
| 421 | je trfin ; go to trfin if not unmatch
|
|---|
| 422 | ; we determine the unmatch byte
|
|---|
| 423 | sub esi,4
|
|---|
| 424 | mov edx,[edi-4]
|
|---|
| 425 | xor edx,[esi]
|
|---|
| 426 |
|
|---|
| 427 | or dl,dl
|
|---|
| 428 | jnz trfin
|
|---|
| 429 | inc esi
|
|---|
| 430 |
|
|---|
| 431 | or dx,dx
|
|---|
| 432 | jnz trfin
|
|---|
| 433 | inc esi
|
|---|
| 434 |
|
|---|
| 435 | and edx,0ffffffh
|
|---|
| 436 | jnz trfin
|
|---|
| 437 | inc esi
|
|---|
| 438 |
|
|---|
| 439 | trfin:
|
|---|
| 440 | sub esi,scan ; esi = len
|
|---|
| 441 | trfinval:
|
|---|
| 442 | ; here we have finised compare, and esi contain len of equal string
|
|---|
| 443 | cmp esi,best_len ; if len > best_len, go newbestlen
|
|---|
| 444 | ja short newbestlen
|
|---|
| 445 | ; now we restore edx, ecx and esi, for the big loop
|
|---|
| 446 | mov esi,prev
|
|---|
| 447 | mov ecx,limit
|
|---|
| 448 | mov edx,window
|
|---|
| 449 | jmp contloop3
|
|---|
| 450 |
|
|---|
| 451 | newbestlen:
|
|---|
| 452 | mov best_len,esi ; len become best_len
|
|---|
| 453 |
|
|---|
| 454 | mov match_start,eax ; save new position as match_start
|
|---|
| 455 | cmp esi,nice_match ; if best_len >= nice_match, exit
|
|---|
| 456 | jae exitloop
|
|---|
| 457 | mov ecx,scan
|
|---|
| 458 | mov edx,window ; restore edx=window
|
|---|
| 459 | add ecx,esi
|
|---|
| 460 | add esi,edx
|
|---|
| 461 |
|
|---|
| 462 | dec esi
|
|---|
| 463 | mov windowlen,esi ; windowlen = window + best_len-1
|
|---|
| 464 | mov bx,[ecx-1] ; bx = *(scan+best_len-1) = scan_end
|
|---|
| 465 |
|
|---|
| 466 | ; now we restore ecx and esi, for the big loop :
|
|---|
| 467 | mov esi,prev
|
|---|
| 468 | mov ecx,limit
|
|---|
| 469 | jmp contloop3
|
|---|
| 470 |
|
|---|
| 471 | exitloop:
|
|---|
| 472 | ; exit : s->match_start=match_start
|
|---|
| 473 | mov ebx,match_start
|
|---|
| 474 | mov ebp,str_s
|
|---|
| 475 | mov ecx,best_len
|
|---|
| 476 | mov dword ptr [ebp+dep_match_start],ebx
|
|---|
| 477 | mov eax,dword ptr [ebp+dep_lookahead]
|
|---|
| 478 | cmp ecx,eax
|
|---|
| 479 | ja minexlo
|
|---|
| 480 | mov eax,ecx
|
|---|
| 481 | minexlo:
|
|---|
| 482 | ; return min(best_len,s->lookahead)
|
|---|
| 483 |
|
|---|
| 484 | ; restore stack and register ebx,esi,edi,ebp
|
|---|
| 485 | add esp,NbStackAdd
|
|---|
| 486 |
|
|---|
| 487 | pop ebx
|
|---|
| 488 | pop esi
|
|---|
| 489 | pop edi
|
|---|
| 490 | pop ebp
|
|---|
| 491 | ret
|
|---|
| 492 | InfoAuthor:
|
|---|
| 493 | ; please don't remove this string !
|
|---|
| 494 | ; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
|
|---|
| 495 | db 0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
|
|---|
| 496 |
|
|---|
| 497 |
|
|---|
| 498 |
|
|---|
| 499 | IFDEF NOUNDERLINE
|
|---|
| 500 | longest_match_7fff endp
|
|---|
| 501 | ELSE
|
|---|
| 502 | _longest_match_7fff endp
|
|---|
| 503 | ENDIF
|
|---|
| 504 |
|
|---|
| 505 |
|
|---|
| 506 | IFDEF NOUNDERLINE
|
|---|
| 507 | cpudetect32 proc near
|
|---|
| 508 | ELSE
|
|---|
| 509 | _cpudetect32 proc near
|
|---|
| 510 | ENDIF
|
|---|
| 511 |
|
|---|
| 512 | push ebx
|
|---|
| 513 |
|
|---|
| 514 | pushfd ; push original EFLAGS
|
|---|
| 515 | pop eax ; get original EFLAGS
|
|---|
| 516 | mov ecx, eax ; save original EFLAGS
|
|---|
| 517 | xor eax, 40000h ; flip AC bit in EFLAGS
|
|---|
| 518 | push eax ; save new EFLAGS value on stack
|
|---|
| 519 | popfd ; replace current EFLAGS value
|
|---|
| 520 | pushfd ; get new EFLAGS
|
|---|
| 521 | pop eax ; store new EFLAGS in EAX
|
|---|
| 522 | xor eax, ecx ; cant toggle AC bit, processor=80386
|
|---|
| 523 | jz end_cpu_is_386 ; jump if 80386 processor
|
|---|
| 524 | push ecx
|
|---|
| 525 | popfd ; restore AC bit in EFLAGS first
|
|---|
| 526 |
|
|---|
| 527 | pushfd
|
|---|
| 528 | pushfd
|
|---|
| 529 | pop ecx
|
|---|
| 530 |
|
|---|
| 531 | mov eax, ecx ; get original EFLAGS
|
|---|
| 532 | xor eax, 200000h ; flip ID bit in EFLAGS
|
|---|
| 533 | push eax ; save new EFLAGS value on stack
|
|---|
| 534 | popfd ; replace current EFLAGS value
|
|---|
| 535 | pushfd ; get new EFLAGS
|
|---|
| 536 | pop eax ; store new EFLAGS in EAX
|
|---|
| 537 | popfd ; restore original EFLAGS
|
|---|
| 538 | xor eax, ecx ; cant toggle ID bit,
|
|---|
| 539 | je is_old_486 ; processor=old
|
|---|
| 540 |
|
|---|
| 541 | mov eax,1
|
|---|
| 542 | db 0fh,0a2h ;CPUID
|
|---|
| 543 |
|
|---|
| 544 | exitcpudetect:
|
|---|
| 545 | pop ebx
|
|---|
| 546 | ret
|
|---|
| 547 |
|
|---|
| 548 | end_cpu_is_386:
|
|---|
| 549 | mov eax,0300h
|
|---|
| 550 | jmp exitcpudetect
|
|---|
| 551 |
|
|---|
| 552 | is_old_486:
|
|---|
| 553 | mov eax,0400h
|
|---|
| 554 | jmp exitcpudetect
|
|---|
| 555 |
|
|---|
| 556 | IFDEF NOUNDERLINE
|
|---|
| 557 | cpudetect32 endp
|
|---|
| 558 | ELSE
|
|---|
| 559 | _cpudetect32 endp
|
|---|
| 560 | ENDIF
|
|---|
| 561 |
|
|---|
| 562 |
|
|---|
| 563 |
|
|---|
| 564 |
|
|---|
| 565 | MAX_MATCH equ 258
|
|---|
| 566 | MIN_MATCH equ 3
|
|---|
| 567 | MIN_LOOKAHEAD equ (MAX_MATCH + MIN_MATCH + 1)
|
|---|
| 568 | MAX_MATCH_8_ equ ((MAX_MATCH + 7) AND 0FFF0h)
|
|---|
| 569 |
|
|---|
| 570 |
|
|---|
| 571 | ;;; stack frame offsets
|
|---|
| 572 |
|
|---|
| 573 | chainlenwmask equ esp + 0 ; high word: current chain len
|
|---|
| 574 | ; low word: s->wmask
|
|---|
| 575 | window equ esp + 4 ; local copy of s->window
|
|---|
| 576 | windowbestlen equ esp + 8 ; s->window + bestlen
|
|---|
| 577 | scanstart equ esp + 16 ; first two bytes of string
|
|---|
| 578 | scanend equ esp + 12 ; last two bytes of string
|
|---|
| 579 | scanalign equ esp + 20 ; dword-misalignment of string
|
|---|
| 580 | nicematch equ esp + 24 ; a good enough match size
|
|---|
| 581 | bestlen equ esp + 28 ; size of best match so far
|
|---|
| 582 | scan equ esp + 32 ; ptr to string wanting match
|
|---|
| 583 |
|
|---|
| 584 | LocalVarsSize equ 36
|
|---|
| 585 | ; saved ebx byte esp + 36
|
|---|
| 586 | ; saved edi byte esp + 40
|
|---|
| 587 | ; saved esi byte esp + 44
|
|---|
| 588 | ; saved ebp byte esp + 48
|
|---|
| 589 | ; return address byte esp + 52
|
|---|
| 590 | deflatestate equ esp + 56 ; the function arguments
|
|---|
| 591 | curmatch equ esp + 60
|
|---|
| 592 |
|
|---|
| 593 | ;;; Offsets for fields in the deflate_state structure. These numbers
|
|---|
| 594 | ;;; are calculated from the definition of deflate_state, with the
|
|---|
| 595 | ;;; assumption that the compiler will dword-align the fields. (Thus,
|
|---|
| 596 | ;;; changing the definition of deflate_state could easily cause this
|
|---|
| 597 | ;;; program to crash horribly, without so much as a warning at
|
|---|
| 598 | ;;; compile time. Sigh.)
|
|---|
| 599 |
|
|---|
| 600 | dsWSize equ 36
|
|---|
| 601 | dsWMask equ 44
|
|---|
| 602 | dsWindow equ 48
|
|---|
| 603 | dsPrev equ 56
|
|---|
| 604 | dsMatchLen equ 88
|
|---|
| 605 | dsPrevMatch equ 92
|
|---|
| 606 | dsStrStart equ 100
|
|---|
| 607 | dsMatchStart equ 104
|
|---|
| 608 | dsLookahead equ 108
|
|---|
| 609 | dsPrevLen equ 112
|
|---|
| 610 | dsMaxChainLen equ 116
|
|---|
| 611 | dsGoodMatch equ 132
|
|---|
| 612 | dsNiceMatch equ 136
|
|---|
| 613 |
|
|---|
| 614 |
|
|---|
| 615 | ;;; match.asm -- Pentium-Pro-optimized version of longest_match()
|
|---|
| 616 | ;;; Written for zlib 1.1.2
|
|---|
| 617 | ;;; Copyright (C) 1998 Brian Raiter <[email protected]>
|
|---|
| 618 | ;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
|
|---|
| 619 | ;;;
|
|---|
| 620 | ;;; This is free software; you can redistribute it and/or modify it
|
|---|
| 621 | ;;; under the terms of the GNU General Public License.
|
|---|
| 622 |
|
|---|
| 623 | ;GLOBAL _longest_match, _match_init
|
|---|
| 624 |
|
|---|
| 625 |
|
|---|
| 626 | ;SECTION .text
|
|---|
| 627 |
|
|---|
| 628 | ;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
|
|---|
| 629 |
|
|---|
| 630 | ;_longest_match:
|
|---|
| 631 | IFDEF NOUNDERLINE
|
|---|
| 632 | longest_match_686 proc near
|
|---|
| 633 | ELSE
|
|---|
| 634 | _longest_match_686 proc near
|
|---|
| 635 | ENDIF
|
|---|
| 636 |
|
|---|
| 637 |
|
|---|
| 638 | ;;; Save registers that the compiler may be using, and adjust esp to
|
|---|
| 639 | ;;; make room for our stack frame.
|
|---|
| 640 |
|
|---|
| 641 | push ebp
|
|---|
| 642 | push edi
|
|---|
| 643 | push esi
|
|---|
| 644 | push ebx
|
|---|
| 645 | sub esp, LocalVarsSize
|
|---|
| 646 |
|
|---|
| 647 | ;;; Retrieve the function arguments. ecx will hold cur_match
|
|---|
| 648 | ;;; throughout the entire function. edx will hold the pointer to the
|
|---|
| 649 | ;;; deflate_state structure during the function's setup (before
|
|---|
| 650 | ;;; entering the main loop.
|
|---|
| 651 |
|
|---|
| 652 | mov edx, [deflatestate]
|
|---|
| 653 | mov ecx, [curmatch]
|
|---|
| 654 |
|
|---|
| 655 | ;;; uInt wmask = s->w_mask;
|
|---|
| 656 | ;;; unsigned chain_length = s->max_chain_length;
|
|---|
| 657 | ;;; if (s->prev_length >= s->good_match) {
|
|---|
| 658 | ;;; chain_length >>= 2;
|
|---|
| 659 | ;;; }
|
|---|
| 660 |
|
|---|
| 661 | mov eax, [edx + dsPrevLen]
|
|---|
| 662 | mov ebx, [edx + dsGoodMatch]
|
|---|
| 663 | cmp eax, ebx
|
|---|
| 664 | mov eax, [edx + dsWMask]
|
|---|
| 665 | mov ebx, [edx + dsMaxChainLen]
|
|---|
| 666 | jl LastMatchGood
|
|---|
| 667 | shr ebx, 2
|
|---|
| 668 | LastMatchGood:
|
|---|
| 669 |
|
|---|
| 670 | ;;; chainlen is decremented once beforehand so that the function can
|
|---|
| 671 | ;;; use the sign flag instead of the zero flag for the exit test.
|
|---|
| 672 | ;;; It is then shifted into the high word, to make room for the wmask
|
|---|
| 673 | ;;; value, which it will always accompany.
|
|---|
| 674 |
|
|---|
| 675 | dec ebx
|
|---|
| 676 | shl ebx, 16
|
|---|
| 677 | or ebx, eax
|
|---|
| 678 | mov [chainlenwmask], ebx
|
|---|
| 679 |
|
|---|
| 680 | ;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
|---|
| 681 |
|
|---|
| 682 | mov eax, [edx + dsNiceMatch]
|
|---|
| 683 | mov ebx, [edx + dsLookahead]
|
|---|
| 684 | cmp ebx, eax
|
|---|
| 685 | jl LookaheadLess
|
|---|
| 686 | mov ebx, eax
|
|---|
| 687 | LookaheadLess: mov [nicematch], ebx
|
|---|
| 688 |
|
|---|
| 689 | ;;; register Bytef *scan = s->window + s->strstart;
|
|---|
| 690 |
|
|---|
| 691 | mov esi, [edx + dsWindow]
|
|---|
| 692 | mov [window], esi
|
|---|
| 693 | mov ebp, [edx + dsStrStart]
|
|---|
| 694 | lea edi, [esi + ebp]
|
|---|
| 695 | mov [scan], edi
|
|---|
| 696 |
|
|---|
| 697 | ;;; Determine how many bytes the scan ptr is off from being
|
|---|
| 698 | ;;; dword-aligned.
|
|---|
| 699 |
|
|---|
| 700 | mov eax, edi
|
|---|
| 701 | neg eax
|
|---|
| 702 | and eax, 3
|
|---|
| 703 | mov [scanalign], eax
|
|---|
| 704 |
|
|---|
| 705 | ;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
|---|
| 706 | ;;; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
|---|
| 707 |
|
|---|
| 708 | mov eax, [edx + dsWSize]
|
|---|
| 709 | sub eax, MIN_LOOKAHEAD
|
|---|
| 710 | sub ebp, eax
|
|---|
| 711 | jg LimitPositive
|
|---|
| 712 | xor ebp, ebp
|
|---|
| 713 | LimitPositive:
|
|---|
| 714 |
|
|---|
| 715 | ;;; int best_len = s->prev_length;
|
|---|
| 716 |
|
|---|
| 717 | mov eax, [edx + dsPrevLen]
|
|---|
| 718 | mov [bestlen], eax
|
|---|
| 719 |
|
|---|
| 720 | ;;; Store the sum of s->window + best_len in esi locally, and in esi.
|
|---|
| 721 |
|
|---|
| 722 | add esi, eax
|
|---|
| 723 | mov [windowbestlen], esi
|
|---|
| 724 |
|
|---|
| 725 | ;;; register ush scan_start = *(ushf*)scan;
|
|---|
| 726 | ;;; register ush scan_end = *(ushf*)(scan+best_len-1);
|
|---|
| 727 | ;;; Posf *prev = s->prev;
|
|---|
| 728 |
|
|---|
| 729 | movzx ebx, word ptr [edi]
|
|---|
| 730 | mov [scanstart], ebx
|
|---|
| 731 | movzx ebx, word ptr [edi + eax - 1]
|
|---|
| 732 | mov [scanend], ebx
|
|---|
| 733 | mov edi, [edx + dsPrev]
|
|---|
| 734 |
|
|---|
| 735 | ;;; Jump into the main loop.
|
|---|
| 736 |
|
|---|
| 737 | mov edx, [chainlenwmask]
|
|---|
| 738 | jmp short LoopEntry
|
|---|
| 739 |
|
|---|
| 740 | align 4
|
|---|
| 741 |
|
|---|
| 742 | ;;; do {
|
|---|
| 743 | ;;; match = s->window + cur_match;
|
|---|
| 744 | ;;; if (*(ushf*)(match+best_len-1) != scan_end ||
|
|---|
| 745 | ;;; *(ushf*)match != scan_start) continue;
|
|---|
| 746 | ;;; [...]
|
|---|
| 747 | ;;; } while ((cur_match = prev[cur_match & wmask]) > limit
|
|---|
| 748 | ;;; && --chain_length != 0);
|
|---|
| 749 | ;;;
|
|---|
| 750 | ;;; Here is the inner loop of the function. The function will spend the
|
|---|
| 751 | ;;; majority of its time in this loop, and majority of that time will
|
|---|
| 752 | ;;; be spent in the first ten instructions.
|
|---|
| 753 | ;;;
|
|---|
| 754 | ;;; Within this loop:
|
|---|
| 755 | ;;; ebx = scanend
|
|---|
| 756 | ;;; ecx = curmatch
|
|---|
| 757 | ;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
|
|---|
| 758 | ;;; esi = windowbestlen - i.e., (window + bestlen)
|
|---|
| 759 | ;;; edi = prev
|
|---|
| 760 | ;;; ebp = limit
|
|---|
| 761 |
|
|---|
| 762 | LookupLoop:
|
|---|
| 763 | and ecx, edx
|
|---|
| 764 | movzx ecx, word ptr [edi + ecx*2]
|
|---|
| 765 | cmp ecx, ebp
|
|---|
| 766 | jbe LeaveNow
|
|---|
| 767 | sub edx, 00010000h
|
|---|
| 768 | js LeaveNow
|
|---|
| 769 | LoopEntry: movzx eax, word ptr [esi + ecx - 1]
|
|---|
| 770 | cmp eax, ebx
|
|---|
| 771 | jnz LookupLoop
|
|---|
| 772 | mov eax, [window]
|
|---|
| 773 | movzx eax, word ptr [eax + ecx]
|
|---|
| 774 | cmp eax, [scanstart]
|
|---|
| 775 | jnz LookupLoop
|
|---|
| 776 |
|
|---|
| 777 | ;;; Store the current value of chainlen.
|
|---|
| 778 |
|
|---|
| 779 | mov [chainlenwmask], edx
|
|---|
| 780 |
|
|---|
| 781 | ;;; Point edi to the string under scrutiny, and esi to the string we
|
|---|
| 782 | ;;; are hoping to match it up with. In actuality, esi and edi are
|
|---|
| 783 | ;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
|
|---|
| 784 | ;;; initialized to -(MAX_MATCH_8 - scanalign).
|
|---|
| 785 |
|
|---|
| 786 | mov esi, [window]
|
|---|
| 787 | mov edi, [scan]
|
|---|
| 788 | add esi, ecx
|
|---|
| 789 | mov eax, [scanalign]
|
|---|
| 790 | mov edx, 0fffffef8h; -(MAX_MATCH_8)
|
|---|
| 791 | lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
|
|---|
| 792 | lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
|
|---|
| 793 |
|
|---|
| 794 | ;;; Test the strings for equality, 8 bytes at a time. At the end,
|
|---|
| 795 | ;;; adjust edx so that it is offset to the exact byte that mismatched.
|
|---|
| 796 | ;;;
|
|---|
| 797 | ;;; We already know at this point that the first three bytes of the
|
|---|
| 798 | ;;; strings match each other, and they can be safely passed over before
|
|---|
| 799 | ;;; starting the compare loop. So what this code does is skip over 0-3
|
|---|
| 800 | ;;; bytes, as much as necessary in order to dword-align the edi
|
|---|
| 801 | ;;; pointer. (esi will still be misaligned three times out of four.)
|
|---|
| 802 | ;;;
|
|---|
| 803 | ;;; It should be confessed that this loop usually does not represent
|
|---|
| 804 | ;;; much of the total running time. Replacing it with a more
|
|---|
| 805 | ;;; straightforward "rep cmpsb" would not drastically degrade
|
|---|
| 806 | ;;; performance.
|
|---|
| 807 |
|
|---|
| 808 | LoopCmps:
|
|---|
| 809 | mov eax, [esi + edx]
|
|---|
| 810 | xor eax, [edi + edx]
|
|---|
| 811 | jnz LeaveLoopCmps
|
|---|
| 812 | mov eax, [esi + edx + 4]
|
|---|
| 813 | xor eax, [edi + edx + 4]
|
|---|
| 814 | jnz LeaveLoopCmps4
|
|---|
| 815 | add edx, 8
|
|---|
| 816 | jnz LoopCmps
|
|---|
| 817 | jmp short LenMaximum
|
|---|
| 818 | LeaveLoopCmps4: add edx, 4
|
|---|
| 819 | LeaveLoopCmps: test eax, 0000FFFFh
|
|---|
| 820 | jnz LenLower
|
|---|
| 821 | add edx, 2
|
|---|
| 822 | shr eax, 16
|
|---|
| 823 | LenLower: sub al, 1
|
|---|
| 824 | adc edx, 0
|
|---|
| 825 |
|
|---|
| 826 | ;;; Calculate the length of the match. If it is longer than MAX_MATCH,
|
|---|
| 827 | ;;; then automatically accept it as the best possible match and leave.
|
|---|
| 828 |
|
|---|
| 829 | lea eax, [edi + edx]
|
|---|
| 830 | mov edi, [scan]
|
|---|
| 831 | sub eax, edi
|
|---|
| 832 | cmp eax, MAX_MATCH
|
|---|
| 833 | jge LenMaximum
|
|---|
| 834 |
|
|---|
| 835 | ;;; If the length of the match is not longer than the best match we
|
|---|
| 836 | ;;; have so far, then forget it and return to the lookup loop.
|
|---|
| 837 |
|
|---|
| 838 | mov edx, [deflatestate]
|
|---|
| 839 | mov ebx, [bestlen]
|
|---|
| 840 | cmp eax, ebx
|
|---|
| 841 | jg LongerMatch
|
|---|
| 842 | mov esi, [windowbestlen]
|
|---|
| 843 | mov edi, [edx + dsPrev]
|
|---|
| 844 | mov ebx, [scanend]
|
|---|
| 845 | mov edx, [chainlenwmask]
|
|---|
| 846 | jmp LookupLoop
|
|---|
| 847 |
|
|---|
| 848 | ;;; s->match_start = cur_match;
|
|---|
| 849 | ;;; best_len = len;
|
|---|
| 850 | ;;; if (len >= nice_match) break;
|
|---|
| 851 | ;;; scan_end = *(ushf*)(scan+best_len-1);
|
|---|
| 852 |
|
|---|
| 853 | LongerMatch: mov ebx, [nicematch]
|
|---|
| 854 | mov [bestlen], eax
|
|---|
| 855 | mov [edx + dsMatchStart], ecx
|
|---|
| 856 | cmp eax, ebx
|
|---|
| 857 | jge LeaveNow
|
|---|
| 858 | mov esi, [window]
|
|---|
| 859 | add esi, eax
|
|---|
| 860 | mov [windowbestlen], esi
|
|---|
| 861 | movzx ebx, word ptr [edi + eax - 1]
|
|---|
| 862 | mov edi, [edx + dsPrev]
|
|---|
| 863 | mov [scanend], ebx
|
|---|
| 864 | mov edx, [chainlenwmask]
|
|---|
| 865 | jmp LookupLoop
|
|---|
| 866 |
|
|---|
| 867 | ;;; Accept the current string, with the maximum possible length.
|
|---|
| 868 |
|
|---|
| 869 | LenMaximum: mov edx, [deflatestate]
|
|---|
| 870 | mov dword ptr [bestlen], MAX_MATCH
|
|---|
| 871 | mov [edx + dsMatchStart], ecx
|
|---|
| 872 |
|
|---|
| 873 | ;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
|
|---|
| 874 | ;;; return s->lookahead;
|
|---|
| 875 |
|
|---|
| 876 | LeaveNow:
|
|---|
| 877 | mov edx, [deflatestate]
|
|---|
| 878 | mov ebx, [bestlen]
|
|---|
| 879 | mov eax, [edx + dsLookahead]
|
|---|
| 880 | cmp ebx, eax
|
|---|
| 881 | jg LookaheadRet
|
|---|
| 882 | mov eax, ebx
|
|---|
| 883 | LookaheadRet:
|
|---|
| 884 |
|
|---|
| 885 | ;;; Restore the stack and return from whence we came.
|
|---|
| 886 |
|
|---|
| 887 | add esp, LocalVarsSize
|
|---|
| 888 | pop ebx
|
|---|
| 889 | pop esi
|
|---|
| 890 | pop edi
|
|---|
| 891 | pop ebp
|
|---|
| 892 |
|
|---|
| 893 | ret
|
|---|
| 894 | ; please don't remove this string !
|
|---|
| 895 | ; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
|
|---|
| 896 | db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
|
|---|
| 897 |
|
|---|
| 898 | IFDEF NOUNDERLINE
|
|---|
| 899 | longest_match_686 endp
|
|---|
| 900 | ELSE
|
|---|
| 901 | _longest_match_686 endp
|
|---|
| 902 | ENDIF
|
|---|
| 903 |
|
|---|
| 904 | _TEXT ends
|
|---|
| 905 | end
|
|---|
