Post-import cleanup

5 files changed, 0 insertions, 2175 deletions

diff --git a/cpukit/zlib/contrib/masmx86/gvmat32.asm b/cpukit/zlib/contrib/masmx86/gvmat32.asm
deleted file mode 100644
index e841a7fda2..0000000000
--- a/cpukit/zlib/contrib/masmx86/gvmat32.asm
+++ /dev/null
@@ -1,909 +0,0 @@
-;
-; 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 +addstr offsets are due to the addition of pending_buf_size in zlib 1.04
-;  and adding gzhead and gzindex in zlib 1.2.2.1
-;  in the deflate_state structure since the asm code was first written
-;  (if you compile with zlib 1.0.4 or older, set addstr to 0).
-;  (if you compiler with zlib between 1.04 and 1.2.1, set addstr to 4)
-;  Note : these value are good with a 8 bytes boundary pack structure
-
-    addstr              equ     4+8
-    dep_chain_length    equ     70h+addstr
-    dep_window          equ     2ch+addstr
-    dep_strstart        equ     60h+addstr
-    dep_prev_length     equ     6ch+addstr
-    dep_nice_match      equ     84h+addstr
-    dep_w_size          equ     20h+addstr
-    dep_prev            equ     34h+addstr
-    dep_w_mask          equ     28h+addstr
-    dep_good_match      equ     80h+addstr
-    dep_match_start     equ     64h+addstr
-    dep_lookahead       equ     68h+addstr
-
-
-_TEXT                   segment
-
-IFDEF NOUNDERLINE
-			public  longest_match_7fff
-			public  longest_match_686
-;                        public  match_init
-ELSE
-			public  _longest_match_7fff
-			public  _longest_match_686
-;                        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
-
-	push	ebx
-
-	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’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’t toggle ID bit,
-	je		is_old_486		; processor=old
-
-	mov     eax,1
-	db      0fh,0a2h        ;CPUID
-
-exitcpudetect:
-	pop	ebx
-	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
-
-
-
-
-MAX_MATCH       equ     258
-MIN_MATCH       equ     3
-MIN_LOOKAHEAD   equ     (MAX_MATCH + MIN_MATCH + 1)
-MAX_MATCH_8_     equ     ((MAX_MATCH + 7) AND 0FFF0h)
-
-
-;;; stack frame offsets
-
-chainlenwmask	equ  esp + 0	; high word: current chain len
-					; low word: s->wmask
-window		equ  esp + 4	; local copy of s->window
-windowbestlen	equ  esp + 8	; s->window + bestlen
-scanstart	equ  esp + 16	; first two bytes of string
-scanend		equ  esp + 12	; last two bytes of string
-scanalign	equ  esp + 20	; dword-misalignment of string
-nicematch	equ  esp + 24	; a good enough match size
-bestlen		equ  esp + 28	; size of best match so far
-scan		equ  esp + 32	; ptr to string wanting match
-
-LocalVarsSize	equ 36
-;	saved ebx	byte esp + 36
-;	saved edi	byte esp + 40
-;	saved esi	byte esp + 44
-;	saved ebp	byte esp + 48
-;	return address	byte esp + 52
-deflatestate	equ  esp + 56	; the function arguments
-curmatch	equ  esp + 60
-
-;;; Offsets for fields in the deflate_state structure. These numbers
-;;; are calculated from the definition of deflate_state, with the
-;;; assumption that the compiler will dword-align the fields. (Thus,
-;;; changing the definition of deflate_state could easily cause this
-;;; program to crash horribly, without so much as a warning at
-;;; compile time. Sigh.)
-
-dsWSize		equ 36+addstr-4
-dsWMask		equ 44+addstr-4
-dsWindow	equ 48+addstr-4
-dsPrev		equ 56+addstr-4
-dsMatchLen	equ 88+addstr-4
-dsPrevMatch	equ 92+addstr-4
-dsStrStart	equ 100+addstr-4
-dsMatchStart	equ 104+addstr-4
-dsLookahead	equ 108+addstr-4
-dsPrevLen	equ 112+addstr-4
-dsMaxChainLen	equ 116+addstr-4
-dsGoodMatch	equ 132+addstr-4
-dsNiceMatch	equ 136+addstr-4
-
-
-;;; match.asm -- Pentium-Pro-optimized version of longest_match()
-;;; Written for zlib 1.1.2
-;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
-;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
-;;;
-;;; This is free software; you can redistribute it and/or modify it
-;;; under the terms of the GNU General Public License.
-
-;GLOBAL	_longest_match, _match_init
-
-
-;SECTION	.text
-
-;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
-
-;_longest_match:
-IFDEF NOUNDERLINE
-longest_match_686   proc near
-ELSE
-_longest_match_686  proc near
-ENDIF
-
-
-;;; Save registers that the compiler may be using, and adjust esp to
-;;; make room for our stack frame.
-
-		push	ebp
-		push	edi
-		push	esi
-		push	ebx
-		sub	esp, LocalVarsSize
-
-;;; Retrieve the function arguments. ecx will hold cur_match
-;;; throughout the entire function. edx will hold the pointer to the
-;;; deflate_state structure during the function's setup (before
-;;; entering the main loop.
-
-		mov	edx, [deflatestate]
-		mov	ecx, [curmatch]
-
-;;; uInt wmask = s->w_mask;
-;;; unsigned chain_length = s->max_chain_length;
-;;; if (s->prev_length >= s->good_match) {
-;;;     chain_length >>= 2;
-;;; }
-
-		mov	eax, [edx + dsPrevLen]
-		mov	ebx, [edx + dsGoodMatch]
-		cmp	eax, ebx
-		mov	eax, [edx + dsWMask]
-		mov	ebx, [edx + dsMaxChainLen]
-		jl	LastMatchGood
-		shr	ebx, 2
-LastMatchGood:
-
-;;; chainlen is decremented once beforehand so that the function can
-;;; use the sign flag instead of the zero flag for the exit test.
-;;; It is then shifted into the high word, to make room for the wmask
-;;; value, which it will always accompany.
-
-		dec	ebx
-		shl	ebx, 16
-		or	ebx, eax
-		mov	[chainlenwmask], ebx
-
-;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
-
-		mov	eax, [edx + dsNiceMatch]
-		mov	ebx, [edx + dsLookahead]
-		cmp	ebx, eax
-		jl	LookaheadLess
-		mov	ebx, eax
-LookaheadLess:	mov	[nicematch], ebx
-
-;;; register Bytef *scan = s->window + s->strstart;
-
-		mov	esi, [edx + dsWindow]
-		mov	[window], esi
-		mov	ebp, [edx + dsStrStart]
-		lea	edi, [esi + ebp]
-		mov	[scan], edi
-
-;;; Determine how many bytes the scan ptr is off from being
-;;; dword-aligned.
-
-		mov	eax, edi
-		neg	eax
-		and	eax, 3
-		mov	[scanalign], eax
-
-;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
-
-		mov	eax, [edx + dsWSize]
-		sub	eax, MIN_LOOKAHEAD
-		sub	ebp, eax
-		jg	LimitPositive
-		xor	ebp, ebp
-LimitPositive:
-
-;;; int best_len = s->prev_length;
-
-		mov	eax, [edx + dsPrevLen]
-		mov	[bestlen], eax
-
-;;; Store the sum of s->window + best_len in esi locally, and in esi.
-
-		add	esi, eax
-		mov	[windowbestlen], esi
-
-;;; register ush scan_start = *(ushf*)scan;
-;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
-;;; Posf *prev = s->prev;
-
-		movzx	ebx, word ptr [edi]
-		mov	[scanstart], ebx
-		movzx	ebx, word ptr [edi + eax - 1]
-		mov	[scanend], ebx
-		mov	edi, [edx + dsPrev]
-
-;;; Jump into the main loop.
-
-		mov	edx, [chainlenwmask]
-		jmp	short LoopEntry
-
-align 4
-
-;;; do {
-;;;     match = s->window + cur_match;
-;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
-;;;         *(ushf*)match != scan_start) continue;
-;;;     [...]
-;;; } while ((cur_match = prev[cur_match & wmask]) > limit
-;;;          && --chain_length != 0);
-;;;
-;;; Here is the inner loop of the function. The function will spend the
-;;; majority of its time in this loop, and majority of that time will
-;;; be spent in the first ten instructions.
-;;;
-;;; Within this loop:
-;;; ebx = scanend
-;;; ecx = curmatch
-;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
-;;; esi = windowbestlen - i.e., (window + bestlen)
-;;; edi = prev
-;;; ebp = limit
-
-LookupLoop:
-		and	ecx, edx
-		movzx	ecx, word ptr [edi + ecx*2]
-		cmp	ecx, ebp
-		jbe	LeaveNow
-		sub	edx, 00010000h
-		js	LeaveNow
-LoopEntry:	movzx	eax, word ptr [esi + ecx - 1]
-		cmp	eax, ebx
-		jnz	LookupLoop
-		mov	eax, [window]
-		movzx	eax, word ptr [eax + ecx]
-		cmp	eax, [scanstart]
-		jnz	LookupLoop
-
-;;; Store the current value of chainlen.
-
-		mov	[chainlenwmask], edx
-
-;;; Point edi to the string under scrutiny, and esi to the string we
-;;; are hoping to match it up with. In actuality, esi and edi are
-;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
-;;; initialized to -(MAX_MATCH_8 - scanalign).
-
-		mov	esi, [window]
-		mov	edi, [scan]
-		add	esi, ecx
-		mov	eax, [scanalign]
-		mov	edx, 0fffffef8h; -(MAX_MATCH_8)
-		lea	edi, [edi + eax + 0108h] ;MAX_MATCH_8]
-		lea	esi, [esi + eax + 0108h] ;MAX_MATCH_8]
-
-;;; Test the strings for equality, 8 bytes at a time. At the end,
-;;; adjust edx so that it is offset to the exact byte that mismatched.
-;;;
-;;; We already know at this point that the first three bytes of the
-;;; strings match each other, and they can be safely passed over before
-;;; starting the compare loop. So what this code does is skip over 0-3
-;;; bytes, as much as necessary in order to dword-align the edi
-;;; pointer. (esi will still be misaligned three times out of four.)
-;;;
-;;; It should be confessed that this loop usually does not represent
-;;; much of the total running time. Replacing it with a more
-;;; straightforward "rep cmpsb" would not drastically degrade
-;;; performance.
-
-LoopCmps:
-		mov	eax, [esi + edx]
-		xor	eax, [edi + edx]
-		jnz	LeaveLoopCmps
-		mov	eax, [esi + edx + 4]
-		xor	eax, [edi + edx + 4]
-		jnz	LeaveLoopCmps4
-		add	edx, 8
-		jnz	LoopCmps
-		jmp	short LenMaximum
-LeaveLoopCmps4:	add	edx, 4
-LeaveLoopCmps:	test	eax, 0000FFFFh
-		jnz	LenLower
-		add	edx,  2
-		shr	eax, 16
-LenLower:	sub	al, 1
-		adc	edx, 0
-
-;;; Calculate the length of the match. If it is longer than MAX_MATCH,
-;;; then automatically accept it as the best possible match and leave.
-
-		lea	eax, [edi + edx]
-		mov	edi, [scan]
-		sub	eax, edi
-		cmp	eax, MAX_MATCH
-		jge	LenMaximum
-
-;;; If the length of the match is not longer than the best match we
-;;; have so far, then forget it and return to the lookup loop.
-
-		mov	edx, [deflatestate]
-		mov	ebx, [bestlen]
-		cmp	eax, ebx
-		jg	LongerMatch
-		mov	esi, [windowbestlen]
-		mov	edi, [edx + dsPrev]
-		mov	ebx, [scanend]
-		mov	edx, [chainlenwmask]
-		jmp	LookupLoop
-
-;;;         s->match_start = cur_match;
-;;;         best_len = len;
-;;;         if (len >= nice_match) break;
-;;;         scan_end = *(ushf*)(scan+best_len-1);
-
-LongerMatch:	mov	ebx, [nicematch]
-		mov	[bestlen], eax
-		mov	[edx + dsMatchStart], ecx
-		cmp	eax, ebx
-		jge	LeaveNow
-		mov	esi, [window]
-		add	esi, eax
-		mov	[windowbestlen], esi
-		movzx	ebx, word ptr [edi + eax - 1]
-		mov	edi, [edx + dsPrev]
-		mov	[scanend], ebx
-		mov	edx, [chainlenwmask]
-		jmp	LookupLoop
-
-;;; Accept the current string, with the maximum possible length.
-
-LenMaximum:	mov	edx, [deflatestate]
-		mov	dword ptr [bestlen], MAX_MATCH
-		mov	[edx + dsMatchStart], ecx
-
-;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
-;;; return s->lookahead;
-
-LeaveNow:
-		mov	edx, [deflatestate]
-		mov	ebx, [bestlen]
-		mov	eax, [edx + dsLookahead]
-		cmp	ebx, eax
-		jg	LookaheadRet
-		mov	eax, ebx
-LookaheadRet:
-
-;;; Restore the stack and return from whence we came.
-
-		add	esp, LocalVarsSize
-		pop	ebx
-		pop	esi
-		pop	edi
-		pop	ebp
-
-		ret
-; please don't remove this string !
-; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
-	db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
-
-IFDEF NOUNDERLINE
-longest_match_686   endp
-ELSE
-_longest_match_686  endp
-ENDIF
-
-_TEXT   ends
-end
diff --git a/cpukit/zlib/contrib/masmx86/gvmat32c.c b/cpukit/zlib/contrib/masmx86/gvmat32c.c
deleted file mode 100644
index 9ed25f3432..0000000000
--- a/cpukit/zlib/contrib/masmx86/gvmat32c.c
+++ /dev/null
@@ -1,206 +0,0 @@
-/* gvmat32.c -- C 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 prepare all parameters and call the assembly longest_match_gvasm
- *  longest_match execute standard C code is wmask != 0x7fff
- *     (assembly code is faster with a fixed wmask)
- *
- */
-
-#include "deflate.h"
-
-#ifdef ASMV
-#define NIL 0
-
-#define UNALIGNED_OK
-
-
-/* if your C compiler don't add underline before function name,
-        define ADD_UNDERLINE_ASMFUNC */
-#ifdef ADD_UNDERLINE_ASMFUNC
-#define longest_match_7fff _longest_match_7fff
-#define longest_match_686  _longest_match_686
-#define cpudetect32        _cpudetect32
-#endif
-
-
-
-void match_init()
-{
-}
-
-unsigned long cpudetect32();
-
-uInt longest_match_c(
-    deflate_state *s,
-    IPos cur_match);                             /* current match */
-
-
-uInt longest_match_7fff(
-    deflate_state *s,
-    IPos cur_match);                             /* current match */
-
-uInt longest_match_686(
-    deflate_state *s,
-    IPos cur_match);                             /* current match */
-
-uInt longest_match(
-    deflate_state *s,
-    IPos cur_match)                             /* current match */
-{
-    static uInt iIsPPro=2;
-
-    if ((s->w_mask == 0x7fff) && (iIsPPro==0))
-        return longest_match_7fff(s,cur_match);
-
-    if (iIsPPro==1)
-        return longest_match_686(s,cur_match);
-
-    if (iIsPPro==2)
-        iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
-
-    return longest_match_c(s,cur_match);
-}
-
-
-
-uInt longest_match_c(s, cur_match)
-    deflate_state *s;
-    IPos cur_match;                             /* current match */
-{
-    unsigned chain_length = s->max_chain_length;/* max hash chain length */
-    register Bytef *scan = s->window + s->strstart; /* current string */
-    register Bytef *match;                       /* matched string */
-    register int len;                           /* length of current match */
-    int best_len = s->prev_length;              /* best match length so far */
-    int nice_match = s->nice_match;             /* stop if match long enough */
-    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
-        s->strstart - (IPos)MAX_DIST(s) : NIL;
-    /* Stop when cur_match becomes <= limit. To simplify the code,
-     * we prevent matches with the string of window index 0.
-     */
-    Posf *prev = s->prev;
-    uInt wmask = s->w_mask;
-
-#ifdef UNALIGNED_OK
-    /* Compare two bytes at a time. Note: this is not always beneficial.
-     * Try with and without -DUNALIGNED_OK to check.
-     */
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
-    register ush scan_start = *(ushf*)scan;
-    register ush scan_end   = *(ushf*)(scan+best_len-1);
-#else
-    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
-    register Byte scan_end1  = scan[best_len-1];
-    register Byte scan_end   = scan[best_len];
-#endif
-
-    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
-     * It is easy to get rid of this optimization if necessary.
-     */
-    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
-
-    /* Do not waste too much time if we already have a good match: */
-    if (s->prev_length >= s->good_match) {
-        chain_length >>= 2;
-    }
-    /* Do not look for matches beyond the end of the input. This is necessary
-     * to make deflate deterministic.
-     */
-    if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
-
-    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
-
-    do {
-        Assert(cur_match < s->strstart, "no future");
-        match = s->window + cur_match;
-
-        /* Skip to next match if the match length cannot increase
-         * or if the match length is less than 2:
-         */
-#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
-        /* This code assumes sizeof(unsigned short) == 2. Do not use
-         * UNALIGNED_OK if your compiler uses a different size.
-         */
-        if (*(ushf*)(match+best_len-1) != scan_end ||
-            *(ushf*)match != scan_start) continue;
-
-        /* It is not necessary to compare scan[2] and match[2] since they are
-         * always equal when the other bytes match, given that the hash keys
-         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
-         * strstart+3, +5, ... up to strstart+257. We check for insufficient
-         * lookahead only every 4th comparison; the 128th check will be made
-         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
-         * necessary to put more guard bytes at the end of the window, or
-         * to check more often for insufficient lookahead.
-         */
-        Assert(scan[2] == match[2], "scan[2]?");
-        scan++, match++;
-        do {
-        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
-                 scan < strend);
-        /* The funny "do {}" generates better code on most compilers */
-
-        /* Here, scan <= window+strstart+257 */
-        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-        if (*scan == *match) scan++;
-
-        len = (MAX_MATCH - 1) - (int)(strend-scan);
-        scan = strend - (MAX_MATCH-1);
-
-#else /* UNALIGNED_OK */
-
-        if (match[best_len]   != scan_end  ||
-            match[best_len-1] != scan_end1 ||
-            *match            != *scan     ||
-            *++match          != scan[1])      continue;
-
-        /* The check at best_len-1 can be removed because it will be made
-         * again later. (This heuristic is not always a win.)
-         * It is not necessary to compare scan[2] and match[2] since they
-         * are always equal when the other bytes match, given that
-         * the hash keys are equal and that HASH_BITS >= 8.
-         */
-        scan += 2, match++;
-        Assert(*scan == *match, "match[2]?");
-
-        /* We check for insufficient lookahead only every 8th comparison;
-         * the 256th check will be made at strstart+258.
-         */
-        do {
-        } while (*++scan == *++match && *++scan == *++match &&
-                 *++scan == *++match && *++scan == *++match &&
-                 *++scan == *++match && *++scan == *++match &&
-                 *++scan == *++match && *++scan == *++match &&
-                 scan < strend);
-
-        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
-
-        len = MAX_MATCH - (int)(strend - scan);
-        scan = strend - MAX_MATCH;
-
-#endif /* UNALIGNED_OK */
-
-        if (len > best_len) {
-            s->match_start = cur_match;
-            best_len = len;
-            if (len >= nice_match) break;
-#ifdef UNALIGNED_OK
-            scan_end = *(ushf*)(scan+best_len-1);
-#else
-            scan_end1  = scan[best_len-1];
-            scan_end   = scan[best_len];
-#endif
-        }
-    } while ((cur_match = prev[cur_match & wmask]) > limit
-             && --chain_length != 0);
-
-    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
-    return s->lookahead;
-}
-
-#endif /* ASMV */
diff --git a/cpukit/zlib/contrib/masmx86/inffas32.asm b/cpukit/zlib/contrib/masmx86/inffas32.asm
deleted file mode 100644
index 531bcefffc..0000000000
--- a/cpukit/zlib/contrib/masmx86/inffas32.asm
+++ /dev/null
@@ -1,1036 +0,0 @@
-; 75 "inffast.S"
-;FILE "inffast.S"
-
-;;;GLOBAL _inflate_fast
-
-;;;SECTION .text
-
-
-
-	.586p
-	.mmx
-
-	name	inflate_fast_x86
-	.MODEL	FLAT
-
-_DATA			segment
-inflate_fast_use_mmx:
-	dd	1
-
-
-_TEXT			segment
-PUBLIC _inflate_fast
-
-ALIGN 4
-_inflate_fast:
-	jmp inflate_fast_entry
-
-
-
-ALIGN 4
-	db	'Fast decoding Code from Chris Anderson'
-	db	0
-
-ALIGN 4
-invalid_literal_length_code_msg:
-	db	'invalid literal/length code'
-	db	0
-
-ALIGN 4
-invalid_distance_code_msg:
-	db	'invalid distance code'
-	db	0
-
-ALIGN 4
-invalid_distance_too_far_msg:
-	db	'invalid distance too far back'
-	db	0
-
-
-ALIGN 4
-inflate_fast_mask:
-dd	0
-dd	1
-dd	3
-dd	7
-dd	15
-dd	31
-dd	63
-dd	127
-dd	255
-dd	511
-dd	1023
-dd	2047
-dd	4095
-dd	8191
-dd	16383
-dd	32767
-dd	65535
-dd	131071
-dd	262143
-dd	524287
-dd	1048575
-dd	2097151
-dd	4194303
-dd	8388607
-dd	16777215
-dd	33554431
-dd	67108863
-dd	134217727
-dd	268435455
-dd	536870911
-dd	1073741823
-dd	2147483647
-dd	4294967295
-
-
-; head was added in zlib 1.2.2.1, so we add addstr
-; set addstr to 0 with zlib 1.2.1 of below
-addstr           equ    4
-
-mode_state	 equ	0	;/* state->mode	*/
-wsize_state	 equ	32+addstr	;/* state->wsize */
-write_state	 equ	(36+4+addstr)	;/* state->write */
-window_state	 equ	(40+4+addstr)	;/* state->window */
-hold_state	 equ	(44+4+addstr)	;/* state->hold	*/
-bits_state	 equ	(48+4+addstr)	;/* state->bits	*/
-lencode_state	 equ	(64+4+addstr)	;/* state->lencode */
-distcode_state	 equ	(68+4+addstr)	;/* state->distcode */
-lenbits_state	 equ	(72+4+addstr)	;/* state->lenbits */
-distbits_state	 equ	(76+4+addstr)	;/* state->distbits */
-
-
-;;SECTION .text
-; 205 "inffast.S"
-;GLOBAL	inflate_fast_use_mmx
-
-;SECTION .data
-
-
-; GLOBAL inflate_fast_use_mmx:object
-;.size inflate_fast_use_mmx, 4
-; 226 "inffast.S"
-;SECTION .text
-
-ALIGN 4
-inflate_fast_entry:
-	push  edi
-	push  esi
-	push  ebp
-	push  ebx
-	pushfd
-	sub  esp,64
-	cld
-
-
-
-
-	mov  esi, [esp+88]
-	mov  edi, [esi+28]
-
-
-
-
-
-
-
-	mov  edx, [esi+4]
-	mov  eax, [esi+0]
-
-	add  edx,eax
-	sub  edx,11
-
-	mov  [esp+44],eax
-	mov  [esp+20],edx
-
-	mov  ebp, [esp+92]
-	mov  ecx, [esi+16]
-	mov  ebx, [esi+12]
-
-	sub  ebp,ecx
-	neg  ebp
-	add  ebp,ebx
-
-	sub  ecx,257
-	add  ecx,ebx
-
-	mov  [esp+60],ebx
-	mov  [esp+40],ebp
-	mov  [esp+16],ecx
-; 285 "inffast.S"
-	mov  eax, [edi+lencode_state]
-	mov  ecx, [edi+distcode_state]
-
-	mov  [esp+8],eax
-	mov  [esp+12],ecx
-
-	mov  eax,1
-	mov  ecx, [edi+lenbits_state]
-	shl  eax,cl
-	dec  eax
-	mov  [esp+0],eax
-
-	mov  eax,1
-	mov  ecx, [edi+distbits_state]
-	shl  eax,cl
-	dec  eax
-	mov  [esp+4],eax
-
-	mov  eax, [edi+wsize_state]
-	mov  ecx, [edi+write_state]
-	mov  edx, [edi+window_state]
-
-	mov  [esp+52],eax
-	mov  [esp+48],ecx
-	mov  [esp+56],edx
-
-	mov  ebp, [edi+hold_state]
-	mov  ebx, [edi+bits_state]
-; 321 "inffast.S"
-	mov  esi, [esp+44]
-	mov  ecx, [esp+20]
-	cmp  ecx,esi
-	ja   L_align_long
-
-	add  ecx,11
-	sub  ecx,esi
-	mov  eax,12
-	sub  eax,ecx
-	lea  edi, [esp+28]
-	rep movsb
-	mov  ecx,eax
-	xor  eax,eax
-	rep stosb
-	lea  esi, [esp+28]
-	mov  [esp+20],esi
-	jmp  L_is_aligned
-
-
-L_align_long:
-	test  esi,3
-	jz   L_is_aligned
-	xor  eax,eax
-	mov  al, [esi]
-	inc  esi
-	mov  ecx,ebx
-	add  ebx,8
-	shl  eax,cl
-	or  ebp,eax
-	jmp L_align_long
-
-L_is_aligned:
-	mov  edi, [esp+60]
-; 366 "inffast.S"
-L_check_mmx:
-	cmp  dword ptr [inflate_fast_use_mmx],2
-	je   L_init_mmx
-	ja   L_do_loop
-
-	push  eax
-	push  ebx
-	push  ecx
-	push  edx
-	pushfd
-	mov  eax, [esp]
-	xor  dword ptr [esp],0200000h
-
-
-
-
-	popfd
-	pushfd
-	pop  edx
-	xor  edx,eax
-	jz   L_dont_use_mmx
-	xor  eax,eax
-	cpuid
-	cmp  ebx,0756e6547h
-	jne  L_dont_use_mmx
-	cmp  ecx,06c65746eh
-	jne  L_dont_use_mmx
-	cmp  edx,049656e69h
-	jne  L_dont_use_mmx
-	mov  eax,1
-	cpuid
-	shr  eax,8
-	and  eax,15
-	cmp  eax,6
-	jne  L_dont_use_mmx
-	test  edx,0800000h
-	jnz  L_use_mmx
-	jmp  L_dont_use_mmx
-L_use_mmx:
-	mov  dword ptr [inflate_fast_use_mmx],2
-	jmp  L_check_mmx_pop
-L_dont_use_mmx:
-	mov  dword ptr [inflate_fast_use_mmx],3
-L_check_mmx_pop:
-	pop  edx
-	pop  ecx
-	pop  ebx
-	pop  eax
-	jmp  L_check_mmx
-; 426 "inffast.S"
-ALIGN 4
-L_do_loop:
-; 437 "inffast.S"
-	cmp  bl,15
-	ja   L_get_length_code
-
-	xor  eax,eax
-	lodsw
-	mov  cl,bl
-	add  bl,16
-	shl  eax,cl
-	or  ebp,eax
-
-L_get_length_code:
-	mov  edx, [esp+0]
-	mov  ecx, [esp+8]
-	and  edx,ebp
-	mov  eax, [ecx+edx*4]
-
-L_dolen:
-
-
-
-
-
-
-	mov  cl,ah
-	sub  bl,ah
-	shr  ebp,cl
-
-
-
-
-
-
-	test  al,al
-	jnz   L_test_for_length_base
-
-	shr  eax,16
-	stosb
-
-L_while_test:
-
-
-	cmp  [esp+16],edi
-	jbe  L_break_loop
-
-	cmp  [esp+20],esi
-	ja   L_do_loop
-	jmp  L_break_loop
-
-L_test_for_length_base:
-; 502 "inffast.S"
-	mov  edx,eax
-	shr  edx,16
-	mov  cl,al
-
-	test  al,16
-	jz   L_test_for_second_level_length
-	and  cl,15
-	jz   L_save_len
-	cmp  bl,cl
-	jae  L_add_bits_to_len
-
-	mov  ch,cl
-	xor  eax,eax
-	lodsw
-	mov  cl,bl
-	add  bl,16
-	shl  eax,cl
-	or  ebp,eax
-	mov  cl,ch
-
-L_add_bits_to_len:
-	mov  eax,1
-	shl  eax,cl
-	dec  eax
-	sub  bl,cl
-	and  eax,ebp
-	shr  ebp,cl
-	add  edx,eax
-
-L_save_len:
-	mov  [esp+24],edx
-
-
-L_decode_distance:
-; 549 "inffast.S"
-	cmp  bl,15
-	ja   L_get_distance_code
-
-	xor  eax,eax
-	lodsw
-	mov  cl,bl
-	add  bl,16
-	shl  eax,cl
-	or  ebp,eax
-
-L_get_distance_code:
-	mov  edx, [esp+4]
-	mov  ecx, [esp+12]
-	and  edx,ebp
-	mov  eax, [ecx+edx*4]
-
-
-L_dodist:
-	mov  edx,eax
-	shr  edx,16
-	mov  cl,ah
-	sub  bl,ah
-	shr  ebp,cl
-; 584 "inffast.S"
-	mov  cl,al
-
-	test  al,16
-	jz  L_test_for_second_level_dist
-	and  cl,15
-	jz  L_check_dist_one
-	cmp  bl,cl
-	jae  L_add_bits_to_dist
-
-	mov  ch,cl
-	xor  eax,eax
-	lodsw
-	mov  cl,bl
-	add  bl,16
-	shl  eax,cl
-	or  ebp,eax
-	mov  cl,ch
-
-L_add_bits_to_dist:
-	mov  eax,1
-	shl  eax,cl
-	dec  eax
-	sub  bl,cl
-	and  eax,ebp
-	shr  ebp,cl
-	add  edx,eax
-	jmp  L_check_window
-
-L_check_window:
-; 625 "inffast.S"
-	mov  [esp+44],esi
-	mov  eax,edi
-	sub  eax, [esp+40]
-
-	cmp  eax,edx
-	jb   L_clip_window
-
-	mov  ecx, [esp+24]
-	mov  esi,edi
-	sub  esi,edx
-
-	sub  ecx,3
-	mov  al, [esi]
-	mov  [edi],al
-	mov  al, [esi+1]
-	mov  dl, [esi+2]
-	add  esi,3
-	mov  [edi+1],al
-	mov  [edi+2],dl
-	add  edi,3
-	rep movsb
-
-	mov  esi, [esp+44]
-	jmp  L_while_test
-
-ALIGN 4
-L_check_dist_one:
-	cmp  edx,1
-	jne  L_check_window
-	cmp  [esp+40],edi
-	je  L_check_window
-
-	dec  edi
-	mov  ecx, [esp+24]
-	mov  al, [edi]
-	sub  ecx,3
-
-	mov  [edi+1],al
-	mov  [edi+2],al
-	mov  [edi+3],al
-	add  edi,4
-	rep stosb
-
-	jmp  L_while_test
-
-ALIGN 4
-L_test_for_second_level_length:
-
-
-
-
-	test  al,64
-	jnz   L_test_for_end_of_block
-
-	mov  eax,1
-	shl  eax,cl
-	dec  eax
-	and  eax,ebp
-	add  eax,edx
-	mov  edx, [esp+8]
-	mov  eax, [edx+eax*4]
-	jmp  L_dolen
-
-ALIGN 4
-L_test_for_second_level_dist:
-
-
-
-
-	test  al,64
-	jnz   L_invalid_distance_code
-
-	mov  eax,1
-	shl  eax,cl
-	dec  eax
-	and  eax,ebp
-	add  eax,edx
-	mov  edx, [esp+12]
-	mov  eax, [edx+eax*4]
-	jmp  L_dodist
-
-ALIGN 4
-L_clip_window:
-; 721 "inffast.S"
-	mov  ecx,eax
-	mov  eax, [esp+52]
-	neg  ecx
-	mov  esi, [esp+56]
-
-	cmp  eax,edx
-	jb   L_invalid_distance_too_far
-
-	add  ecx,edx
-	cmp  dword ptr [esp+48],0
-	jne  L_wrap_around_window
-
-	sub  eax,ecx
-	add  esi,eax
-; 749 "inffast.S"
-	mov  eax, [esp+24]
-	cmp  eax,ecx
-	jbe  L_do_copy1
-
-	sub  eax,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,edx
-	jmp  L_do_copy1
-
-	cmp  eax,ecx
-	jbe  L_do_copy1
-
-	sub  eax,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,edx
-	jmp  L_do_copy1
-
-L_wrap_around_window:
-; 793 "inffast.S"
-	mov  eax, [esp+48]
-	cmp  ecx,eax
-	jbe  L_contiguous_in_window
-
-	add  esi, [esp+52]
-	add  esi,eax
-	sub  esi,ecx
-	sub  ecx,eax
-
-
-	mov  eax, [esp+24]
-	cmp  eax,ecx
-	jbe  L_do_copy1
-
-	sub  eax,ecx
-	rep movsb
-	mov  esi, [esp+56]
-	mov  ecx, [esp+48]
-	cmp  eax,ecx
-	jbe  L_do_copy1
-
-	sub  eax,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,edx
-	jmp  L_do_copy1
-
-L_contiguous_in_window:
-; 836 "inffast.S"
-	add  esi,eax
-	sub  esi,ecx
-
-
-	mov  eax, [esp+24]
-	cmp  eax,ecx
-	jbe  L_do_copy1
-
-	sub  eax,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,edx
-
-L_do_copy1:
-; 862 "inffast.S"
-	mov  ecx,eax
-	rep movsb
-
-	mov  esi, [esp+44]
-	jmp  L_while_test
-; 878 "inffast.S"
-ALIGN 4
-L_init_mmx:
-	emms
-
-
-
-
-
-	movd mm0,ebp
-	mov  ebp,ebx
-; 896 "inffast.S"
-	movd mm4,[esp+0]
-	movq mm3,mm4
-	movd mm5,[esp+4]
-	movq mm2,mm5
-	pxor mm1,mm1
-	mov  ebx, [esp+8]
-	jmp  L_do_loop_mmx
-
-ALIGN 4
-L_do_loop_mmx:
-	psrlq mm0,mm1
-
-	cmp  ebp,32
-	ja  L_get_length_code_mmx
-
-	movd mm6,ebp
-	movd mm7,[esi]
-	add  esi,4
-	psllq mm7,mm6
-	add  ebp,32
-	por mm0,mm7
-
-L_get_length_code_mmx:
-	pand mm4,mm0
-	movd eax,mm4
-	movq mm4,mm3
-	mov  eax, [ebx+eax*4]
-
-L_dolen_mmx:
-	movzx  ecx,ah
-	movd mm1,ecx
-	sub  ebp,ecx
-
-	test  al,al
-	jnz L_test_for_length_base_mmx
-
-	shr  eax,16
-	stosb
-
-L_while_test_mmx:
-
-
-	cmp  [esp+16],edi
-	jbe L_break_loop
-
-	cmp  [esp+20],esi
-	ja L_do_loop_mmx
-	jmp L_break_loop
-
-L_test_for_length_base_mmx:
-
-	mov  edx,eax
-	shr  edx,16
-
-	test  al,16
-	jz  L_test_for_second_level_length_mmx
-	and  eax,15
-	jz L_decode_distance_mmx
-
-	psrlq mm0,mm1
-	movd mm1,eax
-	movd ecx,mm0
-	sub  ebp,eax
-	and  ecx, [inflate_fast_mask+eax*4]
-	add  edx,ecx
-
-L_decode_distance_mmx:
-	psrlq mm0,mm1
-
-	cmp  ebp,32
-	ja L_get_dist_code_mmx
-
-	movd mm6,ebp
-	movd mm7,[esi]
-	add  esi,4
-	psllq mm7,mm6
-	add  ebp,32
-	por mm0,mm7
-
-L_get_dist_code_mmx:
-	mov  ebx, [esp+12]
-	pand mm5,mm0
-	movd eax,mm5
-	movq mm5,mm2
-	mov  eax, [ebx+eax*4]
-
-L_dodist_mmx:
-
-	movzx  ecx,ah
-	mov  ebx,eax
-	shr  ebx,16
-	sub  ebp,ecx
-	movd mm1,ecx
-
-	test  al,16
-	jz L_test_for_second_level_dist_mmx
-	and  eax,15
-	jz L_check_dist_one_mmx
-
-L_add_bits_to_dist_mmx:
-	psrlq mm0,mm1
-	movd mm1,eax
-	movd ecx,mm0
-	sub  ebp,eax
-	and  ecx, [inflate_fast_mask+eax*4]
-	add  ebx,ecx
-
-L_check_window_mmx:
-	mov  [esp+44],esi
-	mov  eax,edi
-	sub  eax, [esp+40]
-
-	cmp  eax,ebx
-	jb L_clip_window_mmx
-
-	mov  ecx,edx
-	mov  esi,edi
-	sub  esi,ebx
-
-	sub  ecx,3
-	mov  al, [esi]
-	mov  [edi],al
-	mov  al, [esi+1]
-	mov  dl, [esi+2]
-	add  esi,3
-	mov  [edi+1],al
-	mov  [edi+2],dl
-	add  edi,3
-	rep movsb
-
-	mov  esi, [esp+44]
-	mov  ebx, [esp+8]
-	jmp  L_while_test_mmx
-
-ALIGN 4
-L_check_dist_one_mmx:
-	cmp  ebx,1
-	jne  L_check_window_mmx
-	cmp  [esp+40],edi
-	je   L_check_window_mmx
-
-	dec  edi
-	mov  ecx,edx
-	mov  al, [edi]
-	sub  ecx,3
-
-	mov  [edi+1],al
-	mov  [edi+2],al
-	mov  [edi+3],al
-	add  edi,4
-	rep stosb
-
-	mov  ebx, [esp+8]
-	jmp  L_while_test_mmx
-
-ALIGN 4
-L_test_for_second_level_length_mmx:
-	test  al,64
-	jnz L_test_for_end_of_block
-
-	and  eax,15
-	psrlq mm0,mm1
-	movd ecx,mm0
-	and  ecx, [inflate_fast_mask+eax*4]
-	add  ecx,edx
-	mov  eax, [ebx+ecx*4]
-	jmp L_dolen_mmx
-
-ALIGN 4
-L_test_for_second_level_dist_mmx:
-	test  al,64
-	jnz L_invalid_distance_code
-
-	and  eax,15
-	psrlq mm0,mm1
-	movd ecx,mm0
-	and  ecx, [inflate_fast_mask+eax*4]
-	mov  eax, [esp+12]
-	add  ecx,ebx
-	mov  eax, [eax+ecx*4]
-	jmp  L_dodist_mmx
-
-ALIGN 4
-L_clip_window_mmx:
-
-	mov  ecx,eax
-	mov  eax, [esp+52]
-	neg  ecx
-	mov  esi, [esp+56]
-
-	cmp  eax,ebx
-	jb  L_invalid_distance_too_far
-
-	add  ecx,ebx
-	cmp  dword ptr [esp+48],0
-	jne  L_wrap_around_window_mmx
-
-	sub  eax,ecx
-	add  esi,eax
-
-	cmp  edx,ecx
-	jbe  L_do_copy1_mmx
-
-	sub  edx,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,ebx
-	jmp  L_do_copy1_mmx
-
-	cmp  edx,ecx
-	jbe  L_do_copy1_mmx
-
-	sub  edx,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,ebx
-	jmp  L_do_copy1_mmx
-
-L_wrap_around_window_mmx:
-
-	mov  eax, [esp+48]
-	cmp  ecx,eax
-	jbe  L_contiguous_in_window_mmx
-
-	add  esi, [esp+52]
-	add  esi,eax
-	sub  esi,ecx
-	sub  ecx,eax
-
-
-	cmp  edx,ecx
-	jbe  L_do_copy1_mmx
-
-	sub  edx,ecx
-	rep movsb
-	mov  esi, [esp+56]
-	mov  ecx, [esp+48]
-	cmp  edx,ecx
-	jbe  L_do_copy1_mmx
-
-	sub  edx,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,ebx
-	jmp  L_do_copy1_mmx
-
-L_contiguous_in_window_mmx:
-
-	add  esi,eax
-	sub  esi,ecx
-
-
-	cmp  edx,ecx
-	jbe  L_do_copy1_mmx
-
-	sub  edx,ecx
-	rep movsb
-	mov  esi,edi
-	sub  esi,ebx
-
-L_do_copy1_mmx:
-
-
-	mov  ecx,edx
-	rep movsb
-
-	mov  esi, [esp+44]
-	mov  ebx, [esp+8]
-	jmp  L_while_test_mmx
-; 1174 "inffast.S"
-L_invalid_distance_code:
-
-
-
-
-
-	mov  ecx, invalid_distance_code_msg
-	mov  edx,26
-	jmp  L_update_stream_state
-
-L_test_for_end_of_block:
-
-
-
-
-
-	test  al,32
-	jz  L_invalid_literal_length_code
-
-	mov  ecx,0
-	mov  edx,11
-	jmp  L_update_stream_state
-
-L_invalid_literal_length_code:
-
-
-
-
-
-	mov  ecx, invalid_literal_length_code_msg
-	mov  edx,26
-	jmp  L_update_stream_state
-
-L_invalid_distance_too_far:
-
-
-
-	mov  esi, [esp+44]
-	mov  ecx, invalid_distance_too_far_msg
-	mov  edx,26
-	jmp  L_update_stream_state
-
-L_update_stream_state:
-
-	mov  eax, [esp+88]
-	test  ecx,ecx
-	jz  L_skip_msg
-	mov  [eax+24],ecx
-L_skip_msg:
-	mov  eax, [eax+28]
-	mov  [eax+mode_state],edx
-	jmp  L_break_loop
-
-ALIGN 4
-L_break_loop:
-; 1243 "inffast.S"
-	cmp  dword ptr [inflate_fast_use_mmx],2
-	jne  L_update_next_in
-
-
-
-	mov  ebx,ebp
-
-L_update_next_in:
-; 1266 "inffast.S"
-	mov  eax, [esp+88]
-	mov  ecx,ebx
-	mov  edx, [eax+28]
-	shr  ecx,3
-	sub  esi,ecx
-	shl  ecx,3
-	sub  ebx,ecx
-	mov  [eax+12],edi
-	mov  [edx+bits_state],ebx
-	mov  ecx,ebx
-
-	lea  ebx, [esp+28]
-	cmp  [esp+20],ebx
-	jne  L_buf_not_used
-
-	sub  esi,ebx
-	mov  ebx, [eax+0]
-	mov  [esp+20],ebx
-	add  esi,ebx
-	mov  ebx, [eax+4]
-	sub  ebx,11
-	add  [esp+20],ebx
-
-L_buf_not_used:
-	mov  [eax+0],esi
-
-	mov  ebx,1
-	shl  ebx,cl
-	dec  ebx
-
-
-
-
-
-	cmp  dword ptr [inflate_fast_use_mmx],2
-	jne  L_update_hold
-
-
-
-	psrlq mm0,mm1
-	movd ebp,mm0
-
-	emms
-
-L_update_hold:
-
-
-
-	and  ebp,ebx
-	mov  [edx+hold_state],ebp
-
-
-
-
-	mov  ebx, [esp+20]
-	cmp  ebx,esi
-	jbe  L_last_is_smaller
-
-	sub  ebx,esi
-	add  ebx,11
-	mov  [eax+4],ebx
-	jmp  L_fixup_out
-L_last_is_smaller:
-	sub  esi,ebx
-	neg  esi
-	add  esi,11
-	mov  [eax+4],esi
-
-
-
-
-L_fixup_out:
-
-	mov  ebx, [esp+16]
-	cmp  ebx,edi
-	jbe  L_end_is_smaller
-
-	sub  ebx,edi
-	add  ebx,257
-	mov  [eax+16],ebx
-	jmp  L_done
-L_end_is_smaller:
-	sub  edi,ebx
-	neg  edi
-	add  edi,257
-	mov  [eax+16],edi
-
-
-
-
-
-L_done:
-	add  esp,64
-	popfd
-	pop  ebx
-	pop  ebp
-	pop  esi
-	pop  edi
-	ret
-
-
-
-
-_TEXT	ends
-end
diff --git a/cpukit/zlib/contrib/masmx86/mkasm.bat b/cpukit/zlib/contrib/masmx86/mkasm.bat
deleted file mode 100755
index 70a51f8377..0000000000
--- a/cpukit/zlib/contrib/masmx86/mkasm.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-cl /DASMV /I..\.. /O2 /c gvmat32c.c

-ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm

-ml /coff /Zi /c /Flinffas32.lst inffas32.asm

diff --git a/cpukit/zlib/contrib/masmx86/readme.txt b/cpukit/zlib/contrib/masmx86/readme.txt
deleted file mode 100644
index 7b57167b71..0000000000
--- a/cpukit/zlib/contrib/masmx86/readme.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-Summary
--------
-This directory contains ASM implementations of the functions
-longest_match() and inflate_fast().
-
-
-Use instructions
-----------------
-Copy these files into the zlib source directory, then run the
-appropriate makefile, as suggested below.
-
-
-Build instructions
-------------------
-* With Microsoft C and MASM:
-nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj"
-
-* With Borland C and TASM:
-make -f win32/Makefile.bor LOCAL_ZLIB="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj" OBJPA="+gvmat32c.obj+gvmat32.obj+inffas32.obj"
-