Created
May 29, 2021 17:49
-
-
Save danlark1/df57a5a15d5ef04dadefb850c2eb79fb to your computer and use it in GitHub Desktop.
gcc_objdump
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
zstd_gcc.o: file format elf64-x86-64 | |
Disassembly of section .text: | |
0000000000000000 <ZSTD_safecopy>: | |
* @param ovtype controls the overlap detection | |
* - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart. | |
* - ZSTD_overlap_src_before_dst: The src and dst may overlap and may be any distance apart. | |
* The src buffer must be before the dst buffer. | |
*/ | |
static void ZSTD_safecopy(BYTE* op, BYTE* const oend_w, BYTE const* ip, ptrdiff_t length, ZSTD_overlap_e ovtype) { | |
0: 48 89 c8 mov %rcx,%rax | |
ptrdiff_t const diff = op - ip; | |
BYTE* const oend = op + length; | |
3: 49 89 cb mov %rcx,%r11 | |
6: 48 01 f9 add %rdi,%rcx | |
assert((ovtype == ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w)) || | |
(ovtype == ZSTD_overlap_src_before_dst && diff >= 0)); | |
if (length < 8) { | |
9: 48 83 f8 07 cmp $0x7,%rax | |
d: 0f 8e 4d 02 00 00 jle 260 <ZSTD_safecopy+0x260> | |
static void ZSTD_safecopy(BYTE* op, BYTE* const oend_w, BYTE const* ip, ptrdiff_t length, ZSTD_overlap_e ovtype) { | |
13: 53 push %rbx | |
/* Handle short lengths. */ | |
while (op < oend) *op++ = *ip++; | |
return; | |
} | |
if (ovtype == ZSTD_overlap_src_before_dst) { | |
14: 41 83 f8 01 cmp $0x1,%r8d | |
18: 0f 84 42 01 00 00 je 160 <ZSTD_safecopy+0x160> | |
ZSTD_overlapCopy8(&op, &ip, diff); | |
assert(op - ip >= 8); | |
assert(op <= oend); | |
} | |
if (oend <= oend_w) { | |
1e: 48 39 f1 cmp %rsi,%rcx | |
21: 0f 86 89 04 00 00 jbe 4b0 <ZSTD_safecopy+0x4b0> | |
/* No risk of overwrite. */ | |
ZSTD_wildcopy(op, ip, length, ovtype); | |
return; | |
} | |
if (op <= oend_w) { | |
27: 48 39 fe cmp %rdi,%rsi | |
2a: 0f 83 c0 04 00 00 jae 4f0 <ZSTD_safecopy+0x4f0> | |
ZSTD_wildcopy(op, ip, oend_w - op, ovtype); | |
ip += oend_w - op; | |
op = oend_w; | |
} | |
/* Handle the leftovers. */ | |
while (op < oend) *op++ = *ip++; | |
30: 48 39 f9 cmp %rdi,%rcx | |
33: 0f 86 22 01 00 00 jbe 15b <ZSTD_safecopy+0x15b> | |
39: 48 8d 47 01 lea 0x1(%rdi),%rax | |
3d: 4c 8d 41 ff lea -0x1(%rcx),%r8 | |
41: 49 29 f8 sub %rdi,%r8 | |
44: 48 39 c1 cmp %rax,%rcx | |
47: 41 0f 93 c1 setae %r9b | |
4b: 49 83 f8 06 cmp $0x6,%r8 | |
4f: 40 0f 97 c6 seta %sil | |
53: 41 84 f1 test %sil,%r9b | |
56: 48 8d 72 01 lea 0x1(%rdx),%rsi | |
5a: 0f 84 e8 01 00 00 je 248 <ZSTD_safecopy+0x248> | |
60: 49 89 f9 mov %rdi,%r9 | |
63: 49 29 f1 sub %rsi,%r9 | |
66: 49 83 f9 0e cmp $0xe,%r9 | |
6a: 0f 86 d8 01 00 00 jbe 248 <ZSTD_safecopy+0x248> | |
70: 48 89 ce mov %rcx,%rsi | |
73: 48 29 fe sub %rdi,%rsi | |
76: 48 39 c1 cmp %rax,%rcx | |
79: b8 01 00 00 00 mov $0x1,%eax | |
7e: 48 0f 42 f0 cmovb %rax,%rsi | |
82: 49 83 f8 0e cmp $0xe,%r8 | |
86: 0f 86 c6 04 00 00 jbe 552 <ZSTD_safecopy+0x552> | |
8c: 49 89 f0 mov %rsi,%r8 | |
ip += oend_w - op; | |
8f: 31 c0 xor %eax,%eax | |
91: 49 83 e0 f0 and $0xfffffffffffffff0,%r8 | |
95: 0f 1f 00 nopl (%rax) | |
while (op < oend) *op++ = *ip++; | |
98: f3 0f 6f 04 02 movdqu (%rdx,%rax,1),%xmm0 | |
9d: 0f 11 04 07 movups %xmm0,(%rdi,%rax,1) | |
a1: 48 83 c0 10 add $0x10,%rax | |
a5: 4c 39 c0 cmp %r8,%rax | |
a8: 75 ee jne 98 <ZSTD_safecopy+0x98> | |
aa: 49 89 f0 mov %rsi,%r8 | |
ad: 49 83 e0 f0 and $0xfffffffffffffff0,%r8 | |
b1: 4a 8d 04 07 lea (%rdi,%r8,1),%rax | |
b5: 4e 8d 0c 02 lea (%rdx,%r8,1),%r9 | |
b9: 4c 39 c6 cmp %r8,%rsi | |
bc: 0f 84 99 00 00 00 je 15b <ZSTD_safecopy+0x15b> | |
c2: 49 89 f2 mov %rsi,%r10 | |
c5: 48 83 ee 01 sub $0x1,%rsi | |
c9: 4c 29 c6 sub %r8,%rsi | |
cc: 4d 29 c2 sub %r8,%r10 | |
cf: 48 83 fe 06 cmp $0x6,%rsi | |
d3: 76 1a jbe ef <ZSTD_safecopy+0xef> | |
d5: 4a 8b 14 02 mov (%rdx,%r8,1),%rdx | |
d9: 4a 89 14 07 mov %rdx,(%rdi,%r8,1) | |
dd: 4c 89 d2 mov %r10,%rdx | |
e0: 48 83 e2 f8 and $0xfffffffffffffff8,%rdx | |
e4: 48 01 d0 add %rdx,%rax | |
e7: 49 01 d1 add %rdx,%r9 | |
ea: 49 39 d2 cmp %rdx,%r10 | |
ed: 74 6c je 15b <ZSTD_safecopy+0x15b> | |
ef: 41 0f b6 11 movzbl (%r9),%edx | |
f3: 88 10 mov %dl,(%rax) | |
f5: 48 8d 50 01 lea 0x1(%rax),%rdx | |
f9: 48 39 d1 cmp %rdx,%rcx | |
fc: 76 5d jbe 15b <ZSTD_safecopy+0x15b> | |
fe: 41 0f b6 51 01 movzbl 0x1(%r9),%edx | |
103: 88 50 01 mov %dl,0x1(%rax) | |
106: 48 8d 50 02 lea 0x2(%rax),%rdx | |
10a: 48 39 d1 cmp %rdx,%rcx | |
10d: 76 4c jbe 15b <ZSTD_safecopy+0x15b> | |
10f: 41 0f b6 51 02 movzbl 0x2(%r9),%edx | |
114: 88 50 02 mov %dl,0x2(%rax) | |
117: 48 8d 50 03 lea 0x3(%rax),%rdx | |
11b: 48 39 d1 cmp %rdx,%rcx | |
11e: 76 3b jbe 15b <ZSTD_safecopy+0x15b> | |
120: 41 0f b6 51 03 movzbl 0x3(%r9),%edx | |
125: 88 50 03 mov %dl,0x3(%rax) | |
128: 48 8d 50 04 lea 0x4(%rax),%rdx | |
12c: 48 39 d1 cmp %rdx,%rcx | |
12f: 76 2a jbe 15b <ZSTD_safecopy+0x15b> | |
131: 41 0f b6 51 04 movzbl 0x4(%r9),%edx | |
136: 88 50 04 mov %dl,0x4(%rax) | |
139: 48 8d 50 05 lea 0x5(%rax),%rdx | |
13d: 48 39 d1 cmp %rdx,%rcx | |
140: 76 19 jbe 15b <ZSTD_safecopy+0x15b> | |
142: 41 0f b6 51 05 movzbl 0x5(%r9),%edx | |
147: 88 50 05 mov %dl,0x5(%rax) | |
14a: 48 8d 50 06 lea 0x6(%rax),%rdx | |
14e: 48 39 d1 cmp %rdx,%rcx | |
151: 76 08 jbe 15b <ZSTD_safecopy+0x15b> | |
153: 41 0f b6 51 06 movzbl 0x6(%r9),%edx | |
158: 88 50 06 mov %dl,0x6(%rax) | |
} | |
15b: 5b pop %rbx | |
15c: c3 retq | |
15d: 0f 1f 00 nopl (%rax) | |
ptrdiff_t const diff = op - ip; | |
160: 49 89 f8 mov %rdi,%r8 | |
163: 49 29 d0 sub %rdx,%r8 | |
if (offset < 8) { | |
166: 49 83 f8 07 cmp $0x7,%r8 | |
16a: 0f 86 28 02 00 00 jbe 398 <ZSTD_safecopy+0x398> | |
*********************************************/ | |
static void ZSTD_copy8(void* dst, const void* src) { | |
#if !defined(ZSTD_NO_INTRINSICS) && defined(__ARM_NEON) | |
vst1_u8((uint8_t*)dst, vld1_u8((const uint8_t*)src)); | |
#else | |
ZSTD_memcpy(dst, src, 8); | |
170: 4c 8b 02 mov (%rdx),%r8 | |
173: 4c 89 07 mov %r8,(%rdi) | |
*ip += 8; | |
176: 4c 8d 4a 08 lea 0x8(%rdx),%r9 | |
*op += 8; | |
17a: 4c 8d 47 08 lea 0x8(%rdi),%r8 | |
if (oend <= oend_w) { | |
17e: 48 39 f1 cmp %rsi,%rcx | |
181: 0f 87 61 02 00 00 ja 3e8 <ZSTD_safecopy+0x3e8> | |
* The src buffer must be before the dst buffer. | |
*/ | |
MEM_STATIC FORCE_INLINE_ATTR | |
void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e const ovtype) | |
{ | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
187: 4c 89 c6 mov %r8,%rsi | |
const BYTE* ip = (const BYTE*)src; | |
BYTE* op = (BYTE*)dst; | |
BYTE* const oend = op + length; | |
18a: 49 8d 0c 00 lea (%r8,%rax,1),%rcx | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
18e: 4c 29 ce sub %r9,%rsi | |
assert(diff >= 8 || (ovtype == ZSTD_no_overlap && diff <= -WILDCOPY_VECLEN)); | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
191: 48 83 fe 0f cmp $0xf,%rsi | |
195: 0f 8f 06 03 00 00 jg 4a1 <ZSTD_safecopy+0x4a1> | |
19b: 4d 89 c2 mov %r8,%r10 | |
19e: 48 89 c8 mov %rcx,%rax | |
1a1: 48 8d 77 09 lea 0x9(%rdi),%rsi | |
1a5: 49 29 d2 sub %rdx,%r10 | |
1a8: 48 29 f8 sub %rdi,%rax | |
1ab: 49 83 ea 09 sub $0x9,%r10 | |
1af: 48 83 e8 09 sub $0x9,%rax | |
1b3: 49 83 fa 0e cmp $0xe,%r10 | |
1b7: 0f 86 bb 01 00 00 jbe 378 <ZSTD_safecopy+0x378> | |
1bd: 48 39 ce cmp %rcx,%rsi | |
1c0: 41 0f 96 c3 setbe %r11b | |
1c4: 48 83 f8 1f cmp $0x1f,%rax | |
1c8: 41 0f 97 c2 seta %r10b | |
1cc: 45 84 d3 test %r10b,%r11b | |
1cf: 0f 84 a3 01 00 00 je 378 <ZSTD_safecopy+0x378> | |
1d5: 48 c1 e8 03 shr $0x3,%rax | |
1d9: 48 83 c0 01 add $0x1,%rax | |
1dd: 48 39 ce cmp %rcx,%rsi | |
1e0: b9 01 00 00 00 mov $0x1,%ecx | |
1e5: 48 0f 46 c8 cmovbe %rax,%rcx | |
1e9: b8 08 00 00 00 mov $0x8,%eax | |
1ee: 48 89 ce mov %rcx,%rsi | |
1f1: 48 d1 ee shr %rsi | |
1f4: 48 c1 e6 04 shl $0x4,%rsi | |
1f8: 48 83 c6 08 add $0x8,%rsi | |
1fc: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 8); | |
200: f3 0f 6f 14 02 movdqu (%rdx,%rax,1),%xmm2 | |
205: 0f 11 14 07 movups %xmm2,(%rdi,%rax,1) | |
/* Handle short offset copies. */ | |
do { | |
COPY8(op, ip) | |
} while (op < oend); | |
209: 48 83 c0 10 add $0x10,%rax | |
20d: 48 39 f0 cmp %rsi,%rax | |
210: 75 ee jne 200 <ZSTD_safecopy+0x200> | |
212: 48 89 ca mov %rcx,%rdx | |
215: 48 83 e2 fe and $0xfffffffffffffffe,%rdx | |
219: 48 8d 04 d5 00 00 00 lea 0x0(,%rdx,8),%rax | |
220: 00 | |
221: 49 01 c1 add %rax,%r9 | |
224: 49 01 c0 add %rax,%r8 | |
227: 48 39 d1 cmp %rdx,%rcx | |
22a: 0f 84 2b ff ff ff je 15b <ZSTD_safecopy+0x15b> | |
ZSTD_memcpy(dst, src, 8); | |
230: 49 8b 01 mov (%r9),%rax | |
233: 49 89 00 mov %rax,(%r8) | |
} | |
236: 5b pop %rbx | |
237: c3 retq | |
238: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
23f: 00 | |
240: 48 83 c6 01 add $0x1,%rsi | |
244: 48 83 c0 01 add $0x1,%rax | |
while (op < oend) *op++ = *ip++; | |
248: 0f b6 56 ff movzbl -0x1(%rsi),%edx | |
24c: 88 50 ff mov %dl,-0x1(%rax) | |
24f: 48 39 c1 cmp %rax,%rcx | |
252: 77 ec ja 240 <ZSTD_safecopy+0x240> | |
} | |
254: 5b pop %rbx | |
255: c3 retq | |
256: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
25d: 00 00 00 | |
while (op < oend) *op++ = *ip++; | |
260: 48 39 f9 cmp %rdi,%rcx | |
263: 0f 86 07 01 00 00 jbe 370 <ZSTD_safecopy+0x370> | |
269: 49 89 fa mov %rdi,%r10 | |
26c: 4c 8d 42 01 lea 0x1(%rdx),%r8 | |
270: 48 89 fe mov %rdi,%rsi | |
273: 49 f7 d2 not %r10 | |
276: 4c 29 c6 sub %r8,%rsi | |
279: 49 01 ca add %rcx,%r10 | |
27c: 48 83 fe 0e cmp $0xe,%rsi | |
280: 0f 86 b2 02 00 00 jbe 538 <ZSTD_safecopy+0x538> | |
286: 49 83 fa 06 cmp $0x6,%r10 | |
28a: 0f 86 a8 02 00 00 jbe 538 <ZSTD_safecopy+0x538> | |
290: 49 83 fa 0e cmp $0xe,%r10 | |
294: 0f 86 e7 02 00 00 jbe 581 <ZSTD_safecopy+0x581> | |
29a: 49 89 c0 mov %rax,%r8 | |
29d: 31 f6 xor %esi,%esi | |
29f: 49 83 e0 f0 and $0xfffffffffffffff0,%r8 | |
2a3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
2a8: f3 0f 6f 0c 32 movdqu (%rdx,%rsi,1),%xmm1 | |
2ad: 0f 11 0c 37 movups %xmm1,(%rdi,%rsi,1) | |
2b1: 48 83 c6 10 add $0x10,%rsi | |
2b5: 49 39 f0 cmp %rsi,%r8 | |
2b8: 75 ee jne 2a8 <ZSTD_safecopy+0x2a8> | |
2ba: 49 89 c0 mov %rax,%r8 | |
2bd: 49 83 e0 f0 and $0xfffffffffffffff0,%r8 | |
2c1: 4a 8d 34 07 lea (%rdi,%r8,1),%rsi | |
2c5: 4e 8d 0c 02 lea (%rdx,%r8,1),%r9 | |
2c9: 4c 39 c0 cmp %r8,%rax | |
2cc: 0f 84 9e 00 00 00 je 370 <ZSTD_safecopy+0x370> | |
2d2: 4c 29 c0 sub %r8,%rax | |
2d5: 4d 29 c2 sub %r8,%r10 | |
2d8: 49 89 c3 mov %rax,%r11 | |
2db: 49 83 fa 06 cmp $0x6,%r10 | |
2df: 76 1a jbe 2fb <ZSTD_safecopy+0x2fb> | |
2e1: 4a 8b 04 02 mov (%rdx,%r8,1),%rax | |
2e5: 4a 89 04 07 mov %rax,(%rdi,%r8,1) | |
2e9: 4c 89 d8 mov %r11,%rax | |
2ec: 48 83 e0 f8 and $0xfffffffffffffff8,%rax | |
2f0: 48 01 c6 add %rax,%rsi | |
2f3: 49 01 c1 add %rax,%r9 | |
2f6: 4c 39 d8 cmp %r11,%rax | |
2f9: 74 75 je 370 <ZSTD_safecopy+0x370> | |
2fb: 41 0f b6 01 movzbl (%r9),%eax | |
2ff: 88 06 mov %al,(%rsi) | |
301: 48 8d 46 01 lea 0x1(%rsi),%rax | |
305: 48 39 c1 cmp %rax,%rcx | |
308: 76 66 jbe 370 <ZSTD_safecopy+0x370> | |
30a: 41 0f b6 41 01 movzbl 0x1(%r9),%eax | |
30f: 88 46 01 mov %al,0x1(%rsi) | |
312: 48 8d 46 02 lea 0x2(%rsi),%rax | |
316: 48 39 c1 cmp %rax,%rcx | |
319: 76 55 jbe 370 <ZSTD_safecopy+0x370> | |
31b: 41 0f b6 41 02 movzbl 0x2(%r9),%eax | |
320: 88 46 02 mov %al,0x2(%rsi) | |
323: 48 8d 46 03 lea 0x3(%rsi),%rax | |
327: 48 39 c1 cmp %rax,%rcx | |
32a: 76 44 jbe 370 <ZSTD_safecopy+0x370> | |
32c: 41 0f b6 41 03 movzbl 0x3(%r9),%eax | |
331: 88 46 03 mov %al,0x3(%rsi) | |
334: 48 8d 46 04 lea 0x4(%rsi),%rax | |
338: 48 39 c1 cmp %rax,%rcx | |
33b: 76 33 jbe 370 <ZSTD_safecopy+0x370> | |
33d: 41 0f b6 41 04 movzbl 0x4(%r9),%eax | |
342: 88 46 04 mov %al,0x4(%rsi) | |
345: 48 8d 46 05 lea 0x5(%rsi),%rax | |
349: 48 39 c1 cmp %rax,%rcx | |
34c: 76 22 jbe 370 <ZSTD_safecopy+0x370> | |
34e: 41 0f b6 41 05 movzbl 0x5(%r9),%eax | |
353: 88 46 05 mov %al,0x5(%rsi) | |
356: 48 8d 46 06 lea 0x6(%rsi),%rax | |
35a: 48 39 c1 cmp %rax,%rcx | |
35d: 76 11 jbe 370 <ZSTD_safecopy+0x370> | |
35f: 41 0f b6 41 06 movzbl 0x6(%r9),%eax | |
364: 88 46 06 mov %al,0x6(%rsi) | |
367: c3 retq | |
368: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
36f: 00 | |
370: c3 retq | |
371: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
378: 49 8b 01 mov (%r9),%rax | |
COPY8(op, ip) | |
37b: 49 83 c0 08 add $0x8,%r8 | |
37f: 49 83 c1 08 add $0x8,%r9 | |
ZSTD_memcpy(dst, src, 8); | |
383: 49 89 40 f8 mov %rax,-0x8(%r8) | |
} while (op < oend); | |
387: 4c 39 c1 cmp %r8,%rcx | |
38a: 77 ec ja 378 <ZSTD_safecopy+0x378> | |
38c: e9 ca fd ff ff jmpq 15b <ZSTD_safecopy+0x15b> | |
391: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
(*op)[0] = (*ip)[0]; | |
398: 44 0f b6 0a movzbl (%rdx),%r9d | |
39c: 44 88 0f mov %r9b,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
39f: 44 0f b6 4a 01 movzbl 0x1(%rdx),%r9d | |
3a4: 44 88 4f 01 mov %r9b,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
3a8: 44 0f b6 4a 02 movzbl 0x2(%rdx),%r9d | |
3ad: 44 88 4f 02 mov %r9b,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
3b1: 44 0f b6 4a 03 movzbl 0x3(%rdx),%r9d | |
3b6: 44 88 4f 03 mov %r9b,0x3(%rdi) | |
*ip += dec32table[offset]; | |
3ba: 4c 8d 0d 00 00 00 00 lea 0x0(%rip),%r9 # 3c1 <ZSTD_safecopy+0x3c1> | |
3c1: 47 8b 0c 81 mov (%r9,%r8,4),%r9d | |
3c5: 4c 01 ca add %r9,%rdx | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
3c8: 44 8b 0a mov (%rdx),%r9d | |
3cb: 44 89 4f 04 mov %r9d,0x4(%rdi) | |
*ip -= sub2; | |
3cf: 4c 8d 0d 00 00 00 00 lea 0x0(%rip),%r9 # 3d6 <ZSTD_safecopy+0x3d6> | |
3d6: 4f 63 04 81 movslq (%r9,%r8,4),%r8 | |
3da: 4c 29 c2 sub %r8,%rdx | |
3dd: e9 94 fd ff ff jmpq 176 <ZSTD_safecopy+0x176> | |
3e2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
if (op <= oend_w) { | |
3e8: 4c 39 c6 cmp %r8,%rsi | |
3eb: 0f 82 a6 01 00 00 jb 597 <ZSTD_safecopy+0x597> | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
3f1: 4c 89 c0 mov %r8,%rax | |
ZSTD_wildcopy(op, ip, oend_w - op, ovtype); | |
3f4: 49 89 f2 mov %rsi,%r10 | |
3f7: 4c 29 c8 sub %r9,%rax | |
3fa: 4d 29 c2 sub %r8,%r10 | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
3fd: 48 83 f8 0f cmp $0xf,%rax | |
401: 0f 8f 88 01 00 00 jg 58f <ZSTD_safecopy+0x58f> | |
407: 48 83 c7 09 add $0x9,%rdi | |
40b: 48 8d 46 ff lea -0x1(%rsi),%rax | |
40f: 4c 29 c0 sub %r8,%rax | |
412: 48 39 f7 cmp %rsi,%rdi | |
415: 0f 96 c3 setbe %bl | |
418: 48 83 f8 1f cmp $0x1f,%rax | |
41c: 41 0f 97 c3 seta %r11b | |
420: 44 84 db test %r11b,%bl | |
423: 0f 84 37 01 00 00 je 560 <ZSTD_safecopy+0x560> | |
429: 4d 89 c3 mov %r8,%r11 | |
42c: 49 29 d3 sub %rdx,%r11 | |
42f: 49 8d 53 f7 lea -0x9(%r11),%rdx | |
433: 48 83 fa 0e cmp $0xe,%rdx | |
437: 0f 86 23 01 00 00 jbe 560 <ZSTD_safecopy+0x560> | |
43d: 48 c1 e8 03 shr $0x3,%rax | |
441: 48 39 f7 cmp %rsi,%rdi | |
444: 48 8d 50 01 lea 0x1(%rax),%rdx | |
448: b8 01 00 00 00 mov $0x1,%eax | |
44d: 48 0f 47 d0 cmova %rax,%rdx | |
451: 31 c0 xor %eax,%eax | |
453: 48 89 d7 mov %rdx,%rdi | |
456: 48 d1 ef shr %rdi | |
459: 48 c1 e7 04 shl $0x4,%rdi | |
45d: 0f 1f 00 nopl (%rax) | |
ZSTD_memcpy(dst, src, 8); | |
460: f3 41 0f 6f 1c 01 movdqu (%r9,%rax,1),%xmm3 | |
466: 41 0f 11 1c 00 movups %xmm3,(%r8,%rax,1) | |
} while (op < oend); | |
46b: 48 83 c0 10 add $0x10,%rax | |
46f: 48 39 f8 cmp %rdi,%rax | |
472: 75 ec jne 460 <ZSTD_safecopy+0x460> | |
474: 49 89 d3 mov %rdx,%r11 | |
477: 49 83 e3 fe and $0xfffffffffffffffe,%r11 | |
47b: 4a 8d 04 dd 00 00 00 lea 0x0(,%r11,8),%rax | |
482: 00 | |
483: 49 8d 3c 01 lea (%r9,%rax,1),%rdi | |
487: 49 01 c0 add %rax,%r8 | |
48a: 4c 39 da cmp %r11,%rdx | |
48d: 74 06 je 495 <ZSTD_safecopy+0x495> | |
ZSTD_memcpy(dst, src, 8); | |
48f: 48 8b 07 mov (%rdi),%rax | |
492: 49 89 00 mov %rax,(%r8) | |
ip += oend_w - op; | |
495: 4b 8d 14 11 lea (%r9,%r10,1),%rdx | |
499: 48 89 f7 mov %rsi,%rdi | |
49c: e9 98 fb ff ff jmpq 39 <ZSTD_safecopy+0x39> | |
*ip += 8; | |
4a1: 4c 89 ca mov %r9,%rdx | |
*op += 8; | |
4a4: 4c 89 c7 mov %r8,%rdi | |
4a7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
4ae: 00 00 | |
ZSTD_memcpy(dst, src, 16); | |
4b0: f3 0f 6f 32 movdqu (%rdx),%xmm6 | |
4b4: 0f 11 37 movups %xmm6,(%rdi) | |
COPY16(op, ip); | |
} | |
while (op < oend); | |
#else | |
ZSTD_copy16(op, ip); | |
if (16 >= length) return; | |
4b7: 48 83 f8 10 cmp $0x10,%rax | |
4bb: 0f 8e 9a fc ff ff jle 15b <ZSTD_safecopy+0x15b> | |
op += 16; | |
4c1: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
4c5: 48 83 c2 10 add $0x10,%rdx | |
4c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
4d0: f3 0f 6f 22 movdqu (%rdx),%xmm4 | |
4d4: 48 83 c7 20 add $0x20,%rdi | |
4d8: 48 83 c2 20 add $0x20,%rdx | |
4dc: 0f 11 67 e0 movups %xmm4,-0x20(%rdi) | |
4e0: f3 0f 6f 6a f0 movdqu -0x10(%rdx),%xmm5 | |
4e5: 0f 11 6f f0 movups %xmm5,-0x10(%rdi) | |
do { | |
COPY16(op, ip); | |
COPY16(op, ip); | |
} | |
while (op < oend); | |
4e9: 48 39 f9 cmp %rdi,%rcx | |
4ec: 77 e2 ja 4d0 <ZSTD_safecopy+0x4d0> | |
} | |
4ee: 5b pop %rbx | |
4ef: c3 retq | |
ZSTD_wildcopy(op, ip, oend_w - op, ovtype); | |
4f0: 49 89 f2 mov %rsi,%r10 | |
BYTE* const oend = op + length; | |
4f3: 49 89 d1 mov %rdx,%r9 | |
4f6: 49 29 fa sub %rdi,%r10 | |
ZSTD_memcpy(dst, src, 16); | |
4f9: f3 41 0f 6f 39 movdqu (%r9),%xmm7 | |
4fe: 0f 11 3f movups %xmm7,(%rdi) | |
if (16 >= length) return; | |
501: 49 83 fa 10 cmp $0x10,%r10 | |
505: 7e 8e jle 495 <ZSTD_safecopy+0x495> | |
op += 16; | |
507: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
50b: 49 8d 41 10 lea 0x10(%r9),%rax | |
50f: 90 nop | |
ZSTD_memcpy(dst, src, 16); | |
510: f3 0f 6f 30 movdqu (%rax),%xmm6 | |
514: 48 83 c7 20 add $0x20,%rdi | |
518: 48 83 c0 20 add $0x20,%rax | |
51c: 0f 11 77 e0 movups %xmm6,-0x20(%rdi) | |
520: f3 0f 6f 78 f0 movdqu -0x10(%rax),%xmm7 | |
525: 0f 11 7f f0 movups %xmm7,-0x10(%rdi) | |
while (op < oend); | |
529: 48 39 fe cmp %rdi,%rsi | |
52c: 77 e2 ja 510 <ZSTD_safecopy+0x510> | |
52e: e9 62 ff ff ff jmpq 495 <ZSTD_safecopy+0x495> | |
533: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
while (op < oend) *op++ = *ip++; | |
538: 31 c9 xor %ecx,%ecx | |
53a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
540: 0f b6 34 0a movzbl (%rdx,%rcx,1),%esi | |
544: 40 88 34 0f mov %sil,(%rdi,%rcx,1) | |
548: 48 83 c1 01 add $0x1,%rcx | |
54c: 48 39 c8 cmp %rcx,%rax | |
54f: 75 ef jne 540 <ZSTD_safecopy+0x540> | |
551: c3 retq | |
ip += oend_w - op; | |
552: 49 89 d1 mov %rdx,%r9 | |
555: 48 89 f8 mov %rdi,%rax | |
558: 45 31 c0 xor %r8d,%r8d | |
55b: e9 62 fb ff ff jmpq c2 <ZSTD_safecopy+0xc2> | |
*ip += 8; | |
560: 4c 89 c8 mov %r9,%rax | |
563: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 8); | |
568: 48 8b 10 mov (%rax),%rdx | |
COPY8(op, ip) | |
56b: 49 83 c0 08 add $0x8,%r8 | |
56f: 48 83 c0 08 add $0x8,%rax | |
ZSTD_memcpy(dst, src, 8); | |
573: 49 89 50 f8 mov %rdx,-0x8(%r8) | |
} while (op < oend); | |
577: 4c 39 c6 cmp %r8,%rsi | |
57a: 77 ec ja 568 <ZSTD_safecopy+0x568> | |
57c: e9 14 ff ff ff jmpq 495 <ZSTD_safecopy+0x495> | |
while (op < oend) *op++ = *ip++; | |
581: 49 89 d1 mov %rdx,%r9 | |
584: 48 89 fe mov %rdi,%rsi | |
587: 45 31 c0 xor %r8d,%r8d | |
58a: e9 52 fd ff ff jmpq 2e1 <ZSTD_safecopy+0x2e1> | |
58f: 4c 89 c7 mov %r8,%rdi | |
592: e9 62 ff ff ff jmpq 4f9 <ZSTD_safecopy+0x4f9> | |
*ip += 8; | |
597: 4c 89 ca mov %r9,%rdx | |
59a: 4c 89 c7 mov %r8,%rdi | |
59d: e9 8e fa ff ff jmpq 30 <ZSTD_safecopy+0x30> | |
5a2: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
5a9: 00 00 00 00 | |
5ad: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
5b4: 00 00 00 00 | |
5b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
5bf: 00 | |
00000000000005c0 <ZSTD_execSequenceEnd>: | |
FORCE_NOINLINE | |
size_t ZSTD_execSequenceEnd(BYTE* op, | |
BYTE* const oend, seq_t sequence, | |
const BYTE** litPtr, const BYTE* const litLimit, | |
const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd) | |
{ | |
5c0: 41 57 push %r15 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
const BYTE* match = oLitEnd - sequence.offset; | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; | |
/* bounds checks : careful of address space overflow in 32-bit mode */ | |
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer"); | |
5c2: 48 89 f0 mov %rsi,%rax | |
{ | |
5c5: 41 56 push %r14 | |
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer"); | |
5c7: 48 29 f8 sub %rdi,%rax | |
{ | |
5ca: 41 55 push %r13 | |
5cc: 41 54 push %r12 | |
5ce: 55 push %rbp | |
5cf: 53 push %rbx | |
5d0: 48 83 ec 38 sub $0x38,%rsp | |
5d4: 4c 8b 64 24 70 mov 0x70(%rsp),%r12 | |
5d9: 4c 8b 7c 24 78 mov 0x78(%rsp),%r15 | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
5de: 4f 8d 34 3c lea (%r12,%r15,1),%r14 | |
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer"); | |
5e2: 4c 39 f0 cmp %r14,%rax | |
5e5: 0f 82 fd 00 00 00 jb 6e8 <ZSTD_execSequenceEnd+0x128> | |
5eb: 48 89 d3 mov %rdx,%rbx | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
5ee: 48 8b 12 mov (%rdx),%rdx | |
RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer"); | |
5f1: 48 29 d1 sub %rdx,%rcx | |
5f4: 4c 39 e1 cmp %r12,%rcx | |
5f7: 0f 82 db 00 00 00 jb 6d8 <ZSTD_execSequenceEnd+0x118> | |
5fd: 4c 89 4c 24 28 mov %r9,0x28(%rsp) | |
BYTE* const oLitEnd = op + sequence.litLength; | |
602: 4e 8d 0c 27 lea (%rdi,%r12,1),%r9 | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; | |
606: 48 8d 6e e0 lea -0x20(%rsi),%rbp | |
assert(op < op + sequenceLength); | |
assert(oLitEnd < op + sequenceLength); | |
/* copy literals */ | |
ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap); | |
60a: 4d 89 c5 mov %r8,%r13 | |
const BYTE* match = oLitEnd - sequence.offset; | |
60d: 4d 89 ca mov %r9,%r10 | |
ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap); | |
610: 45 31 c0 xor %r8d,%r8d | |
613: 4c 89 e1 mov %r12,%rcx | |
616: 48 89 ee mov %rbp,%rsi | |
619: 48 8b 84 24 80 00 00 mov 0x80(%rsp),%rax | |
620: 00 | |
const BYTE* match = oLitEnd - sequence.offset; | |
621: 4c 89 4c 24 20 mov %r9,0x20(%rsp) | |
ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap); | |
626: 48 89 54 24 08 mov %rdx,0x8(%rsp) | |
const BYTE* match = oLitEnd - sequence.offset; | |
62b: 49 29 c2 sub %rax,%r10 | |
62e: 48 89 44 24 18 mov %rax,0x18(%rsp) | |
633: 4c 89 54 24 10 mov %r10,0x10(%rsp) | |
ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap); | |
638: e8 c3 f9 ff ff callq 0 <ZSTD_safecopy> | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
63d: 48 8b 54 24 08 mov 0x8(%rsp),%rdx | |
op = oLitEnd; | |
*litPtr = iLitEnd; | |
/* copy Match */ | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
642: 4c 8b 4c 24 20 mov 0x20(%rsp),%r9 | |
647: 48 8b 44 24 18 mov 0x18(%rsp),%rax | |
64c: 4c 8b 54 24 10 mov 0x10(%rsp),%r10 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
651: 4c 01 e2 add %r12,%rdx | |
654: 48 89 13 mov %rdx,(%rbx) | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
657: 4c 89 ca mov %r9,%rdx | |
65a: 4c 29 ea sub %r13,%rdx | |
65d: 48 39 c2 cmp %rax,%rdx | |
660: 73 46 jae 6a8 <ZSTD_execSequenceEnd+0xe8> | |
/* offset beyond prefix */ | |
RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, ""); | |
662: 4c 8b 5c 24 28 mov 0x28(%rsp),%r11 | |
667: 4c 89 ca mov %r9,%rdx | |
66a: 4c 29 da sub %r11,%rdx | |
66d: 48 39 c2 cmp %rax,%rdx | |
670: 72 66 jb 6d8 <ZSTD_execSequenceEnd+0x118> | |
match = dictEnd - (prefixStart-match); | |
672: 48 8b b4 24 88 00 00 mov 0x88(%rsp),%rsi | |
679: 00 | |
67a: 4c 89 eb mov %r13,%rbx | |
67d: 4c 29 d3 sub %r10,%rbx | |
680: 48 29 de sub %rbx,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
683: 4a 8d 04 3e lea (%rsi,%r15,1),%rax | |
687: 48 39 84 24 88 00 00 cmp %rax,0x88(%rsp) | |
68e: 00 | |
68f: 73 67 jae 6f8 <ZSTD_execSequenceEnd+0x138> | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
return sequenceLength; | |
} | |
/* span extDict & currentPrefixSegment */ | |
{ size_t const length1 = dictEnd - match; | |
ZSTD_memmove(oLitEnd, match, length1); | |
691: 4c 89 cf mov %r9,%rdi | |
694: 48 89 da mov %rbx,%rdx | |
op = oLitEnd + length1; | |
sequence.matchLength -= length1; | |
697: 49 29 df sub %rbx,%r15 | |
ZSTD_memmove(oLitEnd, match, length1); | |
69a: e8 00 00 00 00 callq 69f <ZSTD_execSequenceEnd+0xdf> | |
match = prefixStart; | |
69f: 4d 89 ea mov %r13,%r10 | |
ZSTD_memmove(oLitEnd, match, length1); | |
6a2: 49 89 c1 mov %rax,%r9 | |
op = oLitEnd + length1; | |
6a5: 49 01 d9 add %rbx,%r9 | |
} } | |
ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst); | |
6a8: 41 b8 01 00 00 00 mov $0x1,%r8d | |
6ae: 4c 89 f9 mov %r15,%rcx | |
6b1: 4c 89 d2 mov %r10,%rdx | |
6b4: 48 89 ee mov %rbp,%rsi | |
6b7: 4c 89 cf mov %r9,%rdi | |
6ba: e8 41 f9 ff ff callq 0 <ZSTD_safecopy> | |
return sequenceLength; | |
} | |
6bf: 48 83 c4 38 add $0x38,%rsp | |
6c3: 4c 89 f0 mov %r14,%rax | |
6c6: 5b pop %rbx | |
6c7: 5d pop %rbp | |
6c8: 41 5c pop %r12 | |
6ca: 41 5d pop %r13 | |
6cc: 41 5e pop %r14 | |
6ce: 41 5f pop %r15 | |
6d0: c3 retq | |
6d1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer"); | |
6d8: 49 c7 c6 ec ff ff ff mov $0xffffffffffffffec,%r14 | |
6df: eb de jmp 6bf <ZSTD_execSequenceEnd+0xff> | |
6e1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer"); | |
6e8: 49 c7 c6 ba ff ff ff mov $0xffffffffffffffba,%r14 | |
6ef: eb ce jmp 6bf <ZSTD_execSequenceEnd+0xff> | |
6f1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
6f8: 4c 89 fa mov %r15,%rdx | |
6fb: 4c 89 cf mov %r9,%rdi | |
6fe: e8 00 00 00 00 callq 703 <ZSTD_execSequenceEnd+0x143> | |
return sequenceLength; | |
703: eb ba jmp 6bf <ZSTD_execSequenceEnd+0xff> | |
705: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
70c: 00 00 00 00 | |
710: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
717: 00 00 00 00 | |
71b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
0000000000000720 <ZSTD_buildFSETable_body_bmi2.constprop.0>: | |
TARGET_ATTRIBUTE("bmi2") static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt, | |
720: 45 89 cb mov %r9d,%r11d | |
723: 41 57 push %r15 | |
U32 const tableSize = 1 << tableLog; | |
725: b8 01 00 00 00 mov $0x1,%eax | |
TARGET_ATTRIBUTE("bmi2") static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt, | |
72a: 41 89 d7 mov %edx,%r15d | |
72d: 41 56 push %r14 | |
72f: 4d 89 c6 mov %r8,%r14 | |
732: 41 55 push %r13 | |
734: 49 89 cd mov %rcx,%r13 | |
DTableH.fastMode = 1; | |
737: 4c 89 d9 mov %r11,%rcx | |
TARGET_ATTRIBUTE("bmi2") static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt, | |
73a: 41 54 push %r12 | |
DTableH.fastMode = 1; | |
73c: 48 c1 e1 20 shl $0x20,%rcx | |
TARGET_ATTRIBUTE("bmi2") static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt, | |
740: 55 push %rbp | |
DTableH.fastMode = 1; | |
741: 48 83 c9 01 or $0x1,%rcx | |
TARGET_ATTRIBUTE("bmi2") static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt, | |
745: 53 push %rbx | |
746: 48 89 f3 mov %rsi,%rbx | |
749: 4c 8b 64 24 38 mov 0x38(%rsp),%r12 | |
74e: 48 89 7c 24 e0 mov %rdi,-0x20(%rsp) | |
753: 44 89 4c 24 f0 mov %r9d,-0x10(%rsp) | |
ZSTD_seqSymbol* const tableDecode = dt+1; | |
758: 4c 8d 4f 08 lea 0x8(%rdi),%r9 | |
U32 const tableSize = 1 << tableLog; | |
75c: 44 89 df mov %r11d,%edi | |
DTableH.fastMode = 1; | |
75f: 48 89 4c 24 e8 mov %rcx,-0x18(%rsp) | |
U32 const tableSize = 1 << tableLog; | |
764: c4 e2 41 f7 f0 shlx %edi,%eax,%esi | |
U32 highThreshold = tableSize - 1; | |
769: 8d 56 ff lea -0x1(%rsi),%edx | |
BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1); | |
76c: 49 8d 7c 24 6a lea 0x6a(%r12),%rdi | |
DTableH.fastMode = 1; | |
771: 48 89 4c 24 d8 mov %rcx,-0x28(%rsp) | |
{ S16 const largeLimit= (S16)(1 << (tableLog-1)); | |
776: 41 8d 4b ff lea -0x1(%r11),%ecx | |
77a: c4 e2 71 f7 c0 shlx %ecx,%eax,%eax | |
size_t const step = FSE_TABLESTEP(tableSize); | |
77f: 89 f1 mov %esi,%ecx | |
U32 const tableSize = 1 << tableLog; | |
781: 89 74 24 d4 mov %esi,-0x2c(%rsp) | |
size_t const step = FSE_TABLESTEP(tableSize); | |
785: c1 ee 03 shr $0x3,%esi | |
788: d1 e9 shr %ecx | |
{ S16 const largeLimit= (S16)(1 << (tableLog-1)); | |
78a: 41 89 c0 mov %eax,%r8d | |
size_t const step = FSE_TABLESTEP(tableSize); | |
78d: 8d 74 31 03 lea 0x3(%rcx,%rsi,1),%esi | |
for (s=0; s<maxSV1; s++) { | |
791: 41 83 ff ff cmp $0xffffffff,%r15d | |
795: 0f 84 52 02 00 00 je 9ed <ZSTD_buildFSETable_body_bmi2.constprop.0+0x2cd> | |
79b: 89 54 24 f4 mov %edx,-0xc(%rsp) | |
U32 highThreshold = tableSize - 1; | |
79f: 89 d1 mov %edx,%ecx | |
for (s=0; s<maxSV1; s++) { | |
7a1: 31 c0 xor %eax,%eax | |
7a3: 45 31 db xor %r11d,%r11d | |
7a6: 41 ba 01 00 00 00 mov $0x1,%r10d | |
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; | |
7ac: 31 ed xor %ebp,%ebp | |
7ae: 44 89 c2 mov %r8d,%edx | |
7b1: eb 24 jmp 7d7 <ZSTD_buildFSETable_body_bmi2.constprop.0+0xb7> | |
7b3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
7b8: 66 44 39 c2 cmp %r8w,%dx | |
symbolNext[s] = (U16)normalizedCounter[s]; | |
7bc: 66 45 89 04 44 mov %r8w,(%r12,%rax,2) | |
7c1: 41 bb 01 00 00 00 mov $0x1,%r11d | |
for (s=0; s<maxSV1; s++) { | |
7c7: 4c 8d 40 01 lea 0x1(%rax),%r8 | |
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; | |
7cb: 4c 0f 4e d5 cmovle %rbp,%r10 | |
for (s=0; s<maxSV1; s++) { | |
7cf: 49 39 c7 cmp %rax,%r15 | |
7d2: 74 2e je 802 <ZSTD_buildFSETable_body_bmi2.constprop.0+0xe2> | |
7d4: 4c 89 c0 mov %r8,%rax | |
if (normalizedCounter[s]==-1) { | |
7d7: 44 0f b7 04 43 movzwl (%rbx,%rax,2),%r8d | |
7dc: 66 41 83 f8 ff cmp $0xffff,%r8w | |
7e1: 75 d5 jne 7b8 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x98> | |
tableDecode[highThreshold--].baseValue = s; | |
7e3: 41 89 c8 mov %ecx,%r8d | |
7e6: 83 e9 01 sub $0x1,%ecx | |
7e9: 43 89 44 c1 04 mov %eax,0x4(%r9,%r8,8) | |
symbolNext[s] = 1; | |
7ee: 41 b8 01 00 00 00 mov $0x1,%r8d | |
7f4: 66 45 89 04 44 mov %r8w,(%r12,%rax,2) | |
for (s=0; s<maxSV1; s++) { | |
7f9: 4c 8d 40 01 lea 0x1(%rax),%r8 | |
7fd: 49 39 c7 cmp %rax,%r15 | |
800: 75 d2 jne 7d4 <ZSTD_buildFSETable_body_bmi2.constprop.0+0xb4> | |
802: 8b 54 24 f4 mov -0xc(%rsp),%edx | |
806: 45 84 db test %r11b,%r11b | |
809: 74 17 je 822 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x102> | |
80b: 48 b8 00 00 00 00 ff movabs $0xffffffff00000000,%rax | |
812: ff ff ff | |
815: 48 23 44 24 e8 and -0x18(%rsp),%rax | |
81a: 4c 09 d0 or %r10,%rax | |
81d: 48 89 44 24 d8 mov %rax,-0x28(%rsp) | |
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH)); | |
822: 48 8b 44 24 e0 mov -0x20(%rsp),%rax | |
827: 4c 8b 5c 24 d8 mov -0x28(%rsp),%r11 | |
82c: 4c 89 18 mov %r11,(%rax) | |
if (highThreshold == tableSize - 1) { | |
82f: 39 ca cmp %ecx,%edx | |
831: 0f 84 be 00 00 00 je 8f5 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x1d5> | |
837: 31 ed xor %ebp,%ebp | |
U32 s, position = 0; | |
839: 31 c0 xor %eax,%eax | |
83b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
int const n = normalizedCounter[s]; | |
840: 44 0f bf 04 6b movswl (%rbx,%rbp,2),%r8d | |
845: 41 89 ea mov %ebp,%r10d | |
for (i=0; i<n; i++) { | |
848: 45 85 c0 test %r8d,%r8d | |
84b: 7e 23 jle 870 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x150> | |
84d: 31 ff xor %edi,%edi | |
84f: 90 nop | |
tableDecode[position].baseValue = s; | |
850: 41 89 c3 mov %eax,%r11d | |
853: 47 89 54 d9 04 mov %r10d,0x4(%r9,%r11,8) | |
858: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
85f: 00 | |
position = (position + step) & tableMask; | |
860: 01 f0 add %esi,%eax | |
862: 21 d0 and %edx,%eax | |
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */ | |
864: 39 c8 cmp %ecx,%eax | |
866: 77 f8 ja 860 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x140> | |
for (i=0; i<n; i++) { | |
868: 83 c7 01 add $0x1,%edi | |
86b: 41 39 f8 cmp %edi,%r8d | |
86e: 75 e0 jne 850 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x130> | |
for (s=0; s<maxSV1; s++) { | |
870: 48 8d 7d 01 lea 0x1(%rbp),%rdi | |
874: 49 39 ef cmp %rbp,%r15 | |
877: 74 05 je 87e <ZSTD_buildFSETable_body_bmi2.constprop.0+0x15e> | |
879: 48 89 fd mov %rdi,%rbp | |
87c: eb c2 jmp 840 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x120> | |
for (u=0; u<tableSize; u++) { | |
87e: 8b 44 24 d4 mov -0x2c(%rsp),%eax | |
882: 85 c0 test %eax,%eax | |
884: 74 64 je 8ea <ZSTD_buildFSETable_body_bmi2.constprop.0+0x1ca> | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
886: 44 8b 54 24 d4 mov -0x2c(%rsp),%r10d | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
88b: 44 0f b6 44 24 f0 movzbl -0x10(%rsp),%r8d | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
891: 31 c9 xor %ecx,%ecx | |
893: 44 89 d7 mov %r10d,%edi | |
896: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
89d: 00 00 00 | |
U32 const nextState = symbolNext[symbol]++; | |
8a0: 41 8b 51 04 mov 0x4(%r9),%edx | |
for (u=0; u<tableSize; u++) { | |
8a4: 83 c1 01 add $0x1,%ecx | |
8a7: 49 83 c1 08 add $0x8,%r9 | |
U32 const nextState = symbolNext[symbol]++; | |
8ab: 49 8d 34 54 lea (%r12,%rdx,2),%rsi | |
8af: 0f b7 06 movzwl (%rsi),%eax | |
8b2: 44 8d 58 01 lea 0x1(%rax),%r11d | |
8b6: 66 44 89 1e mov %r11w,(%rsi) | |
# else | |
unsigned long r = 0; | |
return _BitScanReverse(&r, val) ? (unsigned)r : 0; | |
# endif | |
# elif defined(__GNUC__) && (__GNUC__ >= 3) /* Use GCC Intrinsic */ | |
return __builtin_clz (val) ^ 31; | |
8ba: 44 0f bd d8 bsr %eax,%r11d | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
8be: 44 89 c6 mov %r8d,%esi | |
8c1: 44 29 de sub %r11d,%esi | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
8c4: c4 e2 49 f7 c0 shlx %esi,%eax,%eax | |
8c9: 29 f8 sub %edi,%eax | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
8cb: 41 88 71 fb mov %sil,-0x5(%r9) | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
8cf: 66 41 89 41 f8 mov %ax,-0x8(%r9) | |
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol]; | |
8d4: 41 8b 04 96 mov (%r14,%rdx,4),%eax | |
8d8: 41 88 41 fa mov %al,-0x6(%r9) | |
tableDecode[u].baseValue = baseValue[symbol]; | |
8dc: 41 8b 44 95 00 mov 0x0(%r13,%rdx,4),%eax | |
8e1: 41 89 41 fc mov %eax,-0x4(%r9) | |
for (u=0; u<tableSize; u++) { | |
8e5: 41 39 ca cmp %ecx,%r10d | |
8e8: 77 b6 ja 8a0 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x180> | |
} | |
8ea: 5b pop %rbx | |
8eb: 5d pop %rbp | |
8ec: 41 5c pop %r12 | |
8ee: 41 5d pop %r13 | |
8f0: 41 5e pop %r14 | |
8f2: 41 5f pop %r15 | |
8f4: c3 retq | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
8f5: 4a 8d 44 7b 02 lea 0x2(%rbx,%r15,2),%rax | |
8fa: 48 89 54 24 d8 mov %rdx,-0x28(%rsp) | |
size_t const step = FSE_TABLESTEP(tableSize); | |
8ff: 45 31 c0 xor %r8d,%r8d | |
902: 31 c9 xor %ecx,%ecx | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
904: 49 bf 01 01 01 01 01 movabs $0x101010101010101,%r15 | |
90b: 01 01 01 | |
90e: 48 89 c2 mov %rax,%rdx | |
int const n = normalizedCounter[s]; | |
911: 4c 0f bf 13 movswq (%rbx),%r10 | |
MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; } | |
MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; } | |
MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; } | |
MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; } | |
MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; } | |
915: 4c 89 04 0f mov %r8,(%rdi,%rcx,1) | |
for (i = 8; i < n; i += 8) { | |
919: 66 41 83 fa 08 cmp $0x8,%r10w | |
91e: 7e 60 jle 980 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x260> | |
920: 41 0f bf c2 movswl %r10w,%eax | |
924: 83 e8 09 sub $0x9,%eax | |
927: 41 89 c3 mov %eax,%r11d | |
92a: 41 c1 eb 03 shr $0x3,%r11d | |
92e: 41 83 c3 01 add $0x1,%r11d | |
932: 83 f8 07 cmp $0x7,%eax | |
935: 0f 86 ab 00 00 00 jbe 9e6 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x2c6> | |
93b: 44 89 dd mov %r11d,%ebp | |
93e: 66 49 0f 6e c0 movq %r8,%xmm0 | |
943: 49 8d 44 0c 72 lea 0x72(%r12,%rcx,1),%rax | |
948: d1 ed shr %ebp | |
94a: 66 0f 6c c0 punpcklqdq %xmm0,%xmm0 | |
94e: 48 c1 e5 04 shl $0x4,%rbp | |
952: 48 01 c5 add %rax,%rbp | |
955: 0f 1f 00 nopl (%rax) | |
958: 0f 11 00 movups %xmm0,(%rax) | |
95b: 48 83 c0 10 add $0x10,%rax | |
95f: 48 39 c5 cmp %rax,%rbp | |
962: 75 f4 jne 958 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x238> | |
964: 44 89 dd mov %r11d,%ebp | |
967: 83 e5 fe and $0xfffffffe,%ebp | |
96a: 8d 04 ed 08 00 00 00 lea 0x8(,%rbp,8),%eax | |
971: 41 39 eb cmp %ebp,%r11d | |
974: 74 0a je 980 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x260> | |
MEM_write64(spread + pos + i, sv); | |
976: 48 98 cltq | |
978: 4c 8d 1c 0f lea (%rdi,%rcx,1),%r11 | |
97c: 4d 89 04 03 mov %r8,(%r11,%rax,1) | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
980: 48 83 c3 02 add $0x2,%rbx | |
pos += n; | |
984: 4c 01 d1 add %r10,%rcx | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
987: 4d 01 f8 add %r15,%r8 | |
98a: 48 39 da cmp %rbx,%rdx | |
98d: 75 82 jne 911 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x1f1> | |
98f: 48 8b 54 24 d8 mov -0x28(%rsp),%rdx | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
994: 8b 44 24 d4 mov -0x2c(%rsp),%eax | |
998: 48 85 c0 test %rax,%rax | |
99b: 0f 84 49 ff ff ff je 8ea <ZSTD_buildFSETable_body_bmi2.constprop.0+0x1ca> | |
9a1: 48 83 e8 01 sub $0x1,%rax | |
9a5: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
9a9: 4d 8d 54 04 6c lea 0x6c(%r12,%rax,1),%r10 | |
size_t position = 0; | |
9ae: 31 c0 xor %eax,%eax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
9b0: 44 0f b6 07 movzbl (%rdi),%r8d | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
9b4: 48 89 d1 mov %rdx,%rcx | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
9b7: 48 83 c7 02 add $0x2,%rdi | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
9bb: 48 21 c1 and %rax,%rcx | |
9be: 48 01 f0 add %rsi,%rax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
9c1: 45 89 44 c9 04 mov %r8d,0x4(%r9,%rcx,8) | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
9c6: 48 89 d1 mov %rdx,%rcx | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
9c9: 44 0f b6 47 ff movzbl -0x1(%rdi),%r8d | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
9ce: 48 21 c1 and %rax,%rcx | |
position = (position + (unroll * step)) & tableMask; | |
9d1: 48 01 f0 add %rsi,%rax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
9d4: 45 89 44 c9 04 mov %r8d,0x4(%r9,%rcx,8) | |
position = (position + (unroll * step)) & tableMask; | |
9d9: 48 21 d0 and %rdx,%rax | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
9dc: 49 39 fa cmp %rdi,%r10 | |
9df: 75 cf jne 9b0 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x290> | |
9e1: e9 a0 fe ff ff jmpq 886 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x166> | |
for (i = 8; i < n; i += 8) { | |
9e6: b8 08 00 00 00 mov $0x8,%eax | |
9eb: eb 89 jmp 976 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x256> | |
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH)); | |
9ed: 48 8b 44 24 e0 mov -0x20(%rsp),%rax | |
9f2: 48 8b 5c 24 e8 mov -0x18(%rsp),%rbx | |
9f7: 48 89 18 mov %rbx,(%rax) | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
9fa: eb 98 jmp 994 <ZSTD_buildFSETable_body_bmi2.constprop.0+0x274> | |
9fc: 0f 1f 40 00 nopl 0x0(%rax) | |
0000000000000a00 <ZSTD_initFseState>: | |
static void | |
ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt) | |
{ | |
const void* ptr = dt; | |
const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr; | |
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); | |
a00: 44 8b 42 04 mov 0x4(%rdx),%r8d | |
{ | |
/* arbitrate between double-shift and shift+mask */ | |
#if 1 | |
/* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8, | |
* bitstream is likely corrupted, and result is undefined */ | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
a04: 8b 46 08 mov 0x8(%rsi),%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
a07: 4c 8d 0d 00 00 00 00 lea 0x0(%rip),%r9 # a0e <ZSTD_initFseState+0xe> | |
a0e: 4c 8b 1e mov (%rsi),%r11 | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
a11: 44 01 c0 add %r8d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
a14: 89 c1 mov %eax,%ecx | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
} | |
MEM_STATIC FORCE_INLINE_ATTR void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) | |
{ | |
bitD->bitsConsumed += nbBits; | |
a16: 89 46 08 mov %eax,0x8(%rsi) | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
a19: f7 d9 neg %ecx | |
a1b: 49 d3 eb shr %cl,%r11 | |
a1e: 4c 89 d9 mov %r11,%rcx | |
a21: 43 23 0c 81 and (%r9,%r8,4),%ecx | |
a25: 48 89 0f mov %rcx,(%rdi) | |
* This function is safe, it guarantees it will not read beyond src buffer. | |
* @return : status of `BIT_DStream_t` internal register. | |
* when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */ | |
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) | |
{ | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
a28: 83 f8 40 cmp $0x40,%eax | |
a2b: 77 4e ja a7b <ZSTD_initFseState+0x7b> | |
return BIT_DStream_overflow; | |
if (bitD->ptr >= bitD->limitPtr) { | |
a2d: 48 8b 4e 10 mov 0x10(%rsi),%rcx | |
a31: 48 3b 4e 20 cmp 0x20(%rsi),%rcx | |
a35: 73 51 jae a88 <ZSTD_initFseState+0x88> | |
return BIT_reloadDStreamFast(bitD); | |
} | |
if (bitD->ptr == bitD->start) { | |
a37: 4c 8b 56 18 mov 0x18(%rsi),%r10 | |
a3b: 4c 39 d1 cmp %r10,%rcx | |
a3e: 74 3b je a7b <ZSTD_initFseState+0x7b> | |
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; | |
return BIT_DStream_completed; | |
} | |
/* start < ptr < limitPtr */ | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
a40: 41 89 c0 mov %eax,%r8d | |
BIT_DStream_status result = BIT_DStream_unfinished; | |
if (bitD->ptr - nbBytes < bitD->start) { | |
a43: 49 89 c9 mov %rcx,%r9 | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
a46: 41 c1 e8 03 shr $0x3,%r8d | |
if (bitD->ptr - nbBytes < bitD->start) { | |
a4a: 45 89 c3 mov %r8d,%r11d | |
a4d: 4d 29 d9 sub %r11,%r9 | |
a50: 4d 39 ca cmp %r9,%r10 | |
a53: 76 12 jbe a67 <ZSTD_initFseState+0x67> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
a55: 49 89 c9 mov %rcx,%r9 | |
a58: 4d 29 d1 sub %r10,%r9 | |
result = BIT_DStream_endOfBuffer; | |
} | |
bitD->ptr -= nbBytes; | |
a5b: 45 89 ca mov %r9d,%r10d | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
a5e: 45 89 c8 mov %r9d,%r8d | |
bitD->ptr -= nbBytes; | |
a61: 4c 29 d1 sub %r10,%rcx | |
a64: 49 89 c9 mov %rcx,%r9 | |
bitD->bitsConsumed -= nbBytes*8; | |
a67: 41 c1 e0 03 shl $0x3,%r8d | |
bitD->ptr -= nbBytes; | |
a6b: 4c 89 4e 10 mov %r9,0x10(%rsi) | |
bitD->bitsConsumed -= nbBytes*8; | |
a6f: 44 29 c0 sub %r8d,%eax | |
a72: 89 46 08 mov %eax,0x8(%rsi) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
a75: 49 8b 01 mov (%r9),%rax | |
a78: 48 89 06 mov %rax,(%rsi) | |
DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits", | |
(U32)DStatePtr->state, DTableH->tableLog); | |
BIT_reloadDStream(bitD); | |
DStatePtr->table = dt + 1; | |
a7b: 48 83 c2 08 add $0x8,%rdx | |
a7f: 48 89 57 08 mov %rdx,0x8(%rdi) | |
} | |
a83: c3 retq | |
a84: 0f 1f 40 00 nopl 0x0(%rax) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
a88: 41 89 c0 mov %eax,%r8d | |
bitD->bitsConsumed &= 7; | |
a8b: 83 e0 07 and $0x7,%eax | |
DStatePtr->table = dt + 1; | |
a8e: 48 83 c2 08 add $0x8,%rdx | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
a92: 41 c1 e8 03 shr $0x3,%r8d | |
bitD->bitsConsumed &= 7; | |
a96: 89 46 08 mov %eax,0x8(%rsi) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
a99: 4c 29 c1 sub %r8,%rcx | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
a9c: 48 8b 01 mov (%rcx),%rax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
a9f: 48 89 4e 10 mov %rcx,0x10(%rsi) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
aa3: 48 89 06 mov %rax,(%rsi) | |
aa6: 48 89 57 08 mov %rdx,0x8(%rdi) | |
} | |
aaa: c3 retq | |
aab: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
ab2: 00 00 00 00 | |
ab6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
abd: 00 00 00 | |
0000000000000ac0 <ZSTD_decompressSequencesLong_default.constprop.0>: | |
return op-ostart; | |
} | |
static size_t | |
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, | |
ac0: 41 57 push %r15 | |
BYTE* const oend = ostart + maxDstSize; | |
ac2: 48 01 f2 add %rsi,%rdx | |
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, | |
ac5: 41 56 push %r14 | |
ac7: 41 55 push %r13 | |
ac9: 41 54 push %r12 | |
acb: 55 push %rbp | |
acc: 53 push %rbx | |
acd: 48 81 ec 38 02 00 00 sub $0x238,%rsp | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
ad4: 48 8b 87 c0 75 00 00 mov 0x75c0(%rdi),%rax | |
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, | |
adb: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
ae0: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi | |
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, | |
ae7: 48 89 bc 24 88 00 00 mov %rdi,0x88(%rsp) | |
aee: 00 | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
aef: 48 01 f0 add %rsi,%rax | |
ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, | |
af2: 44 89 8c 24 a0 00 00 mov %r9d,0xa0(%rsp) | |
af9: 00 | |
BYTE* const oend = ostart + maxDstSize; | |
afa: 48 89 54 24 78 mov %rdx,0x78(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
aff: 48 89 b4 24 b8 00 00 mov %rsi,0xb8(%rsp) | |
b06: 00 | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
b07: 48 89 44 24 48 mov %rax,0x48(%rsp) | |
if (nbSeq) { | |
b0c: 45 85 c9 test %r9d,%r9d | |
b0f: 0f 84 cb 00 00 00 je be0 <ZSTD_decompressSequencesLong_default.constprop.0+0x120> | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
b15: 48 8b 87 c8 74 00 00 mov 0x74c8(%rdi),%rax | |
dctx->fseEntropy = 1; | |
b1c: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi) | |
b23: 00 00 00 | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
b26: 48 89 44 24 20 mov %rax,0x20(%rsp) | |
const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart); | |
b2b: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax | |
b32: 48 89 84 24 90 00 00 mov %rax,0x90(%rsp) | |
b39: 00 | |
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); | |
b3a: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax | |
b41: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } | |
b46: 8b 87 3c 68 00 00 mov 0x683c(%rdi),%eax | |
b4c: 48 89 84 24 58 01 00 mov %rax,0x158(%rsp) | |
b53: 00 | |
b54: 8b 87 40 68 00 00 mov 0x6840(%rdi),%eax | |
b5a: 48 89 84 24 60 01 00 mov %rax,0x160(%rsp) | |
b61: 00 | |
b62: 8b 87 44 68 00 00 mov 0x6844(%rdi),%eax | |
b68: 48 89 84 24 68 01 00 mov %rax,0x168(%rsp) | |
b6f: 00 | |
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } | |
b70: 4d 85 c0 test %r8,%r8 | |
b73: 74 4b je bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
b75: 48 8d 41 08 lea 0x8(%rcx),%rax | |
bitD->start = (const char*)srcBuffer; | |
b79: 48 89 8c 24 18 01 00 mov %rcx,0x118(%rsp) | |
b80: 00 | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
b81: 48 89 84 24 20 01 00 mov %rax,0x120(%rsp) | |
b88: 00 | |
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; | |
b89: 42 0f b6 44 01 ff movzbl -0x1(%rcx,%r8,1),%eax | |
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ | |
b8f: 49 83 f8 07 cmp $0x7,%r8 | |
b93: 0f 86 87 00 00 00 jbe c20 <ZSTD_decompressSequencesLong_default.constprop.0+0x160> | |
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); | |
b99: 4a 8d 54 01 f8 lea -0x8(%rcx,%r8,1),%rdx | |
b9e: 48 89 94 24 10 01 00 mov %rdx,0x110(%rsp) | |
ba5: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
ba6: 48 8b 12 mov (%rdx),%rdx | |
ba9: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
bb0: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
bb1: 84 c0 test %al,%al | |
bb3: 0f 85 37 04 00 00 jne ff0 <ZSTD_decompressSequencesLong_default.constprop.0+0x530> | |
bb9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF( | |
bc0: 49 c7 c4 ec ff ff ff mov $0xffffffffffffffec,%r12 | |
const void* seqStart, size_t seqSize, int nbSeq, | |
const ZSTD_longOffset_e isLongOffset, | |
const int frame) | |
{ | |
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
} | |
bc7: 48 81 c4 38 02 00 00 add $0x238,%rsp | |
bce: 4c 89 e0 mov %r12,%rax | |
bd1: 5b pop %rbx | |
bd2: 5d pop %rbp | |
bd3: 41 5c pop %r12 | |
bd5: 41 5d pop %r13 | |
bd7: 41 5e pop %r14 | |
bd9: 41 5f pop %r15 | |
bdb: c3 retq | |
bdc: 0f 1f 40 00 nopl 0x0(%rax) | |
BYTE* op = ostart; | |
be0: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11 | |
be5: 48 89 c3 mov %rax,%rbx | |
{ size_t const lastLLSize = litEnd - litPtr; | |
be8: 48 29 f3 sub %rsi,%rbx | |
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, ""); | |
beb: 4c 29 da sub %r11,%rdx | |
bee: 49 c7 c4 ba ff ff ff mov $0xffffffffffffffba,%r12 | |
bf5: 48 39 d3 cmp %rdx,%rbx | |
bf8: 77 cd ja bc7 <ZSTD_decompressSequencesLong_default.constprop.0+0x107> | |
if (op != NULL) { | |
bfa: 4d 85 db test %r11,%r11 | |
bfd: 74 11 je c10 <ZSTD_decompressSequencesLong_default.constprop.0+0x150> | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
bff: 4c 89 df mov %r11,%rdi | |
c02: 48 89 da mov %rbx,%rdx | |
c05: e8 00 00 00 00 callq c0a <ZSTD_decompressSequencesLong_default.constprop.0+0x14a> | |
c0a: 49 89 c3 mov %rax,%r11 | |
op += lastLLSize; | |
c0d: 49 01 db add %rbx,%r11 | |
return op-ostart; | |
c10: 4c 2b 5c 24 58 sub 0x58(%rsp),%r11 | |
c15: 4d 89 dc mov %r11,%r12 | |
c18: eb ad jmp bc7 <ZSTD_decompressSequencesLong_default.constprop.0+0x107> | |
c1a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
bitD->ptr = bitD->start; | |
c20: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # c27 <ZSTD_decompressSequencesLong_default.constprop.0+0x167> | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
c27: 0f b6 11 movzbl (%rcx),%edx | |
bitD->ptr = bitD->start; | |
c2a: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp) | |
c31: 00 | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
c32: 4a 63 34 87 movslq (%rdi,%r8,4),%rsi | |
c36: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
c3d: 00 | |
switch(srcSize) | |
c3e: 48 01 fe add %rdi,%rsi | |
c41: ff e6 jmpq *%rsi | |
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); | |
c43: 0f b6 71 06 movzbl 0x6(%rcx),%esi | |
c47: 48 c1 e6 30 shl $0x30,%rsi | |
c4b: 48 01 f2 add %rsi,%rdx | |
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); | |
c4e: 0f b6 71 05 movzbl 0x5(%rcx),%esi | |
c52: 48 c1 e6 28 shl $0x28,%rsi | |
c56: 48 01 f2 add %rsi,%rdx | |
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); | |
c59: 0f b6 71 04 movzbl 0x4(%rcx),%esi | |
c5d: 48 c1 e6 20 shl $0x20,%rsi | |
c61: 48 01 f2 add %rsi,%rdx | |
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; | |
c64: 0f b6 71 03 movzbl 0x3(%rcx),%esi | |
c68: 48 c1 e6 18 shl $0x18,%rsi | |
c6c: 48 01 f2 add %rsi,%rdx | |
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; | |
c6f: 0f b6 71 02 movzbl 0x2(%rcx),%esi | |
c73: 48 c1 e6 10 shl $0x10,%rsi | |
c77: 48 01 f2 add %rsi,%rdx | |
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; | |
c7a: 0f b6 49 01 movzbl 0x1(%rcx),%ecx | |
c7e: 48 c1 e1 08 shl $0x8,%rcx | |
c82: 48 01 ca add %rcx,%rdx | |
c85: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
c8c: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; | |
c8d: 84 c0 test %al,%al | |
c8f: 0f 84 2b ff ff ff je bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
c95: ba 09 00 00 00 mov $0x9,%edx | |
return __builtin_clz (val) ^ 31; | |
c9a: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
c9d: 44 29 c2 sub %r8d,%edx | |
ca0: c1 e2 03 shl $0x3,%edx | |
ca3: 29 c2 sub %eax,%edx | |
ca5: 89 94 24 08 01 00 00 mov %edx,0x108(%rsp) | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
cac: 8b 9c 24 a0 00 00 00 mov 0xa0(%rsp),%ebx | |
cb3: b8 08 00 00 00 mov $0x8,%eax | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
cb8: 48 8d b4 24 00 01 00 lea 0x100(%rsp),%rsi | |
cbf: 00 | |
cc0: 48 8d bc 24 28 01 00 lea 0x128(%rsp),%rdi | |
cc7: 00 | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
cc8: 83 fb 08 cmp $0x8,%ebx | |
ccb: 0f 4e c3 cmovle %ebx,%eax | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
cce: 48 8b 9c 24 88 00 00 mov 0x88(%rsp),%rbx | |
cd5: 00 | |
cd6: 48 8b 13 mov (%rbx),%rdx | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
cd9: 89 44 24 44 mov %eax,0x44(%rsp) | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
cdd: e8 1e fd ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); | |
ce2: 48 8b 53 10 mov 0x10(%rbx),%rdx | |
ce6: 48 8d bc 24 38 01 00 lea 0x138(%rsp),%rdi | |
ced: 00 | |
cee: e8 0d fd ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); | |
cf3: 48 8b 53 08 mov 0x8(%rbx),%rdx | |
cf7: 48 8d bc 24 48 01 00 lea 0x148(%rsp),%rdi | |
cfe: 00 | |
cff: e8 fc fc ff ff callq a00 <ZSTD_initFseState> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
d04: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
d0b: 89 84 24 a4 00 00 00 mov %eax,0xa4(%rsp) | |
d12: 83 f8 40 cmp $0x40,%eax | |
d15: 0f 87 b5 0d 00 00 ja 1ad0 <ZSTD_decompressSequencesLong_default.constprop.0+0x1010> | |
size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */ | |
d1b: 48 8b 44 24 58 mov 0x58(%rsp),%rax | |
d20: 48 2b 44 24 20 sub 0x20(%rsp),%rax | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
d25: c6 44 24 50 00 movb $0x0,0x50(%rsp) | |
d2a: 31 d2 xor %edx,%edx | |
size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */ | |
d2c: 48 89 44 24 18 mov %rax,0x18(%rsp) | |
if (bitD->ptr >= bitD->limitPtr) { | |
d31: 48 8b 84 24 20 01 00 mov 0x120(%rsp),%rax | |
d38: 00 | |
d39: 4c 8b b4 24 10 01 00 mov 0x110(%rsp),%r14 | |
d40: 00 | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
d41: c7 44 24 08 00 00 00 movl $0x0,0x8(%rsp) | |
d48: 00 | |
d49: 48 89 44 24 38 mov %rax,0x38(%rsp) | |
if (bitD->ptr == bitD->start) { | |
d4e: 48 8b 84 24 18 01 00 mov 0x118(%rsp),%rax | |
d55: 00 | |
d56: 4c 89 b4 24 a8 00 00 mov %r14,0xa8(%rsp) | |
d5d: 00 | |
d5e: 4c 8b 8c 24 00 01 00 mov 0x100(%rsp),%r9 | |
d65: 00 | |
d66: 48 89 84 24 80 00 00 mov %rax,0x80(%rsp) | |
d6d: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
d6e: 48 8b 84 24 30 01 00 mov 0x130(%rsp),%rax | |
d75: 00 | |
d76: 48 89 44 24 60 mov %rax,0x60(%rsp) | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
d7b: 48 8b 84 24 50 01 00 mov 0x150(%rsp),%rax | |
d82: 00 | |
d83: 48 89 44 24 68 mov %rax,0x68(%rsp) | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
d88: 48 8b 84 24 40 01 00 mov 0x140(%rsp),%rax | |
d8f: 00 | |
d90: 48 89 44 24 70 mov %rax,0x70(%rsp) | |
d95: 48 8d 84 24 70 01 00 lea 0x170(%rsp),%rax | |
d9c: 00 | |
d9d: 48 89 c5 mov %rax,%rbp | |
da0: 48 89 84 24 98 00 00 mov %rax,0x98(%rsp) | |
da7: 00 | |
da8: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
daf: 48 89 eb mov %rbp,%rbx | |
db2: 4c 89 f5 mov %r14,%rbp | |
db5: 49 89 de mov %rbx,%r14 | |
db8: e9 36 01 00 00 jmpq ef3 <ZSTD_decompressSequencesLong_default.constprop.0+0x433> | |
dbd: 0f 1f 00 nopl (%rax) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
dc0: 89 c1 mov %eax,%ecx | |
dc2: 4d 89 cf mov %r9,%r15 | |
bitD->bitsConsumed += nbBits; | |
dc5: 44 01 c0 add %r8d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
dc8: 49 d3 e7 shl %cl,%r15 | |
dcb: 44 89 c1 mov %r8d,%ecx | |
dce: f7 d9 neg %ecx | |
dd0: 49 d3 ef shr %cl,%r15 | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
dd3: 8b 4c 24 10 mov 0x10(%rsp),%ecx | |
dd7: 49 01 cf add %rcx,%r15 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
dda: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
de1: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
de2: 48 89 bc 24 60 01 00 mov %rdi,0x160(%rsp) | |
de9: 00 | |
seqState->prevOffset[0] = offset; | |
dea: 4c 89 bc 24 58 01 00 mov %r15,0x158(%rsp) | |
df1: 00 | |
df2: 4c 89 ff mov %r15,%rdi | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
df5: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp) | |
dfc: 00 | |
seq.matchLength = mlBase; | |
dfd: 48 89 74 24 10 mov %rsi,0x10(%rsp) | |
if (mlBits > 0) | |
e02: 45 84 ed test %r13b,%r13b | |
e05: 0f 85 25 02 00 00 jne 1030 <ZSTD_decompressSequencesLong_default.constprop.0+0x570> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
e0b: 80 7c 24 30 1e cmpb $0x1e,0x30(%rsp) | |
e10: 0f 87 3d 02 00 00 ja 1053 <ZSTD_decompressSequencesLong_default.constprop.0+0x593> | |
if (llBits > 0) | |
e16: 45 84 e4 test %r12b,%r12b | |
e19: 0f 85 f1 01 00 00 jne 1010 <ZSTD_decompressSequencesLong_default.constprop.0+0x550> | |
U32 const nbBits = DInfo.nbBits; | |
e1f: 0f b6 73 03 movzbl 0x3(%rbx),%esi | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
e23: 4d 89 cf mov %r9,%r15 | |
sequences[seqNb] = sequence; | |
e26: 66 48 0f 6e c2 movq %rdx,%xmm0 | |
e2b: 0f 16 44 24 10 movhps 0x10(%rsp),%xmm0 | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
e30: 01 f0 add %esi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
e32: 89 c1 mov %eax,%ecx | |
e34: f7 d9 neg %ecx | |
e36: 49 d3 ef shr %cl,%r15 | |
e39: 4c 89 f9 mov %r15,%rcx | |
e3c: 4c 8d 3d 00 00 00 00 lea 0x0(%rip),%r15 # e43 <ZSTD_decompressSequencesLong_default.constprop.0+0x383> | |
e43: 41 23 0c b7 and (%r15,%rsi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
e47: 0f b7 33 movzwl (%rbx),%esi | |
e4a: 4c 89 cb mov %r9,%rbx | |
e4d: 48 01 f1 add %rsi,%rcx | |
e50: 48 89 8c 24 28 01 00 mov %rcx,0x128(%rsp) | |
e57: 00 | |
U32 const nbBits = DInfo.nbBits; | |
e58: 41 0f b6 73 03 movzbl 0x3(%r11),%esi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
e5d: 01 f0 add %esi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
e5f: 89 c1 mov %eax,%ecx | |
e61: f7 d9 neg %ecx | |
e63: 48 d3 eb shr %cl,%rbx | |
e66: 48 89 d9 mov %rbx,%rcx | |
e69: 41 23 0c b7 and (%r15,%rsi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
e6d: 41 0f b7 33 movzwl (%r11),%esi | |
e71: 4d 89 cb mov %r9,%r11 | |
e74: 48 01 f1 add %rsi,%rcx | |
e77: 48 89 8c 24 48 01 00 mov %rcx,0x148(%rsp) | |
e7e: 00 | |
U32 const nbBits = DInfo.nbBits; | |
e7f: 41 0f b6 72 03 movzbl 0x3(%r10),%esi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
e84: 01 f0 add %esi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
e86: 89 c1 mov %eax,%ecx | |
e88: f7 d9 neg %ecx | |
e8a: 49 d3 eb shr %cl,%r11 | |
e8d: 4c 89 d9 mov %r11,%rcx | |
e90: 41 23 0c b7 and (%r15,%rsi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
e94: 41 0f b7 32 movzwl (%r10),%esi | |
e98: 48 01 f1 add %rsi,%rcx | |
prefetchPos += sequence.litLength; | |
e9b: 48 8b 74 24 18 mov 0x18(%rsp),%rsi | |
DStatePtr->state = DInfo.nextState + lowBits; | |
ea0: 48 89 8c 24 38 01 00 mov %rcx,0x138(%rsp) | |
ea7: 00 | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
ea8: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx | |
prefetchPos += sequence.litLength; | |
ead: 48 01 d6 add %rdx,%rsi | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
eb0: ba 01 00 00 00 mov $0x1,%edx | |
eb5: 48 39 fe cmp %rdi,%rsi | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
eb8: 49 89 f0 mov %rsi,%r8 | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
ebb: 48 0f 42 4c 24 28 cmovb 0x28(%rsp),%rcx | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
ec1: 49 83 c6 18 add $0x18,%r14 | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
ec5: 49 29 f8 sub %rdi,%r8 | |
return prefetchPos + sequence.matchLength; | |
ec8: 48 03 74 24 10 add 0x10(%rsp),%rsi | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
ecd: 4c 01 c1 add %r8,%rcx | |
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */ | |
ed0: 0f 18 09 prefetcht0 (%rcx) | |
ed3: 0f 18 49 40 prefetcht0 0x40(%rcx) | |
sequences[seqNb] = sequence; | |
ed7: 41 0f 11 46 e8 movups %xmm0,-0x18(%r14) | |
edc: 49 89 7e f8 mov %rdi,-0x8(%r14) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
ee0: 83 44 24 08 01 addl $0x1,0x8(%rsp) | |
return prefetchPos + sequence.matchLength; | |
ee5: 48 89 74 24 18 mov %rsi,0x18(%rsp) | |
eea: 83 f8 40 cmp $0x40,%eax | |
eed: 0f 87 0d 06 00 00 ja 1500 <ZSTD_decompressSequencesLong_default.constprop.0+0xa40> | |
if (bitD->ptr >= bitD->limitPtr) { | |
ef3: 48 3b 6c 24 38 cmp 0x38(%rsp),%rbp | |
ef8: 0f 83 aa 01 00 00 jae 10a8 <ZSTD_decompressSequencesLong_default.constprop.0+0x5e8> | |
if (bitD->ptr == bitD->start) { | |
efe: 48 8b 9c 24 80 00 00 mov 0x80(%rsp),%rbx | |
f05: 00 | |
f06: 48 39 dd cmp %rbx,%rbp | |
f09: 74 37 je f42 <ZSTD_decompressSequencesLong_default.constprop.0+0x482> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
f0b: 89 c2 mov %eax,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
f0d: 48 89 e9 mov %rbp,%rcx | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
f10: c1 ea 03 shr $0x3,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
f13: 89 d6 mov %edx,%esi | |
f15: 48 29 f1 sub %rsi,%rcx | |
f18: 48 39 cb cmp %rcx,%rbx | |
f1b: 76 10 jbe f2d <ZSTD_decompressSequencesLong_default.constprop.0+0x46d> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
f1d: 48 89 ee mov %rbp,%rsi | |
bitD->ptr -= nbBytes; | |
f20: 48 89 e9 mov %rbp,%rcx | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
f23: 48 29 de sub %rbx,%rsi | |
f26: 89 f2 mov %esi,%edx | |
bitD->ptr -= nbBytes; | |
f28: 89 f6 mov %esi,%esi | |
f2a: 48 29 f1 sub %rsi,%rcx | |
MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; } | |
f2d: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
bitD->bitsConsumed -= nbBytes*8; | |
f32: c1 e2 03 shl $0x3,%edx | |
f35: 4c 8b 09 mov (%rcx),%r9 | |
f38: 48 89 cd mov %rcx,%rbp | |
f3b: 29 d0 sub %edx,%eax | |
f3d: ba 01 00 00 00 mov $0x1,%edx | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
f42: 8b 7c 24 08 mov 0x8(%rsp),%edi | |
f46: 39 7c 24 44 cmp %edi,0x44(%rsp) | |
f4a: 0f 8e 7f 01 00 00 jle 10cf <ZSTD_decompressSequencesLong_default.constprop.0+0x60f> | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
f50: 48 8b 8c 24 48 01 00 mov 0x148(%rsp),%rcx | |
f57: 00 | |
f58: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
f5d: 48 8b 94 24 28 01 00 mov 0x128(%rsp),%rdx | |
f64: 00 | |
f65: 48 8b 5c 24 60 mov 0x60(%rsp),%rbx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
f6a: 4c 8d 1c cf lea (%rdi,%rcx,8),%r11 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
f6e: 48 8b 8c 24 38 01 00 mov 0x138(%rsp),%rcx | |
f75: 00 | |
f76: 48 8b 7c 24 70 mov 0x70(%rsp),%rdi | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
f7b: 48 8d 1c d3 lea (%rbx,%rdx,8),%rbx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
f7f: 45 0f b6 6b 02 movzbl 0x2(%r11),%r13d | |
f84: 41 8b 73 04 mov 0x4(%r11),%esi | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
f88: 4c 8d 14 cf lea (%rdi,%rcx,8),%r10 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
f8c: 44 0f b6 63 02 movzbl 0x2(%rbx),%r12d | |
f91: 8b 53 04 mov 0x4(%rbx),%edx | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
f94: 45 0f b6 42 02 movzbl 0x2(%r10),%r8d | |
f99: 41 8b 7a 04 mov 0x4(%r10),%edi | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
f9d: 43 8d 0c 2c lea (%r12,%r13,1),%ecx | |
fa1: 46 8d 3c 01 lea (%rcx,%r8,1),%r15d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
fa5: 89 7c 24 10 mov %edi,0x10(%rsp) | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
fa9: 48 8b bc 24 58 01 00 mov 0x158(%rsp),%rdi | |
fb0: 00 | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
fb1: 44 88 7c 24 30 mov %r15b,0x30(%rsp) | |
if (ofBits > 1) { | |
fb6: 41 80 f8 01 cmp $0x1,%r8b | |
fba: 0f 87 00 fe ff ff ja dc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x300> | |
if (LIKELY((ofBits == 0))) { | |
fc0: 0f 84 42 09 00 00 je 1908 <ZSTD_decompressSequencesLong_default.constprop.0+0xe48> | |
if (LIKELY(!ll0)) | |
fc6: 85 d2 test %edx,%edx | |
fc8: 0f 85 2f fe ff ff jne dfd <ZSTD_decompressSequencesLong_default.constprop.0+0x33d> | |
offset = seqState->prevOffset[1]; | |
fce: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
fd5: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
fd6: 48 89 bc 24 60 01 00 mov %rdi,0x160(%rsp) | |
fdd: 00 | |
seqState->prevOffset[0] = offset; | |
fde: 48 89 8c 24 58 01 00 mov %rcx,0x158(%rsp) | |
fe5: 00 | |
offset = seqState->prevOffset[1]; | |
fe6: 48 89 cf mov %rcx,%rdi | |
fe9: e9 0f fe ff ff jmpq dfd <ZSTD_decompressSequencesLong_default.constprop.0+0x33d> | |
fee: 66 90 xchg %ax,%ax | |
return __builtin_clz (val) ^ 31; | |
ff0: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
ff3: ba 08 00 00 00 mov $0x8,%edx | |
ff8: 29 c2 sub %eax,%edx | |
ffa: 89 94 24 08 01 00 00 mov %edx,0x108(%rsp) | |
RETURN_ERROR_IF( | |
1001: 49 83 f8 88 cmp $0xffffffffffffff88,%r8 | |
1005: 0f 87 b5 fb ff ff ja bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
100b: e9 9c fc ff ff jmpq cac <ZSTD_decompressSequencesLong_default.constprop.0+0x1ec> | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1010: 89 c1 mov %eax,%ecx | |
1012: 4c 89 ce mov %r9,%rsi | |
bitD->bitsConsumed += nbBits; | |
1015: 44 01 e0 add %r12d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1018: 48 d3 e6 shl %cl,%rsi | |
101b: 44 89 e1 mov %r12d,%ecx | |
101e: f7 d9 neg %ecx | |
1020: 48 d3 ee shr %cl,%rsi | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
1023: 48 01 f2 add %rsi,%rdx | |
1026: e9 f4 fd ff ff jmpq e1f <ZSTD_decompressSequencesLong_default.constprop.0+0x35f> | |
102b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
1030: 89 c1 mov %eax,%ecx | |
1032: 4c 89 ce mov %r9,%rsi | |
bitD->bitsConsumed += nbBits; | |
1035: 44 01 e8 add %r13d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1038: 48 d3 e6 shl %cl,%rsi | |
103b: 44 89 e9 mov %r13d,%ecx | |
103e: f7 d9 neg %ecx | |
1040: 48 d3 ee shr %cl,%rsi | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
1043: 48 01 74 24 10 add %rsi,0x10(%rsp) | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
1048: 80 7c 24 30 1e cmpb $0x1e,0x30(%rsp) | |
104d: 0f 86 c3 fd ff ff jbe e16 <ZSTD_decompressSequencesLong_default.constprop.0+0x356> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
1053: 83 f8 40 cmp $0x40,%eax | |
1056: 0f 87 ba fd ff ff ja e16 <ZSTD_decompressSequencesLong_default.constprop.0+0x356> | |
if (bitD->ptr >= bitD->limitPtr) { | |
105c: 48 3b 6c 24 38 cmp 0x38(%rsp),%rbp | |
1061: 0f 83 49 0a 00 00 jae 1ab0 <ZSTD_decompressSequencesLong_default.constprop.0+0xff0> | |
if (bitD->ptr == bitD->start) { | |
1067: 4c 8b bc 24 80 00 00 mov 0x80(%rsp),%r15 | |
106e: 00 | |
106f: 4c 39 fd cmp %r15,%rbp | |
1072: 0f 84 9e fd ff ff je e16 <ZSTD_decompressSequencesLong_default.constprop.0+0x356> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
1078: 89 c1 mov %eax,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
107a: 48 89 ee mov %rbp,%rsi | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
107d: c1 e9 03 shr $0x3,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
1080: 41 89 c8 mov %ecx,%r8d | |
1083: 4c 29 c6 sub %r8,%rsi | |
1086: 4c 39 fe cmp %r15,%rsi | |
1089: 0f 82 4e 0a 00 00 jb 1add <ZSTD_decompressSequencesLong_default.constprop.0+0x101d> | |
108f: 48 89 f5 mov %rsi,%rbp | |
bitD->bitsConsumed -= nbBytes*8; | |
1092: c1 e1 03 shl $0x3,%ecx | |
1095: 4c 8b 4d 00 mov 0x0(%rbp),%r9 | |
return result; | |
1099: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
bitD->bitsConsumed -= nbBytes*8; | |
109e: 29 c8 sub %ecx,%eax | |
return result; | |
10a0: e9 71 fd ff ff jmpq e16 <ZSTD_decompressSequencesLong_default.constprop.0+0x356> | |
10a5: 0f 1f 00 nopl (%rax) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
10a8: 89 c2 mov %eax,%edx | |
10aa: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
10af: 8b 7c 24 08 mov 0x8(%rsp),%edi | |
bitD->bitsConsumed &= 7; | |
10b3: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
10b6: c1 ea 03 shr $0x3,%edx | |
10b9: 48 29 d5 sub %rdx,%rbp | |
10bc: ba 01 00 00 00 mov $0x1,%edx | |
10c1: 4c 8b 4d 00 mov 0x0(%rbp),%r9 | |
10c5: 39 7c 24 44 cmp %edi,0x44(%rsp) | |
10c9: 0f 8f 81 fe ff ff jg f50 <ZSTD_decompressSequencesLong_default.constprop.0+0x490> | |
10cf: 80 7c 24 50 00 cmpb $0x0,0x50(%rsp) | |
10d4: 49 89 ee mov %rbp,%r14 | |
10d7: 0f 84 a7 08 00 00 je 1984 <ZSTD_decompressSequencesLong_default.constprop.0+0xec4> | |
10dd: 4c 89 8c 24 00 01 00 mov %r9,0x100(%rsp) | |
10e4: 00 | |
10e5: 84 d2 test %dl,%dl | |
10e7: 0f 84 cb 0c 00 00 je 1db8 <ZSTD_decompressSequencesLong_default.constprop.0+0x12f8> | |
10ed: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
10f4: 4c 89 b4 24 10 01 00 mov %r14,0x110(%rsp) | |
10fb: 00 | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
10fc: 83 f8 40 cmp $0x40,%eax | |
10ff: 0f 87 2b 04 00 00 ja 1530 <ZSTD_decompressSequencesLong_default.constprop.0+0xa70> | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
1105: 48 8b 5c 24 78 mov 0x78(%rsp),%rbx | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
110a: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11 | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
110f: 48 83 eb 20 sub $0x20,%rbx | |
1113: 48 89 5c 24 30 mov %rbx,0x30(%rsp) | |
if (bitD->ptr >= bitD->limitPtr) { | |
1118: 4c 3b 74 24 38 cmp 0x38(%rsp),%r14 | |
111d: 0f 83 af 03 00 00 jae 14d2 <ZSTD_decompressSequencesLong_default.constprop.0+0xa12> | |
if (bitD->ptr == bitD->start) { | |
1123: 48 8b 8c 24 18 01 00 mov 0x118(%rsp),%rcx | |
112a: 00 | |
112b: 4c 89 f5 mov %r14,%rbp | |
112e: 4c 39 f1 cmp %r14,%rcx | |
1131: 74 3f je 1172 <ZSTD_decompressSequencesLong_default.constprop.0+0x6b2> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
1133: 89 c2 mov %eax,%edx | |
1135: c1 ea 03 shr $0x3,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
1138: 89 d6 mov %edx,%esi | |
113a: 48 29 f5 sub %rsi,%rbp | |
113d: 48 39 e9 cmp %rbp,%rcx | |
1140: 76 10 jbe 1152 <ZSTD_decompressSequencesLong_default.constprop.0+0x692> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
1142: 4c 89 f6 mov %r14,%rsi | |
1145: 48 29 ce sub %rcx,%rsi | |
1148: 89 f2 mov %esi,%edx | |
bitD->ptr -= nbBytes; | |
114a: 89 f6 mov %esi,%esi | |
114c: 49 29 f6 sub %rsi,%r14 | |
114f: 4c 89 f5 mov %r14,%rbp | |
bitD->bitsConsumed -= nbBytes*8; | |
1152: c1 e2 03 shl $0x3,%edx | |
bitD->ptr -= nbBytes; | |
1155: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp) | |
115c: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
115d: 29 d0 sub %edx,%eax | |
115f: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
1166: 48 8b 45 00 mov 0x0(%rbp),%rax | |
116a: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp) | |
1171: 00 | |
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) { | |
1172: 8b 5c 24 08 mov 0x8(%rsp),%ebx | |
1176: 39 9c 24 a0 00 00 00 cmp %ebx,0xa0(%rsp) | |
117d: 0f 8e c3 03 00 00 jle 1546 <ZSTD_decompressSequencesLong_default.constprop.0+0xa86> | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
1183: 48 8b 94 24 28 01 00 mov 0x128(%rsp),%rdx | |
118a: 00 | |
118b: 48 8b 84 24 30 01 00 mov 0x130(%rsp),%rax | |
1192: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
1193: 48 8b 8c 24 48 01 00 mov 0x148(%rsp),%rcx | |
119a: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
119b: 48 8b 9c 24 58 01 00 mov 0x158(%rsp),%rbx | |
11a2: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
11a3: 4c 8d 14 d0 lea (%rax,%rdx,8),%r10 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
11a7: 48 8b 84 24 50 01 00 mov 0x150(%rsp),%rax | |
11ae: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
11af: 45 0f b6 62 02 movzbl 0x2(%r10),%r12d | |
11b4: 41 8b 52 04 mov 0x4(%r10),%edx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
11b8: 4c 8d 0c c8 lea (%rax,%rcx,8),%r9 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
11bc: 48 8b 84 24 40 01 00 mov 0x140(%rsp),%rax | |
11c3: 00 | |
11c4: 48 8b 8c 24 38 01 00 mov 0x138(%rsp),%rcx | |
11cb: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
11cc: 45 0f b6 69 02 movzbl 0x2(%r9),%r13d | |
11d1: 41 8b 71 04 mov 0x4(%r9),%esi | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
11d5: 4c 8d 04 c8 lea (%rax,%rcx,8),%r8 | |
11d9: 41 8b 40 04 mov 0x4(%r8),%eax | |
11dd: 41 0f b6 78 02 movzbl 0x2(%r8),%edi | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
11e2: 47 8d 34 2c lea (%r12,%r13,1),%r14d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
11e6: 89 44 24 10 mov %eax,0x10(%rsp) | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
11ea: 41 01 fe add %edi,%r14d | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
11ed: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
if (ofBits > 1) { | |
11f4: 40 80 ff 01 cmp $0x1,%dil | |
11f8: 0f 86 4a 05 00 00 jbe 1748 <ZSTD_decompressSequencesLong_default.constprop.0+0xc88> | |
11fe: 4c 8b bc 24 00 01 00 mov 0x100(%rsp),%r15 | |
1205: 00 | |
1206: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
1208: 01 f8 add %edi,%eax | |
120a: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1211: 49 d3 e7 shl %cl,%r15 | |
1214: 89 f9 mov %edi,%ecx | |
1216: f7 d9 neg %ecx | |
1218: 49 d3 ef shr %cl,%r15 | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
121b: 8b 4c 24 10 mov 0x10(%rsp),%ecx | |
121f: 49 01 cf add %rcx,%r15 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
1222: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
1229: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
122a: 48 89 9c 24 60 01 00 mov %rbx,0x160(%rsp) | |
1231: 00 | |
seqState->prevOffset[0] = offset; | |
1232: 4c 89 bc 24 58 01 00 mov %r15,0x158(%rsp) | |
1239: 00 | |
123a: 4c 89 fb mov %r15,%rbx | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
123d: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp) | |
1244: 00 | |
seq.matchLength = mlBase; | |
1245: 89 f7 mov %esi,%edi | |
1247: 48 89 7c 24 10 mov %rdi,0x10(%rsp) | |
if (mlBits > 0) | |
124c: 45 84 ed test %r13b,%r13b | |
124f: 0f 85 4b 05 00 00 jne 17a0 <ZSTD_decompressSequencesLong_default.constprop.0+0xce0> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
1255: 41 80 fe 1e cmp $0x1e,%r14b | |
1259: 0f 87 6f 05 00 00 ja 17ce <ZSTD_decompressSequencesLong_default.constprop.0+0xd0e> | |
125f: 48 8b b4 24 00 01 00 mov 0x100(%rsp),%rsi | |
1266: 00 | |
seq.litLength = llBase; | |
1267: 89 d5 mov %edx,%ebp | |
if (llBits > 0) | |
1269: 45 84 e4 test %r12b,%r12b | |
126c: 0f 85 0e 05 00 00 jne 1780 <ZSTD_decompressSequencesLong_default.constprop.0+0xcc0> | |
U32 const nbBits = DInfo.nbBits; | |
1272: 41 0f b6 52 03 movzbl 0x3(%r10),%edx | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
1277: 48 89 f7 mov %rsi,%rdi | |
127a: 44 8b 74 24 08 mov 0x8(%rsp),%r14d | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
127f: 01 d0 add %edx,%eax | |
DStatePtr->state = DInfo.nextState + lowBits; | |
1281: 41 83 e6 07 and $0x7,%r14d | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
1285: 89 c1 mov %eax,%ecx | |
1287: f7 d9 neg %ecx | |
1289: 48 d3 ef shr %cl,%rdi | |
128c: 48 89 f9 mov %rdi,%rcx | |
128f: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1296 <ZSTD_decompressSequencesLong_default.constprop.0+0x7d6> | |
1296: 23 0c 97 and (%rdi,%rdx,4),%ecx | |
1299: 41 0f b7 12 movzwl (%r10),%edx | |
129d: 49 89 f2 mov %rsi,%r10 | |
12a0: 48 01 d1 add %rdx,%rcx | |
12a3: 48 89 8c 24 28 01 00 mov %rcx,0x128(%rsp) | |
12aa: 00 | |
U32 const nbBits = DInfo.nbBits; | |
12ab: 41 0f b6 51 03 movzbl 0x3(%r9),%edx | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
12b0: 01 d0 add %edx,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
12b2: 89 c1 mov %eax,%ecx | |
12b4: f7 d9 neg %ecx | |
12b6: 49 d3 ea shr %cl,%r10 | |
12b9: 4c 89 d1 mov %r10,%rcx | |
12bc: 23 0c 97 and (%rdi,%rdx,4),%ecx | |
12bf: 49 89 fa mov %rdi,%r10 | |
12c2: 48 89 ca mov %rcx,%rdx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
12c5: 41 0f b7 09 movzwl (%r9),%ecx | |
12c9: 48 01 ca add %rcx,%rdx | |
12cc: 48 89 94 24 48 01 00 mov %rdx,0x148(%rsp) | |
12d3: 00 | |
U32 const nbBits = DInfo.nbBits; | |
12d4: 41 0f b6 78 03 movzbl 0x3(%r8),%edi | |
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state]; | |
12d9: 41 0f b7 10 movzwl (%r8),%edx | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
12dd: 01 f8 add %edi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
12df: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
12e1: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
12e8: 4b 8d 04 76 lea (%r14,%r14,2),%rax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
12ec: f7 d9 neg %ecx | |
12ee: 48 c1 e0 03 shl $0x3,%rax | |
12f2: 48 d3 ee shr %cl,%rsi | |
12f5: 41 23 34 ba and (%r10,%rdi,4),%esi | |
DStatePtr->state = DInfo.nextState + lowBits; | |
12f9: 4c 8b 84 04 78 01 00 mov 0x178(%rsp,%rax,1),%r8 | |
1300: 00 | |
1301: f3 0f 6f ac 04 70 01 movdqu 0x170(%rsp,%rax,1),%xmm5 | |
1308: 00 00 | |
130a: 48 01 d6 add %rdx,%rsi | |
130d: 48 8b 94 04 80 01 00 mov 0x180(%rsp,%rax,1),%rdx | |
1314: 00 | |
1315: 48 89 b4 24 38 01 00 mov %rsi,0x138(%rsp) | |
131c: 00 | |
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd); | |
131d: 48 8b b4 04 70 01 00 mov 0x170(%rsp,%rax,1),%rsi | |
1324: 00 | |
1325: 49 89 d7 mov %rdx,%r15 | |
BYTE* const oLitEnd = op + sequence.litLength; | |
1328: 48 89 94 24 d0 00 00 mov %rdx,0xd0(%rsp) | |
132f: 00 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
1330: 48 8b 94 24 b8 00 00 mov 0xb8(%rsp),%rdx | |
1337: 00 | |
BYTE* const oLitEnd = op + sequence.litLength; | |
1338: 49 8d 3c 33 lea (%r11,%rsi,1),%rdi | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
133c: 4e 8d 24 06 lea (%rsi,%r8,1),%r12 | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
1340: 0f 29 ac 24 c0 00 00 movaps %xmm5,0xc0(%rsp) | |
1347: 00 | |
const BYTE* match = oLitEnd - sequence.offset; | |
1348: 48 89 f8 mov %rdi,%rax | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
134b: 4f 8d 2c 23 lea (%r11,%r12,1),%r13 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
134f: 48 8d 0c 32 lea (%rdx,%rsi,1),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
1353: 4c 29 f8 sub %r15,%rax | |
if (UNLIKELY( | |
1356: 4c 3b 6c 24 30 cmp 0x30(%rsp),%r13 | |
135b: 0f 87 ef 04 00 00 ja 1850 <ZSTD_decompressSequencesLong_default.constprop.0+0xd90> | |
1361: 48 39 4c 24 48 cmp %rcx,0x48(%rsp) | |
1366: 0f 82 e4 04 00 00 jb 1850 <ZSTD_decompressSequencesLong_default.constprop.0+0xd90> | |
ZSTD_memcpy(dst, src, 16); | |
136c: f3 0f 6f 32 movdqu (%rdx),%xmm6 | |
1370: 41 0f 11 33 movups %xmm6,(%r11) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
1374: 48 83 fe 10 cmp $0x10,%rsi | |
1378: 0f 87 42 05 00 00 ja 18c0 <ZSTD_decompressSequencesLong_default.constprop.0+0xe00> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
137e: 48 89 fa mov %rdi,%rdx | |
1381: 48 2b 54 24 20 sub 0x20(%rsp),%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
1386: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp) | |
138d: 00 | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
138e: 49 39 d7 cmp %rdx,%r15 | |
1391: 76 6a jbe 13fd <ZSTD_decompressSequencesLong_default.constprop.0+0x93d> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
1393: 48 89 fa mov %rdi,%rdx | |
1396: 48 2b 94 24 90 00 00 sub 0x90(%rsp),%rdx | |
139d: 00 | |
139e: 49 39 d7 cmp %rdx,%r15 | |
13a1: 0f 87 19 f8 ff ff ja bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
match = dictEnd + (match - prefixStart); | |
13a7: 48 8b 4c 24 28 mov 0x28(%rsp),%rcx | |
13ac: 48 89 c6 mov %rax,%rsi | |
13af: 48 2b 74 24 20 sub 0x20(%rsp),%rsi | |
13b4: 48 01 ce add %rcx,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
13b7: 4a 8d 14 06 lea (%rsi,%r8,1),%rdx | |
13bb: 48 39 d1 cmp %rdx,%rcx | |
13be: 0f 83 74 04 00 00 jae 1838 <ZSTD_decompressSequencesLong_default.constprop.0+0xd78> | |
{ size_t const length1 = dictEnd - match; | |
13c4: 48 8b 54 24 20 mov 0x20(%rsp),%rdx | |
13c9: 4c 89 5c 24 60 mov %r11,0x60(%rsp) | |
13ce: 4c 89 44 24 50 mov %r8,0x50(%rsp) | |
13d3: 48 29 c2 sub %rax,%rdx | |
ZSTD_memmove(oLitEnd, match, length1); | |
13d6: 48 89 54 24 38 mov %rdx,0x38(%rsp) | |
13db: e8 00 00 00 00 callq 13e0 <ZSTD_decompressSequencesLong_default.constprop.0+0x920> | |
op = oLitEnd + length1; | |
13e0: 48 8b 54 24 38 mov 0x38(%rsp),%rdx | |
sequence.matchLength -= length1; | |
13e5: 4c 8b 44 24 50 mov 0x50(%rsp),%r8 | |
ZSTD_memmove(oLitEnd, match, length1); | |
13ea: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
13ed: 4c 8b 5c 24 60 mov 0x60(%rsp),%r11 | |
13f2: 48 8b 44 24 20 mov 0x20(%rsp),%rax | |
op = oLitEnd + length1; | |
13f7: 48 01 d7 add %rdx,%rdi | |
sequence.matchLength -= length1; | |
13fa: 49 29 d0 sub %rdx,%r8 | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
13fd: 49 83 ff 0f cmp $0xf,%r15 | |
1401: 0f 86 99 05 00 00 jbe 19a0 <ZSTD_decompressSequencesLong_default.constprop.0+0xee0> | |
1407: f3 0f 6f 38 movdqu (%rax),%xmm7 | |
140b: 0f 11 3f movups %xmm7,(%rdi) | |
if (16 >= length) return; | |
140e: 49 83 f8 10 cmp $0x10,%r8 | |
1412: 7e 2a jle 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
op += 16; | |
1414: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
1418: 48 83 c0 10 add $0x10,%rax | |
141c: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
1420: f3 0f 6f 08 movdqu (%rax),%xmm1 | |
1424: 48 83 c7 20 add $0x20,%rdi | |
1428: 48 83 c0 20 add $0x20,%rax | |
142c: 0f 11 4f e0 movups %xmm1,-0x20(%rdi) | |
1430: f3 0f 6f 50 f0 movdqu -0x10(%rax),%xmm2 | |
1435: 0f 11 57 f0 movups %xmm2,-0x10(%rdi) | |
while (op < oend); | |
1439: 49 39 fd cmp %rdi,%r13 | |
143c: 77 e2 ja 1420 <ZSTD_decompressSequencesLong_default.constprop.0+0x960> | |
if (ZSTD_isError(oneSeqSize)) return oneSeqSize; | |
143e: 49 83 fc 88 cmp $0xffffffffffffff88,%r12 | |
1442: 0f 87 7f f7 ff ff ja bc7 <ZSTD_decompressSequencesLong_default.constprop.0+0x107> | |
prefetchPos += sequence.litLength; | |
1448: 48 8b 54 24 18 mov 0x18(%rsp),%rdx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
144d: 48 8b 44 24 20 mov 0x20(%rsp),%rax | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
1452: 66 48 0f 6e c5 movq %rbp,%xmm0 | |
1457: 0f 16 44 24 10 movhps 0x10(%rsp),%xmm0 | |
prefetchPos += sequence.litLength; | |
145c: 48 01 ea add %rbp,%rdx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
145f: 48 39 da cmp %rbx,%rdx | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
1462: 48 89 d1 mov %rdx,%rcx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
1465: 48 0f 42 44 24 28 cmovb 0x28(%rsp),%rax | |
op += oneSeqSize; | |
146b: 4d 01 e3 add %r12,%r11 | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
146e: 48 29 d9 sub %rbx,%rcx | |
return prefetchPos + sequence.matchLength; | |
1471: 48 03 54 24 10 add 0x10(%rsp),%rdx | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
1476: 48 01 c8 add %rcx,%rax | |
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */ | |
1479: 0f 18 08 prefetcht0 (%rax) | |
147c: 0f 18 48 40 prefetcht0 0x40(%rax) | |
return prefetchPos + sequence.matchLength; | |
1480: 48 89 54 24 18 mov %rdx,0x18(%rsp) | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
1485: 4b 8d 04 76 lea (%r14,%r14,2),%rax | |
1489: 48 8b 94 24 98 00 00 mov 0x98(%rsp),%rdx | |
1490: 00 | |
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) { | |
1491: 83 44 24 08 01 addl $0x1,0x8(%rsp) | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
1496: 0f 11 04 c2 movups %xmm0,(%rdx,%rax,8) | |
149a: 48 89 9c c4 80 01 00 mov %rbx,0x180(%rsp,%rax,8) | |
14a1: 00 | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
14a2: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
14a9: 83 f8 40 cmp $0x40,%eax | |
14ac: 0f 87 83 00 00 00 ja 1535 <ZSTD_decompressSequencesLong_default.constprop.0+0xa75> | |
if (bitD->ptr >= bitD->limitPtr) { | |
14b2: 48 8b 9c 24 20 01 00 mov 0x120(%rsp),%rbx | |
14b9: 00 | |
14ba: 4c 8b b4 24 10 01 00 mov 0x110(%rsp),%r14 | |
14c1: 00 | |
14c2: 48 89 5c 24 38 mov %rbx,0x38(%rsp) | |
14c7: 4c 3b 74 24 38 cmp 0x38(%rsp),%r14 | |
14cc: 0f 82 51 fc ff ff jb 1123 <ZSTD_decompressSequencesLong_default.constprop.0+0x663> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
14d2: 89 c2 mov %eax,%edx | |
bitD->bitsConsumed &= 7; | |
14d4: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
14d7: c1 ea 03 shr $0x3,%edx | |
bitD->bitsConsumed &= 7; | |
14da: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
14e1: 49 29 d6 sub %rdx,%r14 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
14e4: 49 8b 06 mov (%r14),%rax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
14e7: 4c 89 b4 24 10 01 00 mov %r14,0x110(%rsp) | |
14ee: 00 | |
14ef: 4c 89 f5 mov %r14,%rbp | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
14f2: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp) | |
14f9: 00 | |
return BIT_DStream_unfinished; | |
14fa: e9 73 fc ff ff jmpq 1172 <ZSTD_decompressSequencesLong_default.constprop.0+0x6b2> | |
14ff: 90 nop | |
1500: 80 7c 24 50 00 cmpb $0x0,0x50(%rsp) | |
1505: 0f 84 a5 03 00 00 je 18b0 <ZSTD_decompressSequencesLong_default.constprop.0+0xdf0> | |
150b: 4c 89 8c 24 00 01 00 mov %r9,0x100(%rsp) | |
1512: 00 | |
1513: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
151a: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp) | |
1521: 00 | |
RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, ""); | |
1522: 8b 5c 24 08 mov 0x8(%rsp),%ebx | |
1526: 39 5c 24 44 cmp %ebx,0x44(%rsp) | |
152a: 0f 8f 90 f6 ff ff jg bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
1530: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11 | |
RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, ""); | |
1535: 8b 5c 24 08 mov 0x8(%rsp),%ebx | |
1539: 39 9c 24 a0 00 00 00 cmp %ebx,0xa0(%rsp) | |
1540: 0f 8f 7a f6 ff ff jg bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
seqNb -= seqAdvance; | |
1546: 8b 5c 24 08 mov 0x8(%rsp),%ebx | |
154a: 2b 5c 24 44 sub 0x44(%rsp),%ebx | |
for ( ; seqNb<nbSeq ; seqNb++) { | |
154e: 39 9c 24 a0 00 00 00 cmp %ebx,0xa0(%rsp) | |
1555: 0f 8e 9d 01 00 00 jle 16f8 <ZSTD_decompressSequencesLong_default.constprop.0+0xc38> | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
155b: 48 8b 44 24 78 mov 0x78(%rsp),%rax | |
*ip += dec32table[offset]; | |
1560: 4c 8b 74 24 48 mov 0x48(%rsp),%r14 | |
1565: 41 89 dc mov %ebx,%r12d | |
1568: 4d 89 dd mov %r11,%r13 | |
156b: 4c 8b 7c 24 20 mov 0x20(%rsp),%r15 | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
1570: 48 83 e8 20 sub $0x20,%rax | |
1574: 48 89 44 24 08 mov %rax,0x8(%rsp) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
1579: 48 8d 84 24 b8 00 00 lea 0xb8(%rsp),%rax | |
1580: 00 | |
1581: 48 89 44 24 30 mov %rax,0x30(%rsp) | |
1586: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
158d: 00 00 00 | |
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd); | |
1590: 44 89 e0 mov %r12d,%eax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
1593: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
159a: 00 | |
159b: 83 e0 07 and $0x7,%eax | |
159e: 48 8d 04 40 lea (%rax,%rax,2),%rax | |
15a2: 48 c1 e0 03 shl $0x3,%rax | |
15a6: 48 8b 94 04 80 01 00 mov 0x180(%rsp,%rax,1),%rdx | |
15ad: 00 | |
15ae: 4c 8b 8c 04 78 01 00 mov 0x178(%rsp,%rax,1),%r9 | |
15b5: 00 | |
15b6: f3 0f 6f ac 04 70 01 movdqu 0x170(%rsp,%rax,1),%xmm5 | |
15bd: 00 00 | |
15bf: 48 8b 9c 04 80 01 00 mov 0x180(%rsp,%rax,1),%rbx | |
15c6: 00 | |
15c7: 48 89 94 24 f0 00 00 mov %rdx,0xf0(%rsp) | |
15ce: 00 | |
15cf: 48 8b 94 04 70 01 00 mov 0x170(%rsp,%rax,1),%rdx | |
15d6: 00 | |
BYTE* const oLitEnd = op + sequence.litLength; | |
15d7: 0f 29 ac 24 e0 00 00 movaps %xmm5,0xe0(%rsp) | |
15de: 00 | |
15df: 49 8d 7c 15 00 lea 0x0(%r13,%rdx,1),%rdi | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
15e4: 4a 8d 0c 0a lea (%rdx,%r9,1),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
15e8: 48 89 f8 mov %rdi,%rax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
15eb: 4c 8d 1c 16 lea (%rsi,%rdx,1),%r11 | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
15ef: 49 8d 6c 0d 00 lea 0x0(%r13,%rcx,1),%rbp | |
const BYTE* match = oLitEnd - sequence.offset; | |
15f4: 48 29 d8 sub %rbx,%rax | |
if (UNLIKELY( | |
15f7: 4d 39 de cmp %r11,%r14 | |
15fa: 0f 82 c9 05 00 00 jb 1bc9 <ZSTD_decompressSequencesLong_default.constprop.0+0x1109> | |
1600: 48 3b 6c 24 08 cmp 0x8(%rsp),%rbp | |
1605: 0f 87 be 05 00 00 ja 1bc9 <ZSTD_decompressSequencesLong_default.constprop.0+0x1109> | |
ZSTD_memcpy(dst, src, 16); | |
160b: f3 0f 6f 3e movdqu (%rsi),%xmm7 | |
160f: 41 0f 11 7d 00 movups %xmm7,0x0(%r13) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
1614: 48 83 fa 10 cmp $0x10,%rdx | |
1618: 0f 87 09 06 00 00 ja 1c27 <ZSTD_decompressSequencesLong_default.constprop.0+0x1167> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
161e: 48 89 fa mov %rdi,%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
1621: 4c 89 9c 24 b8 00 00 mov %r11,0xb8(%rsp) | |
1628: 00 | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
1629: 4c 29 fa sub %r15,%rdx | |
162c: 48 39 d3 cmp %rdx,%rbx | |
162f: 76 64 jbe 1695 <ZSTD_decompressSequencesLong_default.constprop.0+0xbd5> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
1631: 48 89 fa mov %rdi,%rdx | |
1634: 48 2b 94 24 90 00 00 sub 0x90(%rsp),%rdx | |
163b: 00 | |
163c: 48 39 d3 cmp %rdx,%rbx | |
163f: 0f 87 7b f5 ff ff ja bc0 <ZSTD_decompressSequencesLong_default.constprop.0+0x100> | |
match = dictEnd + (match - prefixStart); | |
1645: 4c 8b 54 24 28 mov 0x28(%rsp),%r10 | |
164a: 48 89 c6 mov %rax,%rsi | |
164d: 4c 29 fe sub %r15,%rsi | |
1650: 4c 01 d6 add %r10,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
1653: 4a 8d 14 0e lea (%rsi,%r9,1),%rdx | |
1657: 49 39 d2 cmp %rdx,%r10 | |
165a: 0f 83 d0 04 00 00 jae 1b30 <ZSTD_decompressSequencesLong_default.constprop.0+0x1070> | |
{ size_t const length1 = dictEnd - match; | |
1660: 4c 89 fa mov %r15,%rdx | |
1663: 48 89 4c 24 20 mov %rcx,0x20(%rsp) | |
1668: 48 29 c2 sub %rax,%rdx | |
166b: 4c 89 4c 24 18 mov %r9,0x18(%rsp) | |
ZSTD_memmove(oLitEnd, match, length1); | |
1670: 48 89 54 24 10 mov %rdx,0x10(%rsp) | |
1675: e8 00 00 00 00 callq 167a <ZSTD_decompressSequencesLong_default.constprop.0+0xbba> | |
op = oLitEnd + length1; | |
167a: 48 8b 54 24 10 mov 0x10(%rsp),%rdx | |
sequence.matchLength -= length1; | |
167f: 4c 8b 4c 24 18 mov 0x18(%rsp),%r9 | |
ZSTD_memmove(oLitEnd, match, length1); | |
1684: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
1687: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx | |
168c: 4c 89 f8 mov %r15,%rax | |
op = oLitEnd + length1; | |
168f: 48 01 d7 add %rdx,%rdi | |
sequence.matchLength -= length1; | |
1692: 49 29 d1 sub %rdx,%r9 | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
1695: 48 83 fb 0f cmp $0xf,%rbx | |
1699: 0f 86 f8 05 00 00 jbe 1c97 <ZSTD_decompressSequencesLong_default.constprop.0+0x11d7> | |
169f: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
16a3: 0f 11 1f movups %xmm3,(%rdi) | |
if (16 >= length) return; | |
16a6: 49 83 f9 10 cmp $0x10,%r9 | |
16aa: 7e 2a jle 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
op += 16; | |
16ac: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
16b0: 48 83 c0 10 add $0x10,%rax | |
16b4: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
16b8: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
16bc: 48 83 c7 20 add $0x20,%rdi | |
16c0: 48 83 c0 20 add $0x20,%rax | |
16c4: 0f 11 5f e0 movups %xmm3,-0x20(%rdi) | |
16c8: f3 0f 6f 60 f0 movdqu -0x10(%rax),%xmm4 | |
16cd: 0f 11 67 f0 movups %xmm4,-0x10(%rdi) | |
while (op < oend); | |
16d1: 48 39 fd cmp %rdi,%rbp | |
16d4: 77 e2 ja 16b8 <ZSTD_decompressSequencesLong_default.constprop.0+0xbf8> | |
if (ZSTD_isError(oneSeqSize)) return oneSeqSize; | |
16d6: 48 83 f9 88 cmp $0xffffffffffffff88,%rcx | |
16da: 0f 87 d0 06 00 00 ja 1db0 <ZSTD_decompressSequencesLong_default.constprop.0+0x12f0> | |
op += oneSeqSize; | |
16e0: 49 01 cd add %rcx,%r13 | |
for ( ; seqNb<nbSeq ; seqNb++) { | |
16e3: 41 83 c4 01 add $0x1,%r12d | |
16e7: 44 39 a4 24 a0 00 00 cmp %r12d,0xa0(%rsp) | |
16ee: 00 | |
16ef: 0f 85 9b fe ff ff jne 1590 <ZSTD_decompressSequencesLong_default.constprop.0+0xad0> | |
16f5: 4d 89 eb mov %r13,%r11 | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
16f8: 48 8b 9c 24 88 00 00 mov 0x88(%rsp),%rbx | |
16ff: 00 | |
1700: 48 8b 84 24 58 01 00 mov 0x158(%rsp),%rax | |
1707: 00 | |
{ size_t const lastLLSize = litEnd - litPtr; | |
1708: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
170f: 00 | |
1710: 48 8b 54 24 78 mov 0x78(%rsp),%rdx | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
1715: 89 83 3c 68 00 00 mov %eax,0x683c(%rbx) | |
171b: 48 8b 84 24 60 01 00 mov 0x160(%rsp),%rax | |
1722: 00 | |
1723: 89 83 40 68 00 00 mov %eax,0x6840(%rbx) | |
1729: 48 8b 84 24 68 01 00 mov 0x168(%rsp),%rax | |
1730: 00 | |
1731: 89 83 44 68 00 00 mov %eax,0x6844(%rbx) | |
1737: 48 8b 5c 24 48 mov 0x48(%rsp),%rbx | |
173c: e9 a7 f4 ff ff jmpq be8 <ZSTD_decompressSequencesLong_default.constprop.0+0x128> | |
1741: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
if (LIKELY((ofBits == 0))) { | |
1748: 0f 84 02 04 00 00 je 1b50 <ZSTD_decompressSequencesLong_default.constprop.0+0x1090> | |
if (LIKELY(!ll0)) | |
174e: 85 d2 test %edx,%edx | |
1750: 0f 85 ef fa ff ff jne 1245 <ZSTD_decompressSequencesLong_default.constprop.0+0x785> | |
offset = seqState->prevOffset[1]; | |
1756: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
175d: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
175e: 48 89 9c 24 60 01 00 mov %rbx,0x160(%rsp) | |
1765: 00 | |
seqState->prevOffset[0] = offset; | |
1766: 48 89 8c 24 58 01 00 mov %rcx,0x158(%rsp) | |
176d: 00 | |
offset = seqState->prevOffset[1]; | |
176e: 48 89 cb mov %rcx,%rbx | |
1771: e9 cf fa ff ff jmpq 1245 <ZSTD_decompressSequencesLong_default.constprop.0+0x785> | |
1776: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
177d: 00 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1780: 89 c1 mov %eax,%ecx | |
1782: 48 89 f2 mov %rsi,%rdx | |
bitD->bitsConsumed += nbBits; | |
1785: 44 01 e0 add %r12d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1788: 48 d3 e2 shl %cl,%rdx | |
178b: 44 89 e1 mov %r12d,%ecx | |
178e: f7 d9 neg %ecx | |
1790: 48 d3 ea shr %cl,%rdx | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
1793: 48 01 d5 add %rdx,%rbp | |
1796: e9 d7 fa ff ff jmpq 1272 <ZSTD_decompressSequencesLong_default.constprop.0+0x7b2> | |
179b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
17a0: 48 8b b4 24 00 01 00 mov 0x100(%rsp),%rsi | |
17a7: 00 | |
17a8: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
17aa: 44 01 e8 add %r13d,%eax | |
17ad: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
17b4: 48 d3 e6 shl %cl,%rsi | |
17b7: 44 89 e9 mov %r13d,%ecx | |
17ba: f7 d9 neg %ecx | |
17bc: 48 d3 ee shr %cl,%rsi | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
17bf: 48 01 74 24 10 add %rsi,0x10(%rsp) | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
17c4: 41 80 fe 1e cmp $0x1e,%r14b | |
17c8: 0f 86 91 fa ff ff jbe 125f <ZSTD_decompressSequencesLong_default.constprop.0+0x79f> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
17ce: 83 f8 40 cmp $0x40,%eax | |
17d1: 0f 87 88 fa ff ff ja 125f <ZSTD_decompressSequencesLong_default.constprop.0+0x79f> | |
if (bitD->ptr >= bitD->limitPtr) { | |
17d7: 48 39 6c 24 38 cmp %rbp,0x38(%rsp) | |
17dc: 0f 86 91 04 00 00 jbe 1c73 <ZSTD_decompressSequencesLong_default.constprop.0+0x11b3> | |
if (bitD->ptr == bitD->start) { | |
17e2: 48 8b bc 24 18 01 00 mov 0x118(%rsp),%rdi | |
17e9: 00 | |
17ea: 48 39 ef cmp %rbp,%rdi | |
17ed: 0f 84 6c fa ff ff je 125f <ZSTD_decompressSequencesLong_default.constprop.0+0x79f> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
17f3: 89 c1 mov %eax,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
17f5: 48 89 ee mov %rbp,%rsi | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
17f8: c1 e9 03 shr $0x3,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
17fb: 41 89 cd mov %ecx,%r13d | |
17fe: 4c 29 ee sub %r13,%rsi | |
1801: 48 39 f7 cmp %rsi,%rdi | |
1804: 76 10 jbe 1816 <ZSTD_decompressSequencesLong_default.constprop.0+0xd56> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
1806: 48 89 ee mov %rbp,%rsi | |
1809: 48 29 fe sub %rdi,%rsi | |
bitD->ptr -= nbBytes; | |
180c: 89 f7 mov %esi,%edi | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
180e: 89 f1 mov %esi,%ecx | |
bitD->ptr -= nbBytes; | |
1810: 48 89 ee mov %rbp,%rsi | |
1813: 48 29 fe sub %rdi,%rsi | |
1816: 48 89 b4 24 10 01 00 mov %rsi,0x110(%rsp) | |
181d: 00 | |
181e: 48 8b 36 mov (%rsi),%rsi | |
bitD->bitsConsumed -= nbBytes*8; | |
1821: c1 e1 03 shl $0x3,%ecx | |
1824: 29 c8 sub %ecx,%eax | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
1826: 48 89 b4 24 00 01 00 mov %rsi,0x100(%rsp) | |
182d: 00 | |
return result; | |
182e: e9 34 fa ff ff jmpq 1267 <ZSTD_decompressSequencesLong_default.constprop.0+0x7a7> | |
1833: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
1838: 4c 89 c2 mov %r8,%rdx | |
183b: 4c 89 5c 24 38 mov %r11,0x38(%rsp) | |
1840: e8 00 00 00 00 callq 1845 <ZSTD_decompressSequencesLong_default.constprop.0+0xd85> | |
return sequenceLength; | |
1845: 4c 8b 5c 24 38 mov 0x38(%rsp),%r11 | |
184a: e9 ef fb ff ff jmpq 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
184f: 90 nop | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
1850: 48 8d 94 24 b8 00 00 lea 0xb8(%rsp),%rdx | |
1857: 00 | |
1858: ff 74 24 28 pushq 0x28(%rsp) | |
185c: 4c 89 df mov %r11,%rdi | |
185f: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
1866: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
186d: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
1874: 4c 8b 8c 24 b0 00 00 mov 0xb0(%rsp),%r9 | |
187b: 00 | |
187c: 4c 8b 44 24 40 mov 0x40(%rsp),%r8 | |
1881: 48 8b 4c 24 68 mov 0x68(%rsp),%rcx | |
1886: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi | |
188d: 00 | |
188e: 4c 89 5c 24 58 mov %r11,0x58(%rsp) | |
1893: e8 28 ed ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
1898: 48 83 c4 20 add $0x20,%rsp | |
189c: 4c 8b 5c 24 38 mov 0x38(%rsp),%r11 | |
18a1: 49 89 c4 mov %rax,%r12 | |
18a4: e9 95 fb ff ff jmpq 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
18a9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
18b0: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
18b7: e9 66 fc ff ff jmpq 1522 <ZSTD_decompressSequencesLong_default.constprop.0+0xa62> | |
18bc: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
18c0: f3 0f 6f 62 10 movdqu 0x10(%rdx),%xmm4 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
18c5: 48 83 ee 10 sub $0x10,%rsi | |
18c9: 41 0f 11 63 10 movups %xmm4,0x10(%r11) | |
if (16 >= length) return; | |
18ce: 48 83 fe 10 cmp $0x10,%rsi | |
18d2: 0f 8e a6 fa ff ff jle 137e <ZSTD_decompressSequencesLong_default.constprop.0+0x8be> | |
op += 16; | |
18d8: 49 8d 73 20 lea 0x20(%r11),%rsi | |
ip += 16; | |
18dc: 48 83 c2 20 add $0x20,%rdx | |
ZSTD_memcpy(dst, src, 16); | |
18e0: f3 0f 6f 3a movdqu (%rdx),%xmm7 | |
18e4: 48 83 c6 20 add $0x20,%rsi | |
18e8: 48 83 c2 20 add $0x20,%rdx | |
18ec: 0f 11 7e e0 movups %xmm7,-0x20(%rsi) | |
18f0: f3 0f 6f 72 f0 movdqu -0x10(%rdx),%xmm6 | |
18f5: 0f 11 76 f0 movups %xmm6,-0x10(%rsi) | |
while (op < oend); | |
18f9: 48 39 f7 cmp %rsi,%rdi | |
18fc: 77 e2 ja 18e0 <ZSTD_decompressSequencesLong_default.constprop.0+0xe20> | |
18fe: e9 7b fa ff ff jmpq 137e <ZSTD_decompressSequencesLong_default.constprop.0+0x8be> | |
1903: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1908: 89 c1 mov %eax,%ecx | |
190a: 4d 89 c8 mov %r9,%r8 | |
bitD->bitsConsumed += nbBits; | |
190d: 83 c0 01 add $0x1,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1910: 49 d3 e0 shl %cl,%r8 | |
1913: 4c 89 c1 mov %r8,%rcx | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
1916: 44 8b 44 24 10 mov 0x10(%rsp),%r8d | |
191b: 48 c1 e9 3f shr $0x3f,%rcx | |
191f: 83 fa 01 cmp $0x1,%edx | |
1922: 41 83 d0 00 adc $0x0,%r8d | |
1926: 49 01 c8 add %rcx,%r8 | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
1929: 49 83 f8 03 cmp $0x3,%r8 | |
192d: 74 34 je 1963 <ZSTD_decompressSequencesLong_default.constprop.0+0xea3> | |
192f: 4a 8b 8c c4 58 01 00 mov 0x158(%rsp,%r8,8),%rcx | |
1936: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
1937: 48 83 f9 01 cmp $0x1,%rcx | |
193b: 48 83 d1 00 adc $0x0,%rcx | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
193f: 49 83 f8 01 cmp $0x1,%r8 | |
1943: 75 2d jne 1972 <ZSTD_decompressSequencesLong_default.constprop.0+0xeb2> | |
seqState->prevOffset[0] = offset = temp; | |
1945: 66 48 0f 6e ff movq %rdi,%xmm7 | |
194a: 66 48 0f 6e c1 movq %rcx,%xmm0 | |
194f: 48 89 cf mov %rcx,%rdi | |
1952: 66 0f 6c c7 punpcklqdq %xmm7,%xmm0 | |
1956: 0f 11 84 24 58 01 00 movups %xmm0,0x158(%rsp) | |
195d: 00 | |
195e: e9 9a f4 ff ff jmpq dfd <ZSTD_decompressSequencesLong_default.constprop.0+0x33d> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
1963: 49 89 f8 mov %rdi,%r8 | |
1966: 31 c9 xor %ecx,%ecx | |
1968: 49 83 e8 01 sub $0x1,%r8 | |
196c: 0f 94 c1 sete %cl | |
196f: 4c 01 c1 add %r8,%rcx | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
1972: 4c 8b 84 24 60 01 00 mov 0x160(%rsp),%r8 | |
1979: 00 | |
197a: 4c 89 84 24 68 01 00 mov %r8,0x168(%rsp) | |
1981: 00 | |
1982: eb c1 jmp 1945 <ZSTD_decompressSequencesLong_default.constprop.0+0xe85> | |
1984: 84 d2 test %dl,%dl | |
1986: 0f 85 88 01 00 00 jne 1b14 <ZSTD_decompressSequencesLong_default.constprop.0+0x1054> | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
198c: 4c 8b b4 24 a8 00 00 mov 0xa8(%rsp),%r14 | |
1993: 00 | |
1994: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
199b: e9 65 f7 ff ff jmpq 1105 <ZSTD_decompressSequencesLong_default.constprop.0+0x645> | |
if (offset < 8) { | |
19a0: 49 83 ff 07 cmp $0x7,%r15 | |
19a4: 0f 87 5f 01 00 00 ja 1b09 <ZSTD_decompressSequencesLong_default.constprop.0+0x1049> | |
(*op)[0] = (*ip)[0]; | |
19aa: 0f b6 10 movzbl (%rax),%edx | |
19ad: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
19af: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
19b3: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
19b6: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
19ba: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
19bd: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
19c1: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
19c4: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 19cb <ZSTD_decompressSequencesLong_default.constprop.0+0xf0b> | |
19cb: 42 8b 14 ba mov (%rdx,%r15,4),%edx | |
19cf: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
19d2: 8b 10 mov (%rax),%edx | |
19d4: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
19d7: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 19de <ZSTD_decompressSequencesLong_default.constprop.0+0xf1e> | |
19de: 4a 63 14 ba movslq (%rdx,%r15,4),%rdx | |
19e2: 48 29 d0 sub %rdx,%rax | |
if (sequence.matchLength > 8) { | |
19e5: 49 83 f8 08 cmp $0x8,%r8 | |
19e9: 0f 86 4f fa ff ff jbe 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
*op += 8; | |
19ef: 48 8d 57 08 lea 0x8(%rdi),%rdx | |
*ip += 8; | |
19f3: 48 8d 48 08 lea 0x8(%rax),%rcx | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
19f7: 48 89 d6 mov %rdx,%rsi | |
19fa: 48 29 ce sub %rcx,%rsi | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
19fd: 48 83 fe 0f cmp $0xf,%rsi | |
1a01: 0f 8f d1 03 00 00 jg 1dd8 <ZSTD_decompressSequencesLong_default.constprop.0+0x1318> | |
1a07: 48 89 d6 mov %rdx,%rsi | |
1a0a: 4d 8d 55 f7 lea -0x9(%r13),%r10 | |
1a0e: 4c 8d 4f 09 lea 0x9(%rdi),%r9 | |
1a12: 48 29 c6 sub %rax,%rsi | |
1a15: 49 29 fa sub %rdi,%r10 | |
1a18: 48 83 ee 09 sub $0x9,%rsi | |
1a1c: 48 83 fe 0e cmp $0xe,%rsi | |
1a20: 0f 86 ca 00 00 00 jbe 1af0 <ZSTD_decompressSequencesLong_default.constprop.0+0x1030> | |
1a26: 49 83 fa 1f cmp $0x1f,%r10 | |
1a2a: 41 0f 97 c0 seta %r8b | |
1a2e: 4d 39 cd cmp %r9,%r13 | |
1a31: 40 0f 93 c6 setae %sil | |
1a35: 41 84 f0 test %sil,%r8b | |
1a38: 0f 84 b2 00 00 00 je 1af0 <ZSTD_decompressSequencesLong_default.constprop.0+0x1030> | |
1a3e: 49 c1 ea 03 shr $0x3,%r10 | |
1a42: 4d 39 cd cmp %r9,%r13 | |
1a45: 41 b9 01 00 00 00 mov $0x1,%r9d | |
1a4b: 49 8d 72 01 lea 0x1(%r10),%rsi | |
1a4f: 4c 0f 43 ce cmovae %rsi,%r9 | |
1a53: be 08 00 00 00 mov $0x8,%esi | |
1a58: 4d 89 c8 mov %r9,%r8 | |
1a5b: 49 d1 e8 shr %r8 | |
1a5e: 49 c1 e0 04 shl $0x4,%r8 | |
1a62: 49 83 c0 08 add $0x8,%r8 | |
1a66: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
1a6d: 00 00 00 | |
ZSTD_memcpy(dst, src, 8); | |
1a70: f3 0f 6f 34 30 movdqu (%rax,%rsi,1),%xmm6 | |
1a75: 0f 11 34 37 movups %xmm6,(%rdi,%rsi,1) | |
} while (op < oend); | |
1a79: 48 83 c6 10 add $0x10,%rsi | |
1a7d: 4c 39 c6 cmp %r8,%rsi | |
1a80: 75 ee jne 1a70 <ZSTD_decompressSequencesLong_default.constprop.0+0xfb0> | |
1a82: 4c 89 c8 mov %r9,%rax | |
1a85: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
1a89: 48 8d 34 c5 00 00 00 lea 0x0(,%rax,8),%rsi | |
1a90: 00 | |
1a91: 48 01 f1 add %rsi,%rcx | |
1a94: 48 01 f2 add %rsi,%rdx | |
1a97: 4c 39 c8 cmp %r9,%rax | |
1a9a: 0f 84 9e f9 ff ff je 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
ZSTD_memcpy(dst, src, 8); | |
1aa0: 48 8b 01 mov (%rcx),%rax | |
1aa3: 48 89 02 mov %rax,(%rdx) | |
} while (op < oend); | |
1aa6: e9 93 f9 ff ff jmpq 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
1aab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
1ab0: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed &= 7; | |
1ab2: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
1ab5: c1 e9 03 shr $0x3,%ecx | |
1ab8: 48 29 cd sub %rcx,%rbp | |
1abb: 4c 8b 4d 00 mov 0x0(%rbp),%r9 | |
return BIT_reloadDStreamFast(bitD); | |
1abf: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
1ac4: e9 4d f3 ff ff jmpq e16 <ZSTD_decompressSequencesLong_default.constprop.0+0x356> | |
1ac9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
1ad0: c7 44 24 08 00 00 00 movl $0x0,0x8(%rsp) | |
1ad7: 00 | |
1ad8: e9 45 fa ff ff jmpq 1522 <ZSTD_decompressSequencesLong_default.constprop.0+0xa62> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
1add: 48 89 ee mov %rbp,%rsi | |
1ae0: 4c 29 fe sub %r15,%rsi | |
1ae3: 89 f1 mov %esi,%ecx | |
bitD->ptr -= nbBytes; | |
1ae5: 89 f6 mov %esi,%esi | |
1ae7: 48 29 f5 sub %rsi,%rbp | |
1aea: e9 a3 f5 ff ff jmpq 1092 <ZSTD_decompressSequencesLong_default.constprop.0+0x5d2> | |
1aef: 90 nop | |
ZSTD_memcpy(dst, src, 8); | |
1af0: 48 8b 01 mov (%rcx),%rax | |
COPY8(op, ip) | |
1af3: 48 83 c2 08 add $0x8,%rdx | |
1af7: 48 83 c1 08 add $0x8,%rcx | |
ZSTD_memcpy(dst, src, 8); | |
1afb: 48 89 42 f8 mov %rax,-0x8(%rdx) | |
} while (op < oend); | |
1aff: 49 39 d5 cmp %rdx,%r13 | |
1b02: 77 ec ja 1af0 <ZSTD_decompressSequencesLong_default.constprop.0+0x1030> | |
1b04: e9 35 f9 ff ff jmpq 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
ZSTD_memcpy(dst, src, 8); | |
1b09: 48 8b 10 mov (%rax),%rdx | |
1b0c: 48 89 17 mov %rdx,(%rdi) | |
} | |
1b0f: e9 d1 fe ff ff jmpq 19e5 <ZSTD_decompressSequencesLong_default.constprop.0+0xf25> | |
1b14: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
1b1b: 4c 8b b4 24 a8 00 00 mov 0xa8(%rsp),%r14 | |
1b22: 00 | |
1b23: e9 d4 f5 ff ff jmpq 10fc <ZSTD_decompressSequencesLong_default.constprop.0+0x63c> | |
1b28: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
1b2f: 00 | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
1b30: 4c 89 ca mov %r9,%rdx | |
1b33: 48 89 4c 24 10 mov %rcx,0x10(%rsp) | |
1b38: e8 00 00 00 00 callq 1b3d <ZSTD_decompressSequencesLong_default.constprop.0+0x107d> | |
return sequenceLength; | |
1b3d: 48 8b 4c 24 10 mov 0x10(%rsp),%rcx | |
1b42: e9 8f fb ff ff jmpq 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
1b47: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
1b4e: 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1b50: 48 8b bc 24 00 01 00 mov 0x100(%rsp),%rdi | |
1b57: 00 | |
1b58: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
1b5a: 83 c0 01 add $0x1,%eax | |
1b5d: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
1b64: 48 d3 e7 shl %cl,%rdi | |
1b67: 48 89 f9 mov %rdi,%rcx | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
1b6a: 8b 7c 24 10 mov 0x10(%rsp),%edi | |
1b6e: 48 c1 e9 3f shr $0x3f,%rcx | |
1b72: 83 fa 01 cmp $0x1,%edx | |
1b75: 83 d7 00 adc $0x0,%edi | |
1b78: 48 01 f9 add %rdi,%rcx | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
1b7b: 48 83 f9 03 cmp $0x3,%rcx | |
1b7f: 0f 84 3f 02 00 00 je 1dc4 <ZSTD_decompressSequencesLong_default.constprop.0+0x1304> | |
1b85: 48 8b bc cc 58 01 00 mov 0x158(%rsp,%rcx,8),%rdi | |
1b8c: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
1b8d: 48 83 ff 01 cmp $0x1,%rdi | |
1b91: 48 83 d7 00 adc $0x0,%rdi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
1b95: 48 83 f9 01 cmp $0x1,%rcx | |
1b99: 74 10 je 1bab <ZSTD_decompressSequencesLong_default.constprop.0+0x10eb> | |
1b9b: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
1ba2: 00 | |
1ba3: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp) | |
1baa: 00 | |
seqState->prevOffset[0] = offset = temp; | |
1bab: 66 48 0f 6e e3 movq %rbx,%xmm4 | |
1bb0: 66 48 0f 6e c7 movq %rdi,%xmm0 | |
1bb5: 48 89 fb mov %rdi,%rbx | |
1bb8: 66 0f 6c c4 punpcklqdq %xmm4,%xmm0 | |
1bbc: 0f 11 84 24 58 01 00 movups %xmm0,0x158(%rsp) | |
1bc3: 00 | |
1bc4: e9 7c f6 ff ff jmpq 1245 <ZSTD_decompressSequencesLong_default.constprop.0+0x785> | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
1bc9: 66 49 0f 6e f1 movq %r9,%xmm6 | |
1bce: 66 48 0f 6e c2 movq %rdx,%xmm0 | |
1bd3: 4c 89 f1 mov %r14,%rcx | |
1bd6: 4d 89 f8 mov %r15,%r8 | |
1bd9: 66 0f 6c c6 punpcklqdq %xmm6,%xmm0 | |
1bdd: 4c 89 ef mov %r13,%rdi | |
1be0: 0f 29 84 24 e0 00 00 movaps %xmm0,0xe0(%rsp) | |
1be7: 00 | |
1be8: ff 74 24 28 pushq 0x28(%rsp) | |
1bec: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
1bf3: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
1bfa: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
1c01: 4c 8b 8c 24 b0 00 00 mov 0xb0(%rsp),%r9 | |
1c08: 00 | |
1c09: 48 8b 54 24 50 mov 0x50(%rsp),%rdx | |
1c0e: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi | |
1c15: 00 | |
1c16: e8 a5 e9 ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
1c1b: 48 83 c4 20 add $0x20,%rsp | |
1c1f: 48 89 c1 mov %rax,%rcx | |
1c22: e9 af fa ff ff jmpq 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
ZSTD_memcpy(dst, src, 16); | |
1c27: f3 0f 6f 7e 10 movdqu 0x10(%rsi),%xmm7 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
1c2c: 48 83 ea 10 sub $0x10,%rdx | |
1c30: 41 0f 11 7d 10 movups %xmm7,0x10(%r13) | |
if (16 >= length) return; | |
1c35: 48 83 fa 10 cmp $0x10,%rdx | |
1c39: 0f 8e df f9 ff ff jle 161e <ZSTD_decompressSequencesLong_default.constprop.0+0xb5e> | |
op += 16; | |
1c3f: 49 8d 55 20 lea 0x20(%r13),%rdx | |
ip += 16; | |
1c43: 48 83 c6 20 add $0x20,%rsi | |
1c47: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
1c4e: 00 00 | |
ZSTD_memcpy(dst, src, 16); | |
1c50: f3 0f 6f 26 movdqu (%rsi),%xmm4 | |
1c54: 48 83 c2 20 add $0x20,%rdx | |
1c58: 48 83 c6 20 add $0x20,%rsi | |
1c5c: 0f 11 62 e0 movups %xmm4,-0x20(%rdx) | |
1c60: f3 0f 6f 6e f0 movdqu -0x10(%rsi),%xmm5 | |
1c65: 0f 11 6a f0 movups %xmm5,-0x10(%rdx) | |
while (op < oend); | |
1c69: 48 39 d7 cmp %rdx,%rdi | |
1c6c: 77 e2 ja 1c50 <ZSTD_decompressSequencesLong_default.constprop.0+0x1190> | |
1c6e: e9 ab f9 ff ff jmpq 161e <ZSTD_decompressSequencesLong_default.constprop.0+0xb5e> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
1c73: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed &= 7; | |
1c75: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
1c78: c1 e9 03 shr $0x3,%ecx | |
1c7b: 48 29 cd sub %rcx,%rbp | |
1c7e: 48 8b 75 00 mov 0x0(%rbp),%rsi | |
1c82: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp) | |
1c89: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
1c8a: 48 89 b4 24 00 01 00 mov %rsi,0x100(%rsp) | |
1c91: 00 | |
return BIT_reloadDStreamFast(bitD); | |
1c92: e9 d0 f5 ff ff jmpq 1267 <ZSTD_decompressSequencesLong_default.constprop.0+0x7a7> | |
if (offset < 8) { | |
1c97: 48 83 fb 07 cmp $0x7,%rbx | |
1c9b: 0f 87 7a 01 00 00 ja 1e1b <ZSTD_decompressSequencesLong_default.constprop.0+0x135b> | |
(*op)[0] = (*ip)[0]; | |
1ca1: 0f b6 10 movzbl (%rax),%edx | |
1ca4: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
1ca6: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
1caa: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
1cad: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
1cb1: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
1cb4: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
1cb8: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
1cbb: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 1cc2 <ZSTD_decompressSequencesLong_default.constprop.0+0x1202> | |
1cc2: 8b 14 9a mov (%rdx,%rbx,4),%edx | |
1cc5: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
1cc8: 8b 10 mov (%rax),%edx | |
1cca: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
1ccd: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 1cd4 <ZSTD_decompressSequencesLong_default.constprop.0+0x1214> | |
1cd4: 48 63 14 9a movslq (%rdx,%rbx,4),%rdx | |
1cd8: 48 29 d0 sub %rdx,%rax | |
if (sequence.matchLength > 8) { | |
1cdb: 49 83 f9 08 cmp $0x8,%r9 | |
1cdf: 0f 86 f1 f9 ff ff jbe 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
*op += 8; | |
1ce5: 48 8d 57 08 lea 0x8(%rdi),%rdx | |
*ip += 8; | |
1ce9: 48 8d 70 08 lea 0x8(%rax),%rsi | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
1ced: 49 89 d3 mov %rdx,%r11 | |
1cf0: 49 29 f3 sub %rsi,%r11 | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
1cf3: 49 83 fb 0f cmp $0xf,%r11 | |
1cf7: 0f 8f 29 01 00 00 jg 1e26 <ZSTD_decompressSequencesLong_default.constprop.0+0x1366> | |
1cfd: 4c 8d 4d f7 lea -0x9(%rbp),%r9 | |
1d01: 48 8d 5f 09 lea 0x9(%rdi),%rbx | |
1d05: 49 29 f9 sub %rdi,%r9 | |
1d08: 4d 89 c8 mov %r9,%r8 | |
1d0b: 49 89 d1 mov %rdx,%r9 | |
1d0e: 49 29 c1 sub %rax,%r9 | |
1d11: 49 83 e9 09 sub $0x9,%r9 | |
1d15: 49 83 f9 0e cmp $0xe,%r9 | |
1d19: 76 7c jbe 1d97 <ZSTD_decompressSequencesLong_default.constprop.0+0x12d7> | |
1d1b: 48 39 eb cmp %rbp,%rbx | |
1d1e: 41 0f 96 c3 setbe %r11b | |
1d22: 49 83 f8 1f cmp $0x1f,%r8 | |
1d26: 41 0f 97 c1 seta %r9b | |
1d2a: 45 84 cb test %r9b,%r11b | |
1d2d: 74 68 je 1d97 <ZSTD_decompressSequencesLong_default.constprop.0+0x12d7> | |
1d2f: 4d 89 c1 mov %r8,%r9 | |
1d32: 49 c1 e9 03 shr $0x3,%r9 | |
1d36: 49 83 c1 01 add $0x1,%r9 | |
1d3a: 48 39 eb cmp %rbp,%rbx | |
1d3d: bb 01 00 00 00 mov $0x1,%ebx | |
1d42: 49 0f 46 d9 cmovbe %r9,%rbx | |
1d46: 41 b9 08 00 00 00 mov $0x8,%r9d | |
1d4c: 49 89 db mov %rbx,%r11 | |
1d4f: 49 d1 eb shr %r11 | |
1d52: 49 c1 e3 04 shl $0x4,%r11 | |
1d56: 49 83 c3 08 add $0x8,%r11 | |
ZSTD_memcpy(dst, src, 8); | |
1d5a: f3 42 0f 6f 1c 08 movdqu (%rax,%r9,1),%xmm3 | |
1d60: 42 0f 11 1c 0f movups %xmm3,(%rdi,%r9,1) | |
} while (op < oend); | |
1d65: 49 83 c1 10 add $0x10,%r9 | |
1d69: 4d 39 d9 cmp %r11,%r9 | |
1d6c: 75 ec jne 1d5a <ZSTD_decompressSequencesLong_default.constprop.0+0x129a> | |
1d6e: 48 89 d8 mov %rbx,%rax | |
1d71: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
1d75: 48 8d 3c c5 00 00 00 lea 0x0(,%rax,8),%rdi | |
1d7c: 00 | |
1d7d: 48 01 fe add %rdi,%rsi | |
1d80: 48 01 fa add %rdi,%rdx | |
1d83: 48 39 d8 cmp %rbx,%rax | |
1d86: 0f 84 4a f9 ff ff je 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
ZSTD_memcpy(dst, src, 8); | |
1d8c: 48 8b 06 mov (%rsi),%rax | |
1d8f: 48 89 02 mov %rax,(%rdx) | |
} while (op < oend); | |
1d92: e9 3f f9 ff ff jmpq 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
ZSTD_memcpy(dst, src, 8); | |
1d97: 48 8b 06 mov (%rsi),%rax | |
COPY8(op, ip) | |
1d9a: 48 83 c2 08 add $0x8,%rdx | |
1d9e: 48 83 c6 08 add $0x8,%rsi | |
ZSTD_memcpy(dst, src, 8); | |
1da2: 48 89 42 f8 mov %rax,-0x8(%rdx) | |
} while (op < oend); | |
1da6: 48 39 d5 cmp %rdx,%rbp | |
1da9: 77 ec ja 1d97 <ZSTD_decompressSequencesLong_default.constprop.0+0x12d7> | |
1dab: e9 26 f9 ff ff jmpq 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
1db0: 49 89 cc mov %rcx,%r12 | |
1db3: e9 0f ee ff ff jmpq bc7 <ZSTD_decompressSequencesLong_default.constprop.0+0x107> | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
1db8: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
1dbf: e9 30 f3 ff ff jmpq 10f4 <ZSTD_decompressSequencesLong_default.constprop.0+0x634> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
1dc4: 48 89 df mov %rbx,%rdi | |
1dc7: 31 c9 xor %ecx,%ecx | |
1dc9: 48 83 ef 01 sub $0x1,%rdi | |
1dcd: 0f 94 c1 sete %cl | |
1dd0: 48 01 cf add %rcx,%rdi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
1dd3: e9 c3 fd ff ff jmpq 1b9b <ZSTD_decompressSequencesLong_default.constprop.0+0x10db> | |
ZSTD_memcpy(dst, src, 16); | |
1dd8: f3 0f 6f 70 08 movdqu 0x8(%rax),%xmm6 | |
1ddd: 0f 11 77 08 movups %xmm6,0x8(%rdi) | |
if (16 >= length) return; | |
1de1: 49 83 f8 18 cmp $0x18,%r8 | |
1de5: 0f 8e 53 f6 ff ff jle 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
op += 16; | |
1deb: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
1def: 48 83 c0 18 add $0x18,%rax | |
1df3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 16); | |
1df8: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
1dfc: 48 83 c7 20 add $0x20,%rdi | |
1e00: 48 83 c0 20 add $0x20,%rax | |
1e04: 0f 11 5f e0 movups %xmm3,-0x20(%rdi) | |
1e08: f3 0f 6f 68 f0 movdqu -0x10(%rax),%xmm5 | |
1e0d: 0f 11 6f f0 movups %xmm5,-0x10(%rdi) | |
while (op < oend); | |
1e11: 49 39 fd cmp %rdi,%r13 | |
1e14: 77 e2 ja 1df8 <ZSTD_decompressSequencesLong_default.constprop.0+0x1338> | |
1e16: e9 23 f6 ff ff jmpq 143e <ZSTD_decompressSequencesLong_default.constprop.0+0x97e> | |
ZSTD_memcpy(dst, src, 8); | |
1e1b: 48 8b 10 mov (%rax),%rdx | |
1e1e: 48 89 17 mov %rdx,(%rdi) | |
} | |
1e21: e9 b5 fe ff ff jmpq 1cdb <ZSTD_decompressSequencesLong_default.constprop.0+0x121b> | |
ZSTD_memcpy(dst, src, 16); | |
1e26: f3 0f 6f 58 08 movdqu 0x8(%rax),%xmm3 | |
1e2b: 0f 11 5f 08 movups %xmm3,0x8(%rdi) | |
if (16 >= length) return; | |
1e2f: 49 83 f9 18 cmp $0x18,%r9 | |
1e33: 0f 8e 9d f8 ff ff jle 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
op += 16; | |
1e39: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
1e3d: 48 83 c0 18 add $0x18,%rax | |
ZSTD_memcpy(dst, src, 16); | |
1e41: f3 0f 6f 28 movdqu (%rax),%xmm5 | |
1e45: 48 83 c7 20 add $0x20,%rdi | |
1e49: 48 83 c0 20 add $0x20,%rax | |
1e4d: 0f 11 6f e0 movups %xmm5,-0x20(%rdi) | |
1e51: f3 0f 6f 60 f0 movdqu -0x10(%rax),%xmm4 | |
1e56: 0f 11 67 f0 movups %xmm4,-0x10(%rdi) | |
while (op < oend); | |
1e5a: 48 39 fd cmp %rdi,%rbp | |
1e5d: 77 e2 ja 1e41 <ZSTD_decompressSequencesLong_default.constprop.0+0x1381> | |
1e5f: e9 72 f8 ff ff jmpq 16d6 <ZSTD_decompressSequencesLong_default.constprop.0+0xc16> | |
1e64: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
1e6b: 00 00 00 00 | |
1e6f: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
1e76: 00 00 00 00 | |
1e7a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
0000000000001e80 <ZSTD_decompressSequences_bmi2.constprop.0>: | |
#if DYNAMIC_BMI2 | |
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG | |
static TARGET_ATTRIBUTE("bmi2") size_t | |
DONT_VECTORIZE | |
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, | |
1e80: 41 57 push %r15 | |
BYTE* const oend = ostart + maxDstSize; | |
1e82: 48 01 f2 add %rsi,%rdx | |
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, | |
1e85: 41 56 push %r14 | |
1e87: 41 55 push %r13 | |
1e89: 41 54 push %r12 | |
1e8b: 55 push %rbp | |
1e8c: 53 push %rbx | |
1e8d: 48 81 ec f8 00 00 00 sub $0xf8,%rsp | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
1e94: 48 8b 87 c0 75 00 00 mov 0x75c0(%rdi),%rax | |
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, | |
1e9b: 48 89 74 24 10 mov %rsi,0x10(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
1ea0: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi | |
ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, | |
1ea7: 44 89 4c 24 1c mov %r9d,0x1c(%rsp) | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
1eac: 48 01 f0 add %rsi,%rax | |
BYTE* const oend = ostart + maxDstSize; | |
1eaf: 48 89 54 24 20 mov %rdx,0x20(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
1eb4: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
1eb9: 48 89 44 24 08 mov %rax,0x8(%rsp) | |
if (nbSeq) { | |
1ebe: 45 85 c9 test %r9d,%r9d | |
1ec1: 0f 84 e1 00 00 00 je 1fa8 <ZSTD_decompressSequences_bmi2.constprop.0+0x128> | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
1ec7: 48 8b 87 c8 74 00 00 mov 0x74c8(%rdi),%rax | |
1ece: 49 89 ff mov %rdi,%r15 | |
dctx->fseEntropy = 1; | |
1ed1: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi) | |
1ed8: 00 00 00 | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
1edb: 48 89 04 24 mov %rax,(%rsp) | |
const BYTE* const vBase = (const BYTE*) (dctx->virtualStart); | |
1edf: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax | |
1ee6: 48 89 44 24 30 mov %rax,0x30(%rsp) | |
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); | |
1eeb: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax | |
1ef2: 48 89 44 24 38 mov %rax,0x38(%rsp) | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } | |
1ef7: 8b 87 3c 68 00 00 mov 0x683c(%rdi),%eax | |
1efd: 48 89 84 24 d8 00 00 mov %rax,0xd8(%rsp) | |
1f04: 00 | |
1f05: 8b 87 40 68 00 00 mov 0x6840(%rdi),%eax | |
1f0b: 48 89 84 24 e0 00 00 mov %rax,0xe0(%rsp) | |
1f12: 00 | |
1f13: 8b 87 44 68 00 00 mov 0x6844(%rdi),%eax | |
1f19: 48 89 84 24 e8 00 00 mov %rax,0xe8(%rsp) | |
1f20: 00 | |
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } | |
1f21: 4d 85 c0 test %r8,%r8 | |
1f24: 74 62 je 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
1f26: 48 8d 41 08 lea 0x8(%rcx),%rax | |
bitD->start = (const char*)srcBuffer; | |
1f2a: 48 89 8c 24 98 00 00 mov %rcx,0x98(%rsp) | |
1f31: 00 | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
1f32: 48 89 84 24 a0 00 00 mov %rax,0xa0(%rsp) | |
1f39: 00 | |
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; | |
1f3a: 42 0f b6 44 01 ff movzbl -0x1(%rcx,%r8,1),%eax | |
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ | |
1f40: 49 83 f8 07 cmp $0x7,%r8 | |
1f44: 0f 86 96 00 00 00 jbe 1fe0 <ZSTD_decompressSequences_bmi2.constprop.0+0x160> | |
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); | |
1f4a: 4a 8d 54 01 f8 lea -0x8(%rcx,%r8,1),%rdx | |
1f4f: 48 89 94 24 90 00 00 mov %rdx,0x90(%rsp) | |
1f56: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
1f57: 48 8b 12 mov (%rdx),%rdx | |
1f5a: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
1f61: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
1f62: 84 c0 test %al,%al | |
1f64: 74 22 je 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
return __builtin_clz (val) ^ 31; | |
1f66: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
1f69: ba 08 00 00 00 mov $0x8,%edx | |
1f6e: 29 c2 sub %eax,%edx | |
1f70: 89 94 24 88 00 00 00 mov %edx,0x88(%rsp) | |
RETURN_ERROR_IF( | |
1f77: 49 83 f8 88 cmp $0xffffffffffffff88,%r8 | |
1f7b: 0f 86 eb 00 00 00 jbe 206c <ZSTD_decompressSequences_bmi2.constprop.0+0x1ec> | |
1f81: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
1f88: 49 c7 c6 ec ff ff ff mov $0xffffffffffffffec,%r14 | |
const void* seqStart, size_t seqSize, int nbSeq, | |
const ZSTD_longOffset_e isLongOffset, | |
const int frame) | |
{ | |
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
} | |
1f8f: 48 81 c4 f8 00 00 00 add $0xf8,%rsp | |
1f96: 4c 89 f0 mov %r14,%rax | |
1f99: 5b pop %rbx | |
1f9a: 5d pop %rbp | |
1f9b: 41 5c pop %r12 | |
1f9d: 41 5d pop %r13 | |
1f9f: 41 5e pop %r14 | |
1fa1: 41 5f pop %r15 | |
1fa3: c3 retq | |
1fa4: 0f 1f 40 00 nopl 0x0(%rax) | |
BYTE* op = ostart; | |
1fa8: 48 8b 5c 24 10 mov 0x10(%rsp),%rbx | |
1fad: 48 89 c5 mov %rax,%rbp | |
{ size_t const lastLLSize = litEnd - litPtr; | |
1fb0: 48 29 f5 sub %rsi,%rbp | |
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, ""); | |
1fb3: 48 29 da sub %rbx,%rdx | |
1fb6: 49 c7 c6 ba ff ff ff mov $0xffffffffffffffba,%r14 | |
1fbd: 48 39 d5 cmp %rdx,%rbp | |
1fc0: 77 cd ja 1f8f <ZSTD_decompressSequences_bmi2.constprop.0+0x10f> | |
if (op != NULL) { | |
1fc2: 48 85 db test %rbx,%rbx | |
1fc5: 74 0e je 1fd5 <ZSTD_decompressSequences_bmi2.constprop.0+0x155> | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
1fc7: 48 89 df mov %rbx,%rdi | |
1fca: 48 89 ea mov %rbp,%rdx | |
op += lastLLSize; | |
1fcd: 48 01 eb add %rbp,%rbx | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
1fd0: e8 00 00 00 00 callq 1fd5 <ZSTD_decompressSequences_bmi2.constprop.0+0x155> | |
return op-ostart; | |
1fd5: 48 2b 5c 24 10 sub 0x10(%rsp),%rbx | |
1fda: 49 89 de mov %rbx,%r14 | |
1fdd: eb b0 jmp 1f8f <ZSTD_decompressSequences_bmi2.constprop.0+0x10f> | |
1fdf: 90 nop | |
bitD->ptr = bitD->start; | |
1fe0: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 1fe7 <ZSTD_decompressSequences_bmi2.constprop.0+0x167> | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
1fe7: 0f b6 11 movzbl (%rcx),%edx | |
bitD->ptr = bitD->start; | |
1fea: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp) | |
1ff1: 00 | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
1ff2: 4a 63 34 87 movslq (%rdi,%r8,4),%rsi | |
1ff6: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
1ffd: 00 | |
switch(srcSize) | |
1ffe: 48 01 fe add %rdi,%rsi | |
2001: ff e6 jmpq *%rsi | |
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); | |
2003: 0f b6 71 06 movzbl 0x6(%rcx),%esi | |
2007: 48 c1 e6 30 shl $0x30,%rsi | |
200b: 48 01 f2 add %rsi,%rdx | |
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); | |
200e: 0f b6 71 05 movzbl 0x5(%rcx),%esi | |
2012: 48 c1 e6 28 shl $0x28,%rsi | |
2016: 48 01 f2 add %rsi,%rdx | |
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); | |
2019: 0f b6 71 04 movzbl 0x4(%rcx),%esi | |
201d: 48 c1 e6 20 shl $0x20,%rsi | |
2021: 48 01 f2 add %rsi,%rdx | |
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; | |
2024: 0f b6 71 03 movzbl 0x3(%rcx),%esi | |
2028: 48 c1 e6 18 shl $0x18,%rsi | |
202c: 48 01 f2 add %rsi,%rdx | |
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; | |
202f: 0f b6 71 02 movzbl 0x2(%rcx),%esi | |
2033: 48 c1 e6 10 shl $0x10,%rsi | |
2037: 48 01 f2 add %rsi,%rdx | |
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; | |
203a: 0f b6 49 01 movzbl 0x1(%rcx),%ecx | |
203e: 48 c1 e1 08 shl $0x8,%rcx | |
2042: 48 01 ca add %rcx,%rdx | |
2045: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
204c: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; | |
204d: 84 c0 test %al,%al | |
204f: 0f 84 33 ff ff ff je 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
2055: ba 09 00 00 00 mov $0x9,%edx | |
return __builtin_clz (val) ^ 31; | |
205a: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
205d: 44 29 c2 sub %r8d,%edx | |
2060: c1 e2 03 shl $0x3,%edx | |
2063: 29 c2 sub %eax,%edx | |
2065: 89 94 24 88 00 00 00 mov %edx,0x88(%rsp) | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
206c: 49 8b 17 mov (%r15),%rdx | |
206f: 48 8d b4 24 80 00 00 lea 0x80(%rsp),%rsi | |
2076: 00 | |
2077: 48 8d bc 24 a8 00 00 lea 0xa8(%rsp),%rdi | |
207e: 00 | |
207f: e8 7c e9 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); | |
2084: 49 8b 57 10 mov 0x10(%r15),%rdx | |
2088: 48 8d bc 24 b8 00 00 lea 0xb8(%rsp),%rdi | |
208f: 00 | |
2090: e8 6b e9 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); | |
2095: 49 8b 57 08 mov 0x8(%r15),%rdx | |
2099: 48 8d bc 24 c8 00 00 lea 0xc8(%rsp),%rdi | |
20a0: 00 | |
20a1: e8 5a e9 ff ff callq a00 <ZSTD_initFseState> | |
__asm__(".p2align 6"); | |
20a6: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
20ad: 00 00 00 00 | |
20b1: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
20b8: 00 00 00 00 | |
20bc: 0f 1f 40 00 nopl 0x0(%rax) | |
__asm__("nop"); | |
20c0: 90 nop | |
__asm__(".p2align 5"); | |
20c1: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
20c8: 00 00 00 00 | |
20cc: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
20d3: 00 00 00 00 | |
20d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
20de: 00 00 | |
__asm__("nop"); | |
20e0: 90 nop | |
__asm__(".p2align 3"); | |
20e1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
20e8: 48 8b 44 24 20 mov 0x20(%rsp),%rax | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
20ed: 48 8d 74 24 58 lea 0x58(%rsp),%rsi | |
*ip += dec32table[offset]; | |
20f2: 4c 89 7c 24 48 mov %r15,0x48(%rsp) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
20f7: 48 89 74 24 40 mov %rsi,0x40(%rsp) | |
BYTE* op = ostart; | |
20fc: 48 8b 5c 24 10 mov 0x10(%rsp),%rbx | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
2101: 48 83 e8 20 sub $0x20,%rax | |
2105: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
210a: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax | |
2111: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2118: 48 8b 8c 24 a8 00 00 mov 0xa8(%rsp),%rcx | |
211f: 00 | |
2120: 48 8b 94 24 b0 00 00 mov 0xb0(%rsp),%rdx | |
2127: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2128: 48 8b b4 24 c8 00 00 mov 0xc8(%rsp),%rsi | |
212f: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
2130: 48 8b ac 24 d8 00 00 mov 0xd8(%rsp),%rbp | |
2137: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2138: 4c 8d 04 ca lea (%rdx,%rcx,8),%r8 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
213c: 48 8b 8c 24 d0 00 00 mov 0xd0(%rsp),%rcx | |
2143: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2144: 45 0f b6 50 02 movzbl 0x2(%r8),%r10d | |
2149: 41 8b 50 04 mov 0x4(%r8),%edx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
214d: 48 8d 3c f1 lea (%rcx,%rsi,8),%rdi | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
2151: 48 8b 8c 24 c0 00 00 mov 0xc0(%rsp),%rcx | |
2158: 00 | |
2159: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
2160: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2161: 44 0f b6 5f 02 movzbl 0x2(%rdi),%r11d | |
2166: 44 8b 67 04 mov 0x4(%rdi),%r12d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
216a: 48 8d 34 f1 lea (%rcx,%rsi,8),%rsi | |
216e: 0f b6 4e 02 movzbl 0x2(%rsi),%ecx | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
2172: 47 8d 2c 1a lea (%r10,%r11,1),%r13d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
2176: 44 8b 4e 04 mov 0x4(%rsi),%r9d | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
217a: 41 01 cd add %ecx,%r13d | |
if (ofBits > 1) { | |
217d: 80 f9 01 cmp $0x1,%cl | |
2180: 0f 86 62 02 00 00 jbe 23e8 <ZSTD_decompressSequences_bmi2.constprop.0+0x568> | |
2186: 41 89 cf mov %ecx,%r15d | |
2189: c4 62 f9 f7 b4 24 80 shlx %rax,0x80(%rsp),%r14 | |
2190: 00 00 00 | |
bitD->bitsConsumed += nbBits; | |
2193: 01 c8 add %ecx,%eax | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
2195: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
219c: 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
219d: 41 f7 df neg %r15d | |
bitD->bitsConsumed += nbBits; | |
21a0: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
21a7: c4 42 83 f7 f6 shrx %r15,%r14,%r14 | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
21ac: 4d 01 ce add %r9,%r14 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
21af: 48 89 8c 24 e8 00 00 mov %rcx,0xe8(%rsp) | |
21b6: 00 | |
seqState->prevOffset[0] = offset; | |
21b7: 4c 89 b4 24 d8 00 00 mov %r14,0xd8(%rsp) | |
21be: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
21bf: 48 89 ac 24 e0 00 00 mov %rbp,0xe0(%rsp) | |
21c6: 00 | |
seqState->prevOffset[0] = offset; | |
21c7: 4c 89 f5 mov %r14,%rbp | |
if (mlBits > 0) | |
21ca: 45 84 db test %r11b,%r11b | |
21cd: 0f 85 4d 02 00 00 jne 2420 <ZSTD_decompressSequences_bmi2.constprop.0+0x5a0> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
21d3: 41 80 fd 1e cmp $0x1e,%r13b | |
21d7: 0f 87 6f 02 00 00 ja 244c <ZSTD_decompressSequences_bmi2.constprop.0+0x5cc> | |
21dd: 48 8b 8c 24 80 00 00 mov 0x80(%rsp),%rcx | |
21e4: 00 | |
if (llBits > 0) | |
21e5: 45 84 d2 test %r10b,%r10b | |
21e8: 0f 85 da 02 00 00 jne 24c8 <ZSTD_decompressSequences_bmi2.constprop.0+0x648> | |
U32 const nbBits = DInfo.nbBits; | |
21ee: 45 0f b6 50 03 movzbl 0x3(%r8),%r10d | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
21f3: 4c 8d 1d 00 00 00 00 lea 0x0(%rip),%r11 # 21fa <ZSTD_decompressSequences_bmi2.constprop.0+0x37a> | |
DStatePtr->state = DInfo.nextState + lowBits; | |
21fa: 45 0f b7 00 movzwl (%r8),%r8d | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
21fe: 4e 8d 34 22 lea (%rdx,%r12,1),%r14 | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
2202: 4e 8d 2c 33 lea (%rbx,%r14,1),%r13 | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
2206: 44 01 d0 add %r10d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2209: 41 89 c1 mov %eax,%r9d | |
220c: 41 f7 d9 neg %r9d | |
220f: c4 62 b3 f7 c9 shrx %r9,%rcx,%r9 | |
2214: 47 23 0c 93 and (%r11,%r10,4),%r9d | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2218: 4d 01 c8 add %r9,%r8 | |
221b: 4c 89 84 24 a8 00 00 mov %r8,0xa8(%rsp) | |
2222: 00 | |
U32 const nbBits = DInfo.nbBits; | |
2223: 44 0f b6 4f 03 movzbl 0x3(%rdi),%r9d | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2228: 0f b7 3f movzwl (%rdi),%edi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
222b: 44 01 c8 add %r9d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
222e: 41 89 c0 mov %eax,%r8d | |
2231: 41 f7 d8 neg %r8d | |
2234: c4 62 bb f7 c1 shrx %r8,%rcx,%r8 | |
2239: 47 23 04 8b and (%r11,%r9,4),%r8d | |
223d: 4c 01 c7 add %r8,%rdi | |
2240: 48 89 bc 24 c8 00 00 mov %rdi,0xc8(%rsp) | |
2247: 00 | |
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state]; | |
2248: 0f b7 3e movzwl (%rsi),%edi | |
U32 const nbBits = DInfo.nbBits; | |
224b: 0f b6 76 03 movzbl 0x3(%rsi),%esi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
224f: 01 f0 add %esi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2251: 41 89 c0 mov %eax,%r8d | |
bitD->bitsConsumed += nbBits; | |
2254: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
DStatePtr->state = DInfo.nextState + lowBits; | |
225b: 0f b7 c7 movzwl %di,%eax | |
BYTE* const oLitEnd = op + sequence.litLength; | |
225e: 48 8d 3c 13 lea (%rbx,%rdx,1),%rdi | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2262: 41 f7 d8 neg %r8d | |
2265: c4 e2 bb f7 c9 shrx %r8,%rcx,%rcx | |
226a: 41 23 0c b3 and (%r11,%rsi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
226e: 48 01 c1 add %rax,%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
2271: 48 89 f8 mov %rdi,%rax | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2274: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp) | |
227b: 00 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
227c: 48 8b 4c 24 58 mov 0x58(%rsp),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
2281: 48 29 e8 sub %rbp,%rax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
2284: 48 8d 34 11 lea (%rcx,%rdx,1),%rsi | |
if (UNLIKELY( | |
2288: 48 39 74 24 08 cmp %rsi,0x8(%rsp) | |
228d: 0f 82 95 02 00 00 jb 2528 <ZSTD_decompressSequences_bmi2.constprop.0+0x6a8> | |
2293: 4c 3b 6c 24 28 cmp 0x28(%rsp),%r13 | |
2298: 0f 87 8a 02 00 00 ja 2528 <ZSTD_decompressSequences_bmi2.constprop.0+0x6a8> | |
ZSTD_memcpy(dst, src, 16); | |
229e: f3 0f 6f 11 movdqu (%rcx),%xmm2 | |
22a2: 0f 11 13 movups %xmm2,(%rbx) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
22a5: 48 83 fa 10 cmp $0x10,%rdx | |
22a9: 0f 87 c9 02 00 00 ja 2578 <ZSTD_decompressSequences_bmi2.constprop.0+0x6f8> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
22af: 48 89 fa mov %rdi,%rdx | |
22b2: 48 2b 14 24 sub (%rsp),%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
22b6: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
22bb: 48 39 d5 cmp %rdx,%rbp | |
22be: 76 49 jbe 2309 <ZSTD_decompressSequences_bmi2.constprop.0+0x489> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
22c0: 48 89 fa mov %rdi,%rdx | |
22c3: 48 2b 54 24 30 sub 0x30(%rsp),%rdx | |
22c8: 48 39 d5 cmp %rdx,%rbp | |
22cb: 0f 87 b7 fc ff ff ja 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
match = dictEnd + (match - prefixStart); | |
22d1: 48 8b 4c 24 38 mov 0x38(%rsp),%rcx | |
22d6: 48 89 c6 mov %rax,%rsi | |
22d9: 48 2b 34 24 sub (%rsp),%rsi | |
22dd: 48 01 ce add %rcx,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
22e0: 4a 8d 14 26 lea (%rsi,%r12,1),%rdx | |
22e4: 48 39 d1 cmp %rdx,%rcx | |
22e7: 0f 83 2b 02 00 00 jae 2518 <ZSTD_decompressSequences_bmi2.constprop.0+0x698> | |
{ size_t const length1 = dictEnd - match; | |
22ed: 4c 8b 3c 24 mov (%rsp),%r15 | |
22f1: 49 29 c7 sub %rax,%r15 | |
ZSTD_memmove(oLitEnd, match, length1); | |
22f4: 4c 89 fa mov %r15,%rdx | |
sequence.matchLength -= length1; | |
22f7: 4d 29 fc sub %r15,%r12 | |
ZSTD_memmove(oLitEnd, match, length1); | |
22fa: e8 00 00 00 00 callq 22ff <ZSTD_decompressSequences_bmi2.constprop.0+0x47f> | |
22ff: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
2302: 48 8b 04 24 mov (%rsp),%rax | |
op = oLitEnd + length1; | |
2306: 4c 01 ff add %r15,%rdi | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
2309: 48 83 fd 0f cmp $0xf,%rbp | |
230d: 0f 86 b5 02 00 00 jbe 25c8 <ZSTD_decompressSequences_bmi2.constprop.0+0x748> | |
2313: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
2317: 0f 11 1f movups %xmm3,(%rdi) | |
if (16 >= length) return; | |
231a: 49 83 fc 10 cmp $0x10,%r12 | |
231e: 7e 2e jle 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
op += 16; | |
2320: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
2324: 48 83 c0 10 add $0x10,%rax | |
2328: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
232f: 00 | |
ZSTD_memcpy(dst, src, 16); | |
2330: f3 0f 6f 00 movdqu (%rax),%xmm0 | |
2334: 48 83 c7 20 add $0x20,%rdi | |
2338: 48 83 c0 20 add $0x20,%rax | |
233c: 0f 11 47 e0 movups %xmm0,-0x20(%rdi) | |
2340: f3 0f 6f 48 f0 movdqu -0x10(%rax),%xmm1 | |
2345: 0f 11 4f f0 movups %xmm1,-0x10(%rdi) | |
while (op < oend); | |
2349: 49 39 fd cmp %rdi,%r13 | |
234c: 77 e2 ja 2330 <ZSTD_decompressSequences_bmi2.constprop.0+0x4b0> | |
if (UNLIKELY(ZSTD_isError(oneSeqSize))) | |
234e: 49 83 fe 88 cmp $0xffffffffffffff88,%r14 | |
2352: 0f 87 37 fc ff ff ja 1f8f <ZSTD_decompressSequences_bmi2.constprop.0+0x10f> | |
op += oneSeqSize; | |
2358: 4c 01 f3 add %r14,%rbx | |
if (UNLIKELY(!--nbSeq)) | |
235b: 83 6c 24 1c 01 subl $0x1,0x1c(%rsp) | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
2360: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax | |
2367: 0f 84 b3 02 00 00 je 2620 <ZSTD_decompressSequences_bmi2.constprop.0+0x7a0> | |
236d: 83 f8 40 cmp $0x40,%eax | |
2370: 0f 87 a2 fd ff ff ja 2118 <ZSTD_decompressSequences_bmi2.constprop.0+0x298> | |
if (bitD->ptr >= bitD->limitPtr) { | |
2376: 48 8b 94 24 90 00 00 mov 0x90(%rsp),%rdx | |
237d: 00 | |
237e: 48 3b 94 24 a0 00 00 cmp 0xa0(%rsp),%rdx | |
2385: 00 | |
2386: 0f 83 5c 01 00 00 jae 24e8 <ZSTD_decompressSequences_bmi2.constprop.0+0x668> | |
if (bitD->ptr == bitD->start) { | |
238c: 48 8b bc 24 98 00 00 mov 0x98(%rsp),%rdi | |
2393: 00 | |
2394: 48 39 fa cmp %rdi,%rdx | |
2397: 0f 84 7b fd ff ff je 2118 <ZSTD_decompressSequences_bmi2.constprop.0+0x298> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
239d: 89 c1 mov %eax,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
239f: 48 89 d6 mov %rdx,%rsi | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
23a2: c1 e9 03 shr $0x3,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
23a5: 41 89 c8 mov %ecx,%r8d | |
23a8: 4c 29 c6 sub %r8,%rsi | |
23ab: 48 39 f7 cmp %rsi,%rdi | |
23ae: 76 10 jbe 23c0 <ZSTD_decompressSequences_bmi2.constprop.0+0x540> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
23b0: 48 89 d6 mov %rdx,%rsi | |
23b3: 48 29 fe sub %rdi,%rsi | |
bitD->ptr -= nbBytes; | |
23b6: 89 f7 mov %esi,%edi | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
23b8: 89 f1 mov %esi,%ecx | |
bitD->ptr -= nbBytes; | |
23ba: 48 29 fa sub %rdi,%rdx | |
23bd: 48 89 d6 mov %rdx,%rsi | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
23c0: 48 8b 16 mov (%rsi),%rdx | |
bitD->bitsConsumed -= nbBytes*8; | |
23c3: c1 e1 03 shl $0x3,%ecx | |
bitD->ptr -= nbBytes; | |
23c6: 48 89 b4 24 90 00 00 mov %rsi,0x90(%rsp) | |
23cd: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
23ce: 29 c8 sub %ecx,%eax | |
23d0: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
23d7: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
23de: 00 | |
return result; | |
23df: e9 34 fd ff ff jmpq 2118 <ZSTD_decompressSequences_bmi2.constprop.0+0x298> | |
23e4: 0f 1f 40 00 nopl 0x0(%rax) | |
if (LIKELY((ofBits == 0))) { | |
23e8: 0f 84 b2 02 00 00 je 26a0 <ZSTD_decompressSequences_bmi2.constprop.0+0x820> | |
if (LIKELY(!ll0)) | |
23ee: 85 d2 test %edx,%edx | |
23f0: 0f 85 d4 fd ff ff jne 21ca <ZSTD_decompressSequences_bmi2.constprop.0+0x34a> | |
offset = seqState->prevOffset[1]; | |
23f6: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
23fd: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
23fe: 48 89 ac 24 e0 00 00 mov %rbp,0xe0(%rsp) | |
2405: 00 | |
seqState->prevOffset[0] = offset; | |
2406: 48 89 8c 24 d8 00 00 mov %rcx,0xd8(%rsp) | |
240d: 00 | |
offset = seqState->prevOffset[1]; | |
240e: 48 89 cd mov %rcx,%rbp | |
2411: e9 b4 fd ff ff jmpq 21ca <ZSTD_decompressSequences_bmi2.constprop.0+0x34a> | |
2416: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
241d: 00 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2420: 45 89 d9 mov %r11d,%r9d | |
2423: c4 e2 f9 f7 8c 24 80 shlx %rax,0x80(%rsp),%rcx | |
242a: 00 00 00 | |
bitD->bitsConsumed += nbBits; | |
242d: 44 01 d8 add %r11d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2430: 41 f7 d9 neg %r9d | |
bitD->bitsConsumed += nbBits; | |
2433: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
243a: c4 e2 b3 f7 c9 shrx %r9,%rcx,%rcx | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
243f: 49 01 cc add %rcx,%r12 | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
2442: 41 80 fd 1e cmp $0x1e,%r13b | |
2446: 0f 86 91 fd ff ff jbe 21dd <ZSTD_decompressSequences_bmi2.constprop.0+0x35d> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
244c: 83 f8 40 cmp $0x40,%eax | |
244f: 0f 87 88 fd ff ff ja 21dd <ZSTD_decompressSequences_bmi2.constprop.0+0x35d> | |
if (bitD->ptr >= bitD->limitPtr) { | |
2455: 48 8b 8c 24 90 00 00 mov 0x90(%rsp),%rcx | |
245c: 00 | |
245d: 48 3b 8c 24 a0 00 00 cmp 0xa0(%rsp),%rcx | |
2464: 00 | |
2465: 0f 83 ed 02 00 00 jae 2758 <ZSTD_decompressSequences_bmi2.constprop.0+0x8d8> | |
if (bitD->ptr == bitD->start) { | |
246b: 4c 8b ac 24 98 00 00 mov 0x98(%rsp),%r13 | |
2472: 00 | |
2473: 4c 39 e9 cmp %r13,%rcx | |
2476: 0f 84 61 fd ff ff je 21dd <ZSTD_decompressSequences_bmi2.constprop.0+0x35d> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
247c: 41 89 c1 mov %eax,%r9d | |
if (bitD->ptr - nbBytes < bitD->start) { | |
247f: 49 89 cb mov %rcx,%r11 | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
2482: 41 c1 e9 03 shr $0x3,%r9d | |
if (bitD->ptr - nbBytes < bitD->start) { | |
2486: 45 89 ce mov %r9d,%r14d | |
2489: 4d 29 f3 sub %r14,%r11 | |
248c: 4d 39 dd cmp %r11,%r13 | |
248f: 76 12 jbe 24a3 <ZSTD_decompressSequences_bmi2.constprop.0+0x623> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
2491: 49 89 cb mov %rcx,%r11 | |
2494: 4d 29 eb sub %r13,%r11 | |
bitD->ptr -= nbBytes; | |
2497: 45 89 dd mov %r11d,%r13d | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
249a: 45 89 d9 mov %r11d,%r9d | |
bitD->ptr -= nbBytes; | |
249d: 4c 29 e9 sub %r13,%rcx | |
24a0: 49 89 cb mov %rcx,%r11 | |
24a3: 49 8b 0b mov (%r11),%rcx | |
bitD->bitsConsumed -= nbBytes*8; | |
24a6: 41 c1 e1 03 shl $0x3,%r9d | |
bitD->ptr -= nbBytes; | |
24aa: 4c 89 9c 24 90 00 00 mov %r11,0x90(%rsp) | |
24b1: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
24b2: 44 29 c8 sub %r9d,%eax | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
24b5: 48 89 8c 24 80 00 00 mov %rcx,0x80(%rsp) | |
24bc: 00 | |
return result; | |
24bd: e9 23 fd ff ff jmpq 21e5 <ZSTD_decompressSequences_bmi2.constprop.0+0x365> | |
24c2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
24c8: 45 89 d3 mov %r10d,%r11d | |
24cb: c4 62 f9 f7 c9 shlx %rax,%rcx,%r9 | |
bitD->bitsConsumed += nbBits; | |
24d0: 44 01 d0 add %r10d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
24d3: 41 f7 db neg %r11d | |
24d6: c4 42 a3 f7 c9 shrx %r11,%r9,%r9 | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
24db: 4c 01 ca add %r9,%rdx | |
24de: e9 0b fd ff ff jmpq 21ee <ZSTD_decompressSequences_bmi2.constprop.0+0x36e> | |
24e3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
24e8: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed &= 7; | |
24ea: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
24ed: c1 e9 03 shr $0x3,%ecx | |
bitD->bitsConsumed &= 7; | |
24f0: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
24f7: 48 29 ca sub %rcx,%rdx | |
24fa: 48 89 94 24 90 00 00 mov %rdx,0x90(%rsp) | |
2501: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
2502: 48 8b 12 mov (%rdx),%rdx | |
2505: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
250c: 00 | |
return BIT_reloadDStreamFast(bitD); | |
250d: e9 06 fc ff ff jmpq 2118 <ZSTD_decompressSequences_bmi2.constprop.0+0x298> | |
2512: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
2518: 4c 89 e2 mov %r12,%rdx | |
251b: e8 00 00 00 00 callq 2520 <ZSTD_decompressSequences_bmi2.constprop.0+0x6a0> | |
return sequenceLength; | |
2520: e9 29 fe ff ff jmpq 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
2525: 0f 1f 00 nopl (%rax) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
2528: 48 89 54 24 60 mov %rdx,0x60(%rsp) | |
252d: 48 89 df mov %rbx,%rdi | |
2530: 4c 89 64 24 68 mov %r12,0x68(%rsp) | |
2535: 48 89 6c 24 70 mov %rbp,0x70(%rsp) | |
253a: ff 74 24 38 pushq 0x38(%rsp) | |
253e: ff 74 24 78 pushq 0x78(%rsp) | |
2542: ff 74 24 78 pushq 0x78(%rsp) | |
2546: 52 push %rdx | |
2547: 4c 8b 4c 24 50 mov 0x50(%rsp),%r9 | |
254c: 4c 8b 44 24 20 mov 0x20(%rsp),%r8 | |
2551: 48 8b 4c 24 28 mov 0x28(%rsp),%rcx | |
2556: 48 8b 54 24 60 mov 0x60(%rsp),%rdx | |
255b: 48 8b 74 24 40 mov 0x40(%rsp),%rsi | |
2560: e8 5b e0 ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
2565: 48 83 c4 20 add $0x20,%rsp | |
2569: 49 89 c6 mov %rax,%r14 | |
256c: e9 dd fd ff ff jmpq 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
2571: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
2578: f3 0f 6f 71 10 movdqu 0x10(%rcx),%xmm6 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
257d: 48 83 ea 10 sub $0x10,%rdx | |
2581: 0f 11 73 10 movups %xmm6,0x10(%rbx) | |
if (16 >= length) return; | |
2585: 48 83 fa 10 cmp $0x10,%rdx | |
2589: 0f 8e 20 fd ff ff jle 22af <ZSTD_decompressSequences_bmi2.constprop.0+0x42f> | |
op += 16; | |
258f: 48 8d 53 20 lea 0x20(%rbx),%rdx | |
ip += 16; | |
2593: 48 83 c1 20 add $0x20,%rcx | |
2597: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
259e: 00 00 | |
ZSTD_memcpy(dst, src, 16); | |
25a0: f3 0f 6f 21 movdqu (%rcx),%xmm4 | |
25a4: 48 83 c2 20 add $0x20,%rdx | |
25a8: 48 83 c1 20 add $0x20,%rcx | |
25ac: 0f 11 62 e0 movups %xmm4,-0x20(%rdx) | |
25b0: f3 0f 6f 69 f0 movdqu -0x10(%rcx),%xmm5 | |
25b5: 0f 11 6a f0 movups %xmm5,-0x10(%rdx) | |
while (op < oend); | |
25b9: 48 39 d7 cmp %rdx,%rdi | |
25bc: 77 e2 ja 25a0 <ZSTD_decompressSequences_bmi2.constprop.0+0x720> | |
25be: e9 ec fc ff ff jmpq 22af <ZSTD_decompressSequences_bmi2.constprop.0+0x42f> | |
25c3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
if (offset < 8) { | |
25c8: 48 83 fd 07 cmp $0x7,%rbp | |
25cc: 0f 86 34 01 00 00 jbe 2706 <ZSTD_decompressSequences_bmi2.constprop.0+0x886> | |
ZSTD_memcpy(dst, src, 8); | |
25d2: 48 8b 10 mov (%rax),%rdx | |
25d5: 48 89 17 mov %rdx,(%rdi) | |
if (sequence.matchLength > 8) { | |
25d8: 49 83 fc 08 cmp $0x8,%r12 | |
25dc: 0f 86 6c fd ff ff jbe 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
*op += 8; | |
25e2: 48 8d 57 08 lea 0x8(%rdi),%rdx | |
*ip += 8; | |
25e6: 48 8d 48 08 lea 0x8(%rax),%rcx | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
25ea: 48 89 d6 mov %rdx,%rsi | |
25ed: 48 29 ce sub %rcx,%rsi | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
25f0: 48 83 fe 0f cmp $0xf,%rsi | |
25f4: 0f 8f 83 01 00 00 jg 277d <ZSTD_decompressSequences_bmi2.constprop.0+0x8fd> | |
25fa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 8); | |
2600: 48 8b 01 mov (%rcx),%rax | |
COPY8(op, ip) | |
2603: 48 83 c2 08 add $0x8,%rdx | |
2607: 48 83 c1 08 add $0x8,%rcx | |
ZSTD_memcpy(dst, src, 8); | |
260b: 48 89 42 f8 mov %rax,-0x8(%rdx) | |
} while (op < oend); | |
260f: 49 39 d5 cmp %rdx,%r13 | |
2612: 77 ec ja 2600 <ZSTD_decompressSequences_bmi2.constprop.0+0x780> | |
2614: e9 35 fd ff ff jmpq 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
2619: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
2620: 4c 8b 7c 24 48 mov 0x48(%rsp),%r15 | |
2625: 83 f8 40 cmp $0x40,%eax | |
2628: 77 2d ja 2657 <ZSTD_decompressSequences_bmi2.constprop.0+0x7d7> | |
if (bitD->ptr >= bitD->limitPtr) { | |
262a: 48 8b 94 24 90 00 00 mov 0x90(%rsp),%rdx | |
2631: 00 | |
2632: 48 3b 94 24 a0 00 00 cmp 0xa0(%rsp),%rdx | |
2639: 00 | |
263a: 0f 83 48 f9 ff ff jae 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
if (bitD->ptr == bitD->start) { | |
2640: 48 3b 94 24 98 00 00 cmp 0x98(%rsp),%rdx | |
2647: 00 | |
2648: 0f 85 3a f9 ff ff jne 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; | |
264e: 83 f8 40 cmp $0x40,%eax | |
2651: 0f 85 31 f9 ff ff jne 1f88 <ZSTD_decompressSequences_bmi2.constprop.0+0x108> | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
2657: 48 8b 84 24 d8 00 00 mov 0xd8(%rsp),%rax | |
265e: 00 | |
{ size_t const lastLLSize = litEnd - litPtr; | |
265f: 48 8b 74 24 58 mov 0x58(%rsp),%rsi | |
2664: 48 8b 6c 24 08 mov 0x8(%rsp),%rbp | |
2669: 48 8b 54 24 20 mov 0x20(%rsp),%rdx | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
266e: 41 89 87 3c 68 00 00 mov %eax,0x683c(%r15) | |
2675: 48 8b 84 24 e0 00 00 mov 0xe0(%rsp),%rax | |
267c: 00 | |
267d: 41 89 87 40 68 00 00 mov %eax,0x6840(%r15) | |
2684: 48 8b 84 24 e8 00 00 mov 0xe8(%rsp),%rax | |
268b: 00 | |
268c: 41 89 87 44 68 00 00 mov %eax,0x6844(%r15) | |
2693: e9 18 f9 ff ff jmpq 1fb0 <ZSTD_decompressSequences_bmi2.constprop.0+0x130> | |
2698: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
269f: 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
26a0: c4 e2 f9 f7 8c 24 80 shlx %rax,0x80(%rsp),%rcx | |
26a7: 00 00 00 | |
bitD->bitsConsumed += nbBits; | |
26aa: 83 c0 01 add $0x1,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
26ad: 48 c1 e9 3f shr $0x3f,%rcx | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
26b1: 83 fa 01 cmp $0x1,%edx | |
26b4: 41 83 d1 00 adc $0x0,%r9d | |
bitD->bitsConsumed += nbBits; | |
26b8: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
26bf: 4c 01 c9 add %r9,%rcx | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
26c2: 48 83 f9 03 cmp $0x3,%rcx | |
26c6: 74 7d je 2745 <ZSTD_decompressSequences_bmi2.constprop.0+0x8c5> | |
26c8: 4c 8b 8c cc d8 00 00 mov 0xd8(%rsp,%rcx,8),%r9 | |
26cf: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
26d0: 49 83 f9 01 cmp $0x1,%r9 | |
26d4: 49 83 d1 00 adc $0x0,%r9 | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
26d8: 48 83 f9 01 cmp $0x1,%rcx | |
26dc: 74 10 je 26ee <ZSTD_decompressSequences_bmi2.constprop.0+0x86e> | |
26de: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
26e5: 00 | |
26e6: 48 89 8c 24 e8 00 00 mov %rcx,0xe8(%rsp) | |
26ed: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
26ee: 48 89 ac 24 e0 00 00 mov %rbp,0xe0(%rsp) | |
26f5: 00 | |
seqState->prevOffset[0] = offset = temp; | |
26f6: 4c 89 cd mov %r9,%rbp | |
26f9: 4c 89 8c 24 d8 00 00 mov %r9,0xd8(%rsp) | |
2700: 00 | |
2701: e9 c4 fa ff ff jmpq 21ca <ZSTD_decompressSequences_bmi2.constprop.0+0x34a> | |
(*op)[0] = (*ip)[0]; | |
2706: 0f b6 10 movzbl (%rax),%edx | |
2709: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
270b: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
270f: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
2712: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
2716: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
2719: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
271d: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
2720: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 2727 <ZSTD_decompressSequences_bmi2.constprop.0+0x8a7> | |
2727: 8b 14 aa mov (%rdx,%rbp,4),%edx | |
272a: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
272d: 8b 10 mov (%rax),%edx | |
272f: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
2732: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 2739 <ZSTD_decompressSequences_bmi2.constprop.0+0x8b9> | |
2739: 48 63 14 aa movslq (%rdx,%rbp,4),%rdx | |
273d: 48 29 d0 sub %rdx,%rax | |
2740: e9 93 fe ff ff jmpq 25d8 <ZSTD_decompressSequences_bmi2.constprop.0+0x758> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
2745: 48 89 e9 mov %rbp,%rcx | |
2748: 45 31 c9 xor %r9d,%r9d | |
274b: 48 83 e9 01 sub $0x1,%rcx | |
274f: 41 0f 94 c1 sete %r9b | |
2753: 49 01 c9 add %rcx,%r9 | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
2756: eb 86 jmp 26de <ZSTD_decompressSequences_bmi2.constprop.0+0x85e> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
2758: 41 89 c1 mov %eax,%r9d | |
bitD->bitsConsumed &= 7; | |
275b: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
275e: 41 c1 e9 03 shr $0x3,%r9d | |
2762: 4c 29 c9 sub %r9,%rcx | |
2765: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp) | |
276c: 00 | |
276d: 48 8b 09 mov (%rcx),%rcx | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
2770: 48 89 8c 24 80 00 00 mov %rcx,0x80(%rsp) | |
2777: 00 | |
return BIT_reloadDStreamFast(bitD); | |
2778: e9 68 fa ff ff jmpq 21e5 <ZSTD_decompressSequences_bmi2.constprop.0+0x365> | |
ZSTD_memcpy(dst, src, 16); | |
277d: f3 0f 6f 70 08 movdqu 0x8(%rax),%xmm6 | |
2782: 0f 11 77 08 movups %xmm6,0x8(%rdi) | |
if (16 >= length) return; | |
2786: 49 83 fc 18 cmp $0x18,%r12 | |
278a: 0f 8e be fb ff ff jle 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
op += 16; | |
2790: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
2794: 48 83 c0 18 add $0x18,%rax | |
2798: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
279f: 00 | |
ZSTD_memcpy(dst, src, 16); | |
27a0: f3 0f 6f 38 movdqu (%rax),%xmm7 | |
27a4: 48 83 c7 20 add $0x20,%rdi | |
27a8: 48 83 c0 20 add $0x20,%rax | |
27ac: 0f 11 7f e0 movups %xmm7,-0x20(%rdi) | |
27b0: f3 0f 6f 78 f0 movdqu -0x10(%rax),%xmm7 | |
27b5: 0f 11 7f f0 movups %xmm7,-0x10(%rdi) | |
while (op < oend); | |
27b9: 49 39 fd cmp %rdi,%r13 | |
27bc: 77 e2 ja 27a0 <ZSTD_decompressSequences_bmi2.constprop.0+0x920> | |
27be: e9 8b fb ff ff jmpq 234e <ZSTD_decompressSequences_bmi2.constprop.0+0x4ce> | |
27c3: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
27ca: 00 00 00 00 | |
27ce: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
27d5: 00 00 00 00 | |
27d9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
00000000000027e0 <ZSTD_decompressSequences_default.constprop.0>: | |
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, | |
27e0: 41 57 push %r15 | |
BYTE* const oend = ostart + maxDstSize; | |
27e2: 48 01 f2 add %rsi,%rdx | |
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, | |
27e5: 41 56 push %r14 | |
27e7: 41 55 push %r13 | |
27e9: 41 54 push %r12 | |
27eb: 55 push %rbp | |
27ec: 53 push %rbx | |
27ed: 48 81 ec f8 00 00 00 sub $0xf8,%rsp | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
27f4: 48 8b 87 c0 75 00 00 mov 0x75c0(%rdi),%rax | |
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, | |
27fb: 48 89 74 24 10 mov %rsi,0x10(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
2800: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi | |
ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, | |
2807: 44 89 4c 24 1c mov %r9d,0x1c(%rsp) | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
280c: 48 01 f0 add %rsi,%rax | |
BYTE* const oend = ostart + maxDstSize; | |
280f: 48 89 54 24 20 mov %rdx,0x20(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
2814: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
2819: 48 89 44 24 08 mov %rax,0x8(%rsp) | |
if (nbSeq) { | |
281e: 45 85 c9 test %r9d,%r9d | |
2821: 0f 84 e1 00 00 00 je 2908 <ZSTD_decompressSequences_default.constprop.0+0x128> | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
2827: 48 8b 87 c8 74 00 00 mov 0x74c8(%rdi),%rax | |
282e: 49 89 ff mov %rdi,%r15 | |
dctx->fseEntropy = 1; | |
2831: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi) | |
2838: 00 00 00 | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
283b: 48 89 04 24 mov %rax,(%rsp) | |
const BYTE* const vBase = (const BYTE*) (dctx->virtualStart); | |
283f: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax | |
2846: 48 89 44 24 30 mov %rax,0x30(%rsp) | |
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); | |
284b: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax | |
2852: 48 89 44 24 38 mov %rax,0x38(%rsp) | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } | |
2857: 8b 87 3c 68 00 00 mov 0x683c(%rdi),%eax | |
285d: 48 89 84 24 d8 00 00 mov %rax,0xd8(%rsp) | |
2864: 00 | |
2865: 8b 87 40 68 00 00 mov 0x6840(%rdi),%eax | |
286b: 48 89 84 24 e0 00 00 mov %rax,0xe0(%rsp) | |
2872: 00 | |
2873: 8b 87 44 68 00 00 mov 0x6844(%rdi),%eax | |
2879: 48 89 84 24 e8 00 00 mov %rax,0xe8(%rsp) | |
2880: 00 | |
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } | |
2881: 4d 85 c0 test %r8,%r8 | |
2884: 74 62 je 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
2886: 48 8d 41 08 lea 0x8(%rcx),%rax | |
bitD->start = (const char*)srcBuffer; | |
288a: 48 89 8c 24 98 00 00 mov %rcx,0x98(%rsp) | |
2891: 00 | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
2892: 48 89 84 24 a0 00 00 mov %rax,0xa0(%rsp) | |
2899: 00 | |
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; | |
289a: 42 0f b6 44 01 ff movzbl -0x1(%rcx,%r8,1),%eax | |
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ | |
28a0: 49 83 f8 07 cmp $0x7,%r8 | |
28a4: 0f 86 96 00 00 00 jbe 2940 <ZSTD_decompressSequences_default.constprop.0+0x160> | |
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); | |
28aa: 4a 8d 54 01 f8 lea -0x8(%rcx,%r8,1),%rdx | |
28af: 48 89 94 24 90 00 00 mov %rdx,0x90(%rsp) | |
28b6: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
28b7: 48 8b 12 mov (%rdx),%rdx | |
28ba: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
28c1: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
28c2: 84 c0 test %al,%al | |
28c4: 74 22 je 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
return __builtin_clz (val) ^ 31; | |
28c6: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
28c9: ba 08 00 00 00 mov $0x8,%edx | |
28ce: 29 c2 sub %eax,%edx | |
28d0: 89 94 24 88 00 00 00 mov %edx,0x88(%rsp) | |
RETURN_ERROR_IF( | |
28d7: 49 83 f8 88 cmp $0xffffffffffffff88,%r8 | |
28db: 0f 86 eb 00 00 00 jbe 29cc <ZSTD_decompressSequences_default.constprop.0+0x1ec> | |
28e1: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
28e8: 49 c7 c5 ec ff ff ff mov $0xffffffffffffffec,%r13 | |
} | |
28ef: 48 81 c4 f8 00 00 00 add $0xf8,%rsp | |
28f6: 4c 89 e8 mov %r13,%rax | |
28f9: 5b pop %rbx | |
28fa: 5d pop %rbp | |
28fb: 41 5c pop %r12 | |
28fd: 41 5d pop %r13 | |
28ff: 41 5e pop %r14 | |
2901: 41 5f pop %r15 | |
2903: c3 retq | |
2904: 0f 1f 40 00 nopl 0x0(%rax) | |
BYTE* op = ostart; | |
2908: 48 8b 5c 24 10 mov 0x10(%rsp),%rbx | |
290d: 48 89 c5 mov %rax,%rbp | |
{ size_t const lastLLSize = litEnd - litPtr; | |
2910: 48 29 f5 sub %rsi,%rbp | |
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, ""); | |
2913: 48 29 da sub %rbx,%rdx | |
2916: 49 c7 c5 ba ff ff ff mov $0xffffffffffffffba,%r13 | |
291d: 48 39 d5 cmp %rdx,%rbp | |
2920: 77 cd ja 28ef <ZSTD_decompressSequences_default.constprop.0+0x10f> | |
if (op != NULL) { | |
2922: 48 85 db test %rbx,%rbx | |
2925: 74 0e je 2935 <ZSTD_decompressSequences_default.constprop.0+0x155> | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
2927: 48 89 df mov %rbx,%rdi | |
292a: 48 89 ea mov %rbp,%rdx | |
op += lastLLSize; | |
292d: 48 01 eb add %rbp,%rbx | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
2930: e8 00 00 00 00 callq 2935 <ZSTD_decompressSequences_default.constprop.0+0x155> | |
return op-ostart; | |
2935: 48 2b 5c 24 10 sub 0x10(%rsp),%rbx | |
293a: 49 89 dd mov %rbx,%r13 | |
293d: eb b0 jmp 28ef <ZSTD_decompressSequences_default.constprop.0+0x10f> | |
293f: 90 nop | |
bitD->ptr = bitD->start; | |
2940: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 2947 <ZSTD_decompressSequences_default.constprop.0+0x167> | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
2947: 0f b6 11 movzbl (%rcx),%edx | |
bitD->ptr = bitD->start; | |
294a: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp) | |
2951: 00 | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
2952: 4a 63 34 87 movslq (%rdi,%r8,4),%rsi | |
2956: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
295d: 00 | |
switch(srcSize) | |
295e: 48 01 fe add %rdi,%rsi | |
2961: ff e6 jmpq *%rsi | |
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); | |
2963: 0f b6 71 06 movzbl 0x6(%rcx),%esi | |
2967: 48 c1 e6 30 shl $0x30,%rsi | |
296b: 48 01 f2 add %rsi,%rdx | |
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); | |
296e: 0f b6 71 05 movzbl 0x5(%rcx),%esi | |
2972: 48 c1 e6 28 shl $0x28,%rsi | |
2976: 48 01 f2 add %rsi,%rdx | |
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); | |
2979: 0f b6 71 04 movzbl 0x4(%rcx),%esi | |
297d: 48 c1 e6 20 shl $0x20,%rsi | |
2981: 48 01 f2 add %rsi,%rdx | |
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; | |
2984: 0f b6 71 03 movzbl 0x3(%rcx),%esi | |
2988: 48 c1 e6 18 shl $0x18,%rsi | |
298c: 48 01 f2 add %rsi,%rdx | |
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; | |
298f: 0f b6 71 02 movzbl 0x2(%rcx),%esi | |
2993: 48 c1 e6 10 shl $0x10,%rsi | |
2997: 48 01 f2 add %rsi,%rdx | |
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; | |
299a: 0f b6 49 01 movzbl 0x1(%rcx),%ecx | |
299e: 48 c1 e1 08 shl $0x8,%rcx | |
29a2: 48 01 ca add %rcx,%rdx | |
29a5: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
29ac: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; | |
29ad: 84 c0 test %al,%al | |
29af: 0f 84 33 ff ff ff je 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
29b5: ba 09 00 00 00 mov $0x9,%edx | |
return __builtin_clz (val) ^ 31; | |
29ba: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
29bd: 44 29 c2 sub %r8d,%edx | |
29c0: c1 e2 03 shl $0x3,%edx | |
29c3: 29 c2 sub %eax,%edx | |
29c5: 89 94 24 88 00 00 00 mov %edx,0x88(%rsp) | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
29cc: 49 8b 17 mov (%r15),%rdx | |
29cf: 48 8d b4 24 80 00 00 lea 0x80(%rsp),%rsi | |
29d6: 00 | |
29d7: 48 8d bc 24 a8 00 00 lea 0xa8(%rsp),%rdi | |
29de: 00 | |
29df: e8 1c e0 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); | |
29e4: 49 8b 57 10 mov 0x10(%r15),%rdx | |
29e8: 48 8d bc 24 b8 00 00 lea 0xb8(%rsp),%rdi | |
29ef: 00 | |
29f0: e8 0b e0 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); | |
29f5: 49 8b 57 08 mov 0x8(%r15),%rdx | |
29f9: 48 8d bc 24 c8 00 00 lea 0xc8(%rsp),%rdi | |
2a00: 00 | |
2a01: e8 fa df ff ff callq a00 <ZSTD_initFseState> | |
__asm__(".p2align 6"); | |
2a06: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a0d: 00 00 00 00 | |
2a11: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a18: 00 00 00 00 | |
2a1c: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a23: 00 00 00 00 | |
2a27: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a2e: 00 00 00 00 | |
2a32: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a39: 00 00 00 00 | |
2a3d: 0f 1f 00 nopl (%rax) | |
__asm__("nop"); | |
2a40: 90 nop | |
__asm__(".p2align 5"); | |
2a41: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a48: 00 00 00 00 | |
2a4c: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
2a53: 00 00 00 00 | |
2a57: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
2a5e: 00 00 | |
__asm__("nop"); | |
2a60: 90 nop | |
__asm__(".p2align 3"); | |
2a61: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
2a68: 48 8b 44 24 20 mov 0x20(%rsp),%rax | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
2a6d: 48 8d 7c 24 58 lea 0x58(%rsp),%rdi | |
*ip += dec32table[offset]; | |
2a72: 4c 89 7c 24 48 mov %r15,0x48(%rsp) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
2a77: 48 89 7c 24 40 mov %rdi,0x40(%rsp) | |
BYTE* op = ostart; | |
2a7c: 48 8b 5c 24 10 mov 0x10(%rsp),%rbx | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
2a81: 48 83 e8 20 sub $0x20,%rax | |
2a85: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2a8a: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax | |
2a91: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2a98: 48 8b 8c 24 a8 00 00 mov 0xa8(%rsp),%rcx | |
2a9f: 00 | |
2aa0: 48 8b 94 24 b0 00 00 mov 0xb0(%rsp),%rdx | |
2aa7: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2aa8: 48 8b b4 24 c8 00 00 mov 0xc8(%rsp),%rsi | |
2aaf: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
2ab0: 48 8b ac 24 d8 00 00 mov 0xd8(%rsp),%rbp | |
2ab7: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2ab8: 4c 8d 0c ca lea (%rdx,%rcx,8),%r9 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2abc: 48 8b 8c 24 d0 00 00 mov 0xd0(%rsp),%rcx | |
2ac3: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
2ac4: 45 0f b6 59 02 movzbl 0x2(%r9),%r11d | |
2ac9: 41 8b 51 04 mov 0x4(%r9),%edx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2acd: 4c 8d 04 f1 lea (%rcx,%rsi,8),%r8 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
2ad1: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
2ad8: 00 | |
2ad9: 48 8b 8c 24 c0 00 00 mov 0xc0(%rsp),%rcx | |
2ae0: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
2ae1: 45 0f b6 68 02 movzbl 0x2(%r8),%r13d | |
2ae6: 45 8b 60 04 mov 0x4(%r8),%r12d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
2aea: 48 8d 3c f1 lea (%rcx,%rsi,8),%rdi | |
2aee: 0f b6 77 02 movzbl 0x2(%rdi),%esi | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
2af2: 47 8d 34 2b lea (%r11,%r13,1),%r14d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
2af6: 44 8b 57 04 mov 0x4(%rdi),%r10d | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
2afa: 41 01 f6 add %esi,%r14d | |
if (ofBits > 1) { | |
2afd: 40 80 fe 01 cmp $0x1,%sil | |
2b01: 0f 86 61 02 00 00 jbe 2d68 <ZSTD_decompressSequences_default.constprop.0+0x588> | |
2b07: 4c 8b bc 24 80 00 00 mov 0x80(%rsp),%r15 | |
2b0e: 00 | |
2b0f: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
2b11: 01 f0 add %esi,%eax | |
2b13: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2b1a: 49 d3 e7 shl %cl,%r15 | |
2b1d: 89 f1 mov %esi,%ecx | |
2b1f: f7 d9 neg %ecx | |
2b21: 49 d3 ef shr %cl,%r15 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
2b24: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
2b2b: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
2b2c: 48 89 ac 24 e0 00 00 mov %rbp,0xe0(%rsp) | |
2b33: 00 | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
2b34: 4d 01 d7 add %r10,%r15 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
2b37: 48 89 8c 24 e8 00 00 mov %rcx,0xe8(%rsp) | |
2b3e: 00 | |
seqState->prevOffset[0] = offset; | |
2b3f: 4c 89 fd mov %r15,%rbp | |
2b42: 4c 89 bc 24 d8 00 00 mov %r15,0xd8(%rsp) | |
2b49: 00 | |
if (mlBits > 0) | |
2b4a: 45 84 ed test %r13b,%r13b | |
2b4d: 0f 85 4d 02 00 00 jne 2da0 <ZSTD_decompressSequences_default.constprop.0+0x5c0> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
2b53: 41 80 fe 1e cmp $0x1e,%r14b | |
2b57: 0f 87 6f 02 00 00 ja 2dcc <ZSTD_decompressSequences_default.constprop.0+0x5ec> | |
2b5d: 48 8b b4 24 80 00 00 mov 0x80(%rsp),%rsi | |
2b64: 00 | |
if (llBits > 0) | |
2b65: 45 84 db test %r11b,%r11b | |
2b68: 0f 85 d2 02 00 00 jne 2e40 <ZSTD_decompressSequences_default.constprop.0+0x660> | |
U32 const nbBits = DInfo.nbBits; | |
2b6e: 45 0f b6 51 03 movzbl 0x3(%r9),%r10d | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2b73: 49 89 f7 mov %rsi,%r15 | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2b76: 45 0f b7 09 movzwl (%r9),%r9d | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
2b7a: 4e 8d 2c 22 lea (%rdx,%r12,1),%r13 | |
2b7e: 4c 8d 1d 00 00 00 00 lea 0x0(%rip),%r11 # 2b85 <ZSTD_decompressSequences_default.constprop.0+0x3a5> | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
2b85: 4e 8d 34 2b lea (%rbx,%r13,1),%r14 | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
2b89: 44 01 d0 add %r10d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2b8c: 89 c1 mov %eax,%ecx | |
2b8e: f7 d9 neg %ecx | |
2b90: 49 d3 ef shr %cl,%r15 | |
2b93: 4c 89 f9 mov %r15,%rcx | |
2b96: 43 23 0c 93 and (%r11,%r10,4),%ecx | |
2b9a: 49 89 f2 mov %rsi,%r10 | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2b9d: 4c 01 c9 add %r9,%rcx | |
2ba0: 48 89 8c 24 a8 00 00 mov %rcx,0xa8(%rsp) | |
2ba7: 00 | |
U32 const nbBits = DInfo.nbBits; | |
2ba8: 45 0f b6 48 03 movzbl 0x3(%r8),%r9d | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2bad: 45 0f b7 00 movzwl (%r8),%r8d | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
2bb1: 44 01 c8 add %r9d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2bb4: 89 c1 mov %eax,%ecx | |
2bb6: f7 d9 neg %ecx | |
2bb8: 49 d3 ea shr %cl,%r10 | |
2bbb: 4c 89 d1 mov %r10,%rcx | |
2bbe: 43 23 0c 8b and (%r11,%r9,4),%ecx | |
2bc2: 4c 01 c1 add %r8,%rcx | |
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state]; | |
2bc5: 44 0f b7 07 movzwl (%rdi),%r8d | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2bc9: 48 89 8c 24 c8 00 00 mov %rcx,0xc8(%rsp) | |
2bd0: 00 | |
U32 const nbBits = DInfo.nbBits; | |
2bd1: 0f b6 7f 03 movzbl 0x3(%rdi),%edi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
2bd5: 01 f8 add %edi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2bd7: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
2bd9: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
2be0: f7 d9 neg %ecx | |
2be2: 48 d3 ee shr %cl,%rsi | |
2be5: 48 89 f1 mov %rsi,%rcx | |
2be8: 41 23 0c bb and (%r11,%rdi,4),%ecx | |
BYTE* const oLitEnd = op + sequence.litLength; | |
2bec: 48 8d 3c 13 lea (%rbx,%rdx,1),%rdi | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2bf0: 4c 01 c1 add %r8,%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
2bf3: 48 89 f8 mov %rdi,%rax | |
DStatePtr->state = DInfo.nextState + lowBits; | |
2bf6: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp) | |
2bfd: 00 | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
2bfe: 48 8b 4c 24 58 mov 0x58(%rsp),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
2c03: 48 29 e8 sub %rbp,%rax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
2c06: 48 8d 34 11 lea (%rcx,%rdx,1),%rsi | |
if (UNLIKELY( | |
2c0a: 48 39 74 24 08 cmp %rsi,0x8(%rsp) | |
2c0f: 0f 82 8b 02 00 00 jb 2ea0 <ZSTD_decompressSequences_default.constprop.0+0x6c0> | |
2c15: 4c 3b 74 24 28 cmp 0x28(%rsp),%r14 | |
2c1a: 0f 87 80 02 00 00 ja 2ea0 <ZSTD_decompressSequences_default.constprop.0+0x6c0> | |
ZSTD_memcpy(dst, src, 16); | |
2c20: f3 0f 6f 19 movdqu (%rcx),%xmm3 | |
2c24: 0f 11 1b movups %xmm3,(%rbx) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
2c27: 48 83 fa 10 cmp $0x10,%rdx | |
2c2b: 0f 87 c7 02 00 00 ja 2ef8 <ZSTD_decompressSequences_default.constprop.0+0x718> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
2c31: 48 89 fa mov %rdi,%rdx | |
2c34: 48 2b 14 24 sub (%rsp),%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
2c38: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
2c3d: 48 39 d5 cmp %rdx,%rbp | |
2c40: 76 49 jbe 2c8b <ZSTD_decompressSequences_default.constprop.0+0x4ab> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
2c42: 48 89 fa mov %rdi,%rdx | |
2c45: 48 2b 54 24 30 sub 0x30(%rsp),%rdx | |
2c4a: 48 39 d5 cmp %rdx,%rbp | |
2c4d: 0f 87 95 fc ff ff ja 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
match = dictEnd + (match - prefixStart); | |
2c53: 48 8b 4c 24 38 mov 0x38(%rsp),%rcx | |
2c58: 48 89 c6 mov %rax,%rsi | |
2c5b: 48 2b 34 24 sub (%rsp),%rsi | |
2c5f: 48 01 ce add %rcx,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
2c62: 4a 8d 14 26 lea (%rsi,%r12,1),%rdx | |
2c66: 48 39 d1 cmp %rdx,%rcx | |
2c69: 0f 83 21 02 00 00 jae 2e90 <ZSTD_decompressSequences_default.constprop.0+0x6b0> | |
{ size_t const length1 = dictEnd - match; | |
2c6f: 4c 8b 3c 24 mov (%rsp),%r15 | |
2c73: 49 29 c7 sub %rax,%r15 | |
ZSTD_memmove(oLitEnd, match, length1); | |
2c76: 4c 89 fa mov %r15,%rdx | |
sequence.matchLength -= length1; | |
2c79: 4d 29 fc sub %r15,%r12 | |
ZSTD_memmove(oLitEnd, match, length1); | |
2c7c: e8 00 00 00 00 callq 2c81 <ZSTD_decompressSequences_default.constprop.0+0x4a1> | |
2c81: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
2c84: 48 8b 04 24 mov (%rsp),%rax | |
op = oLitEnd + length1; | |
2c88: 4c 01 ff add %r15,%rdi | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
2c8b: 48 83 fd 0f cmp $0xf,%rbp | |
2c8f: 0f 86 b3 02 00 00 jbe 2f48 <ZSTD_decompressSequences_default.constprop.0+0x768> | |
2c95: f3 0f 6f 20 movdqu (%rax),%xmm4 | |
2c99: 0f 11 27 movups %xmm4,(%rdi) | |
if (16 >= length) return; | |
2c9c: 49 83 fc 10 cmp $0x10,%r12 | |
2ca0: 7e 2c jle 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
op += 16; | |
2ca2: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
2ca6: 48 83 c0 10 add $0x10,%rax | |
2caa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 16); | |
2cb0: f3 0f 6f 08 movdqu (%rax),%xmm1 | |
2cb4: 48 83 c7 20 add $0x20,%rdi | |
2cb8: 48 83 c0 20 add $0x20,%rax | |
2cbc: 0f 11 4f e0 movups %xmm1,-0x20(%rdi) | |
2cc0: f3 0f 6f 50 f0 movdqu -0x10(%rax),%xmm2 | |
2cc5: 0f 11 57 f0 movups %xmm2,-0x10(%rdi) | |
while (op < oend); | |
2cc9: 49 39 fe cmp %rdi,%r14 | |
2ccc: 77 e2 ja 2cb0 <ZSTD_decompressSequences_default.constprop.0+0x4d0> | |
if (UNLIKELY(ZSTD_isError(oneSeqSize))) | |
2cce: 49 83 fd 88 cmp $0xffffffffffffff88,%r13 | |
2cd2: 0f 87 17 fc ff ff ja 28ef <ZSTD_decompressSequences_default.constprop.0+0x10f> | |
op += oneSeqSize; | |
2cd8: 4c 01 eb add %r13,%rbx | |
if (UNLIKELY(!--nbSeq)) | |
2cdb: 83 6c 24 1c 01 subl $0x1,0x1c(%rsp) | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
2ce0: 8b 84 24 88 00 00 00 mov 0x88(%rsp),%eax | |
2ce7: 0f 84 33 03 00 00 je 3020 <ZSTD_decompressSequences_default.constprop.0+0x840> | |
2ced: 83 f8 40 cmp $0x40,%eax | |
2cf0: 0f 87 a2 fd ff ff ja 2a98 <ZSTD_decompressSequences_default.constprop.0+0x2b8> | |
if (bitD->ptr >= bitD->limitPtr) { | |
2cf6: 48 8b 94 24 90 00 00 mov 0x90(%rsp),%rdx | |
2cfd: 00 | |
2cfe: 48 3b 94 24 a0 00 00 cmp 0xa0(%rsp),%rdx | |
2d05: 00 | |
2d06: 0f 83 54 01 00 00 jae 2e60 <ZSTD_decompressSequences_default.constprop.0+0x680> | |
if (bitD->ptr == bitD->start) { | |
2d0c: 48 8b bc 24 98 00 00 mov 0x98(%rsp),%rdi | |
2d13: 00 | |
2d14: 48 39 fa cmp %rdi,%rdx | |
2d17: 0f 84 7b fd ff ff je 2a98 <ZSTD_decompressSequences_default.constprop.0+0x2b8> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
2d1d: 89 c1 mov %eax,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
2d1f: 48 89 d6 mov %rdx,%rsi | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
2d22: c1 e9 03 shr $0x3,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
2d25: 41 89 c8 mov %ecx,%r8d | |
2d28: 4c 29 c6 sub %r8,%rsi | |
2d2b: 48 39 f7 cmp %rsi,%rdi | |
2d2e: 76 10 jbe 2d40 <ZSTD_decompressSequences_default.constprop.0+0x560> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
2d30: 48 89 d6 mov %rdx,%rsi | |
2d33: 48 29 fe sub %rdi,%rsi | |
bitD->ptr -= nbBytes; | |
2d36: 89 f7 mov %esi,%edi | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
2d38: 89 f1 mov %esi,%ecx | |
bitD->ptr -= nbBytes; | |
2d3a: 48 29 fa sub %rdi,%rdx | |
2d3d: 48 89 d6 mov %rdx,%rsi | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
2d40: 48 8b 16 mov (%rsi),%rdx | |
bitD->bitsConsumed -= nbBytes*8; | |
2d43: c1 e1 03 shl $0x3,%ecx | |
bitD->ptr -= nbBytes; | |
2d46: 48 89 b4 24 90 00 00 mov %rsi,0x90(%rsp) | |
2d4d: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
2d4e: 29 c8 sub %ecx,%eax | |
2d50: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
2d57: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
2d5e: 00 | |
return result; | |
2d5f: e9 34 fd ff ff jmpq 2a98 <ZSTD_decompressSequences_default.constprop.0+0x2b8> | |
2d64: 0f 1f 40 00 nopl 0x0(%rax) | |
if (LIKELY((ofBits == 0))) { | |
2d68: 0f 84 32 03 00 00 je 30a0 <ZSTD_decompressSequences_default.constprop.0+0x8c0> | |
if (LIKELY(!ll0)) | |
2d6e: 85 d2 test %edx,%edx | |
2d70: 0f 85 d4 fd ff ff jne 2b4a <ZSTD_decompressSequences_default.constprop.0+0x36a> | |
offset = seqState->prevOffset[1]; | |
2d76: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
2d7d: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
2d7e: 48 89 ac 24 e0 00 00 mov %rbp,0xe0(%rsp) | |
2d85: 00 | |
seqState->prevOffset[0] = offset; | |
2d86: 48 89 8c 24 d8 00 00 mov %rcx,0xd8(%rsp) | |
2d8d: 00 | |
offset = seqState->prevOffset[1]; | |
2d8e: 48 89 cd mov %rcx,%rbp | |
2d91: e9 b4 fd ff ff jmpq 2b4a <ZSTD_decompressSequences_default.constprop.0+0x36a> | |
2d96: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
2d9d: 00 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2da0: 48 8b b4 24 80 00 00 mov 0x80(%rsp),%rsi | |
2da7: 00 | |
2da8: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
2daa: 44 01 e8 add %r13d,%eax | |
2dad: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2db4: 48 d3 e6 shl %cl,%rsi | |
2db7: 44 89 e9 mov %r13d,%ecx | |
2dba: f7 d9 neg %ecx | |
2dbc: 48 d3 ee shr %cl,%rsi | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
2dbf: 49 01 f4 add %rsi,%r12 | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
2dc2: 41 80 fe 1e cmp $0x1e,%r14b | |
2dc6: 0f 86 91 fd ff ff jbe 2b5d <ZSTD_decompressSequences_default.constprop.0+0x37d> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
2dcc: 83 f8 40 cmp $0x40,%eax | |
2dcf: 0f 87 88 fd ff ff ja 2b5d <ZSTD_decompressSequences_default.constprop.0+0x37d> | |
if (bitD->ptr >= bitD->limitPtr) { | |
2dd5: 48 8b 8c 24 90 00 00 mov 0x90(%rsp),%rcx | |
2ddc: 00 | |
2ddd: 48 3b 8c 24 a0 00 00 cmp 0xa0(%rsp),%rcx | |
2de4: 00 | |
2de5: 0f 83 a2 03 00 00 jae 318d <ZSTD_decompressSequences_default.constprop.0+0x9ad> | |
if (bitD->ptr == bitD->start) { | |
2deb: 4c 8b ac 24 98 00 00 mov 0x98(%rsp),%r13 | |
2df2: 00 | |
2df3: 4c 39 e9 cmp %r13,%rcx | |
2df6: 0f 84 61 fd ff ff je 2b5d <ZSTD_decompressSequences_default.constprop.0+0x37d> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
2dfc: 89 c6 mov %eax,%esi | |
if (bitD->ptr - nbBytes < bitD->start) { | |
2dfe: 49 89 ca mov %rcx,%r10 | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
2e01: c1 ee 03 shr $0x3,%esi | |
if (bitD->ptr - nbBytes < bitD->start) { | |
2e04: 41 89 f6 mov %esi,%r14d | |
2e07: 4d 29 f2 sub %r14,%r10 | |
2e0a: 4d 39 d5 cmp %r10,%r13 | |
2e0d: 76 12 jbe 2e21 <ZSTD_decompressSequences_default.constprop.0+0x641> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
2e0f: 49 89 ca mov %rcx,%r10 | |
2e12: 4d 29 ea sub %r13,%r10 | |
bitD->ptr -= nbBytes; | |
2e15: 45 89 d5 mov %r10d,%r13d | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
2e18: 44 89 d6 mov %r10d,%esi | |
bitD->ptr -= nbBytes; | |
2e1b: 4c 29 e9 sub %r13,%rcx | |
2e1e: 49 89 ca mov %rcx,%r10 | |
bitD->bitsConsumed -= nbBytes*8; | |
2e21: c1 e6 03 shl $0x3,%esi | |
bitD->ptr -= nbBytes; | |
2e24: 4c 89 94 24 90 00 00 mov %r10,0x90(%rsp) | |
2e2b: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
2e2c: 29 f0 sub %esi,%eax | |
2e2e: 49 8b 32 mov (%r10),%rsi | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
2e31: 48 89 b4 24 80 00 00 mov %rsi,0x80(%rsp) | |
2e38: 00 | |
return result; | |
2e39: e9 27 fd ff ff jmpq 2b65 <ZSTD_decompressSequences_default.constprop.0+0x385> | |
2e3e: 66 90 xchg %ax,%ax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2e40: 89 c1 mov %eax,%ecx | |
2e42: 49 89 f2 mov %rsi,%r10 | |
bitD->bitsConsumed += nbBits; | |
2e45: 44 01 d8 add %r11d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
2e48: 49 d3 e2 shl %cl,%r10 | |
2e4b: 44 89 d9 mov %r11d,%ecx | |
2e4e: f7 d9 neg %ecx | |
2e50: 49 d3 ea shr %cl,%r10 | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
2e53: 4c 01 d2 add %r10,%rdx | |
2e56: e9 13 fd ff ff jmpq 2b6e <ZSTD_decompressSequences_default.constprop.0+0x38e> | |
2e5b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
2e60: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed &= 7; | |
2e62: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
2e65: c1 e9 03 shr $0x3,%ecx | |
bitD->bitsConsumed &= 7; | |
2e68: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
2e6f: 48 29 ca sub %rcx,%rdx | |
2e72: 48 89 94 24 90 00 00 mov %rdx,0x90(%rsp) | |
2e79: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
2e7a: 48 8b 12 mov (%rdx),%rdx | |
2e7d: 48 89 94 24 80 00 00 mov %rdx,0x80(%rsp) | |
2e84: 00 | |
return BIT_reloadDStreamFast(bitD); | |
2e85: e9 0e fc ff ff jmpq 2a98 <ZSTD_decompressSequences_default.constprop.0+0x2b8> | |
2e8a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
2e90: 4c 89 e2 mov %r12,%rdx | |
2e93: e8 00 00 00 00 callq 2e98 <ZSTD_decompressSequences_default.constprop.0+0x6b8> | |
return sequenceLength; | |
2e98: e9 31 fe ff ff jmpq 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
2e9d: 0f 1f 00 nopl (%rax) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
2ea0: 66 48 0f 6e c2 movq %rdx,%xmm0 | |
2ea5: 66 49 0f 6e fc movq %r12,%xmm7 | |
2eaa: 48 89 6c 24 70 mov %rbp,0x70(%rsp) | |
2eaf: 48 89 df mov %rbx,%rdi | |
2eb2: 66 0f 6c c7 punpcklqdq %xmm7,%xmm0 | |
2eb6: 0f 29 44 24 60 movaps %xmm0,0x60(%rsp) | |
2ebb: ff 74 24 38 pushq 0x38(%rsp) | |
2ebf: ff 74 24 78 pushq 0x78(%rsp) | |
2ec3: ff 74 24 78 pushq 0x78(%rsp) | |
2ec7: ff 74 24 78 pushq 0x78(%rsp) | |
2ecb: 4c 8b 4c 24 50 mov 0x50(%rsp),%r9 | |
2ed0: 4c 8b 44 24 20 mov 0x20(%rsp),%r8 | |
2ed5: 48 8b 4c 24 28 mov 0x28(%rsp),%rcx | |
2eda: 48 8b 54 24 60 mov 0x60(%rsp),%rdx | |
2edf: 48 8b 74 24 40 mov 0x40(%rsp),%rsi | |
2ee4: e8 d7 d6 ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
2ee9: 48 83 c4 20 add $0x20,%rsp | |
2eed: 49 89 c5 mov %rax,%r13 | |
2ef0: e9 d9 fd ff ff jmpq 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
2ef5: 0f 1f 00 nopl (%rax) | |
ZSTD_memcpy(dst, src, 16); | |
2ef8: f3 0f 6f 79 10 movdqu 0x10(%rcx),%xmm7 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
2efd: 48 83 ea 10 sub $0x10,%rdx | |
2f01: 0f 11 7b 10 movups %xmm7,0x10(%rbx) | |
if (16 >= length) return; | |
2f05: 48 83 fa 10 cmp $0x10,%rdx | |
2f09: 0f 8e 22 fd ff ff jle 2c31 <ZSTD_decompressSequences_default.constprop.0+0x451> | |
op += 16; | |
2f0f: 48 8d 53 20 lea 0x20(%rbx),%rdx | |
ip += 16; | |
2f13: 48 83 c1 20 add $0x20,%rcx | |
2f17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
2f1e: 00 00 | |
ZSTD_memcpy(dst, src, 16); | |
2f20: f3 0f 6f 29 movdqu (%rcx),%xmm5 | |
2f24: 48 83 c2 20 add $0x20,%rdx | |
2f28: 48 83 c1 20 add $0x20,%rcx | |
2f2c: 0f 11 6a e0 movups %xmm5,-0x20(%rdx) | |
2f30: f3 0f 6f 71 f0 movdqu -0x10(%rcx),%xmm6 | |
2f35: 0f 11 72 f0 movups %xmm6,-0x10(%rdx) | |
while (op < oend); | |
2f39: 48 39 d7 cmp %rdx,%rdi | |
2f3c: 77 e2 ja 2f20 <ZSTD_decompressSequences_default.constprop.0+0x740> | |
2f3e: e9 ee fc ff ff jmpq 2c31 <ZSTD_decompressSequences_default.constprop.0+0x451> | |
2f43: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
if (offset < 8) { | |
2f48: 48 83 fd 07 cmp $0x7,%rbp | |
2f4c: 0f 86 e7 01 00 00 jbe 3139 <ZSTD_decompressSequences_default.constprop.0+0x959> | |
ZSTD_memcpy(dst, src, 8); | |
2f52: 48 8b 10 mov (%rax),%rdx | |
2f55: 48 89 17 mov %rdx,(%rdi) | |
if (sequence.matchLength > 8) { | |
2f58: 49 83 fc 08 cmp $0x8,%r12 | |
2f5c: 0f 86 6c fd ff ff jbe 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
*op += 8; | |
2f62: 48 8d 4f 08 lea 0x8(%rdi),%rcx | |
*ip += 8; | |
2f66: 48 8d 70 08 lea 0x8(%rax),%rsi | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
2f6a: 48 89 ca mov %rcx,%rdx | |
2f6d: 48 29 f2 sub %rsi,%rdx | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
2f70: 48 83 fa 0f cmp $0xf,%rdx | |
2f74: 0f 8f 36 02 00 00 jg 31b0 <ZSTD_decompressSequences_default.constprop.0+0x9d0> | |
2f7a: 49 89 c8 mov %rcx,%r8 | |
2f7d: 49 8d 56 f7 lea -0x9(%r14),%rdx | |
2f81: 4c 8d 4f 09 lea 0x9(%rdi),%r9 | |
2f85: 49 29 c0 sub %rax,%r8 | |
2f88: 48 29 fa sub %rdi,%rdx | |
2f8b: 49 83 e8 09 sub $0x9,%r8 | |
2f8f: 49 83 f8 0e cmp $0xe,%r8 | |
2f93: 0f 86 87 01 00 00 jbe 3120 <ZSTD_decompressSequences_default.constprop.0+0x940> | |
2f99: 48 83 fa 1f cmp $0x1f,%rdx | |
2f9d: 41 0f 97 c2 seta %r10b | |
2fa1: 4d 39 f1 cmp %r14,%r9 | |
2fa4: 41 0f 96 c0 setbe %r8b | |
2fa8: 45 84 c2 test %r8b,%r10b | |
2fab: 0f 84 6f 01 00 00 je 3120 <ZSTD_decompressSequences_default.constprop.0+0x940> | |
2fb1: 48 c1 ea 03 shr $0x3,%rdx | |
2fb5: 4d 39 f1 cmp %r14,%r9 | |
2fb8: 4c 8d 42 01 lea 0x1(%rdx),%r8 | |
2fbc: ba 01 00 00 00 mov $0x1,%edx | |
2fc1: 4c 0f 47 c2 cmova %rdx,%r8 | |
2fc5: ba 08 00 00 00 mov $0x8,%edx | |
2fca: 4d 89 c1 mov %r8,%r9 | |
2fcd: 49 d1 e9 shr %r9 | |
2fd0: 49 c1 e1 04 shl $0x4,%r9 | |
2fd4: 49 83 c1 08 add $0x8,%r9 | |
2fd8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
2fdf: 00 | |
ZSTD_memcpy(dst, src, 8); | |
2fe0: f3 0f 6f 3c 10 movdqu (%rax,%rdx,1),%xmm7 | |
2fe5: 0f 11 3c 17 movups %xmm7,(%rdi,%rdx,1) | |
} while (op < oend); | |
2fe9: 48 83 c2 10 add $0x10,%rdx | |
2fed: 4c 39 ca cmp %r9,%rdx | |
2ff0: 75 ee jne 2fe0 <ZSTD_decompressSequences_default.constprop.0+0x800> | |
2ff2: 4c 89 c0 mov %r8,%rax | |
2ff5: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
2ff9: 48 8d 14 c5 00 00 00 lea 0x0(,%rax,8),%rdx | |
3000: 00 | |
3001: 48 01 d6 add %rdx,%rsi | |
3004: 48 01 d1 add %rdx,%rcx | |
3007: 4c 39 c0 cmp %r8,%rax | |
300a: 0f 84 be fc ff ff je 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
ZSTD_memcpy(dst, src, 8); | |
3010: 48 8b 06 mov (%rsi),%rax | |
3013: 48 89 01 mov %rax,(%rcx) | |
} while (op < oend); | |
3016: e9 b3 fc ff ff jmpq 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
301b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
3020: 4c 8b 7c 24 48 mov 0x48(%rsp),%r15 | |
3025: 83 f8 40 cmp $0x40,%eax | |
3028: 77 2d ja 3057 <ZSTD_decompressSequences_default.constprop.0+0x877> | |
if (bitD->ptr >= bitD->limitPtr) { | |
302a: 48 8b 94 24 90 00 00 mov 0x90(%rsp),%rdx | |
3031: 00 | |
3032: 48 3b 94 24 a0 00 00 cmp 0xa0(%rsp),%rdx | |
3039: 00 | |
303a: 0f 83 a8 f8 ff ff jae 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
if (bitD->ptr == bitD->start) { | |
3040: 48 3b 94 24 98 00 00 cmp 0x98(%rsp),%rdx | |
3047: 00 | |
3048: 0f 85 9a f8 ff ff jne 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; | |
304e: 83 f8 40 cmp $0x40,%eax | |
3051: 0f 85 91 f8 ff ff jne 28e8 <ZSTD_decompressSequences_default.constprop.0+0x108> | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
3057: 48 8b 84 24 d8 00 00 mov 0xd8(%rsp),%rax | |
305e: 00 | |
{ size_t const lastLLSize = litEnd - litPtr; | |
305f: 48 8b 74 24 58 mov 0x58(%rsp),%rsi | |
3064: 48 8b 6c 24 08 mov 0x8(%rsp),%rbp | |
3069: 48 8b 54 24 20 mov 0x20(%rsp),%rdx | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
306e: 41 89 87 3c 68 00 00 mov %eax,0x683c(%r15) | |
3075: 48 8b 84 24 e0 00 00 mov 0xe0(%rsp),%rax | |
307c: 00 | |
307d: 41 89 87 40 68 00 00 mov %eax,0x6840(%r15) | |
3084: 48 8b 84 24 e8 00 00 mov 0xe8(%rsp),%rax | |
308b: 00 | |
308c: 41 89 87 44 68 00 00 mov %eax,0x6844(%r15) | |
3093: e9 78 f8 ff ff jmpq 2910 <ZSTD_decompressSequences_default.constprop.0+0x130> | |
3098: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
309f: 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
30a0: 48 8b b4 24 80 00 00 mov 0x80(%rsp),%rsi | |
30a7: 00 | |
30a8: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed += nbBits; | |
30aa: 83 c0 01 add $0x1,%eax | |
30ad: 89 84 24 88 00 00 00 mov %eax,0x88(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
30b4: 48 d3 e6 shl %cl,%rsi | |
30b7: 48 89 f1 mov %rsi,%rcx | |
30ba: 48 c1 e9 3f shr $0x3f,%rcx | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
30be: 83 fa 01 cmp $0x1,%edx | |
30c1: 41 83 d2 00 adc $0x0,%r10d | |
30c5: 44 89 d6 mov %r10d,%esi | |
30c8: 48 01 f1 add %rsi,%rcx | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
30cb: 48 83 f9 03 cmp $0x3,%rcx | |
30cf: 0f 84 a3 00 00 00 je 3178 <ZSTD_decompressSequences_default.constprop.0+0x998> | |
30d5: 48 8b b4 cc d8 00 00 mov 0xd8(%rsp,%rcx,8),%rsi | |
30dc: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
30dd: 48 83 fe 01 cmp $0x1,%rsi | |
30e1: 48 83 d6 00 adc $0x0,%rsi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
30e5: 48 83 f9 01 cmp $0x1,%rcx | |
30e9: 74 10 je 30fb <ZSTD_decompressSequences_default.constprop.0+0x91b> | |
30eb: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx | |
30f2: 00 | |
30f3: 48 89 8c 24 e8 00 00 mov %rcx,0xe8(%rsp) | |
30fa: 00 | |
seqState->prevOffset[0] = offset = temp; | |
30fb: 66 48 0f 6e fd movq %rbp,%xmm7 | |
3100: 66 48 0f 6e c6 movq %rsi,%xmm0 | |
3105: 48 89 f5 mov %rsi,%rbp | |
3108: 66 0f 6c c7 punpcklqdq %xmm7,%xmm0 | |
310c: 0f 11 84 24 d8 00 00 movups %xmm0,0xd8(%rsp) | |
3113: 00 | |
3114: e9 31 fa ff ff jmpq 2b4a <ZSTD_decompressSequences_default.constprop.0+0x36a> | |
3119: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 8); | |
3120: 48 8b 06 mov (%rsi),%rax | |
COPY8(op, ip) | |
3123: 48 83 c1 08 add $0x8,%rcx | |
3127: 48 83 c6 08 add $0x8,%rsi | |
ZSTD_memcpy(dst, src, 8); | |
312b: 48 89 41 f8 mov %rax,-0x8(%rcx) | |
} while (op < oend); | |
312f: 49 39 ce cmp %rcx,%r14 | |
3132: 77 ec ja 3120 <ZSTD_decompressSequences_default.constprop.0+0x940> | |
3134: e9 95 fb ff ff jmpq 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
(*op)[0] = (*ip)[0]; | |
3139: 0f b6 10 movzbl (%rax),%edx | |
313c: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
313e: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
3142: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
3145: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
3149: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
314c: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
3150: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
3153: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 315a <ZSTD_decompressSequences_default.constprop.0+0x97a> | |
315a: 8b 14 aa mov (%rdx,%rbp,4),%edx | |
315d: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
3160: 8b 10 mov (%rax),%edx | |
3162: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
3165: 48 8d 15 00 00 00 00 lea 0x0(%rip),%rdx # 316c <ZSTD_decompressSequences_default.constprop.0+0x98c> | |
316c: 48 63 14 aa movslq (%rdx,%rbp,4),%rdx | |
3170: 48 29 d0 sub %rdx,%rax | |
3173: e9 e0 fd ff ff jmpq 2f58 <ZSTD_decompressSequences_default.constprop.0+0x778> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
3178: 48 89 e9 mov %rbp,%rcx | |
317b: 31 f6 xor %esi,%esi | |
317d: 48 83 e9 01 sub $0x1,%rcx | |
3181: 40 0f 94 c6 sete %sil | |
3185: 48 01 ce add %rcx,%rsi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
3188: e9 5e ff ff ff jmpq 30eb <ZSTD_decompressSequences_default.constprop.0+0x90b> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
318d: 89 c6 mov %eax,%esi | |
bitD->bitsConsumed &= 7; | |
318f: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
3192: c1 ee 03 shr $0x3,%esi | |
3195: 48 29 f1 sub %rsi,%rcx | |
3198: 48 8b 31 mov (%rcx),%rsi | |
319b: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp) | |
31a2: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
31a3: 48 89 b4 24 80 00 00 mov %rsi,0x80(%rsp) | |
31aa: 00 | |
return BIT_reloadDStreamFast(bitD); | |
31ab: e9 b5 f9 ff ff jmpq 2b65 <ZSTD_decompressSequences_default.constprop.0+0x385> | |
ZSTD_memcpy(dst, src, 16); | |
31b0: f3 0f 6f 40 08 movdqu 0x8(%rax),%xmm0 | |
31b5: 0f 11 47 08 movups %xmm0,0x8(%rdi) | |
if (16 >= length) return; | |
31b9: 49 83 fc 18 cmp $0x18,%r12 | |
31bd: 0f 8e 0b fb ff ff jle 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
op += 16; | |
31c3: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
31c7: 48 83 c0 18 add $0x18,%rax | |
31cb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 16); | |
31d0: f3 0f 6f 38 movdqu (%rax),%xmm7 | |
31d4: 48 83 c7 20 add $0x20,%rdi | |
31d8: 48 83 c0 20 add $0x20,%rax | |
31dc: 0f 11 7f e0 movups %xmm7,-0x20(%rdi) | |
31e0: f3 0f 6f 78 f0 movdqu -0x10(%rax),%xmm7 | |
31e5: 0f 11 7f f0 movups %xmm7,-0x10(%rdi) | |
while (op < oend); | |
31e9: 49 39 fe cmp %rdi,%r14 | |
31ec: 77 e2 ja 31d0 <ZSTD_decompressSequences_default.constprop.0+0x9f0> | |
31ee: e9 db fa ff ff jmpq 2cce <ZSTD_decompressSequences_default.constprop.0+0x4ee> | |
31f3: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
31fa: 00 00 00 00 | |
31fe: 66 90 xchg %ax,%ax | |
0000000000003200 <ZSTD_decompressSequencesLong_bmi2.constprop.0>: | |
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */ | |
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT | |
static TARGET_ATTRIBUTE("bmi2") size_t | |
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, | |
3200: 41 57 push %r15 | |
BYTE* const oend = ostart + maxDstSize; | |
3202: 48 01 f2 add %rsi,%rdx | |
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, | |
3205: 41 56 push %r14 | |
3207: 41 55 push %r13 | |
3209: 41 54 push %r12 | |
320b: 55 push %rbp | |
320c: 53 push %rbx | |
320d: 48 81 ec 38 02 00 00 sub $0x238,%rsp | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
3214: 48 8b 87 c0 75 00 00 mov 0x75c0(%rdi),%rax | |
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, | |
321b: 48 89 74 24 58 mov %rsi,0x58(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
3220: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi | |
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, | |
3227: 48 89 bc 24 88 00 00 mov %rdi,0x88(%rsp) | |
322e: 00 | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
322f: 48 01 f0 add %rsi,%rax | |
ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, | |
3232: 44 89 8c 24 a0 00 00 mov %r9d,0xa0(%rsp) | |
3239: 00 | |
BYTE* const oend = ostart + maxDstSize; | |
323a: 48 89 54 24 78 mov %rdx,0x78(%rsp) | |
const BYTE* litPtr = dctx->litPtr; | |
323f: 48 89 b4 24 b8 00 00 mov %rsi,0xb8(%rsp) | |
3246: 00 | |
const BYTE* const litEnd = litPtr + dctx->litSize; | |
3247: 48 89 44 24 40 mov %rax,0x40(%rsp) | |
if (nbSeq) { | |
324c: 45 85 c9 test %r9d,%r9d | |
324f: 0f 84 cb 00 00 00 je 3320 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x120> | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
3255: 48 8b 87 c8 74 00 00 mov 0x74c8(%rdi),%rax | |
dctx->fseEntropy = 1; | |
325c: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi) | |
3263: 00 00 00 | |
const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); | |
3266: 48 89 44 24 18 mov %rax,0x18(%rsp) | |
const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart); | |
326b: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax | |
3272: 48 89 84 24 90 00 00 mov %rax,0x90(%rsp) | |
3279: 00 | |
const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); | |
327a: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax | |
3281: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } | |
3286: 8b 87 3c 68 00 00 mov 0x683c(%rdi),%eax | |
328c: 48 89 84 24 58 01 00 mov %rax,0x158(%rsp) | |
3293: 00 | |
3294: 8b 87 40 68 00 00 mov 0x6840(%rdi),%eax | |
329a: 48 89 84 24 60 01 00 mov %rax,0x160(%rsp) | |
32a1: 00 | |
32a2: 8b 87 44 68 00 00 mov 0x6844(%rdi),%eax | |
32a8: 48 89 84 24 68 01 00 mov %rax,0x168(%rsp) | |
32af: 00 | |
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } | |
32b0: 4d 85 c0 test %r8,%r8 | |
32b3: 74 4b je 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
32b5: 48 8d 41 08 lea 0x8(%rcx),%rax | |
bitD->start = (const char*)srcBuffer; | |
32b9: 48 89 8c 24 18 01 00 mov %rcx,0x118(%rsp) | |
32c0: 00 | |
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer); | |
32c1: 48 89 84 24 20 01 00 mov %rax,0x120(%rsp) | |
32c8: 00 | |
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; | |
32c9: 42 0f b6 44 01 ff movzbl -0x1(%rcx,%r8,1),%eax | |
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */ | |
32cf: 49 83 f8 07 cmp $0x7,%r8 | |
32d3: 0f 86 87 00 00 00 jbe 3360 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x160> | |
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); | |
32d9: 4a 8d 54 01 f8 lea -0x8(%rcx,%r8,1),%rdx | |
32de: 48 89 94 24 10 01 00 mov %rdx,0x110(%rsp) | |
32e5: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
32e6: 48 8b 12 mov (%rdx),%rdx | |
32e9: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
32f0: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
32f1: 84 c0 test %al,%al | |
32f3: 0f 85 2f 04 00 00 jne 3728 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x528> | |
32f9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF( | |
3300: 49 c7 c5 ec ff ff ff mov $0xffffffffffffffec,%r13 | |
const void* seqStart, size_t seqSize, int nbSeq, | |
const ZSTD_longOffset_e isLongOffset, | |
const int frame) | |
{ | |
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
} | |
3307: 48 81 c4 38 02 00 00 add $0x238,%rsp | |
330e: 4c 89 e8 mov %r13,%rax | |
3311: 5b pop %rbx | |
3312: 5d pop %rbp | |
3313: 41 5c pop %r12 | |
3315: 41 5d pop %r13 | |
3317: 41 5e pop %r14 | |
3319: 41 5f pop %r15 | |
331b: c3 retq | |
331c: 0f 1f 40 00 nopl 0x0(%rax) | |
BYTE* op = ostart; | |
3320: 4c 8b 54 24 58 mov 0x58(%rsp),%r10 | |
3325: 48 89 c3 mov %rax,%rbx | |
{ size_t const lastLLSize = litEnd - litPtr; | |
3328: 48 29 f3 sub %rsi,%rbx | |
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, ""); | |
332b: 4c 29 d2 sub %r10,%rdx | |
332e: 49 c7 c5 ba ff ff ff mov $0xffffffffffffffba,%r13 | |
3335: 48 39 d3 cmp %rdx,%rbx | |
3338: 77 cd ja 3307 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x107> | |
if (op != NULL) { | |
333a: 4d 85 d2 test %r10,%r10 | |
333d: 74 11 je 3350 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x150> | |
ZSTD_memcpy(op, litPtr, lastLLSize); | |
333f: 4c 89 d7 mov %r10,%rdi | |
3342: 48 89 da mov %rbx,%rdx | |
3345: e8 00 00 00 00 callq 334a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x14a> | |
334a: 49 89 c2 mov %rax,%r10 | |
op += lastLLSize; | |
334d: 49 01 da add %rbx,%r10 | |
return op-ostart; | |
3350: 4c 2b 54 24 58 sub 0x58(%rsp),%r10 | |
3355: 4d 89 d5 mov %r10,%r13 | |
3358: eb ad jmp 3307 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x107> | |
335a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
bitD->ptr = bitD->start; | |
3360: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 3367 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x167> | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
3367: 0f b6 11 movzbl (%rcx),%edx | |
bitD->ptr = bitD->start; | |
336a: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp) | |
3371: 00 | |
bitD->bitContainer = *(const BYTE*)(bitD->start); | |
3372: 4a 63 34 87 movslq (%rdi,%r8,4),%rsi | |
3376: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
337d: 00 | |
switch(srcSize) | |
337e: 48 01 fe add %rdi,%rsi | |
3381: ff e6 jmpq *%rsi | |
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); | |
3383: 0f b6 71 06 movzbl 0x6(%rcx),%esi | |
3387: 48 c1 e6 30 shl $0x30,%rsi | |
338b: 48 01 f2 add %rsi,%rdx | |
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); | |
338e: 0f b6 71 05 movzbl 0x5(%rcx),%esi | |
3392: 48 c1 e6 28 shl $0x28,%rsi | |
3396: 48 01 f2 add %rsi,%rdx | |
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); | |
3399: 0f b6 71 04 movzbl 0x4(%rcx),%esi | |
339d: 48 c1 e6 20 shl $0x20,%rsi | |
33a1: 48 01 f2 add %rsi,%rdx | |
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; | |
33a4: 0f b6 71 03 movzbl 0x3(%rcx),%esi | |
33a8: 48 c1 e6 18 shl $0x18,%rsi | |
33ac: 48 01 f2 add %rsi,%rdx | |
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; | |
33af: 0f b6 71 02 movzbl 0x2(%rcx),%esi | |
33b3: 48 c1 e6 10 shl $0x10,%rsi | |
33b7: 48 01 f2 add %rsi,%rdx | |
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8; | |
33ba: 0f b6 49 01 movzbl 0x1(%rcx),%ecx | |
33be: 48 c1 e1 08 shl $0x8,%rcx | |
33c2: 48 01 ca add %rcx,%rdx | |
33c5: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
33cc: 00 | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; | |
33cd: 84 c0 test %al,%al | |
33cf: 0f 84 2b ff ff ff je 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
33d5: ba 09 00 00 00 mov $0x9,%edx | |
return __builtin_clz (val) ^ 31; | |
33da: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; | |
33dd: 44 29 c2 sub %r8d,%edx | |
33e0: c1 e2 03 shl $0x3,%edx | |
33e3: 29 c2 sub %eax,%edx | |
33e5: 89 94 24 08 01 00 00 mov %edx,0x108(%rsp) | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
33ec: 8b 9c 24 a0 00 00 00 mov 0xa0(%rsp),%ebx | |
33f3: b8 08 00 00 00 mov $0x8,%eax | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
33f8: 48 8d b4 24 00 01 00 lea 0x100(%rsp),%rsi | |
33ff: 00 | |
3400: 48 8d bc 24 28 01 00 lea 0x128(%rsp),%rdi | |
3407: 00 | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
3408: 83 fb 08 cmp $0x8,%ebx | |
340b: 0f 4e c3 cmovle %ebx,%eax | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
340e: 48 8b 9c 24 88 00 00 mov 0x88(%rsp),%rbx | |
3415: 00 | |
3416: 48 8b 13 mov (%rbx),%rdx | |
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); | |
3419: 89 44 24 3c mov %eax,0x3c(%rsp) | |
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); | |
341d: e8 de d5 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); | |
3422: 48 8b 53 10 mov 0x10(%rbx),%rdx | |
3426: 48 8d bc 24 38 01 00 lea 0x138(%rsp),%rdi | |
342d: 00 | |
342e: e8 cd d5 ff ff callq a00 <ZSTD_initFseState> | |
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); | |
3433: 48 8b 53 08 mov 0x8(%rbx),%rdx | |
3437: 48 8d bc 24 48 01 00 lea 0x148(%rsp),%rdi | |
343e: 00 | |
343f: e8 bc d5 ff ff callq a00 <ZSTD_initFseState> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
3444: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
344b: 89 84 24 a4 00 00 00 mov %eax,0xa4(%rsp) | |
3452: 83 f8 40 cmp $0x40,%eax | |
3455: 0f 87 85 0d 00 00 ja 41e0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xfe0> | |
size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */ | |
345b: 48 8b 44 24 58 mov 0x58(%rsp),%rax | |
3460: 48 2b 44 24 18 sub 0x18(%rsp),%rax | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
3465: 45 31 ff xor %r15d,%r15d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
3468: 31 d2 xor %edx,%edx | |
size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */ | |
346a: 48 89 44 24 10 mov %rax,0x10(%rsp) | |
if (bitD->ptr >= bitD->limitPtr) { | |
346f: 48 8b 84 24 20 01 00 mov 0x120(%rsp),%rax | |
3476: 00 | |
3477: 48 8b 9c 24 10 01 00 mov 0x110(%rsp),%rbx | |
347e: 00 | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
347f: 44 89 7c 24 20 mov %r15d,0x20(%rsp) | |
if (bitD->ptr >= bitD->limitPtr) { | |
3484: 48 89 44 24 30 mov %rax,0x30(%rsp) | |
if (bitD->ptr == bitD->start) { | |
3489: 48 8b 84 24 18 01 00 mov 0x118(%rsp),%rax | |
3490: 00 | |
3491: 48 89 9c 24 a8 00 00 mov %rbx,0xa8(%rsp) | |
3498: 00 | |
3499: 4c 8b 84 24 00 01 00 mov 0x100(%rsp),%r8 | |
34a0: 00 | |
34a1: 48 89 84 24 80 00 00 mov %rax,0x80(%rsp) | |
34a8: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
34a9: 48 8b 84 24 30 01 00 mov 0x130(%rsp),%rax | |
34b0: 00 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
34b1: c6 44 24 50 00 movb $0x0,0x50(%rsp) | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
34b6: 48 89 44 24 60 mov %rax,0x60(%rsp) | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
34bb: 48 8b 84 24 50 01 00 mov 0x150(%rsp),%rax | |
34c2: 00 | |
34c3: 48 89 44 24 68 mov %rax,0x68(%rsp) | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
34c8: 48 8b 84 24 40 01 00 mov 0x140(%rsp),%rax | |
34cf: 00 | |
34d0: 48 89 44 24 70 mov %rax,0x70(%rsp) | |
34d5: 48 8d 84 24 70 01 00 lea 0x170(%rsp),%rax | |
34dc: 00 | |
34dd: 49 89 c5 mov %rax,%r13 | |
34e0: 48 89 84 24 98 00 00 mov %rax,0x98(%rsp) | |
34e7: 00 | |
34e8: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
34ef: 4d 89 ef mov %r13,%r15 | |
34f2: e9 37 01 00 00 jmpq 362e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x42e> | |
34f7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
34fe: 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3500: c4 42 f9 f7 f0 shlx %rax,%r8,%r14 | |
bitD->bitsConsumed += nbBits; | |
3505: 01 f8 add %edi,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3507: 4c 89 74 24 48 mov %r14,0x48(%rsp) | |
350c: 41 89 fe mov %edi,%r14d | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
350f: 8b 7c 24 08 mov 0x8(%rsp),%edi | |
3513: 41 f7 de neg %r14d | |
3516: c4 62 8b f7 74 24 48 shrx %r14,0x48(%rsp),%r14 | |
351d: 49 01 fe add %rdi,%r14 | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
3520: 48 8b bc 24 60 01 00 mov 0x160(%rsp),%rdi | |
3527: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
3528: 48 89 b4 24 60 01 00 mov %rsi,0x160(%rsp) | |
352f: 00 | |
seqState->prevOffset[0] = offset; | |
3530: 4c 89 b4 24 58 01 00 mov %r14,0x158(%rsp) | |
3537: 00 | |
3538: 4c 89 f6 mov %r14,%rsi | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
353b: 48 89 bc 24 68 01 00 mov %rdi,0x168(%rsp) | |
3542: 00 | |
seq.matchLength = mlBase; | |
3543: 48 89 4c 24 08 mov %rcx,0x8(%rsp) | |
if (mlBits > 0) | |
3548: 45 84 e4 test %r12b,%r12b | |
354b: 0f 85 1f 02 00 00 jne 3770 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x570> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
3551: 41 80 fd 1e cmp $0x1e,%r13b | |
3555: 0f 87 36 02 00 00 ja 3791 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x591> | |
if (llBits > 0) | |
355b: 40 84 ed test %bpl,%bpl | |
355e: 0f 85 ec 01 00 00 jne 3750 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x550> | |
U32 const nbBits = DInfo.nbBits; | |
3564: 41 0f b6 7b 03 movzbl 0x3(%r11),%edi | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
3569: 4c 8d 35 00 00 00 00 lea 0x0(%rip),%r14 # 3570 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x370> | |
sequences[seqNb] = sequence; | |
3570: 66 48 0f 6e c2 movq %rdx,%xmm0 | |
3575: 0f 16 44 24 08 movhps 0x8(%rsp),%xmm0 | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
357a: 01 f8 add %edi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
357c: 89 c1 mov %eax,%ecx | |
357e: f7 d9 neg %ecx | |
3580: c4 c2 f3 f7 c8 shrx %rcx,%r8,%rcx | |
3585: 41 23 0c be and (%r14,%rdi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
3589: 41 0f b7 3b movzwl (%r11),%edi | |
358d: 48 01 f9 add %rdi,%rcx | |
3590: 48 89 8c 24 28 01 00 mov %rcx,0x128(%rsp) | |
3597: 00 | |
U32 const nbBits = DInfo.nbBits; | |
3598: 41 0f b6 7a 03 movzbl 0x3(%r10),%edi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
359d: 01 f8 add %edi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
359f: 89 c1 mov %eax,%ecx | |
35a1: f7 d9 neg %ecx | |
35a3: c4 c2 f3 f7 c8 shrx %rcx,%r8,%rcx | |
35a8: 41 23 0c be and (%r14,%rdi,4),%ecx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
35ac: 41 0f b7 3a movzwl (%r10),%edi | |
35b0: 48 01 f9 add %rdi,%rcx | |
35b3: 48 89 8c 24 48 01 00 mov %rcx,0x148(%rsp) | |
35ba: 00 | |
U32 const nbBits = DInfo.nbBits; | |
35bb: 41 0f b6 49 03 movzbl 0x3(%r9),%ecx | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
35c0: 01 c8 add %ecx,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
35c2: 89 c7 mov %eax,%edi | |
35c4: f7 df neg %edi | |
35c6: c4 c2 c3 f7 f8 shrx %rdi,%r8,%rdi | |
35cb: 41 23 3c 8e and (%r14,%rcx,4),%edi | |
DStatePtr->state = DInfo.nextState + lowBits; | |
35cf: 41 0f b7 09 movzwl (%r9),%ecx | |
35d3: 48 01 cf add %rcx,%rdi | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
35d6: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx | |
DStatePtr->state = DInfo.nextState + lowBits; | |
35db: 48 89 bc 24 38 01 00 mov %rdi,0x138(%rsp) | |
35e2: 00 | |
prefetchPos += sequence.litLength; | |
35e3: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi | |
35e8: 48 01 d7 add %rdx,%rdi | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
35eb: ba 01 00 00 00 mov $0x1,%edx | |
35f0: 48 39 f7 cmp %rsi,%rdi | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
35f3: 49 89 f9 mov %rdi,%r9 | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
35f6: 48 0f 42 4c 24 28 cmovb 0x28(%rsp),%rcx | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
35fc: 49 83 c7 18 add $0x18,%r15 | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
3600: 49 29 f1 sub %rsi,%r9 | |
return prefetchPos + sequence.matchLength; | |
3603: 48 03 7c 24 08 add 0x8(%rsp),%rdi | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
3608: 4c 01 c9 add %r9,%rcx | |
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */ | |
360b: 0f 18 09 prefetcht0 (%rcx) | |
360e: 0f 18 49 40 prefetcht0 0x40(%rcx) | |
sequences[seqNb] = sequence; | |
3612: 41 0f 11 47 e8 movups %xmm0,-0x18(%r15) | |
3617: 49 89 77 f8 mov %rsi,-0x8(%r15) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
361b: 83 44 24 20 01 addl $0x1,0x20(%rsp) | |
return prefetchPos + sequence.matchLength; | |
3620: 48 89 7c 24 10 mov %rdi,0x10(%rsp) | |
3625: 83 f8 40 cmp $0x40,%eax | |
3628: 0f 87 12 06 00 00 ja 3c40 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa40> | |
if (bitD->ptr >= bitD->limitPtr) { | |
362e: 48 3b 5c 24 30 cmp 0x30(%rsp),%rbx | |
3633: 0f 83 af 01 00 00 jae 37e8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x5e8> | |
if (bitD->ptr == bitD->start) { | |
3639: 48 8b bc 24 80 00 00 mov 0x80(%rsp),%rdi | |
3640: 00 | |
3641: 48 39 fb cmp %rdi,%rbx | |
3644: 74 37 je 367d <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x47d> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
3646: 89 c2 mov %eax,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
3648: 48 89 d9 mov %rbx,%rcx | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
364b: c1 ea 03 shr $0x3,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
364e: 89 d6 mov %edx,%esi | |
3650: 48 29 f1 sub %rsi,%rcx | |
3653: 48 39 cf cmp %rcx,%rdi | |
3656: 76 10 jbe 3668 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x468> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
3658: 48 89 de mov %rbx,%rsi | |
365b: 48 29 fe sub %rdi,%rsi | |
365e: 89 f2 mov %esi,%edx | |
bitD->ptr -= nbBytes; | |
3660: 89 f6 mov %esi,%esi | |
3662: 48 29 f3 sub %rsi,%rbx | |
3665: 48 89 d9 mov %rbx,%rcx | |
3668: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
bitD->bitsConsumed -= nbBytes*8; | |
366d: c1 e2 03 shl $0x3,%edx | |
3670: 4c 8b 01 mov (%rcx),%r8 | |
3673: 48 89 cb mov %rcx,%rbx | |
3676: 29 d0 sub %edx,%eax | |
3678: ba 01 00 00 00 mov $0x1,%edx | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
367d: 8b 4c 24 20 mov 0x20(%rsp),%ecx | |
3681: 39 4c 24 3c cmp %ecx,0x3c(%rsp) | |
3685: 0f 8e 83 01 00 00 jle 380e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x60e> | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
368b: 48 8b 94 24 28 01 00 mov 0x128(%rsp),%rdx | |
3692: 00 | |
3693: 48 8b 74 24 60 mov 0x60(%rsp),%rsi | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
3698: 48 8b 8c 24 48 01 00 mov 0x148(%rsp),%rcx | |
369f: 00 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
36a0: 48 8b 7c 24 70 mov 0x70(%rsp),%rdi | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
36a5: 4c 8d 1c d6 lea (%rsi,%rdx,8),%r11 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
36a9: 48 8b 74 24 68 mov 0x68(%rsp),%rsi | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
36ae: 41 0f b6 6b 02 movzbl 0x2(%r11),%ebp | |
36b3: 41 8b 53 04 mov 0x4(%r11),%edx | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
36b7: 4c 8d 14 ce lea (%rsi,%rcx,8),%r10 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
36bb: 48 8b b4 24 38 01 00 mov 0x138(%rsp),%rsi | |
36c2: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
36c3: 45 0f b6 62 02 movzbl 0x2(%r10),%r12d | |
36c8: 41 8b 4a 04 mov 0x4(%r10),%ecx | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
36cc: 4c 8d 0c f7 lea (%rdi,%rsi,8),%r9 | |
36d0: 41 8b 71 04 mov 0x4(%r9),%esi | |
36d4: 41 0f b6 79 02 movzbl 0x2(%r9),%edi | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
36d9: 46 8d 6c 25 00 lea 0x0(%rbp,%r12,1),%r13d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
36de: 89 74 24 08 mov %esi,0x8(%rsp) | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
36e2: 41 01 fd add %edi,%r13d | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
36e5: 48 8b b4 24 58 01 00 mov 0x158(%rsp),%rsi | |
36ec: 00 | |
if (ofBits > 1) { | |
36ed: 40 80 ff 01 cmp $0x1,%dil | |
36f1: 0f 87 09 fe ff ff ja 3500 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x300> | |
if (LIKELY((ofBits == 0))) { | |
36f7: 0f 84 4b 09 00 00 je 4048 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xe48> | |
if (LIKELY(!ll0)) | |
36fd: 85 d2 test %edx,%edx | |
36ff: 0f 85 3e fe ff ff jne 3543 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x343> | |
offset = seqState->prevOffset[1]; | |
3705: 48 8b bc 24 60 01 00 mov 0x160(%rsp),%rdi | |
370c: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
370d: 48 89 b4 24 60 01 00 mov %rsi,0x160(%rsp) | |
3714: 00 | |
seqState->prevOffset[0] = offset; | |
3715: 48 89 bc 24 58 01 00 mov %rdi,0x158(%rsp) | |
371c: 00 | |
offset = seqState->prevOffset[1]; | |
371d: 48 89 fe mov %rdi,%rsi | |
3720: e9 1e fe ff ff jmpq 3543 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x343> | |
3725: 0f 1f 00 nopl (%rax) | |
return __builtin_clz (val) ^ 31; | |
3728: 0f bd c0 bsr %eax,%eax | |
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */ | |
372b: ba 08 00 00 00 mov $0x8,%edx | |
3730: 29 c2 sub %eax,%edx | |
3732: 89 94 24 08 01 00 00 mov %edx,0x108(%rsp) | |
RETURN_ERROR_IF( | |
3739: 49 83 f8 88 cmp $0xffffffffffffff88,%r8 | |
373d: 0f 87 bd fb ff ff ja 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
3743: e9 a4 fc ff ff jmpq 33ec <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1ec> | |
3748: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
374f: 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3750: 89 ef mov %ebp,%edi | |
3752: c4 c2 f9 f7 c8 shlx %rax,%r8,%rcx | |
bitD->bitsConsumed += nbBits; | |
3757: 01 e8 add %ebp,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3759: f7 df neg %edi | |
375b: c4 e2 c3 f7 c9 shrx %rdi,%rcx,%rcx | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
3760: 48 01 ca add %rcx,%rdx | |
3763: e9 fc fd ff ff jmpq 3564 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x364> | |
3768: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
376f: 00 | |
3770: 44 89 e7 mov %r12d,%edi | |
3773: c4 c2 f9 f7 c8 shlx %rax,%r8,%rcx | |
bitD->bitsConsumed += nbBits; | |
3778: 44 01 e0 add %r12d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
377b: f7 df neg %edi | |
377d: c4 e2 c3 f7 c9 shrx %rdi,%rcx,%rcx | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
3782: 48 01 4c 24 08 add %rcx,0x8(%rsp) | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
3787: 41 80 fd 1e cmp $0x1e,%r13b | |
378b: 0f 86 ca fd ff ff jbe 355b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x35b> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
3791: 83 f8 40 cmp $0x40,%eax | |
3794: 0f 87 c1 fd ff ff ja 355b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x35b> | |
if (bitD->ptr >= bitD->limitPtr) { | |
379a: 48 3b 5c 24 30 cmp 0x30(%rsp),%rbx | |
379f: 0f 83 1b 0a 00 00 jae 41c0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xfc0> | |
if (bitD->ptr == bitD->start) { | |
37a5: 4c 8b b4 24 80 00 00 mov 0x80(%rsp),%r14 | |
37ac: 00 | |
37ad: 4c 39 f3 cmp %r14,%rbx | |
37b0: 0f 84 a5 fd ff ff je 355b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x35b> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
37b6: 89 c1 mov %eax,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
37b8: 48 89 df mov %rbx,%rdi | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
37bb: c1 e9 03 shr $0x3,%ecx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
37be: 41 89 c8 mov %ecx,%r8d | |
37c1: 4c 29 c7 sub %r8,%rdi | |
37c4: 4c 39 f7 cmp %r14,%rdi | |
37c7: 0f 82 1b 0a 00 00 jb 41e8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xfe8> | |
37cd: 48 89 fb mov %rdi,%rbx | |
bitD->bitsConsumed -= nbBytes*8; | |
37d0: c1 e1 03 shl $0x3,%ecx | |
37d3: 4c 8b 03 mov (%rbx),%r8 | |
return result; | |
37d6: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
bitD->bitsConsumed -= nbBytes*8; | |
37db: 29 c8 sub %ecx,%eax | |
return result; | |
37dd: e9 79 fd ff ff jmpq 355b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x35b> | |
37e2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
37e8: 89 c2 mov %eax,%edx | |
37ea: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
37ef: 8b 4c 24 20 mov 0x20(%rsp),%ecx | |
bitD->bitsConsumed &= 7; | |
37f3: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
37f6: c1 ea 03 shr $0x3,%edx | |
37f9: 48 29 d3 sub %rdx,%rbx | |
37fc: ba 01 00 00 00 mov $0x1,%edx | |
3801: 4c 8b 03 mov (%rbx),%r8 | |
3804: 39 4c 24 3c cmp %ecx,0x3c(%rsp) | |
3808: 0f 8f 7d fe ff ff jg 368b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x48b> | |
380e: 80 7c 24 50 00 cmpb $0x0,0x50(%rsp) | |
3813: 41 89 cf mov %ecx,%r15d | |
3816: 0f 84 a3 08 00 00 je 40bf <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xebf> | |
381c: 4c 89 84 24 00 01 00 mov %r8,0x100(%rsp) | |
3823: 00 | |
3824: 84 d2 test %dl,%dl | |
3826: 0f 84 cc 0c 00 00 je 44f8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x12f8> | |
382c: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
3833: 48 89 9c 24 10 01 00 mov %rbx,0x110(%rsp) | |
383a: 00 | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
383b: 83 f8 40 cmp $0x40,%eax | |
383e: 0f 87 2e 04 00 00 ja 3c72 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa72> | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
3844: 48 8b 74 24 78 mov 0x78(%rsp),%rsi | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
3849: 4c 8b 54 24 58 mov 0x58(%rsp),%r10 | |
*ip += dec32table[offset]; | |
384e: 44 89 7c 24 08 mov %r15d,0x8(%rsp) | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
3853: 48 83 ee 20 sub $0x20,%rsi | |
*ip += dec32table[offset]; | |
3857: 4d 89 d6 mov %r10,%r14 | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
385a: 48 89 74 24 48 mov %rsi,0x48(%rsp) | |
if (bitD->ptr >= bitD->limitPtr) { | |
385f: 48 3b 5c 24 30 cmp 0x30(%rsp),%rbx | |
3864: 0f 83 a8 03 00 00 jae 3c12 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa12> | |
if (bitD->ptr == bitD->start) { | |
386a: 48 8b 8c 24 18 01 00 mov 0x118(%rsp),%rcx | |
3871: 00 | |
3872: 49 89 da mov %rbx,%r10 | |
3875: 48 39 d9 cmp %rbx,%rcx | |
3878: 74 3e je 38b8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x6b8> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
387a: 89 c2 mov %eax,%edx | |
387c: c1 ea 03 shr $0x3,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
387f: 89 d6 mov %edx,%esi | |
3881: 49 29 f2 sub %rsi,%r10 | |
3884: 4c 39 d1 cmp %r10,%rcx | |
3887: 76 10 jbe 3899 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x699> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
3889: 48 89 de mov %rbx,%rsi | |
388c: 48 29 ce sub %rcx,%rsi | |
388f: 89 f2 mov %esi,%edx | |
bitD->ptr -= nbBytes; | |
3891: 89 f6 mov %esi,%esi | |
3893: 48 29 f3 sub %rsi,%rbx | |
3896: 49 89 da mov %rbx,%r10 | |
bitD->bitsConsumed -= nbBytes*8; | |
3899: c1 e2 03 shl $0x3,%edx | |
bitD->ptr -= nbBytes; | |
389c: 4c 89 94 24 10 01 00 mov %r10,0x110(%rsp) | |
38a3: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
38a4: 29 d0 sub %edx,%eax | |
38a6: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
38ad: 49 8b 02 mov (%r10),%rax | |
38b0: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp) | |
38b7: 00 | |
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) { | |
38b8: 8b 5c 24 08 mov 0x8(%rsp),%ebx | |
38bc: 39 9c 24 a0 00 00 00 cmp %ebx,0xa0(%rsp) | |
38c3: 0f 8e 38 0a 00 00 jle 4301 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1101> | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
38c9: 48 8b 94 24 28 01 00 mov 0x128(%rsp),%rdx | |
38d0: 00 | |
38d1: 48 8b 84 24 30 01 00 mov 0x130(%rsp),%rax | |
38d8: 00 | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
38d9: 48 8b 8c 24 38 01 00 mov 0x138(%rsp),%rcx | |
38e0: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
38e1: 48 8b 9c 24 58 01 00 mov 0x158(%rsp),%rbx | |
38e8: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
38e9: 4c 8d 04 d0 lea (%rax,%rdx,8),%r8 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
38ed: 48 8b 94 24 48 01 00 mov 0x148(%rsp),%rdx | |
38f4: 00 | |
38f5: 48 8b 84 24 50 01 00 mov 0x150(%rsp),%rax | |
38fc: 00 | |
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state]; | |
38fd: 45 0f b6 58 02 movzbl 0x2(%r8),%r11d | |
3902: 45 8b 78 04 mov 0x4(%r8),%r15d | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
3906: 48 8d 3c d0 lea (%rax,%rdx,8),%rdi | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
390a: 48 8b 84 24 40 01 00 mov 0x140(%rsp),%rax | |
3911: 00 | |
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state]; | |
3912: 0f b6 6f 02 movzbl 0x2(%rdi),%ebp | |
3916: 8b 57 04 mov 0x4(%rdi),%edx | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
3919: 48 8d 34 c8 lea (%rax,%rcx,8),%rsi | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
391d: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
3924: 0f b6 4e 02 movzbl 0x2(%rsi),%ecx | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
3928: 45 8d 24 2b lea (%r11,%rbp,1),%r12d | |
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state]; | |
392c: 44 8b 4e 04 mov 0x4(%rsi),%r9d | |
BYTE const totalBits = llBits+mlBits+ofBits; | |
3930: 41 01 cc add %ecx,%r12d | |
if (ofBits > 1) { | |
3933: 80 f9 01 cmp $0x1,%cl | |
3936: 0f 86 44 05 00 00 jbe 3e80 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc80> | |
393c: c4 62 f9 f7 ac 24 00 shlx %rax,0x100(%rsp),%r13 | |
3943: 01 00 00 | |
bitD->bitsConsumed += nbBits; | |
3946: 01 c8 add %ecx,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3948: 4c 89 6c 24 20 mov %r13,0x20(%rsp) | |
394d: 41 89 cd mov %ecx,%r13d | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
3950: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
3957: 00 | |
3958: 41 f7 dd neg %r13d | |
395b: c4 62 93 f7 6c 24 20 shrx %r13,0x20(%rsp),%r13 | |
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */ | |
3962: 4d 01 cd add %r9,%r13 | |
bitD->bitsConsumed += nbBits; | |
3965: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
seqState->prevOffset[2] = seqState->prevOffset[1]; | |
396c: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp) | |
3973: 00 | |
seqState->prevOffset[0] = offset; | |
3974: 4c 89 ac 24 58 01 00 mov %r13,0x158(%rsp) | |
397b: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
397c: 48 89 9c 24 60 01 00 mov %rbx,0x160(%rsp) | |
3983: 00 | |
seqState->prevOffset[0] = offset; | |
3984: 4c 89 eb mov %r13,%rbx | |
seq.matchLength = mlBase; | |
3987: 48 89 54 24 20 mov %rdx,0x20(%rsp) | |
if (mlBits > 0) | |
398c: 40 84 ed test %bpl,%bpl | |
398f: 0f 85 3b 05 00 00 jne 3ed0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xcd0> | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
3995: 41 80 fc 1e cmp $0x1e,%r12b | |
3999: 0f 87 5c 05 00 00 ja 3efb <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xcfb> | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
399f: 48 8b 94 24 00 01 00 mov 0x100(%rsp),%rdx | |
39a6: 00 | |
seq.litLength = llBase; | |
39a7: 45 89 fa mov %r15d,%r10d | |
if (llBits > 0) | |
39aa: 45 84 db test %r11b,%r11b | |
39ad: 0f 85 fd 04 00 00 jne 3eb0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xcb0> | |
U32 const nbBits = DInfo.nbBits; | |
39b3: 41 0f b6 48 03 movzbl 0x3(%r8),%ecx | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
39b8: 4c 8d 3d 00 00 00 00 lea 0x0(%rip),%r15 # 39bf <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x7bf> | |
39bf: 44 8b 64 24 08 mov 0x8(%rsp),%r12d | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
39c4: 01 c8 add %ecx,%eax | |
DStatePtr->state = DInfo.nextState + lowBits; | |
39c6: 41 83 e4 07 and $0x7,%r12d | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
39ca: 41 89 c1 mov %eax,%r9d | |
39cd: 41 f7 d9 neg %r9d | |
39d0: c4 62 b3 f7 ca shrx %r9,%rdx,%r9 | |
39d5: 45 23 0c 8f and (%r15,%rcx,4),%r9d | |
39d9: 41 0f b7 08 movzwl (%r8),%ecx | |
39dd: 49 01 c9 add %rcx,%r9 | |
39e0: 4c 89 8c 24 28 01 00 mov %r9,0x128(%rsp) | |
39e7: 00 | |
U32 const nbBits = DInfo.nbBits; | |
39e8: 44 0f b6 47 03 movzbl 0x3(%rdi),%r8d | |
DStatePtr->state = DInfo.nextState + lowBits; | |
39ed: 0f b7 3f movzwl (%rdi),%edi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
39f0: 44 01 c0 add %r8d,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
39f3: 89 c1 mov %eax,%ecx | |
39f5: f7 d9 neg %ecx | |
39f7: c4 e2 f3 f7 ca shrx %rcx,%rdx,%rcx | |
39fc: 43 23 0c 87 and (%r15,%r8,4),%ecx | |
3a00: 48 01 f9 add %rdi,%rcx | |
3a03: 48 89 8c 24 48 01 00 mov %rcx,0x148(%rsp) | |
3a0a: 00 | |
ZSTD_seqSymbol const DInfo = DStatePtr->table[DStatePtr->state]; | |
3a0b: 0f b7 0e movzwl (%rsi),%ecx | |
U32 const nbBits = DInfo.nbBits; | |
3a0e: 0f b6 76 03 movzbl 0x3(%rsi),%esi | |
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); | |
3a12: 01 f0 add %esi,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
3a14: 89 c7 mov %eax,%edi | |
bitD->bitsConsumed += nbBits; | |
3a16: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
DStatePtr->state = DInfo.nextState + lowBits; | |
3a1d: 0f b7 c1 movzwl %cx,%eax | |
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; | |
3a20: f7 df neg %edi | |
3a22: c4 e2 c3 f7 d2 shrx %rdi,%rdx,%rdx | |
3a27: 41 23 14 b7 and (%r15,%rsi,4),%edx | |
3a2b: 48 01 c2 add %rax,%rdx | |
3a2e: 4b 8d 04 64 lea (%r12,%r12,2),%rax | |
3a32: 48 c1 e0 03 shl $0x3,%rax | |
3a36: 48 89 94 24 38 01 00 mov %rdx,0x138(%rsp) | |
3a3d: 00 | |
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd); | |
3a3e: 48 8b b4 04 70 01 00 mov 0x170(%rsp,%rax,1),%rsi | |
3a45: 00 | |
3a46: 48 8b 94 04 80 01 00 mov 0x180(%rsp,%rax,1),%rdx | |
3a4d: 00 | |
3a4e: 4c 8b 84 04 78 01 00 mov 0x178(%rsp,%rax,1),%r8 | |
3a55: 00 | |
3a56: f3 0f 6f ac 04 70 01 movdqu 0x170(%rsp,%rax,1),%xmm5 | |
3a5d: 00 00 | |
3a5f: 49 89 d7 mov %rdx,%r15 | |
BYTE* const oLitEnd = op + sequence.litLength; | |
3a62: 48 89 94 24 d0 00 00 mov %rdx,0xd0(%rsp) | |
3a69: 00 | |
3a6a: 49 8d 3c 36 lea (%r14,%rsi,1),%rdi | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
3a6e: 48 8b 94 24 b8 00 00 mov 0xb8(%rsp),%rdx | |
3a75: 00 | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
3a76: 4e 8d 2c 06 lea (%rsi,%r8,1),%r13 | |
const BYTE* match = oLitEnd - sequence.offset; | |
3a7a: 48 89 f8 mov %rdi,%rax | |
3a7d: 0f 29 ac 24 c0 00 00 movaps %xmm5,0xc0(%rsp) | |
3a84: 00 | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
3a85: 4b 8d 2c 2e lea (%r14,%r13,1),%rbp | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
3a89: 48 8d 0c 32 lea (%rdx,%rsi,1),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
3a8d: 4c 29 f8 sub %r15,%rax | |
if (UNLIKELY( | |
3a90: 48 3b 6c 24 48 cmp 0x48(%rsp),%rbp | |
3a95: 0f 87 f5 04 00 00 ja 3f90 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd90> | |
3a9b: 48 39 4c 24 40 cmp %rcx,0x40(%rsp) | |
3aa0: 0f 82 ea 04 00 00 jb 3f90 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd90> | |
ZSTD_memcpy(dst, src, 16); | |
3aa6: f3 0f 6f 32 movdqu (%rdx),%xmm6 | |
3aaa: 41 0f 11 36 movups %xmm6,(%r14) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
3aae: 48 83 fe 10 cmp $0x10,%rsi | |
3ab2: 0f 87 48 05 00 00 ja 4000 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xe00> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
3ab8: 48 89 fa mov %rdi,%rdx | |
3abb: 48 2b 54 24 18 sub 0x18(%rsp),%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
3ac0: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp) | |
3ac7: 00 | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
3ac8: 49 39 d7 cmp %rdx,%r15 | |
3acb: 76 6a jbe 3b37 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x937> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
3acd: 48 89 fa mov %rdi,%rdx | |
3ad0: 48 2b 94 24 90 00 00 sub 0x90(%rsp),%rdx | |
3ad7: 00 | |
3ad8: 49 39 d7 cmp %rdx,%r15 | |
3adb: 0f 87 1f f8 ff ff ja 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
match = dictEnd + (match - prefixStart); | |
3ae1: 48 8b 4c 24 28 mov 0x28(%rsp),%rcx | |
3ae6: 48 89 c6 mov %rax,%rsi | |
3ae9: 48 2b 74 24 18 sub 0x18(%rsp),%rsi | |
3aee: 48 01 ce add %rcx,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
3af1: 4a 8d 14 06 lea (%rsi,%r8,1),%rdx | |
3af5: 48 39 d1 cmp %rdx,%rcx | |
3af8: 0f 83 72 04 00 00 jae 3f70 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd70> | |
{ size_t const length1 = dictEnd - match; | |
3afe: 48 8b 54 24 18 mov 0x18(%rsp),%rdx | |
3b03: 4c 89 44 24 60 mov %r8,0x60(%rsp) | |
3b08: 4c 89 54 24 50 mov %r10,0x50(%rsp) | |
3b0d: 48 29 c2 sub %rax,%rdx | |
ZSTD_memmove(oLitEnd, match, length1); | |
3b10: 48 89 54 24 30 mov %rdx,0x30(%rsp) | |
3b15: e8 00 00 00 00 callq 3b1a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x91a> | |
op = oLitEnd + length1; | |
3b1a: 48 8b 54 24 30 mov 0x30(%rsp),%rdx | |
sequence.matchLength -= length1; | |
3b1f: 4c 8b 44 24 60 mov 0x60(%rsp),%r8 | |
ZSTD_memmove(oLitEnd, match, length1); | |
3b24: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
3b27: 4c 8b 54 24 50 mov 0x50(%rsp),%r10 | |
3b2c: 48 8b 44 24 18 mov 0x18(%rsp),%rax | |
op = oLitEnd + length1; | |
3b31: 48 01 d7 add %rdx,%rdi | |
sequence.matchLength -= length1; | |
3b34: 49 29 d0 sub %rdx,%r8 | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
3b37: 49 83 ff 0f cmp $0xf,%r15 | |
3b3b: 0f 86 9f 05 00 00 jbe 40e0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xee0> | |
3b41: f3 0f 6f 38 movdqu (%rax),%xmm7 | |
3b45: 0f 11 3f movups %xmm7,(%rdi) | |
if (16 >= length) return; | |
3b48: 49 83 f8 10 cmp $0x10,%r8 | |
3b4c: 7e 30 jle 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
op += 16; | |
3b4e: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
3b52: 48 83 c0 10 add $0x10,%rax | |
3b56: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
3b5d: 00 00 00 | |
ZSTD_memcpy(dst, src, 16); | |
3b60: f3 0f 6f 08 movdqu (%rax),%xmm1 | |
3b64: 48 83 c7 20 add $0x20,%rdi | |
3b68: 48 83 c0 20 add $0x20,%rax | |
3b6c: 0f 11 4f e0 movups %xmm1,-0x20(%rdi) | |
3b70: f3 0f 6f 50 f0 movdqu -0x10(%rax),%xmm2 | |
3b75: 0f 11 57 f0 movups %xmm2,-0x10(%rdi) | |
while (op < oend); | |
3b79: 48 39 fd cmp %rdi,%rbp | |
3b7c: 77 e2 ja 3b60 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x960> | |
if (ZSTD_isError(oneSeqSize)) return oneSeqSize; | |
3b7e: 49 83 fd 88 cmp $0xffffffffffffff88,%r13 | |
3b82: 0f 87 7f f7 ff ff ja 3307 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x107> | |
prefetchPos += sequence.litLength; | |
3b88: 48 8b 54 24 10 mov 0x10(%rsp),%rdx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
3b8d: 48 8b 44 24 18 mov 0x18(%rsp),%rax | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
3b92: 66 49 0f 6e c2 movq %r10,%xmm0 | |
3b97: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi | |
3b9e: 00 | |
3b9f: 0f 16 44 24 20 movhps 0x20(%rsp),%xmm0 | |
prefetchPos += sequence.litLength; | |
3ba4: 4c 01 d2 add %r10,%rdx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
3ba7: 48 39 da cmp %rbx,%rdx | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
3baa: 48 89 d1 mov %rdx,%rcx | |
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart; | |
3bad: 48 0f 42 44 24 28 cmovb 0x28(%rsp),%rax | |
op += oneSeqSize; | |
3bb3: 4d 01 ee add %r13,%r14 | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
3bb6: 48 29 d9 sub %rbx,%rcx | |
return prefetchPos + sequence.matchLength; | |
3bb9: 48 03 54 24 20 add 0x20(%rsp),%rdx | |
const BYTE* const match = matchBase + prefetchPos - sequence.offset; /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted. | |
3bbe: 48 01 c8 add %rcx,%rax | |
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */ | |
3bc1: 0f 18 08 prefetcht0 (%rax) | |
3bc4: 0f 18 48 40 prefetcht0 0x40(%rax) | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
3bc8: 4b 8d 04 64 lea (%r12,%r12,2),%rax | |
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) { | |
3bcc: 83 44 24 08 01 addl $0x1,0x8(%rsp) | |
sequences[seqNb & STORED_SEQS_MASK] = sequence; | |
3bd1: 0f 11 04 c6 movups %xmm0,(%rsi,%rax,8) | |
3bd5: 48 89 9c c4 80 01 00 mov %rbx,0x180(%rsp,%rax,8) | |
3bdc: 00 | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
3bdd: 8b 84 24 08 01 00 00 mov 0x108(%rsp),%eax | |
return prefetchPos + sequence.matchLength; | |
3be4: 48 89 54 24 10 mov %rdx,0x10(%rsp) | |
3be9: 83 f8 40 cmp $0x40,%eax | |
3bec: 0f 87 6e 03 00 00 ja 3f60 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd60> | |
if (bitD->ptr >= bitD->limitPtr) { | |
3bf2: 48 8b b4 24 20 01 00 mov 0x120(%rsp),%rsi | |
3bf9: 00 | |
3bfa: 48 8b 9c 24 10 01 00 mov 0x110(%rsp),%rbx | |
3c01: 00 | |
3c02: 48 89 74 24 30 mov %rsi,0x30(%rsp) | |
3c07: 48 3b 5c 24 30 cmp 0x30(%rsp),%rbx | |
3c0c: 0f 82 58 fc ff ff jb 386a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x66a> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
3c12: 89 c2 mov %eax,%edx | |
bitD->bitsConsumed &= 7; | |
3c14: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
3c17: c1 ea 03 shr $0x3,%edx | |
bitD->bitsConsumed &= 7; | |
3c1a: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
3c21: 48 29 d3 sub %rdx,%rbx | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
3c24: 48 8b 03 mov (%rbx),%rax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
3c27: 48 89 9c 24 10 01 00 mov %rbx,0x110(%rsp) | |
3c2e: 00 | |
3c2f: 49 89 da mov %rbx,%r10 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
3c32: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp) | |
3c39: 00 | |
return BIT_DStream_unfinished; | |
3c3a: e9 79 fc ff ff jmpq 38b8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x6b8> | |
3c3f: 90 nop | |
3c40: 80 7c 24 50 00 cmpb $0x0,0x50(%rsp) | |
3c45: 44 8b 7c 24 20 mov 0x20(%rsp),%r15d | |
3c4a: 0f 84 a0 03 00 00 je 3ff0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xdf0> | |
3c50: 4c 89 84 24 00 01 00 mov %r8,0x100(%rsp) | |
3c57: 00 | |
3c58: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
3c5f: 48 89 9c 24 10 01 00 mov %rbx,0x110(%rsp) | |
3c66: 00 | |
RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, ""); | |
3c67: 44 39 7c 24 3c cmp %r15d,0x3c(%rsp) | |
3c6c: 0f 8f 8e f6 ff ff jg 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
3c72: 4c 8b 54 24 58 mov 0x58(%rsp),%r10 | |
RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, ""); | |
3c77: 44 39 bc 24 a0 00 00 cmp %r15d,0xa0(%rsp) | |
3c7e: 00 | |
3c7f: 0f 8f 7b f6 ff ff jg 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
seqNb -= seqAdvance; | |
3c85: 44 89 fb mov %r15d,%ebx | |
3c88: 2b 5c 24 3c sub 0x3c(%rsp),%ebx | |
for ( ; seqNb<nbSeq ; seqNb++) { | |
3c8c: 39 9c 24 a0 00 00 00 cmp %ebx,0xa0(%rsp) | |
3c93: 0f 8e 97 01 00 00 jle 3e30 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc30> | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
3c99: 48 8b 44 24 78 mov 0x78(%rsp),%rax | |
*ip += dec32table[offset]; | |
3c9e: 4c 8b 74 24 40 mov 0x40(%rsp),%r14 | |
3ca3: 41 89 dd mov %ebx,%r13d | |
3ca6: 4d 89 d4 mov %r10,%r12 | |
3ca9: 4c 8b 7c 24 18 mov 0x18(%rsp),%r15 | |
BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH; /* risk : address space underflow on oend=NULL */ | |
3cae: 48 83 e8 20 sub $0x20,%rax | |
3cb2: 48 89 44 24 08 mov %rax,0x8(%rsp) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
3cb7: 48 8d 84 24 b8 00 00 lea 0xb8(%rsp),%rax | |
3cbe: 00 | |
3cbf: 48 89 44 24 30 mov %rax,0x30(%rsp) | |
3cc4: 0f 1f 40 00 nopl 0x0(%rax) | |
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd); | |
3cc8: 44 89 e8 mov %r13d,%eax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
3ccb: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
3cd2: 00 | |
3cd3: 83 e0 07 and $0x7,%eax | |
3cd6: 48 8d 04 40 lea (%rax,%rax,2),%rax | |
3cda: 48 c1 e0 03 shl $0x3,%rax | |
3cde: 48 8b 94 04 80 01 00 mov 0x180(%rsp,%rax,1),%rdx | |
3ce5: 00 | |
3ce6: 4c 8b 8c 04 78 01 00 mov 0x178(%rsp,%rax,1),%r9 | |
3ced: 00 | |
3cee: f3 0f 6f ac 04 70 01 movdqu 0x170(%rsp,%rax,1),%xmm5 | |
3cf5: 00 00 | |
3cf7: 48 8b 9c 04 80 01 00 mov 0x180(%rsp,%rax,1),%rbx | |
3cfe: 00 | |
3cff: 48 89 94 24 f0 00 00 mov %rdx,0xf0(%rsp) | |
3d06: 00 | |
3d07: 48 8b 94 04 70 01 00 mov 0x170(%rsp,%rax,1),%rdx | |
3d0e: 00 | |
BYTE* const oLitEnd = op + sequence.litLength; | |
3d0f: 0f 29 ac 24 e0 00 00 movaps %xmm5,0xe0(%rsp) | |
3d16: 00 | |
3d17: 49 8d 3c 14 lea (%r12,%rdx,1),%rdi | |
size_t const sequenceLength = sequence.litLength + sequence.matchLength; | |
3d1b: 4a 8d 0c 0a lea (%rdx,%r9,1),%rcx | |
const BYTE* match = oLitEnd - sequence.offset; | |
3d1f: 48 89 f8 mov %rdi,%rax | |
const BYTE* const iLitEnd = *litPtr + sequence.litLength; | |
3d22: 4c 8d 1c 16 lea (%rsi,%rdx,1),%r11 | |
BYTE* const oMatchEnd = op + sequenceLength; /* risk : address space overflow (32-bits) */ | |
3d26: 49 8d 2c 0c lea (%r12,%rcx,1),%rbp | |
const BYTE* match = oLitEnd - sequence.offset; | |
3d2a: 48 29 d8 sub %rbx,%rax | |
if (UNLIKELY( | |
3d2d: 4d 39 de cmp %r11,%r14 | |
3d30: 0f 82 d6 05 00 00 jb 430c <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x110c> | |
3d36: 48 3b 6c 24 08 cmp 0x8(%rsp),%rbp | |
3d3b: 0f 87 cb 05 00 00 ja 430c <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x110c> | |
ZSTD_memcpy(dst, src, 16); | |
3d41: f3 0f 6f 3e movdqu (%rsi),%xmm7 | |
3d45: 41 0f 11 3c 24 movups %xmm7,(%r12) | |
if (UNLIKELY(sequence.litLength > 16)) { | |
3d4a: 48 83 fa 10 cmp $0x10,%rdx | |
3d4e: 0f 87 16 06 00 00 ja 436a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x116a> | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
3d54: 48 89 fa mov %rdi,%rdx | |
*litPtr = iLitEnd; /* update for next sequence */ | |
3d57: 4c 89 9c 24 b8 00 00 mov %r11,0xb8(%rsp) | |
3d5e: 00 | |
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { | |
3d5f: 4c 29 fa sub %r15,%rdx | |
3d62: 48 39 d3 cmp %rdx,%rbx | |
3d65: 76 64 jbe 3dcb <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xbcb> | |
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, ""); | |
3d67: 48 89 fa mov %rdi,%rdx | |
3d6a: 48 2b 94 24 90 00 00 sub 0x90(%rsp),%rdx | |
3d71: 00 | |
3d72: 48 39 d3 cmp %rdx,%rbx | |
3d75: 0f 87 85 f5 ff ff ja 3300 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x100> | |
match = dictEnd + (match - prefixStart); | |
3d7b: 4c 8b 54 24 28 mov 0x28(%rsp),%r10 | |
3d80: 48 89 c6 mov %rax,%rsi | |
3d83: 4c 29 fe sub %r15,%rsi | |
3d86: 4c 01 d6 add %r10,%rsi | |
if (match + sequence.matchLength <= dictEnd) { | |
3d89: 4a 8d 14 0e lea (%rsi,%r9,1),%rdx | |
3d8d: 49 39 d2 cmp %rdx,%r10 | |
3d90: 0f 83 da 04 00 00 jae 4270 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1070> | |
{ size_t const length1 = dictEnd - match; | |
3d96: 4c 89 fa mov %r15,%rdx | |
3d99: 48 89 4c 24 20 mov %rcx,0x20(%rsp) | |
3d9e: 48 29 c2 sub %rax,%rdx | |
3da1: 4c 89 4c 24 18 mov %r9,0x18(%rsp) | |
ZSTD_memmove(oLitEnd, match, length1); | |
3da6: 48 89 54 24 10 mov %rdx,0x10(%rsp) | |
3dab: e8 00 00 00 00 callq 3db0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xbb0> | |
op = oLitEnd + length1; | |
3db0: 48 8b 54 24 10 mov 0x10(%rsp),%rdx | |
sequence.matchLength -= length1; | |
3db5: 4c 8b 4c 24 18 mov 0x18(%rsp),%r9 | |
ZSTD_memmove(oLitEnd, match, length1); | |
3dba: 48 89 c7 mov %rax,%rdi | |
match = prefixStart; | |
3dbd: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx | |
3dc2: 4c 89 f8 mov %r15,%rax | |
op = oLitEnd + length1; | |
3dc5: 48 01 d7 add %rdx,%rdi | |
sequence.matchLength -= length1; | |
3dc8: 49 29 d1 sub %rdx,%r9 | |
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) { | |
3dcb: 48 83 fb 0f cmp $0xf,%rbx | |
3dcf: 0f 86 01 06 00 00 jbe 43d6 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x11d6> | |
3dd5: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
3dd9: 0f 11 1f movups %xmm3,(%rdi) | |
if (16 >= length) return; | |
3ddc: 49 83 f9 10 cmp $0x10,%r9 | |
3de0: 7e 2c jle 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
op += 16; | |
3de2: 48 83 c7 10 add $0x10,%rdi | |
ip += 16; | |
3de6: 48 83 c0 10 add $0x10,%rax | |
3dea: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 16); | |
3df0: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
3df4: 48 83 c7 20 add $0x20,%rdi | |
3df8: 48 83 c0 20 add $0x20,%rax | |
3dfc: 0f 11 5f e0 movups %xmm3,-0x20(%rdi) | |
3e00: f3 0f 6f 60 f0 movdqu -0x10(%rax),%xmm4 | |
3e05: 0f 11 67 f0 movups %xmm4,-0x10(%rdi) | |
while (op < oend); | |
3e09: 48 39 fd cmp %rdi,%rbp | |
3e0c: 77 e2 ja 3df0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xbf0> | |
if (ZSTD_isError(oneSeqSize)) return oneSeqSize; | |
3e0e: 48 83 f9 88 cmp $0xffffffffffffff88,%rcx | |
3e12: 0f 87 d8 06 00 00 ja 44f0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x12f0> | |
op += oneSeqSize; | |
3e18: 49 01 cc add %rcx,%r12 | |
for ( ; seqNb<nbSeq ; seqNb++) { | |
3e1b: 41 83 c5 01 add $0x1,%r13d | |
3e1f: 44 39 ac 24 a0 00 00 cmp %r13d,0xa0(%rsp) | |
3e26: 00 | |
3e27: 0f 85 9b fe ff ff jne 3cc8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xac8> | |
3e2d: 4d 89 e2 mov %r12,%r10 | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
3e30: 48 8b 9c 24 88 00 00 mov 0x88(%rsp),%rbx | |
3e37: 00 | |
3e38: 48 8b 84 24 58 01 00 mov 0x158(%rsp),%rax | |
3e3f: 00 | |
{ size_t const lastLLSize = litEnd - litPtr; | |
3e40: 48 8b b4 24 b8 00 00 mov 0xb8(%rsp),%rsi | |
3e47: 00 | |
3e48: 48 8b 54 24 78 mov 0x78(%rsp),%rdx | |
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } | |
3e4d: 89 83 3c 68 00 00 mov %eax,0x683c(%rbx) | |
3e53: 48 8b 84 24 60 01 00 mov 0x160(%rsp),%rax | |
3e5a: 00 | |
3e5b: 89 83 40 68 00 00 mov %eax,0x6840(%rbx) | |
3e61: 48 8b 84 24 68 01 00 mov 0x168(%rsp),%rax | |
3e68: 00 | |
3e69: 89 83 44 68 00 00 mov %eax,0x6844(%rbx) | |
3e6f: 48 8b 5c 24 40 mov 0x40(%rsp),%rbx | |
3e74: e9 af f4 ff ff jmpq 3328 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x128> | |
3e79: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
if (LIKELY((ofBits == 0))) { | |
3e80: 0f 84 0a 04 00 00 je 4290 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1090> | |
if (LIKELY(!ll0)) | |
3e86: 45 85 ff test %r15d,%r15d | |
3e89: 0f 85 f8 fa ff ff jne 3987 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x787> | |
offset = seqState->prevOffset[1]; | |
3e8f: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
3e96: 00 | |
seqState->prevOffset[1] = seqState->prevOffset[0]; | |
3e97: 48 89 9c 24 60 01 00 mov %rbx,0x160(%rsp) | |
3e9e: 00 | |
seqState->prevOffset[0] = offset; | |
3e9f: 48 89 8c 24 58 01 00 mov %rcx,0x158(%rsp) | |
3ea6: 00 | |
offset = seqState->prevOffset[1]; | |
3ea7: 48 89 cb mov %rcx,%rbx | |
3eaa: e9 d8 fa ff ff jmpq 3987 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x787> | |
3eaf: 90 nop | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3eb0: 45 89 d9 mov %r11d,%r9d | |
3eb3: c4 e2 f9 f7 ca shlx %rax,%rdx,%rcx | |
bitD->bitsConsumed += nbBits; | |
3eb8: 44 01 d8 add %r11d,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3ebb: 41 f7 d9 neg %r9d | |
3ebe: c4 e2 b3 f7 c9 shrx %r9,%rcx,%rcx | |
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/); | |
3ec3: 49 01 ca add %rcx,%r10 | |
3ec6: e9 e8 fa ff ff jmpq 39b3 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x7b3> | |
3ecb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
3ed0: 89 e9 mov %ebp,%ecx | |
3ed2: c4 e2 f9 f7 94 24 00 shlx %rax,0x100(%rsp),%rdx | |
3ed9: 01 00 00 | |
bitD->bitsConsumed += nbBits; | |
3edc: 01 e8 add %ebp,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3ede: f7 d9 neg %ecx | |
bitD->bitsConsumed += nbBits; | |
3ee0: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
3ee7: c4 e2 f3 f7 d2 shrx %rcx,%rdx,%rdx | |
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/); | |
3eec: 48 01 54 24 20 add %rdx,0x20(%rsp) | |
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog))) | |
3ef1: 41 80 fc 1e cmp $0x1e,%r12b | |
3ef5: 0f 86 a4 fa ff ff jbe 399f <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x79f> | |
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */ | |
3efb: 83 f8 40 cmp $0x40,%eax | |
3efe: 0f 87 9b fa ff ff ja 399f <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x79f> | |
if (bitD->ptr >= bitD->limitPtr) { | |
3f04: 4c 39 54 24 30 cmp %r10,0x30(%rsp) | |
3f09: 0f 86 a4 04 00 00 jbe 43b3 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x11b3> | |
if (bitD->ptr == bitD->start) { | |
3f0f: 4c 8b 8c 24 18 01 00 mov 0x118(%rsp),%r9 | |
3f16: 00 | |
3f17: 4d 39 d1 cmp %r10,%r9 | |
3f1a: 0f 84 7f fa ff ff je 399f <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x79f> | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
3f20: 89 c2 mov %eax,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
3f22: 4c 89 d1 mov %r10,%rcx | |
{ U32 nbBytes = bitD->bitsConsumed >> 3; | |
3f25: c1 ea 03 shr $0x3,%edx | |
if (bitD->ptr - nbBytes < bitD->start) { | |
3f28: 89 d5 mov %edx,%ebp | |
3f2a: 48 29 e9 sub %rbp,%rcx | |
3f2d: 49 39 c9 cmp %rcx,%r9 | |
3f30: 76 11 jbe 3f43 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd43> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
3f32: 4c 89 d1 mov %r10,%rcx | |
3f35: 4c 29 c9 sub %r9,%rcx | |
bitD->ptr -= nbBytes; | |
3f38: 41 89 c9 mov %ecx,%r9d | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
3f3b: 89 ca mov %ecx,%edx | |
bitD->ptr -= nbBytes; | |
3f3d: 4c 89 d1 mov %r10,%rcx | |
3f40: 4c 29 c9 sub %r9,%rcx | |
bitD->bitsConsumed -= nbBytes*8; | |
3f43: c1 e2 03 shl $0x3,%edx | |
bitD->ptr -= nbBytes; | |
3f46: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp) | |
3f4d: 00 | |
bitD->bitsConsumed -= nbBytes*8; | |
3f4e: 29 d0 sub %edx,%eax | |
3f50: 48 8b 11 mov (%rcx),%rdx | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */ | |
3f53: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
3f5a: 00 | |
return result; | |
3f5b: e9 47 fa ff ff jmpq 39a7 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x7a7> | |
3f60: 44 8b 7c 24 08 mov 0x8(%rsp),%r15d | |
3f65: 4d 89 f2 mov %r14,%r10 | |
3f68: e9 0a fd ff ff jmpq 3c77 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa77> | |
3f6d: 0f 1f 00 nopl (%rax) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
3f70: 4c 89 c2 mov %r8,%rdx | |
3f73: 4c 89 54 24 30 mov %r10,0x30(%rsp) | |
3f78: e8 00 00 00 00 callq 3f7d <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xd7d> | |
return sequenceLength; | |
3f7d: 4c 8b 54 24 30 mov 0x30(%rsp),%r10 | |
3f82: e9 f7 fb ff ff jmpq 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
3f87: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
3f8e: 00 00 | |
3f90: 4c 89 54 24 30 mov %r10,0x30(%rsp) | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
3f95: 48 8d 94 24 b8 00 00 lea 0xb8(%rsp),%rdx | |
3f9c: 00 | |
3f9d: 4c 89 f7 mov %r14,%rdi | |
3fa0: ff 74 24 28 pushq 0x28(%rsp) | |
3fa4: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
3fab: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
3fb2: ff b4 24 d8 00 00 00 pushq 0xd8(%rsp) | |
3fb9: 4c 8b 8c 24 b0 00 00 mov 0xb0(%rsp),%r9 | |
3fc0: 00 | |
3fc1: 4c 8b 44 24 38 mov 0x38(%rsp),%r8 | |
3fc6: 48 8b 4c 24 60 mov 0x60(%rsp),%rcx | |
3fcb: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi | |
3fd2: 00 | |
3fd3: e8 e8 c5 ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
3fd8: 48 83 c4 20 add $0x20,%rsp | |
3fdc: 4c 8b 54 24 30 mov 0x30(%rsp),%r10 | |
3fe1: 49 89 c5 mov %rax,%r13 | |
3fe4: e9 95 fb ff ff jmpq 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
3fe9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
3ff0: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
3ff7: e9 6b fc ff ff jmpq 3c67 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa67> | |
3ffc: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
4000: f3 0f 6f 62 10 movdqu 0x10(%rdx),%xmm4 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
4005: 48 83 ee 10 sub $0x10,%rsi | |
4009: 41 0f 11 66 10 movups %xmm4,0x10(%r14) | |
if (16 >= length) return; | |
400e: 48 83 fe 10 cmp $0x10,%rsi | |
4012: 0f 8e a0 fa ff ff jle 3ab8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x8b8> | |
op += 16; | |
4018: 49 8d 76 20 lea 0x20(%r14),%rsi | |
ip += 16; | |
401c: 48 83 c2 20 add $0x20,%rdx | |
ZSTD_memcpy(dst, src, 16); | |
4020: f3 0f 6f 3a movdqu (%rdx),%xmm7 | |
4024: 48 83 c6 20 add $0x20,%rsi | |
4028: 48 83 c2 20 add $0x20,%rdx | |
402c: 0f 11 7e e0 movups %xmm7,-0x20(%rsi) | |
4030: f3 0f 6f 72 f0 movdqu -0x10(%rdx),%xmm6 | |
4035: 0f 11 76 f0 movups %xmm6,-0x10(%rsi) | |
while (op < oend); | |
4039: 48 39 f7 cmp %rsi,%rdi | |
403c: 77 e2 ja 4020 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xe20> | |
403e: e9 75 fa ff ff jmpq 3ab8 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x8b8> | |
4043: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
4048: 44 8b 74 24 08 mov 0x8(%rsp),%r14d | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
404d: c4 c2 f9 f7 f8 shlx %rax,%r8,%rdi | |
bitD->bitsConsumed += nbBits; | |
4052: 83 c0 01 add $0x1,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
4055: 48 c1 ef 3f shr $0x3f,%rdi | |
4059: 83 fa 01 cmp $0x1,%edx | |
405c: 41 83 d6 00 adc $0x0,%r14d | |
4060: 49 01 fe add %rdi,%r14 | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
4063: 49 83 fe 03 cmp $0x3,%r14 | |
4067: 74 34 je 409d <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xe9d> | |
4069: 4a 8b bc f4 58 01 00 mov 0x158(%rsp,%r14,8),%rdi | |
4070: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
4071: 48 83 ff 01 cmp $0x1,%rdi | |
4075: 48 83 d7 00 adc $0x0,%rdi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
4079: 49 83 fe 01 cmp $0x1,%r14 | |
407d: 75 2e jne 40ad <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xead> | |
seqState->prevOffset[0] = offset = temp; | |
407f: 66 48 0f 6e fe movq %rsi,%xmm7 | |
4084: 66 48 0f 6e c7 movq %rdi,%xmm0 | |
4089: 48 89 fe mov %rdi,%rsi | |
408c: 66 0f 6c c7 punpcklqdq %xmm7,%xmm0 | |
4090: 0f 11 84 24 58 01 00 movups %xmm0,0x158(%rsp) | |
4097: 00 | |
4098: e9 a6 f4 ff ff jmpq 3543 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x343> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
409d: 49 89 f6 mov %rsi,%r14 | |
40a0: 31 ff xor %edi,%edi | |
40a2: 49 83 ee 01 sub $0x1,%r14 | |
40a6: 40 0f 94 c7 sete %dil | |
40aa: 4c 01 f7 add %r14,%rdi | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
40ad: 4c 8b b4 24 60 01 00 mov 0x160(%rsp),%r14 | |
40b4: 00 | |
40b5: 4c 89 b4 24 68 01 00 mov %r14,0x168(%rsp) | |
40bc: 00 | |
40bd: eb c0 jmp 407f <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xe7f> | |
40bf: 84 d2 test %dl,%dl | |
40c1: 0f 85 92 01 00 00 jne 4259 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1059> | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
40c7: 48 8b 9c 24 a8 00 00 mov 0xa8(%rsp),%rbx | |
40ce: 00 | |
40cf: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
40d6: e9 69 f7 ff ff jmpq 3844 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x644> | |
40db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
if (offset < 8) { | |
40e0: 49 83 ff 07 cmp $0x7,%r15 | |
40e4: 0f 86 2f 01 00 00 jbe 4219 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1019> | |
ZSTD_memcpy(dst, src, 8); | |
40ea: 48 8b 10 mov (%rax),%rdx | |
40ed: 48 89 17 mov %rdx,(%rdi) | |
if (sequence.matchLength > 8) { | |
40f0: 49 83 f8 08 cmp $0x8,%r8 | |
40f4: 0f 86 84 fa ff ff jbe 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
*op += 8; | |
40fa: 48 8d 57 08 lea 0x8(%rdi),%rdx | |
*ip += 8; | |
40fe: 48 8d 48 08 lea 0x8(%rax),%rcx | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
4102: 48 89 d6 mov %rdx,%rsi | |
4105: 48 29 ce sub %rcx,%rsi | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
4108: 48 83 fe 0f cmp $0xf,%rsi | |
410c: 0f 8f 08 04 00 00 jg 451a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x131a> | |
4112: 48 8d 75 f7 lea -0x9(%rbp),%rsi | |
4116: 4c 8d 4f 09 lea 0x9(%rdi),%r9 | |
411a: 48 29 fe sub %rdi,%rsi | |
411d: 49 89 f3 mov %rsi,%r11 | |
4120: 48 89 d6 mov %rdx,%rsi | |
4123: 48 29 c6 sub %rax,%rsi | |
4126: 48 83 ee 09 sub $0x9,%rsi | |
412a: 48 83 fe 0e cmp $0xe,%rsi | |
412e: 0f 86 cc 00 00 00 jbe 4200 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1000> | |
4134: 49 83 fb 1f cmp $0x1f,%r11 | |
4138: 41 0f 97 c0 seta %r8b | |
413c: 4c 39 cd cmp %r9,%rbp | |
413f: 40 0f 93 c6 setae %sil | |
4143: 41 84 f0 test %sil,%r8b | |
4146: 0f 84 b4 00 00 00 je 4200 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1000> | |
414c: 4c 89 de mov %r11,%rsi | |
414f: 48 c1 ee 03 shr $0x3,%rsi | |
4153: 48 83 c6 01 add $0x1,%rsi | |
4157: 4c 39 cd cmp %r9,%rbp | |
415a: 41 b9 01 00 00 00 mov $0x1,%r9d | |
4160: 4c 0f 43 ce cmovae %rsi,%r9 | |
4164: be 08 00 00 00 mov $0x8,%esi | |
4169: 4d 89 c8 mov %r9,%r8 | |
416c: 49 d1 e8 shr %r8 | |
416f: 49 c1 e0 04 shl $0x4,%r8 | |
4173: 49 83 c0 08 add $0x8,%r8 | |
4177: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
417e: 00 00 | |
ZSTD_memcpy(dst, src, 8); | |
4180: f3 0f 6f 34 30 movdqu (%rax,%rsi,1),%xmm6 | |
4185: 0f 11 34 37 movups %xmm6,(%rdi,%rsi,1) | |
} while (op < oend); | |
4189: 48 83 c6 10 add $0x10,%rsi | |
418d: 4c 39 c6 cmp %r8,%rsi | |
4190: 75 ee jne 4180 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xf80> | |
4192: 4c 89 c8 mov %r9,%rax | |
4195: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
4199: 48 8d 34 c5 00 00 00 lea 0x0(,%rax,8),%rsi | |
41a0: 00 | |
41a1: 48 01 f1 add %rsi,%rcx | |
41a4: 48 01 f2 add %rsi,%rdx | |
41a7: 4c 39 c8 cmp %r9,%rax | |
41aa: 0f 84 ce f9 ff ff je 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
ZSTD_memcpy(dst, src, 8); | |
41b0: 48 8b 01 mov (%rcx),%rax | |
41b3: 48 89 02 mov %rax,(%rdx) | |
} while (op < oend); | |
41b6: e9 c3 f9 ff ff jmpq 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
41bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
41c0: 89 c1 mov %eax,%ecx | |
bitD->bitsConsumed &= 7; | |
41c2: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
41c5: c1 e9 03 shr $0x3,%ecx | |
41c8: 48 29 cb sub %rcx,%rbx | |
41cb: 4c 8b 03 mov (%rbx),%r8 | |
return BIT_reloadDStreamFast(bitD); | |
41ce: c6 44 24 50 01 movb $0x1,0x50(%rsp) | |
41d3: e9 83 f3 ff ff jmpq 355b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x35b> | |
41d8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
41df: 00 | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
41e0: 45 31 ff xor %r15d,%r15d | |
41e3: e9 7f fa ff ff jmpq 3c67 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa67> | |
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */ | |
41e8: 48 89 df mov %rbx,%rdi | |
41eb: 4c 29 f7 sub %r14,%rdi | |
41ee: 89 f9 mov %edi,%ecx | |
bitD->ptr -= nbBytes; | |
41f0: 89 ff mov %edi,%edi | |
41f2: 48 29 fb sub %rdi,%rbx | |
41f5: e9 d6 f5 ff ff jmpq 37d0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x5d0> | |
41fa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dst, src, 8); | |
4200: 48 8b 01 mov (%rcx),%rax | |
COPY8(op, ip) | |
4203: 48 83 c2 08 add $0x8,%rdx | |
4207: 48 83 c1 08 add $0x8,%rcx | |
ZSTD_memcpy(dst, src, 8); | |
420b: 48 89 42 f8 mov %rax,-0x8(%rdx) | |
} while (op < oend); | |
420f: 48 39 d5 cmp %rdx,%rbp | |
4212: 77 ec ja 4200 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1000> | |
4214: e9 65 f9 ff ff jmpq 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
(*op)[0] = (*ip)[0]; | |
4219: 0f b6 10 movzbl (%rax),%edx | |
*ip += dec32table[offset]; | |
421c: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 4223 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1023> | |
(*op)[0] = (*ip)[0]; | |
4223: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
4225: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
4229: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
422c: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
4230: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
4233: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
4237: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
423a: 42 8b 14 be mov (%rsi,%r15,4),%edx | |
*ip -= sub2; | |
423e: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 4245 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1045> | |
*ip += dec32table[offset]; | |
4245: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
4248: 8b 10 mov (%rax),%edx | |
424a: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
424d: 4a 63 14 be movslq (%rsi,%r15,4),%rdx | |
4251: 48 29 d0 sub %rdx,%rax | |
4254: e9 97 fe ff ff jmpq 40f0 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xef0> | |
4259: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
4260: 48 8b 9c 24 a8 00 00 mov 0xa8(%rsp),%rbx | |
4267: 00 | |
4268: e9 ce f5 ff ff jmpq 383b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x63b> | |
426d: 0f 1f 00 nopl (%rax) | |
ZSTD_memmove(oLitEnd, match, sequence.matchLength); | |
4270: 4c 89 ca mov %r9,%rdx | |
4273: 48 89 4c 24 10 mov %rcx,0x10(%rsp) | |
4278: e8 00 00 00 00 callq 427d <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x107d> | |
return sequenceLength; | |
427d: 48 8b 4c 24 10 mov 0x10(%rsp),%rcx | |
4282: e9 87 fb ff ff jmpq 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
4287: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
428e: 00 00 | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
4290: c4 e2 f9 f7 8c 24 00 shlx %rax,0x100(%rsp),%rcx | |
4297: 01 00 00 | |
bitD->bitsConsumed += nbBits; | |
429a: 83 c0 01 add $0x1,%eax | |
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask); | |
429d: 48 c1 e9 3f shr $0x3f,%rcx | |
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1); | |
42a1: 41 83 ff 01 cmp $0x1,%r15d | |
42a5: 41 83 d1 00 adc $0x0,%r9d | |
bitD->bitsConsumed += nbBits; | |
42a9: 89 84 24 08 01 00 00 mov %eax,0x108(%rsp) | |
42b0: 4c 01 c9 add %r9,%rcx | |
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset]; | |
42b3: 48 83 f9 03 cmp $0x3,%rcx | |
42b7: 0f 84 47 02 00 00 je 4504 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1304> | |
42bd: 4c 8b 8c cc 58 01 00 mov 0x158(%rsp,%rcx,8),%r9 | |
42c4: 00 | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
42c5: 49 83 f9 01 cmp $0x1,%r9 | |
42c9: 49 83 d1 00 adc $0x0,%r9 | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
42cd: 48 83 f9 01 cmp $0x1,%rcx | |
42d1: 74 10 je 42e3 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x10e3> | |
42d3: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx | |
42da: 00 | |
42db: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp) | |
42e2: 00 | |
seqState->prevOffset[0] = offset = temp; | |
42e3: 66 48 0f 6e e3 movq %rbx,%xmm4 | |
42e8: 66 49 0f 6e c1 movq %r9,%xmm0 | |
42ed: 4c 89 cb mov %r9,%rbx | |
42f0: 66 0f 6c c4 punpcklqdq %xmm4,%xmm0 | |
42f4: 0f 11 84 24 58 01 00 movups %xmm0,0x158(%rsp) | |
42fb: 00 | |
42fc: e9 86 f6 ff ff jmpq 3987 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x787> | |
4301: 41 89 df mov %ebx,%r15d | |
4304: 4d 89 f2 mov %r14,%r10 | |
4307: e9 79 f9 ff ff jmpq 3c85 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xa85> | |
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd); | |
430c: 66 49 0f 6e f1 movq %r9,%xmm6 | |
4311: 66 48 0f 6e c2 movq %rdx,%xmm0 | |
4316: 4c 89 f1 mov %r14,%rcx | |
4319: 4d 89 f8 mov %r15,%r8 | |
431c: 66 0f 6c c6 punpcklqdq %xmm6,%xmm0 | |
4320: 4c 89 e7 mov %r12,%rdi | |
4323: 0f 29 84 24 e0 00 00 movaps %xmm0,0xe0(%rsp) | |
432a: 00 | |
432b: ff 74 24 28 pushq 0x28(%rsp) | |
432f: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
4336: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
433d: ff b4 24 f8 00 00 00 pushq 0xf8(%rsp) | |
4344: 4c 8b 8c 24 b0 00 00 mov 0xb0(%rsp),%r9 | |
434b: 00 | |
434c: 48 8b 54 24 50 mov 0x50(%rsp),%rdx | |
4351: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi | |
4358: 00 | |
4359: e8 62 c2 ff ff callq 5c0 <ZSTD_execSequenceEnd> | |
435e: 48 83 c4 20 add $0x20,%rsp | |
4362: 48 89 c1 mov %rax,%rcx | |
4365: e9 a4 fa ff ff jmpq 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
ZSTD_memcpy(dst, src, 16); | |
436a: f3 0f 6f 7e 10 movdqu 0x10(%rsi),%xmm7 | |
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap); | |
436f: 48 83 ea 10 sub $0x10,%rdx | |
4373: 41 0f 11 7c 24 10 movups %xmm7,0x10(%r12) | |
if (16 >= length) return; | |
4379: 48 83 fa 10 cmp $0x10,%rdx | |
437d: 0f 8e d1 f9 ff ff jle 3d54 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xb54> | |
op += 16; | |
4383: 49 8d 54 24 20 lea 0x20(%r12),%rdx | |
ip += 16; | |
4388: 48 83 c6 20 add $0x20,%rsi | |
438c: 0f 1f 40 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dst, src, 16); | |
4390: f3 0f 6f 26 movdqu (%rsi),%xmm4 | |
4394: 48 83 c2 20 add $0x20,%rdx | |
4398: 48 83 c6 20 add $0x20,%rsi | |
439c: 0f 11 62 e0 movups %xmm4,-0x20(%rdx) | |
43a0: f3 0f 6f 6e f0 movdqu -0x10(%rsi),%xmm5 | |
43a5: 0f 11 6a f0 movups %xmm5,-0x10(%rdx) | |
while (op < oend); | |
43a9: 48 39 d7 cmp %rdx,%rdi | |
43ac: 77 e2 ja 4390 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1190> | |
43ae: e9 a1 f9 ff ff jmpq 3d54 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xb54> | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
43b3: 89 c2 mov %eax,%edx | |
bitD->bitsConsumed &= 7; | |
43b5: 83 e0 07 and $0x7,%eax | |
bitD->ptr -= bitD->bitsConsumed >> 3; | |
43b8: c1 ea 03 shr $0x3,%edx | |
43bb: 49 29 d2 sub %rdx,%r10 | |
43be: 49 8b 12 mov (%r10),%rdx | |
43c1: 4c 89 94 24 10 01 00 mov %r10,0x110(%rsp) | |
43c8: 00 | |
bitD->bitContainer = MEM_readLEST(bitD->ptr); | |
43c9: 48 89 94 24 00 01 00 mov %rdx,0x100(%rsp) | |
43d0: 00 | |
return BIT_reloadDStreamFast(bitD); | |
43d1: e9 d1 f5 ff ff jmpq 39a7 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x7a7> | |
if (offset < 8) { | |
43d6: 48 83 fb 07 cmp $0x7,%rbx | |
43da: 0f 87 7b 01 00 00 ja 455b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x135b> | |
(*op)[0] = (*ip)[0]; | |
43e0: 0f b6 10 movzbl (%rax),%edx | |
*ip += dec32table[offset]; | |
43e3: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 43ea <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x11ea> | |
(*op)[0] = (*ip)[0]; | |
43ea: 88 17 mov %dl,(%rdi) | |
(*op)[1] = (*ip)[1]; | |
43ec: 0f b6 50 01 movzbl 0x1(%rax),%edx | |
43f0: 88 57 01 mov %dl,0x1(%rdi) | |
(*op)[2] = (*ip)[2]; | |
43f3: 0f b6 50 02 movzbl 0x2(%rax),%edx | |
43f7: 88 57 02 mov %dl,0x2(%rdi) | |
(*op)[3] = (*ip)[3]; | |
43fa: 0f b6 50 03 movzbl 0x3(%rax),%edx | |
43fe: 88 57 03 mov %dl,0x3(%rdi) | |
*ip += dec32table[offset]; | |
4401: 8b 14 9e mov (%rsi,%rbx,4),%edx | |
*ip -= sub2; | |
4404: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 440b <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x120b> | |
*ip += dec32table[offset]; | |
440b: 48 01 d0 add %rdx,%rax | |
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } | |
440e: 8b 10 mov (%rax),%edx | |
4410: 89 57 04 mov %edx,0x4(%rdi) | |
*ip -= sub2; | |
4413: 48 63 14 9e movslq (%rsi,%rbx,4),%rdx | |
4417: 48 29 d0 sub %rdx,%rax | |
if (sequence.matchLength > 8) { | |
441a: 49 83 f9 08 cmp $0x8,%r9 | |
441e: 0f 86 ea f9 ff ff jbe 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
*op += 8; | |
4424: 48 8d 57 08 lea 0x8(%rdi),%rdx | |
*ip += 8; | |
4428: 48 8d 70 08 lea 0x8(%rax),%rsi | |
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src; | |
442c: 49 89 d3 mov %rdx,%r11 | |
442f: 49 29 f3 sub %rsi,%r11 | |
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) { | |
4432: 49 83 fb 0f cmp $0xf,%r11 | |
4436: 0f 8f 2a 01 00 00 jg 4566 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1366> | |
443c: 4c 8d 4d f7 lea -0x9(%rbp),%r9 | |
4440: 48 8d 5f 09 lea 0x9(%rdi),%rbx | |
4444: 4d 89 c8 mov %r9,%r8 | |
4447: 49 89 d1 mov %rdx,%r9 | |
444a: 49 29 c1 sub %rax,%r9 | |
444d: 49 29 f8 sub %rdi,%r8 | |
4450: 49 83 e9 09 sub $0x9,%r9 | |
4454: 49 83 f9 0e cmp $0xe,%r9 | |
4458: 76 7c jbe 44d6 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x12d6> | |
445a: 48 39 eb cmp %rbp,%rbx | |
445d: 41 0f 96 c3 setbe %r11b | |
4461: 49 83 f8 1f cmp $0x1f,%r8 | |
4465: 41 0f 97 c1 seta %r9b | |
4469: 45 84 cb test %r9b,%r11b | |
446c: 74 68 je 44d6 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x12d6> | |
446e: 49 c1 e8 03 shr $0x3,%r8 | |
4472: 4d 89 c1 mov %r8,%r9 | |
4475: 49 83 c1 01 add $0x1,%r9 | |
4479: 48 39 eb cmp %rbp,%rbx | |
447c: bb 01 00 00 00 mov $0x1,%ebx | |
4481: 49 0f 46 d9 cmovbe %r9,%rbx | |
4485: 41 b9 08 00 00 00 mov $0x8,%r9d | |
448b: 49 89 db mov %rbx,%r11 | |
448e: 49 d1 eb shr %r11 | |
4491: 49 c1 e3 04 shl $0x4,%r11 | |
4495: 49 83 c3 08 add $0x8,%r11 | |
ZSTD_memcpy(dst, src, 8); | |
4499: f3 42 0f 6f 1c 08 movdqu (%rax,%r9,1),%xmm3 | |
449f: 42 0f 11 1c 0f movups %xmm3,(%rdi,%r9,1) | |
} while (op < oend); | |
44a4: 49 83 c1 10 add $0x10,%r9 | |
44a8: 4d 39 d9 cmp %r11,%r9 | |
44ab: 75 ec jne 4499 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1299> | |
44ad: 48 89 d8 mov %rbx,%rax | |
44b0: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
44b4: 48 8d 3c c5 00 00 00 lea 0x0(,%rax,8),%rdi | |
44bb: 00 | |
44bc: 48 01 fe add %rdi,%rsi | |
44bf: 48 01 fa add %rdi,%rdx | |
44c2: 48 39 d8 cmp %rbx,%rax | |
44c5: 0f 84 43 f9 ff ff je 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
ZSTD_memcpy(dst, src, 8); | |
44cb: 48 8b 06 mov (%rsi),%rax | |
44ce: 48 89 02 mov %rax,(%rdx) | |
} while (op < oend); | |
44d1: e9 38 f9 ff ff jmpq 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
ZSTD_memcpy(dst, src, 8); | |
44d6: 48 8b 06 mov (%rsi),%rax | |
COPY8(op, ip) | |
44d9: 48 83 c2 08 add $0x8,%rdx | |
44dd: 48 83 c6 08 add $0x8,%rsi | |
ZSTD_memcpy(dst, src, 8); | |
44e1: 48 89 42 f8 mov %rax,-0x8(%rdx) | |
} while (op < oend); | |
44e5: 48 39 d5 cmp %rdx,%rbp | |
44e8: 77 ec ja 44d6 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x12d6> | |
44ea: e9 1f f9 ff ff jmpq 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
44ef: 90 nop | |
44f0: 49 89 cd mov %rcx,%r13 | |
44f3: e9 0f ee ff ff jmpq 3307 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x107> | |
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { | |
44f8: 8b 84 24 a4 00 00 00 mov 0xa4(%rsp),%eax | |
44ff: e9 2f f3 ff ff jmpq 3833 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x633> | |
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */ | |
4504: 48 89 d9 mov %rbx,%rcx | |
4507: 45 31 c9 xor %r9d,%r9d | |
450a: 48 83 e9 01 sub $0x1,%rcx | |
450e: 41 0f 94 c1 sete %r9b | |
4512: 49 01 c9 add %rcx,%r9 | |
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1]; | |
4515: e9 b9 fd ff ff jmpq 42d3 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x10d3> | |
ZSTD_memcpy(dst, src, 16); | |
451a: f3 0f 6f 70 08 movdqu 0x8(%rax),%xmm6 | |
451f: 0f 11 77 08 movups %xmm6,0x8(%rdi) | |
if (16 >= length) return; | |
4523: 49 83 f8 18 cmp $0x18,%r8 | |
4527: 0f 8e 51 f6 ff ff jle 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
op += 16; | |
452d: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
4531: 48 83 c0 18 add $0x18,%rax | |
4535: 0f 1f 00 nopl (%rax) | |
ZSTD_memcpy(dst, src, 16); | |
4538: f3 0f 6f 18 movdqu (%rax),%xmm3 | |
453c: 48 83 c7 20 add $0x20,%rdi | |
4540: 48 83 c0 20 add $0x20,%rax | |
4544: 0f 11 5f e0 movups %xmm3,-0x20(%rdi) | |
4548: f3 0f 6f 68 f0 movdqu -0x10(%rax),%xmm5 | |
454d: 0f 11 6f f0 movups %xmm5,-0x10(%rdi) | |
while (op < oend); | |
4551: 48 39 fd cmp %rdi,%rbp | |
4554: 77 e2 ja 4538 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1338> | |
4556: e9 23 f6 ff ff jmpq 3b7e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x97e> | |
ZSTD_memcpy(dst, src, 8); | |
455b: 48 8b 10 mov (%rax),%rdx | |
455e: 48 89 17 mov %rdx,(%rdi) | |
} | |
4561: e9 b4 fe ff ff jmpq 441a <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x121a> | |
ZSTD_memcpy(dst, src, 16); | |
4566: f3 0f 6f 58 08 movdqu 0x8(%rax),%xmm3 | |
456b: 0f 11 5f 08 movups %xmm3,0x8(%rdi) | |
if (16 >= length) return; | |
456f: 49 83 f9 18 cmp $0x18,%r9 | |
4573: 0f 8e 95 f8 ff ff jle 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
op += 16; | |
4579: 48 83 c7 18 add $0x18,%rdi | |
ip += 16; | |
457d: 48 83 c0 18 add $0x18,%rax | |
ZSTD_memcpy(dst, src, 16); | |
4581: f3 0f 6f 28 movdqu (%rax),%xmm5 | |
4585: 48 83 c7 20 add $0x20,%rdi | |
4589: 48 83 c0 20 add $0x20,%rax | |
458d: 0f 11 6f e0 movups %xmm5,-0x20(%rdi) | |
4591: f3 0f 6f 60 f0 movdqu -0x10(%rax),%xmm4 | |
4596: 0f 11 67 f0 movups %xmm4,-0x10(%rdi) | |
while (op < oend); | |
459a: 48 39 fd cmp %rdi,%rbp | |
459d: 77 e2 ja 4581 <ZSTD_decompressSequencesLong_bmi2.constprop.0+0x1381> | |
459f: e9 6a f8 ff ff jmpq 3e0e <ZSTD_decompressSequencesLong_bmi2.constprop.0+0xc0e> | |
45a4: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
45ab: 00 00 00 00 | |
45af: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
45b6: 00 00 00 00 | |
45ba: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
00000000000045c0 <ZSTD_getcBlockSize>: | |
RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, ""); | |
45c0: 49 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%r8 | |
45c7: 48 83 fe 02 cmp $0x2,%rsi | |
45cb: 76 3c jbe 4609 <ZSTD_getcBlockSize+0x49> | |
} | |
} | |
MEM_STATIC U32 MEM_readLE24(const void* memPtr) | |
{ | |
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16); | |
45cd: 0f b6 47 02 movzbl 0x2(%rdi),%eax | |
45d1: 0f b7 0f movzwl (%rdi),%ecx | |
if (bpPtr->blockType == bt_rle) return 1; | |
45d4: 41 b8 01 00 00 00 mov $0x1,%r8d | |
45da: c1 e0 10 shl $0x10,%eax | |
45dd: 01 c8 add %ecx,%eax | |
U32 const cSize = cBlockHeader >> 3; | |
45df: 89 c1 mov %eax,%ecx | |
bpPtr->lastBlock = cBlockHeader & 1; | |
45e1: 89 c6 mov %eax,%esi | |
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3); | |
45e3: d1 e8 shr %eax | |
U32 const cSize = cBlockHeader >> 3; | |
45e5: c1 e9 03 shr $0x3,%ecx | |
bpPtr->lastBlock = cBlockHeader & 1; | |
45e8: 83 e6 01 and $0x1,%esi | |
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3); | |
45eb: 83 e0 03 and $0x3,%eax | |
bpPtr->lastBlock = cBlockHeader & 1; | |
45ee: 89 72 04 mov %esi,0x4(%rdx) | |
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3); | |
45f1: 89 02 mov %eax,(%rdx) | |
bpPtr->origSize = cSize; /* only useful for RLE */ | |
45f3: 89 4a 08 mov %ecx,0x8(%rdx) | |
if (bpPtr->blockType == bt_rle) return 1; | |
45f6: 83 f8 01 cmp $0x1,%eax | |
45f9: 74 0e je 4609 <ZSTD_getcBlockSize+0x49> | |
return cSize; | |
45fb: 83 f8 03 cmp $0x3,%eax | |
45fe: 49 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%r8 | |
4605: 4c 0f 45 c1 cmovne %rcx,%r8 | |
} | |
4609: 4c 89 c0 mov %r8,%rax | |
460c: c3 retq | |
460d: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4614: 00 00 00 00 | |
4618: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
461f: 00 | |
0000000000004620 <ZSTD_decodeLiteralsBlock>: | |
{ | |
4620: 41 57 push %r15 | |
4622: 41 56 push %r14 | |
4624: 41 55 push %r13 | |
4626: 41 54 push %r12 | |
4628: 55 push %rbp | |
4629: 53 push %rbx | |
462a: 48 83 ec 08 sub $0x8,%rsp | |
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, ""); | |
462e: 48 83 fa 02 cmp $0x2,%rdx | |
4632: 76 6c jbe 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3); | |
4634: 0f b6 06 movzbl (%rsi),%eax | |
4637: 48 89 fd mov %rdi,%rbp | |
463a: 48 89 d7 mov %rdx,%rdi | |
463d: 89 c3 mov %eax,%ebx | |
463f: 83 e3 03 and $0x3,%ebx | |
switch(litEncType) | |
4642: 80 fb 02 cmp $0x2,%bl | |
4645: 0f 84 88 00 00 00 je 46d3 <ZSTD_decodeLiteralsBlock+0xb3> | |
464b: 80 fb 03 cmp $0x3,%bl | |
464e: 74 70 je 46c0 <ZSTD_decodeLiteralsBlock+0xa0> | |
4650: 80 fb 01 cmp $0x1,%bl | |
4653: 0f 84 df 01 00 00 je 4838 <ZSTD_decodeLiteralsBlock+0x218> | |
U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
4659: 89 c2 mov %eax,%edx | |
465b: c0 ea 02 shr $0x2,%dl | |
465e: 83 e2 03 and $0x3,%edx | |
switch(lhlCode) | |
4661: 80 fa 01 cmp $0x1,%dl | |
4664: 0f 84 b6 01 00 00 je 4820 <ZSTD_decodeLiteralsBlock+0x200> | |
466a: 80 fa 03 cmp $0x3,%dl | |
466d: 0f 84 3d 02 00 00 je 48b0 <ZSTD_decodeLiteralsBlock+0x290> | |
litSize = istart[0] >> 3; | |
4673: c0 e8 03 shr $0x3,%al | |
4676: 0f b6 d8 movzbl %al,%ebx | |
lhSize = 1; | |
4679: b8 01 00 00 00 mov $0x1,%eax | |
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */ | |
467e: 4c 8d 24 03 lea (%rbx,%rax,1),%r12 | |
4682: 49 8d 54 24 20 lea 0x20(%r12),%rdx | |
4687: 48 39 fa cmp %rdi,%rdx | |
468a: 0f 86 00 02 00 00 jbe 4890 <ZSTD_decodeLiteralsBlock+0x270> | |
RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, ""); | |
4690: 49 39 fc cmp %rdi,%r12 | |
4693: 0f 86 07 03 00 00 jbe 49a0 <ZSTD_decodeLiteralsBlock+0x380> | |
4699: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, ""); | |
46a0: 49 c7 c4 ec ff ff ff mov $0xffffffffffffffec,%r12 | |
} | |
46a7: 48 83 c4 08 add $0x8,%rsp | |
46ab: 4c 89 e0 mov %r12,%rax | |
46ae: 5b pop %rbx | |
46af: 5d pop %rbp | |
46b0: 41 5c pop %r12 | |
46b2: 41 5d pop %r13 | |
46b4: 41 5e pop %r14 | |
46b6: 41 5f pop %r15 | |
46b8: c3 retq | |
46b9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, ""); | |
46c0: 44 8b 95 28 75 00 00 mov 0x7528(%rbp),%r10d | |
46c7: 49 c7 c4 e2 ff ff ff mov $0xffffffffffffffe2,%r12 | |
46ce: 45 85 d2 test %r10d,%r10d | |
46d1: 74 d4 je 46a7 <ZSTD_decodeLiteralsBlock+0x87> | |
RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3"); | |
46d3: 48 83 ff 04 cmp $0x4,%rdi | |
46d7: 76 c7 jbe 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; } | |
46d9: 8b 0e mov (%rsi),%ecx | |
U32 const lhlCode = (istart[0] >> 2) & 3; | |
46db: c0 e8 02 shr $0x2,%al | |
46de: 83 e0 03 and $0x3,%eax | |
litSize = (lhc >> 4) & 0x3FF; | |
46e1: 41 89 cd mov %ecx,%r13d | |
46e4: 41 c1 ed 04 shr $0x4,%r13d | |
46e8: 3c 02 cmp $0x2,%al | |
46ea: 0f 84 10 01 00 00 je 4800 <ZSTD_decodeLiteralsBlock+0x1e0> | |
46f0: 3c 03 cmp $0x3,%al | |
46f2: 0f 84 d0 00 00 00 je 47c8 <ZSTD_decodeLiteralsBlock+0x1a8> | |
singleStream = !lhlCode; | |
46f8: 83 f0 01 xor $0x1,%eax | |
litCSize = (lhc >> 14) & 0x3FF; | |
46fb: c1 e9 0e shr $0xe,%ecx | |
litSize = (lhc >> 4) & 0x3FF; | |
46fe: 41 81 e5 ff 03 00 00 and $0x3ff,%r13d | |
lhSize = 3; | |
4705: 41 b8 03 00 00 00 mov $0x3,%r8d | |
singleStream = !lhlCode; | |
470b: 0f b6 d0 movzbl %al,%edx | |
litCSize = (lhc >> 14) & 0x3FF; | |
470e: 81 e1 ff 03 00 00 and $0x3ff,%ecx | |
RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, ""); | |
4714: 4d 8d 24 08 lea (%r8,%rcx,1),%r12 | |
4718: 49 39 fc cmp %rdi,%r12 | |
471b: 77 83 ja 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) { | |
471d: 44 8b 8d f4 75 00 00 mov 0x75f4(%rbp),%r9d | |
4724: 45 85 c9 test %r9d,%r9d | |
4727: 74 0d je 4736 <ZSTD_decodeLiteralsBlock+0x116> | |
4729: 49 81 fd 00 03 00 00 cmp $0x300,%r13 | |
4730: 0f 87 ad 02 00 00 ja 49e3 <ZSTD_decodeLiteralsBlock+0x3c3> | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
4736: 8b 85 d8 75 00 00 mov 0x75d8(%rbp),%eax | |
dctx->litBuffer, litSize, istart+lhSize, litCSize, | |
473c: 4e 8d 14 06 lea (%rsi,%r8,1),%r10 | |
4740: 4c 8d b5 90 76 00 00 lea 0x7690(%rbp),%r14 | |
if (litEncType==set_repeat) { | |
4747: 80 fb 03 cmp $0x3,%bl | |
474a: 0f 84 e0 01 00 00 je 4930 <ZSTD_decodeLiteralsBlock+0x310> | |
istart+lhSize, litCSize, dctx->workspace, | |
4750: 4c 8d 8d bc 6a 00 00 lea 0x6abc(%rbp),%r9 | |
dctx->entropy.hufTable, dctx->litBuffer, litSize, | |
4757: 4c 8d bd 38 28 00 00 lea 0x2838(%rbp),%r15 | |
if (singleStream) { | |
475e: 85 d2 test %edx,%edx | |
4760: 0f 84 12 02 00 00 je 4978 <ZSTD_decodeLiteralsBlock+0x358> | |
hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2( | |
4766: 50 push %rax | |
4767: 49 89 c8 mov %rcx,%r8 | |
476a: 4c 89 f6 mov %r14,%rsi | |
476d: 4c 89 ff mov %r15,%rdi | |
4770: 68 00 0a 00 00 pushq $0xa00 | |
4775: 4c 89 d1 mov %r10,%rcx | |
4778: 4c 89 ea mov %r13,%rdx | |
477b: e8 00 00 00 00 callq 4780 <ZSTD_decodeLiteralsBlock+0x160> | |
4780: 5e pop %rsi | |
4781: 5f pop %rdi | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
4782: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
4786: 0f 87 14 ff ff ff ja 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
dctx->litPtr = dctx->litBuffer; | |
478c: 4c 89 b5 a0 75 00 00 mov %r14,0x75a0(%rbp) | |
dctx->litSize = litSize; | |
4793: 4c 89 ad c0 75 00 00 mov %r13,0x75c0(%rbp) | |
dctx->litEntropy = 1; | |
479a: c7 85 28 75 00 00 01 movl $0x1,0x7528(%rbp) | |
47a1: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
47a4: 80 fb 02 cmp $0x2,%bl | |
47a7: 75 04 jne 47ad <ZSTD_decodeLiteralsBlock+0x18d> | |
47a9: 4c 89 7d 18 mov %r15,0x18(%rbp) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
47ad: 4d 01 f5 add %r14,%r13 | |
47b0: 66 0f ef c0 pxor %xmm0,%xmm0 | |
47b4: 41 0f 11 45 00 movups %xmm0,0x0(%r13) | |
47b9: 41 0f 11 45 10 movups %xmm0,0x10(%r13) | |
return litCSize + lhSize; | |
47be: e9 e4 fe ff ff jmpq 46a7 <ZSTD_decodeLiteralsBlock+0x87> | |
47c3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
litSize = (lhc >> 4) & 0x3FFFF; | |
47c8: 44 89 e8 mov %r13d,%eax | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
47cb: 0f b6 56 04 movzbl 0x4(%rsi),%edx | |
47cf: 25 ff ff 03 00 and $0x3ffff,%eax | |
litSize = (lhc >> 4) & 0x3FFFF; | |
47d4: 41 89 c5 mov %eax,%r13d | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
47d7: 3d 00 00 02 00 cmp $0x20000,%eax | |
47dc: 0f 87 be fe ff ff ja 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
47e2: c1 e9 16 shr $0x16,%ecx | |
47e5: 48 c1 e2 0a shl $0xa,%rdx | |
lhSize = 5; | |
47e9: 41 b8 05 00 00 00 mov $0x5,%r8d | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
47ef: 89 c8 mov %ecx,%eax | |
47f1: 48 8d 0c 10 lea (%rax,%rdx,1),%rcx | |
U32 singleStream=0; | |
47f5: 31 d2 xor %edx,%edx | |
47f7: e9 18 ff ff ff jmpq 4714 <ZSTD_decodeLiteralsBlock+0xf4> | |
47fc: 0f 1f 40 00 nopl 0x0(%rax) | |
litSize = (lhc >> 4) & 0x3FFF; | |
4800: 41 81 e5 ff 3f 00 00 and $0x3fff,%r13d | |
litCSize = lhc >> 18; | |
4807: c1 e9 12 shr $0x12,%ecx | |
U32 singleStream=0; | |
480a: 31 d2 xor %edx,%edx | |
lhSize = 4; | |
480c: 41 b8 04 00 00 00 mov $0x4,%r8d | |
break; | |
4812: e9 fd fe ff ff jmpq 4714 <ZSTD_decodeLiteralsBlock+0xf4> | |
4817: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
481e: 00 00 | |
litSize = MEM_readLE16(istart) >> 4; | |
4820: 0f b7 1e movzwl (%rsi),%ebx | |
lhSize = 2; | |
4823: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
4828: 66 c1 eb 04 shr $0x4,%bx | |
482c: 0f b7 db movzwl %bx,%ebx | |
break; | |
482f: e9 4a fe ff ff jmpq 467e <ZSTD_decodeLiteralsBlock+0x5e> | |
4834: 0f 1f 40 00 nopl 0x0(%rax) | |
{ U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
4838: 89 c2 mov %eax,%edx | |
483a: c0 ea 02 shr $0x2,%dl | |
483d: 83 e2 03 and $0x3,%edx | |
switch(lhlCode) | |
4840: 80 fa 01 cmp $0x1,%dl | |
4843: 0f 84 c7 00 00 00 je 4910 <ZSTD_decodeLiteralsBlock+0x2f0> | |
4849: 80 fa 03 cmp $0x3,%dl | |
484c: 0f 84 7e 00 00 00 je 48d0 <ZSTD_decodeLiteralsBlock+0x2b0> | |
litSize = istart[0] >> 3; | |
4852: c0 e8 03 shr $0x3,%al | |
break; | |
4855: 41 bc 02 00 00 00 mov $0x2,%r12d | |
litSize = istart[0] >> 3; | |
485b: 0f b6 d8 movzbl %al,%ebx | |
lhSize = 1; | |
485e: b8 01 00 00 00 mov $0x1,%eax | |
ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH); | |
4863: 48 8d 8d 90 76 00 00 lea 0x7690(%rbp),%rcx | |
486a: 0f b6 34 06 movzbl (%rsi,%rax,1),%esi | |
486e: 48 8d 53 20 lea 0x20(%rbx),%rdx | |
4872: 48 89 cf mov %rcx,%rdi | |
4875: e8 00 00 00 00 callq 487a <ZSTD_decodeLiteralsBlock+0x25a> | |
dctx->litSize = litSize; | |
487a: 48 89 9d c0 75 00 00 mov %rbx,0x75c0(%rbp) | |
dctx->litPtr = dctx->litBuffer; | |
4881: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
return lhSize+1; | |
4888: e9 1a fe ff ff jmpq 46a7 <ZSTD_decodeLiteralsBlock+0x87> | |
488d: 0f 1f 00 nopl (%rax) | |
dctx->litPtr = istart+lhSize; | |
4890: 48 01 c6 add %rax,%rsi | |
dctx->litSize = litSize; | |
4893: 48 89 9d c0 75 00 00 mov %rbx,0x75c0(%rbp) | |
dctx->litPtr = istart+lhSize; | |
489a: 48 89 b5 a0 75 00 00 mov %rsi,0x75a0(%rbp) | |
return lhSize+litSize; | |
48a1: e9 01 fe ff ff jmpq 46a7 <ZSTD_decodeLiteralsBlock+0x87> | |
48a6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
48ad: 00 00 00 | |
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16); | |
48b0: 0f b6 5e 02 movzbl 0x2(%rsi),%ebx | |
48b4: 0f b7 06 movzwl (%rsi),%eax | |
48b7: c1 e3 10 shl $0x10,%ebx | |
48ba: 01 c3 add %eax,%ebx | |
lhSize = 3; | |
48bc: b8 03 00 00 00 mov $0x3,%eax | |
litSize = MEM_readLE24(istart) >> 4; | |
48c1: c1 eb 04 shr $0x4,%ebx | |
break; | |
48c4: e9 b5 fd ff ff jmpq 467e <ZSTD_decodeLiteralsBlock+0x5e> | |
48c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
48d0: 0f b6 5e 02 movzbl 0x2(%rsi),%ebx | |
48d4: 0f b7 06 movzwl (%rsi),%eax | |
48d7: c1 e3 10 shl $0x10,%ebx | |
48da: 01 c3 add %eax,%ebx | |
litSize = MEM_readLE24(istart) >> 4; | |
48dc: c1 eb 04 shr $0x4,%ebx | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
48df: 48 81 fb 00 00 02 00 cmp $0x20000,%rbx | |
48e6: 0f 87 b4 fd ff ff ja 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
48ec: 48 83 ff 03 cmp $0x3,%rdi | |
48f0: 0f 84 aa fd ff ff je 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
48f6: 41 bc 04 00 00 00 mov $0x4,%r12d | |
lhSize = 3; | |
48fc: b8 03 00 00 00 mov $0x3,%eax | |
4901: e9 5d ff ff ff jmpq 4863 <ZSTD_decodeLiteralsBlock+0x243> | |
4906: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
490d: 00 00 00 | |
litSize = MEM_readLE16(istart) >> 4; | |
4910: 0f b7 1e movzwl (%rsi),%ebx | |
break; | |
4913: 41 bc 03 00 00 00 mov $0x3,%r12d | |
lhSize = 2; | |
4919: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
491e: 66 c1 eb 04 shr $0x4,%bx | |
4922: 0f b7 db movzwl %bx,%ebx | |
break; | |
4925: e9 39 ff ff ff jmpq 4863 <ZSTD_decodeLiteralsBlock+0x243> | |
492a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
if (singleStream) { | |
4930: 85 d2 test %edx,%edx | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
4932: 4c 8b 45 18 mov 0x18(%rbp),%r8 | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
4936: 41 89 c1 mov %eax,%r9d | |
4939: 4c 89 d2 mov %r10,%rdx | |
493c: 4c 89 ee mov %r13,%rsi | |
493f: 4c 89 f7 mov %r14,%rdi | |
if (singleStream) { | |
4942: 0f 85 91 00 00 00 jne 49d9 <ZSTD_decodeLiteralsBlock+0x3b9> | |
hufSuccess = HUF_decompress4X_usingDTable_bmi2( | |
4948: e8 00 00 00 00 callq 494d <ZSTD_decodeLiteralsBlock+0x32d> | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
494d: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
4951: 0f 87 49 fd ff ff ja 46a0 <ZSTD_decodeLiteralsBlock+0x80> | |
dctx->litPtr = dctx->litBuffer; | |
4957: 4c 89 b5 a0 75 00 00 mov %r14,0x75a0(%rbp) | |
dctx->litSize = litSize; | |
495e: 4c 89 ad c0 75 00 00 mov %r13,0x75c0(%rbp) | |
dctx->litEntropy = 1; | |
4965: c7 85 28 75 00 00 01 movl $0x1,0x7528(%rbp) | |
496c: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
496f: e9 39 fe ff ff jmpq 47ad <ZSTD_decodeLiteralsBlock+0x18d> | |
4974: 0f 1f 40 00 nopl 0x0(%rax) | |
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2( | |
4978: 50 push %rax | |
4979: 49 89 c8 mov %rcx,%r8 | |
497c: 4c 89 ea mov %r13,%rdx | |
497f: 4c 89 d1 mov %r10,%rcx | |
4982: 68 00 0a 00 00 pushq $0xa00 | |
4987: 4c 89 f6 mov %r14,%rsi | |
498a: 4c 89 ff mov %r15,%rdi | |
498d: e8 00 00 00 00 callq 4992 <ZSTD_decodeLiteralsBlock+0x372> | |
4992: 5a pop %rdx | |
4993: 59 pop %rcx | |
4994: e9 e9 fd ff ff jmpq 4782 <ZSTD_decodeLiteralsBlock+0x162> | |
4999: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
49a0: 48 8d 8d 90 76 00 00 lea 0x7690(%rbp),%rcx | |
49a7: 48 01 c6 add %rax,%rsi | |
49aa: 48 89 da mov %rbx,%rdx | |
49ad: 48 89 cf mov %rcx,%rdi | |
49b0: e8 00 00 00 00 callq 49b5 <ZSTD_decodeLiteralsBlock+0x395> | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
49b5: 66 0f ef c0 pxor %xmm0,%xmm0 | |
dctx->litSize = litSize; | |
49b9: 48 89 9d c0 75 00 00 mov %rbx,0x75c0(%rbp) | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
49c0: 48 89 c1 mov %rax,%rcx | |
dctx->litPtr = dctx->litBuffer; | |
49c3: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
49ca: 48 01 d9 add %rbx,%rcx | |
49cd: 0f 11 01 movups %xmm0,(%rcx) | |
49d0: 0f 11 41 10 movups %xmm0,0x10(%rcx) | |
return lhSize+litSize; | |
49d4: e9 ce fc ff ff jmpq 46a7 <ZSTD_decodeLiteralsBlock+0x87> | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
49d9: e8 00 00 00 00 callq 49de <ZSTD_decodeLiteralsBlock+0x3be> | |
49de: e9 6a ff ff ff jmpq 494d <ZSTD_decodeLiteralsBlock+0x32d> | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
49e3: 48 8b 45 18 mov 0x18(%rbp),%rax | |
49e7: 48 8d b8 40 40 00 00 lea 0x4040(%rax),%rdi | |
49ee: 66 90 xchg %ax,%ax | |
49f0: 0f 18 10 prefetcht1 (%rax) | |
49f3: 48 83 c0 40 add $0x40,%rax | |
49f7: 48 39 c7 cmp %rax,%rdi | |
49fa: 75 f4 jne 49f0 <ZSTD_decodeLiteralsBlock+0x3d0> | |
49fc: e9 35 fd ff ff jmpq 4736 <ZSTD_decodeLiteralsBlock+0x116> | |
4a01: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4a08: 00 00 00 00 | |
4a0c: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4a13: 00 00 00 00 | |
4a17: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
4a1e: 00 00 | |
0000000000004a20 <ZSTD_buildFSETable>: | |
{ | |
4a20: 41 57 push %r15 | |
4a22: 41 89 d7 mov %edx,%r15d | |
4a25: 41 56 push %r14 | |
4a27: 41 55 push %r13 | |
4a29: 4d 89 c5 mov %r8,%r13 | |
4a2c: 41 54 push %r12 | |
4a2e: 49 89 cc mov %rcx,%r12 | |
4a31: 55 push %rbp | |
4a32: 48 89 f5 mov %rsi,%rbp | |
4a35: 53 push %rbx | |
if (bmi2) { | |
4a36: 44 8b 54 24 48 mov 0x48(%rsp),%r10d | |
{ | |
4a3b: 4c 8b 74 24 38 mov 0x38(%rsp),%r14 | |
4a40: 48 89 7c 24 d0 mov %rdi,-0x30(%rsp) | |
4a45: 44 89 4c 24 dc mov %r9d,-0x24(%rsp) | |
if (bmi2) { | |
4a4a: 45 85 d2 test %r10d,%r10d | |
4a4d: 0f 85 af 01 00 00 jne 4c02 <ZSTD_buildFSETable+0x1e2> | |
4a53: 44 89 ce mov %r9d,%esi | |
U32 const tableSize = 1 << tableLog; | |
4a56: b8 01 00 00 00 mov $0x1,%eax | |
ZSTD_seqSymbol* const tableDecode = dt+1; | |
4a5b: 4c 8d 4f 08 lea 0x8(%rdi),%r9 | |
U32 const tableSize = 1 << tableLog; | |
4a5f: 89 f1 mov %esi,%ecx | |
4a61: 89 c3 mov %eax,%ebx | |
BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1); | |
4a63: 49 8d 7e 6a lea 0x6a(%r14),%rdi | |
U32 const tableSize = 1 << tableLog; | |
4a67: d3 e3 shl %cl,%ebx | |
DTableH.fastMode = 1; | |
4a69: 48 89 f1 mov %rsi,%rcx | |
4a6c: 48 c1 e1 20 shl $0x20,%rcx | |
U32 const tableSize = 1 << tableLog; | |
4a70: 89 5c 24 f0 mov %ebx,-0x10(%rsp) | |
U32 highThreshold = tableSize - 1; | |
4a74: 8d 53 ff lea -0x1(%rbx),%edx | |
DTableH.fastMode = 1; | |
4a77: 48 83 c9 01 or $0x1,%rcx | |
4a7b: 48 89 4c 24 e8 mov %rcx,-0x18(%rsp) | |
4a80: 48 89 4c 24 e0 mov %rcx,-0x20(%rsp) | |
{ S16 const largeLimit= (S16)(1 << (tableLog-1)); | |
4a85: 8d 4e ff lea -0x1(%rsi),%ecx | |
4a88: d3 e0 shl %cl,%eax | |
size_t const step = FSE_TABLESTEP(tableSize); | |
4a8a: 89 d9 mov %ebx,%ecx | |
4a8c: c1 eb 03 shr $0x3,%ebx | |
4a8f: d1 e9 shr %ecx | |
{ S16 const largeLimit= (S16)(1 << (tableLog-1)); | |
4a91: 41 89 c0 mov %eax,%r8d | |
size_t const step = FSE_TABLESTEP(tableSize); | |
4a94: 8d 74 19 03 lea 0x3(%rcx,%rbx,1),%esi | |
for (s=0; s<maxSV1; s++) { | |
4a98: 41 83 ff ff cmp $0xffffffff,%r15d | |
4a9c: 0f 84 73 02 00 00 je 4d15 <ZSTD_buildFSETable+0x2f5> | |
4aa2: 89 54 24 f4 mov %edx,-0xc(%rsp) | |
U32 highThreshold = tableSize - 1; | |
4aa6: 89 d1 mov %edx,%ecx | |
for (s=0; s<maxSV1; s++) { | |
4aa8: 31 c0 xor %eax,%eax | |
4aaa: 45 31 db xor %r11d,%r11d | |
4aad: 41 ba 01 00 00 00 mov $0x1,%r10d | |
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; | |
4ab3: 31 db xor %ebx,%ebx | |
4ab5: 44 89 c2 mov %r8d,%edx | |
4ab8: eb 25 jmp 4adf <ZSTD_buildFSETable+0xbf> | |
4aba: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
4ac0: 66 44 39 c2 cmp %r8w,%dx | |
symbolNext[s] = (U16)normalizedCounter[s]; | |
4ac4: 66 45 89 04 46 mov %r8w,(%r14,%rax,2) | |
4ac9: 41 bb 01 00 00 00 mov $0x1,%r11d | |
for (s=0; s<maxSV1; s++) { | |
4acf: 4c 8d 40 01 lea 0x1(%rax),%r8 | |
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; | |
4ad3: 4c 0f 4e d3 cmovle %rbx,%r10 | |
for (s=0; s<maxSV1; s++) { | |
4ad7: 49 39 c7 cmp %rax,%r15 | |
4ada: 74 2f je 4b0b <ZSTD_buildFSETable+0xeb> | |
4adc: 4c 89 c0 mov %r8,%rax | |
if (normalizedCounter[s]==-1) { | |
4adf: 44 0f b7 44 45 00 movzwl 0x0(%rbp,%rax,2),%r8d | |
4ae5: 66 41 83 f8 ff cmp $0xffff,%r8w | |
4aea: 75 d4 jne 4ac0 <ZSTD_buildFSETable+0xa0> | |
tableDecode[highThreshold--].baseValue = s; | |
4aec: 41 89 c8 mov %ecx,%r8d | |
4aef: 83 e9 01 sub $0x1,%ecx | |
4af2: 43 89 44 c1 04 mov %eax,0x4(%r9,%r8,8) | |
symbolNext[s] = 1; | |
4af7: 41 b8 01 00 00 00 mov $0x1,%r8d | |
4afd: 66 45 89 04 46 mov %r8w,(%r14,%rax,2) | |
for (s=0; s<maxSV1; s++) { | |
4b02: 4c 8d 40 01 lea 0x1(%rax),%r8 | |
4b06: 49 39 c7 cmp %rax,%r15 | |
4b09: 75 d1 jne 4adc <ZSTD_buildFSETable+0xbc> | |
4b0b: 8b 54 24 f4 mov -0xc(%rsp),%edx | |
4b0f: 45 84 db test %r11b,%r11b | |
4b12: 74 17 je 4b2b <ZSTD_buildFSETable+0x10b> | |
4b14: 48 b8 00 00 00 00 ff movabs $0xffffffff00000000,%rax | |
4b1b: ff ff ff | |
4b1e: 48 23 44 24 e8 and -0x18(%rsp),%rax | |
4b23: 4c 09 d0 or %r10,%rax | |
4b26: 48 89 44 24 e0 mov %rax,-0x20(%rsp) | |
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH)); | |
4b2b: 48 8b 44 24 d0 mov -0x30(%rsp),%rax | |
4b30: 48 8b 5c 24 e0 mov -0x20(%rsp),%rbx | |
4b35: 48 89 18 mov %rbx,(%rax) | |
if (highThreshold == tableSize - 1) { | |
4b38: 39 ca cmp %ecx,%edx | |
4b3a: 0f 84 d4 00 00 00 je 4c14 <ZSTD_buildFSETable+0x1f4> | |
4b40: 31 db xor %ebx,%ebx | |
U32 s, position = 0; | |
4b42: 31 c0 xor %eax,%eax | |
4b44: 0f 1f 40 00 nopl 0x0(%rax) | |
int const n = normalizedCounter[s]; | |
4b48: 44 0f bf 44 5d 00 movswl 0x0(%rbp,%rbx,2),%r8d | |
4b4e: 41 89 da mov %ebx,%r10d | |
for (i=0; i<n; i++) { | |
4b51: 45 85 c0 test %r8d,%r8d | |
4b54: 7e 2a jle 4b80 <ZSTD_buildFSETable+0x160> | |
4b56: 31 ff xor %edi,%edi | |
4b58: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
4b5f: 00 | |
tableDecode[position].baseValue = s; | |
4b60: 41 89 c3 mov %eax,%r11d | |
4b63: 47 89 54 d9 04 mov %r10d,0x4(%r9,%r11,8) | |
4b68: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
4b6f: 00 | |
position = (position + step) & tableMask; | |
4b70: 01 f0 add %esi,%eax | |
4b72: 21 d0 and %edx,%eax | |
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */ | |
4b74: 39 c8 cmp %ecx,%eax | |
4b76: 77 f8 ja 4b70 <ZSTD_buildFSETable+0x150> | |
for (i=0; i<n; i++) { | |
4b78: 83 c7 01 add $0x1,%edi | |
4b7b: 41 39 f8 cmp %edi,%r8d | |
4b7e: 75 e0 jne 4b60 <ZSTD_buildFSETable+0x140> | |
for (s=0; s<maxSV1; s++) { | |
4b80: 48 8d 7b 01 lea 0x1(%rbx),%rdi | |
4b84: 49 39 df cmp %rbx,%r15 | |
4b87: 74 05 je 4b8e <ZSTD_buildFSETable+0x16e> | |
4b89: 48 89 fb mov %rdi,%rbx | |
4b8c: eb ba jmp 4b48 <ZSTD_buildFSETable+0x128> | |
for (u=0; u<tableSize; u++) { | |
4b8e: 8b 44 24 f0 mov -0x10(%rsp),%eax | |
4b92: 85 c0 test %eax,%eax | |
4b94: 74 61 je 4bf7 <ZSTD_buildFSETable+0x1d7> | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
4b96: 44 8b 54 24 f0 mov -0x10(%rsp),%r10d | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
4b9b: 44 0f b6 44 24 dc movzbl -0x24(%rsp),%r8d | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
4ba1: 31 f6 xor %esi,%esi | |
4ba3: 44 89 d7 mov %r10d,%edi | |
4ba6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
4bad: 00 00 00 | |
U32 const nextState = symbolNext[symbol]++; | |
4bb0: 41 8b 51 04 mov 0x4(%r9),%edx | |
for (u=0; u<tableSize; u++) { | |
4bb4: 83 c6 01 add $0x1,%esi | |
4bb7: 49 83 c1 08 add $0x8,%r9 | |
U32 const nextState = symbolNext[symbol]++; | |
4bbb: 49 8d 0c 56 lea (%r14,%rdx,2),%rcx | |
4bbf: 0f b7 01 movzwl (%rcx),%eax | |
4bc2: 44 8d 58 01 lea 0x1(%rax),%r11d | |
4bc6: 66 44 89 19 mov %r11w,(%rcx) | |
return __builtin_clz (val) ^ 31; | |
4bca: 44 0f bd d8 bsr %eax,%r11d | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
4bce: 44 89 c1 mov %r8d,%ecx | |
4bd1: 44 29 d9 sub %r11d,%ecx | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
4bd4: d3 e0 shl %cl,%eax | |
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); | |
4bd6: 41 88 49 fb mov %cl,-0x5(%r9) | |
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); | |
4bda: 29 f8 sub %edi,%eax | |
4bdc: 66 41 89 41 f8 mov %ax,-0x8(%r9) | |
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol]; | |
4be1: 41 8b 44 95 00 mov 0x0(%r13,%rdx,4),%eax | |
4be6: 41 88 41 fa mov %al,-0x6(%r9) | |
tableDecode[u].baseValue = baseValue[symbol]; | |
4bea: 41 8b 04 94 mov (%r12,%rdx,4),%eax | |
4bee: 41 89 41 fc mov %eax,-0x4(%r9) | |
for (u=0; u<tableSize; u++) { | |
4bf2: 41 39 f2 cmp %esi,%r10d | |
4bf5: 77 b9 ja 4bb0 <ZSTD_buildFSETable+0x190> | |
} | |
4bf7: 5b pop %rbx | |
4bf8: 5d pop %rbp | |
4bf9: 41 5c pop %r12 | |
4bfb: 41 5d pop %r13 | |
4bfd: 41 5e pop %r14 | |
4bff: 41 5f pop %r15 | |
4c01: c3 retq | |
4c02: 5b pop %rbx | |
ZSTD_buildFSETable_body_bmi2(dt, normalizedCounter, maxSymbolValue, | |
4c03: 44 89 fa mov %r15d,%edx | |
} | |
4c06: 5d pop %rbp | |
4c07: 41 5c pop %r12 | |
4c09: 41 5d pop %r13 | |
4c0b: 41 5e pop %r14 | |
4c0d: 41 5f pop %r15 | |
ZSTD_buildFSETable_body_bmi2(dt, normalizedCounter, maxSymbolValue, | |
4c0f: e9 0c bb ff ff jmpq 720 <ZSTD_buildFSETable_body_bmi2.constprop.0> | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
4c14: 4a 8d 44 7d 00 lea 0x0(%rbp,%r15,2),%rax | |
4c19: 48 89 54 24 d0 mov %rdx,-0x30(%rsp) | |
size_t const step = FSE_TABLESTEP(tableSize); | |
4c1e: 45 31 c0 xor %r8d,%r8d | |
4c21: 31 c9 xor %ecx,%ecx | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
4c23: 49 bf 01 01 01 01 01 movabs $0x101010101010101,%r15 | |
4c2a: 01 01 01 | |
4c2d: 48 89 c2 mov %rax,%rdx | |
int const n = normalizedCounter[s]; | |
4c30: 4c 0f bf 55 00 movswq 0x0(%rbp),%r10 | |
MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; } | |
4c35: 4c 89 04 0f mov %r8,(%rdi,%rcx,1) | |
for (i = 8; i < n; i += 8) { | |
4c39: 66 41 83 fa 08 cmp $0x8,%r10w | |
4c3e: 7e 60 jle 4ca0 <ZSTD_buildFSETable+0x280> | |
4c40: 41 0f bf c2 movswl %r10w,%eax | |
4c44: 83 e8 09 sub $0x9,%eax | |
4c47: 41 89 c3 mov %eax,%r11d | |
4c4a: 41 c1 eb 03 shr $0x3,%r11d | |
4c4e: 41 83 c3 01 add $0x1,%r11d | |
4c52: 83 f8 07 cmp $0x7,%eax | |
4c55: 0f 86 b3 00 00 00 jbe 4d0e <ZSTD_buildFSETable+0x2ee> | |
4c5b: 44 89 db mov %r11d,%ebx | |
4c5e: 66 49 0f 6e c0 movq %r8,%xmm0 | |
4c63: 49 8d 44 0e 72 lea 0x72(%r14,%rcx,1),%rax | |
4c68: d1 eb shr %ebx | |
4c6a: 66 0f 6c c0 punpcklqdq %xmm0,%xmm0 | |
4c6e: 48 c1 e3 04 shl $0x4,%rbx | |
4c72: 48 01 c3 add %rax,%rbx | |
4c75: 0f 1f 00 nopl (%rax) | |
4c78: 0f 11 00 movups %xmm0,(%rax) | |
4c7b: 48 83 c0 10 add $0x10,%rax | |
4c7f: 48 39 c3 cmp %rax,%rbx | |
4c82: 75 f4 jne 4c78 <ZSTD_buildFSETable+0x258> | |
4c84: 44 89 db mov %r11d,%ebx | |
4c87: 83 e3 fe and $0xfffffffe,%ebx | |
4c8a: 8d 04 dd 08 00 00 00 lea 0x8(,%rbx,8),%eax | |
4c91: 44 39 db cmp %r11d,%ebx | |
4c94: 74 0a je 4ca0 <ZSTD_buildFSETable+0x280> | |
MEM_write64(spread + pos + i, sv); | |
4c96: 48 98 cltq | |
4c98: 4c 8d 1c 0f lea (%rdi,%rcx,1),%r11 | |
4c9c: 4d 89 04 03 mov %r8,(%r11,%rax,1) | |
pos += n; | |
4ca0: 4c 01 d1 add %r10,%rcx | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
4ca3: 4d 01 f8 add %r15,%r8 | |
4ca6: 48 8d 45 02 lea 0x2(%rbp),%rax | |
4caa: 48 39 ea cmp %rbp,%rdx | |
4cad: 74 08 je 4cb7 <ZSTD_buildFSETable+0x297> | |
4caf: 48 89 c5 mov %rax,%rbp | |
4cb2: e9 79 ff ff ff jmpq 4c30 <ZSTD_buildFSETable+0x210> | |
4cb7: 48 8b 54 24 d0 mov -0x30(%rsp),%rdx | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
4cbc: 8b 44 24 f0 mov -0x10(%rsp),%eax | |
4cc0: 48 85 c0 test %rax,%rax | |
4cc3: 0f 84 2e ff ff ff je 4bf7 <ZSTD_buildFSETable+0x1d7> | |
4cc9: 48 83 e8 01 sub $0x1,%rax | |
4ccd: 48 83 e0 fe and $0xfffffffffffffffe,%rax | |
4cd1: 4d 8d 54 06 6c lea 0x6c(%r14,%rax,1),%r10 | |
size_t position = 0; | |
4cd6: 31 c0 xor %eax,%eax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
4cd8: 44 0f b6 07 movzbl (%rdi),%r8d | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
4cdc: 48 89 d1 mov %rdx,%rcx | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
4cdf: 48 83 c7 02 add $0x2,%rdi | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
4ce3: 48 21 c1 and %rax,%rcx | |
4ce6: 48 01 f0 add %rsi,%rax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
4ce9: 45 89 44 c9 04 mov %r8d,0x4(%r9,%rcx,8) | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
4cee: 48 89 d1 mov %rdx,%rcx | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
4cf1: 44 0f b6 47 ff movzbl -0x1(%rdi),%r8d | |
size_t const uPosition = (position + (u * step)) & tableMask; | |
4cf6: 48 21 c1 and %rax,%rcx | |
position = (position + (unroll * step)) & tableMask; | |
4cf9: 48 01 f0 add %rsi,%rax | |
tableDecode[uPosition].baseValue = spread[s + u]; | |
4cfc: 45 89 44 c9 04 mov %r8d,0x4(%r9,%rcx,8) | |
position = (position + (unroll * step)) & tableMask; | |
4d01: 48 21 d0 and %rdx,%rax | |
for (s = 0; s < (size_t)tableSize; s += unroll) { | |
4d04: 49 39 fa cmp %rdi,%r10 | |
4d07: 75 cf jne 4cd8 <ZSTD_buildFSETable+0x2b8> | |
4d09: e9 88 fe ff ff jmpq 4b96 <ZSTD_buildFSETable+0x176> | |
for (i = 8; i < n; i += 8) { | |
4d0e: b8 08 00 00 00 mov $0x8,%eax | |
4d13: eb 81 jmp 4c96 <ZSTD_buildFSETable+0x276> | |
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH)); | |
4d15: 48 8b 44 24 d0 mov -0x30(%rsp),%rax | |
4d1a: 48 8b 5c 24 e8 mov -0x18(%rsp),%rbx | |
4d1f: 48 89 18 mov %rbx,(%rax) | |
for (s=0; s<maxSV1; ++s, sv += add) { | |
4d22: eb 98 jmp 4cbc <ZSTD_buildFSETable+0x29c> | |
4d24: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4d2b: 00 00 00 00 | |
4d2f: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4d36: 00 00 00 00 | |
4d3a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
0000000000004d40 <ZSTD_buildSeqTable.constprop.0>: | |
static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr, | |
4d40: 41 55 push %r13 | |
4d42: 41 54 push %r12 | |
4d44: 45 89 c4 mov %r8d,%r12d | |
4d47: 55 push %rbp | |
4d48: 48 89 f5 mov %rsi,%rbp | |
4d4b: 53 push %rbx | |
4d4c: 48 89 fb mov %rdi,%rbx | |
4d4f: 48 81 ec 98 00 00 00 sub $0x98,%rsp | |
4d56: 89 4c 24 0c mov %ecx,0xc(%rsp) | |
switch(type) | |
4d5a: 83 fa 02 cmp $0x2,%edx | |
4d5d: 74 31 je 4d90 <ZSTD_buildSeqTable.constprop.0+0x50> | |
4d5f: 83 fa 03 cmp $0x3,%edx | |
4d62: 0f 84 30 01 00 00 je 4e98 <ZSTD_buildSeqTable.constprop.0+0x158> | |
4d68: 83 fa 01 cmp $0x1,%edx | |
4d6b: 0f 84 af 00 00 00 je 4e20 <ZSTD_buildSeqTable.constprop.0+0xe0> | |
*DTablePtr = defaultTable; | |
4d71: 48 8b 84 24 d8 00 00 mov 0xd8(%rsp),%rax | |
4d78: 00 | |
4d79: 48 89 06 mov %rax,(%rsi) | |
return 0; | |
4d7c: 31 c0 xor %eax,%eax | |
} | |
4d7e: 48 81 c4 98 00 00 00 add $0x98,%rsp | |
4d85: 5b pop %rbx | |
4d86: 5d pop %rbp | |
4d87: 41 5c pop %r12 | |
4d89: 41 5d pop %r13 | |
4d8b: c3 retq | |
4d8c: 0f 1f 40 00 nopl 0x0(%rax) | |
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); | |
4d90: 4c 8b 84 24 c0 00 00 mov 0xc0(%rsp),%r8 | |
4d97: 00 | |
4d98: 4c 8d 6c 24 20 lea 0x20(%rsp),%r13 | |
4d9d: 48 8d 54 24 1c lea 0x1c(%rsp),%rdx | |
4da2: 4c 89 c9 mov %r9,%rcx | |
4da5: 48 8d 74 24 0c lea 0xc(%rsp),%rsi | |
4daa: 4c 89 ef mov %r13,%rdi | |
4dad: e8 00 00 00 00 callq 4db2 <ZSTD_buildSeqTable.constprop.0+0x72> | |
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, ""); | |
4db2: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
4db6: 48 89 04 24 mov %rax,(%rsp) | |
4dba: 0f 87 40 01 00 00 ja 4f00 <ZSTD_buildSeqTable.constprop.0+0x1c0> | |
RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, ""); | |
4dc0: 44 8b 4c 24 1c mov 0x1c(%rsp),%r9d | |
4dc5: 45 39 cc cmp %r9d,%r12d | |
4dc8: 0f 82 32 01 00 00 jb 4f00 <ZSTD_buildSeqTable.constprop.0+0x1c0> | |
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2); | |
4dce: 48 83 ec 08 sub $0x8,%rsp | |
4dd2: 4c 89 ee mov %r13,%rsi | |
4dd5: 48 89 df mov %rbx,%rdi | |
4dd8: 8b 94 24 08 01 00 00 mov 0x108(%rsp),%edx | |
4ddf: 52 push %rdx | |
4de0: 68 00 0a 00 00 pushq $0xa00 | |
4de5: ff b4 24 10 01 00 00 pushq 0x110(%rsp) | |
4dec: 4c 8b 84 24 f0 00 00 mov 0xf0(%rsp),%r8 | |
4df3: 00 | |
4df4: 48 8b 8c 24 e8 00 00 mov 0xe8(%rsp),%rcx | |
4dfb: 00 | |
4dfc: 8b 54 24 2c mov 0x2c(%rsp),%edx | |
4e00: e8 00 00 00 00 callq 4e05 <ZSTD_buildSeqTable.constprop.0+0xc5> | |
return headerSize; | |
4e05: 48 83 c4 20 add $0x20,%rsp | |
*DTablePtr = DTableSpace; | |
4e09: 48 89 5d 00 mov %rbx,0x0(%rbp) | |
return headerSize; | |
4e0d: 48 8b 04 24 mov (%rsp),%rax | |
4e11: e9 68 ff ff ff jmpq 4d7e <ZSTD_buildSeqTable.constprop.0+0x3e> | |
4e16: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
4e1d: 00 00 00 | |
RETURN_ERROR_IF(!srcSize, srcSize_wrong, ""); | |
4e20: 48 83 bc 24 c0 00 00 cmpq $0x0,0xc0(%rsp) | |
4e27: 00 00 | |
4e29: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax | |
4e30: 0f 84 48 ff ff ff je 4d7e <ZSTD_buildSeqTable.constprop.0+0x3e> | |
RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, ""); | |
4e36: 41 0f b6 09 movzbl (%r9),%ecx | |
4e3a: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
4e41: 48 89 ca mov %rcx,%rdx | |
4e44: 3b 4c 24 0c cmp 0xc(%rsp),%ecx | |
4e48: 0f 87 30 ff ff ff ja 4d7e <ZSTD_buildSeqTable.constprop.0+0x3e> | |
U32 const baseline = baseValue[symbol]; | |
4e4e: 48 8b 84 24 c8 00 00 mov 0xc8(%rsp),%rax | |
4e55: 00 | |
4e56: 8b 04 88 mov (%rax,%rcx,4),%eax | |
U32 const nbBits = nbAdditionalBits[symbol]; | |
4e59: 48 8b 8c 24 d0 00 00 mov 0xd0(%rsp),%rcx | |
4e60: 00 | |
4e61: 8b 14 91 mov (%rcx,%rdx,4),%edx | |
cell->nextState = 0; | |
4e64: 31 c9 xor %ecx,%ecx | |
cell->baseValue = baseValue; | |
4e66: 89 47 0c mov %eax,0xc(%rdi) | |
return 1; | |
4e69: b8 01 00 00 00 mov $0x1,%eax | |
DTableH->fastMode = 0; | |
4e6e: 48 c7 07 00 00 00 00 movq $0x0,(%rdi) | |
cell->nbBits = 0; | |
4e75: c6 47 0b 00 movb $0x0,0xb(%rdi) | |
cell->nextState = 0; | |
4e79: 66 89 4f 08 mov %cx,0x8(%rdi) | |
cell->nbAdditionalBits = (BYTE)nbAddBits; | |
4e7d: 88 57 0a mov %dl,0xa(%rdi) | |
*DTablePtr = DTableSpace; | |
4e80: 48 89 7d 00 mov %rdi,0x0(%rbp) | |
} | |
4e84: 48 81 c4 98 00 00 00 add $0x98,%rsp | |
4e8b: 5b pop %rbx | |
4e8c: 5d pop %rbp | |
4e8d: 41 5c pop %r12 | |
4e8f: 41 5d pop %r13 | |
4e91: c3 retq | |
4e92: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, ""); | |
4e98: 8b 94 24 e0 00 00 00 mov 0xe0(%rsp),%edx | |
RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, ""); | |
4e9f: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, ""); | |
4ea6: 85 d2 test %edx,%edx | |
4ea8: 0f 84 d0 fe ff ff je 4d7e <ZSTD_buildSeqTable.constprop.0+0x3e> | |
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) { | |
4eae: 8b 84 24 e8 00 00 00 mov 0xe8(%rsp),%eax | |
4eb5: 85 c0 test %eax,%eax | |
4eb7: 74 34 je 4eed <ZSTD_buildSeqTable.constprop.0+0x1ad> | |
4eb9: 83 bc 24 f0 00 00 00 cmpl $0x18,0xf0(%rsp) | |
4ec0: 18 | |
4ec1: 7e 2a jle 4eed <ZSTD_buildSeqTable.constprop.0+0x1ad> | |
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog)); | |
4ec3: ba 01 00 00 00 mov $0x1,%edx | |
4ec8: 44 89 c1 mov %r8d,%ecx | |
const void* const pStart = *DTablePtr; | |
4ecb: 48 8b 36 mov (%rsi),%rsi | |
PREFETCH_AREA(pStart, pSize); | |
4ece: 31 c0 xor %eax,%eax | |
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog)); | |
4ed0: d3 e2 shl %cl,%edx | |
4ed2: 83 c2 01 add $0x1,%edx | |
4ed5: 48 63 d2 movslq %edx,%rdx | |
4ed8: 48 c1 e2 03 shl $0x3,%rdx | |
PREFETCH_AREA(pStart, pSize); | |
4edc: 0f 1f 40 00 nopl 0x0(%rax) | |
4ee0: 0f 18 14 06 prefetcht1 (%rsi,%rax,1) | |
4ee4: 48 83 c0 40 add $0x40,%rax | |
4ee8: 48 39 c2 cmp %rax,%rdx | |
4eeb: 77 f3 ja 4ee0 <ZSTD_buildSeqTable.constprop.0+0x1a0> | |
} | |
4eed: 48 81 c4 98 00 00 00 add $0x98,%rsp | |
return 0; | |
4ef4: 31 c0 xor %eax,%eax | |
} | |
4ef6: 5b pop %rbx | |
4ef7: 5d pop %rbp | |
4ef8: 41 5c pop %r12 | |
4efa: 41 5d pop %r13 | |
4efc: c3 retq | |
4efd: 0f 1f 00 nopl (%rax) | |
4f00: 48 81 c4 98 00 00 00 add $0x98,%rsp | |
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, ""); | |
4f07: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
} | |
4f0e: 5b pop %rbx | |
4f0f: 5d pop %rbp | |
4f10: 41 5c pop %r12 | |
4f12: 41 5d pop %r13 | |
4f14: c3 retq | |
4f15: 66 66 2e 0f 1f 84 00 data16 nopw %cs:0x0(%rax,%rax,1) | |
4f1c: 00 00 00 00 | |
0000000000004f20 <ZSTD_decodeSeqHeaders>: | |
RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, ""); | |
4f20: 48 85 c9 test %rcx,%rcx | |
4f23: 0f 84 d7 01 00 00 je 5100 <ZSTD_decodeSeqHeaders+0x1e0> | |
{ | |
4f29: 41 57 push %r15 | |
4f2b: 41 56 push %r14 | |
4f2d: 41 55 push %r13 | |
4f2f: 41 54 push %r12 | |
4f31: 49 89 d4 mov %rdx,%r12 | |
4f34: 55 push %rbp | |
4f35: 53 push %rbx | |
4f36: 48 81 ec b8 00 00 00 sub $0xb8,%rsp | |
nbSeq = *ip++; | |
4f3d: 44 0f b6 2a movzbl (%rdx),%r13d | |
if (!nbSeq) { | |
4f41: 45 85 ed test %r13d,%r13d | |
4f44: 75 2a jne 4f70 <ZSTD_decodeSeqHeaders+0x50> | |
*nbSeqPtr=0; | |
4f46: c7 06 00 00 00 00 movl $0x0,(%rsi) | |
return 1; | |
4f4c: b8 01 00 00 00 mov $0x1,%eax | |
RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, ""); | |
4f51: 48 83 f9 01 cmp $0x1,%rcx | |
4f55: 74 07 je 4f5e <ZSTD_decodeSeqHeaders+0x3e> | |
4f57: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax | |
} | |
4f5e: 48 81 c4 b8 00 00 00 add $0xb8,%rsp | |
4f65: 5b pop %rbx | |
4f66: 5d pop %rbp | |
4f67: 41 5c pop %r12 | |
4f69: 41 5d pop %r13 | |
4f6b: 41 5e pop %r14 | |
4f6d: 41 5f pop %r15 | |
4f6f: c3 retq | |
const BYTE* const iend = istart + srcSize; | |
4f70: 48 8d 1c 0a lea (%rdx,%rcx,1),%rbx | |
4f74: 48 89 fd mov %rdi,%rbp | |
nbSeq = *ip++; | |
4f77: 48 8d 52 01 lea 0x1(%rdx),%rdx | |
if (nbSeq > 0x7F) { | |
4f7b: 41 83 fd 7f cmp $0x7f,%r13d | |
4f7f: 7e 28 jle 4fa9 <ZSTD_decodeSeqHeaders+0x89> | |
if (nbSeq == 0xFF) { | |
4f81: 41 81 fd ff 00 00 00 cmp $0xff,%r13d | |
4f88: 0f 84 82 01 00 00 je 5110 <ZSTD_decodeSeqHeaders+0x1f0> | |
RETURN_ERROR_IF(ip >= iend, srcSize_wrong, ""); | |
4f8e: 48 39 d3 cmp %rdx,%rbx | |
4f91: 76 c4 jbe 4f57 <ZSTD_decodeSeqHeaders+0x37> | |
nbSeq = ((nbSeq-0x80)<<8) + *ip++; | |
4f93: 41 0f b6 44 24 01 movzbl 0x1(%r12),%eax | |
4f99: 41 83 c5 80 add $0xffffff80,%r13d | |
4f9d: 49 8d 54 24 02 lea 0x2(%r12),%rdx | |
4fa2: 41 c1 e5 08 shl $0x8,%r13d | |
4fa6: 41 01 c5 add %eax,%r13d | |
RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */ | |
4fa9: 4c 8d 72 01 lea 0x1(%rdx),%r14 | |
*nbSeqPtr = nbSeq; | |
4fad: 44 89 2e mov %r13d,(%rsi) | |
RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */ | |
4fb0: 49 39 de cmp %rbx,%r14 | |
4fb3: 77 a2 ja 4f57 <ZSTD_decodeSeqHeaders+0x37> | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
4fb5: 44 0f b6 3a movzbl (%rdx),%r15d | |
ip, iend-ip, | |
4fb9: 49 89 d8 mov %rbx,%r8 | |
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, | |
4fbc: 4c 8d 5d 20 lea 0x20(%rbp),%r11 | |
4fc0: c7 44 24 38 23 00 00 movl $0x23,0x38(%rsp) | |
4fc7: 00 | |
4fc8: 44 8b 8d d8 75 00 00 mov 0x75d8(%rbp),%r9d | |
4fcf: 8b 8d f4 75 00 00 mov 0x75f4(%rbp),%ecx | |
ip, iend-ip, | |
4fd5: 4d 29 f0 sub %r14,%r8 | |
dctx->workspace, sizeof(dctx->workspace), | |
4fd8: 4c 8d 95 bc 6a 00 00 lea 0x6abc(%rbp),%r10 | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
4fdf: 44 89 fe mov %r15d,%esi | |
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, | |
4fe2: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
4fe8: 40 c0 ee 06 shr $0x6,%sil | |
switch(type) | |
4fec: 40 80 fe 02 cmp $0x2,%sil | |
4ff0: 0f 84 da 01 00 00 je 51d0 <ZSTD_decodeSeqHeaders+0x2b0> | |
4ff6: 40 80 fe 03 cmp $0x3,%sil | |
4ffa: 0f 84 90 01 00 00 je 5190 <ZSTD_decodeSeqHeaders+0x270> | |
5000: 40 80 fe 01 cmp $0x1,%sil | |
5004: 0f 84 26 01 00 00 je 5130 <ZSTD_decodeSeqHeaders+0x210> | |
*DTablePtr = defaultTable; | |
500a: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 5011 <ZSTD_decodeSeqHeaders+0xf1> | |
5011: 48 89 7d 00 mov %rdi,0x0(%rbp) | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5015: 48 83 ec 08 sub $0x8,%rsp | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
5019: 44 89 fa mov %r15d,%edx | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
501c: 48 8d 75 10 lea 0x10(%rbp),%rsi | |
5020: 41 51 push %r9 | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
5022: c0 ea 04 shr $0x4,%dl | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5025: 48 8d bd 28 10 00 00 lea 0x1028(%rbp),%rdi | |
502c: 4d 89 f1 mov %r14,%r9 | |
502f: 41 52 push %r10 | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
5031: 83 e2 03 and $0x3,%edx | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5034: 4c 89 54 24 20 mov %r10,0x20(%rsp) | |
5039: 41 55 push %r13 | |
503b: 51 push %rcx | |
503c: b9 1f 00 00 00 mov $0x1f,%ecx | |
5041: 50 push %rax | |
5042: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5049 <ZSTD_decodeSeqHeaders+0x129> | |
5049: 50 push %rax | |
504a: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5051 <ZSTD_decodeSeqHeaders+0x131> | |
5051: 50 push %rax | |
5052: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5059 <ZSTD_decodeSeqHeaders+0x139> | |
5059: 50 push %rax | |
505a: 41 50 push %r8 | |
505c: 41 b8 08 00 00 00 mov $0x8,%r8d | |
5062: e8 d9 fc ff ff callq 4d40 <ZSTD_buildSeqTable.constprop.0> | |
RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed"); | |
5067: 48 83 c4 50 add $0x50,%rsp | |
506b: 4c 8b 54 24 08 mov 0x8(%rsp),%r10 | |
5070: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
5074: 0f 87 16 02 00 00 ja 5290 <ZSTD_decodeSeqHeaders+0x370> | |
ip += ofhSize; | |
507a: 49 01 c6 add %rax,%r14 | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
507d: 8b 85 d8 75 00 00 mov 0x75d8(%rbp),%eax | |
5083: 48 83 ec 08 sub $0x8,%rsp | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
5087: 44 89 fa mov %r15d,%edx | |
ip, iend-ip, | |
508a: 4c 29 f3 sub %r14,%rbx | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
508d: c0 ea 02 shr $0x2,%dl | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
5090: 48 8d 75 08 lea 0x8(%rbp),%rsi | |
5094: 4d 89 f1 mov %r14,%r9 | |
5097: 50 push %rax | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
5098: 83 e2 03 and $0x3,%edx | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
509b: 48 8d bd 30 18 00 00 lea 0x1830(%rbp),%rdi | |
50a2: b9 34 00 00 00 mov $0x34,%ecx | |
50a7: 41 52 push %r10 | |
50a9: 41 b8 09 00 00 00 mov $0x9,%r8d | |
50af: 41 55 push %r13 | |
50b1: 8b 85 f4 75 00 00 mov 0x75f4(%rbp),%eax | |
50b7: 50 push %rax | |
50b8: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
50be: 50 push %rax | |
50bf: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 50c6 <ZSTD_decodeSeqHeaders+0x1a6> | |
50c6: 50 push %rax | |
50c7: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 50ce <ZSTD_decodeSeqHeaders+0x1ae> | |
50ce: 50 push %rax | |
50cf: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 50d6 <ZSTD_decodeSeqHeaders+0x1b6> | |
50d6: 50 push %rax | |
50d7: 53 push %rbx | |
50d8: e8 63 fc ff ff callq 4d40 <ZSTD_buildSeqTable.constprop.0> | |
RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed"); | |
50dd: 48 83 c4 50 add $0x50,%rsp | |
50e1: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
50e5: 0f 87 a5 01 00 00 ja 5290 <ZSTD_decodeSeqHeaders+0x370> | |
ip += mlhSize; | |
50eb: 4c 01 f0 add %r14,%rax | |
return ip-istart; | |
50ee: 4c 29 e0 sub %r12,%rax | |
50f1: e9 68 fe ff ff jmpq 4f5e <ZSTD_decodeSeqHeaders+0x3e> | |
50f6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
50fd: 00 00 00 | |
RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, ""); | |
5100: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax | |
} | |
5107: c3 retq | |
5108: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
510f: 00 | |
RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, ""); | |
5110: 49 8d 54 24 03 lea 0x3(%r12),%rdx | |
5115: 48 39 da cmp %rbx,%rdx | |
5118: 0f 87 39 fe ff ff ja 4f57 <ZSTD_decodeSeqHeaders+0x37> | |
nbSeq = MEM_readLE16(ip) + LONGNBSEQ; | |
511e: 45 0f b7 6c 24 01 movzwl 0x1(%r12),%r13d | |
5124: 41 81 c5 00 7f 00 00 add $0x7f00,%r13d | |
ip+=2; | |
512b: e9 79 fe ff ff jmpq 4fa9 <ZSTD_decodeSeqHeaders+0x89> | |
RETURN_ERROR_IF(!srcSize, srcSize_wrong, ""); | |
5130: 4d 85 c0 test %r8,%r8 | |
5133: 0f 84 57 01 00 00 je 5290 <ZSTD_decodeSeqHeaders+0x370> | |
RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, ""); | |
5139: 0f b6 72 01 movzbl 0x1(%rdx),%esi | |
513d: 40 80 fe 23 cmp $0x23,%sil | |
5141: 0f 87 49 01 00 00 ja 5290 <ZSTD_decodeSeqHeaders+0x370> | |
U32 const nbBits = nbAdditionalBits[symbol]; | |
5147: 4c 8d 05 00 00 00 00 lea 0x0(%rip),%r8 # 514e <ZSTD_decodeSeqHeaders+0x22e> | |
U32 const baseline = baseValue[symbol]; | |
514e: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 5155 <ZSTD_decodeSeqHeaders+0x235> | |
5155: 8b 3c b7 mov (%rdi,%rsi,4),%edi | |
U32 const nbBits = nbAdditionalBits[symbol]; | |
5158: 41 8b 34 b0 mov (%r8,%rsi,4),%esi | |
cell->nextState = 0; | |
515c: 45 31 c0 xor %r8d,%r8d | |
ip += llhSize; | |
515f: 4c 8d 72 02 lea 0x2(%rdx),%r14 | |
cell->nextState = 0; | |
5163: 66 44 89 45 28 mov %r8w,0x28(%rbp) | |
ip, iend-ip, | |
5168: 49 89 d8 mov %rbx,%r8 | |
DTableH->fastMode = 0; | |
516b: 48 c7 45 20 00 00 00 movq $0x0,0x20(%rbp) | |
5172: 00 | |
ip, iend-ip, | |
5173: 4d 29 f0 sub %r14,%r8 | |
cell->nbBits = 0; | |
5176: c6 45 2b 00 movb $0x0,0x2b(%rbp) | |
cell->nbAdditionalBits = (BYTE)nbAddBits; | |
517a: 40 88 75 2a mov %sil,0x2a(%rbp) | |
cell->baseValue = baseValue; | |
517e: 89 7d 2c mov %edi,0x2c(%rbp) | |
*DTablePtr = DTableSpace; | |
5181: 4c 89 5d 00 mov %r11,0x0(%rbp) | |
******************************************/ | |
#undef ERROR /* already defined on Visual Studio */ | |
#define ERROR(name) ZSTD_ERROR(name) | |
#define ZSTD_ERROR(name) ((size_t)-PREFIX(name)) | |
ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } | |
5185: e9 8b fe ff ff jmpq 5015 <ZSTD_decodeSeqHeaders+0xf5> | |
518a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, ""); | |
5190: 85 c0 test %eax,%eax | |
5192: 0f 84 f8 00 00 00 je 5290 <ZSTD_decodeSeqHeaders+0x370> | |
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) { | |
5198: 85 c9 test %ecx,%ecx | |
519a: 0f 84 75 fe ff ff je 5015 <ZSTD_decodeSeqHeaders+0xf5> | |
51a0: 41 83 fd 18 cmp $0x18,%r13d | |
51a4: 0f 8e 6b fe ff ff jle 5015 <ZSTD_decodeSeqHeaders+0xf5> | |
PREFETCH_AREA(pStart, pSize); | |
51aa: 48 8b 55 00 mov 0x0(%rbp),%rdx | |
51ae: 48 8d b2 40 10 00 00 lea 0x1040(%rdx),%rsi | |
51b5: 0f 1f 00 nopl (%rax) | |
51b8: 0f 18 12 prefetcht1 (%rdx) | |
51bb: 48 83 c2 40 add $0x40,%rdx | |
51bf: 48 39 d6 cmp %rdx,%rsi | |
51c2: 75 f4 jne 51b8 <ZSTD_decodeSeqHeaders+0x298> | |
51c4: e9 4c fe ff ff jmpq 5015 <ZSTD_decodeSeqHeaders+0xf5> | |
51c9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); | |
51d0: 48 8d 7c 24 40 lea 0x40(%rsp),%rdi | |
51d5: 48 8d 54 24 3c lea 0x3c(%rsp),%rdx | |
51da: 4c 89 f1 mov %r14,%rcx | |
51dd: 4c 89 5c 24 20 mov %r11,0x20(%rsp) | |
51e2: 48 8d 74 24 38 lea 0x38(%rsp),%rsi | |
51e7: 4c 89 54 24 18 mov %r10,0x18(%rsp) | |
51ec: 44 89 4c 24 10 mov %r9d,0x10(%rsp) | |
51f1: 48 89 7c 24 08 mov %rdi,0x8(%rsp) | |
51f6: e8 00 00 00 00 callq 51fb <ZSTD_decodeSeqHeaders+0x2db> | |
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, ""); | |
51fb: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi | |
5200: 44 8b 4c 24 10 mov 0x10(%rsp),%r9d | |
5205: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); | |
5209: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, ""); | |
520e: 4c 8b 54 24 18 mov 0x18(%rsp),%r10 | |
5213: 4c 8b 5c 24 20 mov 0x20(%rsp),%r11 | |
5218: 77 76 ja 5290 <ZSTD_decodeSeqHeaders+0x370> | |
RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, ""); | |
521a: 8b 44 24 3c mov 0x3c(%rsp),%eax | |
521e: 83 f8 09 cmp $0x9,%eax | |
5221: 77 6d ja 5290 <ZSTD_decodeSeqHeaders+0x370> | |
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2); | |
5223: 48 83 ec 08 sub $0x8,%rsp | |
5227: 4c 8d 05 00 00 00 00 lea 0x0(%rip),%r8 # 522e <ZSTD_decodeSeqHeaders+0x30e> | |
522e: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 5235 <ZSTD_decodeSeqHeaders+0x315> | |
5235: 48 89 fe mov %rdi,%rsi | |
5238: 41 51 push %r9 | |
523a: 4c 89 df mov %r11,%rdi | |
523d: 41 89 c1 mov %eax,%r9d | |
5240: 68 00 0a 00 00 pushq $0xa00 | |
5245: 41 52 push %r10 | |
5247: 8b 54 24 58 mov 0x58(%rsp),%edx | |
524b: 4c 89 5c 24 28 mov %r11,0x28(%rsp) | |
5250: 4c 89 54 24 30 mov %r10,0x30(%rsp) | |
5255: e8 00 00 00 00 callq 525a <ZSTD_decodeSeqHeaders+0x33a> | |
*DTablePtr = DTableSpace; | |
525a: 4c 8b 5c 24 28 mov 0x28(%rsp),%r11 | |
ip, iend-ip, | |
525f: 49 89 d8 mov %rbx,%r8 | |
ip += llhSize; | |
5262: 4c 03 74 24 48 add 0x48(%rsp),%r14 | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5267: 44 8b 8d d8 75 00 00 mov 0x75d8(%rbp),%r9d | |
526e: 48 83 c4 20 add $0x20,%rsp | |
5272: 8b 8d f4 75 00 00 mov 0x75f4(%rbp),%ecx | |
ip, iend-ip, | |
5278: 4d 29 f0 sub %r14,%r8 | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
527b: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
5281: 4c 8b 54 24 10 mov 0x10(%rsp),%r10 | |
*DTablePtr = DTableSpace; | |
5286: 4c 89 5d 00 mov %r11,0x0(%rbp) | |
return headerSize; | |
528a: e9 86 fd ff ff jmpq 5015 <ZSTD_decodeSeqHeaders+0xf5> | |
528f: 90 nop | |
RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed"); | |
5290: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
5297: e9 c2 fc ff ff jmpq 4f5e <ZSTD_decodeSeqHeaders+0x3e> | |
529c: 0f 1f 40 00 nopl 0x0(%rax) | |
00000000000052a0 <ZSTD_decompressBlock_internal>: | |
size_t | |
ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, | |
void* dst, size_t dstCapacity, | |
const void* src, size_t srcSize, const int frame) | |
{ /* blockType == blockCompressed */ | |
52a0: 41 57 push %r15 | |
52a2: 41 56 push %r14 | |
52a4: 41 55 push %r13 | |
52a6: 41 54 push %r12 | |
52a8: 55 push %rbp | |
52a9: 53 push %rbx | |
52aa: 48 81 ec c8 00 00 00 sub $0xc8,%rsp | |
52b1: 48 89 54 24 08 mov %rdx,0x8(%rsp) | |
* (note: but it could be evaluated from current-lowLimit) | |
*/ | |
ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN)))); | |
DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize); | |
RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong, ""); | |
52b6: 49 81 f8 ff ff 01 00 cmp $0x1ffff,%r8 | |
52bd: 0f 87 95 00 00 00 ja 5358 <ZSTD_decompressBlock_internal+0xb8> | |
52c3: 4c 89 c3 mov %r8,%rbx | |
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, ""); | |
52c6: 49 83 f8 02 cmp $0x2,%r8 | |
52ca: 76 7c jbe 5348 <ZSTD_decompressBlock_internal+0xa8> | |
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3); | |
52cc: 0f b6 01 movzbl (%rcx),%eax | |
52cf: 48 89 fd mov %rdi,%rbp | |
52d2: 49 89 f5 mov %rsi,%r13 | |
52d5: 49 89 cc mov %rcx,%r12 | |
52d8: 45 89 cb mov %r9d,%r11d | |
52db: 41 89 c6 mov %eax,%r14d | |
52de: 41 83 e6 03 and $0x3,%r14d | |
switch(litEncType) | |
52e2: 41 80 fe 02 cmp $0x2,%r14b | |
52e6: 0f 84 9c 00 00 00 je 5388 <ZSTD_decompressBlock_internal+0xe8> | |
52ec: 41 80 fe 03 cmp $0x3,%r14b | |
52f0: 0f 84 82 00 00 00 je 5378 <ZSTD_decompressBlock_internal+0xd8> | |
52f6: 41 80 fe 01 cmp $0x1,%r14b | |
52fa: 0f 84 b0 01 00 00 je 54b0 <ZSTD_decompressBlock_internal+0x210> | |
U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
5300: 89 c2 mov %eax,%edx | |
5302: c0 ea 02 shr $0x2,%dl | |
5305: 83 e2 03 and $0x3,%edx | |
switch(lhlCode) | |
5308: 80 fa 01 cmp $0x1,%dl | |
530b: 0f 84 9f 09 00 00 je 5cb0 <ZSTD_decompressBlock_internal+0xa10> | |
5311: 80 fa 03 cmp $0x3,%dl | |
5314: 0f 84 76 09 00 00 je 5c90 <ZSTD_decompressBlock_internal+0x9f0> | |
litSize = istart[0] >> 3; | |
531a: c0 e8 03 shr $0x3,%al | |
531d: 44 0f b6 f0 movzbl %al,%r14d | |
lhSize = 1; | |
5321: b8 01 00 00 00 mov $0x1,%eax | |
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */ | |
5326: 4d 8d 3c 06 lea (%r14,%rax,1),%r15 | |
532a: 49 8d 57 20 lea 0x20(%r15),%rdx | |
532e: 48 39 d3 cmp %rdx,%rbx | |
5331: 0f 83 59 07 00 00 jae 5a90 <ZSTD_decompressBlock_internal+0x7f0> | |
5337: 44 89 5c 24 10 mov %r11d,0x10(%rsp) | |
RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, ""); | |
533c: 4c 39 fb cmp %r15,%rbx | |
533f: 0f 83 0b 08 00 00 jae 5b50 <ZSTD_decompressBlock_internal+0x8b0> | |
5345: 0f 1f 00 nopl (%rax) | |
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, | |
5348: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
534f: eb 0e jmp 535f <ZSTD_decompressBlock_internal+0xbf> | |
5351: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong, ""); | |
5358: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax | |
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG | |
/* else */ | |
return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame); | |
#endif | |
} | |
} | |
535f: 48 81 c4 c8 00 00 00 add $0xc8,%rsp | |
5366: 5b pop %rbx | |
5367: 5d pop %rbp | |
5368: 41 5c pop %r12 | |
536a: 41 5d pop %r13 | |
536c: 41 5e pop %r14 | |
536e: 41 5f pop %r15 | |
5370: c3 retq | |
5371: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, ""); | |
5378: 44 8b 8f 28 75 00 00 mov 0x7528(%rdi),%r9d | |
537f: 45 85 c9 test %r9d,%r9d | |
5382: 0f 84 08 08 00 00 je 5b90 <ZSTD_decompressBlock_internal+0x8f0> | |
RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3"); | |
5388: 48 83 fb 04 cmp $0x4,%rbx | |
538c: 76 ba jbe 5348 <ZSTD_decompressBlock_internal+0xa8> | |
MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; } | |
538e: 41 8b 0c 24 mov (%r12),%ecx | |
U32 const lhlCode = (istart[0] >> 2) & 3; | |
5392: c0 e8 02 shr $0x2,%al | |
5395: 83 e0 03 and $0x3,%eax | |
litSize = (lhc >> 4) & 0x3FF; | |
5398: 41 89 ca mov %ecx,%r10d | |
539b: 41 c1 ea 04 shr $0x4,%r10d | |
539f: 3c 02 cmp $0x2,%al | |
53a1: 0f 84 49 07 00 00 je 5af0 <ZSTD_decompressBlock_internal+0x850> | |
53a7: 3c 03 cmp $0x3,%al | |
53a9: 0f 84 01 07 00 00 je 5ab0 <ZSTD_decompressBlock_internal+0x810> | |
singleStream = !lhlCode; | |
53af: 83 f0 01 xor $0x1,%eax | |
litCSize = (lhc >> 14) & 0x3FF; | |
53b2: c1 e9 0e shr $0xe,%ecx | |
lhSize = 3; | |
53b5: bf 03 00 00 00 mov $0x3,%edi | |
litSize = (lhc >> 4) & 0x3FF; | |
53ba: 41 81 e2 ff 03 00 00 and $0x3ff,%r10d | |
singleStream = !lhlCode; | |
53c1: 0f b6 d0 movzbl %al,%edx | |
litCSize = (lhc >> 14) & 0x3FF; | |
53c4: 81 e1 ff 03 00 00 and $0x3ff,%ecx | |
RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, ""); | |
53ca: 4c 8d 3c 0f lea (%rdi,%rcx,1),%r15 | |
53ce: 4c 39 fb cmp %r15,%rbx | |
53d1: 0f 82 71 ff ff ff jb 5348 <ZSTD_decompressBlock_internal+0xa8> | |
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) { | |
53d7: 44 8b 85 f4 75 00 00 mov 0x75f4(%rbp),%r8d | |
53de: 45 85 c0 test %r8d,%r8d | |
53e1: 74 0d je 53f0 <ZSTD_decompressBlock_internal+0x150> | |
53e3: 49 81 fa 00 03 00 00 cmp $0x300,%r10 | |
53ea: 0f 87 ac 07 00 00 ja 5b9c <ZSTD_decompressBlock_internal+0x8fc> | |
dctx->litBuffer, litSize, istart+lhSize, litCSize, | |
53f0: 49 8d 04 3c lea (%r12,%rdi,1),%rax | |
53f4: 48 8d bd 90 76 00 00 lea 0x7690(%rbp),%rdi | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
53fb: 8b b5 d8 75 00 00 mov 0x75d8(%rbp),%esi | |
dctx->litBuffer, litSize, istart+lhSize, litCSize, | |
5401: 48 89 7c 24 10 mov %rdi,0x10(%rsp) | |
if (litEncType==set_repeat) { | |
5406: 41 80 fe 03 cmp $0x3,%r14b | |
540a: 0f 84 40 09 00 00 je 5d50 <ZSTD_decompressBlock_internal+0xab0> | |
if (singleStream) { | |
5410: 44 89 5c 24 28 mov %r11d,0x28(%rsp) | |
istart+lhSize, litCSize, dctx->workspace, | |
5415: 4c 8d 8d bc 6a 00 00 lea 0x6abc(%rbp),%r9 | |
dctx->entropy.hufTable, dctx->litBuffer, litSize, | |
541c: 48 8d bd 38 28 00 00 lea 0x2838(%rbp),%rdi | |
if (singleStream) { | |
5423: 85 d2 test %edx,%edx | |
5425: 0f 85 e5 06 00 00 jne 5b10 <ZSTD_decompressBlock_internal+0x870> | |
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2( | |
542b: 56 push %rsi | |
542c: 4c 89 d2 mov %r10,%rdx | |
542f: 49 89 c8 mov %rcx,%r8 | |
5432: 48 8d b5 90 76 00 00 lea 0x7690(%rbp),%rsi | |
5439: 68 00 0a 00 00 pushq $0xa00 | |
543e: 48 89 c1 mov %rax,%rcx | |
5441: 4c 89 54 24 30 mov %r10,0x30(%rsp) | |
5446: 48 89 7c 24 28 mov %rdi,0x28(%rsp) | |
544b: e8 00 00 00 00 callq 5450 <ZSTD_decompressBlock_internal+0x1b0> | |
5450: 5a pop %rdx | |
5451: 59 pop %rcx | |
5452: 44 8b 5c 24 28 mov 0x28(%rsp),%r11d | |
5457: 4c 8b 54 24 20 mov 0x20(%rsp),%r10 | |
545c: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
5461: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
5465: 0f 87 dd fe ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
dctx->litPtr = dctx->litBuffer; | |
546b: 48 8d 85 90 76 00 00 lea 0x7690(%rbp),%rax | |
dctx->litSize = litSize; | |
5472: 4c 89 95 c0 75 00 00 mov %r10,0x75c0(%rbp) | |
dctx->litPtr = dctx->litBuffer; | |
5479: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
dctx->litEntropy = 1; | |
5480: c7 85 28 75 00 00 01 movl $0x1,0x7528(%rbp) | |
5487: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
548a: 41 80 fe 02 cmp $0x2,%r14b | |
548e: 75 04 jne 5494 <ZSTD_decompressBlock_internal+0x1f4> | |
5490: 48 89 7d 18 mov %rdi,0x18(%rbp) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
5494: 4c 03 54 24 10 add 0x10(%rsp),%r10 | |
5499: 66 0f ef c0 pxor %xmm0,%xmm0 | |
549d: 41 0f 11 02 movups %xmm0,(%r10) | |
54a1: 41 0f 11 42 10 movups %xmm0,0x10(%r10) | |
return litCSize + lhSize; | |
54a6: eb 64 jmp 550c <ZSTD_decompressBlock_internal+0x26c> | |
54a8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
54af: 00 | |
{ U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
54b0: 89 c2 mov %eax,%edx | |
54b2: c0 ea 02 shr $0x2,%dl | |
54b5: 83 e2 03 and $0x3,%edx | |
switch(lhlCode) | |
54b8: 80 fa 01 cmp $0x1,%dl | |
54bb: 0f 84 4f 08 00 00 je 5d10 <ZSTD_decompressBlock_internal+0xa70> | |
54c1: 80 fa 03 cmp $0x3,%dl | |
54c4: 0f 84 06 08 00 00 je 5cd0 <ZSTD_decompressBlock_internal+0xa30> | |
litSize = istart[0] >> 3; | |
54ca: c0 e8 03 shr $0x3,%al | |
break; | |
54cd: 41 bf 02 00 00 00 mov $0x2,%r15d | |
litSize = istart[0] >> 3; | |
54d3: 44 0f b6 f0 movzbl %al,%r14d | |
lhSize = 1; | |
54d7: b8 01 00 00 00 mov $0x1,%eax | |
ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH); | |
54dc: 48 8d 8d 90 76 00 00 lea 0x7690(%rbp),%rcx | |
54e3: 41 0f b6 34 04 movzbl (%r12,%rax,1),%esi | |
54e8: 49 8d 56 20 lea 0x20(%r14),%rdx | |
54ec: 44 89 5c 24 10 mov %r11d,0x10(%rsp) | |
54f1: 48 89 cf mov %rcx,%rdi | |
54f4: e8 00 00 00 00 callq 54f9 <ZSTD_decompressBlock_internal+0x259> | |
dctx->litSize = litSize; | |
54f9: 4c 89 b5 c0 75 00 00 mov %r14,0x75c0(%rbp) | |
return lhSize+1; | |
5500: 44 8b 5c 24 10 mov 0x10(%rsp),%r11d | |
dctx->litPtr = dctx->litBuffer; | |
5505: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, ""); | |
550c: 48 89 d8 mov %rbx,%rax | |
ip += litCSize; | |
550f: 4f 8d 34 3c lea (%r12,%r15,1),%r14 | |
RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, ""); | |
5513: 4c 29 f8 sub %r15,%rax | |
5516: 48 89 44 24 10 mov %rax,0x10(%rsp) | |
551b: 0f 84 37 fe ff ff je 5358 <ZSTD_decompressBlock_internal+0xb8> | |
nbSeq = *ip++; | |
5521: 45 0f b6 3e movzbl (%r14),%r15d | |
int usePrefetchDecoder = dctx->ddictIsCold; | |
5525: 44 8b 95 f4 75 00 00 mov 0x75f4(%rbp),%r10d | |
nbSeq = *ip++; | |
552c: 49 8d 56 01 lea 0x1(%r14),%rdx | |
if (!nbSeq) { | |
5530: 45 85 ff test %r15d,%r15d | |
5533: 75 5b jne 5590 <ZSTD_decompressBlock_internal+0x2f0> | |
srcSize -= seqHSize; | |
5535: 45 31 c0 xor %r8d,%r8d | |
RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, ""); | |
5538: 48 83 7c 24 10 01 cmpq $0x1,0x10(%rsp) | |
553e: 0f 85 14 fe ff ff jne 5358 <ZSTD_decompressBlock_internal+0xb8> | |
if ( !usePrefetchDecoder | |
5544: 45 85 d2 test %r10d,%r10d | |
5547: 0f 84 13 02 00 00 je 5760 <ZSTD_decompressBlock_internal+0x4c0> | |
dctx->ddictIsCold = 0; | |
554d: c7 85 f4 75 00 00 00 movl $0x0,0x75f4(%rbp) | |
5554: 00 00 00 | |
if (dctx->bmi2) { | |
5557: 44 8b 95 d8 75 00 00 mov 0x75d8(%rbp),%r10d | |
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
555e: 48 89 d1 mov %rdx,%rcx | |
5561: 45 89 f9 mov %r15d,%r9d | |
5564: 4c 89 ee mov %r13,%rsi | |
5567: 48 8b 54 24 08 mov 0x8(%rsp),%rdx | |
556c: 48 89 ef mov %rbp,%rdi | |
if (dctx->bmi2) { | |
556f: 45 85 d2 test %r10d,%r10d | |
5572: 0f 85 fa 06 00 00 jne 5c72 <ZSTD_decompressBlock_internal+0x9d2> | |
} | |
5578: 48 81 c4 c8 00 00 00 add $0xc8,%rsp | |
557f: 5b pop %rbx | |
5580: 5d pop %rbp | |
5581: 41 5c pop %r12 | |
5583: 41 5d pop %r13 | |
5585: 41 5e pop %r14 | |
5587: 41 5f pop %r15 | |
return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
5589: e9 32 b5 ff ff jmpq ac0 <ZSTD_decompressSequencesLong_default.constprop.0> | |
558e: 66 90 xchg %ax,%ax | |
const BYTE* const iend = istart + srcSize; | |
5590: 49 01 dc add %rbx,%r12 | |
if (nbSeq > 0x7F) { | |
5593: 41 83 ff 7f cmp $0x7f,%r15d | |
5597: 7e 2a jle 55c3 <ZSTD_decompressBlock_internal+0x323> | |
if (nbSeq == 0xFF) { | |
5599: 41 81 ff ff 00 00 00 cmp $0xff,%r15d | |
55a0: 0f 84 ae 06 00 00 je 5c54 <ZSTD_decompressBlock_internal+0x9b4> | |
RETURN_ERROR_IF(ip >= iend, srcSize_wrong, ""); | |
55a6: 49 39 d4 cmp %rdx,%r12 | |
55a9: 0f 86 a9 fd ff ff jbe 5358 <ZSTD_decompressBlock_internal+0xb8> | |
nbSeq = ((nbSeq-0x80)<<8) + *ip++; | |
55af: 41 0f b6 46 01 movzbl 0x1(%r14),%eax | |
55b4: 41 83 c7 80 add $0xffffff80,%r15d | |
55b8: 49 8d 56 02 lea 0x2(%r14),%rdx | |
55bc: 41 c1 e7 08 shl $0x8,%r15d | |
55c0: 41 01 c7 add %eax,%r15d | |
RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */ | |
55c3: 48 8d 5a 01 lea 0x1(%rdx),%rbx | |
55c7: 49 39 dc cmp %rbx,%r12 | |
55ca: 0f 82 88 fd ff ff jb 5358 <ZSTD_decompressBlock_internal+0xb8> | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
55d0: 0f b6 02 movzbl (%rdx),%eax | |
ip, iend-ip, | |
55d3: 4d 89 e0 mov %r12,%r8 | |
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, | |
55d6: 48 8d 7d 20 lea 0x20(%rbp),%rdi | |
55da: c7 44 24 48 23 00 00 movl $0x23,0x48(%rsp) | |
55e1: 00 | |
55e2: 48 89 7c 24 18 mov %rdi,0x18(%rsp) | |
55e7: 44 8b 8d d8 75 00 00 mov 0x75d8(%rbp),%r9d | |
ip, iend-ip, | |
55ee: 49 29 d8 sub %rbx,%r8 | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
55f1: 89 c1 mov %eax,%ecx | |
55f3: 88 44 24 37 mov %al,0x37(%rsp) | |
dctx->workspace, sizeof(dctx->workspace), | |
55f7: 48 8d 85 bc 6a 00 00 lea 0x6abc(%rbp),%rax | |
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); | |
55fe: c0 e9 06 shr $0x6,%cl | |
dctx->workspace, sizeof(dctx->workspace), | |
5601: 48 89 44 24 28 mov %rax,0x28(%rsp) | |
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, | |
5606: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
switch(type) | |
560c: 80 f9 02 cmp $0x2,%cl | |
560f: 0f 84 ab 07 00 00 je 5dc0 <ZSTD_decompressBlock_internal+0xb20> | |
5615: 80 f9 03 cmp $0x3,%cl | |
5618: 0f 84 ff 05 00 00 je 5c1d <ZSTD_decompressBlock_internal+0x97d> | |
561e: 80 f9 01 cmp $0x1,%cl | |
5621: 0f 84 9a 05 00 00 je 5bc1 <ZSTD_decompressBlock_internal+0x921> | |
*DTablePtr = defaultTable; | |
5627: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 562e <ZSTD_decompressBlock_internal+0x38e> | |
int usePrefetchDecoder = dctx->ddictIsCold; | |
562e: 44 89 d1 mov %r10d,%ecx | |
*DTablePtr = defaultTable; | |
5631: 48 89 7d 00 mov %rdi,0x0(%rbp) | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
5635: 0f b6 54 24 37 movzbl 0x37(%rsp),%edx | |
563a: 44 89 5c 24 20 mov %r11d,0x20(%rsp) | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
563f: 48 83 ec 08 sub $0x8,%rsp | |
5643: 48 8d 75 10 lea 0x10(%rbp),%rsi | |
5647: 44 89 54 24 20 mov %r10d,0x20(%rsp) | |
564c: 48 8d bd 28 10 00 00 lea 0x1028(%rbp),%rdi | |
5653: 41 51 push %r9 | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
5655: c0 ea 04 shr $0x4,%dl | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5658: 49 89 d9 mov %rbx,%r9 | |
565b: ff 74 24 38 pushq 0x38(%rsp) | |
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); | |
565f: 83 e2 03 and $0x3,%edx | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5662: 41 57 push %r15 | |
5664: 51 push %rcx | |
5665: b9 1f 00 00 00 mov $0x1f,%ecx | |
566a: 50 push %rax | |
566b: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5672 <ZSTD_decompressBlock_internal+0x3d2> | |
5672: 50 push %rax | |
5673: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 567a <ZSTD_decompressBlock_internal+0x3da> | |
567a: 50 push %rax | |
567b: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 5682 <ZSTD_decompressBlock_internal+0x3e2> | |
5682: 50 push %rax | |
5683: 41 50 push %r8 | |
5685: 41 b8 08 00 00 00 mov $0x8,%r8d | |
568b: e8 b0 f6 ff ff callq 4d40 <ZSTD_buildSeqTable.constprop.0> | |
RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed"); | |
5690: 48 83 c4 50 add $0x50,%rsp | |
5694: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
5698: 0f 87 aa fc ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
ip += ofhSize; | |
569e: 48 01 c3 add %rax,%rbx | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
56a1: 0f b6 54 24 37 movzbl 0x37(%rsp),%edx | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
56a6: 48 83 ec 08 sub $0x8,%rsp | |
56aa: 48 8d 75 08 lea 0x8(%rbp),%rsi | |
56ae: 8b 85 d8 75 00 00 mov 0x75d8(%rbp),%eax | |
ip, iend-ip, | |
56b4: 49 29 dc sub %rbx,%r12 | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
56b7: 48 8d bd 30 18 00 00 lea 0x1830(%rbp),%rdi | |
56be: 49 89 d9 mov %rbx,%r9 | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
56c1: c0 ea 02 shr $0x2,%dl | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
56c4: 41 b8 09 00 00 00 mov $0x9,%r8d | |
56ca: b9 34 00 00 00 mov $0x34,%ecx | |
56cf: 50 push %rax | |
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); | |
56d0: 83 e2 03 and $0x3,%edx | |
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, | |
56d3: ff 74 24 38 pushq 0x38(%rsp) | |
56d7: 41 57 push %r15 | |
56d9: 8b 85 f4 75 00 00 mov 0x75f4(%rbp),%eax | |
56df: 50 push %rax | |
56e0: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
56e6: 50 push %rax | |
56e7: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 56ee <ZSTD_decompressBlock_internal+0x44e> | |
56ee: 50 push %rax | |
56ef: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 56f6 <ZSTD_decompressBlock_internal+0x456> | |
56f6: 50 push %rax | |
56f7: 48 8d 05 00 00 00 00 lea 0x0(%rip),%rax # 56fe <ZSTD_decompressBlock_internal+0x45e> | |
56fe: 50 push %rax | |
56ff: 41 54 push %r12 | |
5701: e8 3a f6 ff ff callq 4d40 <ZSTD_buildSeqTable.constprop.0> | |
RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed"); | |
5706: 48 83 c4 50 add $0x50,%rsp | |
570a: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
570e: 0f 87 34 fc ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
ip += mlhSize; | |
5714: 48 01 d8 add %rbx,%rax | |
return ip-istart; | |
5717: 4c 29 f0 sub %r14,%rax | |
if (ZSTD_isError(seqHSize)) return seqHSize; | |
571a: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
571e: 0f 87 3b fc ff ff ja 535f <ZSTD_decompressBlock_internal+0xbf> | |
srcSize -= seqHSize; | |
5724: 4c 8b 44 24 10 mov 0x10(%rsp),%r8 | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
5729: 44 8b 54 24 18 mov 0x18(%rsp),%r10d | |
ip += seqHSize; | |
572e: 49 8d 14 06 lea (%r14,%rax,1),%rdx | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
5732: 44 8b 5c 24 20 mov 0x20(%rsp),%r11d | |
srcSize -= seqHSize; | |
5737: 49 29 c0 sub %rax,%r8 | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
573a: 4d 85 ed test %r13,%r13 | |
573d: 0f 85 01 fe ff ff jne 5544 <ZSTD_decompressBlock_internal+0x2a4> | |
5743: 48 c7 c0 ba ff ff ff mov $0xffffffffffffffba,%rax | |
574a: 45 85 ff test %r15d,%r15d | |
574d: 0f 85 0c fc ff ff jne 535f <ZSTD_decompressBlock_internal+0xbf> | |
5753: e9 ec fd ff ff jmpq 5544 <ZSTD_decompressBlock_internal+0x2a4> | |
5758: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
575f: 00 | |
&& (!frame || (dctx->fParams.windowSize > (1<<24))) | |
5760: 45 85 db test %r11d,%r11d | |
5763: 0f 85 d7 02 00 00 jne 5a40 <ZSTD_decompressBlock_internal+0x7a0> | |
&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */ | |
5769: 41 83 ff 08 cmp $0x8,%r15d | |
576d: 0f 8e de 02 00 00 jle 5a51 <ZSTD_decompressBlock_internal+0x7b1> | |
U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr); | |
5773: 48 8b 7d 10 mov 0x10(%rbp),%rdi | |
U32 const max = 1 << tableLog; | |
5777: 41 ba 01 00 00 00 mov $0x1,%r10d | |
U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog; | |
577d: 8b 4f 04 mov 0x4(%rdi),%ecx | |
U32 const max = 1 << tableLog; | |
5780: 41 d3 e2 shl %cl,%r10d | |
for (u=0; u<max; u++) { | |
5783: 45 85 d2 test %r10d,%r10d | |
5786: 0f 84 c5 02 00 00 je 5a51 <ZSTD_decompressBlock_internal+0x7b1> | |
578c: 41 8d 72 ff lea -0x1(%r10),%esi | |
5790: 83 fe 0f cmp $0xf,%esi | |
5793: 0f 86 f8 06 00 00 jbe 5e91 <ZSTD_decompressBlock_internal+0xbf1> | |
5799: 41 89 f1 mov %esi,%r9d | |
579c: 48 8d 47 0a lea 0xa(%rdi),%rax | |
57a0: 66 0f ef d2 pxor %xmm2,%xmm2 | |
57a4: 66 0f 6f 0d 00 00 00 movdqa 0x0(%rip),%xmm1 # 57ac <ZSTD_decompressBlock_internal+0x50c> | |
57ab: 00 | |
57ac: 41 c1 e9 04 shr $0x4,%r9d | |
57b0: 66 0f 6f 35 00 00 00 movdqa 0x0(%rip),%xmm6 # 57b8 <ZSTD_decompressBlock_internal+0x518> | |
57b7: 00 | |
57b8: 66 0f ef e4 pxor %xmm4,%xmm4 | |
57bc: 66 0f ef db pxor %xmm3,%xmm3 | |
57c0: 41 83 e9 01 sub $0x1,%r9d | |
57c4: 66 0f 6f 2d 00 00 00 movdqa 0x0(%rip),%xmm5 # 57cc <ZSTD_decompressBlock_internal+0x52c> | |
57cb: 00 | |
57cc: 49 c1 e1 07 shl $0x7,%r9 | |
57d0: 4e 8d 8c 0f 8a 00 00 lea 0x8a(%rdi,%r9,1),%r9 | |
57d7: 00 | |
57d8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
57df: 00 | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
57e0: f3 0f 6f 00 movdqu (%rax),%xmm0 | |
57e4: f3 0f 6f 78 10 movdqu 0x10(%rax),%xmm7 | |
57e9: 48 83 e8 80 sub $0xffffffffffffff80,%rax | |
57ed: f3 44 0f 6f 40 b0 movdqu -0x50(%rax),%xmm8 | |
57f3: f3 44 0f 6f 48 f0 movdqu -0x10(%rax),%xmm9 | |
57f9: 66 0f db f9 pand %xmm1,%xmm7 | |
57fd: 66 0f db c1 pand %xmm1,%xmm0 | |
5801: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
5805: f3 0f 6f 78 a0 movdqu -0x60(%rax),%xmm7 | |
580a: 66 44 0f db c1 pand %xmm1,%xmm8 | |
580f: 66 44 0f db c9 pand %xmm1,%xmm9 | |
5814: 66 0f db c1 pand %xmm1,%xmm0 | |
5818: 66 0f db f9 pand %xmm1,%xmm7 | |
581c: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
5821: f3 44 0f 6f 40 d0 movdqu -0x30(%rax),%xmm8 | |
5827: 66 0f db f9 pand %xmm1,%xmm7 | |
582b: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
582f: f3 0f 6f 78 c0 movdqu -0x40(%rax),%xmm7 | |
5834: 66 44 0f db c1 pand %xmm1,%xmm8 | |
5839: 66 0f db c1 pand %xmm1,%xmm0 | |
583d: 66 0f db f9 pand %xmm1,%xmm7 | |
5841: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
5846: f3 44 0f 6f 40 e0 movdqu -0x20(%rax),%xmm8 | |
584c: 66 0f db f9 pand %xmm1,%xmm7 | |
5850: 66 44 0f db c1 pand %xmm1,%xmm8 | |
5855: 66 45 0f 67 c1 packuswb %xmm9,%xmm8 | |
585a: 66 44 0f db c1 pand %xmm1,%xmm8 | |
585f: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
5864: 66 0f db f9 pand %xmm1,%xmm7 | |
5868: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
586c: 66 0f d8 c6 psubusb %xmm6,%xmm0 | |
5870: 66 0f 74 c4 pcmpeqb %xmm4,%xmm0 | |
5874: 66 0f df c5 pandn %xmm5,%xmm0 | |
5878: 66 0f 6f f8 movdqa %xmm0,%xmm7 | |
587c: 66 0f 68 c4 punpckhbw %xmm4,%xmm0 | |
5880: 66 44 0f 6f c0 movdqa %xmm0,%xmm8 | |
5885: 66 0f 60 fc punpcklbw %xmm4,%xmm7 | |
5889: 66 0f 69 c3 punpckhwd %xmm3,%xmm0 | |
588d: 66 44 0f 61 c3 punpcklwd %xmm3,%xmm8 | |
5892: 66 41 0f fe c0 paddd %xmm8,%xmm0 | |
5897: 66 44 0f 6f c7 movdqa %xmm7,%xmm8 | |
589c: 66 0f 69 fb punpckhwd %xmm3,%xmm7 | |
58a0: 66 44 0f 61 c3 punpcklwd %xmm3,%xmm8 | |
58a5: 66 41 0f fe f8 paddd %xmm8,%xmm7 | |
58aa: 66 0f fe c7 paddd %xmm7,%xmm0 | |
58ae: 66 0f fe d0 paddd %xmm0,%xmm2 | |
for (u=0; u<max; u++) { | |
58b2: 4c 39 c8 cmp %r9,%rax | |
58b5: 0f 85 25 ff ff ff jne 57e0 <ZSTD_decompressBlock_internal+0x540> | |
58bb: 66 0f 6f c2 movdqa %xmm2,%xmm0 | |
58bf: 83 e6 f0 and $0xfffffff0,%esi | |
58c2: 66 0f 73 d8 08 psrldq $0x8,%xmm0 | |
58c7: 66 0f fe d0 paddd %xmm0,%xmm2 | |
58cb: 66 0f 6f c2 movdqa %xmm2,%xmm0 | |
58cf: 66 0f 73 d8 04 psrldq $0x4,%xmm0 | |
58d4: 66 0f fe d0 paddd %xmm0,%xmm2 | |
58d8: 66 0f 7e d0 movd %xmm2,%eax | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
58dc: 44 8d 5e 01 lea 0x1(%rsi),%r11d | |
58e0: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
58e6: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
58e9: 45 39 da cmp %r11d,%r10d | |
58ec: 0f 86 26 01 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
58f2: 44 8d 5e 02 lea 0x2(%rsi),%r11d | |
58f6: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
58fc: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
58ff: 45 39 da cmp %r11d,%r10d | |
5902: 0f 86 10 01 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
5908: 44 8d 5e 03 lea 0x3(%rsi),%r11d | |
590c: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5912: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5915: 45 39 da cmp %r11d,%r10d | |
5918: 0f 86 fa 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
591e: 44 8d 5e 04 lea 0x4(%rsi),%r11d | |
5922: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5928: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
592b: 45 39 da cmp %r11d,%r10d | |
592e: 0f 86 e4 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
5934: 44 8d 5e 05 lea 0x5(%rsi),%r11d | |
5938: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
593e: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5941: 45 39 da cmp %r11d,%r10d | |
5944: 0f 86 ce 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
594a: 44 8d 5e 06 lea 0x6(%rsi),%r11d | |
594e: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5954: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5957: 45 39 da cmp %r11d,%r10d | |
595a: 0f 86 b8 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
5960: 44 8d 5e 07 lea 0x7(%rsi),%r11d | |
5964: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
596a: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
596d: 45 39 da cmp %r11d,%r10d | |
5970: 0f 86 a2 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
5976: 44 8d 5e 08 lea 0x8(%rsi),%r11d | |
597a: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5980: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5983: 45 39 da cmp %r11d,%r10d | |
5986: 0f 86 8c 00 00 00 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
598c: 44 8d 5e 09 lea 0x9(%rsi),%r11d | |
5990: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5996: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5999: 45 39 da cmp %r11d,%r10d | |
599c: 76 7a jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
599e: 44 8d 5e 0a lea 0xa(%rsi),%r11d | |
59a2: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
59a8: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
59ab: 45 39 da cmp %r11d,%r10d | |
59ae: 76 68 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
59b0: 44 8d 5e 0b lea 0xb(%rsi),%r11d | |
59b4: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
59ba: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
59bd: 45 39 da cmp %r11d,%r10d | |
59c0: 76 56 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
59c2: 44 8d 5e 0c lea 0xc(%rsi),%r11d | |
59c6: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
59cc: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
59cf: 45 39 da cmp %r11d,%r10d | |
59d2: 76 44 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
59d4: 44 8d 5e 0d lea 0xd(%rsi),%r11d | |
59d8: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
59de: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
59e1: 45 39 da cmp %r11d,%r10d | |
59e4: 76 32 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
59e6: 44 8d 5e 0e lea 0xe(%rsi),%r11d | |
59ea: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
59f0: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
59f3: 45 39 da cmp %r11d,%r10d | |
59f6: 76 20 jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
59f8: 44 8d 5e 0f lea 0xf(%rsi),%r11d | |
59fc: 42 80 7c df 02 17 cmpb $0x17,0x2(%rdi,%r11,8) | |
5a02: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
5a05: 45 39 da cmp %r11d,%r10d | |
5a08: 76 0e jbe 5a18 <ZSTD_decompressBlock_internal+0x778> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
5a0a: 83 c6 10 add $0x10,%esi | |
5a0d: 80 7c f7 02 17 cmpb $0x17,0x2(%rdi,%rsi,8) | |
5a12: 83 d8 ff sbb $0xffffffff,%eax | |
5a15: 0f 1f 00 nopl (%rax) | |
dctx->ddictIsCold = 0; | |
5a18: c7 85 f4 75 00 00 00 movl $0x0,0x75f4(%rbp) | |
5a1f: 00 00 00 | |
total <<= (OffFSELog - tableLog); /* scale to OffFSELog */ | |
5a22: be 08 00 00 00 mov $0x8,%esi | |
5a27: 29 ce sub %ecx,%esi | |
5a29: 89 f1 mov %esi,%ecx | |
5a2b: d3 e0 shl %cl,%eax | |
if (usePrefetchDecoder) | |
5a2d: 83 f8 06 cmp $0x6,%eax | |
5a30: 76 29 jbe 5a5b <ZSTD_decompressBlock_internal+0x7bb> | |
5a32: e9 20 fb ff ff jmpq 5557 <ZSTD_decompressBlock_internal+0x2b7> | |
5a37: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
5a3e: 00 00 | |
&& (!frame || (dctx->fParams.windowSize > (1<<24))) | |
5a40: 48 81 bd f0 74 00 00 cmpq $0x1000000,0x74f0(%rbp) | |
5a47: 00 00 00 01 | |
5a4b: 0f 87 18 fd ff ff ja 5769 <ZSTD_decompressBlock_internal+0x4c9> | |
dctx->ddictIsCold = 0; | |
5a51: c7 85 f4 75 00 00 00 movl $0x0,0x75f4(%rbp) | |
5a58: 00 00 00 | |
if (dctx->bmi2) { | |
5a5b: 8b 85 d8 75 00 00 mov 0x75d8(%rbp),%eax | |
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
5a61: 48 89 d1 mov %rdx,%rcx | |
5a64: 45 89 f9 mov %r15d,%r9d | |
5a67: 4c 89 ee mov %r13,%rsi | |
5a6a: 48 8b 54 24 08 mov 0x8(%rsp),%rdx | |
5a6f: 48 89 ef mov %rbp,%rdi | |
if (dctx->bmi2) { | |
5a72: 85 c0 test %eax,%eax | |
5a74: 0f 85 b6 02 00 00 jne 5d30 <ZSTD_decompressBlock_internal+0xa90> | |
} | |
5a7a: 48 81 c4 c8 00 00 00 add $0xc8,%rsp | |
5a81: 5b pop %rbx | |
5a82: 5d pop %rbp | |
5a83: 41 5c pop %r12 | |
5a85: 41 5d pop %r13 | |
5a87: 41 5e pop %r14 | |
5a89: 41 5f pop %r15 | |
return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
5a8b: e9 50 cd ff ff jmpq 27e0 <ZSTD_decompressSequences_default.constprop.0> | |
dctx->litPtr = istart+lhSize; | |
5a90: 4c 01 e0 add %r12,%rax | |
dctx->litSize = litSize; | |
5a93: 4c 89 b5 c0 75 00 00 mov %r14,0x75c0(%rbp) | |
dctx->litPtr = istart+lhSize; | |
5a9a: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
return lhSize+litSize; | |
5aa1: e9 66 fa ff ff jmpq 550c <ZSTD_decompressBlock_internal+0x26c> | |
5aa6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
5aad: 00 00 00 | |
litSize = (lhc >> 4) & 0x3FFFF; | |
5ab0: 44 89 d0 mov %r10d,%eax | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
5ab3: 41 0f b6 54 24 04 movzbl 0x4(%r12),%edx | |
5ab9: 25 ff ff 03 00 and $0x3ffff,%eax | |
litSize = (lhc >> 4) & 0x3FFFF; | |
5abe: 41 89 c2 mov %eax,%r10d | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
5ac1: 3d 00 00 02 00 cmp $0x20000,%eax | |
5ac6: 0f 87 7c f8 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
5acc: c1 e9 16 shr $0x16,%ecx | |
lhSize = 5; | |
5acf: bf 05 00 00 00 mov $0x5,%edi | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
5ad4: 89 c8 mov %ecx,%eax | |
5ad6: 0f b6 ca movzbl %dl,%ecx | |
U32 singleStream=0; | |
5ad9: 31 d2 xor %edx,%edx | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
5adb: 48 c1 e1 0a shl $0xa,%rcx | |
5adf: 48 01 c1 add %rax,%rcx | |
5ae2: e9 e3 f8 ff ff jmpq 53ca <ZSTD_decompressBlock_internal+0x12a> | |
5ae7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
5aee: 00 00 | |
litSize = (lhc >> 4) & 0x3FFF; | |
5af0: 41 81 e2 ff 3f 00 00 and $0x3fff,%r10d | |
litCSize = lhc >> 18; | |
5af7: c1 e9 12 shr $0x12,%ecx | |
U32 singleStream=0; | |
5afa: 31 d2 xor %edx,%edx | |
lhSize = 4; | |
5afc: bf 04 00 00 00 mov $0x4,%edi | |
break; | |
5b01: e9 c4 f8 ff ff jmpq 53ca <ZSTD_decompressBlock_internal+0x12a> | |
5b06: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
5b0d: 00 00 00 | |
hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2( | |
5b10: 56 push %rsi | |
5b11: 49 89 c8 mov %rcx,%r8 | |
5b14: 4c 89 d2 mov %r10,%rdx | |
5b17: 48 8d b5 90 76 00 00 lea 0x7690(%rbp),%rsi | |
5b1e: 68 00 0a 00 00 pushq $0xa00 | |
5b23: 48 89 c1 mov %rax,%rcx | |
5b26: 4c 89 54 24 30 mov %r10,0x30(%rsp) | |
5b2b: 48 89 7c 24 28 mov %rdi,0x28(%rsp) | |
5b30: e8 00 00 00 00 callq 5b35 <ZSTD_decompressBlock_internal+0x895> | |
5b35: 5e pop %rsi | |
5b36: 5f pop %rdi | |
5b37: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi | |
5b3c: 4c 8b 54 24 20 mov 0x20(%rsp),%r10 | |
5b41: 44 8b 5c 24 28 mov 0x28(%rsp),%r11d | |
5b46: e9 16 f9 ff ff jmpq 5461 <ZSTD_decompressBlock_internal+0x1c1> | |
5b4b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
5b50: 48 8d 8d 90 76 00 00 lea 0x7690(%rbp),%rcx | |
5b57: 49 8d 34 04 lea (%r12,%rax,1),%rsi | |
5b5b: 4c 89 f2 mov %r14,%rdx | |
5b5e: 48 89 cf mov %rcx,%rdi | |
5b61: e8 00 00 00 00 callq 5b66 <ZSTD_decompressBlock_internal+0x8c6> | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
5b66: 66 0f ef c0 pxor %xmm0,%xmm0 | |
return lhSize+litSize; | |
5b6a: 44 8b 5c 24 10 mov 0x10(%rsp),%r11d | |
dctx->litSize = litSize; | |
5b6f: 4c 89 b5 c0 75 00 00 mov %r14,0x75c0(%rbp) | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
5b76: 48 89 c1 mov %rax,%rcx | |
dctx->litPtr = dctx->litBuffer; | |
5b79: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
5b80: 4c 01 f1 add %r14,%rcx | |
5b83: 0f 11 01 movups %xmm0,(%rcx) | |
5b86: 0f 11 41 10 movups %xmm0,0x10(%rcx) | |
return lhSize+litSize; | |
5b8a: e9 7d f9 ff ff jmpq 550c <ZSTD_decompressBlock_internal+0x26c> | |
5b8f: 90 nop | |
RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, ""); | |
5b90: 48 c7 c0 e2 ff ff ff mov $0xffffffffffffffe2,%rax | |
5b97: e9 c3 f7 ff ff jmpq 535f <ZSTD_decompressBlock_internal+0xbf> | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
5b9c: 48 8b 45 18 mov 0x18(%rbp),%rax | |
5ba0: 48 8d b0 40 40 00 00 lea 0x4040(%rax),%rsi | |
5ba7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
5bae: 00 00 | |
5bb0: 0f 18 10 prefetcht1 (%rax) | |
5bb3: 48 83 c0 40 add $0x40,%rax | |
5bb7: 48 39 f0 cmp %rsi,%rax | |
5bba: 75 f4 jne 5bb0 <ZSTD_decompressBlock_internal+0x910> | |
5bbc: e9 2f f8 ff ff jmpq 53f0 <ZSTD_decompressBlock_internal+0x150> | |
RETURN_ERROR_IF(!srcSize, srcSize_wrong, ""); | |
5bc1: 4d 85 c0 test %r8,%r8 | |
5bc4: 0f 84 7e f7 ff ff je 5348 <ZSTD_decompressBlock_internal+0xa8> | |
RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, ""); | |
5bca: 0f b6 4a 01 movzbl 0x1(%rdx),%ecx | |
5bce: 80 f9 23 cmp $0x23,%cl | |
5bd1: 0f 87 71 f7 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
cell->nextState = 0; | |
5bd7: 31 db xor %ebx,%ebx | |
U32 const baseline = baseValue[symbol]; | |
5bd9: 48 8d 35 00 00 00 00 lea 0x0(%rip),%rsi # 5be0 <ZSTD_decompressBlock_internal+0x940> | |
U32 const nbBits = nbAdditionalBits[symbol]; | |
5be0: 48 8d 3d 00 00 00 00 lea 0x0(%rip),%rdi # 5be7 <ZSTD_decompressBlock_internal+0x947> | |
ip, iend-ip, | |
5be7: 4d 89 e0 mov %r12,%r8 | |
U32 const baseline = baseValue[symbol]; | |
5bea: 8b 34 8e mov (%rsi,%rcx,4),%esi | |
U32 const nbBits = nbAdditionalBits[symbol]; | |
5bed: 8b 0c 8f mov (%rdi,%rcx,4),%ecx | |
cell->nextState = 0; | |
5bf0: 66 89 5d 28 mov %bx,0x28(%rbp) | |
*DTablePtr = DTableSpace; | |
5bf4: 48 8d 5d 20 lea 0x20(%rbp),%rbx | |
5bf8: 48 89 5d 00 mov %rbx,0x0(%rbp) | |
ip += llhSize; | |
5bfc: 48 8d 5a 02 lea 0x2(%rdx),%rbx | |
cell->nbAdditionalBits = (BYTE)nbAddBits; | |
5c00: 88 4d 2a mov %cl,0x2a(%rbp) | |
ip, iend-ip, | |
5c03: 49 29 d8 sub %rbx,%r8 | |
int usePrefetchDecoder = dctx->ddictIsCold; | |
5c06: 44 89 d1 mov %r10d,%ecx | |
DTableH->fastMode = 0; | |
5c09: 48 c7 45 20 00 00 00 movq $0x0,0x20(%rbp) | |
5c10: 00 | |
cell->nbBits = 0; | |
5c11: c6 45 2b 00 movb $0x0,0x2b(%rbp) | |
cell->baseValue = baseValue; | |
5c15: 89 75 2c mov %esi,0x2c(%rbp) | |
5c18: e9 18 fa ff ff jmpq 5635 <ZSTD_decompressBlock_internal+0x395> | |
RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, ""); | |
5c1d: 85 c0 test %eax,%eax | |
5c1f: 0f 84 23 f7 ff ff je 5348 <ZSTD_decompressBlock_internal+0xa8> | |
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) { | |
5c25: 45 85 d2 test %r10d,%r10d | |
5c28: 74 22 je 5c4c <ZSTD_decompressBlock_internal+0x9ac> | |
5c2a: 41 83 ff 18 cmp $0x18,%r15d | |
5c2e: 7e 1c jle 5c4c <ZSTD_decompressBlock_internal+0x9ac> | |
PREFETCH_AREA(pStart, pSize); | |
5c30: 48 8b 55 00 mov 0x0(%rbp),%rdx | |
5c34: 48 8d 8a 40 10 00 00 lea 0x1040(%rdx),%rcx | |
5c3b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
5c40: 0f 18 12 prefetcht1 (%rdx) | |
5c43: 48 83 c2 40 add $0x40,%rdx | |
5c47: 48 39 ca cmp %rcx,%rdx | |
5c4a: 75 f4 jne 5c40 <ZSTD_decompressBlock_internal+0x9a0> | |
5c4c: 44 89 d1 mov %r10d,%ecx | |
5c4f: e9 e1 f9 ff ff jmpq 5635 <ZSTD_decompressBlock_internal+0x395> | |
RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, ""); | |
5c54: 49 8d 56 03 lea 0x3(%r14),%rdx | |
5c58: 49 39 d4 cmp %rdx,%r12 | |
5c5b: 0f 82 f7 f6 ff ff jb 5358 <ZSTD_decompressBlock_internal+0xb8> | |
nbSeq = MEM_readLE16(ip) + LONGNBSEQ; | |
5c61: 45 0f b7 7e 01 movzwl 0x1(%r14),%r15d | |
5c66: 41 81 c7 00 7f 00 00 add $0x7f00,%r15d | |
ip+=2; | |
5c6d: e9 51 f9 ff ff jmpq 55c3 <ZSTD_decompressBlock_internal+0x323> | |
} | |
5c72: 48 81 c4 c8 00 00 00 add $0xc8,%rsp | |
5c79: 5b pop %rbx | |
5c7a: 5d pop %rbp | |
5c7b: 41 5c pop %r12 | |
5c7d: 41 5d pop %r13 | |
5c7f: 41 5e pop %r14 | |
5c81: 41 5f pop %r15 | |
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
5c83: e9 78 d5 ff ff jmpq 3200 <ZSTD_decompressSequencesLong_bmi2.constprop.0> | |
5c88: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) | |
5c8f: 00 | |
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16); | |
5c90: 44 0f b6 71 02 movzbl 0x2(%rcx),%r14d | |
5c95: 0f b7 01 movzwl (%rcx),%eax | |
5c98: 41 c1 e6 10 shl $0x10,%r14d | |
5c9c: 41 01 c6 add %eax,%r14d | |
lhSize = 3; | |
5c9f: b8 03 00 00 00 mov $0x3,%eax | |
litSize = MEM_readLE24(istart) >> 4; | |
5ca4: 41 c1 ee 04 shr $0x4,%r14d | |
break; | |
5ca8: e9 79 f6 ff ff jmpq 5326 <ZSTD_decompressBlock_internal+0x86> | |
5cad: 0f 1f 00 nopl (%rax) | |
litSize = MEM_readLE16(istart) >> 4; | |
5cb0: 44 0f b7 31 movzwl (%rcx),%r14d | |
lhSize = 2; | |
5cb4: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
5cb9: 66 41 c1 ee 04 shr $0x4,%r14w | |
5cbe: 45 0f b7 f6 movzwl %r14w,%r14d | |
break; | |
5cc2: e9 5f f6 ff ff jmpq 5326 <ZSTD_decompressBlock_internal+0x86> | |
5cc7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
5cce: 00 00 | |
5cd0: 44 0f b6 71 02 movzbl 0x2(%rcx),%r14d | |
5cd5: 0f b7 01 movzwl (%rcx),%eax | |
5cd8: 41 c1 e6 10 shl $0x10,%r14d | |
5cdc: 41 01 c6 add %eax,%r14d | |
litSize = MEM_readLE24(istart) >> 4; | |
5cdf: 41 c1 ee 04 shr $0x4,%r14d | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
5ce3: 49 81 fe 00 00 02 00 cmp $0x20000,%r14 | |
5cea: 0f 87 58 f6 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
5cf0: 49 83 f8 03 cmp $0x3,%r8 | |
5cf4: 0f 84 4e f6 ff ff je 5348 <ZSTD_decompressBlock_internal+0xa8> | |
5cfa: 41 bf 04 00 00 00 mov $0x4,%r15d | |
lhSize = 3; | |
5d00: b8 03 00 00 00 mov $0x3,%eax | |
5d05: e9 d2 f7 ff ff jmpq 54dc <ZSTD_decompressBlock_internal+0x23c> | |
5d0a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
litSize = MEM_readLE16(istart) >> 4; | |
5d10: 44 0f b7 31 movzwl (%rcx),%r14d | |
break; | |
5d14: 41 bf 03 00 00 00 mov $0x3,%r15d | |
lhSize = 2; | |
5d1a: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
5d1f: 66 41 c1 ee 04 shr $0x4,%r14w | |
5d24: 45 0f b7 f6 movzwl %r14w,%r14d | |
break; | |
5d28: e9 af f7 ff ff jmpq 54dc <ZSTD_decompressBlock_internal+0x23c> | |
5d2d: 0f 1f 00 nopl (%rax) | |
} | |
5d30: 48 81 c4 c8 00 00 00 add $0xc8,%rsp | |
5d37: 5b pop %rbx | |
5d38: 5d pop %rbp | |
5d39: 41 5c pop %r12 | |
5d3b: 41 5d pop %r13 | |
5d3d: 41 5e pop %r14 | |
5d3f: 41 5f pop %r15 | |
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
5d41: e9 3a c1 ff ff jmpq 1e80 <ZSTD_decompressSequences_bmi2.constprop.0> | |
5d46: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
5d4d: 00 00 00 | |
if (singleStream) { | |
5d50: 85 d2 test %edx,%edx | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
5d52: 41 89 f1 mov %esi,%r9d | |
5d55: 44 89 5c 24 20 mov %r11d,0x20(%rsp) | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
5d5a: 4c 8b 45 18 mov 0x18(%rbp),%r8 | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
5d5e: 4c 89 54 24 18 mov %r10,0x18(%rsp) | |
5d63: 48 89 c2 mov %rax,%rdx | |
5d66: 4c 89 d6 mov %r10,%rsi | |
if (singleStream) { | |
5d69: 74 3d je 5da8 <ZSTD_decompressBlock_internal+0xb08> | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
5d6b: e8 00 00 00 00 callq 5d70 <ZSTD_decompressBlock_internal+0xad0> | |
5d70: 4c 8b 54 24 18 mov 0x18(%rsp),%r10 | |
5d75: 44 8b 5c 24 20 mov 0x20(%rsp),%r11d | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
5d7a: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
5d7e: 0f 87 c4 f5 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
dctx->litPtr = dctx->litBuffer; | |
5d84: 48 8d 85 90 76 00 00 lea 0x7690(%rbp),%rax | |
dctx->litSize = litSize; | |
5d8b: 4c 89 95 c0 75 00 00 mov %r10,0x75c0(%rbp) | |
dctx->litPtr = dctx->litBuffer; | |
5d92: 48 89 85 a0 75 00 00 mov %rax,0x75a0(%rbp) | |
dctx->litEntropy = 1; | |
5d99: c7 85 28 75 00 00 01 movl $0x1,0x7528(%rbp) | |
5da0: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
5da3: e9 ec f6 ff ff jmpq 5494 <ZSTD_decompressBlock_internal+0x1f4> | |
hufSuccess = HUF_decompress4X_usingDTable_bmi2( | |
5da8: 48 8d bd 90 76 00 00 lea 0x7690(%rbp),%rdi | |
5daf: e8 00 00 00 00 callq 5db4 <ZSTD_decompressBlock_internal+0xb14> | |
5db4: 4c 8b 54 24 18 mov 0x18(%rsp),%r10 | |
5db9: 44 8b 5c 24 20 mov 0x20(%rsp),%r11d | |
5dbe: eb ba jmp 5d7a <ZSTD_decompressBlock_internal+0xada> | |
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); | |
5dc0: 48 8d 7c 24 50 lea 0x50(%rsp),%rdi | |
5dc5: 48 8d 54 24 4c lea 0x4c(%rsp),%rdx | |
5dca: 48 89 d9 mov %rbx,%rcx | |
5dcd: 44 89 5c 24 3c mov %r11d,0x3c(%rsp) | |
5dd2: 48 8d 74 24 48 lea 0x48(%rsp),%rsi | |
5dd7: 44 89 4c 24 38 mov %r9d,0x38(%rsp) | |
5ddc: 44 89 54 24 20 mov %r10d,0x20(%rsp) | |
5de1: 48 89 7c 24 18 mov %rdi,0x18(%rsp) | |
5de6: e8 00 00 00 00 callq 5deb <ZSTD_decompressBlock_internal+0xb4b> | |
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, ""); | |
5deb: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi | |
5df0: 44 8b 54 24 20 mov 0x20(%rsp),%r10d | |
5df5: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
5df9: 44 8b 4c 24 38 mov 0x38(%rsp),%r9d | |
5dfe: 44 8b 5c 24 3c mov 0x3c(%rsp),%r11d | |
5e03: 0f 87 3f f5 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, ""); | |
5e09: 8b 54 24 4c mov 0x4c(%rsp),%edx | |
5e0d: 44 89 5c 24 38 mov %r11d,0x38(%rsp) | |
5e12: 48 89 44 24 20 mov %rax,0x20(%rsp) | |
5e17: 44 89 54 24 18 mov %r10d,0x18(%rsp) | |
5e1c: 83 fa 09 cmp $0x9,%edx | |
5e1f: 0f 87 23 f5 ff ff ja 5348 <ZSTD_decompressBlock_internal+0xa8> | |
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2); | |
5e25: 48 83 ec 08 sub $0x8,%rsp | |
5e29: 4c 8d 05 00 00 00 00 lea 0x0(%rip),%r8 # 5e30 <ZSTD_decompressBlock_internal+0xb90> | |
5e30: 48 8d 0d 00 00 00 00 lea 0x0(%rip),%rcx # 5e37 <ZSTD_decompressBlock_internal+0xb97> | |
5e37: 48 89 fe mov %rdi,%rsi | |
5e3a: 41 51 push %r9 | |
5e3c: 41 89 d1 mov %edx,%r9d | |
5e3f: 48 8d 7d 20 lea 0x20(%rbp),%rdi | |
5e43: 68 00 0a 00 00 pushq $0xa00 | |
5e48: ff 74 24 40 pushq 0x40(%rsp) | |
5e4c: 8b 54 24 68 mov 0x68(%rsp),%edx | |
5e50: e8 00 00 00 00 callq 5e55 <ZSTD_decompressBlock_internal+0xbb5> | |
*DTablePtr = DTableSpace; | |
5e55: 48 8d 45 20 lea 0x20(%rbp),%rax | |
ip, iend-ip, | |
5e59: 4d 89 e0 mov %r12,%r8 | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5e5c: 44 8b 8d d8 75 00 00 mov 0x75d8(%rbp),%r9d | |
*DTablePtr = DTableSpace; | |
5e63: 48 89 45 00 mov %rax,0x0(%rbp) | |
ip += llhSize; | |
5e67: 48 8b 44 24 40 mov 0x40(%rsp),%rax | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5e6c: 48 83 c4 20 add $0x20,%rsp | |
5e70: 8b 8d f4 75 00 00 mov 0x75f4(%rbp),%ecx | |
5e76: 44 8b 5c 24 38 mov 0x38(%rsp),%r11d | |
ip += llhSize; | |
5e7b: 48 01 c3 add %rax,%rbx | |
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, | |
5e7e: 44 8b 54 24 18 mov 0x18(%rsp),%r10d | |
5e83: 8b 85 2c 75 00 00 mov 0x752c(%rbp),%eax | |
ip, iend-ip, | |
5e89: 49 29 d8 sub %rbx,%r8 | |
5e8c: e9 a4 f7 ff ff jmpq 5635 <ZSTD_decompressBlock_internal+0x395> | |
U32 u, total = 0; | |
5e91: 31 c0 xor %eax,%eax | |
for (u=0; u<max; u++) { | |
5e93: 31 f6 xor %esi,%esi | |
5e95: e9 42 fa ff ff jmpq 58dc <ZSTD_decompressBlock_internal+0x63c> | |
5e9a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
0000000000005ea0 <ZSTD_checkContinuity>: | |
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize) | |
{ | |
if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */ | |
5ea0: 48 8b 87 c0 74 00 00 mov 0x74c0(%rdi),%rax | |
5ea7: 48 39 f0 cmp %rsi,%rax | |
5eaa: 74 30 je 5edc <ZSTD_checkContinuity+0x3c> | |
5eac: 48 85 d2 test %rdx,%rdx | |
5eaf: 74 2b je 5edc <ZSTD_checkContinuity+0x3c> | |
dctx->dictEnd = dctx->previousDstEnd; | |
5eb1: 48 89 87 d8 74 00 00 mov %rax,0x74d8(%rdi) | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5eb8: 48 89 f2 mov %rsi,%rdx | |
5ebb: 48 2b 87 c8 74 00 00 sub 0x74c8(%rdi),%rax | |
dctx->prefixStart = dst; | |
dctx->previousDstEnd = dst; | |
5ec2: 66 48 0f 6e c6 movq %rsi,%xmm0 | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5ec7: 48 29 c2 sub %rax,%rdx | |
dctx->previousDstEnd = dst; | |
5eca: 66 0f 6c c0 punpcklqdq %xmm0,%xmm0 | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5ece: 48 89 97 d0 74 00 00 mov %rdx,0x74d0(%rdi) | |
dctx->previousDstEnd = dst; | |
5ed5: 0f 11 87 c0 74 00 00 movups %xmm0,0x74c0(%rdi) | |
} | |
} | |
5edc: c3 retq | |
5edd: 0f 1f 00 nopl (%rax) | |
0000000000005ee0 <ZSTD_decompressBlock>: | |
size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, | |
void* dst, size_t dstCapacity, | |
const void* src, size_t srcSize) | |
{ | |
5ee0: 41 57 push %r15 | |
5ee2: 41 56 push %r14 | |
5ee4: 49 89 d6 mov %rdx,%r14 | |
5ee7: 41 55 push %r13 | |
5ee9: 49 89 cd mov %rcx,%r13 | |
5eec: 41 54 push %r12 | |
5eee: 4d 89 c4 mov %r8,%r12 | |
5ef1: 55 push %rbp | |
5ef2: 48 89 f5 mov %rsi,%rbp | |
5ef5: 53 push %rbx | |
5ef6: 48 89 fb mov %rdi,%rbx | |
5ef9: 48 83 ec 38 sub $0x38,%rsp | |
if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */ | |
5efd: 48 8b 87 c0 74 00 00 mov 0x74c0(%rdi),%rax | |
5f04: 48 85 d2 test %rdx,%rdx | |
5f07: 74 30 je 5f39 <ZSTD_decompressBlock+0x59> | |
5f09: 48 39 c6 cmp %rax,%rsi | |
5f0c: 74 2b je 5f39 <ZSTD_decompressBlock+0x59> | |
dctx->dictEnd = dctx->previousDstEnd; | |
5f0e: 48 89 87 d8 74 00 00 mov %rax,0x74d8(%rdi) | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5f15: 48 89 f2 mov %rsi,%rdx | |
5f18: 48 2b 87 c8 74 00 00 sub 0x74c8(%rdi),%rax | |
dctx->previousDstEnd = dst; | |
5f1f: 66 48 0f 6e c6 movq %rsi,%xmm0 | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5f24: 48 29 c2 sub %rax,%rdx | |
dctx->previousDstEnd = dst; | |
5f27: 66 0f 6c c0 punpcklqdq %xmm0,%xmm0 | |
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); | |
5f2b: 48 89 97 d0 74 00 00 mov %rdx,0x74d0(%rdi) | |
dctx->previousDstEnd = dst; | |
5f32: 0f 11 87 c0 74 00 00 movups %xmm0,0x74c0(%rdi) | |
RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong, ""); | |
5f39: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax | |
5f40: 49 81 fc ff ff 01 00 cmp $0x1ffff,%r12 | |
5f47: 77 7e ja 5fc7 <ZSTD_decompressBlock+0xe7> | |
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, ""); | |
5f49: 49 83 fc 02 cmp $0x2,%r12 | |
5f4d: 76 71 jbe 5fc0 <ZSTD_decompressBlock+0xe0> | |
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3); | |
5f4f: 41 0f b6 55 00 movzbl 0x0(%r13),%edx | |
5f54: 41 89 d7 mov %edx,%r15d | |
5f57: 41 83 e7 03 and $0x3,%r15d | |
switch(litEncType) | |
5f5b: 41 80 ff 02 cmp $0x2,%r15b | |
5f5f: 0f 84 8e 00 00 00 je 5ff3 <ZSTD_decompressBlock+0x113> | |
5f65: 41 80 ff 03 cmp $0x3,%r15b | |
5f69: 74 75 je 5fe0 <ZSTD_decompressBlock+0x100> | |
5f6b: 41 80 ff 01 cmp $0x1,%r15b | |
5f6f: 0f 84 a3 01 00 00 je 6118 <ZSTD_decompressBlock+0x238> | |
U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
5f75: 89 d0 mov %edx,%eax | |
5f77: c0 e8 02 shr $0x2,%al | |
5f7a: 83 e0 03 and $0x3,%eax | |
switch(lhlCode) | |
5f7d: 3c 01 cmp $0x1,%al | |
5f7f: 0f 84 f3 06 00 00 je 6678 <ZSTD_decompressBlock+0x798> | |
5f85: 3c 03 cmp $0x3,%al | |
5f87: 0f 84 03 07 00 00 je 6690 <ZSTD_decompressBlock+0x7b0> | |
litSize = istart[0] >> 3; | |
5f8d: c0 ea 03 shr $0x3,%dl | |
lhSize = 1; | |
5f90: b8 01 00 00 00 mov $0x1,%eax | |
litSize = istart[0] >> 3; | |
5f95: 44 0f b6 fa movzbl %dl,%r15d | |
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */ | |
5f99: 4d 8d 14 07 lea (%r15,%rax,1),%r10 | |
5f9d: 49 8d 52 20 lea 0x20(%r10),%rdx | |
5fa1: 49 39 d4 cmp %rdx,%r12 | |
5fa4: 0f 83 16 05 00 00 jae 64c0 <ZSTD_decompressBlock+0x5e0> | |
RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, ""); | |
5faa: 4d 39 d4 cmp %r10,%r12 | |
5fad: 4c 89 14 24 mov %r10,(%rsp) | |
5fb1: 0f 83 11 06 00 00 jae 65c8 <ZSTD_decompressBlock+0x6e8> | |
5fb7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
5fbe: 00 00 | |
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, ""); | |
5fc0: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax | |
size_t dSize; | |
ZSTD_checkContinuity(dctx, dst, dstCapacity); | |
dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0); | |
dctx->previousDstEnd = (char*)dst + dSize; | |
5fc7: 48 01 c5 add %rax,%rbp | |
5fca: 48 89 ab c0 74 00 00 mov %rbp,0x74c0(%rbx) | |
return dSize; | |
} | |
5fd1: 48 83 c4 38 add $0x38,%rsp | |
5fd5: 5b pop %rbx | |
5fd6: 5d pop %rbp | |
5fd7: 41 5c pop %r12 | |
5fd9: 41 5d pop %r13 | |
5fdb: 41 5e pop %r14 | |
5fdd: 41 5f pop %r15 | |
5fdf: c3 retq | |
RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, ""); | |
5fe0: 44 8b 8b 28 75 00 00 mov 0x7528(%rbx),%r9d | |
5fe7: 48 c7 c0 e2 ff ff ff mov $0xffffffffffffffe2,%rax | |
5fee: 45 85 c9 test %r9d,%r9d | |
5ff1: 74 d4 je 5fc7 <ZSTD_decompressBlock+0xe7> | |
RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3"); | |
5ff3: 49 83 fc 04 cmp $0x4,%r12 | |
5ff7: 76 c7 jbe 5fc0 <ZSTD_decompressBlock+0xe0> | |
MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; } | |
5ff9: 41 8b 4d 00 mov 0x0(%r13),%ecx | |
U32 const lhlCode = (istart[0] >> 2) & 3; | |
5ffd: c0 ea 02 shr $0x2,%dl | |
6000: 83 e2 03 and $0x3,%edx | |
litSize = (lhc >> 4) & 0x3FF; | |
6003: 41 89 cb mov %ecx,%r11d | |
6006: 41 c1 eb 04 shr $0x4,%r11d | |
600a: 80 fa 02 cmp $0x2,%dl | |
600d: 0f 84 1d 05 00 00 je 6530 <ZSTD_decompressBlock+0x650> | |
6013: 80 fa 03 cmp $0x3,%dl | |
6016: 0f 84 dc 04 00 00 je 64f8 <ZSTD_decompressBlock+0x618> | |
singleStream = !lhlCode; | |
601c: 83 f2 01 xor $0x1,%edx | |
litCSize = (lhc >> 14) & 0x3FF; | |
601f: c1 e9 0e shr $0xe,%ecx | |
lhSize = 3; | |
6022: bf 03 00 00 00 mov $0x3,%edi | |
litSize = (lhc >> 4) & 0x3FF; | |
6027: 41 81 e3 ff 03 00 00 and $0x3ff,%r11d | |
singleStream = !lhlCode; | |
602e: 0f b6 d2 movzbl %dl,%edx | |
litCSize = (lhc >> 14) & 0x3FF; | |
6031: 81 e1 ff 03 00 00 and $0x3ff,%ecx | |
RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, ""); | |
6037: 4c 8d 14 0f lea (%rdi,%rcx,1),%r10 | |
603b: 4d 39 d4 cmp %r10,%r12 | |
603e: 0f 82 7c ff ff ff jb 5fc0 <ZSTD_decompressBlock+0xe0> | |
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) { | |
6044: 44 8b 83 f4 75 00 00 mov 0x75f4(%rbx),%r8d | |
604b: 45 85 c0 test %r8d,%r8d | |
604e: 74 0d je 605d <ZSTD_decompressBlock+0x17d> | |
6050: 49 81 fb 00 03 00 00 cmp $0x300,%r11 | |
6057: 0f 87 aa 05 00 00 ja 6607 <ZSTD_decompressBlock+0x727> | |
dctx->litBuffer, litSize, istart+lhSize, litCSize, | |
605d: 49 8d 44 3d 00 lea 0x0(%r13,%rdi,1),%rax | |
6062: 48 8d bb 90 76 00 00 lea 0x7690(%rbx),%rdi | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
6069: 8b b3 d8 75 00 00 mov 0x75d8(%rbx),%esi | |
dctx->litBuffer, litSize, istart+lhSize, litCSize, | |
606f: 48 89 3c 24 mov %rdi,(%rsp) | |
if (litEncType==set_repeat) { | |
6073: 41 80 ff 03 cmp $0x3,%r15b | |
6077: 0f 84 63 06 00 00 je 66e0 <ZSTD_decompressBlock+0x800> | |
if (singleStream) { | |
607d: 4c 89 54 24 18 mov %r10,0x18(%rsp) | |
istart+lhSize, litCSize, dctx->workspace, | |
6082: 4c 8d 8b bc 6a 00 00 lea 0x6abc(%rbx),%r9 | |
dctx->entropy.hufTable, dctx->litBuffer, litSize, | |
6089: 48 8d bb 38 28 00 00 lea 0x2838(%rbx),%rdi | |
if (singleStream) { | |
6090: 85 d2 test %edx,%edx | |
6092: 0f 85 f0 04 00 00 jne 6588 <ZSTD_decompressBlock+0x6a8> | |
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2( | |
6098: 56 push %rsi | |
6099: 4c 89 da mov %r11,%rdx | |
609c: 49 89 c8 mov %rcx,%r8 | |
609f: 48 8d b3 90 76 00 00 lea 0x7690(%rbx),%rsi | |
60a6: 68 00 0a 00 00 pushq $0xa00 | |
60ab: 48 89 c1 mov %rax,%rcx | |
60ae: 48 89 7c 24 18 mov %rdi,0x18(%rsp) | |
60b3: 4c 89 5c 24 20 mov %r11,0x20(%rsp) | |
60b8: e8 00 00 00 00 callq 60bd <ZSTD_decompressBlock+0x1dd> | |
60bd: 41 5b pop %r11 | |
60bf: 5a pop %rdx | |
60c0: 4c 8b 54 24 18 mov 0x18(%rsp),%r10 | |
60c5: 4c 8b 5c 24 10 mov 0x10(%rsp),%r11 | |
60ca: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
60cf: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
60d3: 0f 87 e7 fe ff ff ja 5fc0 <ZSTD_decompressBlock+0xe0> | |
dctx->litPtr = dctx->litBuffer; | |
60d9: 48 8d 83 90 76 00 00 lea 0x7690(%rbx),%rax | |
dctx->litSize = litSize; | |
60e0: 4c 89 9b c0 75 00 00 mov %r11,0x75c0(%rbx) | |
dctx->litPtr = dctx->litBuffer; | |
60e7: 48 89 83 a0 75 00 00 mov %rax,0x75a0(%rbx) | |
dctx->litEntropy = 1; | |
60ee: c7 83 28 75 00 00 01 movl $0x1,0x7528(%rbx) | |
60f5: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
60f8: 41 80 ff 02 cmp $0x2,%r15b | |
60fc: 75 04 jne 6102 <ZSTD_decompressBlock+0x222> | |
60fe: 48 89 7b 18 mov %rdi,0x18(%rbx) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
6102: 4c 03 1c 24 add (%rsp),%r11 | |
6106: 66 0f ef c0 pxor %xmm0,%xmm0 | |
610a: 41 0f 11 03 movups %xmm0,(%r11) | |
610e: 41 0f 11 43 10 movups %xmm0,0x10(%r11) | |
return litCSize + lhSize; | |
6113: eb 5c jmp 6171 <ZSTD_decompressBlock+0x291> | |
6115: 0f 1f 00 nopl (%rax) | |
{ U32 const lhlCode = ((istart[0]) >> 2) & 3; | |
6118: 89 d0 mov %edx,%eax | |
611a: c0 e8 02 shr $0x2,%al | |
611d: 83 e0 03 and $0x3,%eax | |
switch(lhlCode) | |
6120: 3c 01 cmp $0x1,%al | |
6122: 0f 84 88 05 00 00 je 66b0 <ZSTD_decompressBlock+0x7d0> | |
6128: 3c 03 cmp $0x3,%al | |
612a: 0f 84 08 05 00 00 je 6638 <ZSTD_decompressBlock+0x758> | |
litSize = istart[0] >> 3; | |
6130: c0 ea 03 shr $0x3,%dl | |
break; | |
6133: 41 ba 02 00 00 00 mov $0x2,%r10d | |
lhSize = 1; | |
6139: b8 01 00 00 00 mov $0x1,%eax | |
litSize = istart[0] >> 3; | |
613e: 44 0f b6 fa movzbl %dl,%r15d | |
ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH); | |
6142: 48 8d 8b 90 76 00 00 lea 0x7690(%rbx),%rcx | |
6149: 41 0f b6 74 05 00 movzbl 0x0(%r13,%rax,1),%esi | |
614f: 49 8d 57 20 lea 0x20(%r15),%rdx | |
6153: 4c 89 14 24 mov %r10,(%rsp) | |
6157: 48 89 cf mov %rcx,%rdi | |
615a: e8 00 00 00 00 callq 615f <ZSTD_decompressBlock+0x27f> | |
dctx->litSize = litSize; | |
615f: 4c 89 bb c0 75 00 00 mov %r15,0x75c0(%rbx) | |
return lhSize+1; | |
6166: 4c 8b 14 24 mov (%rsp),%r10 | |
dctx->litPtr = dctx->litBuffer; | |
616a: 48 89 83 a0 75 00 00 mov %rax,0x75a0(%rbx) | |
ip += litCSize; | |
6171: 4d 01 d5 add %r10,%r13 | |
srcSize -= litCSize; | |
6174: 4d 29 d4 sub %r10,%r12 | |
size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize); | |
6177: 48 8d 74 24 2c lea 0x2c(%rsp),%rsi | |
617c: 48 89 df mov %rbx,%rdi | |
617f: 4c 89 e1 mov %r12,%rcx | |
6182: 4c 89 ea mov %r13,%rdx | |
int usePrefetchDecoder = dctx->ddictIsCold; | |
6185: 44 8b bb f4 75 00 00 mov 0x75f4(%rbx),%r15d | |
size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize); | |
618c: e8 00 00 00 00 callq 6191 <ZSTD_decompressBlock+0x2b1> | |
if (ZSTD_isError(seqHSize)) return seqHSize; | |
6191: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
6195: 0f 87 2c fe ff ff ja 5fc7 <ZSTD_decompressBlock+0xe7> | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
619b: 44 8b 4c 24 2c mov 0x2c(%rsp),%r9d | |
ip += seqHSize; | |
61a0: 49 01 c5 add %rax,%r13 | |
srcSize -= seqHSize; | |
61a3: 49 29 c4 sub %rax,%r12 | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
61a6: 48 85 ed test %rbp,%rbp | |
61a9: 0f 84 31 03 00 00 je 64e0 <ZSTD_decompressBlock+0x600> | |
if ( !usePrefetchDecoder | |
61af: 45 85 ff test %r15d,%r15d | |
61b2: 74 3c je 61f0 <ZSTD_decompressBlock+0x310> | |
dctx->ddictIsCold = 0; | |
61b4: c7 83 f4 75 00 00 00 movl $0x0,0x75f4(%rbx) | |
61bb: 00 00 00 | |
if (dctx->bmi2) { | |
61be: 44 8b 93 d8 75 00 00 mov 0x75d8(%rbx),%r10d | |
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
61c5: 4d 89 e0 mov %r12,%r8 | |
61c8: 4c 89 e9 mov %r13,%rcx | |
61cb: 4c 89 f2 mov %r14,%rdx | |
61ce: 48 89 ee mov %rbp,%rsi | |
61d1: 48 89 df mov %rbx,%rdi | |
if (dctx->bmi2) { | |
61d4: 45 85 d2 test %r10d,%r10d | |
61d7: 0f 85 4c 04 00 00 jne 6629 <ZSTD_decompressBlock+0x749> | |
return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
61dd: e8 de a8 ff ff callq ac0 <ZSTD_decompressSequencesLong_default.constprop.0> | |
61e2: e9 e0 fd ff ff jmpq 5fc7 <ZSTD_decompressBlock+0xe7> | |
61e7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1) | |
61ee: 00 00 | |
&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */ | |
61f0: 41 83 f9 08 cmp $0x8,%r9d | |
61f4: 0f 8e 56 03 00 00 jle 6550 <ZSTD_decompressBlock+0x670> | |
U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr); | |
61fa: 48 8b 73 10 mov 0x10(%rbx),%rsi | |
U32 const max = 1 << tableLog; | |
61fe: 41 b8 01 00 00 00 mov $0x1,%r8d | |
U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog; | |
6204: 8b 4e 04 mov 0x4(%rsi),%ecx | |
U32 const max = 1 << tableLog; | |
6207: 41 d3 e0 shl %cl,%r8d | |
for (u=0; u<max; u++) { | |
620a: 45 85 c0 test %r8d,%r8d | |
620d: 0f 84 3d 03 00 00 je 6550 <ZSTD_decompressBlock+0x670> | |
6213: 41 8d 50 ff lea -0x1(%r8),%edx | |
6217: 83 fa 0f cmp $0xf,%edx | |
621a: 0f 86 30 05 00 00 jbe 6750 <ZSTD_decompressBlock+0x870> | |
6220: 89 d7 mov %edx,%edi | |
6222: 48 8d 46 0a lea 0xa(%rsi),%rax | |
6226: 66 0f ef d2 pxor %xmm2,%xmm2 | |
622a: 66 0f 6f 0d 00 00 00 movdqa 0x0(%rip),%xmm1 # 6232 <ZSTD_decompressBlock+0x352> | |
6231: 00 | |
6232: c1 ef 04 shr $0x4,%edi | |
6235: 66 0f 6f 35 00 00 00 movdqa 0x0(%rip),%xmm6 # 623d <ZSTD_decompressBlock+0x35d> | |
623c: 00 | |
623d: 66 0f ef e4 pxor %xmm4,%xmm4 | |
6241: 66 0f ef db pxor %xmm3,%xmm3 | |
6245: 83 ef 01 sub $0x1,%edi | |
6248: 66 0f 6f 2d 00 00 00 movdqa 0x0(%rip),%xmm5 # 6250 <ZSTD_decompressBlock+0x370> | |
624f: 00 | |
6250: 48 c1 e7 07 shl $0x7,%rdi | |
6254: 48 8d bc 3e 8a 00 00 lea 0x8a(%rsi,%rdi,1),%rdi | |
625b: 00 | |
625c: 0f 1f 40 00 nopl 0x0(%rax) | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6260: f3 0f 6f 00 movdqu (%rax),%xmm0 | |
6264: f3 0f 6f 78 10 movdqu 0x10(%rax),%xmm7 | |
6269: 48 83 e8 80 sub $0xffffffffffffff80,%rax | |
626d: f3 44 0f 6f 40 b0 movdqu -0x50(%rax),%xmm8 | |
6273: f3 44 0f 6f 48 f0 movdqu -0x10(%rax),%xmm9 | |
6279: 66 0f db f9 pand %xmm1,%xmm7 | |
627d: 66 0f db c1 pand %xmm1,%xmm0 | |
6281: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
6285: f3 0f 6f 78 a0 movdqu -0x60(%rax),%xmm7 | |
628a: 66 44 0f db c1 pand %xmm1,%xmm8 | |
628f: 66 44 0f db c9 pand %xmm1,%xmm9 | |
6294: 66 0f db c1 pand %xmm1,%xmm0 | |
6298: 66 0f db f9 pand %xmm1,%xmm7 | |
629c: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
62a1: f3 44 0f 6f 40 d0 movdqu -0x30(%rax),%xmm8 | |
62a7: 66 0f db f9 pand %xmm1,%xmm7 | |
62ab: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
62af: f3 0f 6f 78 c0 movdqu -0x40(%rax),%xmm7 | |
62b4: 66 44 0f db c1 pand %xmm1,%xmm8 | |
62b9: 66 0f db c1 pand %xmm1,%xmm0 | |
62bd: 66 0f db f9 pand %xmm1,%xmm7 | |
62c1: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
62c6: f3 44 0f 6f 40 e0 movdqu -0x20(%rax),%xmm8 | |
62cc: 66 0f db f9 pand %xmm1,%xmm7 | |
62d0: 66 44 0f db c1 pand %xmm1,%xmm8 | |
62d5: 66 45 0f 67 c1 packuswb %xmm9,%xmm8 | |
62da: 66 44 0f db c1 pand %xmm1,%xmm8 | |
62df: 66 41 0f 67 f8 packuswb %xmm8,%xmm7 | |
62e4: 66 0f db f9 pand %xmm1,%xmm7 | |
62e8: 66 0f 67 c7 packuswb %xmm7,%xmm0 | |
62ec: 66 0f d8 c6 psubusb %xmm6,%xmm0 | |
62f0: 66 0f 74 c4 pcmpeqb %xmm4,%xmm0 | |
62f4: 66 0f df c5 pandn %xmm5,%xmm0 | |
62f8: 66 0f 6f f8 movdqa %xmm0,%xmm7 | |
62fc: 66 0f 68 c4 punpckhbw %xmm4,%xmm0 | |
6300: 66 44 0f 6f c0 movdqa %xmm0,%xmm8 | |
6305: 66 0f 60 fc punpcklbw %xmm4,%xmm7 | |
6309: 66 0f 69 c3 punpckhwd %xmm3,%xmm0 | |
630d: 66 44 0f 61 c3 punpcklwd %xmm3,%xmm8 | |
6312: 66 41 0f fe c0 paddd %xmm8,%xmm0 | |
6317: 66 44 0f 6f c7 movdqa %xmm7,%xmm8 | |
631c: 66 0f 69 fb punpckhwd %xmm3,%xmm7 | |
6320: 66 44 0f 61 c3 punpcklwd %xmm3,%xmm8 | |
6325: 66 41 0f fe f8 paddd %xmm8,%xmm7 | |
632a: 66 0f fe c7 paddd %xmm7,%xmm0 | |
632e: 66 0f fe d0 paddd %xmm0,%xmm2 | |
for (u=0; u<max; u++) { | |
6332: 48 39 f8 cmp %rdi,%rax | |
6335: 0f 85 25 ff ff ff jne 6260 <ZSTD_decompressBlock+0x380> | |
633b: 66 0f 6f c2 movdqa %xmm2,%xmm0 | |
633f: 83 e2 f0 and $0xfffffff0,%edx | |
6342: 66 0f 73 d8 08 psrldq $0x8,%xmm0 | |
6347: 66 0f fe d0 paddd %xmm0,%xmm2 | |
634b: 66 0f 6f c2 movdqa %xmm2,%xmm0 | |
634f: 66 0f 73 d8 04 psrldq $0x4,%xmm0 | |
6354: 66 0f fe d0 paddd %xmm0,%xmm2 | |
6358: 66 0f 7e d0 movd %xmm2,%eax | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
635c: 44 8d 52 01 lea 0x1(%rdx),%r10d | |
6360: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6366: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6369: 45 39 d0 cmp %r10d,%r8d | |
636c: 0f 86 26 01 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6372: 44 8d 52 02 lea 0x2(%rdx),%r10d | |
6376: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
637c: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
637f: 45 39 d0 cmp %r10d,%r8d | |
6382: 0f 86 10 01 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6388: 44 8d 52 03 lea 0x3(%rdx),%r10d | |
638c: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6392: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6395: 45 39 d0 cmp %r10d,%r8d | |
6398: 0f 86 fa 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
639e: 44 8d 52 04 lea 0x4(%rdx),%r10d | |
63a2: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
63a8: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
63ab: 45 39 d0 cmp %r10d,%r8d | |
63ae: 0f 86 e4 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
63b4: 44 8d 52 05 lea 0x5(%rdx),%r10d | |
63b8: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
63be: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
63c1: 45 39 d0 cmp %r10d,%r8d | |
63c4: 0f 86 ce 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
63ca: 44 8d 52 06 lea 0x6(%rdx),%r10d | |
63ce: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
63d4: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
63d7: 45 39 d0 cmp %r10d,%r8d | |
63da: 0f 86 b8 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
63e0: 44 8d 52 07 lea 0x7(%rdx),%r10d | |
63e4: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
63ea: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
63ed: 45 39 d0 cmp %r10d,%r8d | |
63f0: 0f 86 a2 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
63f6: 44 8d 52 08 lea 0x8(%rdx),%r10d | |
63fa: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6400: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6403: 45 39 d0 cmp %r10d,%r8d | |
6406: 0f 86 8c 00 00 00 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
640c: 44 8d 52 09 lea 0x9(%rdx),%r10d | |
6410: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6416: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6419: 45 39 d0 cmp %r10d,%r8d | |
641c: 76 7a jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
641e: 44 8d 52 0a lea 0xa(%rdx),%r10d | |
6422: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6428: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
642b: 45 39 d0 cmp %r10d,%r8d | |
642e: 76 68 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6430: 44 8d 52 0b lea 0xb(%rdx),%r10d | |
6434: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
643a: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
643d: 45 39 d0 cmp %r10d,%r8d | |
6440: 76 56 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6442: 44 8d 52 0c lea 0xc(%rdx),%r10d | |
6446: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
644c: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
644f: 45 39 d0 cmp %r10d,%r8d | |
6452: 76 44 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6454: 44 8d 52 0d lea 0xd(%rdx),%r10d | |
6458: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
645e: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6461: 45 39 d0 cmp %r10d,%r8d | |
6464: 76 32 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6466: 44 8d 52 0e lea 0xe(%rdx),%r10d | |
646a: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6470: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6473: 45 39 d0 cmp %r10d,%r8d | |
6476: 76 20 jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
6478: 44 8d 52 0f lea 0xf(%rdx),%r10d | |
647c: 42 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%r10,8) | |
6482: 83 d8 ff sbb $0xffffffff,%eax | |
for (u=0; u<max; u++) { | |
6485: 45 39 d0 cmp %r10d,%r8d | |
6488: 76 0e jbe 6498 <ZSTD_decompressBlock+0x5b8> | |
if (table[u].nbAdditionalBits > 22) total += 1; | |
648a: 83 c2 10 add $0x10,%edx | |
648d: 80 7c d6 02 17 cmpb $0x17,0x2(%rsi,%rdx,8) | |
6492: 83 d8 ff sbb $0xffffffff,%eax | |
6495: 0f 1f 00 nopl (%rax) | |
dctx->ddictIsCold = 0; | |
6498: c7 83 f4 75 00 00 00 movl $0x0,0x75f4(%rbx) | |
649f: 00 00 00 | |
total <<= (OffFSELog - tableLog); /* scale to OffFSELog */ | |
64a2: ba 08 00 00 00 mov $0x8,%edx | |
64a7: 29 ca sub %ecx,%edx | |
64a9: 89 d1 mov %edx,%ecx | |
64ab: d3 e0 shl %cl,%eax | |
if (usePrefetchDecoder) | |
64ad: 83 f8 06 cmp $0x6,%eax | |
64b0: 0f 86 a4 00 00 00 jbe 655a <ZSTD_decompressBlock+0x67a> | |
64b6: e9 03 fd ff ff jmpq 61be <ZSTD_decompressBlock+0x2de> | |
64bb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
dctx->litPtr = istart+lhSize; | |
64c0: 4c 01 e8 add %r13,%rax | |
dctx->litSize = litSize; | |
64c3: 4c 89 bb c0 75 00 00 mov %r15,0x75c0(%rbx) | |
dctx->litPtr = istart+lhSize; | |
64ca: 48 89 83 a0 75 00 00 mov %rax,0x75a0(%rbx) | |
return lhSize+litSize; | |
64d1: e9 9b fc ff ff jmpq 6171 <ZSTD_decompressBlock+0x291> | |
64d6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
64dd: 00 00 00 | |
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled"); | |
64e0: 48 c7 c0 ba ff ff ff mov $0xffffffffffffffba,%rax | |
64e7: 45 85 c9 test %r9d,%r9d | |
64ea: 0f 8e bf fc ff ff jle 61af <ZSTD_decompressBlock+0x2cf> | |
64f0: e9 d2 fa ff ff jmpq 5fc7 <ZSTD_decompressBlock+0xe7> | |
64f5: 0f 1f 00 nopl (%rax) | |
litSize = (lhc >> 4) & 0x3FFFF; | |
64f8: 44 89 d8 mov %r11d,%eax | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
64fb: 41 0f b6 55 04 movzbl 0x4(%r13),%edx | |
6500: 25 ff ff 03 00 and $0x3ffff,%eax | |
litSize = (lhc >> 4) & 0x3FFFF; | |
6505: 41 89 c3 mov %eax,%r11d | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
6508: 3d 00 00 02 00 cmp $0x20000,%eax | |
650d: 0f 87 ad fa ff ff ja 5fc0 <ZSTD_decompressBlock+0xe0> | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
6513: c1 e9 16 shr $0x16,%ecx | |
lhSize = 5; | |
6516: bf 05 00 00 00 mov $0x5,%edi | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
651b: 89 c8 mov %ecx,%eax | |
651d: 0f b6 ca movzbl %dl,%ecx | |
U32 singleStream=0; | |
6520: 31 d2 xor %edx,%edx | |
litCSize = (lhc >> 22) + ((size_t)istart[4] << 10); | |
6522: 48 c1 e1 0a shl $0xa,%rcx | |
6526: 48 01 c1 add %rax,%rcx | |
6529: e9 09 fb ff ff jmpq 6037 <ZSTD_decompressBlock+0x157> | |
652e: 66 90 xchg %ax,%ax | |
litSize = (lhc >> 4) & 0x3FFF; | |
6530: 41 81 e3 ff 3f 00 00 and $0x3fff,%r11d | |
litCSize = lhc >> 18; | |
6537: c1 e9 12 shr $0x12,%ecx | |
U32 singleStream=0; | |
653a: 31 d2 xor %edx,%edx | |
lhSize = 4; | |
653c: bf 04 00 00 00 mov $0x4,%edi | |
break; | |
6541: e9 f1 fa ff ff jmpq 6037 <ZSTD_decompressBlock+0x157> | |
6546: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) | |
654d: 00 00 00 | |
dctx->ddictIsCold = 0; | |
6550: c7 83 f4 75 00 00 00 movl $0x0,0x75f4(%rbx) | |
6557: 00 00 00 | |
if (dctx->bmi2) { | |
655a: 8b 83 d8 75 00 00 mov 0x75d8(%rbx),%eax | |
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
6560: 4d 89 e0 mov %r12,%r8 | |
6563: 4c 89 e9 mov %r13,%rcx | |
6566: 4c 89 f2 mov %r14,%rdx | |
6569: 48 89 ee mov %rbp,%rsi | |
656c: 48 89 df mov %rbx,%rdi | |
if (dctx->bmi2) { | |
656f: 85 c0 test %eax,%eax | |
6571: 0f 85 59 01 00 00 jne 66d0 <ZSTD_decompressBlock+0x7f0> | |
return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
6577: e8 64 c2 ff ff callq 27e0 <ZSTD_decompressSequences_default.constprop.0> | |
657c: e9 46 fa ff ff jmpq 5fc7 <ZSTD_decompressBlock+0xe7> | |
6581: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) | |
hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2( | |
6588: 56 push %rsi | |
6589: 49 89 c8 mov %rcx,%r8 | |
658c: 4c 89 da mov %r11,%rdx | |
658f: 48 89 c1 mov %rax,%rcx | |
6592: 68 00 0a 00 00 pushq $0xa00 | |
6597: 48 8d b3 90 76 00 00 lea 0x7690(%rbx),%rsi | |
659e: 4c 89 5c 24 20 mov %r11,0x20(%rsp) | |
65a3: 48 89 7c 24 18 mov %rdi,0x18(%rsp) | |
65a8: e8 00 00 00 00 callq 65ad <ZSTD_decompressBlock+0x6cd> | |
65ad: 59 pop %rcx | |
65ae: 5e pop %rsi | |
65af: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi | |
65b4: 4c 8b 5c 24 10 mov 0x10(%rsp),%r11 | |
65b9: 4c 8b 54 24 18 mov 0x18(%rsp),%r10 | |
65be: e9 0c fb ff ff jmpq 60cf <ZSTD_decompressBlock+0x1ef> | |
65c3: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
65c8: 48 8d 8b 90 76 00 00 lea 0x7690(%rbx),%rcx | |
65cf: 49 8d 74 05 00 lea 0x0(%r13,%rax,1),%rsi | |
65d4: 4c 89 fa mov %r15,%rdx | |
65d7: 48 89 cf mov %rcx,%rdi | |
65da: e8 00 00 00 00 callq 65df <ZSTD_decompressBlock+0x6ff> | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
65df: 66 0f ef c0 pxor %xmm0,%xmm0 | |
dctx->litSize = litSize; | |
65e3: 4c 89 bb c0 75 00 00 mov %r15,0x75c0(%rbx) | |
return lhSize+litSize; | |
65ea: 4c 8b 14 24 mov (%rsp),%r10 | |
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize); | |
65ee: 48 89 c1 mov %rax,%rcx | |
dctx->litPtr = dctx->litBuffer; | |
65f1: 48 89 83 a0 75 00 00 mov %rax,0x75a0(%rbx) | |
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH); | |
65f8: 4c 01 f9 add %r15,%rcx | |
65fb: 0f 11 01 movups %xmm0,(%rcx) | |
65fe: 0f 11 41 10 movups %xmm0,0x10(%rcx) | |
return lhSize+litSize; | |
6602: e9 6a fb ff ff jmpq 6171 <ZSTD_decompressBlock+0x291> | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
6607: 48 8b 43 18 mov 0x18(%rbx),%rax | |
660b: 48 8d b0 40 40 00 00 lea 0x4040(%rax),%rsi | |
6612: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
6618: 0f 18 10 prefetcht1 (%rax) | |
661b: 48 83 c0 40 add $0x40,%rax | |
661f: 48 39 f0 cmp %rsi,%rax | |
6622: 75 f4 jne 6618 <ZSTD_decompressBlock+0x738> | |
6624: e9 34 fa ff ff jmpq 605d <ZSTD_decompressBlock+0x17d> | |
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
6629: e8 d2 cb ff ff callq 3200 <ZSTD_decompressSequencesLong_bmi2.constprop.0> | |
662e: e9 94 f9 ff ff jmpq 5fc7 <ZSTD_decompressBlock+0xe7> | |
6633: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16); | |
6638: 45 0f b6 7d 02 movzbl 0x2(%r13),%r15d | |
663d: 41 0f b7 45 00 movzwl 0x0(%r13),%eax | |
6642: 41 c1 e7 10 shl $0x10,%r15d | |
6646: 41 01 c7 add %eax,%r15d | |
litSize = MEM_readLE24(istart) >> 4; | |
6649: 41 c1 ef 04 shr $0x4,%r15d | |
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, ""); | |
664d: 49 83 fc 03 cmp $0x3,%r12 | |
6651: 0f 84 69 f9 ff ff je 5fc0 <ZSTD_decompressBlock+0xe0> | |
6657: 49 81 ff 00 00 02 00 cmp $0x20000,%r15 | |
665e: 0f 87 5c f9 ff ff ja 5fc0 <ZSTD_decompressBlock+0xe0> | |
6664: 41 ba 04 00 00 00 mov $0x4,%r10d | |
lhSize = 3; | |
666a: b8 03 00 00 00 mov $0x3,%eax | |
666f: e9 ce fa ff ff jmpq 6142 <ZSTD_decompressBlock+0x262> | |
6674: 0f 1f 40 00 nopl 0x0(%rax) | |
litSize = MEM_readLE16(istart) >> 4; | |
6678: 45 0f b7 7d 00 movzwl 0x0(%r13),%r15d | |
lhSize = 2; | |
667d: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
6682: 66 41 c1 ef 04 shr $0x4,%r15w | |
6687: 45 0f b7 ff movzwl %r15w,%r15d | |
break; | |
668b: e9 09 f9 ff ff jmpq 5f99 <ZSTD_decompressBlock+0xb9> | |
6690: 45 0f b6 7d 02 movzbl 0x2(%r13),%r15d | |
6695: 41 0f b7 45 00 movzwl 0x0(%r13),%eax | |
669a: 41 c1 e7 10 shl $0x10,%r15d | |
669e: 41 01 c7 add %eax,%r15d | |
lhSize = 3; | |
66a1: b8 03 00 00 00 mov $0x3,%eax | |
litSize = MEM_readLE24(istart) >> 4; | |
66a6: 41 c1 ef 04 shr $0x4,%r15d | |
break; | |
66aa: e9 ea f8 ff ff jmpq 5f99 <ZSTD_decompressBlock+0xb9> | |
66af: 90 nop | |
litSize = MEM_readLE16(istart) >> 4; | |
66b0: 45 0f b7 7d 00 movzwl 0x0(%r13),%r15d | |
break; | |
66b5: 41 ba 03 00 00 00 mov $0x3,%r10d | |
lhSize = 2; | |
66bb: b8 02 00 00 00 mov $0x2,%eax | |
litSize = MEM_readLE16(istart) >> 4; | |
66c0: 66 41 c1 ef 04 shr $0x4,%r15w | |
66c5: 45 0f b7 ff movzwl %r15w,%r15d | |
break; | |
66c9: e9 74 fa ff ff jmpq 6142 <ZSTD_decompressBlock+0x262> | |
66ce: 66 90 xchg %ax,%ax | |
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame); | |
66d0: e8 ab b7 ff ff callq 1e80 <ZSTD_decompressSequences_bmi2.constprop.0> | |
66d5: e9 ed f8 ff ff jmpq 5fc7 <ZSTD_decompressBlock+0xe7> | |
66da: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1) | |
if (singleStream) { | |
66e0: 85 d2 test %edx,%edx | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
66e2: 41 89 f1 mov %esi,%r9d | |
66e5: 4c 89 54 24 10 mov %r10,0x10(%rsp) | |
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); | |
66ea: 4c 8b 43 18 mov 0x18(%rbx),%r8 | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
66ee: 4c 89 5c 24 08 mov %r11,0x8(%rsp) | |
66f3: 48 89 c2 mov %rax,%rdx | |
66f6: 4c 89 de mov %r11,%rsi | |
if (singleStream) { | |
66f9: 74 3d je 6738 <ZSTD_decompressBlock+0x858> | |
hufSuccess = HUF_decompress1X_usingDTable_bmi2( | |
66fb: e8 00 00 00 00 callq 6700 <ZSTD_decompressBlock+0x820> | |
6700: 4c 8b 5c 24 08 mov 0x8(%rsp),%r11 | |
6705: 4c 8b 54 24 10 mov 0x10(%rsp),%r10 | |
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, ""); | |
670a: 48 83 f8 88 cmp $0xffffffffffffff88,%rax | |
670e: 0f 87 ac f8 ff ff ja 5fc0 <ZSTD_decompressBlock+0xe0> | |
dctx->litPtr = dctx->litBuffer; | |
6714: 48 8d 83 90 76 00 00 lea 0x7690(%rbx),%rax | |
dctx->litSize = litSize; | |
671b: 4c 89 9b c0 75 00 00 mov %r11,0x75c0(%rbx) | |
dctx->litPtr = dctx->litBuffer; | |
6722: 48 89 83 a0 75 00 00 mov %rax,0x75a0(%rbx) | |
dctx->litEntropy = 1; | |
6729: c7 83 28 75 00 00 01 movl $0x1,0x7528(%rbx) | |
6730: 00 00 00 | |
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; | |
6733: e9 ca f9 ff ff jmpq 6102 <ZSTD_decompressBlock+0x222> | |
hufSuccess = HUF_decompress4X_usingDTable_bmi2( | |
6738: 48 8d bb 90 76 00 00 lea 0x7690(%rbx),%rdi | |
673f: e8 00 00 00 00 callq 6744 <ZSTD_decompressBlock+0x864> | |
6744: 4c 8b 5c 24 08 mov 0x8(%rsp),%r11 | |
6749: 4c 8b 54 24 10 mov 0x10(%rsp),%r10 | |
674e: eb ba jmp 670a <ZSTD_decompressBlock+0x82a> | |
U32 u, total = 0; | |
6750: 31 c0 xor %eax,%eax | |
for (u=0; u<max; u++) { | |
6752: 31 d2 xor %edx,%edx | |
6754: e9 03 fc ff ff jmpq 635c <ZSTD_decompressBlock+0x47c> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment