--- /dev/null
+/* match.s -- optional optimized asm version of longest match in deflate.c
+
+ Copyright (C) 2002, 2006 Free Software Foundation, Inc.
+ Copyright (C) 1992-1993 Jean-loup Gailly
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
+
+/*
+ * The 68020 version has been written by Francesco Potorti` <pot@cnuce.cnr.it>
+ * with adaptations by Carsten Steger <stegerc@informatik.tu-muenchen.de>,
+ * Andreas Schwab <schwab@lamothe.informatik.uni-dortmund.de> and
+ * Kristoffer Eriksson <ske@pkmab.se>
+ *
+ * The ia64 version has been written by Sverre Jarp (HP Labs) 2001-2002.
+ * Unwind directives and some reformatting for better readability added by
+ * David Mosberger-Tang <davidm@hpl.hp.com>.
+ */
+
+/* $Id: match.c,v 1.1 2006/11/20 08:40:34 eggert Exp $ */
+
+/* Preprocess with -DNO_UNDERLINE if your C compiler does not prefix
+ * external symbols with an underline character '_'.
+ */
+#ifdef NO_UNDERLINE
+# define _prev prev
+# define _window window
+# define _match_start match_start
+# define _prev_length prev_length
+# define _good_match good_match
+# define _nice_match nice_match
+# define _strstart strstart
+# define _max_chain_length max_chain_length
+
+# define _match_init match_init
+# define _longest_match longest_match
+#endif
+
+#ifdef DYN_ALLOC
+ error: DYN_ALLOC not yet supported in match.s
+#endif
+
+#if defined(i386) || defined(_I386) || defined(__i386) || defined(__i386__)
+
+/* 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 set OBJA to an empty string.
+ * If you have reduced WSIZE in gzip.h, then change its value below.
+ * This version assumes static allocation of the arrays (-DDYN_ALLOC not used).
+ */
+
+ .file "match.S"
+
+#define MAX_MATCH 258
+#define MAX_MATCH2 $128 /* MAX_MATCH/2-1 */
+#define MIN_MATCH 3
+#define WSIZE $32768
+#define MAX_DIST WSIZE - MAX_MATCH - MIN_MATCH - 1
+
+ .globl _match_init
+ .globl _longest_match
+
+ .text
+
+_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 $2+_window,%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:
+/*
+ * 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
+ dec %ebp /* --chain_length */
+ jz 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 */
+ rep; cmpsw /* loop until mismatch */
+ 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 $2+_window,%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 _nice_match,%eax /* len >= nice_match ? */
+ jl long_loop
+the_end:
+ mov %ebx,%eax /* result = eax = best_len */
+ pop %ebx
+ pop %esi
+ pop %edi
+ pop %ebp
+ ret
+maxmatch:
+ cmpsb
+ jmp mismatch
+
+#else
+
+/* ======================== 680x0 version ================================= */
+
+#if defined(m68k)||defined(mc68k)||defined(__mc68000__)||defined(__MC68000__)
+# ifndef mc68000
+# define mc68000
+# endif
+#endif
+
+#if defined(__mc68020__) || defined(__MC68020__) || defined(sysV68)
+# ifndef mc68020
+# define mc68020
+# endif
+#endif
+
+#if defined(mc68020) || defined(mc68000)
+
+#if (defined(mc68020) || defined(NeXT)) && !defined(UNALIGNED_OK)
+# define UNALIGNED_OK
+#endif
+
+#ifdef sysV68 /* Try Motorola Delta style */
+
+# define GLOBAL(symbol) global symbol
+# define TEXT text
+# define FILE(filename) file filename
+# define invert_maybe(src,dst) dst,src
+# define imm(data) &data
+# define reg(register) %register
+
+# define addl add.l
+# define addql addq.l
+# define blos blo.b
+# define bhis bhi.b
+# define bras bra.b
+# define clrl clr.l
+# define cmpmb cmpm.b
+# define cmpw cmp.w
+# define cmpl cmp.l
+# define lslw lsl.w
+# define lsrl lsr.l
+# define movel move.l
+# define movew move.w
+# define moveb move.b
+# define moveml movem.l
+# define subl sub.l
+# define subw sub.w
+# define subql subq.l
+
+# define IndBase(bd,An) (bd,An)
+# define IndBaseNdxl(bd,An,Xn) (bd,An,Xn.l)
+# define IndBaseNdxw(bd,An,Xn) (bd,An,Xn.w)
+# define predec(An) -(An)
+# define postinc(An) (An)+
+
+#else /* default style (Sun 3, NeXT, Amiga, Atari) */
+
+# define GLOBAL(symbol) .globl symbol
+# define TEXT .text
+# define FILE(filename) .even
+# define invert_maybe(src,dst) src,dst
+# if defined(sun) || defined(mc68k)
+# define imm(data) #data
+# else
+# define imm(data) \#data
+# endif
+# define reg(register) register
+
+# define blos bcss
+# if defined(sun) || defined(mc68k)
+# define movel movl
+# define movew movw
+# define moveb movb
+# endif
+# define IndBase(bd,An) An@(bd)
+# define IndBaseNdxl(bd,An,Xn) An@(bd,Xn:l)
+# define IndBaseNdxw(bd,An,Xn) An@(bd,Xn:w)
+# define predec(An) An@-
+# define postinc(An) An@+
+
+#endif /* styles */
+
+#define Best_Len reg(d0) /* unsigned */
+#define Cur_Match reg(d1) /* Ipos */
+#define Loop_Counter reg(d2) /* int */
+#define Scan_Start reg(d3) /* unsigned short */
+#define Scan_End reg(d4) /* unsigned short */
+#define Limit reg(d5) /* IPos */
+#define Chain_Length reg(d6) /* unsigned */
+#define Scan_Test reg(d7)
+#define Scan reg(a0) /* *uch */
+#define Match reg(a1) /* *uch */
+#define Prev_Address reg(a2) /* *Pos */
+#define Scan_Ini reg(a3) /* *uch */
+#define Match_Ini reg(a4) /* *uch */
+#define Stack_Pointer reg(sp)
+
+#define MAX_MATCH 258
+#define MIN_MATCH 3
+#define WSIZE 32768
+#define MAX_DIST (WSIZE - MAX_MATCH - MIN_MATCH - 1)
+
+ GLOBAL (_match_init)
+ GLOBAL (_longest_match)
+
+ TEXT
+
+ FILE ("match.S")
+
+_match_init:
+ rts
+
+/*-----------------------------------------------------------------------
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ */
+
+/* int longest_match (cur_match) */
+
+#ifdef UNALIGNED_OK
+# define pushreg 15928 /* d2-d6/a2-a4 */
+# define popreg 7292
+#else
+# define pushreg 16184 /* d2-d7/a2-a4 */
+# define popreg 7420
+#endif
+
+_longest_match:
+ movel IndBase(4,Stack_Pointer),Cur_Match
+ moveml imm(pushreg),predec(Stack_Pointer)
+ movel _max_chain_length,Chain_Length
+ movel _prev_length,Best_Len
+ movel imm(_prev),Prev_Address
+ movel imm(_window+MIN_MATCH),Match_Ini
+ movel _strstart,Limit
+ movel Match_Ini,Scan_Ini
+ addl Limit,Scan_Ini
+ subw imm(MAX_DIST),Limit
+ bhis L__limit_ok
+ clrl Limit
+L__limit_ok:
+ cmpl invert_maybe(_good_match,Best_Len)
+ blos L__length_ok
+ lsrl imm(2),Chain_Length
+L__length_ok:
+ subql imm(1),Chain_Length
+#ifdef UNALIGNED_OK
+ movew IndBase(-MIN_MATCH,Scan_Ini),Scan_Start
+ movew IndBaseNdxw(-MIN_MATCH-1,Scan_Ini,Best_Len),Scan_End
+#else
+ moveb IndBase(-MIN_MATCH,Scan_Ini),Scan_Start
+ lslw imm(8),Scan_Start
+ moveb IndBase(-MIN_MATCH+1,Scan_Ini),Scan_Start
+ moveb IndBaseNdxw(-MIN_MATCH-1,Scan_Ini,Best_Len),Scan_End
+ lslw imm(8),Scan_End
+ moveb IndBaseNdxw(-MIN_MATCH,Scan_Ini,Best_Len),Scan_End
+#endif
+ bras L__do_scan
+
+L__long_loop:
+#ifdef UNALIGNED_OK
+ movew IndBaseNdxw(-MIN_MATCH-1,Scan_Ini,Best_Len),Scan_End
+#else
+ moveb IndBaseNdxw(-MIN_MATCH-1,Scan_Ini,Best_Len),Scan_End
+ lslw imm(8),Scan_End
+ moveb IndBaseNdxw(-MIN_MATCH,Scan_Ini,Best_Len),Scan_End
+#endif
+
+L__short_loop:
+ lslw imm(1),Cur_Match
+ movew IndBaseNdxl(0,Prev_Address,Cur_Match),Cur_Match
+ cmpw invert_maybe(Limit,Cur_Match)
+ dbls Chain_Length,L__do_scan
+ bras L__return
+
+L__do_scan:
+ movel Match_Ini,Match
+ addl Cur_Match,Match
+#ifdef UNALIGNED_OK
+ cmpw invert_maybe(IndBaseNdxw(-MIN_MATCH-1,Match,Best_Len),Scan_End)
+ bne L__short_loop
+ cmpw invert_maybe(IndBase(-MIN_MATCH,Match),Scan_Start)
+ bne L__short_loop
+#else
+ moveb IndBaseNdxw(-MIN_MATCH-1,Match,Best_Len),Scan_Test
+ lslw imm(8),Scan_Test
+ moveb IndBaseNdxw(-MIN_MATCH,Match,Best_Len),Scan_Test
+ cmpw invert_maybe(Scan_Test,Scan_End)
+ bne L__short_loop
+ moveb IndBase(-MIN_MATCH,Match),Scan_Test
+ lslw imm(8),Scan_Test
+ moveb IndBase(-MIN_MATCH+1,Match),Scan_Test
+ cmpw invert_maybe(Scan_Test,Scan_Start)
+ bne L__short_loop
+#endif
+
+ movew imm((MAX_MATCH-MIN_MATCH+1)-1),Loop_Counter
+ movel Scan_Ini,Scan
+L__scan_loop:
+ cmpmb postinc(Match),postinc(Scan)
+ dbne Loop_Counter,L__scan_loop
+
+ subl Scan_Ini,Scan
+ addql imm(MIN_MATCH-1),Scan
+ cmpl invert_maybe(Best_Len,Scan)
+ bls L__short_loop
+ movel Scan,Best_Len
+ movel Cur_Match,_match_start
+ cmpl invert_maybe(_nice_match,Best_Len)
+ blos L__long_loop
+L__return:
+ moveml postinc(Stack_Pointer),imm(popreg)
+ rts
+
+#else
+
+# if defined (__ia64__)
+
+/* ======================== ia64 version ================================= */
+
+/*
+ * 'longest_match.S' (assembly program for gzip for the IA-64 architecture)
+ *
+ * Optimised for McKinley, but with Merced-compatibility, such as MIB+MIB, used wherever
+ * possible.
+ *
+ * Copyright: Sverre Jarp (HP Labs) 2001-2002
+ *
+ * See deflate.c for c-version
+ * Version 2 - Optimize the outer loop
+ */
+
+#include <endian.h>
+
+#if __BYTE_ORDER == ____BIG_ENDIAN
+#define first shl
+#define second shr.u
+#define count czx1.l
+#else
+#define first shr.u
+#define second shl
+#define count czx1.r
+#endif
+
+// 24 rotating register (r32 - r55)
+
+#define s_vmatch0 r32
+#define s_vmatch1 r33
+#define s_vmatbst r34
+#define s_vmatbst1 r35
+#define s_amatblen r36
+
+#define s_tm1 r56
+#define s_tm2 r57
+#define s_tm3 r58
+#define s_tm4 r59
+#define s_tm5 r60
+#define s_tm6 r61
+#define s_tm7 r62
+#define s_tm8 r63
+
+#define s_vlen r31
+#define s_vstrstart r30
+#define s_vchainlen r29
+#define s_awinbest r28
+#define s_vcurmatch r27
+#define s_vlimit r26
+#define s_vscanend r25
+#define s_vscanend1 r24
+#define s_anicematch r23
+#define s_vscan0 r22
+#define s_vscan1 r21
+
+#define s_aprev r20
+#define s_awindow r19
+#define s_amatchstart r18
+#define s_ascan r17
+#define s_amatch r16
+#define s_wmask r15
+#define s_ascanend r14
+
+#define s_vspec_cmatch r11 // next iteration
+#define s_lcsave r10
+#define s_prsave r9
+#define s_vbestlen r8 // return register
+
+#define s_vscan3 r3
+#define s_vmatch3 r2
+
+#define p_no p2
+#define p_yes p3
+#define p_shf p4 //
+#define p_bn2 p5 // Use in loop (indicating bestlen != 2)
+
+#define p_nbs p9 // not new best_len
+#define p_nnc p10 // not nice_length
+#define p_ll p11
+#define p_end p12
+
+#define MAX_MATCH 258
+#define MIN_MATCH 4
+#define WSIZE 32768
+#define MAX_DIST WSIZE - MAX_MATCH - MIN_MATCH - 1
+
+#define R_INPUT 1
+#define R_LOCAL 31
+#define R_OUTPUT 0
+#define R_ROTATING 24
+#define MLAT 3
+#define SHLAT 2
+
+#define mova mov
+#define movi0 mov
+#define cgtu cmp.gt.unc
+#define cgeu cmp.ge.unc
+#define cneu cmp.ne.unc
+
+ .global longest_match
+ .proc longest_match
+ .align 32
+longest_match:
+// -- Cycle: 0
+ .prologue
+{.mmi
+ alloc r2=ar.pfs,R_INPUT,R_LOCAL,R_OUTPUT,R_ROTATING
+ .rotr scan[MLAT+2], match[MLAT+2], shscan0[SHLAT+1], \
+ shscan1[SHLAT+1], shmatch0[SHLAT+1], shmatch1[SHLAT+1]
+ .rotp lc[MLAT+SHLAT+2]
+ mova s_vspec_cmatch=in0 // cur_match from input register
+ add s_tm1=@gprel(strstart),gp // a(a(strstart))
+}{.mmi
+ add s_tm3=@gprel(prev_length),gp // a(a(prev_length))
+ add s_tm5=@ltoff(window),gp // a(a(window))
+ add s_tm6=@ltoff(prev),gp // a(a(prev))
+ ;;
+}{.mmb // Cycle: 1
+ ld4 s_vstrstart=[s_tm1] // strstart
+ ld4 s_vbestlen=[s_tm3] // best_len = prev_length
+ brp.loop.imp .cmploop,.cmploop+48
+}{.mli
+ add s_tm2=@gprel(max_chain_length),gp // a(a(max_chain_length))
+ movl s_wmask=WSIZE-1
+ ;;
+}{.mmi // Cycle: 2
+ ld8 s_aprev=[s_tm6] // a(prev)
+ ld8 s_awindow=[s_tm5] // a(window)
+ .save pr, s_prsave
+ movi0 s_prsave=pr // save predicates
+}{.mmi
+ add s_tm4=@gprel(good_match),gp // a(a(good_match))
+ add s_tm7=@ltoff(nice_match),gp // a(a(nice_match))
+ add s_tm8=@ltoff(match_start),gp // a(match_start)
+ ;;
+}{.mmi // Cycle: 3
+ ld8 s_anicematch=[s_tm7] // a(nice_match)
+ ld8 s_amatchstart=[s_tm8] // a(match_start)
+ .save ar.lc, s_lcsave
+ movi0 s_lcsave=ar.lc // save loop count register
+}{.mmi
+ .body
+ add s_tm1=-(MAX_MATCH + MIN_MATCH),s_wmask // maxdist
+ cmp.eq p_ll,p0=r0,r0 // parallel compare initialized as 'true'
+ mova s_vcurmatch=s_vspec_cmatch
+ ;;
+}{.mmi // Cycle: 4
+ ld4 s_vchainlen=[s_tm2] // chain_length=max_chain_length
+ ld4 s_tm4=[s_tm4] // v(good_match)
+ add s_ascan=s_awindow,s_vstrstart // scan=window + strstart
+}{.mmi
+ sub s_vlimit=s_vstrstart, s_tm1 // limit=strstart - MAX_DIST
+ add s_amatch=s_awindow,s_vspec_cmatch // match=window + cur_match
+ and s_vspec_cmatch =s_vspec_cmatch,s_wmask
+ ;;
+}{.mmi // Cycle: 5
+ add s_amatblen=s_amatch,s_vbestlen //
+ cneu p_bn2,p0=2,s_vbestlen // set if bestlen != 2
+ add s_ascanend=s_ascan,s_vbestlen // compute a(scan) + best_len
+}{.mmi
+ ld1 s_vscan0=[s_ascan],1 // NB: s_ascan++
+ ld1 s_vmatch0=[s_amatch],1
+ cgtu p0,p_no=s_vlimit,r0 // is result positive ?
+ ;;
+}{.mmi // Cycle: 6
+ ld1.nt1 s_vscan1=[s_ascan],2 // NB: s_ascan+3 in total
+ ld1.nt1 s_vmatch1=[s_amatch],2
+ add s_awinbest=s_awindow,s_vbestlen //
+ ;;
+}{.mmi // Cycle: 7
+ ld1.nt1 s_vscanend=[s_ascanend],-1 // scan_end=scan[best_len]
+ ld1.nt1 s_vmatbst=[s_amatblen],-1
+(p_no) mova s_vlimit=r0
+ ;;
+}{.mmi // Cycle: 8
+(p_bn2) ld1.nt1 s_vscanend1=[s_ascanend],1 // scan_end1=scan[best_len-1]
+(p_bn2) ld1.nt1 s_vmatbst1=[s_amatblen]
+ shladd s_vspec_cmatch =s_vspec_cmatch,1,s_aprev
+}{.mmi
+ cgeu p_shf,p0=s_vbestlen,s_tm4 // is (prev_length >= good_match) ?
+ ;;
+}{.mmi // Cycle: 9
+ ld1.nt1 s_vscan3=[s_ascan]
+ ld2.nt1 s_vspec_cmatch=[s_vspec_cmatch]
+ mova s_vlen=3
+}{.mmi
+(p_shf) shr.u s_vchainlen=s_vchainlen,2 // (cur_len) >> 2
+ ;;
+}{.mmi // Cycle: 10
+ ld1.nt1 s_vmatch3=[s_amatch]
+ // p_ll switched on as soon as we get a mismatch:
+ cmp.eq.and p_ll,p0=s_vmatch0,s_vscan0
+ cmp.eq.and p_ll,p0=s_vmatbst,s_vscanend
+}{.mib
+ cmp.eq.and p_ll,p0=s_vmatch1,s_vscan1
+(p_bn2) cmp.eq.and p_ll,p0=s_vmatbst1,s_vscanend1
+(p_ll) br.cond.dpnt.many .test_more
+ ;;
+}
+
+.next_iter:
+{.mmi // Cycle 0
+ add s_amatch=s_awindow,s_vspec_cmatch // match=window + cur_match
+ mov s_vcurmatch=s_vspec_cmatch // current value
+ add s_vchainlen=-1,s_vchainlen // --chain_length
+}{.mib
+ cmp.le.unc p_end,p0=s_vspec_cmatch,s_vlimit
+ and s_vspec_cmatch=s_vspec_cmatch,s_wmask
+(p_end) br.cond.dptk.many .terminate
+ ;;
+}{.mmi // Cycle 1
+ ld1 s_vmatch0=[s_amatch],1 // load match[0]
+ // compute prev[cur_match]:
+ shladd s_vspec_cmatch=s_vspec_cmatch,1,s_aprev
+ cmp.eq.unc p_end,p0=s_vchainlen,r0
+} {.mib
+ nop.m 0
+ add s_amatblen=s_awinbest,s_vcurmatch // match=window + cur_match
+(p_end) br.cond.dptk.many .terminate
+ ;;
+}{.mmi // Cycle 2 (short)
+ ld2.nt1 s_vspec_cmatch=[s_vspec_cmatch] // get next cur_match
+ ;;
+}{.mmi // Cycle 3 (short)
+ ld1.nt1 s_vmatbst=[s_amatblen],-1 // load match[best_len]
+ cmp.ne.unc p_ll,p0=r0,r0 // parallel compare initialized as 'false'
+ ;;
+}{.mmi // Cycle 4 (short)
+ // load match[1] - - note: match += 3 (in total):
+ ld1.nt1 s_vmatch1=[s_amatch],2
+ ;;
+ // Cycle 5 (short)
+(p_bn2) ld1.nt1 s_vmatbst1=[s_amatblen] // load match[best_len-1]
+}{.mib // Here we (MOST LIKELY) pay a L2-fetch stall
+ // p_ll switched on as soon as we get a mismatch:
+ cmp.ne.or p_ll,p0=s_vmatch0,s_vscan0
+ cmp.ne.or p_ll,p0=s_vmatbst,s_vscanend
+(p_ll) br.cond.dptk.many .next_iter
+ ;;
+}{.mmi // Cycle 6
+ ld1.nt1 s_vmatch3=[s_amatch]
+ mova s_vlen=3
+ nop.i 0
+}{.mib
+ cmp.ne.or p_ll,p0=s_vmatch1,s_vscan1
+(p_bn2) cmp.ne.or p_ll,p0=s_vmatbst1,s_vscanend1
+(p_ll) br.cond.dptk.many .next_iter
+ ;;
+}
+
+// We have passed the first hurdle - Are there additional matches ???
+
+.test_more:
+{.mmi // Cycle 0
+ and s_tm3=7,s_ascan // get byte offset
+ and s_tm4=7,s_amatch // get byte offset
+ movi0 ar.ec=MLAT+SHLAT+2 // NB: One trip more than usual
+}{.mib
+ cmp.ne.unc p_no,p0=s_vscan3,s_vmatch3 // does not next one differ?
+(p_no) br.cond.dptk.many .only3
+ ;;
+}{.mmi // Cycle 1
+ and s_tm1=-8,s_ascan // get aligned address
+ shladd s_tm3=s_tm3,3,r0
+ movi0 ar.lc=31 // 32 times around the loop (8B at a time)
+}{.mib
+ and s_tm2=-8,s_amatch // get aligned address
+ shladd s_tm4=s_tm4,3,r0
+ nop.b 0
+ ;;
+}{.mmi // Cycle 2
+ ld8.nt1 scan[1]=[s_tm1],8 // load first chunk
+ sub s_tm5=64,s_tm3 // 64 - amount
+ movi0 pr.rot=1<<16
+}{.mmi
+ ld8.nt1 match[1]=[s_tm2],8 // load first chunk
+ sub s_tm6=64,s_tm4 // 64 - amount
+ add s_vlen=-8,s_vlen // will be updated at least once
+ ;;
+}
+ .align 32
+.cmploop:
+{.mmi // Cycle 0
+(lc[0]) ld8 scan[0]=[s_tm1],8 // next scan chunk
+(lc[MLAT+SHLAT+1]) add s_vlen=8,s_vlen
+(lc[MLAT]) first shscan0[0]=scan[MLAT+1],s_tm3
+}{.mib
+(lc[MLAT+SHLAT+1]) cmp.ne.unc p_no,p0=s_tm7,s_tm8 // break search if !=
+(lc[MLAT]) first shmatch0[0]=match[MLAT+1],s_tm4
+(p_no) br.cond.dpnt.many .mismatch
+ ;;
+}{.mii // Cycle 1
+(lc[0]) ld8 match[0]=[s_tm2],8
+ // shift left(le) or right(be):
+(lc[MLAT]) second shscan1[0]=scan[MLAT],s_tm5
+(lc[MLAT]) second shmatch1[0]=match[MLAT],s_tm6
+}{.mmb
+(lc[MLAT+SHLAT]) or s_tm7=shscan0[SHLAT],shscan1[SHLAT]
+(lc[MLAT+SHLAT]) or s_tm8=shmatch0[SHLAT],shmatch1[SHLAT]
+ br.ctop.dptk.many .cmploop
+ ;;
+}{.mfi
+ mov s_vlen=258
+ nop.f 0
+}{.mfi
+ nop.f 0 // realign
+ ;;
+}
+.mismatch:
+{.mii // Cycle 0 (short)
+(p_no) pcmp1.eq s_tm2=s_tm7,s_tm8 // find first non-matching character
+ nop.i 0
+ ;;
+ // Cycle 1 (short)
+(p_no) count s_tm1=s_tm2
+ ;;
+}{.mib // Cycle 2 (short)
+(p_no) add s_vlen=s_vlen,s_tm1 // effective length
+ nop.i 0
+ clrrrb
+ ;;
+}
+
+.only3:
+{.mib // Cycle 0 (short)
+ cmp.gt.unc p0,p_nbs=s_vlen,s_vbestlen // (len > best_len) ?
+(p_nbs) br.cond.dpnt.many .next_iter // if not, re-iternate
+ ;;
+}{.mmi // Cycle 1 (short)
+ ld4 s_tm7=[s_anicematch] // nice_match
+ st4 [s_amatchstart]= s_vcurmatch
+ add s_ascanend=s_ascan,s_vlen // reset with best_len
+ ;;
+}{.mmi // Cycle 2 (short)
+ mova s_vbestlen=s_vlen
+ add s_ascanend=-3,s_ascanend // remember extra offset
+ ;;
+}{.mmi // Cycle 3 (short)
+ ld1 s_vscanend=[s_ascanend],-1 // scan_end=scan[best_len]
+ add s_awinbest=s_awindow,s_vbestlen // update with new best_len
+ cmp.ne.unc p_bn2,p0=2,s_vbestlen // set if bestlen != 2
+ ;;
+}{.mib // Cycle 4 (short)
+ // scan_end1=scan[best_len-1] NB: s_ascanend reset:
+ ld1.nt1 s_vscanend1=[s_ascanend],1
+ cmp.lt.unc p_nnc,p0=s_vlen,s_tm7 // compare with nice_match
+(p_nnc) br.cond.dptk.many .next_iter
+ ;;
+}
+.terminate:
+{.mii // Cycle 0/1
+ nop.m 0
+ movi0 ar.lc=s_lcsave
+ movi0 pr=s_prsave,-1
+}{.mbb
+ nop.m 0
+ nop.b 0
+ br.ret.sptk.many rp // ret0 is identical to best_len
+ ;;
+}
+ .endp
+
+ .global match_init
+ .proc match_init
+match_init:
+ sub ret0=ret0,ret0
+ br.ret.sptk.many rp
+ .endp
+
+# else
+ error: this asm version is for 386 or 680x0 or ia64 only
+# endif /* __ia64__ */
+#endif /* mc68000 || mc68020 */
+#endif /* i386 || _I386 */
projects / debian / gzip / blobdiff