]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* |
2 | ;uInt longest_match_x64( | |
3 | ; deflate_state *s, | |
4 | ; IPos cur_match); // current match | |
5 | ||
6 | ; gvmat64.S -- Asm portion of the optimized longest_match for 32 bits x86_64 | |
7 | ; (AMD64 on Athlon 64, Opteron, Phenom | |
8 | ; and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7) | |
9 | ; this file is translation from gvmat64.asm to GCC 4.x (for Linux, Mac XCode) | |
10 | ; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant. | |
11 | ; | |
12 | ; File written by Gilles Vollant, by converting to assembly the longest_match | |
13 | ; from Jean-loup Gailly in deflate.c of zLib and infoZip zip. | |
14 | ; and by taking inspiration on asm686 with masm, optimised assembly code | |
15 | ; from Brian Raiter, written 1998 | |
16 | ; | |
17 | ; This software is provided 'as-is', without any express or implied | |
18 | ; warranty. In no event will the authors be held liable for any damages | |
19 | ; arising from the use of this software. | |
20 | ; | |
21 | ; Permission is granted to anyone to use this software for any purpose, | |
22 | ; including commercial applications, and to alter it and redistribute it | |
23 | ; freely, subject to the following restrictions: | |
24 | ; | |
25 | ; 1. The origin of this software must not be misrepresented; you must not | |
26 | ; claim that you wrote the original software. If you use this software | |
27 | ; in a product, an acknowledgment in the product documentation would be | |
28 | ; appreciated but is not required. | |
29 | ; 2. Altered source versions must be plainly marked as such, and must not be | |
30 | ; misrepresented as being the original software | |
31 | ; 3. This notice may not be removed or altered from any source distribution. | |
32 | ; | |
33 | ; http://www.zlib.net | |
34 | ; http://www.winimage.com/zLibDll | |
35 | ; http://www.muppetlabs.com/~breadbox/software/assembly.html | |
36 | ; | |
37 | ; to compile this file for zLib, I use option: | |
38 | ; gcc -c -arch x86_64 gvmat64.S | |
39 | ||
40 | ||
41 | ;uInt longest_match(s, cur_match) | |
42 | ; deflate_state *s; | |
43 | ; IPos cur_match; // current match / | |
44 | ; | |
45 | ; with XCode for Mac, I had strange error with some jump on intel syntax | |
46 | ; this is why BEFORE_JMP and AFTER_JMP are used | |
47 | */ | |
48 | ||
49 | ||
50 | #define BEFORE_JMP .att_syntax | |
51 | #define AFTER_JMP .intel_syntax noprefix | |
52 | ||
53 | #ifndef NO_UNDERLINE | |
54 | # define match_init _match_init | |
55 | # define longest_match _longest_match | |
56 | #endif | |
57 | ||
58 | .intel_syntax noprefix | |
59 | ||
60 | .globl match_init, longest_match | |
61 | .text | |
62 | longest_match: | |
63 | ||
64 | ||
65 | ||
66 | #define LocalVarsSize 96 | |
67 | /* | |
68 | ; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12 | |
69 | ; free register : r14,r15 | |
70 | ; register can be saved : rsp | |
71 | */ | |
72 | ||
73 | #define chainlenwmask (rsp + 8 - LocalVarsSize) | |
74 | #define nicematch (rsp + 16 - LocalVarsSize) | |
75 | ||
76 | #define save_rdi (rsp + 24 - LocalVarsSize) | |
77 | #define save_rsi (rsp + 32 - LocalVarsSize) | |
78 | #define save_rbx (rsp + 40 - LocalVarsSize) | |
79 | #define save_rbp (rsp + 48 - LocalVarsSize) | |
80 | #define save_r12 (rsp + 56 - LocalVarsSize) | |
81 | #define save_r13 (rsp + 64 - LocalVarsSize) | |
82 | #define save_r14 (rsp + 72 - LocalVarsSize) | |
83 | #define save_r15 (rsp + 80 - LocalVarsSize) | |
84 | ||
85 | ||
86 | /* | |
87 | ; all the +4 offsets are due to the addition of pending_buf_size (in zlib | |
88 | ; in the deflate_state structure since the asm code was first written | |
89 | ; (if you compile with zlib 1.0.4 or older, remove the +4). | |
90 | ; Note : these value are good with a 8 bytes boundary pack structure | |
91 | */ | |
92 | ||
93 | #define MAX_MATCH 258 | |
94 | #define MIN_MATCH 3 | |
95 | #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) | |
96 | ||
97 | /* | |
98 | ;;; Offsets for fields in the deflate_state structure. These numbers | |
99 | ;;; are calculated from the definition of deflate_state, with the | |
100 | ;;; assumption that the compiler will dword-align the fields. (Thus, | |
101 | ;;; changing the definition of deflate_state could easily cause this | |
102 | ;;; program to crash horribly, without so much as a warning at | |
103 | ;;; compile time. Sigh.) | |
104 | ||
105 | ; all the +zlib1222add offsets are due to the addition of fields | |
106 | ; in zlib in the deflate_state structure since the asm code was first written | |
107 | ; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)"). | |
108 | ; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0"). | |
109 | ; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8"). | |
110 | */ | |
111 | ||
112 | ||
113 | ||
114 | /* you can check the structure offset by running | |
115 | ||
116 | #include <stdlib.h> | |
117 | #include <stdio.h> | |
118 | #include "deflate.h" | |
119 | ||
120 | void print_depl() | |
121 | { | |
122 | deflate_state ds; | |
123 | deflate_state *s=&ds; | |
124 | printf("size pointer=%u\n",(int)sizeof(void*)); | |
125 | ||
126 | printf("#define dsWSize %u\n",(int)(((char*)&(s->w_size))-((char*)s))); | |
127 | printf("#define dsWMask %u\n",(int)(((char*)&(s->w_mask))-((char*)s))); | |
128 | printf("#define dsWindow %u\n",(int)(((char*)&(s->window))-((char*)s))); | |
129 | printf("#define dsPrev %u\n",(int)(((char*)&(s->prev))-((char*)s))); | |
130 | printf("#define dsMatchLen %u\n",(int)(((char*)&(s->match_length))-((char*)s))); | |
131 | printf("#define dsPrevMatch %u\n",(int)(((char*)&(s->prev_match))-((char*)s))); | |
132 | printf("#define dsStrStart %u\n",(int)(((char*)&(s->strstart))-((char*)s))); | |
133 | printf("#define dsMatchStart %u\n",(int)(((char*)&(s->match_start))-((char*)s))); | |
134 | printf("#define dsLookahead %u\n",(int)(((char*)&(s->lookahead))-((char*)s))); | |
135 | printf("#define dsPrevLen %u\n",(int)(((char*)&(s->prev_length))-((char*)s))); | |
136 | printf("#define dsMaxChainLen %u\n",(int)(((char*)&(s->max_chain_length))-((char*)s))); | |
137 | printf("#define dsGoodMatch %u\n",(int)(((char*)&(s->good_match))-((char*)s))); | |
138 | printf("#define dsNiceMatch %u\n",(int)(((char*)&(s->nice_match))-((char*)s))); | |
139 | } | |
140 | */ | |
141 | ||
142 | #define dsWSize 68 | |
143 | #define dsWMask 76 | |
144 | #define dsWindow 80 | |
145 | #define dsPrev 96 | |
146 | #define dsMatchLen 144 | |
147 | #define dsPrevMatch 148 | |
148 | #define dsStrStart 156 | |
149 | #define dsMatchStart 160 | |
150 | #define dsLookahead 164 | |
151 | #define dsPrevLen 168 | |
152 | #define dsMaxChainLen 172 | |
153 | #define dsGoodMatch 188 | |
154 | #define dsNiceMatch 192 | |
155 | ||
156 | #define window_size [ rcx + dsWSize] | |
157 | #define WMask [ rcx + dsWMask] | |
158 | #define window_ad [ rcx + dsWindow] | |
159 | #define prev_ad [ rcx + dsPrev] | |
160 | #define strstart [ rcx + dsStrStart] | |
161 | #define match_start [ rcx + dsMatchStart] | |
162 | #define Lookahead [ rcx + dsLookahead] //; 0ffffffffh on infozip | |
163 | #define prev_length [ rcx + dsPrevLen] | |
164 | #define max_chain_length [ rcx + dsMaxChainLen] | |
165 | #define good_match [ rcx + dsGoodMatch] | |
166 | #define nice_match [ rcx + dsNiceMatch] | |
167 | ||
168 | /* | |
169 | ; windows: | |
170 | ; parameter 1 in rcx(deflate state s), param 2 in rdx (cur match) | |
171 | ||
172 | ; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and | |
173 | ; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp | |
174 | ; | |
175 | ; All registers must be preserved across the call, except for | |
176 | ; rax, rcx, rdx, r8, r9, r10, and r11, which are scratch. | |
177 | ||
178 | ; | |
179 | ; gcc on macosx-linux: | |
180 | ; see http://www.x86-64.org/documentation/abi-0.99.pdf | |
181 | ; param 1 in rdi, param 2 in rsi | |
182 | ; rbx, rsp, rbp, r12 to r15 must be preserved | |
183 | ||
184 | ;;; Save registers that the compiler may be using, and adjust esp to | |
185 | ;;; make room for our stack frame. | |
186 | ||
187 | ||
188 | ;;; Retrieve the function arguments. r8d will hold cur_match | |
189 | ;;; throughout the entire function. edx will hold the pointer to the | |
190 | ;;; deflate_state structure during the function's setup (before | |
191 | ;;; entering the main loop. | |
192 | ||
193 | ; ms: parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match) | |
194 | ; mac: param 1 in rdi, param 2 rsi | |
195 | ; this clear high 32 bits of r8, which can be garbage in both r8 and rdx | |
196 | */ | |
197 | mov [save_rbx],rbx | |
198 | mov [save_rbp],rbp | |
199 | ||
200 | ||
201 | mov rcx,rdi | |
202 | ||
203 | mov r8d,esi | |
204 | ||
205 | ||
206 | mov [save_r12],r12 | |
207 | mov [save_r13],r13 | |
208 | mov [save_r14],r14 | |
209 | mov [save_r15],r15 | |
210 | ||
211 | ||
212 | //;;; uInt wmask = s->w_mask; | |
213 | //;;; unsigned chain_length = s->max_chain_length; | |
214 | //;;; if (s->prev_length >= s->good_match) { | |
215 | //;;; chain_length >>= 2; | |
216 | //;;; } | |
217 | ||
218 | ||
219 | mov edi, prev_length | |
220 | mov esi, good_match | |
221 | mov eax, WMask | |
222 | mov ebx, max_chain_length | |
223 | cmp edi, esi | |
224 | jl LastMatchGood | |
225 | shr ebx, 2 | |
226 | LastMatchGood: | |
227 | ||
228 | //;;; chainlen is decremented once beforehand so that the function can | |
229 | //;;; use the sign flag instead of the zero flag for the exit test. | |
230 | //;;; It is then shifted into the high word, to make room for the wmask | |
231 | //;;; value, which it will always accompany. | |
232 | ||
233 | dec ebx | |
234 | shl ebx, 16 | |
235 | or ebx, eax | |
236 | ||
237 | //;;; on zlib only | |
238 | //;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; | |
239 | ||
240 | ||
241 | ||
242 | mov eax, nice_match | |
243 | mov [chainlenwmask], ebx | |
244 | mov r10d, Lookahead | |
245 | cmp r10d, eax | |
246 | cmovnl r10d, eax | |
247 | mov [nicematch],r10d | |
248 | ||
249 | ||
250 | ||
251 | //;;; register Bytef *scan = s->window + s->strstart; | |
252 | mov r10, window_ad | |
253 | mov ebp, strstart | |
254 | lea r13, [r10 + rbp] | |
255 | ||
256 | //;;; Determine how many bytes the scan ptr is off from being | |
257 | //;;; dword-aligned. | |
258 | ||
259 | mov r9,r13 | |
260 | neg r13 | |
261 | and r13,3 | |
262 | ||
263 | //;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? | |
264 | //;;; s->strstart - (IPos)MAX_DIST(s) : NIL; | |
265 | ||
266 | ||
267 | mov eax, window_size | |
268 | sub eax, MIN_LOOKAHEAD | |
269 | ||
270 | ||
271 | xor edi,edi | |
272 | sub ebp, eax | |
273 | ||
274 | mov r11d, prev_length | |
275 | ||
276 | cmovng ebp,edi | |
277 | ||
278 | //;;; int best_len = s->prev_length; | |
279 | ||
280 | ||
281 | //;;; Store the sum of s->window + best_len in esi locally, and in esi. | |
282 | ||
283 | lea rsi,[r10+r11] | |
284 | ||
285 | //;;; register ush scan_start = *(ushf*)scan; | |
286 | //;;; register ush scan_end = *(ushf*)(scan+best_len-1); | |
287 | //;;; Posf *prev = s->prev; | |
288 | ||
289 | movzx r12d,word ptr [r9] | |
290 | movzx ebx, word ptr [r9 + r11 - 1] | |
291 | ||
292 | mov rdi, prev_ad | |
293 | ||
294 | //;;; Jump into the main loop. | |
295 | ||
296 | mov edx, [chainlenwmask] | |
297 | ||
298 | cmp bx,word ptr [rsi + r8 - 1] | |
299 | jz LookupLoopIsZero | |
300 | ||
301 | ||
302 | ||
303 | LookupLoop1: | |
304 | and r8d, edx | |
305 | ||
306 | movzx r8d, word ptr [rdi + r8*2] | |
307 | cmp r8d, ebp | |
308 | jbe LeaveNow | |
309 | ||
310 | ||
311 | ||
312 | sub edx, 0x00010000 | |
313 | BEFORE_JMP | |
314 | js LeaveNow | |
315 | AFTER_JMP | |
316 | ||
317 | LoopEntry1: | |
318 | cmp bx,word ptr [rsi + r8 - 1] | |
319 | BEFORE_JMP | |
320 | jz LookupLoopIsZero | |
321 | AFTER_JMP | |
322 | ||
323 | LookupLoop2: | |
324 | and r8d, edx | |
325 | ||
326 | movzx r8d, word ptr [rdi + r8*2] | |
327 | cmp r8d, ebp | |
328 | BEFORE_JMP | |
329 | jbe LeaveNow | |
330 | AFTER_JMP | |
331 | sub edx, 0x00010000 | |
332 | BEFORE_JMP | |
333 | js LeaveNow | |
334 | AFTER_JMP | |
335 | ||
336 | LoopEntry2: | |
337 | cmp bx,word ptr [rsi + r8 - 1] | |
338 | BEFORE_JMP | |
339 | jz LookupLoopIsZero | |
340 | AFTER_JMP | |
341 | ||
342 | LookupLoop4: | |
343 | and r8d, edx | |
344 | ||
345 | movzx r8d, word ptr [rdi + r8*2] | |
346 | cmp r8d, ebp | |
347 | BEFORE_JMP | |
348 | jbe LeaveNow | |
349 | AFTER_JMP | |
350 | sub edx, 0x00010000 | |
351 | BEFORE_JMP | |
352 | js LeaveNow | |
353 | AFTER_JMP | |
354 | ||
355 | LoopEntry4: | |
356 | ||
357 | cmp bx,word ptr [rsi + r8 - 1] | |
358 | BEFORE_JMP | |
359 | jnz LookupLoop1 | |
360 | jmp LookupLoopIsZero | |
361 | AFTER_JMP | |
362 | /* | |
363 | ;;; do { | |
364 | ;;; match = s->window + cur_match; | |
365 | ;;; if (*(ushf*)(match+best_len-1) != scan_end || | |
366 | ;;; *(ushf*)match != scan_start) continue; | |
367 | ;;; [...] | |
368 | ;;; } while ((cur_match = prev[cur_match & wmask]) > limit | |
369 | ;;; && --chain_length != 0); | |
370 | ;;; | |
371 | ;;; Here is the inner loop of the function. The function will spend the | |
372 | ;;; majority of its time in this loop, and majority of that time will | |
373 | ;;; be spent in the first ten instructions. | |
374 | ;;; | |
375 | ;;; Within this loop: | |
376 | ;;; ebx = scanend | |
377 | ;;; r8d = curmatch | |
378 | ;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask) | |
379 | ;;; esi = windowbestlen - i.e., (window + bestlen) | |
380 | ;;; edi = prev | |
381 | ;;; ebp = limit | |
382 | */ | |
383 | .balign 16 | |
384 | LookupLoop: | |
385 | and r8d, edx | |
386 | ||
387 | movzx r8d, word ptr [rdi + r8*2] | |
388 | cmp r8d, ebp | |
389 | BEFORE_JMP | |
390 | jbe LeaveNow | |
391 | AFTER_JMP | |
392 | sub edx, 0x00010000 | |
393 | BEFORE_JMP | |
394 | js LeaveNow | |
395 | AFTER_JMP | |
396 | ||
397 | LoopEntry: | |
398 | ||
399 | cmp bx,word ptr [rsi + r8 - 1] | |
400 | BEFORE_JMP | |
401 | jnz LookupLoop1 | |
402 | AFTER_JMP | |
403 | LookupLoopIsZero: | |
404 | cmp r12w, word ptr [r10 + r8] | |
405 | BEFORE_JMP | |
406 | jnz LookupLoop1 | |
407 | AFTER_JMP | |
408 | ||
409 | ||
410 | //;;; Store the current value of chainlen. | |
411 | mov [chainlenwmask], edx | |
412 | /* | |
413 | ;;; Point edi to the string under scrutiny, and esi to the string we | |
414 | ;;; are hoping to match it up with. In actuality, esi and edi are | |
415 | ;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is | |
416 | ;;; initialized to -(MAX_MATCH_8 - scanalign). | |
417 | */ | |
418 | lea rsi,[r8+r10] | |
419 | mov rdx, 0xfffffffffffffef8 //; -(MAX_MATCH_8) | |
420 | lea rsi, [rsi + r13 + 0x0108] //;MAX_MATCH_8] | |
421 | lea rdi, [r9 + r13 + 0x0108] //;MAX_MATCH_8] | |
422 | ||
423 | prefetcht1 [rsi+rdx] | |
424 | prefetcht1 [rdi+rdx] | |
425 | ||
426 | /* | |
427 | ;;; Test the strings for equality, 8 bytes at a time. At the end, | |
428 | ;;; adjust rdx so that it is offset to the exact byte that mismatched. | |
429 | ;;; | |
430 | ;;; We already know at this point that the first three bytes of the | |
431 | ;;; strings match each other, and they can be safely passed over before | |
432 | ;;; starting the compare loop. So what this code does is skip over 0-3 | |
433 | ;;; bytes, as much as necessary in order to dword-align the edi | |
434 | ;;; pointer. (rsi will still be misaligned three times out of four.) | |
435 | ;;; | |
436 | ;;; It should be confessed that this loop usually does not represent | |
437 | ;;; much of the total running time. Replacing it with a more | |
438 | ;;; straightforward "rep cmpsb" would not drastically degrade | |
439 | ;;; performance. | |
440 | */ | |
441 | ||
442 | LoopCmps: | |
443 | mov rax, [rsi + rdx] | |
444 | xor rax, [rdi + rdx] | |
445 | jnz LeaveLoopCmps | |
446 | ||
447 | mov rax, [rsi + rdx + 8] | |
448 | xor rax, [rdi + rdx + 8] | |
449 | jnz LeaveLoopCmps8 | |
450 | ||
451 | ||
452 | mov rax, [rsi + rdx + 8+8] | |
453 | xor rax, [rdi + rdx + 8+8] | |
454 | jnz LeaveLoopCmps16 | |
455 | ||
456 | add rdx,8+8+8 | |
457 | ||
458 | BEFORE_JMP | |
459 | jnz LoopCmps | |
460 | jmp LenMaximum | |
461 | AFTER_JMP | |
462 | ||
463 | LeaveLoopCmps16: add rdx,8 | |
464 | LeaveLoopCmps8: add rdx,8 | |
465 | LeaveLoopCmps: | |
466 | ||
467 | test eax, 0x0000FFFF | |
468 | jnz LenLower | |
469 | ||
470 | test eax,0xffffffff | |
471 | ||
472 | jnz LenLower32 | |
473 | ||
474 | add rdx,4 | |
475 | shr rax,32 | |
476 | or ax,ax | |
477 | BEFORE_JMP | |
478 | jnz LenLower | |
479 | AFTER_JMP | |
480 | ||
481 | LenLower32: | |
482 | shr eax,16 | |
483 | add rdx,2 | |
484 | ||
485 | LenLower: | |
486 | sub al, 1 | |
487 | adc rdx, 0 | |
488 | //;;; Calculate the length of the match. If it is longer than MAX_MATCH, | |
489 | //;;; then automatically accept it as the best possible match and leave. | |
490 | ||
491 | lea rax, [rdi + rdx] | |
492 | sub rax, r9 | |
493 | cmp eax, MAX_MATCH | |
494 | BEFORE_JMP | |
495 | jge LenMaximum | |
496 | AFTER_JMP | |
497 | /* | |
498 | ;;; If the length of the match is not longer than the best match we | |
499 | ;;; have so far, then forget it and return to the lookup loop. | |
500 | ;/////////////////////////////////// | |
501 | */ | |
502 | cmp eax, r11d | |
503 | jg LongerMatch | |
504 | ||
505 | lea rsi,[r10+r11] | |
506 | ||
507 | mov rdi, prev_ad | |
508 | mov edx, [chainlenwmask] | |
509 | BEFORE_JMP | |
510 | jmp LookupLoop | |
511 | AFTER_JMP | |
512 | /* | |
513 | ;;; s->match_start = cur_match; | |
514 | ;;; best_len = len; | |
515 | ;;; if (len >= nice_match) break; | |
516 | ;;; scan_end = *(ushf*)(scan+best_len-1); | |
517 | */ | |
518 | LongerMatch: | |
519 | mov r11d, eax | |
520 | mov match_start, r8d | |
521 | cmp eax, [nicematch] | |
522 | BEFORE_JMP | |
523 | jge LeaveNow | |
524 | AFTER_JMP | |
525 | ||
526 | lea rsi,[r10+rax] | |
527 | ||
528 | movzx ebx, word ptr [r9 + rax - 1] | |
529 | mov rdi, prev_ad | |
530 | mov edx, [chainlenwmask] | |
531 | BEFORE_JMP | |
532 | jmp LookupLoop | |
533 | AFTER_JMP | |
534 | ||
535 | //;;; Accept the current string, with the maximum possible length. | |
536 | ||
537 | LenMaximum: | |
538 | mov r11d,MAX_MATCH | |
539 | mov match_start, r8d | |
540 | ||
541 | //;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len; | |
542 | //;;; return s->lookahead; | |
543 | ||
544 | LeaveNow: | |
545 | mov eax, Lookahead | |
546 | cmp r11d, eax | |
547 | cmovng eax, r11d | |
548 | ||
549 | ||
550 | ||
551 | //;;; Restore the stack and return from whence we came. | |
552 | ||
553 | ||
554 | // mov rsi,[save_rsi] | |
555 | // mov rdi,[save_rdi] | |
556 | mov rbx,[save_rbx] | |
557 | mov rbp,[save_rbp] | |
558 | mov r12,[save_r12] | |
559 | mov r13,[save_r13] | |
560 | mov r14,[save_r14] | |
561 | mov r15,[save_r15] | |
562 | ||
563 | ||
564 | ret 0 | |
565 | //; please don't remove this string ! | |
566 | //; Your can freely use gvmat64 in any free or commercial app | |
567 | //; but it is far better don't remove the string in the binary! | |
568 | // db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0 | |
569 | ||
570 | ||
571 | match_init: | |
572 | ret 0 | |
573 | ||
574 |