amd64-match.S@ 69339

Last change on this file since 69339 was 58208, checked in by vboxsync, 9 years ago
zlib 1.2.8 unmodified
Property svn:eol-style set to `native`
File size: 12.1 KB

Line
1	/*
2	* match.S -- optimized version of longest_match()
3	* based on the similar work by Gilles Vollant, and Brian Raiter, written 1998
4	*
5	* This is free software; you can redistribute it and/or modify it
6	* under the terms of the BSD License. Use by owners of Che Guevarra
7	* parafernalia is prohibited, where possible, and highly discouraged
8	* elsewhere.
9	*/
10
11	#ifndef NO_UNDERLINE
12	# define match_init _match_init
13	# define longest_match _longest_match
14	#endif
15
16	#define scanend ebx
17	#define scanendw bx
18	#define chainlenwmask edx /* high word: current chain len low word: s->wmask */
19	#define curmatch rsi
20	#define curmatchd esi
21	#define windowbestlen r8
22	#define scanalign r9
23	#define scanalignd r9d
24	#define window r10
25	#define bestlen r11
26	#define bestlend r11d
27	#define scanstart r12d
28	#define scanstartw r12w
29	#define scan r13
30	#define nicematch r14d
31	#define limit r15
32	#define limitd r15d
33	#define prev rcx
34
35	/*
36	* The 258 is a "magic number, not a parameter -- changing it
37	* breaks the hell loose
38	*/
39	#define MAX_MATCH (258)
40	#define MIN_MATCH (3)
41	#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
42	#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7)
43
44	/* stack frame offsets */
45	#define LocalVarsSize (112)
46	#define _chainlenwmask ( 8-LocalVarsSize)(%rsp)
47	#define _windowbestlen (16-LocalVarsSize)(%rsp)
48	#define save_r14 (24-LocalVarsSize)(%rsp)
49	#define save_rsi (32-LocalVarsSize)(%rsp)
50	#define save_rbx (40-LocalVarsSize)(%rsp)
51	#define save_r12 (56-LocalVarsSize)(%rsp)
52	#define save_r13 (64-LocalVarsSize)(%rsp)
53	#define save_r15 (80-LocalVarsSize)(%rsp)
54
55
56	.globl match_init, longest_match
57
58	/*
59	* On AMD64 the first argument of a function (in our case -- the pointer to
60	* deflate_state structure) is passed in %rdi, hence our offsets below are
61	* all off of that.
62	*/
63
64	/* you can check the structure offset by running
65
66	#include <stdlib.h>
67	#include <stdio.h>
68	#include "deflate.h"
69
70	void print_depl()
71	{
72	deflate_state ds;
73	deflate_state *s=&ds;
74	printf("size pointer=%u\n",(int)sizeof(void*));
75
76	printf("#define dsWSize (%3u)(%%rdi)\n",(int)(((char)&(s->w_size))-((char)s)));
77	printf("#define dsWMask (%3u)(%%rdi)\n",(int)(((char)&(s->w_mask))-((char)s)));
78	printf("#define dsWindow (%3u)(%%rdi)\n",(int)(((char)&(s->window))-((char)s)));
79	printf("#define dsPrev (%3u)(%%rdi)\n",(int)(((char)&(s->prev))-((char)s)));
80	printf("#define dsMatchLen (%3u)(%%rdi)\n",(int)(((char)&(s->match_length))-((char)s)));
81	printf("#define dsPrevMatch (%3u)(%%rdi)\n",(int)(((char)&(s->prev_match))-((char)s)));
82	printf("#define dsStrStart (%3u)(%%rdi)\n",(int)(((char)&(s->strstart))-((char)s)));
83	printf("#define dsMatchStart (%3u)(%%rdi)\n",(int)(((char)&(s->match_start))-((char)s)));
84	printf("#define dsLookahead (%3u)(%%rdi)\n",(int)(((char)&(s->lookahead))-((char)s)));
85	printf("#define dsPrevLen (%3u)(%%rdi)\n",(int)(((char)&(s->prev_length))-((char)s)));
86	printf("#define dsMaxChainLen (%3u)(%%rdi)\n",(int)(((char)&(s->max_chain_length))-((char)s)));
87	printf("#define dsGoodMatch (%3u)(%%rdi)\n",(int)(((char)&(s->good_match))-((char)s)));
88	printf("#define dsNiceMatch (%3u)(%%rdi)\n",(int)(((char)&(s->nice_match))-((char)s)));
89	}
90
91	*/
92
93
94	/*
95	to compile for XCode 3.2 on MacOSX x86_64
96	- run "gcc -g -c -DXCODE_MAC_X64_STRUCTURE amd64-match.S"
97	*/
98
99
100	#ifndef CURRENT_LINX_XCODE_MAC_X64_STRUCTURE
101	#define dsWSize ( 68)(%rdi)
102	#define dsWMask ( 76)(%rdi)
103	#define dsWindow ( 80)(%rdi)
104	#define dsPrev ( 96)(%rdi)
105	#define dsMatchLen (144)(%rdi)
106	#define dsPrevMatch (148)(%rdi)
107	#define dsStrStart (156)(%rdi)
108	#define dsMatchStart (160)(%rdi)
109	#define dsLookahead (164)(%rdi)
110	#define dsPrevLen (168)(%rdi)
111	#define dsMaxChainLen (172)(%rdi)
112	#define dsGoodMatch (188)(%rdi)
113	#define dsNiceMatch (192)(%rdi)
114
115	#else
116
117	#ifndef STRUCT_OFFSET
118	# define STRUCT_OFFSET (0)
119	#endif
120
121
122	#define dsWSize ( 56 + STRUCT_OFFSET)(%rdi)
123	#define dsWMask ( 64 + STRUCT_OFFSET)(%rdi)
124	#define dsWindow ( 72 + STRUCT_OFFSET)(%rdi)
125	#define dsPrev ( 88 + STRUCT_OFFSET)(%rdi)
126	#define dsMatchLen (136 + STRUCT_OFFSET)(%rdi)
127	#define dsPrevMatch (140 + STRUCT_OFFSET)(%rdi)
128	#define dsStrStart (148 + STRUCT_OFFSET)(%rdi)
129	#define dsMatchStart (152 + STRUCT_OFFSET)(%rdi)
130	#define dsLookahead (156 + STRUCT_OFFSET)(%rdi)
131	#define dsPrevLen (160 + STRUCT_OFFSET)(%rdi)
132	#define dsMaxChainLen (164 + STRUCT_OFFSET)(%rdi)
133	#define dsGoodMatch (180 + STRUCT_OFFSET)(%rdi)
134	#define dsNiceMatch (184 + STRUCT_OFFSET)(%rdi)
135
136	#endif
137
138
139
140
141	.text
142
143	/* uInt longest_match(deflate_state deflatestate, IPos curmatch) /
144
145	longest_match:
146	/*
147	* Retrieve the function arguments. %curmatch will hold cur_match
148	* throughout the entire function (passed via rsi on amd64).
149	* rdi will hold the pointer to the deflate_state (first arg on amd64)
150	*/
151	mov %rsi, save_rsi
152	mov %rbx, save_rbx
153	mov %r12, save_r12
154	mov %r13, save_r13
155	mov %r14, save_r14
156	mov %r15, save_r15
157
158	/* uInt wmask = s->w_mask; */
159	/* unsigned chain_length = s->max_chain_length; */
160	/* if (s->prev_length >= s->good_match) { */
161	/* chain_length >>= 2; */
162	/* } */
163
164	movl dsPrevLen, %eax
165	movl dsGoodMatch, %ebx
166	cmpl %ebx, %eax
167	movl dsWMask, %eax
168	movl dsMaxChainLen, %chainlenwmask
169	jl LastMatchGood
170	shrl $2, %chainlenwmask
171	LastMatchGood:
172
173	/* chainlen is decremented once beforehand so that the function can */
174	/* use the sign flag instead of the zero flag for the exit test. */
175	/* It is then shifted into the high word, to make room for the wmask */
176	/* value, which it will always accompany. */
177
178	decl %chainlenwmask
179	shll $16, %chainlenwmask
180	orl %eax, %chainlenwmask
181
182	/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */
183
184	movl dsNiceMatch, %eax
185	movl dsLookahead, %ebx
186	cmpl %eax, %ebx
187	jl LookaheadLess
188	movl %eax, %ebx
189	LookaheadLess: movl %ebx, %nicematch
190
191	/* register Bytef scan = s->window + s->strstart; /
192
193	mov dsWindow, %window
194	movl dsStrStart, %limitd
195	lea (%limit, %window), %scan
196
197	/* Determine how many bytes the scan ptr is off from being */
198	/* dword-aligned. */
199
200	mov %scan, %scanalign
201	negl %scanalignd
202	andl $3, %scanalignd
203
204	/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */
205	/* s->strstart - (IPos)MAX_DIST(s) : NIL; */
206
207	movl dsWSize, %eax
208	subl $MIN_LOOKAHEAD, %eax
209	xorl %ecx, %ecx
210	subl %eax, %limitd
211	cmovng %ecx, %limitd
212
213	/* int best_len = s->prev_length; */
214
215	movl dsPrevLen, %bestlend
216
217	/* Store the sum of s->window + best_len in %windowbestlen locally, and in memory. */
218
219	lea (%window, %bestlen), %windowbestlen
220	mov %windowbestlen, _windowbestlen
221
222	/* register ush scan_start = (ushf)scan; */
223	/* register ush scan_end = (ushf)(scan+best_len-1); */
224	/* Posf prev = s->prev; /
225
226	movzwl (%scan), %scanstart
227	movzwl -1(%scan, %bestlen), %scanend
228	mov dsPrev, %prev
229
230	/* Jump into the main loop. */
231
232	movl %chainlenwmask, _chainlenwmask
233	jmp LoopEntry
234
235	.balign 16
236
237	/* do {
238	* match = s->window + cur_match;
239	* if ((ushf)(match+best_len-1) != scan_end \|\|
240	* (ushf)match != scan_start) continue;
241	* [...]
242	* } while ((cur_match = prev[cur_match & wmask]) > limit
243	* && --chain_length != 0);
244	*
245	* Here is the inner loop of the function. The function will spend the
246	* majority of its time in this loop, and majority of that time will
247	* be spent in the first ten instructions.
248	*/
249	LookupLoop:
250	andl %chainlenwmask, %curmatchd
251	movzwl (%prev, %curmatch, 2), %curmatchd
252	cmpl %limitd, %curmatchd
253	jbe LeaveNow
254	subl $0x00010000, %chainlenwmask
255	js LeaveNow
256	LoopEntry: cmpw -1(%windowbestlen, %curmatch), %scanendw
257	jne LookupLoop
258	cmpw %scanstartw, (%window, %curmatch)
259	jne LookupLoop
260
261	/* Store the current value of chainlen. */
262	movl %chainlenwmask, _chainlenwmask
263
264	/* %scan is the string under scrutiny, and %prev to the string we */
265	/* are hoping to match it up with. In actuality, %esi and %edi are */
266	/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
267	/* initialized to -(MAX_MATCH_8 - scanalign). */
268
269	mov $(-MAX_MATCH_8), %rdx
270	lea (%curmatch, %window), %windowbestlen
271	lea MAX_MATCH_8(%windowbestlen, %scanalign), %windowbestlen
272	lea MAX_MATCH_8(%scan, %scanalign), %prev
273
274	/* the prefetching below makes very little difference... */
275	prefetcht1 (%windowbestlen, %rdx)
276	prefetcht1 (%prev, %rdx)
277
278	/*
279	* Test the strings for equality, 8 bytes at a time. At the end,
280	* adjust %rdx so that it is offset to the exact byte that mismatched.
281	*
282	* It should be confessed that this loop usually does not represent
283	* much of the total running time. Replacing it with a more
284	* straightforward "rep cmpsb" would not drastically degrade
285	* performance -- unrolling it, for example, makes no difference.
286	*/
287
288	#undef USE_SSE /* works, but is 6-7% slower, than non-SSE... */
289
290	LoopCmps:
291	#ifdef USE_SSE
292	/* Preload the SSE registers */
293	movdqu (%windowbestlen, %rdx), %xmm1
294	movdqu (%prev, %rdx), %xmm2
295	pcmpeqb %xmm2, %xmm1
296	movdqu 16(%windowbestlen, %rdx), %xmm3
297	movdqu 16(%prev, %rdx), %xmm4
298	pcmpeqb %xmm4, %xmm3
299	movdqu 32(%windowbestlen, %rdx), %xmm5
300	movdqu 32(%prev, %rdx), %xmm6
301	pcmpeqb %xmm6, %xmm5
302	movdqu 48(%windowbestlen, %rdx), %xmm7
303	movdqu 48(%prev, %rdx), %xmm8
304	pcmpeqb %xmm8, %xmm7
305
306	/* Check the comparisions' results */
307	pmovmskb %xmm1, %rax
308	notw %ax
309	bsfw %ax, %ax
310	jnz LeaveLoopCmps
311
312	/* this is the only iteration of the loop with a possibility of having
313	incremented rdx by 0x108 (each loop iteration add 16*4 = 0x40
314	and (0x404)+8=0x108 /
315	add $8, %rdx
316	jz LenMaximum
317	add $8, %rdx
318
319
320	pmovmskb %xmm3, %rax
321	notw %ax
322	bsfw %ax, %ax
323	jnz LeaveLoopCmps
324
325
326	add $16, %rdx
327
328
329	pmovmskb %xmm5, %rax
330	notw %ax
331	bsfw %ax, %ax
332	jnz LeaveLoopCmps
333
334	add $16, %rdx
335
336
337	pmovmskb %xmm7, %rax
338	notw %ax
339	bsfw %ax, %ax
340	jnz LeaveLoopCmps
341
342	add $16, %rdx
343
344	jmp LoopCmps
345	LeaveLoopCmps: add %rax, %rdx
346	#else
347	mov (%windowbestlen, %rdx), %rax
348	xor (%prev, %rdx), %rax
349	jnz LeaveLoopCmps
350
351	mov 8(%windowbestlen, %rdx), %rax
352	xor 8(%prev, %rdx), %rax
353	jnz LeaveLoopCmps8
354
355	mov 16(%windowbestlen, %rdx), %rax
356	xor 16(%prev, %rdx), %rax
357	jnz LeaveLoopCmps16
358
359	add $24, %rdx
360	jnz LoopCmps
361	jmp LenMaximum
362	# if 0
363	/*
364	* This three-liner is tantalizingly simple, but bsf is a slow instruction,
365	* and the complicated alternative down below is quite a bit faster. Sad...
366	*/
367
368	LeaveLoopCmps: bsf %rax, %rax /* find the first non-zero bit */
369	shrl $3, %eax /* divide by 8 to get the byte */
370	add %rax, %rdx
371	# else
372	LeaveLoopCmps16:
373	add $8, %rdx
374	LeaveLoopCmps8:
375	add $8, %rdx
376	LeaveLoopCmps: testl $0xFFFFFFFF, %eax /* Check the first 4 bytes */
377	jnz Check16
378	add $4, %rdx
379	shr $32, %rax
380	Check16: testw $0xFFFF, %ax
381	jnz LenLower
382	add $2, %rdx
383	shrl $16, %eax
384	LenLower: subb $1, %al
385	adc $0, %rdx
386	# endif
387	#endif
388
389	/* Calculate the length of the match. If it is longer than MAX_MATCH, */
390	/* then automatically accept it as the best possible match and leave. */
391
392	lea (%prev, %rdx), %rax
393	sub %scan, %rax
394	cmpl $MAX_MATCH, %eax
395	jge LenMaximum
396
397	/* If the length of the match is not longer than the best match we */
398	/* have so far, then forget it and return to the lookup loop. */
399
400	cmpl %bestlend, %eax
401	jg LongerMatch
402	mov _windowbestlen, %windowbestlen
403	mov dsPrev, %prev
404	movl _chainlenwmask, %edx
405	jmp LookupLoop
406
407	/* s->match_start = cur_match; */
408	/* best_len = len; */
409	/* if (len >= nice_match) break; */
410	/* scan_end = (ushf)(scan+best_len-1); */
411
412	LongerMatch:
413	movl %eax, %bestlend
414	movl %curmatchd, dsMatchStart
415	cmpl %nicematch, %eax
416	jge LeaveNow
417
418	lea (%window, %bestlen), %windowbestlen
419	mov %windowbestlen, _windowbestlen
420
421	movzwl -1(%scan, %rax), %scanend
422	mov dsPrev, %prev
423	movl _chainlenwmask, %chainlenwmask
424	jmp LookupLoop
425
426	/* Accept the current string, with the maximum possible length. */
427
428	LenMaximum:
429	movl $MAX_MATCH, %bestlend
430	movl %curmatchd, dsMatchStart
431
432	/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
433	/* return s->lookahead; */
434
435	LeaveNow:
436	movl dsLookahead, %eax
437	cmpl %eax, %bestlend
438	cmovngl %bestlend, %eax
439	LookaheadRet:
440
441	/* Restore the registers and return from whence we came. */
442
443	mov save_rsi, %rsi
444	mov save_rbx, %rbx
445	mov save_r12, %r12
446	mov save_r13, %r13
447	mov save_r14, %r14
448	mov save_r15, %r15
449
450	ret
451
452	match_init: ret

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format