Power-Programmierung/CD2.mdf/gnu/djgpp/diffs/infozip/zip19p1/match.s

Text File | 1993-12-14 | 10.4 KB | 236 lines

*** orig/infozip/zip19p1/match.s    Sat Sep  4 15:55:44 1993
--- src/infozip/zip19p1/match.s    Sat Sep  4 16:00:22 1993
***************
*** 1,20 ****
! /
! / Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly,
! / Kai Uwe Rommel and Igor Mandrichenko.
! / Permission is granted to any individual or institution to use, copy, or
! / redistribute this software so long as all of the original files are included
! / unmodified, that it is not sold for profit, and that this copyright notice
! / is retained.
! /
! / match.s by Jean-loup Gailly. Translated to 32 bit code by Kai Uwe Rommel.
!
! / match.s, optimized version of longest_match() in deflate.c
! / This version is for 386 Unix or OS/2 in 32 bit mode.
! / Warning: it uses the AT&T syntax: mov source,dest
! / This file is only optional. If you want to force the C version,
! / add -DNO_ASM to CFLAGS in makefile and remove match.o from OBJI).
! / If you have reduced WSIZE in zip.h, then change its value below.
! / This version assumes static allocation of the arrays (-DDYN_ALLOC not used).

      .file   "match.s"

--- 1,21 ----
! /* */
! /* Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly, */
! /* Kai Uwe Rommel and Igor Mandrichenko. */
! /* Permission is granted to any individual or institution to use, copy, or */
! /* redistribute this software so long as all of the original files are included */
! /* unmodified, that it is not sold for profit, and that this copyright notice */
! /* is retained. */
! /* */
! /* match.s by Jean-loup Gailly. Translated to 32 bit code by Kai Uwe Rommel. */
! /* syntax changed for gas 2.1.1 by DJ Delorie [e-mail] */
!
! /* match.s, optimized version of longest_match() in deflate.c */
! /* This version is for 386 Unix or OS/2 in 32 bit mode. */
! /* Warning: it uses the AT&T syntax: mov source,dest */
! /* This file is only optional. If you want to force the C version, */
! /* add -DNO_ASM to CFLAGS in makefile and remove match.o from OBJI). */
! /* If you have reduced WSIZE in zip.h, then change its value below. */
! /* This version assumes static allocation of the arrays (-DDYN_ALLOC not used). */

      .file   "match.s"

***************
*** 49,141 ****
  _match_init:
      ret

! / -----------------------------------------------------------------------
! / Set match_start to the longest match starting at the given string and
! / return its length. Matches shorter or equal to prev_length are discarded,
! / in which case the result is equal to prev_length and match_start is
! / garbage.
! / IN assertions: cur_match is the head of the hash chain for the current
! /   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1

  _longest_match:    /* int longest_match(cur_match) */

  #define cur_match   20(%esp)
!         / return address                / esp+16
!         push    %ebp                    / esp+12
!         push    %edi                    / esp+8
!     push    %esi                    / esp+4
!     push    %ebx            / esp
!
! /       match        equ esi
! /       scan         equ edi
! /       chain_length equ ebp
! /       best_len     equ ebx
! /       limit        equ edx

      mov     cur_match,%esi
!         mov     _max_chain_length,%ebp  / chain_length = max_chain_length
      mov     _strstart,%edi
      mov     %edi,%edx
!     sub    $ MAX_DIST,%edx         / limit = strstart-MAX_DIST
      jae    limit_ok
!     sub    %edx,%edx               / limit = NIL
  limit_ok:
!         add    $_window+2,%edi         / edi = offset(window + strstart + 2)
!         mov    _prev_length,%ebx       / best_len = prev_length
!         movw     -3(%ebx,%edi),%ax       / ax = scan[best_len-1..best_len]
!         movw     -2(%edi),%cx            / cx = scan[0..1]
!     cmp    _good_match,%ebx        / do we have a good match already?
          jb      do_scan
!     shr     $2,%ebp                 / chain_length >>= 2
          jmp     do_scan

          .align  4
  long_loop:
! / at this point, edi == scan+2, esi == cur_match
!         movw    -3(%ebx,%edi),%ax       / ax = scan[best_len-1..best_len]
!         movw     -2(%edi),%cx            / cx = scan[0..1]
  short_loop:
!         dec     %ebp                    / --chain_length
          jz      the_end
! / at this point, di == scan+2, si == cur_match,
! / ax = scan[best_len-1..best_len] and cx = scan[0..1]
!         and     $ WSIZE-1, %esi
!         movw     _prev(%esi,%esi),%si    / cur_match = prev[cur_match]
!                                         / top word of esi is still 0
!         cmp     %edx,%esi        / cur_match <= limit ?
          jbe     the_end
  do_scan:
!         cmpw    _window-1(%ebx,%esi),%ax /check match at best_len-1
          jne     short_loop
!         cmpw    _window(%esi),%cx       / check min_match_length match
          jne     short_loop

!         lea     _window+2(%esi),%esi    / si = match
!         mov     %edi,%eax               / ax = scan+2
!         mov     $ MAX_MATCH2,%ecx       / scan for at most MAX_MATCH bytes
  #ifdef unix
!         repz;   cmpsw                   / loop until mismatch
  #else
          repe;   cmpsw
  #endif
!         je      maxmatch                / match of length MAX_MATCH?
  mismatch:
!         movb    -2(%edi),%cl            / mismatch on first or second byte?
!         subb    -2(%esi),%cl            / cl = 0 if first bytes equal
!         xchg    %edi,%eax               / edi = scan+2, eax = end of scan
!         sub     %edi,%eax               / eax = len
!     sub    %eax,%esi               / esi = cur_match + 2 + offset(window)
!     sub    $_window+2,%esi         / esi = cur_match
!         subb    $1,%cl                  / set carry if cl == 0 (cannot use DEC)
!         adc     $0,%eax                 / eax = carry ? len+1 : len
!         cmp     %ebx,%eax               / len > best_len ?
          jle     long_loop
!         mov     %esi,_match_start       / match_start = cur_match
!         mov     %eax,%ebx               / ebx = best_len = len
!         cmp     $ MAX_MATCH,%eax        / len >= MAX_MATCH ?
          jl      long_loop
  the_end:
!         mov     %ebx,%eax               / result = eax = best_len
      pop     %ebx
          pop     %esi
          pop     %edi
--- 50,142 ----
  _match_init:
      ret

! /* ----------------------------------------------------------------------- */
! /* Set match_start to the longest match starting at the given string and */
! /* return its length. Matches shorter or equal to prev_length are discarded, */
! /* in which case the result is equal to prev_length and match_start is */
! /* garbage. */
! /* IN assertions: cur_match is the head of the hash chain for the current */
! /*   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 */

  _longest_match:    /* int longest_match(cur_match) */

  #define cur_match   20(%esp)
!         /* return address                / esp+16 */
!         push    %ebp                    /* esp+12 */
!         push    %edi                    /* esp+8 */
!     push    %esi                    /* esp+4 */
!     push    %ebx            /* esp */
!
! /*       match        equ esi */
! /*       scan         equ edi */
! /*       chain_length equ ebp */
! /*       best_len     equ ebx */
! /*       limit        equ edx */

      mov     cur_match,%esi
!         mov     _max_chain_length,%ebp  /* chain_length = max_chain_length */
      mov     _strstart,%edi
      mov     %edi,%edx
!     sub    $(MAX_DIST),%edx         /* limit = strstart-MAX_DIST */
      jae    limit_ok
!     sub    %edx,%edx               /* limit = NIL */
  limit_ok:
!         add    $_window+2,%edi         /* edi = offset(window + strstart + 2) */
!         mov    _prev_length,%ebx       /* best_len = prev_length */
!         movw     -3(%ebx,%edi),%ax       /* ax = scan[best_len-1..best_len] */
!         movw     -2(%edi),%cx            /* cx = scan[0..1] */
!     cmp    _good_match,%ebx        /* do we have a good match already? */
          jb      do_scan
!     shr     $2,%ebp                 /* chain_length >>= 2 */
          jmp     do_scan

          .align  4
  long_loop:
! /* at this point, edi == scan+2, esi == cur_match */
!         movw    -3(%ebx,%edi),%ax       /* ax = scan[best_len-1..best_len] */
!         movw     -2(%edi),%cx            /* cx = scan[0..1] */
  short_loop:
!         dec     %ebp                    /* --chain_length */
          jz      the_end
! /* at this point, di == scan+2, si == cur_match, */
! /* ax = scan[best_len-1..best_len] and cx = scan[0..1] */
!         and     $(WSIZE-1), %esi
!         movw     _prev(%esi,%esi),%si    /* cur_match = prev[cur_match] */
!                                         /* top word of esi is still 0 */
!         cmp     %edx,%esi        /* cur_match <= limit ? */
          jbe     the_end
  do_scan:
!         cmpw    _window-1(%ebx,%esi),%ax /* check match at best_len-1 */
          jne     short_loop
!         cmpw    _window(%esi),%cx       /* check min_match_length match */
          jne     short_loop

!         lea     _window+2(%esi),%esi    /* si = match */
!         mov     %edi,%eax               /* ax = scan+2 */
!         mov     $(MAX_MATCH2),%ecx       /* scan for at most MAX_MATCH bytes */
  #ifdef unix
!         repz;   cmpsw                   /* loop until mismatch */
  #else
          repe;   cmpsw
  #endif
!         je      maxmatch                /* match of length MAX_MATCH? */
  mismatch:
!         movb    -2(%edi),%cl            /* mismatch on first or second byte? */
!         subb    -2(%esi),%cl            /* cl = 0 if first bytes equal */
!         xchg    %edi,%eax               /* edi = scan+2, eax = end of scan */
!         sub     %edi,%eax               /* eax = len */
!     sub    %eax,%esi               /* esi = cur_match + 2 + offset(window) */
!     sub    $_window+2,%esi         /* esi = cur_match */
!         subb    $1,%cl                  /* set carry if cl == 0 (cannot use DEC) */
!         adc     $0,%eax                 /* eax = carry ? len+1 : len */
!         cmp     %ebx,%eax               /* len > best_len ? */
          jle     long_loop
!         mov     %esi,_match_start       /* match_start = cur_match */
!         mov     %eax,%ebx               /* ebx = best_len = len */
!         cmp     $(MAX_MATCH),%eax       /* len >= MAX_MATCH ? */
          jl      long_loop
  the_end:
!         mov     %ebx,%eax               /* result = eax = best_len */
      pop     %ebx
          pop     %esi
          pop     %edi