aboutsummaryrefslogtreecommitdiff
path: root/contrib/asm386/gvmat32c.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/asm386/gvmat32c.c')
-rw-r--r--contrib/asm386/gvmat32c.c200
1 files changed, 0 insertions, 200 deletions
diff --git a/contrib/asm386/gvmat32c.c b/contrib/asm386/gvmat32c.c
deleted file mode 100644
index d853bb7..0000000
--- a/contrib/asm386/gvmat32c.c
+++ /dev/null
@@ -1,200 +0,0 @@
1/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
2 * Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
3 * File written by Gilles Vollant, by modifiying the longest_match
4 * from Jean-loup Gailly in deflate.c
5 * it prepare all parameters and call the assembly longest_match_gvasm
6 * longest_match execute standard C code is wmask != 0x7fff
7 * (assembly code is faster with a fixed wmask)
8 *
9 */
10
11#include "deflate.h"
12
13#undef FAR
14#include <windows.h>
15
16#ifdef ASMV
17#define NIL 0
18
19#define UNALIGNED_OK
20
21
22/* if your C compiler don't add underline before function name,
23 define ADD_UNDERLINE_ASMFUNC */
24#ifdef ADD_UNDERLINE_ASMFUNC
25#define longest_match_7fff _longest_match_7fff
26#endif
27
28
29
30void match_init()
31{
32}
33
34unsigned long cpudetect32();
35
36uInt longest_match_c(
37 deflate_state *s,
38 IPos cur_match); /* current match */
39
40
41uInt longest_match_7fff(
42 deflate_state *s,
43 IPos cur_match); /* current match */
44
45uInt longest_match(
46 deflate_state *s,
47 IPos cur_match) /* current match */
48{
49 static uInt iIsPPro=2;
50
51 if ((s->w_mask == 0x7fff) && (iIsPPro==0))
52 return longest_match_7fff(s,cur_match);
53
54 if (iIsPPro==2)
55 iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
56
57 return longest_match_c(s,cur_match);
58}
59
60
61
62uInt longest_match_c(s, cur_match)
63 deflate_state *s;
64 IPos cur_match; /* current match */
65{
66 unsigned chain_length = s->max_chain_length;/* max hash chain length */
67 register Bytef *scan = s->window + s->strstart; /* current string */
68 register Bytef *match; /* matched string */
69 register int len; /* length of current match */
70 int best_len = s->prev_length; /* best match length so far */
71 int nice_match = s->nice_match; /* stop if match long enough */
72 IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
73 s->strstart - (IPos)MAX_DIST(s) : NIL;
74 /* Stop when cur_match becomes <= limit. To simplify the code,
75 * we prevent matches with the string of window index 0.
76 */
77 Posf *prev = s->prev;
78 uInt wmask = s->w_mask;
79
80#ifdef UNALIGNED_OK
81 /* Compare two bytes at a time. Note: this is not always beneficial.
82 * Try with and without -DUNALIGNED_OK to check.
83 */
84 register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
85 register ush scan_start = *(ushf*)scan;
86 register ush scan_end = *(ushf*)(scan+best_len-1);
87#else
88 register Bytef *strend = s->window + s->strstart + MAX_MATCH;
89 register Byte scan_end1 = scan[best_len-1];
90 register Byte scan_end = scan[best_len];
91#endif
92
93 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
94 * It is easy to get rid of this optimization if necessary.
95 */
96 Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
97
98 /* Do not waste too much time if we already have a good match: */
99 if (s->prev_length >= s->good_match) {
100 chain_length >>= 2;
101 }
102 /* Do not look for matches beyond the end of the input. This is necessary
103 * to make deflate deterministic.
104 */
105 if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
106
107 Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
108
109 do {
110 Assert(cur_match < s->strstart, "no future");
111 match = s->window + cur_match;
112
113 /* Skip to next match if the match length cannot increase
114 * or if the match length is less than 2:
115 */
116#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
117 /* This code assumes sizeof(unsigned short) == 2. Do not use
118 * UNALIGNED_OK if your compiler uses a different size.
119 */
120 if (*(ushf*)(match+best_len-1) != scan_end ||
121 *(ushf*)match != scan_start) continue;
122
123 /* It is not necessary to compare scan[2] and match[2] since they are
124 * always equal when the other bytes match, given that the hash keys
125 * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
126 * strstart+3, +5, ... up to strstart+257. We check for insufficient
127 * lookahead only every 4th comparison; the 128th check will be made
128 * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
129 * necessary to put more guard bytes at the end of the window, or
130 * to check more often for insufficient lookahead.
131 */
132 Assert(scan[2] == match[2], "scan[2]?");
133 scan++, match++;
134 do {
135 } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
136 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
137 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
138 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
139 scan < strend);
140 /* The funny "do {}" generates better code on most compilers */
141
142 /* Here, scan <= window+strstart+257 */
143 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
144 if (*scan == *match) scan++;
145
146 len = (MAX_MATCH - 1) - (int)(strend-scan);
147 scan = strend - (MAX_MATCH-1);
148
149#else /* UNALIGNED_OK */
150
151 if (match[best_len] != scan_end ||
152 match[best_len-1] != scan_end1 ||
153 *match != *scan ||
154 *++match != scan[1]) continue;
155
156 /* The check at best_len-1 can be removed because it will be made
157 * again later. (This heuristic is not always a win.)
158 * It is not necessary to compare scan[2] and match[2] since they
159 * are always equal when the other bytes match, given that
160 * the hash keys are equal and that HASH_BITS >= 8.
161 */
162 scan += 2, match++;
163 Assert(*scan == *match, "match[2]?");
164
165 /* We check for insufficient lookahead only every 8th comparison;
166 * the 256th check will be made at strstart+258.
167 */
168 do {
169 } while (*++scan == *++match && *++scan == *++match &&
170 *++scan == *++match && *++scan == *++match &&
171 *++scan == *++match && *++scan == *++match &&
172 *++scan == *++match && *++scan == *++match &&
173 scan < strend);
174
175 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
176
177 len = MAX_MATCH - (int)(strend - scan);
178 scan = strend - MAX_MATCH;
179
180#endif /* UNALIGNED_OK */
181
182 if (len > best_len) {
183 s->match_start = cur_match;
184 best_len = len;
185 if (len >= nice_match) break;
186#ifdef UNALIGNED_OK
187 scan_end = *(ushf*)(scan+best_len-1);
188#else
189 scan_end1 = scan[best_len-1];
190 scan_end = scan[best_len];
191#endif
192 }
193 } while ((cur_match = prev[cur_match & wmask]) > limit
194 && --chain_length != 0);
195
196 if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
197 return s->lookahead;
198}
199
200#endif /* ASMV */
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-16 15:16:46 +0000