Skip to content

Instantly share code, notes, and snippets.

@danlark1

danlark1/gcc.obj

Created May 29, 2021 17:49
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save danlark1/df57a5a15d5ef04dadefb850c2eb79fb to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save danlark1/df57a5a15d5ef04dadefb850c2eb79fb to your computer and use it in GitHub Desktop.
Download ZIP
gcc_objdump
Raw
gcc.obj
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