Skip to content

Instantly share code, notes, and snippets.

@danlark1

danlark1/clang.obj

Created May 29, 2021 17:51
Show Gist options

  • Select an option

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

Select an option

Learn more about clone URLs
Save danlark1/62390556e36f6c1cb227734034cfcf33 to your computer and use it in GitHub Desktop.
Download ZIP
clang_objdump
Raw
clang.obj
zstd_clang.o: file format elf64-x86-64
Disassembly of section .text:
0000000000000000 <ZSTD_getcBlockSize>:
/*! ZSTD_getcBlockSize() :
* Provides the size of compressed block from block header `src` */
size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
blockProperties_t* bpPtr)
{
0: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax
RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, "");
7: 48 83 fe 03 cmp $0x3,%rsi
b: 72 35 jb 42 <ZSTD_getcBlockSize+0x42>
typedef struct { U32 v; } __attribute__((packed)) unalign32;
typedef struct { U64 v; } __attribute__((packed)) unalign64;
typedef struct { size_t v; } __attribute__((packed)) unalignArch;
#endif
MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
d: 0f b7 0f movzwl (%rdi),%ecx
}
}
MEM_STATIC U32 MEM_readLE24(const void* memPtr)
{
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);
10: 0f b6 47 02 movzbl 0x2(%rdi),%eax
14: 48 c1 e0 10 shl $0x10,%rax
18: 48 09 c8 or %rcx,%rax
{ U32 const cBlockHeader = MEM_readLE24(src);
U32 const cSize = cBlockHeader >> 3;
1b: 48 c1 e8 03 shr $0x3,%rax
bpPtr->lastBlock = cBlockHeader & 1;
1f: 89 ce mov %ecx,%esi
21: 83 e6 01 and $0x1,%esi
24: 89 72 04 mov %esi,0x4(%rdx)
bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
27: d1 e9 shr %ecx
29: 83 e1 03 and $0x3,%ecx
2c: 89 0a mov %ecx,(%rdx)
bpPtr->origSize = cSize; /* only useful for RLE */
2e: 89 42 08 mov %eax,0x8(%rdx)
if (bpPtr->blockType == bt_rle) return 1;
31: 83 f9 01 cmp $0x1,%ecx
34: 74 0d je 43 <ZSTD_getcBlockSize+0x43>
36: 83 f9 03 cmp $0x3,%ecx
39: 75 07 jne 42 <ZSTD_getcBlockSize+0x42>
3b: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax
RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, "");
return cSize;
}
}
42: c3 retq
43: b8 01 00 00 00 mov $0x1,%eax
48: c3 retq
49: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
50: 00 00 00
53: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a: 00 00 00
5d: 0f 1f 00 nopl (%rax)
0000000000000060 <ZSTD_decodeLiteralsBlock>:
/*! ZSTD_decodeLiteralsBlock() :
* @return : nb of bytes read from src (< srcSize )
* note : symbol not declared but exposed for fullbench */
size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
const void* src, size_t srcSize) /* note : srcSize < BLOCKSIZE */
{
60: 55 push %rbp
61: 41 57 push %r15
63: 41 56 push %r14
65: 41 55 push %r13
67: 41 54 push %r12
69: 53 push %rbx
6a: 50 push %rax
6b: 49 c7 c7 ec ff ff ff mov $0xffffffffffffffec,%r15
DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");
72: 48 83 fa 03 cmp $0x3,%rdx
76: 73 12 jae 8a <ZSTD_decodeLiteralsBlock+0x2a>
}
default:
RETURN_ERROR(corruption_detected, "impossible");
}
}
}
78: 4c 89 f8 mov %r15,%rax
7b: 48 83 c4 08 add $0x8,%rsp
7f: 5b pop %rbx
80: 41 5c pop %r12
82: 41 5d pop %r13
84: 41 5e pop %r14
86: 41 5f pop %r15
88: 5d pop %rbp
89: c3 retq
8a: 48 89 f1 mov %rsi,%rcx
8d: 49 89 fe mov %rdi,%r14
symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
90: 0f b6 1e movzbl (%rsi),%ebx
93: 41 89 dc mov %ebx,%r12d
96: 41 83 e4 03 and $0x3,%r12d
9a: 42 ff 24 e5 00 00 00 jmpq *0x0(,%r12,8)
a1: 00
U32 const lhlCode = ((istart[0]) >> 2) & 3;
a2: 89 d8 mov %ebx,%eax
a4: c1 e8 02 shr $0x2,%eax
a7: 83 e0 03 and $0x3,%eax
switch(lhlCode)
aa: 83 f8 01 cmp $0x1,%eax
ad: 0f 84 3a 01 00 00 je 1ed <ZSTD_decodeLiteralsBlock+0x18d>
b3: 83 f8 03 cmp $0x3,%eax
b6: 0f 85 54 01 00 00 jne 210 <ZSTD_decodeLiteralsBlock+0x1b0>
MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
bc: 0f b7 01 movzwl (%rcx),%eax
return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);
bf: 0f b6 59 02 movzbl 0x2(%rcx),%ebx
c3: 48 c1 e3 10 shl $0x10,%rbx
c7: 48 09 c3 or %rax,%rbx
litSize = MEM_readLE24(istart) >> 4;
ca: 48 c1 eb 04 shr $0x4,%rbx
ce: b8 03 00 00 00 mov $0x3,%eax
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
d3: 48 8d 2c 18 lea (%rax,%rbx,1),%rbp
d7: 48 8d 34 18 lea (%rax,%rbx,1),%rsi
db: 48 83 c6 20 add $0x20,%rsi
df: 48 39 d6 cmp %rdx,%rsi
e2: 0f 86 46 01 00 00 jbe 22e <ZSTD_decodeLiteralsBlock+0x1ce>
RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, "");
e8: 48 39 d5 cmp %rdx,%rbp
eb: 77 8b ja 78 <ZSTD_decodeLiteralsBlock+0x18>
ZSTD_memcpy(dctx->litBuffer, istart+lhSize, litSize);
ed: 4d 8d be 90 76 00 00 lea 0x7690(%r14),%r15
f4: 48 01 c1 add %rax,%rcx
f7: 4c 89 ff mov %r15,%rdi
fa: 48 89 ce mov %rcx,%rsi
fd: 48 89 da mov %rbx,%rdx
100: e8 00 00 00 00 callq 105 <ZSTD_decodeLiteralsBlock+0xa5>
dctx->litPtr = dctx->litBuffer;
105: 4d 89 be a0 75 00 00 mov %r15,0x75a0(%r14)
dctx->litSize = litSize;
10c: 49 89 9e c0 75 00 00 mov %rbx,0x75c0(%r14)
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
113: 0f 57 c0 xorps %xmm0,%xmm0
116: 41 0f 11 84 1e 90 76 movups %xmm0,0x7690(%r14,%rbx,1)
11d: 00 00
11f: 41 0f 11 84 1e a0 76 movups %xmm0,0x76a0(%r14,%rbx,1)
126: 00 00
128: 49 89 ef mov %rbp,%r15
12b: e9 48 ff ff ff jmpq 78 <ZSTD_decodeLiteralsBlock+0x18>
{ U32 const lhlCode = ((istart[0]) >> 2) & 3;
130: 89 d8 mov %ebx,%eax
132: c1 e8 02 shr $0x2,%eax
135: 83 e0 03 and $0x3,%eax
switch(lhlCode)
138: 83 f8 01 cmp $0x1,%eax
13b: 0f 84 06 01 00 00 je 247 <ZSTD_decodeLiteralsBlock+0x1e7>
141: 83 f8 03 cmp $0x3,%eax
144: 0f 85 0c 01 00 00 jne 256 <ZSTD_decodeLiteralsBlock+0x1f6>
RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4");
14a: 48 83 fa 04 cmp $0x4,%rdx
14e: 0f 82 24 ff ff ff jb 78 <ZSTD_decodeLiteralsBlock+0x18>
154: 0f b7 01 movzwl (%rcx),%eax
157: 0f b6 59 02 movzbl 0x2(%rcx),%ebx
15b: 48 c1 e3 10 shl $0x10,%rbx
15f: 48 09 c3 or %rax,%rbx
162: 81 fb 0f 00 20 00 cmp $0x20000f,%ebx
168: 0f 87 0a ff ff ff ja 78 <ZSTD_decodeLiteralsBlock+0x18>
16e: 48 c1 eb 04 shr $0x4,%rbx
172: 41 bf 03 00 00 00 mov $0x3,%r15d
178: e9 e3 00 00 00 jmpq 260 <ZSTD_decodeLiteralsBlock+0x200>
RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, "");
17d: 41 83 be 28 75 00 00 cmpl $0x0,0x7528(%r14)
184: 00
185: 74 5a je 1e1 <ZSTD_decodeLiteralsBlock+0x181>
RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3");
187: 48 83 fa 05 cmp $0x5,%rdx
18b: 0f 82 e7 fe ff ff jb 78 <ZSTD_decodeLiteralsBlock+0x18>
U32 const lhlCode = (istart[0] >> 2) & 3;
191: c0 eb 02 shr $0x2,%bl
194: 80 e3 03 and $0x3,%bl
MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
197: 8b 39 mov (%rcx),%edi
switch(lhlCode)
199: 80 fb 02 cmp $0x2,%bl
19c: 0f 84 ed 00 00 00 je 28f <ZSTD_decodeLiteralsBlock+0x22f>
1a2: 0f b6 c3 movzbl %bl,%eax
1a5: 83 f8 03 cmp $0x3,%eax
1a8: 0f 85 f9 00 00 00 jne 2a7 <ZSTD_decodeLiteralsBlock+0x247>
litSize = (lhc >> 4) & 0x3FFFF;
1ae: 89 fe mov %edi,%esi
1b0: c1 ee 04 shr $0x4,%esi
1b3: 81 e6 ff ff 03 00 and $0x3ffff,%esi
RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
1b9: 81 fe 00 00 02 00 cmp $0x20000,%esi
1bf: 0f 87 b3 fe ff ff ja 78 <ZSTD_decodeLiteralsBlock+0x18>
1c5: 48 c1 ef 16 shr $0x16,%rdi
1c9: 0f b6 41 04 movzbl 0x4(%rcx),%eax
1cd: 48 c1 e0 0a shl $0xa,%rax
1d1: 48 09 f8 or %rdi,%rax
1d4: 45 31 d2 xor %r10d,%r10d
1d7: bb 05 00 00 00 mov $0x5,%ebx
1dc: e9 ea 00 00 00 jmpq 2cb <ZSTD_decodeLiteralsBlock+0x26b>
1e1: 49 c7 c7 e2 ff ff ff mov $0xffffffffffffffe2,%r15
1e8: e9 8b fe ff ff jmpq 78 <ZSTD_decodeLiteralsBlock+0x18>
MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
1ed: 0f b7 19 movzwl (%rcx),%ebx
litSize = MEM_readLE16(istart) >> 4;
1f0: 48 c1 eb 04 shr $0x4,%rbx
1f4: b8 02 00 00 00 mov $0x2,%eax
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
1f9: 48 8d 2c 18 lea (%rax,%rbx,1),%rbp
1fd: 48 8d 34 18 lea (%rax,%rbx,1),%rsi
201: 48 83 c6 20 add $0x20,%rsi
205: 48 39 d6 cmp %rdx,%rsi
208: 0f 87 da fe ff ff ja e8 <ZSTD_decodeLiteralsBlock+0x88>
20e: eb 1e jmp 22e <ZSTD_decodeLiteralsBlock+0x1ce>
litSize = istart[0] >> 3;
210: 48 c1 eb 03 shr $0x3,%rbx
214: b8 01 00 00 00 mov $0x1,%eax
if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) { /* risk reading beyond src buffer with wildcopy */
219: 48 8d 2c 18 lea (%rax,%rbx,1),%rbp
21d: 48 8d 34 18 lea (%rax,%rbx,1),%rsi
221: 48 83 c6 20 add $0x20,%rsi
225: 48 39 d6 cmp %rdx,%rsi
228: 0f 87 ba fe ff ff ja e8 <ZSTD_decodeLiteralsBlock+0x88>
dctx->litPtr = istart+lhSize;
22e: 48 01 c1 add %rax,%rcx
231: 49 89 8e a0 75 00 00 mov %rcx,0x75a0(%r14)
dctx->litSize = litSize;
238: 49 89 9e c0 75 00 00 mov %rbx,0x75c0(%r14)
23f: 49 89 ef mov %rbp,%r15
242: e9 31 fe ff ff jmpq 78 <ZSTD_decodeLiteralsBlock+0x18>
247: 0f b7 19 movzwl (%rcx),%ebx
litSize = MEM_readLE16(istart) >> 4;
24a: 48 c1 eb 04 shr $0x4,%rbx
24e: 41 bf 02 00 00 00 mov $0x2,%r15d
254: eb 0a jmp 260 <ZSTD_decodeLiteralsBlock+0x200>
litSize = istart[0] >> 3;
256: 48 c1 eb 03 shr $0x3,%rbx
25a: 41 bf 01 00 00 00 mov $0x1,%r15d
ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
260: 4d 8d a6 90 76 00 00 lea 0x7690(%r14),%r12
267: 48 8d 53 20 lea 0x20(%rbx),%rdx
26b: 42 0f b6 34 39 movzbl (%rcx,%r15,1),%esi
270: 4c 89 e7 mov %r12,%rdi
273: e8 00 00 00 00 callq 278 <ZSTD_decodeLiteralsBlock+0x218>
dctx->litPtr = dctx->litBuffer;
278: 4d 89 a6 a0 75 00 00 mov %r12,0x75a0(%r14)
dctx->litSize = litSize;
27f: 49 89 9e c0 75 00 00 mov %rbx,0x75c0(%r14)
return lhSize+1;
286: 49 83 c7 01 add $0x1,%r15
28a: e9 e9 fd ff ff jmpq 78 <ZSTD_decodeLiteralsBlock+0x18>
litSize = (lhc >> 4) & 0x3FFF;
28f: 89 fe mov %edi,%esi
291: c1 ee 04 shr $0x4,%esi
294: 81 e6 ff 3f 00 00 and $0x3fff,%esi
litCSize = lhc >> 18;
29a: c1 ef 12 shr $0x12,%edi
29d: bb 04 00 00 00 mov $0x4,%ebx
2a2: 45 31 d2 xor %r10d,%r10d
2a5: eb 22 jmp 2c9 <ZSTD_decodeLiteralsBlock+0x269>
singleStream = !lhlCode;
2a7: 45 31 d2 xor %r10d,%r10d
2aa: 84 db test %bl,%bl
2ac: 41 0f 94 c2 sete %r10b
litSize = (lhc >> 4) & 0x3FF;
2b0: 89 fe mov %edi,%esi
2b2: c1 ee 04 shr $0x4,%esi
2b5: 81 e6 ff 03 00 00 and $0x3ff,%esi
litCSize = (lhc >> 14) & 0x3FF;
2bb: c1 ef 0e shr $0xe,%edi
2be: 81 e7 ff 03 00 00 and $0x3ff,%edi
2c4: bb 03 00 00 00 mov $0x3,%ebx
2c9: 89 f8 mov %edi,%eax
RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, "");
2cb: 4c 8d 2c 18 lea (%rax,%rbx,1),%r13
2cf: 49 39 d5 cmp %rdx,%r13
2d2: 0f 87 a0 fd ff ff ja 78 <ZSTD_decodeLiteralsBlock+0x18>
2d8: 89 f5 mov %esi,%ebp
2da: 81 fd 01 03 00 00 cmp $0x301,%ebp
if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
2e0: 72 74 jb 356 <ZSTD_decodeLiteralsBlock+0x2f6>
2e2: 41 83 be f4 75 00 00 cmpl $0x0,0x75f4(%r14)
2e9: 00
2ea: 74 6a je 356 <ZSTD_decodeLiteralsBlock+0x2f6>
2ec: ba c0 01 00 00 mov $0x1c0,%edx
PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
2f1: 49 03 56 18 add 0x18(%r14),%rdx
2f5: 31 f6 xor %esi,%esi
2f7: 0f 18 94 32 40 fe ff prefetcht1 -0x1c0(%rdx,%rsi,1)
2fe: ff
2ff: 48 81 fe c4 3f 00 00 cmp $0x3fc4,%rsi
306: 73 4e jae 356 <ZSTD_decodeLiteralsBlock+0x2f6>
308: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
30f: 00
310: 0f 18 94 32 80 fe ff prefetcht1 -0x180(%rdx,%rsi,1)
317: ff
318: 0f 18 94 32 c0 fe ff prefetcht1 -0x140(%rdx,%rsi,1)
31f: ff
320: 0f 18 94 32 00 ff ff prefetcht1 -0x100(%rdx,%rsi,1)
327: ff
328: 0f 18 94 32 40 ff ff prefetcht1 -0xc0(%rdx,%rsi,1)
32f: ff
330: 0f 18 54 32 80 prefetcht1 -0x80(%rdx,%rsi,1)
335: 0f 18 54 32 c0 prefetcht1 -0x40(%rdx,%rsi,1)
33a: 0f 18 14 32 prefetcht1 (%rdx,%rsi,1)
33e: 48 81 c6 00 02 00 00 add $0x200,%rsi
345: 0f 18 94 32 40 fe ff prefetcht1 -0x1c0(%rdx,%rsi,1)
34c: ff
34d: 48 81 fe c4 3f 00 00 cmp $0x3fc4,%rsi
354: 72 ba jb 310 <ZSTD_decodeLiteralsBlock+0x2b0>
if (litEncType==set_repeat) {
356: 41 83 fc 03 cmp $0x3,%r12d
35a: 75 2a jne 386 <ZSTD_decodeLiteralsBlock+0x326>
35c: 49 8d be 90 76 00 00 lea 0x7690(%r14),%rdi
363: 48 01 d9 add %rbx,%rcx
366: 4d 8b 46 18 mov 0x18(%r14),%r8
36a: 45 8b 8e d8 75 00 00 mov 0x75d8(%r14),%r9d
hufSuccess = HUF_decompress4X_usingDTable_bmi2(
371: 48 89 ee mov %rbp,%rsi
374: 48 89 ca mov %rcx,%rdx
377: 48 89 c1 mov %rax,%rcx
37a: 45 85 d2 test %r10d,%r10d
if (singleStream) {
37d: 74 3e je 3bd <ZSTD_decodeLiteralsBlock+0x35d>
hufSuccess = HUF_decompress1X_usingDTable_bmi2(
37f: e8 00 00 00 00 callq 384 <ZSTD_decodeLiteralsBlock+0x324>
384: eb 4d jmp 3d3 <ZSTD_decodeLiteralsBlock+0x373>
386: 49 8d be 38 28 00 00 lea 0x2838(%r14),%rdi
38d: 49 8d b6 90 76 00 00 lea 0x7690(%r14),%rsi
394: 48 01 d9 add %rbx,%rcx
397: 4d 8d 8e bc 6a 00 00 lea 0x6abc(%r14),%r9
39e: 41 8b 9e d8 75 00 00 mov 0x75d8(%r14),%ebx
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
3a5: 48 89 ea mov %rbp,%rdx
3a8: 49 89 c0 mov %rax,%r8
3ab: 45 85 d2 test %r10d,%r10d
if (singleStream) {
3ae: 74 14 je 3c4 <ZSTD_decodeLiteralsBlock+0x364>
hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2(
3b0: 53 push %rbx
3b1: 68 00 0a 00 00 pushq $0xa00
3b6: e8 00 00 00 00 callq 3bb <ZSTD_decodeLiteralsBlock+0x35b>
3bb: eb 12 jmp 3cf <ZSTD_decodeLiteralsBlock+0x36f>
hufSuccess = HUF_decompress4X_usingDTable_bmi2(
3bd: e8 00 00 00 00 callq 3c2 <ZSTD_decodeLiteralsBlock+0x362>
3c2: eb 0f jmp 3d3 <ZSTD_decodeLiteralsBlock+0x373>
hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
3c4: 53 push %rbx
3c5: 68 00 0a 00 00 pushq $0xa00
3ca: e8 00 00 00 00 callq 3cf <ZSTD_decodeLiteralsBlock+0x36f>
3cf: 48 83 c4 10 add $0x10,%rsp
******************************************/
#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)); }
3d3: 48 83 f8 88 cmp $0xffffffffffffff88,%rax
RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, "");
3d7: 0f 87 9b fc ff ff ja 78 <ZSTD_decodeLiteralsBlock+0x18>
dctx->litPtr = dctx->litBuffer;
3dd: 49 8d 86 90 76 00 00 lea 0x7690(%r14),%rax
3e4: 49 89 86 a0 75 00 00 mov %rax,0x75a0(%r14)
dctx->litSize = litSize;
3eb: 49 89 ae c0 75 00 00 mov %rbp,0x75c0(%r14)
dctx->litEntropy = 1;
3f2: 41 c7 86 28 75 00 00 movl $0x1,0x7528(%r14)
3f9: 01 00 00 00
if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
3fd: 41 83 fc 02 cmp $0x2,%r12d
401: 75 0b jne 40e <ZSTD_decodeLiteralsBlock+0x3ae>
403: 49 8d 86 38 28 00 00 lea 0x2838(%r14),%rax
40a: 49 89 46 18 mov %rax,0x18(%r14)
ZSTD_memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
40e: 0f 57 c0 xorps %xmm0,%xmm0
411: 41 0f 11 84 2e a0 76 movups %xmm0,0x76a0(%r14,%rbp,1)
418: 00 00
41a: 41 0f 11 84 2e 90 76 movups %xmm0,0x7690(%r14,%rbp,1)
421: 00 00
423: 4d 89 ef mov %r13,%r15
426: e9 4d fc ff ff jmpq 78 <ZSTD_decodeLiteralsBlock+0x18>
42b: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
432: 00 00 00
435: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
43c: 00 00 00
43f: 90 nop
0000000000000440 <ZSTD_buildFSETable>:
void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
const short* normalizedCounter, unsigned maxSymbolValue,
const U32* baseValue, const U32* nbAdditionalBits,
unsigned tableLog, void* wksp, size_t wkspSize, int bmi2)
{
440: 55 push %rbp
441: 41 57 push %r15
443: 41 56 push %r14
445: 41 55 push %r13
447: 41 54 push %r12
449: 53 push %rbx
44a: 49 89 cc mov %rcx,%r12
#if DYNAMIC_BMI2
if (bmi2) {
44d: 83 7c 24 48 00 cmpl $0x0,0x48(%rsp)
452: 74 12 je 466 <ZSTD_buildFSETable+0x26>
ZSTD_buildFSETable_body_bmi2(dt, normalizedCounter, maxSymbolValue,
454: 4c 89 e1 mov %r12,%rcx
457: 5b pop %rbx
458: 41 5c pop %r12
45a: 41 5d pop %r13
45c: 41 5e pop %r14
45e: 41 5f pop %r15
460: 5d pop %rbp
461: e9 5a 04 00 00 jmpq 8c0 <ZSTD_buildFSETable_body_bmi2>
U32 const tableSize = 1 << tableLog;
466: 41 be 01 00 00 00 mov $0x1,%r14d
46c: 44 89 c9 mov %r9d,%ecx
46f: 41 d3 e6 shl %cl,%r14d
472: 4c 8b 6c 24 38 mov 0x38(%rsp),%r13
477: 41 bb 01 00 00 00 mov $0x1,%r11d
U32 highThreshold = tableSize - 1;
47d: 41 8d 5e ff lea -0x1(%r14),%ebx
U32 const maxSV1 = maxSymbolValue + 1;
481: 89 d0 mov %edx,%eax
483: ff c0 inc %eax
for (s=0; s<maxSV1; s++) {
485: 75 1f jne 4a6 <ZSTD_buildFSETable+0x66>
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
487: c7 07 01 00 00 00 movl $0x1,(%rdi)
48d: 44 89 4f 04 mov %r9d,0x4(%rdi)
size_t const step = FSE_TABLESTEP(tableSize);
491: 44 89 f0 mov %r14d,%eax
494: d1 e8 shr %eax
496: 44 89 f1 mov %r14d,%ecx
499: c1 e9 03 shr $0x3,%ecx
49c: 01 c1 add %eax,%ecx
49e: 83 c1 03 add $0x3,%ecx
4a1: e9 57 03 00 00 jmpq 7fd <ZSTD_buildFSETable+0x3bd>
4a6: 4c 89 74 24 c0 mov %r14,-0x40(%rsp)
4ab: 41 8d 49 ff lea -0x1(%r9),%ecx
4af: 41 be 00 00 01 00 mov $0x10000,%r14d
4b5: 41 d3 e6 shl %cl,%r14d
4b8: 41 c1 fe 10 sar $0x10,%r14d
for (s=0; s<maxSV1; s++) {
4bc: 41 89 c2 mov %eax,%r10d
4bf: 45 31 ff xor %r15d,%r15d
4c2: 85 d2 test %edx,%edx
4c4: 4c 89 54 24 c8 mov %r10,-0x38(%rsp)
4c9: 0f 84 87 00 00 00 je 556 <ZSTD_buildFSETable+0x116>
4cf: 41 83 e2 fe and $0xfffffffe,%r10d
4d3: 41 bb 01 00 00 00 mov $0x1,%r11d
4d9: 31 c9 xor %ecx,%ecx
4db: 89 da mov %ebx,%edx
4dd: eb 20 jmp 4ff <ZSTD_buildFSETable+0xbf>
4df: 90 nop
tableDecode[highThreshold--].baseValue = s;
4e0: 89 d0 mov %edx,%eax
4e2: 83 c2 ff add $0xffffffff,%edx
4e5: 8d 69 01 lea 0x1(%rcx),%ebp
4e8: 89 6c c7 0c mov %ebp,0xc(%rdi,%rax,8)
4ec: 66 b8 01 00 mov $0x1,%ax
symbolNext[s] = 1;
4f0: 66 41 89 44 4d 02 mov %ax,0x2(%r13,%rcx,2)
for (s=0; s<maxSV1; s++) {
4f6: 48 83 c1 02 add $0x2,%rcx
4fa: 49 39 ca cmp %rcx,%r10
4fd: 74 5b je 55a <ZSTD_buildFSETable+0x11a>
if (normalizedCounter[s]==-1) {
4ff: 0f bf 04 4e movswl (%rsi,%rcx,2),%eax
503: 83 f8 ff cmp $0xffffffff,%eax
506: 74 28 je 530 <ZSTD_buildFSETable+0xf0>
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
508: 41 39 c6 cmp %eax,%r14d
50b: 45 0f 4e df cmovle %r15d,%r11d
symbolNext[s] = 1;
50f: 66 41 89 44 4d 00 mov %ax,0x0(%r13,%rcx,2)
if (normalizedCounter[s]==-1) {
515: 0f bf 44 4e 02 movswl 0x2(%rsi,%rcx,2),%eax
51a: 83 f8 ff cmp $0xffffffff,%eax
51d: 75 2e jne 54d <ZSTD_buildFSETable+0x10d>
51f: eb bf jmp 4e0 <ZSTD_buildFSETable+0xa0>
521: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
528: 00 00 00
52b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
tableDecode[highThreshold--].baseValue = s;
530: 89 d0 mov %edx,%eax
532: 83 c2 ff add $0xffffffff,%edx
535: 89 4c c7 0c mov %ecx,0xc(%rdi,%rax,8)
539: 66 b8 01 00 mov $0x1,%ax
symbolNext[s] = 1;
53d: 66 41 89 44 4d 00 mov %ax,0x0(%r13,%rcx,2)
if (normalizedCounter[s]==-1) {
543: 0f bf 44 4e 02 movswl 0x2(%rsi,%rcx,2),%eax
548: 83 f8 ff cmp $0xffffffff,%eax
54b: 74 93 je 4e0 <ZSTD_buildFSETable+0xa0>
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
54d: 41 39 c6 cmp %eax,%r14d
550: 45 0f 4e df cmovle %r15d,%r11d
554: eb 9a jmp 4f0 <ZSTD_buildFSETable+0xb0>
556: 31 c9 xor %ecx,%ecx
558: 89 da mov %ebx,%edx
55a: 4c 8b 7c 24 c8 mov -0x38(%rsp),%r15
if (normalizedCounter[s]==-1) {
55f: 41 f6 c7 01 test $0x1,%r15b
563: 74 28 je 58d <ZSTD_buildFSETable+0x14d>
565: 0f bf 04 4e movswl (%rsi,%rcx,2),%eax
569: 83 f8 ff cmp $0xffffffff,%eax
56c: 74 0c je 57a <ZSTD_buildFSETable+0x13a>
56e: 45 31 d2 xor %r10d,%r10d
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
571: 41 39 c6 cmp %eax,%r14d
574: 45 0f 4e da cmovle %r10d,%r11d
578: eb 0d jmp 587 <ZSTD_buildFSETable+0x147>
tableDecode[highThreshold--].baseValue = s;
57a: 89 d0 mov %edx,%eax
57c: 83 c2 ff add $0xffffffff,%edx
57f: 89 4c c7 0c mov %ecx,0xc(%rdi,%rax,8)
583: 66 b8 01 00 mov $0x1,%ax
symbolNext[s] = 1;
587: 66 41 89 44 4d 00 mov %ax,0x0(%r13,%rcx,2)
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
58d: 44 89 1f mov %r11d,(%rdi)
590: 44 89 4f 04 mov %r9d,0x4(%rdi)
594: 4c 8b 74 24 c0 mov -0x40(%rsp),%r14
599: 44 89 f1 mov %r14d,%ecx
59c: c1 e9 03 shr $0x3,%ecx
if (highThreshold == tableSize - 1) {
59f: 39 da cmp %ebx,%edx
5a1: 48 89 74 24 b8 mov %rsi,-0x48(%rsp)
5a6: 0f 85 96 01 00 00 jne 742 <ZSTD_buildFSETable+0x302>
5ac: 48 89 4c 24 d0 mov %rcx,-0x30(%rsp)
5b1: 4c 89 64 24 d8 mov %r12,-0x28(%rsp)
5b6: 4c 89 44 24 e0 mov %r8,-0x20(%rsp)
5bb: 4c 89 4c 24 e8 mov %r9,-0x18(%rsp)
5c0: 4d 8d 45 6a lea 0x6a(%r13),%r8
for (s=0; s<maxSV1; ++s, sv += add) {
5c4: 49 8d 85 e2 00 00 00 lea 0xe2(%r13),%rax
5cb: 48 89 44 24 f0 mov %rax,-0x10(%rsp)
5d0: 31 ed xor %ebp,%ebp
5d2: 49 b9 01 01 01 01 01 movabs $0x101010101010101,%r9
5d9: 01 01 01
5dc: 31 c9 xor %ecx,%ecx
5de: 45 31 ff xor %r15d,%r15d
5e1: 4c 89 44 24 f8 mov %r8,-0x8(%rsp)
5e6: eb 21 jmp 609 <ZSTD_buildFSETable+0x1c9>
5e8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
5ef: 00
pos += n;
5f0: 49 0f bf c6 movswq %r14w,%rax
5f4: 48 01 c1 add %rax,%rcx
for (s=0; s<maxSV1; ++s, sv += add) {
5f7: 48 83 c5 01 add $0x1,%rbp
5fb: 4d 01 cf add %r9,%r15
5fe: 48 3b 6c 24 c8 cmp -0x38(%rsp),%rbp
603: 0f 84 d1 01 00 00 je 7da <ZSTD_buildFSETable+0x39a>
int const n = normalizedCounter[s];
609: 44 0f b7 34 6e movzwl (%rsi,%rbp,2),%r14d
MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }
60e: 4d 89 3c 08 mov %r15,(%r8,%rcx,1)
for (i = 8; i < n; i += 8) {
612: 66 41 83 fe 09 cmp $0x9,%r14w
617: 7c d7 jl 5f0 <ZSTD_buildFSETable+0x1b0>
619: 66 41 83 fe 10 cmp $0x10,%r14w
61e: 41 ba 10 00 00 00 mov $0x10,%r10d
624: 4d 0f 47 d6 cmova %r14,%r10
628: 4d 8d 24 08 lea (%r8,%rcx,1),%r12
62c: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
630: ba 08 00 00 00 mov $0x8,%edx
635: 49 83 fa 18 cmp $0x18,%r10
639: 0f 82 f1 00 00 00 jb 730 <ZSTD_buildFSETable+0x2f0>
63f: 49 c1 ea 03 shr $0x3,%r10
643: 49 83 c2 01 add $0x1,%r10
647: 4c 89 d6 mov %r10,%rsi
64a: 48 83 e6 fc and $0xfffffffffffffffc,%rsi
64e: 66 49 0f 6e c7 movq %r15,%xmm0
653: 66 0f 70 c0 44 pshufd $0x44,%xmm0,%xmm0
658: 48 8d 56 fc lea -0x4(%rsi),%rdx
65c: 49 89 d0 mov %rdx,%r8
65f: 49 c1 e8 02 shr $0x2,%r8
663: 49 83 c0 01 add $0x1,%r8
667: 45 89 c1 mov %r8d,%r9d
66a: 41 83 e1 03 and $0x3,%r9d
66e: 48 83 fa 0c cmp $0xc,%rdx
672: 73 04 jae 678 <ZSTD_buildFSETable+0x238>
674: 31 d2 xor %edx,%edx
676: eb 59 jmp 6d1 <ZSTD_buildFSETable+0x291>
678: 48 8b 44 24 f0 mov -0x10(%rsp),%rax
67d: 4c 8d 1c 08 lea (%rax,%rcx,1),%r11
681: 49 83 e0 fc and $0xfffffffffffffffc,%r8
685: 49 f7 d8 neg %r8
688: 31 d2 xor %edx,%edx
68a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
690: f3 41 0f 7f 44 d3 90 movdqu %xmm0,-0x70(%r11,%rdx,8)
697: f3 41 0f 7f 44 d3 a0 movdqu %xmm0,-0x60(%r11,%rdx,8)
69e: f3 41 0f 7f 44 d3 b0 movdqu %xmm0,-0x50(%r11,%rdx,8)
6a5: f3 41 0f 7f 44 d3 c0 movdqu %xmm0,-0x40(%r11,%rdx,8)
6ac: f3 41 0f 7f 44 d3 d0 movdqu %xmm0,-0x30(%r11,%rdx,8)
6b3: f3 41 0f 7f 44 d3 e0 movdqu %xmm0,-0x20(%r11,%rdx,8)
6ba: f3 41 0f 7f 44 d3 f0 movdqu %xmm0,-0x10(%r11,%rdx,8)
6c1: f3 41 0f 7f 04 d3 movdqu %xmm0,(%r11,%rdx,8)
6c7: 48 83 c2 10 add $0x10,%rdx
6cb: 49 83 c0 04 add $0x4,%r8
6cf: 75 bf jne 690 <ZSTD_buildFSETable+0x250>
6d1: 4d 85 c9 test %r9,%r9
6d4: 74 27 je 6fd <ZSTD_buildFSETable+0x2bd>
6d6: 48 c1 e2 03 shl $0x3,%rdx
6da: 49 f7 d9 neg %r9
6dd: 0f 1f 00 nopl (%rax)
6e0: 48 89 d0 mov %rdx,%rax
6e3: 48 83 c8 08 or $0x8,%rax
6e7: f3 41 0f 7f 04 04 movdqu %xmm0,(%r12,%rax,1)
6ed: f3 41 0f 7f 44 04 10 movdqu %xmm0,0x10(%r12,%rax,1)
6f4: 48 83 c2 20 add $0x20,%rdx
6f8: 49 ff c1 inc %r9
6fb: 75 e3 jne 6e0 <ZSTD_buildFSETable+0x2a0>
6fd: 49 39 f2 cmp %rsi,%r10
700: 48 89 f0 mov %rsi,%rax
703: 48 8b 74 24 b8 mov -0x48(%rsp),%rsi
708: 4c 8b 44 24 f8 mov -0x8(%rsp),%r8
70d: 49 b9 01 01 01 01 01 movabs $0x101010101010101,%r9
714: 01 01 01
717: 0f 84 d3 fe ff ff je 5f0 <ZSTD_buildFSETable+0x1b0>
71d: 48 8d 14 c5 08 00 00 lea 0x8(,%rax,8),%rdx
724: 00
725: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
72c: 00 00 00
72f: 90 nop
730: 4d 89 3c 14 mov %r15,(%r12,%rdx,1)
734: 48 83 c2 08 add $0x8,%rdx
738: 4c 39 f2 cmp %r14,%rdx
73b: 72 f3 jb 730 <ZSTD_buildFSETable+0x2f0>
73d: e9 ae fe ff ff jmpq 5f0 <ZSTD_buildFSETable+0x1b0>
U32 const step = FSE_TABLESTEP(tableSize);
742: 44 89 f0 mov %r14d,%eax
745: d1 e8 shr %eax
747: 01 c1 add %eax,%ecx
749: 83 c1 03 add $0x3,%ecx
74c: 45 31 d2 xor %r10d,%r10d
74f: 31 c0 xor %eax,%eax
751: eb 1f jmp 772 <ZSTD_buildFSETable+0x332>
753: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
75a: 00 00 00
75d: 0f 1f 00 nopl (%rax)
760: 48 8b 74 24 b8 mov -0x48(%rsp),%rsi
for (s=0; s<maxSV1; s++) {
765: 49 83 c2 01 add $0x1,%r10
769: 4d 39 fa cmp %r15,%r10
76c: 0f 84 c9 00 00 00 je 83b <ZSTD_buildFSETable+0x3fb>
int const n = normalizedCounter[s];
772: 46 0f bf 1c 56 movswl (%rsi,%r10,2),%r11d
777: 45 85 db test %r11d,%r11d
for (i=0; i<n; i++) {
77a: 7e e4 jle 760 <ZSTD_buildFSETable+0x320>
77c: 66 41 83 fb 01 cmp $0x1,%r11w
781: 74 3a je 7bd <ZSTD_buildFSETable+0x37d>
783: 44 89 dd mov %r11d,%ebp
786: 83 e5 fe and $0xfffffffe,%ebp
789: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
tableDecode[position].baseValue = s;
790: 89 c6 mov %eax,%esi
792: 44 89 54 f7 0c mov %r10d,0xc(%rdi,%rsi,8)
797: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
79e: 00 00
7a0: 01 c8 add %ecx,%eax
7a2: 21 d8 and %ebx,%eax
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
7a4: 39 d0 cmp %edx,%eax
7a6: 77 f8 ja 7a0 <ZSTD_buildFSETable+0x360>
tableDecode[position].baseValue = s;
7a8: 89 c6 mov %eax,%esi
7aa: 44 89 54 f7 0c mov %r10d,0xc(%rdi,%rsi,8)
7af: 90 nop
7b0: 01 c8 add %ecx,%eax
7b2: 21 d8 and %ebx,%eax
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
7b4: 39 d0 cmp %edx,%eax
7b6: 77 f8 ja 7b0 <ZSTD_buildFSETable+0x370>
for (i=0; i<n; i++) {
7b8: 83 c5 fe add $0xfffffffe,%ebp
7bb: 75 d3 jne 790 <ZSTD_buildFSETable+0x350>
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
7bd: 41 f6 c3 01 test $0x1,%r11b
7c1: 48 8b 74 24 b8 mov -0x48(%rsp),%rsi
7c6: 74 9d je 765 <ZSTD_buildFSETable+0x325>
tableDecode[position].baseValue = s;
7c8: 89 c5 mov %eax,%ebp
7ca: 44 89 54 ef 0c mov %r10d,0xc(%rdi,%rbp,8)
7cf: 90 nop
7d0: 01 c8 add %ecx,%eax
7d2: 21 d8 and %ebx,%eax
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
7d4: 39 d0 cmp %edx,%eax
7d6: 77 f8 ja 7d0 <ZSTD_buildFSETable+0x390>
7d8: eb 8b jmp 765 <ZSTD_buildFSETable+0x325>
7da: 4c 8b 74 24 c0 mov -0x40(%rsp),%r14
size_t const step = FSE_TABLESTEP(tableSize);
7df: 44 89 f0 mov %r14d,%eax
7e2: d1 e8 shr %eax
7e4: 48 8b 4c 24 d0 mov -0x30(%rsp),%rcx
7e9: 01 c1 add %eax,%ecx
7eb: 83 c1 03 add $0x3,%ecx
7ee: 4c 8b 4c 24 e8 mov -0x18(%rsp),%r9
7f3: 4c 8b 44 24 e0 mov -0x20(%rsp),%r8
7f8: 4c 8b 64 24 d8 mov -0x28(%rsp),%r12
size_t const tableMask = tableSize-1;
7fd: 89 d8 mov %ebx,%eax
size_t const step = FSE_TABLESTEP(tableSize);
7ff: 41 89 cb mov %ecx,%r11d
for (s = 0; s < (size_t)tableSize; s += unroll) {
802: 45 89 f2 mov %r14d,%r10d
805: 4b 8d 34 1b lea (%r11,%r11,1),%rsi
809: 31 ed xor %ebp,%ebp
80b: 31 db xor %ebx,%ebx
80d: 0f 1f 00 nopl (%rax)
size_t const uPosition = (position + (u * step)) & tableMask;
810: 89 d9 mov %ebx,%ecx
812: 21 c1 and %eax,%ecx
tableDecode[uPosition].baseValue = spread[s + u];
814: 41 0f b6 54 2d 6a movzbl 0x6a(%r13,%rbp,1),%edx
81a: 89 54 cf 0c mov %edx,0xc(%rdi,%rcx,8)
size_t const uPosition = (position + (u * step)) & tableMask;
81e: 41 8d 0c 1b lea (%r11,%rbx,1),%ecx
822: 21 c1 and %eax,%ecx
tableDecode[uPosition].baseValue = spread[s + u];
824: 41 0f b6 54 2d 6b movzbl 0x6b(%r13,%rbp,1),%edx
82a: 89 54 cf 0c mov %edx,0xc(%rdi,%rcx,8)
position = (position + (unroll * step)) & tableMask;
82e: 01 f3 add %esi,%ebx
830: 21 c3 and %eax,%ebx
for (s = 0; s < (size_t)tableSize; s += unroll) {
832: 48 83 c5 02 add $0x2,%rbp
836: 4c 39 d5 cmp %r10,%rbp
839: 72 d5 jb 810 <ZSTD_buildFSETable+0x3d0>
83b: 41 83 c1 01 add $0x1,%r9d
for (u=0; u<tableSize; u++) {
83f: 41 83 fe 01 cmp $0x1,%r14d
843: b8 01 00 00 00 mov $0x1,%eax
848: 41 0f 47 c6 cmova %r14d,%eax
84c: 31 d2 xor %edx,%edx
84e: 66 90 xchg %ax,%ax
U32 const symbol = tableDecode[u].baseValue;
850: 8b 74 d7 0c mov 0xc(%rdi,%rdx,8),%esi
U32 const nextState = symbolNext[symbol]++;
854: 41 0f b7 6c 75 00 movzwl 0x0(%r13,%rsi,2),%ebp
85a: 8d 4d 01 lea 0x1(%rbp),%ecx
85d: 66 41 89 4c 75 00 mov %cx,0x0(%r13,%rsi,2)
# 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;
863: 0f bd cd bsr %ebp,%ecx
866: f7 d1 not %ecx
868: 81 c9 e0 00 00 00 or $0xe0,%ecx
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
86e: 44 01 c9 add %r9d,%ecx
871: 88 4c d7 0b mov %cl,0xb(%rdi,%rdx,8)
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
875: d3 e5 shl %cl,%ebp
877: 44 29 f5 sub %r14d,%ebp
87a: 66 89 6c d7 08 mov %bp,0x8(%rdi,%rdx,8)
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
87f: 41 0f b6 0c b0 movzbl (%r8,%rsi,4),%ecx
884: 88 4c d7 0a mov %cl,0xa(%rdi,%rdx,8)
tableDecode[u].baseValue = baseValue[symbol];
888: 41 8b 0c b4 mov (%r12,%rsi,4),%ecx
88c: 89 4c d7 0c mov %ecx,0xc(%rdi,%rdx,8)
for (u=0; u<tableSize; u++) {
890: 48 83 c2 01 add $0x1,%rdx
894: 48 39 d0 cmp %rdx,%rax
897: 75 b7 jne 850 <ZSTD_buildFSETable+0x410>
}
#endif
(void)bmi2;
ZSTD_buildFSETable_body_default(dt, normalizedCounter, maxSymbolValue,
baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
}
899: 5b pop %rbx
89a: 41 5c pop %r12
89c: 41 5d pop %r13
89e: 41 5e pop %r14
8a0: 41 5f pop %r15
8a2: 5d pop %rbp
8a3: c3 retq
8a4: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
8ab: 00 00 00
8ae: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
8b5: 00 00 00
8b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
8bf: 00
00000000000008c0 <ZSTD_buildFSETable_body_bmi2>:
{
8c0: 55 push %rbp
8c1: 41 57 push %r15
8c3: 41 56 push %r14
8c5: 41 55 push %r13
8c7: 41 54 push %r12
8c9: 53 push %rbx
8ca: 49 89 cc mov %rcx,%r12
8cd: 4c 8b 5c 24 38 mov 0x38(%rsp),%r11
8d2: 41 ba 01 00 00 00 mov $0x1,%r10d
U32 const tableSize = 1 << tableLog;
8d8: c4 c2 31 f7 da shlx %r9d,%r10d,%ebx
U32 highThreshold = tableSize - 1;
8dd: 8d 43 ff lea -0x1(%rbx),%eax
U32 const maxSV1 = maxSymbolValue + 1;
8e0: 89 d1 mov %edx,%ecx
8e2: ff c1 inc %ecx
8e4: 48 89 5c 24 c0 mov %rbx,-0x40(%rsp)
for (s=0; s<maxSV1; s++) {
8e9: 75 1d jne 908 <ZSTD_buildFSETable_body_bmi2+0x48>
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
8eb: c7 07 01 00 00 00 movl $0x1,(%rdi)
8f1: 44 89 4f 04 mov %r9d,0x4(%rdi)
size_t const step = FSE_TABLESTEP(tableSize);
8f5: 89 d9 mov %ebx,%ecx
8f7: d1 e9 shr %ecx
8f9: 89 da mov %ebx,%edx
8fb: c1 ea 03 shr $0x3,%edx
8fe: 01 ca add %ecx,%edx
900: 83 c2 03 add $0x3,%edx
903: e9 51 03 00 00 jmpq c59 <ZSTD_buildFSETable_body_bmi2+0x399>
908: 41 8d 69 ff lea -0x1(%r9),%ebp
90c: bb 00 00 01 00 mov $0x10000,%ebx
911: c4 62 51 f7 f3 shlx %ebp,%ebx,%r14d
916: 41 c1 fe 10 sar $0x10,%r14d
for (s=0; s<maxSV1; s++) {
91a: 41 89 cd mov %ecx,%r13d
91d: 45 31 ff xor %r15d,%r15d
920: 85 d2 test %edx,%edx
922: 4c 89 44 24 d0 mov %r8,-0x30(%rsp)
927: 4c 89 64 24 c8 mov %r12,-0x38(%rsp)
92c: 0f 84 83 00 00 00 je 9b5 <ZSTD_buildFSETable_body_bmi2+0xf5>
932: 45 89 ec mov %r13d,%r12d
935: 41 83 e4 fe and $0xfffffffe,%r12d
939: 41 ba 01 00 00 00 mov $0x1,%r10d
93f: 31 db xor %ebx,%ebx
941: 89 c2 mov %eax,%edx
943: eb 2a jmp 96f <ZSTD_buildFSETable_body_bmi2+0xaf>
945: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
94c: 00 00 00
94f: 90 nop
tableDecode[highThreshold--].baseValue = s;
950: 89 d1 mov %edx,%ecx
952: 83 c2 ff add $0xffffffff,%edx
955: 8d 6b 01 lea 0x1(%rbx),%ebp
958: 89 6c cf 0c mov %ebp,0xc(%rdi,%rcx,8)
95c: 66 b9 01 00 mov $0x1,%cx
symbolNext[s] = 1;
960: 66 41 89 4c 5b 02 mov %cx,0x2(%r11,%rbx,2)
for (s=0; s<maxSV1; s++) {
966: 48 83 c3 02 add $0x2,%rbx
96a: 49 39 dc cmp %rbx,%r12
96d: 74 4a je 9b9 <ZSTD_buildFSETable_body_bmi2+0xf9>
if (normalizedCounter[s]==-1) {
96f: 0f bf 0c 5e movswl (%rsi,%rbx,2),%ecx
973: 83 f9 ff cmp $0xffffffff,%ecx
976: 74 18 je 990 <ZSTD_buildFSETable_body_bmi2+0xd0>
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
978: 41 39 ce cmp %ecx,%r14d
97b: 45 0f 4e d7 cmovle %r15d,%r10d
symbolNext[s] = 1;
97f: 66 41 89 0c 5b mov %cx,(%r11,%rbx,2)
if (normalizedCounter[s]==-1) {
984: 0f bf 4c 5e 02 movswl 0x2(%rsi,%rbx,2),%ecx
989: 83 f9 ff cmp $0xffffffff,%ecx
98c: 75 1e jne 9ac <ZSTD_buildFSETable_body_bmi2+0xec>
98e: eb c0 jmp 950 <ZSTD_buildFSETable_body_bmi2+0x90>
tableDecode[highThreshold--].baseValue = s;
990: 89 d1 mov %edx,%ecx
992: 83 c2 ff add $0xffffffff,%edx
995: 89 5c cf 0c mov %ebx,0xc(%rdi,%rcx,8)
999: 66 b9 01 00 mov $0x1,%cx
symbolNext[s] = 1;
99d: 66 41 89 0c 5b mov %cx,(%r11,%rbx,2)
if (normalizedCounter[s]==-1) {
9a2: 0f bf 4c 5e 02 movswl 0x2(%rsi,%rbx,2),%ecx
9a7: 83 f9 ff cmp $0xffffffff,%ecx
9aa: 74 a4 je 950 <ZSTD_buildFSETable_body_bmi2+0x90>
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
9ac: 41 39 ce cmp %ecx,%r14d
9af: 45 0f 4e d7 cmovle %r15d,%r10d
9b3: eb ab jmp 960 <ZSTD_buildFSETable_body_bmi2+0xa0>
9b5: 31 db xor %ebx,%ebx
9b7: 89 c2 mov %eax,%edx
if (normalizedCounter[s]==-1) {
9b9: 41 f6 c5 01 test $0x1,%r13b
9bd: 4c 8b 44 24 d0 mov -0x30(%rsp),%r8
9c2: 4c 8b 64 24 c8 mov -0x38(%rsp),%r12
9c7: 74 26 je 9ef <ZSTD_buildFSETable_body_bmi2+0x12f>
9c9: 0f bf 0c 5e movswl (%rsi,%rbx,2),%ecx
9cd: 83 f9 ff cmp $0xffffffff,%ecx
9d0: 74 0b je 9dd <ZSTD_buildFSETable_body_bmi2+0x11d>
9d2: 31 ed xor %ebp,%ebp
if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
9d4: 41 39 ce cmp %ecx,%r14d
9d7: 44 0f 4e d5 cmovle %ebp,%r10d
9db: eb 0d jmp 9ea <ZSTD_buildFSETable_body_bmi2+0x12a>
tableDecode[highThreshold--].baseValue = s;
9dd: 89 d1 mov %edx,%ecx
9df: 83 c2 ff add $0xffffffff,%edx
9e2: 89 5c cf 0c mov %ebx,0xc(%rdi,%rcx,8)
9e6: 66 b9 01 00 mov $0x1,%cx
symbolNext[s] = 1;
9ea: 66 41 89 0c 5b mov %cx,(%r11,%rbx,2)
ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
9ef: 44 89 17 mov %r10d,(%rdi)
9f2: 44 89 4f 04 mov %r9d,0x4(%rdi)
9f6: 48 8b 4c 24 c0 mov -0x40(%rsp),%rcx
9fb: 89 cd mov %ecx,%ebp
9fd: c1 ed 03 shr $0x3,%ebp
if (highThreshold == tableSize - 1) {
a00: 39 c2 cmp %eax,%edx
a02: 0f 85 9a 01 00 00 jne ba2 <ZSTD_buildFSETable_body_bmi2+0x2e2>
a08: 4c 89 4c 24 e8 mov %r9,-0x18(%rsp)
a0d: 49 8d 53 6a lea 0x6a(%r11),%rdx
size_t const step = FSE_TABLESTEP(tableSize);
a11: 83 c5 03 add $0x3,%ebp
a14: 48 89 6c 24 e0 mov %rbp,-0x20(%rsp)
for (s=0; s<maxSV1; ++s, sv += add) {
a19: 49 8d 8b e2 00 00 00 lea 0xe2(%r11),%rcx
a20: 48 89 4c 24 f0 mov %rcx,-0x10(%rsp)
a25: 31 ed xor %ebp,%ebp
a27: 49 b8 01 01 01 01 01 movabs $0x101010101010101,%r8
a2e: 01 01 01
a31: 31 db xor %ebx,%ebx
a33: 45 31 ff xor %r15d,%r15d
a36: 4c 89 6c 24 d8 mov %r13,-0x28(%rsp)
a3b: 48 89 54 24 f8 mov %rdx,-0x8(%rsp)
a40: eb 25 jmp a67 <ZSTD_buildFSETable_body_bmi2+0x1a7>
a42: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
a49: 00 00 00
a4c: 0f 1f 40 00 nopl 0x0(%rax)
pos += n;
a50: 49 0f bf ce movswq %r14w,%rcx
a54: 48 01 cb add %rcx,%rbx
for (s=0; s<maxSV1; ++s, sv += add) {
a57: 48 83 c5 01 add $0x1,%rbp
a5b: 4d 01 c7 add %r8,%r15
a5e: 4c 39 ed cmp %r13,%rbp
a61: 0f 84 d3 01 00 00 je c3a <ZSTD_buildFSETable_body_bmi2+0x37a>
int const n = normalizedCounter[s];
a67: 44 0f b7 34 6e movzwl (%rsi,%rbp,2),%r14d
a6c: 4c 89 3c 1a mov %r15,(%rdx,%rbx,1)
for (i = 8; i < n; i += 8) {
a70: 66 41 83 fe 09 cmp $0x9,%r14w
a75: 7c d9 jl a50 <ZSTD_buildFSETable_body_bmi2+0x190>
a77: 66 41 83 fe 10 cmp $0x10,%r14w
a7c: 41 bd 10 00 00 00 mov $0x10,%r13d
a82: 4d 0f 47 ee cmova %r14,%r13
a86: 4c 8d 24 1a lea (%rdx,%rbx,1),%r12
a8a: 49 83 c5 f7 add $0xfffffffffffffff7,%r13
a8e: b9 08 00 00 00 mov $0x8,%ecx
a93: 49 83 fd 18 cmp $0x18,%r13
a97: 0f 82 e5 00 00 00 jb b82 <ZSTD_buildFSETable_body_bmi2+0x2c2>
a9d: 49 c1 ed 03 shr $0x3,%r13
aa1: 49 83 c5 01 add $0x1,%r13
aa5: 4d 89 ea mov %r13,%r10
aa8: 49 83 e2 fc and $0xfffffffffffffffc,%r10
aac: 66 49 0f 6e c7 movq %r15,%xmm0
ab1: 66 0f 70 c0 44 pshufd $0x44,%xmm0,%xmm0
ab6: 49 8d 4a fc lea -0x4(%r10),%rcx
aba: 49 89 c8 mov %rcx,%r8
abd: 49 c1 e8 02 shr $0x2,%r8
ac1: 49 83 c0 01 add $0x1,%r8
ac5: 45 89 c1 mov %r8d,%r9d
ac8: 41 83 e1 03 and $0x3,%r9d
acc: 48 83 f9 0c cmp $0xc,%rcx
ad0: 73 04 jae ad6 <ZSTD_buildFSETable_body_bmi2+0x216>
ad2: 31 c9 xor %ecx,%ecx
ad4: eb 53 jmp b29 <ZSTD_buildFSETable_body_bmi2+0x269>
ad6: 48 8b 4c 24 f0 mov -0x10(%rsp),%rcx
adb: 48 8d 14 19 lea (%rcx,%rbx,1),%rdx
adf: 49 83 e0 fc and $0xfffffffffffffffc,%r8
ae3: 49 f7 d8 neg %r8
ae6: 31 c9 xor %ecx,%ecx
ae8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
aef: 00
af0: f3 0f 7f 44 ca 90 movdqu %xmm0,-0x70(%rdx,%rcx,8)
af6: f3 0f 7f 44 ca a0 movdqu %xmm0,-0x60(%rdx,%rcx,8)
afc: f3 0f 7f 44 ca b0 movdqu %xmm0,-0x50(%rdx,%rcx,8)
b02: f3 0f 7f 44 ca c0 movdqu %xmm0,-0x40(%rdx,%rcx,8)
b08: f3 0f 7f 44 ca d0 movdqu %xmm0,-0x30(%rdx,%rcx,8)
b0e: f3 0f 7f 44 ca e0 movdqu %xmm0,-0x20(%rdx,%rcx,8)
b14: f3 0f 7f 44 ca f0 movdqu %xmm0,-0x10(%rdx,%rcx,8)
b1a: f3 0f 7f 04 ca movdqu %xmm0,(%rdx,%rcx,8)
b1f: 48 83 c1 10 add $0x10,%rcx
b23: 49 83 c0 04 add $0x4,%r8
b27: 75 c7 jne af0 <ZSTD_buildFSETable_body_bmi2+0x230>
b29: 4d 85 c9 test %r9,%r9
b2c: 74 2f je b5d <ZSTD_buildFSETable_body_bmi2+0x29d>
b2e: 48 c1 e1 03 shl $0x3,%rcx
b32: 49 f7 d9 neg %r9
b35: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
b3c: 00 00 00
b3f: 90 nop
b40: 48 89 ca mov %rcx,%rdx
b43: 48 83 ca 08 or $0x8,%rdx
b47: f3 41 0f 7f 04 14 movdqu %xmm0,(%r12,%rdx,1)
b4d: f3 41 0f 7f 44 14 10 movdqu %xmm0,0x10(%r12,%rdx,1)
b54: 48 83 c1 20 add $0x20,%rcx
b58: 49 ff c1 inc %r9
b5b: 75 e3 jne b40 <ZSTD_buildFSETable_body_bmi2+0x280>
b5d: 4d 39 d5 cmp %r10,%r13
b60: 4c 8b 6c 24 d8 mov -0x28(%rsp),%r13
b65: 48 8b 54 24 f8 mov -0x8(%rsp),%rdx
b6a: 49 b8 01 01 01 01 01 movabs $0x101010101010101,%r8
b71: 01 01 01
b74: 0f 84 d6 fe ff ff je a50 <ZSTD_buildFSETable_body_bmi2+0x190>
b7a: 4a 8d 0c d5 08 00 00 lea 0x8(,%r10,8),%rcx
b81: 00
b82: 4c 8b 6c 24 d8 mov -0x28(%rsp),%r13
b87: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
b8e: 00 00
b90: 4d 89 3c 0c mov %r15,(%r12,%rcx,1)
b94: 48 83 c1 08 add $0x8,%rcx
b98: 4c 39 f1 cmp %r14,%rcx
b9b: 72 f3 jb b90 <ZSTD_buildFSETable_body_bmi2+0x2d0>
b9d: e9 ae fe ff ff jmpq a50 <ZSTD_buildFSETable_body_bmi2+0x190>
U32 const step = FSE_TABLESTEP(tableSize);
ba2: d1 e9 shr %ecx
ba4: 8d 1c 29 lea (%rcx,%rbp,1),%ebx
ba7: 83 c3 03 add $0x3,%ebx
baa: 45 31 f6 xor %r14d,%r14d
bad: 31 ed xor %ebp,%ebp
baf: eb 1c jmp bcd <ZSTD_buildFSETable_body_bmi2+0x30d>
bb1: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
bb8: 00 00 00
bbb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
for (s=0; s<maxSV1; s++) {
bc0: 49 83 c6 01 add $0x1,%r14
bc4: 4d 39 ee cmp %r13,%r14
bc7: 0f 84 ce 00 00 00 je c9b <ZSTD_buildFSETable_body_bmi2+0x3db>
int const n = normalizedCounter[s];
bcd: 46 0f bf 3c 76 movswl (%rsi,%r14,2),%r15d
bd2: 45 85 ff test %r15d,%r15d
for (i=0; i<n; i++) {
bd5: 7e e9 jle bc0 <ZSTD_buildFSETable_body_bmi2+0x300>
bd7: 66 41 83 ff 01 cmp $0x1,%r15w
bdc: 74 40 je c1e <ZSTD_buildFSETable_body_bmi2+0x35e>
bde: 45 89 fa mov %r15d,%r10d
be1: 41 83 e2 fe and $0xfffffffe,%r10d
be5: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
bec: 00 00 00
bef: 90 nop
tableDecode[position].baseValue = s;
bf0: 89 e9 mov %ebp,%ecx
bf2: 44 89 74 cf 0c mov %r14d,0xc(%rdi,%rcx,8)
bf7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
bfe: 00 00
c00: 01 dd add %ebx,%ebp
c02: 21 c5 and %eax,%ebp
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
c04: 39 d5 cmp %edx,%ebp
c06: 77 f8 ja c00 <ZSTD_buildFSETable_body_bmi2+0x340>
tableDecode[position].baseValue = s;
c08: 89 e9 mov %ebp,%ecx
c0a: 44 89 74 cf 0c mov %r14d,0xc(%rdi,%rcx,8)
c0f: 90 nop
c10: 01 dd add %ebx,%ebp
c12: 21 c5 and %eax,%ebp
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
c14: 39 d5 cmp %edx,%ebp
c16: 77 f8 ja c10 <ZSTD_buildFSETable_body_bmi2+0x350>
for (i=0; i<n; i++) {
c18: 41 83 c2 fe add $0xfffffffe,%r10d
c1c: 75 d2 jne bf0 <ZSTD_buildFSETable_body_bmi2+0x330>
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
c1e: 41 f6 c7 01 test $0x1,%r15b
c22: 74 9c je bc0 <ZSTD_buildFSETable_body_bmi2+0x300>
tableDecode[position].baseValue = s;
c24: 89 e9 mov %ebp,%ecx
c26: 44 89 74 cf 0c mov %r14d,0xc(%rdi,%rcx,8)
c2b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
c30: 01 dd add %ebx,%ebp
c32: 21 c5 and %eax,%ebp
while (position > highThreshold) position = (position + step) & tableMask; /* lowprob area */
c34: 39 d5 cmp %edx,%ebp
c36: 77 f8 ja c30 <ZSTD_buildFSETable_body_bmi2+0x370>
c38: eb 86 jmp bc0 <ZSTD_buildFSETable_body_bmi2+0x300>
c3a: 48 8b 5c 24 c0 mov -0x40(%rsp),%rbx
size_t const step = FSE_TABLESTEP(tableSize);
c3f: 89 d9 mov %ebx,%ecx
c41: d1 e9 shr %ecx
c43: 48 8b 54 24 e0 mov -0x20(%rsp),%rdx
c48: 01 ca add %ecx,%edx
c4a: 4c 8b 4c 24 e8 mov -0x18(%rsp),%r9
c4f: 4c 8b 44 24 d0 mov -0x30(%rsp),%r8
c54: 4c 8b 64 24 c8 mov -0x38(%rsp),%r12
size_t const tableMask = tableSize-1;
c59: 89 c0 mov %eax,%eax
size_t const step = FSE_TABLESTEP(tableSize);
c5b: 41 89 d6 mov %edx,%r14d
for (s = 0; s < (size_t)tableSize; s += unroll) {
c5e: 41 89 da mov %ebx,%r10d
c61: 4b 8d 34 36 lea (%r14,%r14,1),%rsi
c65: 31 ed xor %ebp,%ebp
c67: 31 db xor %ebx,%ebx
c69: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
size_t const uPosition = (position + (u * step)) & tableMask;
c70: 89 d9 mov %ebx,%ecx
c72: 21 c1 and %eax,%ecx
tableDecode[uPosition].baseValue = spread[s + u];
c74: 41 0f b6 54 2b 6a movzbl 0x6a(%r11,%rbp,1),%edx
c7a: 89 54 cf 0c mov %edx,0xc(%rdi,%rcx,8)
size_t const uPosition = (position + (u * step)) & tableMask;
c7e: 41 8d 0c 1e lea (%r14,%rbx,1),%ecx
c82: 21 c1 and %eax,%ecx
tableDecode[uPosition].baseValue = spread[s + u];
c84: 41 0f b6 54 2b 6b movzbl 0x6b(%r11,%rbp,1),%edx
c8a: 89 54 cf 0c mov %edx,0xc(%rdi,%rcx,8)
position = (position + (unroll * step)) & tableMask;
c8e: 01 f3 add %esi,%ebx
c90: 21 c3 and %eax,%ebx
for (s = 0; s < (size_t)tableSize; s += unroll) {
c92: 48 83 c5 02 add $0x2,%rbp
c96: 4c 39 d5 cmp %r10,%rbp
c99: 72 d5 jb c70 <ZSTD_buildFSETable_body_bmi2+0x3b0>
c9b: 41 83 c1 01 add $0x1,%r9d
c9f: 4c 8b 54 24 c0 mov -0x40(%rsp),%r10
for (u=0; u<tableSize; u++) {
ca4: 41 83 fa 01 cmp $0x1,%r10d
ca8: b8 01 00 00 00 mov $0x1,%eax
cad: 41 0f 47 c2 cmova %r10d,%eax
cb1: 31 c9 xor %ecx,%ecx
cb3: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
cba: 00 00 00
cbd: 0f 1f 00 nopl (%rax)
U32 const symbol = tableDecode[u].baseValue;
cc0: 8b 54 cf 0c mov 0xc(%rdi,%rcx,8),%edx
U32 const nextState = symbolNext[symbol]++;
cc4: 41 0f b7 34 53 movzwl (%r11,%rdx,2),%esi
cc9: 8d 6e 01 lea 0x1(%rsi),%ebp
ccc: 66 41 89 2c 53 mov %bp,(%r11,%rdx,2)
cd1: 0f bd ee bsr %esi,%ebp
cd4: f7 d5 not %ebp
cd6: 81 cd e0 00 00 00 or $0xe0,%ebp
tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
cdc: 44 01 cd add %r9d,%ebp
cdf: 40 88 6c cf 0b mov %bpl,0xb(%rdi,%rcx,8)
tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
ce4: c4 e2 51 f7 f6 shlx %ebp,%esi,%esi
ce9: 44 29 d6 sub %r10d,%esi
cec: 66 89 74 cf 08 mov %si,0x8(%rdi,%rcx,8)
tableDecode[u].nbAdditionalBits = (BYTE)nbAdditionalBits[symbol];
cf1: 41 0f b6 1c 90 movzbl (%r8,%rdx,4),%ebx
cf6: 88 5c cf 0a mov %bl,0xa(%rdi,%rcx,8)
tableDecode[u].baseValue = baseValue[symbol];
cfa: 41 8b 14 94 mov (%r12,%rdx,4),%edx
cfe: 89 54 cf 0c mov %edx,0xc(%rdi,%rcx,8)
for (u=0; u<tableSize; u++) {
d02: 48 83 c1 01 add $0x1,%rcx
d06: 48 39 c8 cmp %rcx,%rax
d09: 75 b5 jne cc0 <ZSTD_buildFSETable_body_bmi2+0x400>
}
d0b: 5b pop %rbx
d0c: 41 5c pop %r12
d0e: 41 5d pop %r13
d10: 41 5e pop %r14
d12: 41 5f pop %r15
d14: 5d pop %rbp
d15: c3 retq
d16: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
d1d: 00 00 00
0000000000000d20 <ZSTD_decodeSeqHeaders>:
}
}
size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
const void* src, size_t srcSize)
{
d20: 55 push %rbp
d21: 41 57 push %r15
d23: 41 56 push %r14
d25: 41 55 push %r13
d27: 41 54 push %r12
d29: 53 push %rbx
d2a: 48 83 ec 18 sub $0x18,%rsp
d2e: 49 c7 c7 b8 ff ff ff mov $0xffffffffffffffb8,%r15
const BYTE* ip = istart;
int nbSeq;
DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
/* check */
RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, "");
d35: 48 85 c9 test %rcx,%rcx
d38: 0f 84 e3 01 00 00 je f21 <ZSTD_decodeSeqHeaders+0x201>
d3e: 48 89 cb mov %rcx,%rbx
d41: 49 89 d6 mov %rdx,%r14
/* SeqHead */
nbSeq = *ip++;
d44: 44 0f b6 2a movzbl (%rdx),%r13d
d48: 45 85 ed test %r13d,%r13d
if (!nbSeq) {
d4b: 0f 84 bb 01 00 00 je f0c <ZSTD_decodeSeqHeaders+0x1ec>
d51: 49 89 fc mov %rdi,%r12
*nbSeqPtr=0;
RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, "");
return 1;
}
if (nbSeq > 0x7F) {
d54: 45 84 ed test %r13b,%r13b
d57: 0f 88 d6 01 00 00 js f33 <ZSTD_decodeSeqHeaders+0x213>
d5d: 49 8d 46 01 lea 0x1(%r14),%rax
d61: 4c 01 f3 add %r14,%rbx
} else {
RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
nbSeq = ((nbSeq-0x80)<<8) + *ip++;
}
}
*nbSeqPtr = nbSeq;
d64: 44 89 2e mov %r13d,(%rsi)
/* FSE table descriptors */
RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */
d67: 48 8d 68 01 lea 0x1(%rax),%rbp
d6b: 48 39 dd cmp %rbx,%rbp
d6e: 0f 87 ad 01 00 00 ja f21 <ZSTD_decodeSeqHeaders+0x201>
{ symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
d74: 0f b6 10 movzbl (%rax),%edx
d77: 89 54 24 04 mov %edx,0x4(%rsp)
d7b: c1 ea 06 shr $0x6,%edx
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
ip++;
/* Build DTables */
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
d7e: 49 8d 7c 24 20 lea 0x20(%r12),%rdi
LLtype, MaxLL, LLFSELog,
ip, iend-ip,
d83: 48 89 d8 mov %rbx,%rax
d86: 48 29 e8 sub %rbp,%rax
LL_base, LL_bits,
LL_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq,
d89: 45 8b 94 24 f4 75 00 mov 0x75f4(%r12),%r10d
d90: 00
dctx->workspace, sizeof(dctx->workspace),
d91: 4d 8d 9c 24 bc 6a 00 lea 0x6abc(%r12),%r11
d98: 00
LL_defaultDTable, dctx->fseEntropy,
d99: 41 8b 8c 24 2c 75 00 mov 0x752c(%r12),%ecx
da0: 00
da1: 48 89 4c 24 08 mov %rcx,0x8(%rsp)
dctx->bmi2);
da6: 45 8b bc 24 d8 75 00 mov 0x75d8(%r12),%r15d
dad: 00
{ size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
dae: 48 83 ec 08 sub $0x8,%rsp
db2: 4c 89 e6 mov %r12,%rsi
db5: b9 23 00 00 00 mov $0x23,%ecx
dba: 41 b8 09 00 00 00 mov $0x9,%r8d
dc0: 49 89 e9 mov %rbp,%r9
dc3: 41 57 push %r15
dc5: 4c 89 5c 24 20 mov %r11,0x20(%rsp)
dca: 41 53 push %r11
dcc: 41 55 push %r13
dce: 41 52 push %r10
dd0: ff 74 24 30 pushq 0x30(%rsp)
dd4: 68 00 00 00 00 pushq $0x0
dd9: 68 00 00 00 00 pushq $0x0
dde: 68 00 00 00 00 pushq $0x0
de3: 50 push %rax
de4: e8 97 01 00 00 callq f80 <ZSTD_buildSeqTable>
de9: 48 83 c4 50 add $0x50,%rsp
RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, "ZSTD_buildSeqTable failed");
ded: 4c 8d 0c 28 lea (%rax,%rbp,1),%r9
df1: 48 83 f8 89 cmp $0xffffffffffffff89,%rax
df5: 4c 0f 43 cd cmovae %rbp,%r9
df9: 49 c7 c7 ec ff ff ff mov $0xffffffffffffffec,%r15
e00: 48 83 f8 88 cmp $0xffffffffffffff88,%rax
e04: 0f 87 17 01 00 00 ja f21 <ZSTD_decodeSeqHeaders+0x201>
e0a: 8b 54 24 04 mov 0x4(%rsp),%edx
symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
e0e: c1 ea 04 shr $0x4,%edx
e11: 83 e2 03 and $0x3,%edx
ip += llhSize;
}
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
e14: 49 8d bc 24 28 10 00 lea 0x1028(%r12),%rdi
e1b: 00
e1c: 49 8d 74 24 10 lea 0x10(%r12),%rsi
OFtype, MaxOff, OffFSELog,
ip, iend-ip,
e21: 48 89 d8 mov %rbx,%rax
e24: 4c 29 c8 sub %r9,%rax
OF_base, OF_bits,
OF_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq,
e27: 45 8b 9c 24 f4 75 00 mov 0x75f4(%r12),%r11d
e2e: 00
OF_defaultDTable, dctx->fseEntropy,
e2f: 41 8b 8c 24 2c 75 00 mov 0x752c(%r12),%ecx
e36: 00
e37: 48 89 4c 24 08 mov %rcx,0x8(%rsp)
dctx->workspace, sizeof(dctx->workspace),
dctx->bmi2);
e3c: 45 8b 94 24 d8 75 00 mov 0x75d8(%r12),%r10d
e43: 00
{ size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
e44: 48 83 ec 08 sub $0x8,%rsp
e48: b9 1f 00 00 00 mov $0x1f,%ecx
e4d: 41 b8 08 00 00 00 mov $0x8,%r8d
e53: 4c 89 cd mov %r9,%rbp
e56: 41 52 push %r10
e58: ff 74 24 20 pushq 0x20(%rsp)
e5c: 41 55 push %r13
e5e: 41 53 push %r11
e60: ff 74 24 30 pushq 0x30(%rsp)
e64: 68 00 00 00 00 pushq $0x0
e69: 68 00 00 00 00 pushq $0x0
e6e: 68 00 00 00 00 pushq $0x0
e73: 50 push %rax
e74: e8 07 01 00 00 callq f80 <ZSTD_buildSeqTable>
e79: 48 83 c4 50 add $0x50,%rsp
RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed");
e7d: 4c 8d 0c 28 lea (%rax,%rbp,1),%r9
e81: 48 83 f8 89 cmp $0xffffffffffffff89,%rax
e85: 4c 0f 43 cd cmovae %rbp,%r9
e89: 48 83 f8 88 cmp $0xffffffffffffff88,%rax
e8d: 0f 87 8e 00 00 00 ja f21 <ZSTD_decodeSeqHeaders+0x201>
e93: 8b 54 24 04 mov 0x4(%rsp),%edx
e97: c1 ea 02 shr $0x2,%edx
e9a: 83 e2 03 and $0x3,%edx
ip += ofhSize;
}
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
e9d: 49 8d bc 24 30 18 00 lea 0x1830(%r12),%rdi
ea4: 00
ea5: 49 8d 74 24 08 lea 0x8(%r12),%rsi
MLtype, MaxML, MLFSELog,
ip, iend-ip,
eaa: 4c 29 cb sub %r9,%rbx
ML_base, ML_bits,
ML_defaultDTable, dctx->fseEntropy,
dctx->ddictIsCold, nbSeq,
ead: 45 8b 9c 24 f4 75 00 mov 0x75f4(%r12),%r11d
eb4: 00
ML_defaultDTable, dctx->fseEntropy,
eb5: 45 8b 94 24 2c 75 00 mov 0x752c(%r12),%r10d
ebc: 00
dctx->workspace, sizeof(dctx->workspace),
dctx->bmi2);
ebd: 41 8b 84 24 d8 75 00 mov 0x75d8(%r12),%eax
ec4: 00
{ size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
ec5: 48 83 ec 08 sub $0x8,%rsp
ec9: b9 34 00 00 00 mov $0x34,%ecx
ece: 41 b8 09 00 00 00 mov $0x9,%r8d
ed4: 4c 89 cd mov %r9,%rbp
ed7: 50 push %rax
ed8: ff 74 24 20 pushq 0x20(%rsp)
edc: 41 55 push %r13
ede: 41 53 push %r11
ee0: 41 52 push %r10
ee2: 68 00 00 00 00 pushq $0x0
ee7: 68 00 00 00 00 pushq $0x0
eec: 68 00 00 00 00 pushq $0x0
ef1: 53 push %rbx
ef2: e8 89 00 00 00 callq f80 <ZSTD_buildSeqTable>
ef7: 48 83 c4 50 add $0x50,%rsp
efb: 48 83 f8 88 cmp $0xffffffffffffff88,%rax
eff: 77 20 ja f21 <ZSTD_decodeSeqHeaders+0x201>
f01: 49 89 ef mov %rbp,%r15
RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed");
f04: 49 01 c7 add %rax,%r15
ip += mlhSize;
}
}
return ip-istart;
f07: 4d 29 f7 sub %r14,%r15
f0a: eb 15 jmp f21 <ZSTD_decodeSeqHeaders+0x201>
*nbSeqPtr=0;
f0c: c7 06 00 00 00 00 movl $0x0,(%rsi)
RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, "");
f12: 48 83 fb 01 cmp $0x1,%rbx
f16: 49 c7 c7 b8 ff ff ff mov $0xffffffffffffffb8,%r15
f1d: 4c 0f 44 fb cmove %rbx,%r15
}
f21: 4c 89 f8 mov %r15,%rax
f24: 48 83 c4 18 add $0x18,%rsp
f28: 5b pop %rbx
f29: 41 5c pop %r12
f2b: 41 5d pop %r13
f2d: 41 5e pop %r14
f2f: 41 5f pop %r15
f31: 5d pop %rbp
f32: c3 retq
if (nbSeq == 0xFF) {
f33: 41 80 fd ff cmp $0xff,%r13b
f37: 74 22 je f5b <ZSTD_decodeSeqHeaders+0x23b>
RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
f39: 48 83 fb 02 cmp $0x2,%rbx
f3d: 7c e2 jl f21 <ZSTD_decodeSeqHeaders+0x201>
nbSeq = ((nbSeq-0x80)<<8) + *ip++;
f3f: 41 c1 e5 08 shl $0x8,%r13d
f43: 49 8d 46 02 lea 0x2(%r14),%rax
f47: 41 0f b6 4e 01 movzbl 0x1(%r14),%ecx
f4c: 41 01 cd add %ecx,%r13d
f4f: 41 81 c5 00 80 ff ff add $0xffff8000,%r13d
f56: e9 06 fe ff ff jmpq d61 <ZSTD_decodeSeqHeaders+0x41>
RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, "");
f5b: 48 83 fb 03 cmp $0x3,%rbx
f5f: 7c c0 jl f21 <ZSTD_decodeSeqHeaders+0x201>
f61: 49 8d 46 03 lea 0x3(%r14),%rax
MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
f65: 45 0f b7 6e 01 movzwl 0x1(%r14),%r13d
nbSeq = MEM_readLE16(ip) + LONGNBSEQ;
f6a: 41 81 c5 00 7f 00 00 add $0x7f00,%r13d
f71: e9 eb fd ff ff jmpq d61 <ZSTD_decodeSeqHeaders+0x41>
f76: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
f7d: 00 00 00
0000000000000f80 <ZSTD_buildSeqTable>:
{
f80: 55 push %rbp
f81: 41 57 push %r15
f83: 41 56 push %r14
f85: 41 55 push %r13
f87: 41 54 push %r12
f89: 53 push %rbx
f8a: 48 81 ec 98 00 00 00 sub $0x98,%rsp
f91: 89 4c 24 18 mov %ecx,0x18(%rsp)
switch(type)
f95: 83 fa 03 cmp $0x3,%edx
f98: 77 3c ja fd6 <ZSTD_buildSeqTable+0x56>
f9a: 44 89 c5 mov %r8d,%ebp
f9d: 49 89 f6 mov %rsi,%r14
fa0: 48 89 fb mov %rdi,%rbx
fa3: 4c 8b bc 24 e0 00 00 mov 0xe0(%rsp),%r15
faa: 00
fab: 4c 8b a4 24 d8 00 00 mov 0xd8(%rsp),%r12
fb2: 00
fb3: 4c 8b 84 24 d0 00 00 mov 0xd0(%rsp),%r8
fba: 00
fbb: 89 d0 mov %edx,%eax
fbd: ff 24 c5 00 00 00 00 jmpq *0x0(,%rax,8)
fc4: 48 8b 84 24 e8 00 00 mov 0xe8(%rsp),%rax
fcb: 00
*DTablePtr = defaultTable;
fcc: 49 89 06 mov %rax,(%r14)
fcf: 31 c0 xor %eax,%eax
fd1: e9 29 01 00 00 jmpq 10ff <ZSTD_buildSeqTable+0x17f>
fd6: 48 c7 c0 ff ff ff ff mov $0xffffffffffffffff,%rax
fdd: e9 1d 01 00 00 jmpq 10ff <ZSTD_buildSeqTable+0x17f>
RETURN_ERROR_IF(!srcSize, srcSize_wrong, "");
fe2: 4d 85 c0 test %r8,%r8
fe5: 0f 84 04 01 00 00 je 10ef <ZSTD_buildSeqTable+0x16f>
RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, "");
feb: 41 0f b6 11 movzbl (%r9),%edx
fef: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax
ff6: 39 ca cmp %ecx,%edx
ff8: 0f 87 01 01 00 00 ja 10ff <ZSTD_buildSeqTable+0x17f>
U32 const baseline = baseValue[symbol];
ffe: 41 8b 04 94 mov (%r12,%rdx,4),%eax
U32 const nbBits = nbAdditionalBits[symbol];
1002: 41 8a 0c 97 mov (%r15,%rdx,4),%cl
DTableH->fastMode = 0;
1006: 48 c7 03 00 00 00 00 movq $0x0,(%rbx)
cell->nbBits = 0;
100d: c6 43 0b 00 movb $0x0,0xb(%rbx)
cell->nextState = 0;
1011: 66 c7 43 08 00 00 movw $0x0,0x8(%rbx)
cell->nbAdditionalBits = (BYTE)nbAddBits;
1017: 88 4b 0a mov %cl,0xa(%rbx)
cell->baseValue = baseValue;
101a: 89 43 0c mov %eax,0xc(%rbx)
*DTablePtr = DTableSpace;
101d: 49 89 1e mov %rbx,(%r14)
1020: b8 01 00 00 00 mov $0x1,%eax
1025: e9 d5 00 00 00 jmpq 10ff <ZSTD_buildSeqTable+0x17f>
102a: 48 8d 7c 24 20 lea 0x20(%rsp),%rdi
102f: 48 8d 74 24 18 lea 0x18(%rsp),%rsi
1034: 48 8d 54 24 1c lea 0x1c(%rsp),%rdx
size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
1039: 4c 89 c9 mov %r9,%rcx
103c: e8 00 00 00 00 callq 1041 <ZSTD_buildSeqTable+0xc1>
1041: 49 89 c5 mov %rax,%r13
1044: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax
104b: 49 83 fd 88 cmp $0xffffffffffffff88,%r13
RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, "");
104f: 0f 87 aa 00 00 00 ja 10ff <ZSTD_buildSeqTable+0x17f>
RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, "");
1055: 44 8b 4c 24 1c mov 0x1c(%rsp),%r9d
105a: 41 39 e9 cmp %ebp,%r9d
105d: 0f 87 9c 00 00 00 ja 10ff <ZSTD_buildSeqTable+0x17f>
1063: 8b 84 24 10 01 00 00 mov 0x110(%rsp),%eax
106a: 48 8b 8c 24 08 01 00 mov 0x108(%rsp),%rcx
1071: 00
ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2);
1072: 8b 54 24 18 mov 0x18(%rsp),%edx
1076: 89 44 24 10 mov %eax,0x10(%rsp)
107a: 48 89 0c 24 mov %rcx,(%rsp)
107e: 48 8d 74 24 20 lea 0x20(%rsp),%rsi
1083: 48 89 df mov %rbx,%rdi
1086: 4c 89 e1 mov %r12,%rcx
1089: 4d 89 f8 mov %r15,%r8
108c: e8 00 00 00 00 callq 1091 <ZSTD_buildSeqTable+0x111>
*DTablePtr = DTableSpace;
1091: 49 89 1e mov %rbx,(%r14)
1094: 4c 89 e8 mov %r13,%rax
1097: eb 66 jmp 10ff <ZSTD_buildSeqTable+0x17f>
RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, "");
1099: 83 bc 24 f0 00 00 00 cmpl $0x0,0xf0(%rsp)
10a0: 00
10a1: 74 55 je 10f8 <ZSTD_buildSeqTable+0x178>
10a3: 31 c0 xor %eax,%eax
if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
10a5: 83 bc 24 f8 00 00 00 cmpl $0x0,0xf8(%rsp)
10ac: 00
10ad: 74 50 je 10ff <ZSTD_buildSeqTable+0x17f>
10af: 83 bc 24 00 01 00 00 cmpl $0x19,0x100(%rsp)
10b6: 19
10b7: 7c 46 jl 10ff <ZSTD_buildSeqTable+0x17f>
10b9: b8 01 00 00 00 mov $0x1,%eax
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
10be: 89 e9 mov %ebp,%ecx
10c0: d3 e0 shl %cl,%eax
const void* const pStart = *DTablePtr;
10c2: 49 8b 0e mov (%r14),%rcx
size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
10c5: 48 8d 14 c5 08 00 00 lea 0x8(,%rax,8),%rdx
10cc: 00
10cd: 31 c0 xor %eax,%eax
10cf: 31 f6 xor %esi,%esi
10d1: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
10d8: 00 00 00
10db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
PREFETCH_AREA(pStart, pSize);
10e0: 0f 18 14 31 prefetcht1 (%rcx,%rsi,1)
10e4: 48 83 c6 40 add $0x40,%rsi
10e8: 48 39 d6 cmp %rdx,%rsi
10eb: 72 f3 jb 10e0 <ZSTD_buildSeqTable+0x160>
10ed: eb 10 jmp 10ff <ZSTD_buildSeqTable+0x17f>
10ef: 48 c7 c0 b8 ff ff ff mov $0xffffffffffffffb8,%rax
10f6: eb 07 jmp 10ff <ZSTD_buildSeqTable+0x17f>
10f8: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax
}
10ff: 48 81 c4 98 00 00 00 add $0x98,%rsp
1106: 5b pop %rbx
1107: 41 5c pop %r12
1109: 41 5d pop %r13
110b: 41 5e pop %r14
110d: 41 5f pop %r15
110f: 5d pop %rbp
1110: c3 retq
1111: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1118: 00 00 00
111b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
0000000000001120 <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 */
1120: 55 push %rbp
1121: 41 57 push %r15
1123: 41 56 push %r14
1125: 41 55 push %r13
1127: 41 54 push %r12
1129: 53 push %rbx
112a: 48 81 ec 28 02 00 00 sub $0x228,%rsp
1131: 49 c7 c3 b8 ff ff ff mov $0xffffffffffffffb8,%r11
* (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, "");
1138: 49 81 f8 ff ff 01 00 cmp $0x1ffff,%r8
113f: 0f 87 e3 23 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
1145: 44 89 cb mov %r9d,%ebx
1148: 4d 89 c4 mov %r8,%r12
114b: 48 89 cd mov %rcx,%rbp
114e: 49 89 d7 mov %rdx,%r15
1151: 49 89 f6 mov %rsi,%r14
/* Decode literals section */
{ size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
1154: 48 89 ce mov %rcx,%rsi
1157: 4c 89 c2 mov %r8,%rdx
115a: 48 89 7c 24 20 mov %rdi,0x20(%rsp)
115f: e8 00 00 00 00 callq 1164 <ZSTD_decompressBlock_internal+0x44>
1164: 48 8b 7c 24 20 mov 0x20(%rsp),%rdi
1169: 49 89 c3 mov %rax,%r11
DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
if (ZSTD_isError(litCSize)) return litCSize;
116c: 4c 8d 2c 28 lea (%rax,%rbp,1),%r13
1170: 31 c0 xor %eax,%eax
1172: 49 83 fb 89 cmp $0xffffffffffffff89,%r11
1176: 4c 0f 43 ed cmovae %rbp,%r13
117a: 49 0f 42 c3 cmovb %r11,%rax
117e: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
1182: 0f 87 a0 23 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
1188: 49 29 c4 sub %rax,%r12
* we use. If neither is defined, we do some inspection and dispatch at
* runtime.
*/
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
int usePrefetchDecoder = dctx->ddictIsCold;
118b: 8b af f4 75 00 00 mov 0x75f4(%rdi),%ebp
1191: 48 8d b4 24 fc 01 00 lea 0x1fc(%rsp),%rsi
1198: 00
#endif
int nbSeq;
size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
1199: 4c 89 ea mov %r13,%rdx
119c: 4c 89 e1 mov %r12,%rcx
119f: e8 00 00 00 00 callq 11a4 <ZSTD_decompressBlock_internal+0x84>
11a4: 49 89 c3 mov %rax,%r11
11a7: 48 83 f8 88 cmp $0xffffffffffffff88,%rax
if (ZSTD_isError(seqHSize)) return seqHSize;
11ab: 0f 87 77 23 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
11b1: 44 8b 8c 24 fc 01 00 mov 0x1fc(%rsp),%r9d
11b8: 00
ip += seqHSize;
srcSize -= seqHSize;
RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled");
11b9: 4d 85 f6 test %r14,%r14
11bc: 75 10 jne 11ce <ZSTD_decompressBlock_internal+0xae>
11be: 49 c7 c3 ba ff ff ff mov $0xffffffffffffffba,%r11
11c5: 45 85 c9 test %r9d,%r9d
11c8: 0f 8f 5a 23 00 00 jg 3528 <ZSTD_decompressBlock_internal+0x2408>
11ce: 49 01 c5 add %rax,%r13
11d1: 49 29 c4 sub %rax,%r12
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
if ( !usePrefetchDecoder
11d4: 85 ed test %ebp,%ebp
&& (!frame || (dctx->fParams.windowSize > (1<<24)))
11d6: 74 3a je 1212 <ZSTD_decompressBlock_internal+0xf2>
11d8: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
usePrefetchDecoder = (shareLongOffsets >= minShare);
}
#endif
dctx->ddictIsCold = 0;
11dd: 41 c7 82 f4 75 00 00 movl $0x0,0x75f4(%r10)
11e4: 00 00 00 00
11e8: 4c 89 fa mov %r15,%rdx
if (dctx->bmi2) {
11eb: 41 83 ba d8 75 00 00 cmpl $0x0,0x75d8(%r10)
11f2: 00
11f3: 0f 84 96 00 00 00 je 128f <ZSTD_decompressBlock_internal+0x16f>
return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
11f9: 4c 89 d7 mov %r10,%rdi
11fc: 4c 89 f6 mov %r14,%rsi
11ff: 4c 89 e9 mov %r13,%rcx
1202: 4d 89 e0 mov %r12,%r8
1205: e8 56 24 00 00 callq 3660 <ZSTD_decompressSequencesLong_bmi2>
120a: 49 89 c3 mov %rax,%r11
120d: e9 16 23 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
&& (!frame || (dctx->fParams.windowSize > (1<<24)))
1212: 85 db test %ebx,%ebx
1214: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
1219: 0f 84 7e 01 00 00 je 139d <ZSTD_decompressBlock_internal+0x27d>
121f: 41 83 f9 09 cmp $0x9,%r9d
&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */
1223: 0f 8c 7e 01 00 00 jl 13a7 <ZSTD_decompressBlock_internal+0x287>
1229: 49 81 ba f0 74 00 00 cmpq $0x1000000,0x74f0(%r10)
1230: 00 00 00 01
1234: 0f 86 6d 01 00 00 jbe 13a7 <ZSTD_decompressBlock_internal+0x287>
U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
123a: 49 8b 42 10 mov 0x10(%r10),%rax
U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
123e: 8b 48 04 mov 0x4(%rax),%ecx
1241: 31 d2 xor %edx,%edx
1243: be 01 00 00 00 mov $0x1,%esi
1248: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
124f: 00
if (table[u].nbAdditionalBits > 22) total += 1;
1250: 8d 7e ff lea -0x1(%rsi),%edi
1253: 31 ed xor %ebp,%ebp
1255: 80 7c f8 0a 16 cmpb $0x16,0xa(%rax,%rdi,8)
125a: 40 0f 97 c5 seta %bpl
for (u=0; u<max; u++) {
125e: 89 f7 mov %esi,%edi
1260: d3 ef shr %cl,%edi
if (table[u].nbAdditionalBits > 22) total += 1;
1262: 01 ea add %ebp,%edx
for (u=0; u<max; u++) {
1264: 83 c6 01 add $0x1,%esi
1267: 85 ff test %edi,%edi
1269: 74 e5 je 1250 <ZSTD_decompressBlock_internal+0x130>
126b: b0 08 mov $0x8,%al
total <<= (OffFSELog - tableLog); /* scale to OffFSELog */
126d: 28 c8 sub %cl,%al
126f: 89 c1 mov %eax,%ecx
1271: d3 e2 shl %cl,%edx
dctx->ddictIsCold = 0;
1273: 41 c7 82 f4 75 00 00 movl $0x0,0x75f4(%r10)
127a: 00 00 00 00
usePrefetchDecoder = (shareLongOffsets >= minShare);
127e: 83 fa 07 cmp $0x7,%edx
1281: 4c 89 fa mov %r15,%rdx
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
if (usePrefetchDecoder)
1284: 0f 83 61 ff ff ff jae 11eb <ZSTD_decompressBlock_internal+0xcb>
128a: e9 26 01 00 00 jmpq 13b5 <ZSTD_decompressBlock_internal+0x295>
BYTE* const oend = ostart + maxDstSize;
128f: 4c 01 f2 add %r14,%rdx
const BYTE* litPtr = dctx->litPtr;
1292: 49 8b b2 a0 75 00 00 mov 0x75a0(%r10),%rsi
1299: 48 89 b4 24 e0 00 00 mov %rsi,0xe0(%rsp)
12a0: 00
12a1: 49 8b 82 c0 75 00 00 mov 0x75c0(%r10),%rax
const BYTE* const litEnd = litPtr + dctx->litSize;
12a8: 48 01 f0 add %rsi,%rax
BYTE* op = ostart;
12ab: 4c 89 f7 mov %r14,%rdi
if (nbSeq) {
12ae: 45 85 c9 test %r9d,%r9d
12b1: 0f 84 c0 21 00 00 je 3477 <ZSTD_decompressBlock_internal+0x2357>
12b7: 49 8b ba c8 74 00 00 mov 0x74c8(%r10),%rdi
12be: 49 8b 8a d0 74 00 00 mov 0x74d0(%r10),%rcx
12c5: 48 89 8c 24 d0 01 00 mov %rcx,0x1d0(%rsp)
12cc: 00
12cd: 49 8b 8a d8 74 00 00 mov 0x74d8(%r10),%rcx
12d4: 48 89 4c 24 38 mov %rcx,0x38(%rsp)
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
12d9: 41 83 f9 09 cmp $0x9,%r9d
dctx->fseEntropy = 1;
12dd: 41 c7 82 2c 75 00 00 movl $0x1,0x752c(%r10)
12e4: 01 00 00 00
{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
12e8: 45 8b ba 3c 68 00 00 mov 0x683c(%r10),%r15d
12ef: 4c 89 bc 24 b8 00 00 mov %r15,0xb8(%rsp)
12f6: 00
12f7: f2 41 0f 10 82 40 68 movsd 0x6840(%r10),%xmm0
12fe: 00 00
1300: 0f 57 c9 xorps %xmm1,%xmm1
1303: 0f 14 c1 unpcklps %xmm1,%xmm0
1306: 0f 11 84 24 c0 00 00 movups %xmm0,0xc0(%rsp)
130d: 00
130e: b9 08 00 00 00 mov $0x8,%ecx
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
1313: 41 0f 4c c9 cmovl %r9d,%ecx
1317: 89 8c 24 ec 00 00 00 mov %ecx,0xec(%rsp)
* `srcSize` must be the *exact* size of the bitStream, in bytes.
* @return : size of stream (== srcSize), or an errorCode if a problem is detected
*/
MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
{
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
131e: 4d 85 e4 test %r12,%r12
1321: 0f 84 c0 01 00 00 je 14e7 <ZSTD_decompressBlock_internal+0x3c7>
1327: 48 89 84 24 f8 00 00 mov %rax,0xf8(%rsp)
132e: 00
bitD->start = (const char*)srcBuffer;
132f: 4c 89 6c 24 78 mov %r13,0x78(%rsp)
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
1334: 49 8d 45 08 lea 0x8(%r13),%rax
1338: 48 89 84 24 80 00 00 mov %rax,0x80(%rsp)
133f: 00
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
1340: 49 83 fc 08 cmp $0x8,%r12
1344: 48 89 54 24 18 mov %rdx,0x18(%rsp)
1349: 0f 82 b3 01 00 00 jb 1502 <ZSTD_decompressBlock_internal+0x3e2>
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
134f: 4b 8d 04 2c lea (%r12,%r13,1),%rax
1353: 48 83 c0 f8 add $0xfffffffffffffff8,%rax
1357: 48 89 44 24 70 mov %rax,0x70(%rsp)
MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
135c: 4b 8b 5c 25 f8 mov -0x8(%r13,%r12,1),%rbx
bitD->bitContainer = MEM_readLEST(bitD->ptr);
1361: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
1366: 43 0f b6 44 2c ff movzbl -0x1(%r12,%r13,1),%eax
136c: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
136e: 0f 84 b0 02 00 00 je 1624 <ZSTD_decompressBlock_internal+0x504>
return __builtin_clz (val) ^ 31;
1374: 0f bd c0 bsr %eax,%eax
1377: f7 d0 not %eax
1379: 83 c8 e0 or $0xffffffe0,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
137c: 83 c0 09 add $0x9,%eax
137f: 89 44 24 68 mov %eax,0x68(%rsp)
1383: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
138a: 49 83 fc 88 cmp $0xffffffffffffff88,%r12
RETURN_ERROR_IF(
138e: 0f 87 94 21 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
1394: 49 83 c4 f8 add $0xfffffffffffffff8,%r12
1398: e9 13 02 00 00 jmpq 15b0 <ZSTD_decompressBlock_internal+0x490>
&& (nbSeq>ADVANCED_SEQS) ) { /* could probably use a larger nbSeq limit */
139d: 41 83 f9 09 cmp $0x9,%r9d
if ( !usePrefetchDecoder
13a1: 0f 8d 93 fe ff ff jge 123a <ZSTD_decompressBlock_internal+0x11a>
dctx->ddictIsCold = 0;
13a7: 41 c7 82 f4 75 00 00 movl $0x0,0x75f4(%r10)
13ae: 00 00 00 00
13b2: 4c 89 fa mov %r15,%rdx
if (dctx->bmi2) {
13b5: 41 83 ba d8 75 00 00 cmpl $0x0,0x75d8(%r10)
13bc: 00
13bd: 74 19 je 13d8 <ZSTD_decompressBlock_internal+0x2b8>
return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
13bf: 4c 89 d7 mov %r10,%rdi
13c2: 4c 89 f6 mov %r14,%rsi
13c5: 4c 89 e9 mov %r13,%rcx
13c8: 4d 89 e0 mov %r12,%r8
13cb: e8 b0 42 00 00 callq 5680 <ZSTD_decompressSequences_bmi2>
13d0: 49 89 c3 mov %rax,%r11
13d3: e9 50 21 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
BYTE* const oend = ostart + maxDstSize;
13d8: 4c 01 f2 add %r14,%rdx
const BYTE* litPtr = dctx->litPtr;
13db: 49 8b b2 a0 75 00 00 mov 0x75a0(%r10),%rsi
13e2: 48 89 74 24 60 mov %rsi,0x60(%rsp)
13e7: 49 8b 9a c0 75 00 00 mov 0x75c0(%r10),%rbx
const BYTE* const litEnd = litPtr + dctx->litSize;
13ee: 48 01 f3 add %rsi,%rbx
13f1: 4c 89 74 24 40 mov %r14,0x40(%rsp)
if (nbSeq) {
13f6: 45 85 c9 test %r9d,%r9d
13f9: 0f 84 1b 0f 00 00 je 231a <ZSTD_decompressBlock_internal+0x11fa>
13ff: 49 8b 8a c8 74 00 00 mov 0x74c8(%r10),%rcx
1406: 49 8b 82 d0 74 00 00 mov 0x74d0(%r10),%rax
140d: 48 89 44 24 50 mov %rax,0x50(%rsp)
1412: 49 8b 82 d8 74 00 00 mov 0x74d8(%r10),%rax
1419: 48 89 84 24 f0 00 00 mov %rax,0xf0(%rsp)
1420: 00
dctx->fseEntropy = 1;
1421: 41 c7 82 2c 75 00 00 movl $0x1,0x752c(%r10)
1428: 01 00 00 00
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
142c: f2 41 0f 10 8a 3c 68 movsd 0x683c(%r10),%xmm1
1433: 00 00
1435: 0f 57 c0 xorps %xmm0,%xmm0
1438: 0f 14 c8 unpcklps %xmm0,%xmm1
143b: 0f 11 8c 24 58 01 00 movups %xmm1,0x158(%rsp)
1442: 00
1443: 41 8b 82 44 68 00 00 mov 0x6844(%r10),%eax
144a: 48 89 84 24 68 01 00 mov %rax,0x168(%rsp)
1451: 00
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
1452: 4d 85 e4 test %r12,%r12
1455: 0f 84 d6 01 00 00 je 1631 <ZSTD_decompressBlock_internal+0x511>
bitD->start = (const char*)srcBuffer;
145b: 4c 89 ac 24 18 01 00 mov %r13,0x118(%rsp)
1462: 00
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
1463: 49 8d 45 08 lea 0x8(%r13),%rax
1467: 48 89 84 24 20 01 00 mov %rax,0x120(%rsp)
146e: 00
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
146f: 49 83 fc 08 cmp $0x8,%r12
1473: 48 89 5c 24 58 mov %rbx,0x58(%rsp)
1478: 0f 82 d4 01 00 00 jb 1652 <ZSTD_decompressBlock_internal+0x532>
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
147e: 4b 8d 04 2c lea (%r12,%r13,1),%rax
1482: 48 83 c0 f8 add $0xfffffffffffffff8,%rax
1486: 48 89 84 24 10 01 00 mov %rax,0x110(%rsp)
148d: 00
148e: 4f 8b 54 25 f8 mov -0x8(%r13,%r12,1),%r10
bitD->bitContainer = MEM_readLEST(bitD->ptr);
1493: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
149a: 00
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
149b: 43 0f b6 44 2c ff movzbl -0x1(%r12,%r13,1),%eax
14a1: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
14a3: 0f 84 6d 20 00 00 je 3516 <ZSTD_decompressBlock_internal+0x23f6>
return __builtin_clz (val) ^ 31;
14a9: 44 0f bd f8 bsr %eax,%r15d
14ad: 41 f7 d7 not %r15d
14b0: 41 83 cf e0 or $0xffffffe0,%r15d
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
14b4: 41 83 c7 09 add $0x9,%r15d
14b8: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
14bf: 00
14c0: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
14c7: 49 83 fc 88 cmp $0xffffffffffffff88,%r12
RETURN_ERROR_IF(
14cb: 0f 87 57 20 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
14d1: 49 89 cb mov %rcx,%r11
14d4: 48 89 54 24 18 mov %rdx,0x18(%rsp)
14d9: 49 83 c4 f8 add $0xfffffffffffffff8,%r12
14dd: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
14e2: e9 4a 02 00 00 jmpq 1731 <ZSTD_decompressBlock_internal+0x611>
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
14e7: 0f 29 4c 24 70 movaps %xmm1,0x70(%rsp)
14ec: 0f 29 4c 24 60 movaps %xmm1,0x60(%rsp)
14f1: 48 c7 84 24 80 00 00 movq $0x0,0x80(%rsp)
14f8: 00 00 00 00 00
14fd: e9 1f 20 00 00 jmpq 3521 <ZSTD_decompressBlock_internal+0x2401>
if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
} else {
bitD->ptr = bitD->start;
1502: 4c 89 6c 24 70 mov %r13,0x70(%rsp)
bitD->bitContainer = *(const BYTE*)(bitD->start);
1507: 41 0f b6 5d 00 movzbl 0x0(%r13),%ebx
150c: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
switch(srcSize)
1511: 49 8d 44 24 fe lea -0x2(%r12),%rax
1516: 48 83 f8 05 cmp $0x5,%rax
151a: 77 6d ja 1589 <ZSTD_decompressBlock_internal+0x469>
151c: ff 24 c5 00 00 00 00 jmpq *0x0(,%rax,8)
{
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
1523: 41 0f b6 45 06 movzbl 0x6(%r13),%eax
1528: 48 c1 e0 30 shl $0x30,%rax
152c: 48 09 c3 or %rax,%rbx
152f: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
1534: 41 0f b6 45 05 movzbl 0x5(%r13),%eax
1539: 48 c1 e0 28 shl $0x28,%rax
153d: 48 01 c3 add %rax,%rbx
1540: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
1545: 41 0f b6 45 04 movzbl 0x4(%r13),%eax
154a: 48 c1 e0 20 shl $0x20,%rax
154e: 48 01 c3 add %rax,%rbx
1551: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
1556: 41 0f b6 45 03 movzbl 0x3(%r13),%eax
155b: 48 c1 e0 18 shl $0x18,%rax
155f: 48 01 c3 add %rax,%rbx
1562: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
1567: 41 0f b6 45 02 movzbl 0x2(%r13),%eax
156c: 48 c1 e0 10 shl $0x10,%rax
1570: 48 01 c3 add %rax,%rbx
1573: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
1578: 41 0f b6 45 01 movzbl 0x1(%r13),%eax
157d: 48 c1 e0 08 shl $0x8,%rax
1581: 48 01 c3 add %rax,%rbx
1584: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
/* fall-through */
default: break;
}
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
1589: 43 0f b6 44 2c ff movzbl -0x1(%r12,%r13,1),%eax
158f: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
1591: 0f 84 8d 00 00 00 je 1624 <ZSTD_decompressBlock_internal+0x504>
return __builtin_clz (val) ^ 31;
1597: 0f bd c0 bsr %eax,%eax
159a: f7 d0 not %eax
159c: 83 c8 e0 or $0xffffffe0,%eax
if (lastByte == 0) return ERROR(corruption_detected); /* endMark not present */
}
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
159f: 41 c1 e4 03 shl $0x3,%r12d
15a3: 44 29 e0 sub %r12d,%eax
15a6: 83 c0 49 add $0x49,%eax
15a9: 89 44 24 68 mov %eax,0x68(%rsp)
15ad: 45 31 e4 xor %r12d,%r12d
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
15b0: 49 8b 0a mov (%r10),%rcx
15b3: 48 89 cd mov %rcx,%rbp
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
15b6: 8b 51 04 mov 0x4(%rcx),%edx
{
/* 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);
15b9: 01 d0 add %edx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
15bb: 89 c1 mov %eax,%ecx
15bd: f6 d9 neg %cl
15bf: 48 89 de mov %rbx,%rsi
15c2: 48 d3 ee shr %cl,%rsi
15c5: 23 34 95 00 00 00 00 and 0x0(,%rdx,4),%esi
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;
15cc: 89 44 24 68 mov %eax,0x68(%rsp)
15d0: 48 89 b4 24 88 00 00 mov %rsi,0x88(%rsp)
15d7: 00
* 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 */
15d8: 83 f8 40 cmp $0x40,%eax
15db: 48 89 7c 24 08 mov %rdi,0x8(%rsp)
15e0: 0f 87 b4 01 00 00 ja 179a <ZSTD_decompressBlock_internal+0x67a>
return BIT_DStream_overflow;
if (bitD->ptr >= bitD->limitPtr) {
15e6: 49 83 fc 08 cmp $0x8,%r12
15ea: 0f 8d 88 01 00 00 jge 1778 <ZSTD_decompressBlock_internal+0x658>
return BIT_reloadDStreamFast(bitD);
}
if (bitD->ptr == bitD->start) {
15f0: 4d 85 e4 test %r12,%r12
15f3: 0f 84 5c 0d 00 00 je 2355 <ZSTD_decompressBlock_internal+0x1235>
15f9: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
return BIT_DStream_completed;
}
/* start < ptr < limitPtr */
{ U32 nbBytes = bitD->bitsConsumed >> 3;
15fd: 89 c2 mov %eax,%edx
15ff: c1 ea 03 shr $0x3,%edx
BIT_DStream_status result = BIT_DStream_unfinished;
if (bitD->ptr - nbBytes < bitD->start) {
1602: 48 29 d1 sub %rdx,%rcx
1605: 4c 39 e9 cmp %r13,%rcx
1608: 44 89 e1 mov %r12d,%ecx
160b: 0f 43 ca cmovae %edx,%ecx
nbBytes = (U32)(bitD->ptr - bitD->start); /* ptr > start */
result = BIT_DStream_endOfBuffer;
}
bitD->ptr -= nbBytes;
160e: 49 29 cc sub %rcx,%r12
1611: 4b 8d 14 2c lea (%r12,%r13,1),%rdx
1615: 48 89 54 24 70 mov %rdx,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
161a: c1 e1 03 shl $0x3,%ecx
161d: 29 c8 sub %ecx,%eax
161f: e9 68 01 00 00 jmpq 178c <ZSTD_decompressBlock_internal+0x66c>
1624: c7 44 24 68 00 00 00 movl $0x0,0x68(%rsp)
162b: 00
162c: e9 f0 1e 00 00 jmpq 3521 <ZSTD_decompressBlock_internal+0x2401>
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
1631: 0f 29 84 24 10 01 00 movaps %xmm0,0x110(%rsp)
1638: 00
1639: 0f 29 84 24 00 01 00 movaps %xmm0,0x100(%rsp)
1640: 00
1641: 48 c7 84 24 20 01 00 movq $0x0,0x120(%rsp)
1648: 00 00 00 00 00
164d: e9 cf 1e 00 00 jmpq 3521 <ZSTD_decompressBlock_internal+0x2401>
1652: 49 89 cb mov %rcx,%r11
bitD->ptr = bitD->start;
1655: 4c 89 ac 24 10 01 00 mov %r13,0x110(%rsp)
165c: 00
bitD->bitContainer = *(const BYTE*)(bitD->start);
165d: 45 0f b6 55 00 movzbl 0x0(%r13),%r10d
1662: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
1669: 00
switch(srcSize)
166a: 49 8d 44 24 fe lea -0x2(%r12),%rax
166f: 48 83 f8 05 cmp $0x5,%rax
1673: 0f 87 8a 1e 00 00 ja 3503 <ZSTD_decompressBlock_internal+0x23e3>
1679: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
167e: ff 24 c5 00 00 00 00 jmpq *0x0(,%rax,8)
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
1685: 41 0f b6 45 06 movzbl 0x6(%r13),%eax
168a: 48 c1 e0 30 shl $0x30,%rax
168e: 49 09 c2 or %rax,%r10
1691: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
1698: 00
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
1699: 41 0f b6 45 05 movzbl 0x5(%r13),%eax
169e: 48 c1 e0 28 shl $0x28,%rax
16a2: 49 01 c2 add %rax,%r10
16a5: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
16ac: 00
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
16ad: 41 0f b6 45 04 movzbl 0x4(%r13),%eax
16b2: 48 c1 e0 20 shl $0x20,%rax
16b6: 49 01 c2 add %rax,%r10
16b9: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
16c0: 00
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
16c1: 41 0f b6 45 03 movzbl 0x3(%r13),%eax
16c6: 48 c1 e0 18 shl $0x18,%rax
16ca: 49 01 c2 add %rax,%r10
16cd: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
16d4: 00
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
16d5: 41 0f b6 45 02 movzbl 0x2(%r13),%eax
16da: 48 c1 e0 10 shl $0x10,%rax
16de: 49 01 c2 add %rax,%r10
16e1: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
16e8: 00
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
16e9: 41 0f b6 45 01 movzbl 0x1(%r13),%eax
16ee: 48 c1 e0 08 shl $0x8,%rax
16f2: 49 01 c2 add %rax,%r10
16f5: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
16fc: 00
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
16fd: 43 0f b6 44 2c ff movzbl -0x1(%r12,%r13,1),%eax
1703: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
1705: 0f 84 0b 1e 00 00 je 3516 <ZSTD_decompressBlock_internal+0x23f6>
170b: 48 89 54 24 18 mov %rdx,0x18(%rsp)
return __builtin_clz (val) ^ 31;
1710: 44 0f bd f8 bsr %eax,%r15d
1714: 41 f7 d7 not %r15d
1717: 41 83 cf e0 or $0xffffffe0,%r15d
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
171b: 41 c1 e4 03 shl $0x3,%r12d
171f: 45 29 e7 sub %r12d,%r15d
1722: 41 83 c7 49 add $0x49,%r15d
1726: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
172d: 00
172e: 45 31 e4 xor %r12d,%r12d
1731: 48 8b 44 24 20 mov 0x20(%rsp),%rax
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
1736: 48 8b 10 mov (%rax),%rdx
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
1739: 8b 72 04 mov 0x4(%rdx),%esi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
173c: 41 01 f7 add %esi,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
173f: 44 89 f9 mov %r15d,%ecx
1742: f6 d9 neg %cl
1744: 4c 89 d7 mov %r10,%rdi
1747: 48 d3 ef shr %cl,%rdi
174a: 23 3c b5 00 00 00 00 and 0x0(,%rsi,4),%edi
bitD->bitsConsumed += nbBits;
1751: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1758: 00
1759: 48 89 bc 24 28 01 00 mov %rdi,0x128(%rsp)
1760: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
1761: 41 83 ff 40 cmp $0x40,%r15d
1765: 44 89 4c 24 14 mov %r9d,0x14(%rsp)
176a: 0f 86 c2 01 00 00 jbe 1932 <ZSTD_decompressBlock_internal+0x812>
1770: 4d 89 e8 mov %r13,%r8
1773: e9 27 02 00 00 jmpq 199f <ZSTD_decompressBlock_internal+0x87f>
bitD->ptr -= bitD->bitsConsumed >> 3;
1778: 89 c1 mov %eax,%ecx
177a: c1 e9 03 shr $0x3,%ecx
177d: 49 29 cc sub %rcx,%r12
1780: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
1784: 48 89 4c 24 70 mov %rcx,0x70(%rsp)
bitD->bitsConsumed &= 7;
1789: 83 e0 07 and $0x7,%eax
178c: 89 44 24 68 mov %eax,0x68(%rsp)
1790: 4b 8b 5c 25 00 mov 0x0(%r13,%r12,1),%rbx
1795: 48 89 5c 24 60 mov %rbx,0x60(%rsp)
DStatePtr->table = dt + 1;
179a: 48 83 c5 08 add $0x8,%rbp
179e: 48 89 ac 24 18 02 00 mov %rbp,0x218(%rsp)
17a5: 00
17a6: 48 89 ac 24 90 00 00 mov %rbp,0x90(%rsp)
17ad: 00
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
17ae: 49 8b 4a 10 mov 0x10(%r10),%rcx
17b2: 49 89 c8 mov %rcx,%r8
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
17b5: 8b 79 04 mov 0x4(%rcx),%edi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
17b8: 01 f8 add %edi,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
17ba: 89 c1 mov %eax,%ecx
17bc: f6 d9 neg %cl
17be: 48 89 da mov %rbx,%rdx
17c1: 48 d3 ea shr %cl,%rdx
17c4: 23 14 bd 00 00 00 00 and 0x0(,%rdi,4),%edx
bitD->bitsConsumed += nbBits;
17cb: 89 44 24 68 mov %eax,0x68(%rsp)
17cf: 48 89 94 24 98 00 00 mov %rdx,0x98(%rsp)
17d6: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
17d7: 83 f8 40 cmp $0x40,%eax
17da: 48 89 dd mov %rbx,%rbp
17dd: 77 59 ja 1838 <ZSTD_decompressBlock_internal+0x718>
if (bitD->ptr >= bitD->limitPtr) {
17df: 49 83 fc 08 cmp $0x8,%r12
17e3: 7d 31 jge 1816 <ZSTD_decompressBlock_internal+0x6f6>
if (bitD->ptr == bitD->start) {
17e5: 4d 85 e4 test %r12,%r12
17e8: 0f 84 6f 0b 00 00 je 235d <ZSTD_decompressBlock_internal+0x123d>
17ee: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
17f2: 89 c7 mov %eax,%edi
17f4: c1 ef 03 shr $0x3,%edi
if (bitD->ptr - nbBytes < bitD->start) {
17f7: 48 29 f9 sub %rdi,%rcx
17fa: 4c 39 e9 cmp %r13,%rcx
17fd: 44 89 e1 mov %r12d,%ecx
1800: 0f 43 cf cmovae %edi,%ecx
bitD->ptr -= nbBytes;
1803: 49 29 cc sub %rcx,%r12
1806: 4b 8d 3c 2c lea (%r12,%r13,1),%rdi
180a: 48 89 7c 24 70 mov %rdi,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
180f: c1 e1 03 shl $0x3,%ecx
1812: 29 c8 sub %ecx,%eax
1814: eb 14 jmp 182a <ZSTD_decompressBlock_internal+0x70a>
bitD->ptr -= bitD->bitsConsumed >> 3;
1816: 89 c1 mov %eax,%ecx
1818: c1 e9 03 shr $0x3,%ecx
181b: 49 29 cc sub %rcx,%r12
181e: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
1822: 48 89 4c 24 70 mov %rcx,0x70(%rsp)
bitD->bitsConsumed &= 7;
1827: 83 e0 07 and $0x7,%eax
182a: 89 44 24 68 mov %eax,0x68(%rsp)
182e: 4b 8b 6c 25 00 mov 0x0(%r13,%r12,1),%rbp
1833: 48 89 6c 24 60 mov %rbp,0x60(%rsp)
DStatePtr->table = dt + 1;
1838: 49 83 c0 08 add $0x8,%r8
183c: 4c 89 84 24 10 02 00 mov %r8,0x210(%rsp)
1843: 00
1844: 4c 89 84 24 a0 00 00 mov %r8,0xa0(%rsp)
184b: 00
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
184c: 49 8b 5a 08 mov 0x8(%r10),%rbx
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
1850: 8b 7b 04 mov 0x4(%rbx),%edi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
1853: 01 f8 add %edi,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
1855: 89 c1 mov %eax,%ecx
1857: f6 d9 neg %cl
1859: 49 89 e8 mov %rbp,%r8
185c: 49 d3 e8 shr %cl,%r8
185f: 4c 89 74 24 40 mov %r14,0x40(%rsp)
1864: 44 23 04 bd 00 00 00 and 0x0(,%rdi,4),%r8d
186b: 00
186c: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx
1871: 48 89 cf mov %rcx,%rdi
1874: 49 29 ce sub %rcx,%r14
bitD->bitsConsumed += nbBits;
1877: 89 44 24 68 mov %eax,0x68(%rsp)
187b: 4c 89 84 24 a8 00 00 mov %r8,0xa8(%rsp)
1882: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
1883: 83 f8 41 cmp $0x41,%eax
1886: 44 89 4c 24 14 mov %r9d,0x14(%rsp)
188b: 72 14 jb 18a1 <ZSTD_decompressBlock_internal+0x781>
DStatePtr->table = dt + 1;
188d: 48 83 c3 08 add $0x8,%rbx
1891: 48 89 9c 24 b0 00 00 mov %rbx,0xb0(%rsp)
1898: 00
1899: 45 31 ff xor %r15d,%r15d
189c: e9 61 0f 00 00 jmpq 2802 <ZSTD_decompressBlock_internal+0x16e2>
if (bitD->ptr >= bitD->limitPtr) {
18a1: 49 83 fc 08 cmp $0x8,%r12
18a5: 7d 64 jge 190b <ZSTD_decompressBlock_internal+0x7eb>
if (bitD->ptr == bitD->start) {
18a7: 4d 85 e4 test %r12,%r12
18aa: 0f 84 b5 0a 00 00 je 2365 <ZSTD_decompressBlock_internal+0x1245>
18b0: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
18b4: 89 c7 mov %eax,%edi
18b6: c1 ef 03 shr $0x3,%edi
if (bitD->ptr - nbBytes < bitD->start) {
18b9: 48 29 f9 sub %rdi,%rcx
18bc: 4c 39 e9 cmp %r13,%rcx
18bf: 44 89 e1 mov %r12d,%ecx
18c2: 0f 43 cf cmovae %edi,%ecx
bitD->ptr -= nbBytes;
18c5: 49 29 cc sub %rcx,%r12
18c8: 4b 8d 3c 2c lea (%r12,%r13,1),%rdi
18cc: 48 89 7c 24 70 mov %rdi,0x70(%rsp)
18d1: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi
bitD->bitsConsumed -= nbBytes*8;
18d6: c1 e1 03 shl $0x3,%ecx
18d9: 29 c8 sub %ecx,%eax
18db: 89 44 24 68 mov %eax,0x68(%rsp)
18df: 4b 8b 6c 25 00 mov 0x0(%r13,%r12,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
18e4: 48 89 6c 24 60 mov %rbp,0x60(%rsp)
18e9: 48 8d 4b 08 lea 0x8(%rbx),%rcx
18ed: 48 89 8c 24 b0 00 00 mov %rcx,0xb0(%rsp)
18f4: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
18f5: 83 f8 40 cmp $0x40,%eax
18f8: 0f 86 76 0a 00 00 jbe 2374 <ZSTD_decompressBlock_internal+0x1254>
18fe: 44 8b 4c 24 14 mov 0x14(%rsp),%r9d
1903: 45 31 ff xor %r15d,%r15d
1906: e9 f7 0e 00 00 jmpq 2802 <ZSTD_decompressBlock_internal+0x16e2>
bitD->ptr -= bitD->bitsConsumed >> 3;
190b: 89 c1 mov %eax,%ecx
190d: c1 e9 03 shr $0x3,%ecx
1910: 49 29 cc sub %rcx,%r12
1913: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
1917: 48 89 4c 24 70 mov %rcx,0x70(%rsp)
bitD->bitsConsumed &= 7;
191c: 83 e0 07 and $0x7,%eax
191f: 89 44 24 68 mov %eax,0x68(%rsp)
1923: 4b 8b 6c 25 00 mov 0x0(%r13,%r12,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr);
1928: 48 89 6c 24 60 mov %rbp,0x60(%rsp)
192d: e9 36 0a 00 00 jmpq 2368 <ZSTD_decompressBlock_internal+0x1248>
if (bitD->ptr >= bitD->limitPtr) {
1932: 49 83 fc 08 cmp $0x8,%r12
1936: 7d 36 jge 196e <ZSTD_decompressBlock_internal+0x84e>
if (bitD->ptr == bitD->start) {
1938: 4d 85 e4 test %r12,%r12
193b: 0f 84 27 1c 00 00 je 3568 <ZSTD_decompressBlock_internal+0x2448>
1941: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
1945: 44 89 fe mov %r15d,%esi
1948: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
194b: 48 29 f1 sub %rsi,%rcx
194e: 4c 39 e9 cmp %r13,%rcx
1951: 44 89 e1 mov %r12d,%ecx
1954: 0f 43 ce cmovae %esi,%ecx
bitD->ptr -= nbBytes;
1957: 49 29 cc sub %rcx,%r12
195a: 4b 8d 34 2c lea (%r12,%r13,1),%rsi
195e: 48 89 b4 24 10 01 00 mov %rsi,0x110(%rsp)
1965: 00
bitD->bitsConsumed -= nbBytes*8;
1966: c1 e1 03 shl $0x3,%ecx
1969: 41 29 cf sub %ecx,%r15d
196c: eb 19 jmp 1987 <ZSTD_decompressBlock_internal+0x867>
bitD->ptr -= bitD->bitsConsumed >> 3;
196e: 44 89 f9 mov %r15d,%ecx
1971: c1 e9 03 shr $0x3,%ecx
1974: 49 29 cc sub %rcx,%r12
1977: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
197b: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
1982: 00
bitD->bitsConsumed &= 7;
1983: 41 83 e7 07 and $0x7,%r15d
1987: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
198e: 00
198f: 4d 89 e8 mov %r13,%r8
1992: 4f 8b 54 25 00 mov 0x0(%r13,%r12,1),%r10
1997: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
199e: 00
199f: 48 83 c2 08 add $0x8,%rdx
19a3: 48 89 94 24 30 01 00 mov %rdx,0x130(%rsp)
19aa: 00
19ab: 48 8b 44 24 20 mov 0x20(%rsp),%rax
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
19b0: 48 8b 70 10 mov 0x10(%rax),%rsi
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
19b4: 8b 6e 04 mov 0x4(%rsi),%ebp
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
19b7: 41 01 ef add %ebp,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
19ba: 44 89 f9 mov %r15d,%ecx
19bd: f6 d9 neg %cl
19bf: 4d 89 d5 mov %r10,%r13
19c2: 49 d3 ed shr %cl,%r13
19c5: 44 23 2c ad 00 00 00 and 0x0(,%rbp,4),%r13d
19cc: 00
bitD->bitsConsumed += nbBits;
19cd: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
19d4: 00
19d5: 4c 89 ac 24 38 01 00 mov %r13,0x138(%rsp)
19dc: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
19dd: 41 83 ff 40 cmp $0x40,%r15d
19e1: 77 6f ja 1a52 <ZSTD_decompressBlock_internal+0x932>
if (bitD->ptr >= bitD->limitPtr) {
19e3: 49 83 fc 08 cmp $0x8,%r12
19e7: 7d 39 jge 1a22 <ZSTD_decompressBlock_internal+0x902>
if (bitD->ptr == bitD->start) {
19e9: 4d 85 e4 test %r12,%r12
19ec: 0f 84 81 1b 00 00 je 3573 <ZSTD_decompressBlock_internal+0x2453>
19f2: 4c 89 c0 mov %r8,%rax
19f5: 4b 8d 0c 20 lea (%r8,%r12,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
19f9: 44 89 fd mov %r15d,%ebp
19fc: c1 ed 03 shr $0x3,%ebp
if (bitD->ptr - nbBytes < bitD->start) {
19ff: 48 29 e9 sub %rbp,%rcx
1a02: 4c 39 c1 cmp %r8,%rcx
1a05: 44 89 e1 mov %r12d,%ecx
1a08: 0f 43 cd cmovae %ebp,%ecx
bitD->ptr -= nbBytes;
1a0b: 49 29 cc sub %rcx,%r12
1a0e: 4b 8d 2c 20 lea (%r8,%r12,1),%rbp
1a12: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp)
1a19: 00
bitD->bitsConsumed -= nbBytes*8;
1a1a: c1 e1 03 shl $0x3,%ecx
1a1d: 41 29 cf sub %ecx,%r15d
1a20: eb 1c jmp 1a3e <ZSTD_decompressBlock_internal+0x91e>
bitD->ptr -= bitD->bitsConsumed >> 3;
1a22: 44 89 f9 mov %r15d,%ecx
1a25: c1 e9 03 shr $0x3,%ecx
1a28: 49 29 cc sub %rcx,%r12
1a2b: 4c 89 c0 mov %r8,%rax
1a2e: 4b 8d 0c 20 lea (%r8,%r12,1),%rcx
1a32: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
1a39: 00
bitD->bitsConsumed &= 7;
1a3a: 41 83 e7 07 and $0x7,%r15d
1a3e: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1a45: 00
1a46: 4f 8b 14 20 mov (%r8,%r12,1),%r10
1a4a: 4c 89 94 24 00 01 00 mov %r10,0x100(%rsp)
1a51: 00
DStatePtr->table = dt + 1;
1a52: 48 83 c6 08 add $0x8,%rsi
1a56: 48 89 b4 24 40 01 00 mov %rsi,0x140(%rsp)
1a5d: 00
1a5e: 48 8b 44 24 20 mov 0x20(%rsp),%rax
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
1a63: 48 8b 58 08 mov 0x8(%rax),%rbx
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
1a67: 8b 6b 04 mov 0x4(%rbx),%ebp
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
1a6a: 41 01 ef add %ebp,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
1a6d: 44 89 f9 mov %r15d,%ecx
1a70: f6 d9 neg %cl
1a72: 49 d3 ea shr %cl,%r10
1a75: 44 23 14 ad 00 00 00 and 0x0(,%rbp,4),%r10d
1a7c: 00
bitD->bitsConsumed += nbBits;
1a7d: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1a84: 00
1a85: 4c 89 94 24 48 01 00 mov %r10,0x148(%rsp)
1a8c: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
1a8d: 41 83 ff 40 cmp $0x40,%r15d
1a91: 77 5f ja 1af2 <ZSTD_decompressBlock_internal+0x9d2>
1a93: 4b 8d 2c 20 lea (%r8,%r12,1),%rbp
if (bitD->ptr >= bitD->limitPtr) {
1a97: 49 83 fc 08 cmp $0x8,%r12
1a9b: 7d 2c jge 1ac9 <ZSTD_decompressBlock_internal+0x9a9>
if (bitD->ptr == bitD->start) {
1a9d: 4d 85 e4 test %r12,%r12
1aa0: 74 50 je 1af2 <ZSTD_decompressBlock_internal+0x9d2>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
1aa2: 44 89 f8 mov %r15d,%eax
1aa5: c1 e8 03 shr $0x3,%eax
if (bitD->ptr - nbBytes < bitD->start) {
1aa8: 48 89 e9 mov %rbp,%rcx
1aab: 48 29 c1 sub %rax,%rcx
1aae: 4c 39 c1 cmp %r8,%rcx
1ab1: 44 0f 43 e0 cmovae %eax,%r12d
bitD->ptr -= nbBytes;
1ab5: 4c 29 e5 sub %r12,%rbp
1ab8: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp)
1abf: 00
bitD->bitsConsumed -= nbBytes*8;
1ac0: 41 c1 e4 03 shl $0x3,%r12d
1ac4: 45 29 e7 sub %r12d,%r15d
1ac7: eb 15 jmp 1ade <ZSTD_decompressBlock_internal+0x9be>
bitD->ptr -= bitD->bitsConsumed >> 3;
1ac9: 44 89 f8 mov %r15d,%eax
1acc: c1 e8 03 shr $0x3,%eax
1acf: 48 29 c5 sub %rax,%rbp
1ad2: 48 89 ac 24 10 01 00 mov %rbp,0x110(%rsp)
1ad9: 00
bitD->bitsConsumed &= 7;
1ada: 41 83 e7 07 and $0x7,%r15d
1ade: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1ae5: 00
1ae6: 48 8b 45 00 mov 0x0(%rbp),%rax
1aea: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp)
1af1: 00
DStatePtr->table = dt + 1;
1af2: 48 83 c3 08 add $0x8,%rbx
1af6: 48 89 9c 24 50 01 00 mov %rbx,0x150(%rsp)
1afd: 00
1afe: 66 90 xchg %ax,%ax
__asm__("nop");
1b00: 90 nop
1b01: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1b08: 00 00 00
1b0b: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1b12: 00 00 00
1b15: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1b1c: 00 00 00
1b1f: 90 nop
__asm__("nop");
1b20: 90 nop
1b21: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1b28: 00 00 00
1b2b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
__asm__(".p2align 4");
1b30: 48 8b 44 24 18 mov 0x18(%rsp),%rax
1b35: 48 83 c0 e0 add $0xffffffffffffffe0,%rax
1b39: 48 89 84 24 d8 00 00 mov %rax,0xd8(%rsp)
1b40: 00
1b41: 4c 89 74 24 30 mov %r14,0x30(%rsp)
1b46: 4d 89 de mov %r11,%r14
1b49: 4c 89 5c 24 48 mov %r11,0x48(%rsp)
1b4e: eb 59 jmp 1ba9 <ZSTD_decompressBlock_internal+0xa89>
bitD->ptr -= bitD->bitsConsumed >> 3;
1b50: 4c 89 f8 mov %r15,%rax
1b53: 48 c1 e8 03 shr $0x3,%rax
1b57: 48 29 c1 sub %rax,%rcx
1b5a: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
1b61: 00
bitD->bitsConsumed &= 7;
1b62: 41 83 e7 07 and $0x7,%r15d
1b66: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1b6d: 00
1b6e: 48 8b 01 mov (%rcx),%rax
1b71: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp)
1b78: 00
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
1b79: 48 8b bc 24 28 01 00 mov 0x128(%rsp),%rdi
1b80: 00
1b81: 48 8b 94 24 30 01 00 mov 0x130(%rsp),%rdx
1b88: 00
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
1b89: 48 8b 9c 24 50 01 00 mov 0x150(%rsp),%rbx
1b90: 00
1b91: 4c 8b 94 24 48 01 00 mov 0x148(%rsp),%r10
1b98: 00
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
1b99: 48 8b b4 24 40 01 00 mov 0x140(%rsp),%rsi
1ba0: 00
1ba1: 4c 8b ac 24 38 01 00 mov 0x138(%rsp),%r13
1ba8: 00
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
1ba9: 0f b7 04 fa movzwl (%rdx,%rdi,8),%eax
1bad: 48 89 44 24 28 mov %rax,0x28(%rsp)
1bb2: 0f b6 6c fa 02 movzbl 0x2(%rdx,%rdi,8),%ebp
1bb7: 44 0f b6 5c fa 03 movzbl 0x3(%rdx,%rdi,8),%r11d
1bbd: 8b 54 fa 04 mov 0x4(%rdx,%rdi,8),%edx
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
1bc1: 42 0f b7 3c d3 movzwl (%rbx,%r10,8),%edi
1bc6: 46 0f b6 44 d3 02 movzbl 0x2(%rbx,%r10,8),%r8d
1bcc: 42 0f b6 44 d3 03 movzbl 0x3(%rbx,%r10,8),%eax
1bd2: 89 44 24 08 mov %eax,0x8(%rsp)
1bd6: 46 8b 64 d3 04 mov 0x4(%rbx,%r10,8),%r12d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
1bdb: 42 0f b7 04 ee movzwl (%rsi,%r13,8),%eax
1be0: 46 0f b6 4c ee 02 movzbl 0x2(%rsi,%r13,8),%r9d
BYTE const totalBits = llBits+mlBits+ofBits;
1be6: 45 8d 14 28 lea (%r8,%rbp,1),%r10d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
1bea: 42 0f b6 4c ee 03 movzbl 0x3(%rsi,%r13,8),%ecx
1bf0: 42 8b 74 ee 04 mov 0x4(%rsi,%r13,8),%esi
1bf5: 41 89 cd mov %ecx,%r13d
1bf8: 49 89 c6 mov %rax,%r14
1bfb: 41 83 f9 02 cmp $0x2,%r9d
if (ofBits > 1) {
1bff: 0f 82 4b 02 00 00 jb 1e50 <ZSTD_decompressBlock_internal+0xd30>
size_t const value = BIT_lookBitsFast(bitD, nbBits);
1c05: 48 8b 84 24 00 01 00 mov 0x100(%rsp),%rax
1c0c: 00
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
1c0d: 44 89 f9 mov %r15d,%ecx
1c10: 48 d3 e0 shl %cl,%rax
1c13: 44 89 c9 mov %r9d,%ecx
1c16: f6 d9 neg %cl
1c18: 48 d3 e8 shr %cl,%rax
bitD->bitsConsumed += nbBits;
1c1b: 45 01 cf add %r9d,%r15d
1c1e: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1c25: 00
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
1c26: 48 01 f0 add %rsi,%rax
seqState->prevOffset[1] = seqState->prevOffset[0];
1c29: 0f 10 84 24 58 01 00 movups 0x158(%rsp),%xmm0
1c30: 00
1c31: 0f 11 84 24 60 01 00 movups %xmm0,0x160(%rsp)
1c38: 00
1c39: 48 89 44 24 38 mov %rax,0x38(%rsp)
1c3e: 48 89 84 24 58 01 00 mov %rax,0x158(%rsp)
1c45: 00
1c46: 45 00 ca add %r9b,%r10b
if (mlBits > 0)
1c49: 45 84 c0 test %r8b,%r8b
1c4c: 74 24 je 1c72 <ZSTD_decompressBlock_internal+0xb52>
size_t const value = BIT_lookBitsFast(bitD, nbBits);
1c4e: 48 8b b4 24 00 01 00 mov 0x100(%rsp),%rsi
1c55: 00
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
1c56: 44 89 f9 mov %r15d,%ecx
1c59: 48 d3 e6 shl %cl,%rsi
1c5c: 44 89 c1 mov %r8d,%ecx
1c5f: f6 d9 neg %cl
1c61: 48 d3 ee shr %cl,%rsi
bitD->bitsConsumed += nbBits;
1c64: 45 01 c7 add %r8d,%r15d
1c67: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1c6e: 00
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
1c6f: 49 01 f4 add %rsi,%r12
1c72: 4c 8b 44 24 38 mov 0x38(%rsp),%r8
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
1c77: 41 80 fa 1f cmp $0x1f,%r10b
1c7b: 72 0a jb 1c87 <ZSTD_decompressBlock_internal+0xb67>
1c7d: 41 83 ff 40 cmp $0x40,%r15d
1c81: 0f 86 6a 03 00 00 jbe 1ff1 <ZSTD_decompressBlock_internal+0xed1>
1c87: 48 89 fb mov %rdi,%rbx
1c8a: 48 8b bc 24 00 01 00 mov 0x100(%rsp),%rdi
1c91: 00
if (llBits > 0)
1c92: 40 84 ed test %bpl,%bpl
1c95: 74 1e je 1cb5 <ZSTD_decompressBlock_internal+0xb95>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
1c97: 48 89 f8 mov %rdi,%rax
1c9a: 44 89 f9 mov %r15d,%ecx
1c9d: 48 d3 e0 shl %cl,%rax
1ca0: 89 e9 mov %ebp,%ecx
1ca2: f6 d9 neg %cl
1ca4: 48 d3 e8 shr %cl,%rax
bitD->bitsConsumed += nbBits;
1ca7: 41 01 ef add %ebp,%r15d
1caa: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1cb1: 00
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
1cb2: 48 01 c2 add %rax,%rdx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
1cb5: 45 01 df add %r11d,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
1cb8: 44 89 f9 mov %r15d,%ecx
1cbb: f6 d9 neg %cl
1cbd: 48 89 f8 mov %rdi,%rax
1cc0: 48 d3 e8 shr %cl,%rax
1cc3: 44 89 d9 mov %r11d,%ecx
1cc6: 23 04 8d 00 00 00 00 and 0x0(,%rcx,4),%eax
DStatePtr->state = DInfo.nextState + lowBits;
1ccd: 48 03 44 24 28 add 0x28(%rsp),%rax
1cd2: 8b 6c 24 08 mov 0x8(%rsp),%ebp
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
1cd6: 41 01 ef add %ebp,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
1cd9: 44 89 f9 mov %r15d,%ecx
1cdc: f6 d9 neg %cl
1cde: 48 89 fe mov %rdi,%rsi
1ce1: 48 d3 ee shr %cl,%rsi
1ce4: 48 89 84 24 28 01 00 mov %rax,0x128(%rsp)
1ceb: 00
1cec: 89 e8 mov %ebp,%eax
1cee: 23 34 85 00 00 00 00 and 0x0(,%rax,4),%esi
1cf5: 48 01 de add %rbx,%rsi
1cf8: 48 89 b4 24 48 01 00 mov %rsi,0x148(%rsp)
1cff: 00
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
1d00: 45 01 ef add %r13d,%r15d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
1d03: 44 89 f9 mov %r15d,%ecx
1d06: f6 d9 neg %cl
1d08: 48 d3 ef shr %cl,%rdi
1d0b: 44 89 e8 mov %r13d,%eax
1d0e: 23 3c 85 00 00 00 00 and 0x0(,%rax,4),%edi
1d15: 4c 01 f7 add %r14,%rdi
bitD->bitsConsumed += nbBits;
1d18: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
1d1f: 00
1d20: 48 89 bc 24 38 01 00 mov %rdi,0x138(%rsp)
1d27: 00
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
1d28: 4e 8d 1c 22 lea (%rdx,%r12,1),%r11
1d2c: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx
1d31: 4a 8d 04 1b lea (%rbx,%r11,1),%rax
1d35: 48 3b 84 24 d8 00 00 cmp 0xd8(%rsp),%rax
1d3c: 00
1d3d: 4c 8b 7c 24 58 mov 0x58(%rsp),%r15
if (UNLIKELY(
1d42: 0f 87 d4 01 00 00 ja 1f1c <ZSTD_decompressBlock_internal+0xdfc>
1d48: 48 8b 4c 24 60 mov 0x60(%rsp),%rcx
1d4d: 48 8d 04 11 lea (%rcx,%rdx,1),%rax
1d51: 4c 39 f8 cmp %r15,%rax
1d54: 0f 87 c2 01 00 00 ja 1f1c <ZSTD_decompressBlock_internal+0xdfc>
1d5a: 4c 8d 2c 13 lea (%rbx,%rdx,1),%r13
1d5e: 4c 89 ed mov %r13,%rbp
1d61: 4c 29 c5 sub %r8,%rbp
#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
static void ZSTD_copy16(void* dst, const void* src) {
#if !defined(ZSTD_NO_INTRINSICS) && defined(__ARM_NEON)
vst1q_u8((uint8_t*)dst, vld1q_u8((const uint8_t*)src));
#else
ZSTD_memcpy(dst, src, 16);
1d64: 0f 10 01 movups (%rcx),%xmm0
1d67: 0f 11 03 movups %xmm0,(%rbx)
if (UNLIKELY(sequence.litLength > 16)) {
1d6a: 48 83 fa 11 cmp $0x11,%rdx
1d6e: 4c 8b 74 24 48 mov 0x48(%rsp),%r14
1d73: 0f 83 e6 01 00 00 jae 1f5f <ZSTD_decompressBlock_internal+0xe3f>
*litPtr = iLitEnd; /* update for next sequence */
1d79: 48 89 44 24 60 mov %rax,0x60(%rsp)
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
1d7e: 4c 89 e8 mov %r13,%rax
1d81: 4c 29 f0 sub %r14,%rax
1d84: 4c 39 c0 cmp %r8,%rax
1d87: 73 54 jae 1ddd <ZSTD_decompressBlock_internal+0xcbd>
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
1d89: 4c 89 e8 mov %r13,%rax
1d8c: 48 2b 44 24 50 sub 0x50(%rsp),%rax
1d91: 4c 39 c0 cmp %r8,%rax
1d94: 0f 82 87 17 00 00 jb 3521 <ZSTD_decompressBlock_internal+0x2401>
1d9a: 4d 89 df mov %r11,%r15
match = dictEnd + (match - prefixStart);
1d9d: 4c 29 f5 sub %r14,%rbp
1da0: 48 8b 8c 24 f0 00 00 mov 0xf0(%rsp),%rcx
1da7: 00
1da8: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
1dac: 4a 8d 04 26 lea (%rsi,%r12,1),%rax
1db0: 48 39 c8 cmp %rcx,%rax
1db3: 0f 86 c7 00 00 00 jbe 1e80 <ZSTD_decompressBlock_internal+0xd60>
{ size_t const length1 = dictEnd - match;
1db9: 48 89 ea mov %rbp,%rdx
1dbc: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
1dbf: 4c 89 ef mov %r13,%rdi
1dc2: e8 00 00 00 00 callq 1dc7 <ZSTD_decompressBlock_internal+0xca7>
1dc7: 4c 8b 44 24 38 mov 0x38(%rsp),%r8
op = oLitEnd + length1;
1dcc: 49 29 ed sub %rbp,%r13
sequence.matchLength -= length1;
1dcf: 49 01 ec add %rbp,%r12
1dd2: 4c 89 f5 mov %r14,%rbp
1dd5: 4d 89 fb mov %r15,%r11
1dd8: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
1ddd: 49 83 f8 10 cmp $0x10,%r8
1de1: 0f 82 c0 01 00 00 jb 1fa7 <ZSTD_decompressBlock_internal+0xe87>
1de7: 0f 10 45 00 movups 0x0(%rbp),%xmm0
1deb: 41 0f 11 45 00 movups %xmm0,0x0(%r13)
COPY16(op, ip);
}
while (op < oend);
#else
ZSTD_copy16(op, ip);
if (16 >= length) return;
1df0: 49 83 fc 11 cmp $0x11,%r12
1df4: 7c 41 jl 1e37 <ZSTD_decompressBlock_internal+0xd17>
1df6: 4d 01 ec add %r13,%r12
op += 16;
ip += 16;
do {
1df9: 48 83 c5 10 add $0x10,%rbp
1dfd: b8 10 00 00 00 mov $0x10,%eax
1e02: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1e09: 00 00 00
1e0c: 0f 1f 40 00 nopl 0x0(%rax)
ZSTD_memcpy(dst, src, 16);
1e10: 0f 10 44 05 f0 movups -0x10(%rbp,%rax,1),%xmm0
1e15: 41 0f 11 44 05 00 movups %xmm0,0x0(%r13,%rax,1)
1e1b: 0f 10 44 05 00 movups 0x0(%rbp,%rax,1),%xmm0
1e20: 41 0f 11 44 05 10 movups %xmm0,0x10(%r13,%rax,1)
COPY16(op, ip);
COPY16(op, ip);
}
while (op < oend);
1e26: 4a 8d 0c 28 lea (%rax,%r13,1),%rcx
1e2a: 48 83 c1 20 add $0x20,%rcx
1e2e: 48 83 c0 20 add $0x20,%rax
1e32: 4c 39 e1 cmp %r12,%rcx
}
1e35: 72 d9 jb 1e10 <ZSTD_decompressBlock_internal+0xcf0>
1e37: 8b 44 24 14 mov 0x14(%rsp),%eax
1e3b: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
1e3f: 76 60 jbe 1ea1 <ZSTD_decompressBlock_internal+0xd81>
1e41: e9 e2 16 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
1e46: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
1e4d: 00 00 00
if (LIKELY((ofBits == 0))) {
1e50: 45 84 c9 test %r9b,%r9b
1e53: 0f 85 05 02 00 00 jne 205e <ZSTD_decompressBlock_internal+0xf3e>
U32 const ll0 = (llBase == 0);
1e59: 85 d2 test %edx,%edx
if (LIKELY(!ll0))
1e5b: 0f 84 4c 02 00 00 je 20ad <ZSTD_decompressBlock_internal+0xf8d>
offset = seqState->prevOffset[0];
1e61: 48 8b 84 24 58 01 00 mov 0x158(%rsp),%rax
1e68: 00
1e69: 48 89 44 24 38 mov %rax,0x38(%rsp)
1e6e: 45 00 ca add %r9b,%r10b
if (mlBits > 0)
1e71: 45 84 c0 test %r8b,%r8b
1e74: 0f 85 d4 fd ff ff jne 1c4e <ZSTD_decompressBlock_internal+0xb2e>
1e7a: e9 f3 fd ff ff jmpq 1c72 <ZSTD_decompressBlock_internal+0xb52>
1e7f: 90 nop
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
1e80: 4c 89 ef mov %r13,%rdi
1e83: 4c 89 e2 mov %r12,%rdx
1e86: e8 00 00 00 00 callq 1e8b <ZSTD_decompressBlock_internal+0xd6b>
1e8b: 8b 44 24 14 mov 0x14(%rsp),%eax
1e8f: 4d 89 fb mov %r15,%r11
1e92: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx
1e97: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
if (UNLIKELY(ZSTD_isError(oneSeqSize)))
1e9b: 0f 87 87 16 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
op += oneSeqSize;
1ea1: 4c 01 db add %r11,%rbx
1ea4: 48 89 5c 24 30 mov %rbx,0x30(%rsp)
1ea9: 44 8b bc 24 08 01 00 mov 0x108(%rsp),%r15d
1eb0: 00
if (UNLIKELY(!--nbSeq))
1eb1: 83 c0 ff add $0xffffffff,%eax
1eb4: 0f 84 16 04 00 00 je 22d0 <ZSTD_decompressBlock_internal+0x11b0>
1eba: 41 83 ff 40 cmp $0x40,%r15d
1ebe: 89 44 24 14 mov %eax,0x14(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
1ec2: 0f 87 b1 fc ff ff ja 1b79 <ZSTD_decompressBlock_internal+0xa59>
if (bitD->ptr >= bitD->limitPtr) {
1ec8: 48 8b 8c 24 10 01 00 mov 0x110(%rsp),%rcx
1ecf: 00
1ed0: 48 3b 8c 24 20 01 00 cmp 0x120(%rsp),%rcx
1ed7: 00
1ed8: 0f 83 72 fc ff ff jae 1b50 <ZSTD_decompressBlock_internal+0xa30>
if (bitD->ptr == bitD->start) {
1ede: 48 8b 94 24 18 01 00 mov 0x118(%rsp),%rdx
1ee5: 00
1ee6: 48 39 d1 cmp %rdx,%rcx
1ee9: 0f 84 8a fc ff ff je 1b79 <ZSTD_decompressBlock_internal+0xa59>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
1eef: 4c 89 f8 mov %r15,%rax
1ef2: 48 c1 e8 03 shr $0x3,%rax
if (bitD->ptr - nbBytes < bitD->start) {
1ef6: 48 89 ce mov %rcx,%rsi
1ef9: 48 29 c6 sub %rax,%rsi
1efc: 89 cf mov %ecx,%edi
1efe: 29 d7 sub %edx,%edi
1f00: 48 39 d6 cmp %rdx,%rsi
1f03: 0f 43 f8 cmovae %eax,%edi
bitD->ptr -= nbBytes;
1f06: 48 29 f9 sub %rdi,%rcx
1f09: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
1f10: 00
bitD->bitsConsumed -= nbBytes*8;
1f11: c1 e7 03 shl $0x3,%edi
1f14: 41 29 ff sub %edi,%r15d
1f17: e9 4a fc ff ff jmpq 1b66 <ZSTD_decompressBlock_internal+0xa46>
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
1f1c: 48 89 df mov %rbx,%rdi
1f1f: 48 8b 74 24 18 mov 0x18(%rsp),%rsi
1f24: 4c 89 e1 mov %r12,%rcx
1f27: 4c 8d 4c 24 60 lea 0x60(%rsp),%r9
1f2c: ff b4 24 f0 00 00 00 pushq 0xf0(%rsp)
1f33: ff 74 24 58 pushq 0x58(%rsp)
1f37: 4c 8b 74 24 58 mov 0x58(%rsp),%r14
1f3c: 41 56 push %r14
1f3e: 41 57 push %r15
1f40: e8 3b 2d 00 00 callq 4c80 <ZSTD_execSequenceEnd>
1f45: 48 83 c4 20 add $0x20,%rsp
1f49: 49 89 c3 mov %rax,%r11
1f4c: 8b 44 24 14 mov 0x14(%rsp),%eax
1f50: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
1f54: 0f 86 47 ff ff ff jbe 1ea1 <ZSTD_decompressBlock_internal+0xd81>
1f5a: e9 c9 15 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
1f5f: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
1f63: 0f 10 41 10 movups 0x10(%rcx),%xmm0
1f67: 0f 11 43 10 movups %xmm0,0x10(%rbx)
if (16 >= length) return;
1f6b: 48 83 fa 11 cmp $0x11,%rdx
1f6f: 0f 8c 04 fe ff ff jl 1d79 <ZSTD_decompressBlock_internal+0xc59>
op += 16;
1f75: 48 8d 53 20 lea 0x20(%rbx),%rdx
do {
1f79: 48 83 c1 30 add $0x30,%rcx
1f7d: 31 f6 xor %esi,%esi
ZSTD_memcpy(dst, src, 16);
1f7f: 0f 10 44 31 f0 movups -0x10(%rcx,%rsi,1),%xmm0
1f84: 0f 11 04 32 movups %xmm0,(%rdx,%rsi,1)
1f88: 0f 10 04 31 movups (%rcx,%rsi,1),%xmm0
1f8c: 0f 11 44 32 10 movups %xmm0,0x10(%rdx,%rsi,1)
while (op < oend);
1f91: 48 8d 3c 32 lea (%rdx,%rsi,1),%rdi
1f95: 48 83 c7 20 add $0x20,%rdi
1f99: 48 83 c6 20 add $0x20,%rsi
1f9d: 4c 39 ef cmp %r13,%rdi
}
1fa0: 72 dd jb 1f7f <ZSTD_decompressBlock_internal+0xe5f>
1fa2: e9 d2 fd ff ff jmpq 1d79 <ZSTD_decompressBlock_internal+0xc59>
if (offset < 8) {
1fa7: 49 83 f8 07 cmp $0x7,%r8
1fab: 0f 87 19 01 00 00 ja 20ca <ZSTD_decompressBlock_internal+0xfaa>
int const sub2 = dec64table[offset];
1fb1: 4a 63 04 85 00 00 00 movslq 0x0(,%r8,4),%rax
1fb8: 00
(*op)[0] = (*ip)[0];
1fb9: 8a 4d 00 mov 0x0(%rbp),%cl
1fbc: 41 88 4d 00 mov %cl,0x0(%r13)
(*op)[1] = (*ip)[1];
1fc0: 8a 4d 01 mov 0x1(%rbp),%cl
1fc3: 41 88 4d 01 mov %cl,0x1(%r13)
(*op)[2] = (*ip)[2];
1fc7: 8a 4d 02 mov 0x2(%rbp),%cl
1fca: 41 88 4d 02 mov %cl,0x2(%r13)
(*op)[3] = (*ip)[3];
1fce: 8a 4d 03 mov 0x3(%rbp),%cl
1fd1: 41 88 4d 03 mov %cl,0x3(%r13)
*ip += dec32table[offset];
1fd5: 42 8b 0c 85 00 00 00 mov 0x0(,%r8,4),%ecx
1fdc: 00
1fdd: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
*ip -= sub2;
1fe1: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
1fe4: 8b 44 0d 00 mov 0x0(%rbp,%rcx,1),%eax
1fe8: 41 89 45 04 mov %eax,0x4(%r13)
1fec: e9 e4 00 00 00 jmpq 20d5 <ZSTD_decompressBlock_internal+0xfb5>
if (bitD->ptr >= bitD->limitPtr) {
1ff1: 48 8b 8c 24 10 01 00 mov 0x110(%rsp),%rcx
1ff8: 00
1ff9: 48 3b 8c 24 20 01 00 cmp 0x120(%rsp),%rcx
2000: 00
2001: 0f 83 b0 01 00 00 jae 21b7 <ZSTD_decompressBlock_internal+0x1097>
2007: 48 89 fb mov %rdi,%rbx
if (bitD->ptr == bitD->start) {
200a: 4c 8b 84 24 18 01 00 mov 0x118(%rsp),%r8
2011: 00
2012: 4c 39 c1 cmp %r8,%rcx
2015: 74 3d je 2054 <ZSTD_decompressBlock_internal+0xf34>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
2017: 45 89 fa mov %r15d,%r10d
201a: 41 c1 ea 03 shr $0x3,%r10d
if (bitD->ptr - nbBytes < bitD->start) {
201e: 49 89 c9 mov %rcx,%r9
2021: 4d 29 d1 sub %r10,%r9
2024: 89 ce mov %ecx,%esi
2026: 44 29 c6 sub %r8d,%esi
2029: 4d 39 c1 cmp %r8,%r9
202c: 41 0f 43 f2 cmovae %r10d,%esi
bitD->ptr -= nbBytes;
2030: 48 29 f1 sub %rsi,%rcx
2033: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
203a: 00
bitD->bitsConsumed -= nbBytes*8;
203b: c1 e6 03 shl $0x3,%esi
203e: 41 29 f7 sub %esi,%r15d
2041: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
2048: 00
2049: 48 8b 09 mov (%rcx),%rcx
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
204c: 48 89 8c 24 00 01 00 mov %rcx,0x100(%rsp)
2053: 00
2054: 4c 8b 44 24 38 mov 0x38(%rsp),%r8
2059: e9 2c fc ff ff jmpq 1c8a <ZSTD_decompressBlock_internal+0xb6a>
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
205e: 83 fa 01 cmp $0x1,%edx
2061: 83 d6 00 adc $0x0,%esi
size_t const value = BIT_lookBitsFast(bitD, nbBits);
2064: 48 8b 9c 24 00 01 00 mov 0x100(%rsp),%rbx
206b: 00
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
206c: 44 89 f9 mov %r15d,%ecx
206f: 48 d3 e3 shl %cl,%rbx
2072: 48 c1 eb 3f shr $0x3f,%rbx
bitD->bitsConsumed += nbBits;
2076: 41 83 c7 01 add $0x1,%r15d
207a: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
2081: 00
2082: 48 01 f3 add %rsi,%rbx
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
2085: 48 83 fb 03 cmp $0x3,%rbx
2089: 0f 85 58 01 00 00 jne 21e7 <ZSTD_decompressBlock_internal+0x10c7>
208f: 48 8b 84 24 58 01 00 mov 0x158(%rsp),%rax
2096: 00
2097: 48 83 c0 ff add $0xffffffffffffffff,%rax
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
209b: 48 83 f8 01 cmp $0x1,%rax
209f: 48 83 d0 00 adc $0x0,%rax
20a3: 48 89 44 24 38 mov %rax,0x38(%rsp)
20a8: e9 55 01 00 00 jmpq 2202 <ZSTD_decompressBlock_internal+0x10e2>
seqState->prevOffset[1] = seqState->prevOffset[0];
20ad: 48 8b 8c 24 58 01 00 mov 0x158(%rsp),%rcx
20b4: 00
offset = seqState->prevOffset[1];
20b5: 48 8b 84 24 60 01 00 mov 0x160(%rsp),%rax
20bc: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
20bd: 48 89 8c 24 60 01 00 mov %rcx,0x160(%rsp)
20c4: 00
20c5: e9 6f fb ff ff jmpq 1c39 <ZSTD_decompressBlock_internal+0xb19>
ZSTD_memcpy(dst, src, 8);
20ca: 48 8b 45 00 mov 0x0(%rbp),%rax
20ce: 49 89 45 00 mov %rax,0x0(%r13)
*ip += 8;
20d2: 48 89 ee mov %rbp,%rsi
if (sequence.matchLength > 8) {
20d5: 49 83 fc 09 cmp $0x9,%r12
20d9: 0f 82 58 fd ff ff jb 1e37 <ZSTD_decompressBlock_internal+0xd17>
20df: 48 8d 4e 08 lea 0x8(%rsi),%rcx
20e3: 49 8d 55 08 lea 0x8(%r13),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
20e7: 48 89 d7 mov %rdx,%rdi
20ea: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
20ed: 4b 8d 04 2c lea (%r12,%r13,1),%rax
20f1: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
20f5: 0f 8f 45 01 00 00 jg 2240 <ZSTD_decompressBlock_internal+0x1120>
do {
20fb: 49 8d 7d 10 lea 0x10(%r13),%rdi
20ff: 48 39 f8 cmp %rdi,%rax
2102: 49 89 fa mov %rdi,%r10
2105: 4c 0f 47 d0 cmova %rax,%r10
2109: 4d 29 ea sub %r13,%r10
210c: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
2110: 49 83 fa 18 cmp $0x18,%r10
2114: 0f 82 8b 01 00 00 jb 22a5 <ZSTD_decompressBlock_internal+0x1185>
211a: 48 39 f8 cmp %rdi,%rax
211d: 48 0f 47 f8 cmova %rax,%rdi
2121: 4c 29 ef sub %r13,%rdi
2124: 48 83 c7 f7 add $0xfffffffffffffff7,%rdi
2128: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
212c: 48 8d 2c 3e lea (%rsi,%rdi,1),%rbp
2130: 48 83 c5 10 add $0x10,%rbp
2134: 48 39 ea cmp %rbp,%rdx
2137: 73 10 jae 2149 <ZSTD_decompressBlock_internal+0x1029>
2139: 4c 01 ef add %r13,%rdi
213c: 48 83 c7 10 add $0x10,%rdi
2140: 48 39 f9 cmp %rdi,%rcx
2143: 0f 82 5c 01 00 00 jb 22a5 <ZSTD_decompressBlock_internal+0x1185>
2149: 49 c1 ea 03 shr $0x3,%r10
214d: 49 83 c2 01 add $0x1,%r10
2151: 4d 89 d0 mov %r10,%r8
2154: 49 83 e0 fc and $0xfffffffffffffffc,%r8
2158: 49 8d 78 fc lea -0x4(%r8),%rdi
215c: 49 89 f9 mov %rdi,%r9
215f: 49 c1 e9 02 shr $0x2,%r9
2163: 49 83 c1 01 add $0x1,%r9
2167: 48 85 ff test %rdi,%rdi
216a: 0f 84 0e 01 00 00 je 227e <ZSTD_decompressBlock_internal+0x115e>
2170: 4c 89 cb mov %r9,%rbx
2173: 48 83 e3 fe and $0xfffffffffffffffe,%rbx
2177: 48 f7 db neg %rbx
217a: 31 ed xor %ebp,%ebp
ZSTD_memcpy(dst, src, 8);
217c: 0f 10 44 ee 08 movups 0x8(%rsi,%rbp,8),%xmm0
2181: 0f 10 4c ee 18 movups 0x18(%rsi,%rbp,8),%xmm1
2186: 41 0f 11 44 ed 08 movups %xmm0,0x8(%r13,%rbp,8)
218c: 41 0f 11 4c ed 18 movups %xmm1,0x18(%r13,%rbp,8)
2192: 0f 10 44 ee 28 movups 0x28(%rsi,%rbp,8),%xmm0
2197: 0f 10 4c ee 38 movups 0x38(%rsi,%rbp,8),%xmm1
219c: 41 0f 11 44 ed 28 movups %xmm0,0x28(%r13,%rbp,8)
21a2: 41 0f 11 4c ed 38 movups %xmm1,0x38(%r13,%rbp,8)
21a8: 48 83 c5 08 add $0x8,%rbp
21ac: 48 83 c3 02 add $0x2,%rbx
21b0: 75 ca jne 217c <ZSTD_decompressBlock_internal+0x105c>
21b2: e9 c9 00 00 00 jmpq 2280 <ZSTD_decompressBlock_internal+0x1160>
21b7: 48 89 fb mov %rdi,%rbx
bitD->ptr -= bitD->bitsConsumed >> 3;
21ba: 44 89 fe mov %r15d,%esi
21bd: c1 ee 03 shr $0x3,%esi
21c0: 48 29 f1 sub %rsi,%rcx
21c3: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
21ca: 00
bitD->bitsConsumed &= 7;
21cb: 41 83 e7 07 and $0x7,%r15d
21cf: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
21d6: 00
21d7: 48 8b 09 mov (%rcx),%rcx
bitD->bitContainer = MEM_readLEST(bitD->ptr);
21da: 48 89 8c 24 00 01 00 mov %rcx,0x100(%rsp)
21e1: 00
21e2: e9 a3 fa ff ff jmpq 1c8a <ZSTD_decompressBlock_internal+0xb6a>
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
21e7: 48 8b 84 dc 58 01 00 mov 0x158(%rsp,%rbx,8),%rax
21ee: 00
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
21ef: 48 83 f8 01 cmp $0x1,%rax
21f3: 48 83 d0 00 adc $0x0,%rax
21f7: 48 89 44 24 38 mov %rax,0x38(%rsp)
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
21fc: 48 83 fb 01 cmp $0x1,%rbx
2200: 74 10 je 2212 <ZSTD_decompressBlock_internal+0x10f2>
2202: 48 8b 8c 24 60 01 00 mov 0x160(%rsp),%rcx
2209: 00
220a: 48 89 8c 24 68 01 00 mov %rcx,0x168(%rsp)
2211: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
2212: 48 8b 8c 24 58 01 00 mov 0x158(%rsp),%rcx
2219: 00
221a: 48 89 8c 24 60 01 00 mov %rcx,0x160(%rsp)
2221: 00
2222: 48 8b 44 24 38 mov 0x38(%rsp),%rax
2227: 48 89 84 24 58 01 00 mov %rax,0x158(%rsp)
222e: 00
222f: 45 00 ca add %r9b,%r10b
if (mlBits > 0)
2232: 45 84 c0 test %r8b,%r8b
2235: 0f 85 13 fa ff ff jne 1c4e <ZSTD_decompressBlock_internal+0xb2e>
223b: e9 32 fa ff ff jmpq 1c72 <ZSTD_decompressBlock_internal+0xb52>
ZSTD_memcpy(dst, src, 16);
2240: 0f 10 01 movups (%rcx),%xmm0
2243: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
2246: 49 83 fc 19 cmp $0x19,%r12
224a: 7c 6c jl 22b8 <ZSTD_decompressBlock_internal+0x1198>
op += 16;
224c: 49 83 c5 18 add $0x18,%r13
do {
2250: 48 83 c6 28 add $0x28,%rsi
2254: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
2256: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
225b: 41 0f 11 44 0d 00 movups %xmm0,0x0(%r13,%rcx,1)
2261: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
2265: 41 0f 11 44 0d 10 movups %xmm0,0x10(%r13,%rcx,1)
while (op < oend);
226b: 4a 8d 14 29 lea (%rcx,%r13,1),%rdx
226f: 48 83 c2 20 add $0x20,%rdx
2273: 48 83 c1 20 add $0x20,%rcx
2277: 48 39 c2 cmp %rax,%rdx
}
227a: 72 da jb 2256 <ZSTD_decompressBlock_internal+0x1136>
227c: eb 3a jmp 22b8 <ZSTD_decompressBlock_internal+0x1198>
227e: 31 ed xor %ebp,%ebp
2280: 41 f6 c1 01 test $0x1,%r9b
2284: 74 12 je 2298 <ZSTD_decompressBlock_internal+0x1178>
ZSTD_memcpy(dst, src, 8);
2286: 0f 10 04 e9 movups (%rcx,%rbp,8),%xmm0
228a: 0f 10 4c e9 10 movups 0x10(%rcx,%rbp,8),%xmm1
228f: 0f 11 04 ea movups %xmm0,(%rdx,%rbp,8)
2293: 0f 11 4c ea 10 movups %xmm1,0x10(%rdx,%rbp,8)
} while (op < oend);
2298: 4d 39 c2 cmp %r8,%r10
229b: 74 1b je 22b8 <ZSTD_decompressBlock_internal+0x1198>
229d: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
22a1: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
ZSTD_memcpy(dst, src, 8);
22a5: 48 8b 31 mov (%rcx),%rsi
22a8: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
22ab: 48 83 c2 08 add $0x8,%rdx
22af: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
22b3: 48 39 c2 cmp %rax,%rdx
22b6: 72 ed jb 22a5 <ZSTD_decompressBlock_internal+0x1185>
22b8: 8b 44 24 14 mov 0x14(%rsp),%eax
22bc: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx
22c1: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
22c5: 0f 86 d6 fb ff ff jbe 1ea1 <ZSTD_decompressBlock_internal+0xd81>
22cb: e9 58 12 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
22d0: 41 83 ff 40 cmp $0x40,%r15d
22d4: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
22d9: 0f 86 d4 11 00 00 jbe 34b3 <ZSTD_decompressBlock_internal+0x2393>
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
22df: 8b 84 24 58 01 00 00 mov 0x158(%rsp),%eax
22e6: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx
22eb: 89 81 3c 68 00 00 mov %eax,0x683c(%rcx)
22f1: 8b 84 24 60 01 00 00 mov 0x160(%rsp),%eax
22f8: 89 81 40 68 00 00 mov %eax,0x6840(%rcx)
22fe: 8b 84 24 68 01 00 00 mov 0x168(%rsp),%eax
2305: 89 81 44 68 00 00 mov %eax,0x6844(%rcx)
{ size_t const lastLLSize = litEnd - litPtr;
230b: 48 8b 74 24 60 mov 0x60(%rsp),%rsi
2310: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx
2315: 4c 8b 74 24 30 mov 0x30(%rsp),%r14
231a: 48 29 f3 sub %rsi,%rbx
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
231d: 4c 29 f2 sub %r14,%rdx
2320: 49 c7 c3 ba ff ff ff mov $0xffffffffffffffba,%r11
2327: 48 39 d3 cmp %rdx,%rbx
232a: 0f 87 f8 11 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
if (op != NULL) {
2330: 4d 85 f6 test %r14,%r14
2333: 74 13 je 2348 <ZSTD_decompressBlock_internal+0x1228>
ZSTD_memcpy(op, litPtr, lastLLSize);
2335: 4c 89 f7 mov %r14,%rdi
2338: 48 89 da mov %rbx,%rdx
233b: e8 00 00 00 00 callq 2340 <ZSTD_decompressBlock_internal+0x1220>
op += lastLLSize;
2340: 49 01 de add %rbx,%r14
2343: 4d 89 f3 mov %r14,%r11
2346: eb 03 jmp 234b <ZSTD_decompressBlock_internal+0x122b>
2348: 45 31 db xor %r11d,%r11d
return op-ostart;
234b: 4c 2b 5c 24 40 sub 0x40(%rsp),%r11
2350: e9 d3 11 00 00 jmpq 3528 <ZSTD_decompressBlock_internal+0x2408>
2355: 45 31 e4 xor %r12d,%r12d
2358: e9 3d f4 ff ff jmpq 179a <ZSTD_decompressBlock_internal+0x67a>
235d: 45 31 e4 xor %r12d,%r12d
2360: e9 d3 f4 ff ff jmpq 1838 <ZSTD_decompressBlock_internal+0x718>
2365: 45 31 e4 xor %r12d,%r12d
DStatePtr->table = dt + 1;
2368: 48 8d 4b 08 lea 0x8(%rbx),%rcx
236c: 48 89 8c 24 b0 00 00 mov %rcx,0xb0(%rsp)
2373: 00
2374: 48 89 9c 24 08 02 00 mov %rbx,0x208(%rsp)
237b: 00
237c: 4c 89 7c 24 48 mov %r15,0x48(%rsp)
2381: 4c 89 ac 24 c8 01 00 mov %r13,0x1c8(%rsp)
2388: 00
2389: 31 db xor %ebx,%ebx
238b: 8b 8c 24 ec 00 00 00 mov 0xec(%rsp),%ecx
2392: 85 c9 test %ecx,%ecx
2394: 49 89 e9 mov %rbp,%r9
2397: bd 00 00 00 00 mov $0x0,%ebp
239c: 0f 49 e9 cmovns %ecx,%ebp
239f: 48 89 6c 24 30 mov %rbp,0x30(%rsp)
23a4: 4d 89 cf mov %r9,%r15
23a7: 0f 13 84 24 d8 00 00 movlps %xmm0,0xd8(%rsp)
23ae: 00
23af: 4c 8d 8c 24 10 01 00 lea 0x110(%rsp),%r9
23b6: 00
23b7: 4d 89 e5 mov %r12,%r13
23ba: e9 db 00 00 00 jmpq 249a <ZSTD_decompressBlock_internal+0x137a>
23bf: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx
23c4: 8b 94 24 f4 01 00 00 mov 0x1f4(%rsp),%edx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
23cb: 01 d0 add %edx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
23cd: 89 c1 mov %eax,%ecx
23cf: f6 d9 neg %cl
23d1: 4c 89 fe mov %r15,%rsi
23d4: 48 d3 ee shr %cl,%rsi
23d7: 89 d1 mov %edx,%ecx
23d9: 23 34 8d 00 00 00 00 and 0x0(,%rcx,4),%esi
DStatePtr->state = DInfo.nextState + lowBits;
23e0: 48 03 b4 24 20 02 00 add 0x220(%rsp),%rsi
23e7: 00
23e8: 8b 94 24 f8 01 00 00 mov 0x1f8(%rsp),%edx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
23ef: 01 d0 add %edx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
23f1: 89 c1 mov %eax,%ecx
23f3: f6 d9 neg %cl
23f5: 4d 89 f8 mov %r15,%r8
23f8: 49 d3 e8 shr %cl,%r8
23fb: 89 d1 mov %edx,%ecx
23fd: 44 23 04 8d 00 00 00 and 0x0(,%rcx,4),%r8d
2404: 00
2405: 8b ac 24 e8 01 00 00 mov 0x1e8(%rsp),%ebp
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
240c: 01 e8 add %ebp,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
240e: 89 c1 mov %eax,%ecx
2410: f6 d9 neg %cl
2412: 4c 89 fa mov %r15,%rdx
2415: 48 d3 ea shr %cl,%rdx
2418: 4c 03 84 24 d8 01 00 add 0x1d8(%rsp),%r8
241f: 00
2420: 89 e9 mov %ebp,%ecx
2422: 23 14 8d 00 00 00 00 and 0x0(,%rcx,4),%edx
2429: 48 89 b4 24 88 00 00 mov %rsi,0x88(%rsp)
2430: 00
2431: 4c 89 84 24 a8 00 00 mov %r8,0xa8(%rsp)
2438: 00
2439: 48 03 94 24 d0 00 00 add 0xd0(%rsp),%rdx
2440: 00
bitD->bitsConsumed += nbBits;
2441: 89 44 24 68 mov %eax,0x68(%rsp)
prefetchPos += sequence.litLength;
2445: 49 01 de add %rbx,%r14
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;
2448: 4d 39 d6 cmp %r10,%r14
244b: 48 89 f9 mov %rdi,%rcx
244e: 48 0f 42 4c 24 38 cmovb 0x38(%rsp),%rcx
DStatePtr->state = DInfo.nextState + lowBits;
2454: 48 89 94 24 98 00 00 mov %rdx,0x98(%rsp)
245b: 00
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.
245c: 4c 01 f1 add %r14,%rcx
245f: 4c 29 d1 sub %r10,%rcx
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
2462: 0f 18 09 prefetcht0 (%rcx)
2465: 0f 18 49 40 prefetcht0 0x40(%rcx)
sequences[seqNb] = sequence;
2469: 49 89 59 f0 mov %rbx,-0x10(%r9)
return prefetchPos + sequence.matchLength;
246d: 4d 01 de add %r11,%r14
sequences[seqNb] = sequence;
2470: 4d 89 59 f8 mov %r11,-0x8(%r9)
2474: 4d 89 11 mov %r10,(%r9)
2477: 48 8b 9c 24 f0 00 00 mov 0xf0(%rsp),%rbx
247e: 00
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
247f: 48 83 c3 01 add $0x1,%rbx
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
2483: 49 83 c1 18 add $0x18,%r9
2487: 4c 89 54 24 48 mov %r10,0x48(%rsp)
248c: 83 f8 40 cmp $0x40,%eax
248f: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
2494: 0f 87 60 03 00 00 ja 27fa <ZSTD_decompressBlock_internal+0x16da>
if (bitD->ptr >= bitD->limitPtr) {
249a: 49 83 fd 08 cmp $0x8,%r13
249e: 7d 41 jge 24e1 <ZSTD_decompressBlock_internal+0x13c1>
if (bitD->ptr == bitD->start) {
24a0: 4d 85 ed test %r13,%r13
24a3: 0f 84 14 02 00 00 je 26bd <ZSTD_decompressBlock_internal+0x159d>
24a9: 4c 8b a4 24 c8 01 00 mov 0x1c8(%rsp),%r12
24b0: 00
24b1: 4b 8d 0c 2c lea (%r12,%r13,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
24b5: 89 c5 mov %eax,%ebp
24b7: c1 ed 03 shr $0x3,%ebp
if (bitD->ptr - nbBytes < bitD->start) {
24ba: 48 29 e9 sub %rbp,%rcx
24bd: 4c 39 e1 cmp %r12,%rcx
24c0: 44 89 e9 mov %r13d,%ecx
24c3: 0f 43 cd cmovae %ebp,%ecx
bitD->ptr -= nbBytes;
24c6: 49 29 cd sub %rcx,%r13
24c9: 4b 8d 2c 2c lea (%r12,%r13,1),%rbp
24cd: 48 89 6c 24 70 mov %rbp,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
24d2: c1 e1 03 shl $0x3,%ecx
24d5: 29 c8 sub %ecx,%eax
24d7: 89 44 24 68 mov %eax,0x68(%rsp)
24db: 4f 8b 3c 2c mov (%r12,%r13,1),%r15
24df: eb 27 jmp 2508 <ZSTD_decompressBlock_internal+0x13e8>
bitD->ptr -= bitD->bitsConsumed >> 3;
24e1: 89 c1 mov %eax,%ecx
24e3: c1 e9 03 shr $0x3,%ecx
24e6: 49 29 cd sub %rcx,%r13
24e9: 48 8b ac 24 c8 01 00 mov 0x1c8(%rsp),%rbp
24f0: 00
24f1: 48 89 e9 mov %rbp,%rcx
24f4: 4c 01 e9 add %r13,%rcx
24f7: 48 89 4c 24 70 mov %rcx,0x70(%rsp)
bitD->bitsConsumed &= 7;
24fc: 83 e0 07 and $0x7,%eax
24ff: 89 44 24 68 mov %eax,0x68(%rsp)
2503: 4e 8b 7c 2d 00 mov 0x0(%rbp,%r13,1),%r15
2508: 4c 89 7c 24 60 mov %r15,0x60(%rsp)
250d: 4d 89 ec mov %r13,%r12
2510: 48 39 5c 24 30 cmp %rbx,0x30(%rsp)
2515: 0f 84 cb 02 00 00 je 27e6 <ZSTD_decompressBlock_internal+0x16c6>
251b: 4c 89 ac 24 00 02 00 mov %r13,0x200(%rsp)
2522: 00
2523: 48 89 9c 24 f0 00 00 mov %rbx,0xf0(%rsp)
252a: 00
252b: 4c 89 7c 24 28 mov %r15,0x28(%rsp)
2530: 48 8b 8c 24 18 02 00 mov 0x218(%rsp),%rcx
2537: 00
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
2538: 0f b7 2c f1 movzwl (%rcx,%rsi,8),%ebp
253c: 48 89 ac 24 20 02 00 mov %rbp,0x220(%rsp)
2543: 00
2544: 44 0f b6 5c f1 02 movzbl 0x2(%rcx,%rsi,8),%r11d
254a: 0f b6 6c f1 03 movzbl 0x3(%rcx,%rsi,8),%ebp
254f: 89 ac 24 f4 01 00 00 mov %ebp,0x1f4(%rsp)
2556: 8b 4c f1 04 mov 0x4(%rcx,%rsi,8),%ecx
255a: 48 89 4c 24 58 mov %rcx,0x58(%rsp)
255f: 48 8b 8c 24 08 02 00 mov 0x208(%rsp),%rcx
2566: 00
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
2567: 46 0f b7 54 c1 08 movzwl 0x8(%rcx,%r8,8),%r10d
256d: 46 0f b6 6c c1 0a movzbl 0xa(%rcx,%r8,8),%r13d
2573: 42 0f b6 5c c1 0b movzbl 0xb(%rcx,%r8,8),%ebx
2579: 42 8b 4c c1 0c mov 0xc(%rcx,%r8,8),%ecx
257e: 48 89 8c 24 e0 01 00 mov %rcx,0x1e0(%rsp)
2585: 00
2586: 48 8b 8c 24 10 02 00 mov 0x210(%rsp),%rcx
258d: 00
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
258e: 0f b7 34 d1 movzwl (%rcx,%rdx,8),%esi
2592: 44 0f b6 7c d1 02 movzbl 0x2(%rcx,%rdx,8),%r15d
2598: 4c 89 5c 24 50 mov %r11,0x50(%rsp)
BYTE const totalBits = llBits+mlBits+ofBits;
259d: 47 8d 04 2b lea (%r11,%r13,1),%r8d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
25a1: 0f b6 6c d1 03 movzbl 0x3(%rcx,%rdx,8),%ebp
25a6: 8b 54 d1 04 mov 0x4(%rcx,%rdx,8),%edx
25aa: 41 83 ff 02 cmp $0x2,%r15d
25ae: 48 89 b4 24 d0 00 00 mov %rsi,0xd0(%rsp)
25b5: 00
25b6: 4c 89 94 24 d8 01 00 mov %r10,0x1d8(%rsp)
25bd: 00
25be: 89 ac 24 e8 01 00 00 mov %ebp,0x1e8(%rsp)
25c5: 89 9c 24 f8 01 00 00 mov %ebx,0x1f8(%rsp)
if (ofBits > 1) {
25cc: 72 51 jb 261f <ZSTD_decompressBlock_internal+0x14ff>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
25ce: 89 c1 mov %eax,%ecx
bitD->bitsConsumed += nbBits;
25d0: 44 01 f8 add %r15d,%eax
25d3: 89 44 24 68 mov %eax,0x68(%rsp)
25d7: 48 8b bc 24 d8 00 00 mov 0xd8(%rsp),%rdi
25de: 00
seqState->prevOffset[2] = seqState->prevOffset[1];
25df: 48 89 bc 24 c8 00 00 mov %rdi,0xc8(%rsp)
25e6: 00
25e7: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
25ec: 48 d3 e7 shl %cl,%rdi
25ef: 44 89 f9 mov %r15d,%ecx
25f2: f6 d9 neg %cl
25f4: 48 d3 ef shr %cl,%rdi
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
25f7: 48 01 d7 add %rdx,%rdi
25fa: 48 89 f9 mov %rdi,%rcx
25fd: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi
2602: 4c 8b 5c 24 48 mov 0x48(%rsp),%r11
2607: 4c 89 9c 24 c0 00 00 mov %r11,0xc0(%rsp)
260e: 00
260f: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp)
2616: 00
2617: 49 89 ca mov %rcx,%r10
261a: 4c 89 d9 mov %r11,%rcx
261d: eb 1d jmp 263c <ZSTD_decompressBlock_internal+0x151c>
if (LIKELY((ofBits == 0))) {
261f: 45 84 ff test %r15b,%r15b
2622: 0f 85 a8 00 00 00 jne 26d0 <ZSTD_decompressBlock_internal+0x15b0>
U32 const ll0 = (llBase == 0);
2628: 83 7c 24 58 00 cmpl $0x0,0x58(%rsp)
262d: 48 8b 8c 24 d8 00 00 mov 0xd8(%rsp),%rcx
2634: 00
if (LIKELY(!ll0))
2635: 74 cb je 2602 <ZSTD_decompressBlock_internal+0x14e2>
2637: 4c 8b 54 24 48 mov 0x48(%rsp),%r10
263c: 48 8b 74 24 50 mov 0x50(%rsp),%rsi
2641: 48 89 8c 24 d8 00 00 mov %rcx,0xd8(%rsp)
2648: 00
2649: 45 00 f8 add %r15b,%r8b
if (mlBits > 0)
264c: 45 84 ed test %r13b,%r13b
264f: 4c 8b 9c 24 e0 01 00 mov 0x1e0(%rsp),%r11
2656: 00
2657: 74 21 je 267a <ZSTD_decompressBlock_internal+0x155a>
2659: 4c 8b 7c 24 28 mov 0x28(%rsp),%r15
265e: 4c 89 fa mov %r15,%rdx
2661: 89 c1 mov %eax,%ecx
2663: 48 d3 e2 shl %cl,%rdx
2666: 44 89 e9 mov %r13d,%ecx
2669: f6 d9 neg %cl
266b: 48 d3 ea shr %cl,%rdx
bitD->bitsConsumed += nbBits;
266e: 44 01 e8 add %r13d,%eax
2671: 89 44 24 68 mov %eax,0x68(%rsp)
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
2675: 49 01 d3 add %rdx,%r11
2678: eb 05 jmp 267f <ZSTD_decompressBlock_internal+0x155f>
267a: 4c 8b 7c 24 28 mov 0x28(%rsp),%r15
267f: 4c 8b ac 24 00 02 00 mov 0x200(%rsp),%r13
2686: 00
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
2687: 41 80 f8 1f cmp $0x1f,%r8b
268b: 72 05 jb 2692 <ZSTD_decompressBlock_internal+0x1572>
268d: 83 f8 40 cmp $0x40,%eax
2690: 76 77 jbe 2709 <ZSTD_decompressBlock_internal+0x15e9>
if (llBits > 0)
2692: 40 84 f6 test %sil,%sil
2695: 0f 84 24 fd ff ff je 23bf <ZSTD_decompressBlock_internal+0x129f>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
269b: 4c 89 fa mov %r15,%rdx
269e: 89 c1 mov %eax,%ecx
26a0: 48 d3 e2 shl %cl,%rdx
26a3: 89 f1 mov %esi,%ecx
26a5: f6 d9 neg %cl
26a7: 48 d3 ea shr %cl,%rdx
bitD->bitsConsumed += nbBits;
26aa: 01 f0 add %esi,%eax
26ac: 89 44 24 68 mov %eax,0x68(%rsp)
26b0: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
26b5: 48 01 d3 add %rdx,%rbx
26b8: e9 07 fd ff ff jmpq 23c4 <ZSTD_decompressBlock_internal+0x12a4>
26bd: 45 31 ed xor %r13d,%r13d
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
26c0: 48 39 5c 24 30 cmp %rbx,0x30(%rsp)
26c5: 0f 85 50 fe ff ff jne 251b <ZSTD_decompressBlock_internal+0x13fb>
26cb: e9 16 01 00 00 jmpq 27e6 <ZSTD_decompressBlock_internal+0x16c6>
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
26d0: 83 7c 24 58 01 cmpl $0x1,0x58(%rsp)
26d5: 83 d2 00 adc $0x0,%edx
26d8: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
26dd: 89 c1 mov %eax,%ecx
26df: 48 d3 e7 shl %cl,%rdi
26e2: 48 c1 ef 3f shr $0x3f,%rdi
bitD->bitsConsumed += nbBits;
26e6: 83 c0 01 add $0x1,%eax
26e9: 89 44 24 68 mov %eax,0x68(%rsp)
26ed: 48 01 d7 add %rdx,%rdi
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
26f0: 48 83 ff 03 cmp $0x3,%rdi
26f4: 75 5a jne 2750 <ZSTD_decompressBlock_internal+0x1630>
26f6: 48 8b 4c 24 48 mov 0x48(%rsp),%rcx
26fb: 48 83 c1 ff add $0xffffffffffffffff,%rcx
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
26ff: 48 83 f9 01 cmp $0x1,%rcx
2703: 48 83 d1 00 adc $0x0,%rcx
2707: eb 61 jmp 276a <ZSTD_decompressBlock_internal+0x164a>
if (bitD->ptr >= bitD->limitPtr) {
2709: 49 83 fc 08 cmp $0x8,%r12
270d: 7d 70 jge 277f <ZSTD_decompressBlock_internal+0x165f>
if (bitD->ptr == bitD->start) {
270f: 4d 85 e4 test %r12,%r12
2712: 0f 84 ab 00 00 00 je 27c3 <ZSTD_decompressBlock_internal+0x16a3>
2718: 48 8b b4 24 c8 01 00 mov 0x1c8(%rsp),%rsi
271f: 00
2720: 4a 8d 0c 26 lea (%rsi,%r12,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
2724: 89 c2 mov %eax,%edx
2726: c1 ea 03 shr $0x3,%edx
if (bitD->ptr - nbBytes < bitD->start) {
2729: 48 29 d1 sub %rdx,%rcx
272c: 48 39 f1 cmp %rsi,%rcx
272f: 44 89 e1 mov %r12d,%ecx
2732: 0f 43 ca cmovae %edx,%ecx
bitD->ptr -= nbBytes;
2735: 49 29 cc sub %rcx,%r12
2738: 4a 8d 14 26 lea (%rsi,%r12,1),%rdx
273c: 48 89 54 24 70 mov %rdx,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
2741: c1 e1 03 shl $0x3,%ecx
2744: 29 c8 sub %ecx,%eax
2746: 89 44 24 68 mov %eax,0x68(%rsp)
274a: 4e 8b 3c 26 mov (%rsi,%r12,1),%r15
274e: eb 53 jmp 27a3 <ZSTD_decompressBlock_internal+0x1683>
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
2750: 48 8b 8c fc b8 00 00 mov 0xb8(%rsp,%rdi,8),%rcx
2757: 00
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
2758: 48 83 f9 01 cmp $0x1,%rcx
275c: 48 83 d1 00 adc $0x0,%rcx
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
2760: 48 83 ff 01 cmp $0x1,%rdi
2764: 0f 84 93 fe ff ff je 25fd <ZSTD_decompressBlock_internal+0x14dd>
276a: 48 8b 94 24 d8 00 00 mov 0xd8(%rsp),%rdx
2771: 00
2772: 48 89 94 24 c8 00 00 mov %rdx,0xc8(%rsp)
2779: 00
277a: e9 7e fe ff ff jmpq 25fd <ZSTD_decompressBlock_internal+0x14dd>
bitD->ptr -= bitD->bitsConsumed >> 3;
277f: 89 c1 mov %eax,%ecx
2781: c1 e9 03 shr $0x3,%ecx
2784: 49 29 cc sub %rcx,%r12
2787: 48 8b 94 24 c8 01 00 mov 0x1c8(%rsp),%rdx
278e: 00
278f: 4a 8d 0c 22 lea (%rdx,%r12,1),%rcx
2793: 48 89 4c 24 70 mov %rcx,0x70(%rsp)
bitD->bitsConsumed &= 7;
2798: 83 e0 07 and $0x7,%eax
279b: 89 44 24 68 mov %eax,0x68(%rsp)
279f: 4e 8b 3c 22 mov (%rdx,%r12,1),%r15
27a3: 4c 89 7c 24 60 mov %r15,0x60(%rsp)
27a8: 4d 89 e5 mov %r12,%r13
27ab: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi
27b0: 48 8b 74 24 50 mov 0x50(%rsp),%rsi
if (llBits > 0)
27b5: 40 84 f6 test %sil,%sil
27b8: 0f 85 dd fe ff ff jne 269b <ZSTD_decompressBlock_internal+0x157b>
27be: e9 fc fb ff ff jmpq 23bf <ZSTD_decompressBlock_internal+0x129f>
27c3: 45 31 e4 xor %r12d,%r12d
27c6: 45 31 ed xor %r13d,%r13d
27c9: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi
27ce: 4c 8b 7c 24 28 mov 0x28(%rsp),%r15
27d3: 48 8b 74 24 50 mov 0x50(%rsp),%rsi
27d8: 40 84 f6 test %sil,%sil
27db: 0f 85 ba fe ff ff jne 269b <ZSTD_decompressBlock_internal+0x157b>
27e1: e9 d9 fb ff ff jmpq 23bf <ZSTD_decompressBlock_internal+0x129f>
27e6: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
27eb: 44 8b 4c 24 14 mov 0x14(%rsp),%r9d
27f0: 4c 8b 7c 24 30 mov 0x30(%rsp),%r15
27f5: 49 89 f8 mov %rdi,%r8
27f8: eb 25 jmp 281f <ZSTD_decompressBlock_internal+0x16ff>
27fa: 41 89 df mov %ebx,%r15d
27fd: 44 8b 4c 24 14 mov 0x14(%rsp),%r9d
2802: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
2809: 44 3b bc 24 ec 00 00 cmp 0xec(%rsp),%r15d
2810: 00
2811: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
2816: 49 89 f8 mov %rdi,%r8
RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, "");
2819: 0f 8c 09 0d 00 00 jl 3528 <ZSTD_decompressBlock_internal+0x2408>
281f: 48 8d 4a e0 lea -0x20(%rdx),%rcx
2823: 48 89 8c 24 d8 01 00 mov %rcx,0x1d8(%rsp)
282a: 00
282b: 48 8b 7c 24 40 mov 0x40(%rsp),%rdi
2830: 48 89 7c 24 28 mov %rdi,0x28(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
2835: 83 f8 41 cmp $0x41,%eax
2838: 0f 83 e1 07 00 00 jae 301f <ZSTD_decompressBlock_internal+0x1eff>
if (bitD->ptr >= bitD->limitPtr) {
283e: 4c 8b 5c 24 70 mov 0x70(%rsp),%r11
2843: 48 8b 9c 24 80 00 00 mov 0x80(%rsp),%rbx
284a: 00
284b: 49 39 db cmp %rbx,%r11
284e: 73 39 jae 2889 <ZSTD_decompressBlock_internal+0x1769>
if (bitD->ptr == bitD->start) {
2850: 48 8b 4c 24 78 mov 0x78(%rsp),%rcx
2855: 49 39 cb cmp %rcx,%r11
2858: 74 4b je 28a5 <ZSTD_decompressBlock_internal+0x1785>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
285a: 89 c6 mov %eax,%esi
285c: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
285f: 4c 89 df mov %r11,%rdi
2862: 48 29 f7 sub %rsi,%rdi
2865: 44 89 da mov %r11d,%edx
2868: 29 ca sub %ecx,%edx
286a: 48 39 cf cmp %rcx,%rdi
286d: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
2872: 0f 43 d6 cmovae %esi,%edx
bitD->ptr -= nbBytes;
2875: 49 29 d3 sub %rdx,%r11
2878: 4c 89 5c 24 70 mov %r11,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
287d: c1 e2 03 shl $0x3,%edx
2880: 29 d0 sub %edx,%eax
2882: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
2887: eb 10 jmp 2899 <ZSTD_decompressBlock_internal+0x1779>
bitD->ptr -= bitD->bitsConsumed >> 3;
2889: 89 c1 mov %eax,%ecx
288b: c1 e9 03 shr $0x3,%ecx
288e: 49 29 cb sub %rcx,%r11
2891: 4c 89 5c 24 70 mov %r11,0x70(%rsp)
bitD->bitsConsumed &= 7;
2896: 83 e0 07 and $0x7,%eax
2899: 89 44 24 68 mov %eax,0x68(%rsp)
289d: 49 8b 0b mov (%r11),%rcx
28a0: 48 89 4c 24 60 mov %rcx,0x60(%rsp)
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
28a5: 45 39 cf cmp %r9d,%r15d
28a8: 0f 8d 81 07 00 00 jge 302f <ZSTD_decompressBlock_internal+0x1f0f>
28ae: 48 89 9c 24 e8 01 00 mov %rbx,0x1e8(%rsp)
28b5: 00
28b6: 4c 89 7c 24 30 mov %r15,0x30(%rsp)
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
28bb: 48 8b 8c 24 88 00 00 mov 0x88(%rsp),%rcx
28c2: 00
28c3: 48 8b 94 24 90 00 00 mov 0x90(%rsp),%rdx
28ca: 00
28cb: 0f b7 34 ca movzwl (%rdx,%rcx,8),%esi
28cf: 48 89 b4 24 f0 00 00 mov %rsi,0xf0(%rsp)
28d6: 00
28d7: 44 0f b6 54 ca 02 movzbl 0x2(%rdx,%rcx,8),%r10d
28dd: 44 0f b6 6c ca 03 movzbl 0x3(%rdx,%rcx,8),%r13d
28e3: 8b 6c ca 04 mov 0x4(%rdx,%rcx,8),%ebp
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
28e7: 48 8b 8c 24 b0 00 00 mov 0xb0(%rsp),%rcx
28ee: 00
28ef: 48 8b 94 24 a8 00 00 mov 0xa8(%rsp),%rdx
28f6: 00
28f7: 0f b7 34 d1 movzwl (%rcx,%rdx,8),%esi
28fb: 48 89 b4 24 d8 00 00 mov %rsi,0xd8(%rsp)
2902: 00
2903: 44 0f b6 4c d1 02 movzbl 0x2(%rcx,%rdx,8),%r9d
2909: 44 0f b6 64 d1 03 movzbl 0x3(%rcx,%rdx,8),%r12d
290f: 8b 5c d1 04 mov 0x4(%rcx,%rdx,8),%ebx
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
2913: 48 8b 8c 24 a0 00 00 mov 0xa0(%rsp),%rcx
291a: 00
291b: 48 8b 94 24 98 00 00 mov 0x98(%rsp),%rdx
2922: 00
2923: 0f b7 34 d1 movzwl (%rcx,%rdx,8),%esi
2927: 48 89 74 24 48 mov %rsi,0x48(%rsp)
292c: 0f b6 74 d1 02 movzbl 0x2(%rcx,%rdx,8),%esi
BYTE const totalBits = llBits+mlBits+ofBits;
2931: 47 8d 3c 11 lea (%r9,%r10,1),%r15d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
2935: 0f b6 7c d1 03 movzbl 0x3(%rcx,%rdx,8),%edi
293a: 89 7c 24 50 mov %edi,0x50(%rsp)
293e: 44 8b 44 d1 04 mov 0x4(%rcx,%rdx,8),%r8d
2943: 83 fe 02 cmp $0x2,%esi
2946: 48 89 6c 24 58 mov %rbp,0x58(%rsp)
if (ofBits > 1) {
294b: 0f 82 15 02 00 00 jb 2b66 <ZSTD_decompressBlock_internal+0x1a46>
size_t const value = BIT_lookBitsFast(bitD, nbBits);
2951: 48 8b 54 24 60 mov 0x60(%rsp),%rdx
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
2956: 89 c1 mov %eax,%ecx
2958: 48 d3 e2 shl %cl,%rdx
295b: 89 f1 mov %esi,%ecx
295d: f6 d9 neg %cl
295f: 48 d3 ea shr %cl,%rdx
bitD->bitsConsumed += nbBits;
2962: 01 f0 add %esi,%eax
2964: 89 44 24 68 mov %eax,0x68(%rsp)
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
2968: 4c 01 c2 add %r8,%rdx
seqState->prevOffset[1] = seqState->prevOffset[0];
296b: 0f 10 84 24 b8 00 00 movups 0xb8(%rsp),%xmm0
2972: 00
2973: 0f 11 84 24 c0 00 00 movups %xmm0,0xc0(%rsp)
297a: 00
297b: 48 89 94 24 d0 00 00 mov %rdx,0xd0(%rsp)
2982: 00
2983: 48 89 94 24 b8 00 00 mov %rdx,0xb8(%rsp)
298a: 00
298b: 41 00 f7 add %sil,%r15b
if (mlBits > 0)
298e: 45 84 c9 test %r9b,%r9b
2991: 74 1c je 29af <ZSTD_decompressBlock_internal+0x188f>
size_t const value = BIT_lookBitsFast(bitD, nbBits);
2993: 48 8b 54 24 60 mov 0x60(%rsp),%rdx
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
2998: 89 c1 mov %eax,%ecx
299a: 48 d3 e2 shl %cl,%rdx
299d: 44 89 c9 mov %r9d,%ecx
29a0: f6 d9 neg %cl
29a2: 48 d3 ea shr %cl,%rdx
bitD->bitsConsumed += nbBits;
29a5: 44 01 c8 add %r9d,%eax
29a8: 89 44 24 68 mov %eax,0x68(%rsp)
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
29ac: 48 01 d3 add %rdx,%rbx
29af: 48 89 9c 24 e0 01 00 mov %rbx,0x1e0(%rsp)
29b6: 00
29b7: 4c 8b 4c 24 08 mov 0x8(%rsp),%r9
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
29bc: 41 80 ff 1f cmp $0x1f,%r15b
29c0: 72 09 jb 29cb <ZSTD_decompressBlock_internal+0x18ab>
29c2: 83 f8 40 cmp $0x40,%eax
29c5: 0f 86 a3 03 00 00 jbe 2d6e <ZSTD_decompressBlock_internal+0x1c4e>
29cb: 48 8b 54 24 60 mov 0x60(%rsp),%rdx
if (llBits > 0)
29d0: 45 84 d2 test %r10b,%r10b
29d3: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
29d8: 74 1c je 29f6 <ZSTD_decompressBlock_internal+0x18d6>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
29da: 48 89 d6 mov %rdx,%rsi
29dd: 89 c1 mov %eax,%ecx
29df: 48 d3 e6 shl %cl,%rsi
29e2: 44 89 d1 mov %r10d,%ecx
29e5: f6 d9 neg %cl
29e7: 48 d3 ee shr %cl,%rsi
bitD->bitsConsumed += nbBits;
29ea: 44 01 d0 add %r10d,%eax
29ed: 89 44 24 68 mov %eax,0x68(%rsp)
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
29f1: 48 01 74 24 58 add %rsi,0x58(%rsp)
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
29f6: 44 01 e8 add %r13d,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
29f9: 89 c1 mov %eax,%ecx
29fb: f6 d9 neg %cl
29fd: 48 89 d6 mov %rdx,%rsi
2a00: 48 d3 ee shr %cl,%rsi
2a03: 44 89 e9 mov %r13d,%ecx
2a06: 23 34 8d 00 00 00 00 and 0x0(,%rcx,4),%esi
DStatePtr->state = DInfo.nextState + lowBits;
2a0d: 48 03 b4 24 f0 00 00 add 0xf0(%rsp),%rsi
2a14: 00
2a15: 48 89 b4 24 88 00 00 mov %rsi,0x88(%rsp)
2a1c: 00
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
2a1d: 44 01 e0 add %r12d,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
2a20: 89 c1 mov %eax,%ecx
2a22: f6 d9 neg %cl
2a24: 48 89 d6 mov %rdx,%rsi
2a27: 48 d3 ee shr %cl,%rsi
2a2a: 44 89 e1 mov %r12d,%ecx
2a2d: 23 34 8d 00 00 00 00 and 0x0(,%rcx,4),%esi
2a34: 8b 6c 24 50 mov 0x50(%rsp),%ebp
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
2a38: 01 e8 add %ebp,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
2a3a: 89 c1 mov %eax,%ecx
2a3c: f6 d9 neg %cl
2a3e: 48 d3 ea shr %cl,%rdx
2a41: 48 03 b4 24 d8 00 00 add 0xd8(%rsp),%rsi
2a48: 00
2a49: 89 e9 mov %ebp,%ecx
2a4b: 23 14 8d 00 00 00 00 and 0x0(,%rcx,4),%edx
2a52: 48 89 b4 24 a8 00 00 mov %rsi,0xa8(%rsp)
2a59: 00
2a5a: 48 03 54 24 48 add 0x48(%rsp),%rdx
bitD->bitsConsumed += nbBits;
2a5f: 89 44 24 68 mov %eax,0x68(%rsp)
2a63: 48 89 94 24 98 00 00 mov %rdx,0x98(%rsp)
2a6a: 00
2a6b: 4c 8b 7c 24 30 mov 0x30(%rsp),%r15
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
2a70: 44 89 f8 mov %r15d,%eax
2a73: 83 e0 07 and $0x7,%eax
2a76: 48 8d 04 40 lea (%rax,%rax,2),%rax
2a7a: 48 8b 94 c4 00 01 00 mov 0x100(%rsp,%rax,8),%rdx
2a81: 00
2a82: 4c 8b ac c4 08 01 00 mov 0x108(%rsp,%rax,8),%r13
2a89: 00
2a8a: 48 89 44 24 48 mov %rax,0x48(%rsp)
2a8f: 4c 8b a4 c4 10 01 00 mov 0x110(%rsp,%rax,8),%r12
2a96: 00
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
2a97: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx
2a9e: 00
2a9f: 48 8d 04 11 lea (%rcx,%rdx,1),%rax
if (UNLIKELY(
2aa3: 48 3b 84 24 f8 00 00 cmp 0xf8(%rsp),%rax
2aaa: 00
2aab: 0f 87 db 01 00 00 ja 2c8c <ZSTD_decompressBlock_internal+0x1b6c>
2ab1: 4e 8d 1c 2a lea (%rdx,%r13,1),%r11
2ab5: 4a 8d 34 1f lea (%rdi,%r11,1),%rsi
2ab9: 48 3b b4 24 d8 01 00 cmp 0x1d8(%rsp),%rsi
2ac0: 00
2ac1: 0f 87 c5 01 00 00 ja 2c8c <ZSTD_decompressBlock_internal+0x1b6c>
2ac7: 48 8d 1c 17 lea (%rdi,%rdx,1),%rbx
2acb: 48 89 dd mov %rbx,%rbp
2ace: 4c 29 e5 sub %r12,%rbp
ZSTD_memcpy(dst, src, 16);
2ad1: 0f 10 01 movups (%rcx),%xmm0
2ad4: 0f 11 07 movups %xmm0,(%rdi)
if (UNLIKELY(sequence.litLength > 16)) {
2ad7: 48 83 fa 11 cmp $0x11,%rdx
2adb: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
2ae0: 0f 83 f5 01 00 00 jae 2cdb <ZSTD_decompressBlock_internal+0x1bbb>
*litPtr = iLitEnd; /* update for next sequence */
2ae6: 48 89 84 24 e0 00 00 mov %rax,0xe0(%rsp)
2aed: 00
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
2aee: 48 89 d8 mov %rbx,%rax
2af1: 4d 89 c8 mov %r9,%r8
2af4: 4c 29 c8 sub %r9,%rax
2af7: 4c 39 e0 cmp %r12,%rax
2afa: 0f 83 98 00 00 00 jae 2b98 <ZSTD_decompressBlock_internal+0x1a78>
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
2b00: 48 89 d8 mov %rbx,%rax
2b03: 48 2b 84 24 d0 01 00 sub 0x1d0(%rsp),%rax
2b0a: 00
2b0b: 4c 39 e0 cmp %r12,%rax
2b0e: 0f 82 0d 0a 00 00 jb 3521 <ZSTD_decompressBlock_internal+0x2401>
2b14: 4d 89 f7 mov %r14,%r15
2b17: 4d 89 de mov %r11,%r14
match = dictEnd + (match - prefixStart);
2b1a: 4c 29 c5 sub %r8,%rbp
2b1d: 48 8b 4c 24 38 mov 0x38(%rsp),%rcx
2b22: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
2b26: 4a 8d 04 2e lea (%rsi,%r13,1),%rax
2b2a: 48 39 c8 cmp %rcx,%rax
2b2d: 0f 86 b3 00 00 00 jbe 2be6 <ZSTD_decompressBlock_internal+0x1ac6>
{ size_t const length1 = dictEnd - match;
2b33: 48 89 ea mov %rbp,%rdx
2b36: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
2b39: 48 89 df mov %rbx,%rdi
2b3c: e8 00 00 00 00 callq 2b41 <ZSTD_decompressBlock_internal+0x1a21>
op = oLitEnd + length1;
2b41: 48 29 eb sub %rbp,%rbx
sequence.matchLength -= length1;
2b44: 49 01 ed add %rbp,%r13
2b47: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
2b4c: 4c 89 c5 mov %r8,%rbp
2b4f: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
2b54: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
2b59: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
2b5e: 4d 89 f3 mov %r14,%r11
2b61: 4d 89 fe mov %r15,%r14
2b64: eb 37 jmp 2b9d <ZSTD_decompressBlock_internal+0x1a7d>
if (LIKELY((ofBits == 0))) {
2b66: 40 84 f6 test %sil,%sil
2b69: 0f 85 43 02 00 00 jne 2db2 <ZSTD_decompressBlock_internal+0x1c92>
U32 const ll0 = (llBase == 0);
2b6f: 85 ed test %ebp,%ebp
if (LIKELY(!ll0))
2b71: 0f 84 85 02 00 00 je 2dfc <ZSTD_decompressBlock_internal+0x1cdc>
offset = seqState->prevOffset[0];
2b77: 48 8b 8c 24 b8 00 00 mov 0xb8(%rsp),%rcx
2b7e: 00
2b7f: 48 89 8c 24 d0 00 00 mov %rcx,0xd0(%rsp)
2b86: 00
2b87: 41 00 f7 add %sil,%r15b
if (mlBits > 0)
2b8a: 45 84 c9 test %r9b,%r9b
2b8d: 0f 85 00 fe ff ff jne 2993 <ZSTD_decompressBlock_internal+0x1873>
2b93: e9 17 fe ff ff jmpq 29af <ZSTD_decompressBlock_internal+0x188f>
2b98: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
2b9d: 49 83 fc 10 cmp $0x10,%r12
2ba1: 0f 82 83 01 00 00 jb 2d2a <ZSTD_decompressBlock_internal+0x1c0a>
2ba7: 0f 10 45 00 movups 0x0(%rbp),%xmm0
2bab: 0f 11 03 movups %xmm0,(%rbx)
if (16 >= length) return;
2bae: 49 83 fd 11 cmp $0x11,%r13
2bb2: 7c 57 jl 2c0b <ZSTD_decompressBlock_internal+0x1aeb>
2bb4: 49 01 dd add %rbx,%r13
do {
2bb7: 48 83 c5 10 add $0x10,%rbp
2bbb: b8 10 00 00 00 mov $0x10,%eax
ZSTD_memcpy(dst, src, 16);
2bc0: 0f 10 44 05 f0 movups -0x10(%rbp,%rax,1),%xmm0
2bc5: 0f 11 04 03 movups %xmm0,(%rbx,%rax,1)
2bc9: 0f 10 44 05 00 movups 0x0(%rbp,%rax,1),%xmm0
2bce: 0f 11 44 03 10 movups %xmm0,0x10(%rbx,%rax,1)
while (op < oend);
2bd3: 48 8d 0c 03 lea (%rbx,%rax,1),%rcx
2bd7: 48 83 c1 20 add $0x20,%rcx
2bdb: 48 83 c0 20 add $0x20,%rax
2bdf: 4c 39 e9 cmp %r13,%rcx
}
2be2: 72 dc jb 2bc0 <ZSTD_decompressBlock_internal+0x1aa0>
2be4: eb 25 jmp 2c0b <ZSTD_decompressBlock_internal+0x1aeb>
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
2be6: 48 89 df mov %rbx,%rdi
2be9: 4c 89 ea mov %r13,%rdx
2bec: e8 00 00 00 00 callq 2bf1 <ZSTD_decompressBlock_internal+0x1ad1>
2bf1: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
2bf6: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
2bfb: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
2c00: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
2c05: 4d 89 f3 mov %r14,%r11
2c08: 4d 89 fe mov %r15,%r14
2c0b: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
2c0f: 44 8b 4c 24 14 mov 0x14(%rsp),%r9d
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
2c14: 0f 87 0e 09 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
2c1a: 48 8b 74 24 58 mov 0x58(%rsp),%rsi
prefetchPos += sequence.litLength;
2c1f: 49 01 f6 add %rsi,%r14
2c22: 48 8b 9c 24 d0 00 00 mov 0xd0(%rsp),%rbx
2c29: 00
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;
2c2a: 49 39 de cmp %rbx,%r14
2c2d: 4c 89 c0 mov %r8,%rax
2c30: 48 0f 42 44 24 38 cmovb 0x38(%rsp),%rax
2c36: 48 8b 4c 24 48 mov 0x48(%rsp),%rcx
2c3b: 48 8d 0c cc lea (%rsp,%rcx,8),%rcx
2c3f: 48 81 c1 00 01 00 00 add $0x100,%rcx
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.
2c46: 4c 01 f0 add %r14,%rax
2c49: 48 29 d8 sub %rbx,%rax
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
2c4c: 0f 18 08 prefetcht0 (%rax)
2c4f: 0f 18 48 40 prefetcht0 0x40(%rax)
2c53: 48 8b 84 24 e0 01 00 mov 0x1e0(%rsp),%rax
2c5a: 00
return prefetchPos + sequence.matchLength;
2c5b: 49 01 c6 add %rax,%r14
sequences[seqNb & STORED_SEQS_MASK] = sequence;
2c5e: 48 89 31 mov %rsi,(%rcx)
2c61: 48 89 41 08 mov %rax,0x8(%rcx)
2c65: 48 89 59 10 mov %rbx,0x10(%rcx)
op += oneSeqSize;
2c69: 4c 01 df add %r11,%rdi
2c6c: 4c 8b 7c 24 30 mov 0x30(%rsp),%r15
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
2c71: 41 83 c7 01 add $0x1,%r15d
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
2c75: 8b 44 24 68 mov 0x68(%rsp),%eax
2c79: 48 89 7c 24 28 mov %rdi,0x28(%rsp)
2c7e: 83 f8 41 cmp $0x41,%eax
2c81: 0f 82 b7 fb ff ff jb 283e <ZSTD_decompressBlock_internal+0x171e>
2c87: e9 93 03 00 00 jmpq 301f <ZSTD_decompressBlock_internal+0x1eff>
2c8c: 48 8b 5c 24 18 mov 0x18(%rsp),%rbx
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
2c91: 48 89 de mov %rbx,%rsi
2c94: 4c 89 e9 mov %r13,%rcx
2c97: 4d 89 e0 mov %r12,%r8
2c9a: 4c 8d 8c 24 e0 00 00 lea 0xe0(%rsp),%r9
2ca1: 00
2ca2: ff 74 24 38 pushq 0x38(%rsp)
2ca6: ff b4 24 d8 01 00 00 pushq 0x1d8(%rsp)
2cad: ff 74 24 18 pushq 0x18(%rsp)
2cb1: ff b4 24 10 01 00 00 pushq 0x110(%rsp)
2cb8: e8 c3 1f 00 00 callq 4c80 <ZSTD_execSequenceEnd>
2cbd: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi
2cc2: 4c 8b 44 24 28 mov 0x28(%rsp),%r8
2cc7: 48 89 da mov %rbx,%rdx
2cca: 48 83 c4 20 add $0x20,%rsp
2cce: 49 89 c3 mov %rax,%r11
2cd1: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
2cd6: e9 30 ff ff ff jmpq 2c0b <ZSTD_decompressBlock_internal+0x1aeb>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
2cdb: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
2cdf: 0f 10 41 10 movups 0x10(%rcx),%xmm0
2ce3: 0f 11 47 10 movups %xmm0,0x10(%rdi)
if (16 >= length) return;
2ce7: 48 83 fa 11 cmp $0x11,%rdx
2ceb: 0f 8c f5 fd ff ff jl 2ae6 <ZSTD_decompressBlock_internal+0x19c6>
op += 16;
2cf1: 4c 8d 47 20 lea 0x20(%rdi),%r8
do {
2cf5: 48 83 c1 30 add $0x30,%rcx
2cf9: 31 f6 xor %esi,%esi
ZSTD_memcpy(dst, src, 16);
2cfb: 0f 10 44 31 f0 movups -0x10(%rcx,%rsi,1),%xmm0
2d00: 41 0f 11 04 30 movups %xmm0,(%r8,%rsi,1)
2d05: 0f 10 04 31 movups (%rcx,%rsi,1),%xmm0
2d09: 41 0f 11 44 30 10 movups %xmm0,0x10(%r8,%rsi,1)
while (op < oend);
2d0f: 49 8d 14 30 lea (%r8,%rsi,1),%rdx
2d13: 48 83 c2 20 add $0x20,%rdx
2d17: 48 83 c6 20 add $0x20,%rsi
2d1b: 48 39 da cmp %rbx,%rdx
2d1e: 4c 8b 4c 24 08 mov 0x8(%rsp),%r9
}
2d23: 72 d6 jb 2cfb <ZSTD_decompressBlock_internal+0x1bdb>
2d25: e9 bc fd ff ff jmpq 2ae6 <ZSTD_decompressBlock_internal+0x19c6>
if (offset < 8) {
2d2a: 49 83 fc 07 cmp $0x7,%r12
2d2e: 0f 87 e5 00 00 00 ja 2e19 <ZSTD_decompressBlock_internal+0x1cf9>
int const sub2 = dec64table[offset];
2d34: 4a 63 04 a5 00 00 00 movslq 0x0(,%r12,4),%rax
2d3b: 00
(*op)[0] = (*ip)[0];
2d3c: 8a 4d 00 mov 0x0(%rbp),%cl
2d3f: 88 0b mov %cl,(%rbx)
(*op)[1] = (*ip)[1];
2d41: 8a 4d 01 mov 0x1(%rbp),%cl
2d44: 88 4b 01 mov %cl,0x1(%rbx)
(*op)[2] = (*ip)[2];
2d47: 8a 4d 02 mov 0x2(%rbp),%cl
2d4a: 88 4b 02 mov %cl,0x2(%rbx)
(*op)[3] = (*ip)[3];
2d4d: 8a 4d 03 mov 0x3(%rbp),%cl
2d50: 88 4b 03 mov %cl,0x3(%rbx)
*ip += dec32table[offset];
2d53: 42 8b 0c a5 00 00 00 mov 0x0(,%r12,4),%ecx
2d5a: 00
2d5b: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
*ip -= sub2;
2d5f: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
2d62: 8b 44 0d 00 mov 0x0(%rbp,%rcx,1),%eax
2d66: 89 43 04 mov %eax,0x4(%rbx)
2d69: e9 b5 00 00 00 jmpq 2e23 <ZSTD_decompressBlock_internal+0x1d03>
if (bitD->ptr >= bitD->limitPtr) {
2d6e: 4c 3b 9c 24 e8 01 00 cmp 0x1e8(%rsp),%r11
2d75: 00
2d76: 0f 83 7d 01 00 00 jae 2ef9 <ZSTD_decompressBlock_internal+0x1dd9>
if (bitD->ptr == bitD->start) {
2d7c: 48 8b 4c 24 78 mov 0x78(%rsp),%rcx
2d81: 49 39 cb cmp %rcx,%r11
2d84: 0f 84 8b 01 00 00 je 2f15 <ZSTD_decompressBlock_internal+0x1df5>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
2d8a: 89 c2 mov %eax,%edx
2d8c: c1 ea 03 shr $0x3,%edx
if (bitD->ptr - nbBytes < bitD->start) {
2d8f: 4c 89 de mov %r11,%rsi
2d92: 48 29 d6 sub %rdx,%rsi
2d95: 44 89 df mov %r11d,%edi
2d98: 29 cf sub %ecx,%edi
2d9a: 48 39 ce cmp %rcx,%rsi
2d9d: 0f 43 fa cmovae %edx,%edi
bitD->ptr -= nbBytes;
2da0: 49 29 fb sub %rdi,%r11
2da3: 4c 89 5c 24 70 mov %r11,0x70(%rsp)
bitD->bitsConsumed -= nbBytes*8;
2da8: c1 e7 03 shl $0x3,%edi
2dab: 29 f8 sub %edi,%eax
2dad: e9 57 01 00 00 jmpq 2f09 <ZSTD_decompressBlock_internal+0x1de9>
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
2db2: 83 fd 01 cmp $0x1,%ebp
2db5: 41 83 d0 00 adc $0x0,%r8d
size_t const value = BIT_lookBitsFast(bitD, nbBits);
2db9: 48 8b 54 24 60 mov 0x60(%rsp),%rdx
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
2dbe: 89 c1 mov %eax,%ecx
2dc0: 48 d3 e2 shl %cl,%rdx
2dc3: 48 c1 ea 3f shr $0x3f,%rdx
bitD->bitsConsumed += nbBits;
2dc7: 83 c0 01 add $0x1,%eax
2dca: 89 44 24 68 mov %eax,0x68(%rsp)
2dce: 4c 01 c2 add %r8,%rdx
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
2dd1: 48 83 fa 03 cmp $0x3,%rdx
2dd5: 0f 85 57 01 00 00 jne 2f32 <ZSTD_decompressBlock_internal+0x1e12>
2ddb: 48 8b 8c 24 b8 00 00 mov 0xb8(%rsp),%rcx
2de2: 00
2de3: 48 83 c1 ff add $0xffffffffffffffff,%rcx
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
2de7: 48 83 f9 01 cmp $0x1,%rcx
2deb: 48 83 d1 00 adc $0x0,%rcx
2def: 48 89 8c 24 d0 00 00 mov %rcx,0xd0(%rsp)
2df6: 00
2df7: e9 54 01 00 00 jmpq 2f50 <ZSTD_decompressBlock_internal+0x1e30>
seqState->prevOffset[1] = seqState->prevOffset[0];
2dfc: 48 8b 8c 24 b8 00 00 mov 0xb8(%rsp),%rcx
2e03: 00
offset = seqState->prevOffset[1];
2e04: 48 8b 94 24 c0 00 00 mov 0xc0(%rsp),%rdx
2e0b: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
2e0c: 48 89 8c 24 c0 00 00 mov %rcx,0xc0(%rsp)
2e13: 00
2e14: e9 62 fb ff ff jmpq 297b <ZSTD_decompressBlock_internal+0x185b>
ZSTD_memcpy(dst, src, 8);
2e19: 48 8b 45 00 mov 0x0(%rbp),%rax
2e1d: 48 89 03 mov %rax,(%rbx)
*ip += 8;
2e20: 48 89 ee mov %rbp,%rsi
if (sequence.matchLength > 8) {
2e23: 49 83 fd 09 cmp $0x9,%r13
2e27: 0f 82 d9 01 00 00 jb 3006 <ZSTD_decompressBlock_internal+0x1ee6>
2e2d: 48 8d 4e 08 lea 0x8(%rsi),%rcx
2e31: 48 8d 53 08 lea 0x8(%rbx),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
2e35: 48 89 d7 mov %rdx,%rdi
2e38: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
2e3b: 4a 8d 04 2b lea (%rbx,%r13,1),%rax
2e3f: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
2e43: 0f 8f 48 01 00 00 jg 2f91 <ZSTD_decompressBlock_internal+0x1e71>
do {
2e49: 48 8d 7b 10 lea 0x10(%rbx),%rdi
2e4d: 48 39 f8 cmp %rdi,%rax
2e50: 49 89 fa mov %rdi,%r10
2e53: 4c 0f 47 d0 cmova %rax,%r10
2e57: 49 29 da sub %rbx,%r10
2e5a: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
2e5e: 49 83 fa 18 cmp $0x18,%r10
2e62: 0f 82 8b 01 00 00 jb 2ff3 <ZSTD_decompressBlock_internal+0x1ed3>
2e68: 48 39 f8 cmp %rdi,%rax
2e6b: 48 0f 47 f8 cmova %rax,%rdi
2e6f: 48 29 df sub %rbx,%rdi
2e72: 48 83 c7 07 add $0x7,%rdi
2e76: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
2e7a: 48 8d 2c 3e lea (%rsi,%rdi,1),%rbp
2e7e: 48 39 ea cmp %rbp,%rdx
2e81: 73 0c jae 2e8f <ZSTD_decompressBlock_internal+0x1d6f>
2e83: 48 01 df add %rbx,%rdi
2e86: 48 39 f9 cmp %rdi,%rcx
2e89: 0f 82 64 01 00 00 jb 2ff3 <ZSTD_decompressBlock_internal+0x1ed3>
2e8f: 49 c1 ea 03 shr $0x3,%r10
2e93: 49 83 c2 01 add $0x1,%r10
2e97: 4d 89 d0 mov %r10,%r8
2e9a: 49 83 e0 fc and $0xfffffffffffffffc,%r8
2e9e: 49 8d 78 fc lea -0x4(%r8),%rdi
2ea2: 49 89 f9 mov %rdi,%r9
2ea5: 49 c1 e9 02 shr $0x2,%r9
2ea9: 49 83 c1 01 add $0x1,%r9
2ead: 48 85 ff test %rdi,%rdi
2eb0: 0f 84 16 01 00 00 je 2fcc <ZSTD_decompressBlock_internal+0x1eac>
2eb6: 4c 89 cf mov %r9,%rdi
2eb9: 48 83 e7 fe and $0xfffffffffffffffe,%rdi
2ebd: 48 f7 df neg %rdi
2ec0: 31 ed xor %ebp,%ebp
ZSTD_memcpy(dst, src, 8);
2ec2: 0f 10 44 ee 08 movups 0x8(%rsi,%rbp,8),%xmm0
2ec7: 0f 10 4c ee 18 movups 0x18(%rsi,%rbp,8),%xmm1
2ecc: 0f 11 44 eb 08 movups %xmm0,0x8(%rbx,%rbp,8)
2ed1: 0f 11 4c eb 18 movups %xmm1,0x18(%rbx,%rbp,8)
2ed6: 0f 10 44 ee 28 movups 0x28(%rsi,%rbp,8),%xmm0
2edb: 0f 10 4c ee 38 movups 0x38(%rsi,%rbp,8),%xmm1
2ee0: 0f 11 44 eb 28 movups %xmm0,0x28(%rbx,%rbp,8)
2ee5: 0f 11 4c eb 38 movups %xmm1,0x38(%rbx,%rbp,8)
2eea: 48 83 c5 08 add $0x8,%rbp
2eee: 48 83 c7 02 add $0x2,%rdi
2ef2: 75 ce jne 2ec2 <ZSTD_decompressBlock_internal+0x1da2>
2ef4: e9 d5 00 00 00 jmpq 2fce <ZSTD_decompressBlock_internal+0x1eae>
bitD->ptr -= bitD->bitsConsumed >> 3;
2ef9: 89 c1 mov %eax,%ecx
2efb: c1 e9 03 shr $0x3,%ecx
2efe: 49 29 cb sub %rcx,%r11
2f01: 4c 89 5c 24 70 mov %r11,0x70(%rsp)
bitD->bitsConsumed &= 7;
2f06: 83 e0 07 and $0x7,%eax
2f09: 89 44 24 68 mov %eax,0x68(%rsp)
2f0d: 49 8b 0b mov (%r11),%rcx
2f10: 48 89 4c 24 60 mov %rcx,0x60(%rsp)
2f15: 4c 8b 4c 24 08 mov 0x8(%rsp),%r9
2f1a: 48 8b 54 24 60 mov 0x60(%rsp),%rdx
if (llBits > 0)
2f1f: 45 84 d2 test %r10b,%r10b
2f22: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
2f27: 0f 85 ad fa ff ff jne 29da <ZSTD_decompressBlock_internal+0x18ba>
2f2d: e9 c4 fa ff ff jmpq 29f6 <ZSTD_decompressBlock_internal+0x18d6>
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
2f32: 48 8b 8c d4 b8 00 00 mov 0xb8(%rsp,%rdx,8),%rcx
2f39: 00
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
2f3a: 48 83 f9 01 cmp $0x1,%rcx
2f3e: 48 83 d1 00 adc $0x0,%rcx
2f42: 48 89 8c 24 d0 00 00 mov %rcx,0xd0(%rsp)
2f49: 00
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
2f4a: 48 83 fa 01 cmp $0x1,%rdx
2f4e: 74 10 je 2f60 <ZSTD_decompressBlock_internal+0x1e40>
2f50: 48 8b 8c 24 c0 00 00 mov 0xc0(%rsp),%rcx
2f57: 00
2f58: 48 89 8c 24 c8 00 00 mov %rcx,0xc8(%rsp)
2f5f: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
2f60: 48 8b 8c 24 b8 00 00 mov 0xb8(%rsp),%rcx
2f67: 00
2f68: 48 89 8c 24 c0 00 00 mov %rcx,0xc0(%rsp)
2f6f: 00
2f70: 48 8b 8c 24 d0 00 00 mov 0xd0(%rsp),%rcx
2f77: 00
seqState->prevOffset[0] = offset = temp;
2f78: 48 89 8c 24 b8 00 00 mov %rcx,0xb8(%rsp)
2f7f: 00
2f80: 41 00 f7 add %sil,%r15b
if (mlBits > 0)
2f83: 45 84 c9 test %r9b,%r9b
2f86: 0f 85 07 fa ff ff jne 2993 <ZSTD_decompressBlock_internal+0x1873>
2f8c: e9 1e fa ff ff jmpq 29af <ZSTD_decompressBlock_internal+0x188f>
ZSTD_memcpy(dst, src, 16);
2f91: 0f 10 01 movups (%rcx),%xmm0
2f94: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
2f97: 49 83 fd 19 cmp $0x19,%r13
2f9b: 7c 69 jl 3006 <ZSTD_decompressBlock_internal+0x1ee6>
op += 16;
2f9d: 48 83 c3 18 add $0x18,%rbx
do {
2fa1: 48 83 c6 28 add $0x28,%rsi
2fa5: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
2fa7: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
2fac: 0f 11 04 0b movups %xmm0,(%rbx,%rcx,1)
2fb0: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
2fb4: 0f 11 44 0b 10 movups %xmm0,0x10(%rbx,%rcx,1)
while (op < oend);
2fb9: 48 8d 14 0b lea (%rbx,%rcx,1),%rdx
2fbd: 48 83 c2 20 add $0x20,%rdx
2fc1: 48 83 c1 20 add $0x20,%rcx
2fc5: 48 39 c2 cmp %rax,%rdx
}
2fc8: 72 dd jb 2fa7 <ZSTD_decompressBlock_internal+0x1e87>
2fca: eb 3a jmp 3006 <ZSTD_decompressBlock_internal+0x1ee6>
2fcc: 31 ed xor %ebp,%ebp
2fce: 41 f6 c1 01 test $0x1,%r9b
2fd2: 74 12 je 2fe6 <ZSTD_decompressBlock_internal+0x1ec6>
ZSTD_memcpy(dst, src, 8);
2fd4: 0f 10 04 e9 movups (%rcx,%rbp,8),%xmm0
2fd8: 0f 10 4c e9 10 movups 0x10(%rcx,%rbp,8),%xmm1
2fdd: 0f 11 04 ea movups %xmm0,(%rdx,%rbp,8)
2fe1: 0f 11 4c ea 10 movups %xmm1,0x10(%rdx,%rbp,8)
} while (op < oend);
2fe6: 4d 39 c2 cmp %r8,%r10
2fe9: 74 1b je 3006 <ZSTD_decompressBlock_internal+0x1ee6>
2feb: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
2fef: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
ZSTD_memcpy(dst, src, 8);
2ff3: 48 8b 31 mov (%rcx),%rsi
2ff6: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
2ff9: 48 83 c2 08 add $0x8,%rdx
2ffd: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
3001: 48 39 c2 cmp %rax,%rdx
3004: 72 ed jb 2ff3 <ZSTD_decompressBlock_internal+0x1ed3>
3006: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
300b: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
3010: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
3015: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
301a: e9 ec fb ff ff jmpq 2c0b <ZSTD_decompressBlock_internal+0x1aeb>
301f: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
3026: 45 39 cf cmp %r9d,%r15d
RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, "");
3029: 0f 8c f9 04 00 00 jl 3528 <ZSTD_decompressBlock_internal+0x2408>
seqNb -= seqAdvance;
302f: 44 2b bc 24 ec 00 00 sub 0xec(%rsp),%r15d
3036: 00
for ( ; seqNb<nbSeq ; seqNb++) {
3037: 45 39 cf cmp %r9d,%r15d
303a: 0f 8d f3 03 00 00 jge 3433 <ZSTD_decompressBlock_internal+0x2313>
3040: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
3045: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
304a: 4c 89 c6 mov %r8,%rsi
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[seqNb&STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
304d: 44 89 f8 mov %r15d,%eax
3050: 83 e0 07 and $0x7,%eax
3053: 48 8d 04 40 lea (%rax,%rax,2),%rax
3057: 48 8b 94 c4 00 01 00 mov 0x100(%rsp,%rax,8),%rdx
305e: 00
305f: 4c 8b ac c4 08 01 00 mov 0x108(%rsp,%rax,8),%r13
3066: 00
3067: 4c 8b 84 c4 10 01 00 mov 0x110(%rsp,%rax,8),%r8
306e: 00
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
306f: 4e 8d 1c 2a lea (%rdx,%r13,1),%r11
3073: 4a 8d 04 1f lea (%rdi,%r11,1),%rax
3077: 48 3b 84 24 d8 01 00 cmp 0x1d8(%rsp),%rax
307e: 00
if (UNLIKELY(
307f: 0f 87 55 01 00 00 ja 31da <ZSTD_decompressBlock_internal+0x20ba>
3085: 48 8b 8c 24 e0 00 00 mov 0xe0(%rsp),%rcx
308c: 00
308d: 48 8d 04 11 lea (%rcx,%rdx,1),%rax
3091: 48 3b 84 24 f8 00 00 cmp 0xf8(%rsp),%rax
3098: 00
3099: 0f 87 3b 01 00 00 ja 31da <ZSTD_decompressBlock_internal+0x20ba>
309f: 48 8d 2c 17 lea (%rdi,%rdx,1),%rbp
30a3: 48 89 eb mov %rbp,%rbx
30a6: 4c 29 c3 sub %r8,%rbx
ZSTD_memcpy(dst, src, 16);
30a9: 0f 10 01 movups (%rcx),%xmm0
30ac: 0f 11 07 movups %xmm0,(%rdi)
if (UNLIKELY(sequence.litLength > 16)) {
30af: 48 83 fa 11 cmp $0x11,%rdx
30b3: 0f 83 6b 01 00 00 jae 3224 <ZSTD_decompressBlock_internal+0x2104>
*litPtr = iLitEnd; /* update for next sequence */
30b9: 48 89 84 24 e0 00 00 mov %rax,0xe0(%rsp)
30c0: 00
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
30c1: 48 89 e8 mov %rbp,%rax
30c4: 48 89 f1 mov %rsi,%rcx
30c7: 48 29 f0 sub %rsi,%rax
30ca: 4c 39 c0 cmp %r8,%rax
30cd: 73 6f jae 313e <ZSTD_decompressBlock_internal+0x201e>
30cf: 4c 89 5c 24 30 mov %r11,0x30(%rsp)
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
30d4: 48 89 e8 mov %rbp,%rax
30d7: 48 2b 84 24 d0 01 00 sub 0x1d0(%rsp),%rax
30de: 00
30df: 4c 39 c0 cmp %r8,%rax
30e2: 0f 82 39 04 00 00 jb 3521 <ZSTD_decompressBlock_internal+0x2401>
30e8: 49 89 fc mov %rdi,%r12
match = dictEnd + (match - prefixStart);
30eb: 48 29 cb sub %rcx,%rbx
30ee: 48 8b 4c 24 38 mov 0x38(%rsp),%rcx
30f3: 48 8d 34 19 lea (%rcx,%rbx,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
30f7: 4a 8d 04 2e lea (%rsi,%r13,1),%rax
30fb: 48 39 c8 cmp %rcx,%rax
30fe: 0f 86 90 00 00 00 jbe 3194 <ZSTD_decompressBlock_internal+0x2074>
{ size_t const length1 = dictEnd - match;
3104: 48 89 da mov %rbx,%rdx
3107: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
310a: 48 89 ef mov %rbp,%rdi
310d: 4c 89 44 24 28 mov %r8,0x28(%rsp)
3112: e8 00 00 00 00 callq 3117 <ZSTD_decompressBlock_internal+0x1ff7>
3117: 4c 8b 44 24 28 mov 0x28(%rsp),%r8
op = oLitEnd + length1;
311c: 48 29 dd sub %rbx,%rbp
sequence.matchLength -= length1;
311f: 49 01 dd add %rbx,%r13
3122: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx
3127: 48 89 cb mov %rcx,%rbx
312a: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
312f: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
3134: 4c 89 e7 mov %r12,%rdi
3137: 4c 8b 5c 24 30 mov 0x30(%rsp),%r11
313c: eb 05 jmp 3143 <ZSTD_decompressBlock_internal+0x2023>
313e: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
3143: 49 83 f8 10 cmp $0x10,%r8
3147: 0f 82 26 01 00 00 jb 3273 <ZSTD_decompressBlock_internal+0x2153>
314d: 0f 10 03 movups (%rbx),%xmm0
3150: 0f 11 45 00 movups %xmm0,0x0(%rbp)
if (16 >= length) return;
3154: 49 83 fd 11 cmp $0x11,%r13
3158: 7d 05 jge 315f <ZSTD_decompressBlock_internal+0x203f>
315a: 49 89 c8 mov %rcx,%r8
315d: eb 57 jmp 31b6 <ZSTD_decompressBlock_internal+0x2096>
315f: 49 01 ed add %rbp,%r13
do {
3162: 48 83 c3 10 add $0x10,%rbx
3166: b8 10 00 00 00 mov $0x10,%eax
316b: 49 89 c8 mov %rcx,%r8
ZSTD_memcpy(dst, src, 16);
316e: 0f 10 44 03 f0 movups -0x10(%rbx,%rax,1),%xmm0
3173: 0f 11 44 05 00 movups %xmm0,0x0(%rbp,%rax,1)
3178: 0f 10 04 03 movups (%rbx,%rax,1),%xmm0
317c: 0f 11 44 05 10 movups %xmm0,0x10(%rbp,%rax,1)
while (op < oend);
3181: 48 8d 0c 28 lea (%rax,%rbp,1),%rcx
3185: 48 83 c1 20 add $0x20,%rcx
3189: 48 83 c0 20 add $0x20,%rax
318d: 4c 39 e9 cmp %r13,%rcx
}
3190: 72 dc jb 316e <ZSTD_decompressBlock_internal+0x204e>
3192: eb 22 jmp 31b6 <ZSTD_decompressBlock_internal+0x2096>
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
3194: 48 89 ef mov %rbp,%rdi
3197: 4c 89 ea mov %r13,%rdx
319a: e8 00 00 00 00 callq 319f <ZSTD_decompressBlock_internal+0x207f>
319f: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
31a4: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
31a9: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
31ae: 4c 89 e7 mov %r12,%rdi
31b1: 4c 8b 5c 24 30 mov 0x30(%rsp),%r11
31b6: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
31ba: 44 8b 4c 24 14 mov 0x14(%rsp),%r9d
31bf: 0f 87 63 03 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
31c5: 4c 01 df add %r11,%rdi
for ( ; seqNb<nbSeq ; seqNb++) {
31c8: 41 83 c7 01 add $0x1,%r15d
31cc: 45 39 cf cmp %r9d,%r15d
31cf: 0f 85 75 fe ff ff jne 304a <ZSTD_decompressBlock_internal+0x1f2a>
31d5: e9 63 02 00 00 jmpq 343d <ZSTD_decompressBlock_internal+0x231d>
31da: 48 8b 5c 24 18 mov 0x18(%rsp),%rbx
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
31df: 48 89 de mov %rbx,%rsi
31e2: 4c 89 e9 mov %r13,%rcx
31e5: 4c 8d 8c 24 e0 00 00 lea 0xe0(%rsp),%r9
31ec: 00
31ed: ff 74 24 38 pushq 0x38(%rsp)
31f1: ff b4 24 d8 01 00 00 pushq 0x1d8(%rsp)
31f8: ff 74 24 18 pushq 0x18(%rsp)
31fc: ff b4 24 10 01 00 00 pushq 0x110(%rsp)
3203: 48 89 fd mov %rdi,%rbp
3206: e8 75 1a 00 00 callq 4c80 <ZSTD_execSequenceEnd>
320b: 48 89 ef mov %rbp,%rdi
320e: 4c 8b 44 24 28 mov 0x28(%rsp),%r8
3213: 4c 8b 54 24 40 mov 0x40(%rsp),%r10
3218: 48 89 da mov %rbx,%rdx
321b: 48 83 c4 20 add $0x20,%rsp
321f: 49 89 c3 mov %rax,%r11
3222: eb 92 jmp 31b6 <ZSTD_decompressBlock_internal+0x2096>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
3224: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
3228: 0f 10 41 10 movups 0x10(%rcx),%xmm0
322c: 0f 11 47 10 movups %xmm0,0x10(%rdi)
if (16 >= length) return;
3230: 48 83 fa 11 cmp $0x11,%rdx
3234: 0f 8c 7f fe ff ff jl 30b9 <ZSTD_decompressBlock_internal+0x1f99>
op += 16;
323a: 4c 8d 4f 20 lea 0x20(%rdi),%r9
do {
323e: 48 83 c1 30 add $0x30,%rcx
3242: 31 d2 xor %edx,%edx
ZSTD_memcpy(dst, src, 16);
3244: 0f 10 44 11 f0 movups -0x10(%rcx,%rdx,1),%xmm0
3249: 41 0f 11 04 11 movups %xmm0,(%r9,%rdx,1)
324e: 0f 10 04 11 movups (%rcx,%rdx,1),%xmm0
3252: 41 0f 11 44 11 10 movups %xmm0,0x10(%r9,%rdx,1)
while (op < oend);
3258: 49 8d 34 11 lea (%r9,%rdx,1),%rsi
325c: 48 83 c6 20 add $0x20,%rsi
3260: 48 83 c2 20 add $0x20,%rdx
3264: 48 39 ee cmp %rbp,%rsi
3267: 48 8b 74 24 08 mov 0x8(%rsp),%rsi
}
326c: 72 d6 jb 3244 <ZSTD_decompressBlock_internal+0x2124>
326e: e9 46 fe ff ff jmpq 30b9 <ZSTD_decompressBlock_internal+0x1f99>
3273: 4d 89 dc mov %r11,%r12
3276: 49 89 fb mov %rdi,%r11
if (offset < 8) {
3279: 49 83 f8 07 cmp $0x7,%r8
327d: 77 3c ja 32bb <ZSTD_decompressBlock_internal+0x219b>
327f: 4c 89 c0 mov %r8,%rax
3282: 4c 89 c2 mov %r8,%rdx
int const sub2 = dec64table[offset];
3285: 48 63 04 85 00 00 00 movslq 0x0(,%rax,4),%rax
328c: 00
(*op)[0] = (*ip)[0];
328d: 8a 0b mov (%rbx),%cl
328f: 88 4d 00 mov %cl,0x0(%rbp)
(*op)[1] = (*ip)[1];
3292: 8a 4b 01 mov 0x1(%rbx),%cl
3295: 88 4d 01 mov %cl,0x1(%rbp)
(*op)[2] = (*ip)[2];
3298: 8a 4b 02 mov 0x2(%rbx),%cl
329b: 88 4d 02 mov %cl,0x2(%rbp)
(*op)[3] = (*ip)[3];
329e: 8a 4b 03 mov 0x3(%rbx),%cl
32a1: 88 4d 03 mov %cl,0x3(%rbp)
*ip += dec32table[offset];
32a4: 42 8b 0c 85 00 00 00 mov 0x0(,%r8,4),%ecx
32ab: 00
32ac: 48 8d 34 0b lea (%rbx,%rcx,1),%rsi
*ip -= sub2;
32b0: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
32b3: 8b 04 0b mov (%rbx,%rcx,1),%eax
32b6: 89 45 04 mov %eax,0x4(%rbp)
32b9: eb 0a jmp 32c5 <ZSTD_decompressBlock_internal+0x21a5>
ZSTD_memcpy(dst, src, 8);
32bb: 48 8b 03 mov (%rbx),%rax
32be: 48 89 45 00 mov %rax,0x0(%rbp)
*ip += 8;
32c2: 48 89 de mov %rbx,%rsi
if (sequence.matchLength > 8) {
32c5: 49 83 fd 09 cmp $0x9,%r13
32c9: 0f 82 45 01 00 00 jb 3414 <ZSTD_decompressBlock_internal+0x22f4>
32cf: 48 8d 4e 08 lea 0x8(%rsi),%rcx
32d3: 48 8d 55 08 lea 0x8(%rbp),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
32d7: 48 89 d7 mov %rdx,%rdi
32da: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
32dd: 48 89 e8 mov %rbp,%rax
32e0: 4c 01 e8 add %r13,%rax
32e3: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
32e7: 0f 8f b1 00 00 00 jg 339e <ZSTD_decompressBlock_internal+0x227e>
do {
32ed: 48 8d 7d 10 lea 0x10(%rbp),%rdi
32f1: 48 39 f8 cmp %rdi,%rax
32f4: 49 89 fa mov %rdi,%r10
32f7: 4c 0f 47 d0 cmova %rax,%r10
32fb: 49 29 ea sub %rbp,%r10
32fe: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
3302: 49 83 fa 18 cmp $0x18,%r10
3306: 0f 82 f5 00 00 00 jb 3401 <ZSTD_decompressBlock_internal+0x22e1>
330c: 48 39 f8 cmp %rdi,%rax
330f: 48 0f 47 f8 cmova %rax,%rdi
3313: 48 29 ef sub %rbp,%rdi
3316: 48 83 c7 f7 add $0xfffffffffffffff7,%rdi
331a: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
331e: 48 8d 1c 3e lea (%rsi,%rdi,1),%rbx
3322: 48 83 c3 10 add $0x10,%rbx
3326: 48 39 da cmp %rbx,%rdx
3329: 73 10 jae 333b <ZSTD_decompressBlock_internal+0x221b>
332b: 48 01 ef add %rbp,%rdi
332e: 48 83 c7 10 add $0x10,%rdi
3332: 48 39 f9 cmp %rdi,%rcx
3335: 0f 82 c6 00 00 00 jb 3401 <ZSTD_decompressBlock_internal+0x22e1>
333b: 49 c1 ea 03 shr $0x3,%r10
333f: 49 83 c2 01 add $0x1,%r10
3343: 4d 89 d0 mov %r10,%r8
3346: 49 83 e0 fc and $0xfffffffffffffffc,%r8
334a: 49 8d 78 fc lea -0x4(%r8),%rdi
334e: 49 89 f9 mov %rdi,%r9
3351: 49 c1 e9 02 shr $0x2,%r9
3355: 49 83 c1 01 add $0x1,%r9
3359: 48 85 ff test %rdi,%rdi
335c: 74 7c je 33da <ZSTD_decompressBlock_internal+0x22ba>
335e: 4c 89 cf mov %r9,%rdi
3361: 48 83 e7 fe and $0xfffffffffffffffe,%rdi
3365: 48 f7 df neg %rdi
3368: 31 db xor %ebx,%ebx
ZSTD_memcpy(dst, src, 8);
336a: 0f 10 44 de 08 movups 0x8(%rsi,%rbx,8),%xmm0
336f: 0f 10 4c de 18 movups 0x18(%rsi,%rbx,8),%xmm1
3374: 0f 11 44 dd 08 movups %xmm0,0x8(%rbp,%rbx,8)
3379: 0f 11 4c dd 18 movups %xmm1,0x18(%rbp,%rbx,8)
337e: 0f 10 44 de 28 movups 0x28(%rsi,%rbx,8),%xmm0
3383: 0f 10 4c de 38 movups 0x38(%rsi,%rbx,8),%xmm1
3388: 0f 11 44 dd 28 movups %xmm0,0x28(%rbp,%rbx,8)
338d: 0f 11 4c dd 38 movups %xmm1,0x38(%rbp,%rbx,8)
3392: 48 83 c3 08 add $0x8,%rbx
3396: 48 83 c7 02 add $0x2,%rdi
339a: 75 ce jne 336a <ZSTD_decompressBlock_internal+0x224a>
339c: eb 3e jmp 33dc <ZSTD_decompressBlock_internal+0x22bc>
ZSTD_memcpy(dst, src, 16);
339e: 0f 10 01 movups (%rcx),%xmm0
33a1: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
33a4: 49 83 fd 19 cmp $0x19,%r13
33a8: 7c 6a jl 3414 <ZSTD_decompressBlock_internal+0x22f4>
op += 16;
33aa: 48 83 c5 18 add $0x18,%rbp
do {
33ae: 48 83 c6 28 add $0x28,%rsi
33b2: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
33b4: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
33b9: 0f 11 44 0d 00 movups %xmm0,0x0(%rbp,%rcx,1)
33be: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
33c2: 0f 11 44 0d 10 movups %xmm0,0x10(%rbp,%rcx,1)
while (op < oend);
33c7: 48 8d 14 29 lea (%rcx,%rbp,1),%rdx
33cb: 48 83 c2 20 add $0x20,%rdx
33cf: 48 83 c1 20 add $0x20,%rcx
33d3: 48 39 c2 cmp %rax,%rdx
}
33d6: 72 dc jb 33b4 <ZSTD_decompressBlock_internal+0x2294>
33d8: eb 3a jmp 3414 <ZSTD_decompressBlock_internal+0x22f4>
33da: 31 db xor %ebx,%ebx
33dc: 41 f6 c1 01 test $0x1,%r9b
33e0: 74 12 je 33f4 <ZSTD_decompressBlock_internal+0x22d4>
ZSTD_memcpy(dst, src, 8);
33e2: 0f 10 04 d9 movups (%rcx,%rbx,8),%xmm0
33e6: 0f 10 4c d9 10 movups 0x10(%rcx,%rbx,8),%xmm1
33eb: 0f 11 04 da movups %xmm0,(%rdx,%rbx,8)
33ef: 0f 11 4c da 10 movups %xmm1,0x10(%rdx,%rbx,8)
} while (op < oend);
33f4: 4d 39 c2 cmp %r8,%r10
33f7: 74 1b je 3414 <ZSTD_decompressBlock_internal+0x22f4>
33f9: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
33fd: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
ZSTD_memcpy(dst, src, 8);
3401: 48 8b 31 mov (%rcx),%rsi
3404: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
3407: 48 83 c2 08 add $0x8,%rdx
340b: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
340f: 48 39 c2 cmp %rax,%rdx
3412: 72 ed jb 3401 <ZSTD_decompressBlock_internal+0x22e1>
3414: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
3419: 48 8b 54 24 18 mov 0x18(%rsp),%rdx
341e: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
3423: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
3428: 4c 89 df mov %r11,%rdi
342b: 4d 89 e3 mov %r12,%r11
342e: e9 83 fd ff ff jmpq 31b6 <ZSTD_decompressBlock_internal+0x2096>
3433: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
3438: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
343d: 8b 84 24 b8 00 00 00 mov 0xb8(%rsp),%eax
3444: 41 89 82 3c 68 00 00 mov %eax,0x683c(%r10)
344b: 8b 84 24 c0 00 00 00 mov 0xc0(%rsp),%eax
3452: 41 89 82 40 68 00 00 mov %eax,0x6840(%r10)
3459: 8b 84 24 c8 00 00 00 mov 0xc8(%rsp),%eax
3460: 41 89 82 44 68 00 00 mov %eax,0x6844(%r10)
{ size_t const lastLLSize = litEnd - litPtr;
3467: 48 8b b4 24 e0 00 00 mov 0xe0(%rsp),%rsi
346e: 00
346f: 48 8b 84 24 f8 00 00 mov 0xf8(%rsp),%rax
3476: 00
3477: 48 29 f0 sub %rsi,%rax
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
347a: 48 29 fa sub %rdi,%rdx
347d: 49 c7 c3 ba ff ff ff mov $0xffffffffffffffba,%r11
3484: 48 39 d0 cmp %rdx,%rax
3487: 0f 87 9b 00 00 00 ja 3528 <ZSTD_decompressBlock_internal+0x2408>
if (op != NULL) {
348d: 48 85 ff test %rdi,%rdi
3490: 74 19 je 34ab <ZSTD_decompressBlock_internal+0x238b>
ZSTD_memcpy(op, litPtr, lastLLSize);
3492: 48 89 c2 mov %rax,%rdx
3495: 48 89 c3 mov %rax,%rbx
3498: 48 89 fd mov %rdi,%rbp
349b: e8 00 00 00 00 callq 34a0 <ZSTD_decompressBlock_internal+0x2380>
op += lastLLSize;
34a0: 48 01 dd add %rbx,%rbp
34a3: 49 89 eb mov %rbp,%r11
return op-ostart;
34a6: 4d 29 f3 sub %r14,%r11
34a9: eb 7d jmp 3528 <ZSTD_decompressBlock_internal+0x2408>
34ab: 45 31 db xor %r11d,%r11d
34ae: 4d 29 f3 sub %r14,%r11
34b1: eb 75 jmp 3528 <ZSTD_decompressBlock_internal+0x2408>
if (bitD->ptr >= bitD->limitPtr) {
34b3: 48 8b 8c 24 10 01 00 mov 0x110(%rsp),%rcx
34ba: 00
34bb: 48 3b 8c 24 20 01 00 cmp 0x120(%rsp),%rcx
34c2: 00
34c3: 73 78 jae 353d <ZSTD_decompressBlock_internal+0x241d>
34c5: 48 89 d0 mov %rdx,%rax
if (bitD->ptr == bitD->start) {
34c8: 48 8b 94 24 18 01 00 mov 0x118(%rsp),%rdx
34cf: 00
34d0: 48 39 d1 cmp %rdx,%rcx
34d3: 0f 84 a2 00 00 00 je 357b <ZSTD_decompressBlock_internal+0x245b>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
34d9: 4c 89 f8 mov %r15,%rax
34dc: 48 c1 e8 03 shr $0x3,%rax
if (bitD->ptr - nbBytes < bitD->start) {
34e0: 48 89 ce mov %rcx,%rsi
34e3: 48 29 c6 sub %rax,%rsi
34e6: 89 cf mov %ecx,%edi
34e8: 29 d7 sub %edx,%edi
34ea: 48 39 d6 cmp %rdx,%rsi
34ed: 0f 43 f8 cmovae %eax,%edi
bitD->ptr -= nbBytes;
34f0: 48 29 f9 sub %rdi,%rcx
34f3: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
34fa: 00
bitD->bitsConsumed -= nbBytes*8;
34fb: c1 e7 03 shl $0x3,%edi
34fe: 41 29 ff sub %edi,%r15d
3501: eb 50 jmp 3553 <ZSTD_decompressBlock_internal+0x2433>
3503: 4c 8b 74 24 40 mov 0x40(%rsp),%r14
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
3508: 43 0f b6 44 2c ff movzbl -0x1(%r12,%r13,1),%eax
350e: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
3510: 0f 85 f5 e1 ff ff jne 170b <ZSTD_decompressBlock_internal+0x5eb>
3516: c7 84 24 08 01 00 00 movl $0x0,0x108(%rsp)
351d: 00 00 00 00
3521: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
/* else */
return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
#endif
}
}
3528: 4c 89 d8 mov %r11,%rax
352b: 48 81 c4 28 02 00 00 add $0x228,%rsp
3532: 5b pop %rbx
3533: 41 5c pop %r12
3535: 41 5d pop %r13
3537: 41 5e pop %r14
3539: 41 5f pop %r15
353b: 5d pop %rbp
353c: c3 retq
bitD->ptr -= bitD->bitsConsumed >> 3;
353d: 4c 89 f8 mov %r15,%rax
3540: 48 c1 e8 03 shr $0x3,%rax
3544: 48 29 c1 sub %rax,%rcx
3547: 48 89 8c 24 10 01 00 mov %rcx,0x110(%rsp)
354e: 00
bitD->bitsConsumed &= 7;
354f: 41 83 e7 07 and $0x7,%r15d
3553: 44 89 bc 24 08 01 00 mov %r15d,0x108(%rsp)
355a: 00
355b: 48 8b 01 mov (%rcx),%rax
355e: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp)
3565: 00
3566: eb b9 jmp 3521 <ZSTD_decompressBlock_internal+0x2401>
3568: 4d 89 e8 mov %r13,%r8
356b: 45 31 e4 xor %r12d,%r12d
356e: e9 2c e4 ff ff jmpq 199f <ZSTD_decompressBlock_internal+0x87f>
3573: 45 31 e4 xor %r12d,%r12d
3576: e9 d7 e4 ff ff jmpq 1a52 <ZSTD_decompressBlock_internal+0x932>
357b: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
3582: 41 83 ff 40 cmp $0x40,%r15d
3586: 48 89 c2 mov %rax,%rdx
3589: 0f 83 50 ed ff ff jae 22df <ZSTD_decompressBlock_internal+0x11bf>
358f: eb 97 jmp 3528 <ZSTD_decompressBlock_internal+0x2408>
3591: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
3598: 00 00 00
359b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000035a0 <ZSTD_checkContinuity>:
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
{
35a0: 48 85 d2 test %rdx,%rdx
if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */
35a3: 74 35 je 35da <ZSTD_checkContinuity+0x3a>
35a5: 48 8b 87 c0 74 00 00 mov 0x74c0(%rdi),%rax
35ac: 48 39 f0 cmp %rsi,%rax
35af: 74 29 je 35da <ZSTD_checkContinuity+0x3a>
dctx->dictEnd = dctx->previousDstEnd;
35b1: 48 89 87 d8 74 00 00 mov %rax,0x74d8(%rdi)
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
35b8: 48 8b 8f c8 74 00 00 mov 0x74c8(%rdi),%rcx
35bf: 48 29 c1 sub %rax,%rcx
35c2: 48 01 f1 add %rsi,%rcx
35c5: 48 89 8f d0 74 00 00 mov %rcx,0x74d0(%rdi)
dctx->prefixStart = dst;
35cc: 48 89 b7 c8 74 00 00 mov %rsi,0x74c8(%rdi)
dctx->previousDstEnd = dst;
35d3: 48 89 b7 c0 74 00 00 mov %rsi,0x74c0(%rdi)
}
}
35da: c3 retq
35db: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
00000000000035e0 <ZSTD_decompressBlock>:
size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
35e0: 41 56 push %r14
35e2: 53 push %rbx
35e3: 50 push %rax
35e4: 48 89 f3 mov %rsi,%rbx
35e7: 49 89 fe mov %rdi,%r14
35ea: 48 85 d2 test %rdx,%rdx
if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */
35ed: 74 35 je 3624 <ZSTD_decompressBlock+0x44>
35ef: 49 8b 86 c0 74 00 00 mov 0x74c0(%r14),%rax
35f6: 48 39 d8 cmp %rbx,%rax
35f9: 74 29 je 3624 <ZSTD_decompressBlock+0x44>
dctx->dictEnd = dctx->previousDstEnd;
35fb: 49 89 86 d8 74 00 00 mov %rax,0x74d8(%r14)
dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
3602: 49 8b b6 c8 74 00 00 mov 0x74c8(%r14),%rsi
3609: 48 29 c6 sub %rax,%rsi
360c: 48 01 de add %rbx,%rsi
360f: 49 89 b6 d0 74 00 00 mov %rsi,0x74d0(%r14)
dctx->prefixStart = dst;
3616: 49 89 9e c8 74 00 00 mov %rbx,0x74c8(%r14)
dctx->previousDstEnd = dst;
361d: 49 89 9e c0 74 00 00 mov %rbx,0x74c0(%r14)
size_t dSize;
ZSTD_checkContinuity(dctx, dst, dstCapacity);
dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0);
3624: 4c 89 f7 mov %r14,%rdi
3627: 48 89 de mov %rbx,%rsi
362a: 45 31 c9 xor %r9d,%r9d
362d: e8 00 00 00 00 callq 3632 <ZSTD_decompressBlock+0x52>
dctx->previousDstEnd = (char*)dst + dSize;
3632: 48 01 c3 add %rax,%rbx
3635: 49 89 9e c0 74 00 00 mov %rbx,0x74c0(%r14)
return dSize;
363c: 48 83 c4 08 add $0x8,%rsp
3640: 5b pop %rbx
3641: 41 5e pop %r14
3643: c3 retq
3644: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
364b: 00 00 00
364e: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
3655: 00 00 00
3658: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
365f: 00
0000000000003660 <ZSTD_decompressSequencesLong_bmi2>:
{
3660: 55 push %rbp
3661: 41 57 push %r15
3663: 41 56 push %r14
3665: 41 55 push %r13
3667: 41 54 push %r12
3669: 53 push %rbx
366a: 48 81 ec 18 02 00 00 sub $0x218,%rsp
3671: 49 89 ca mov %rcx,%r10
3674: 49 89 f5 mov %rsi,%r13
BYTE* const oend = ostart + maxDstSize;
3677: 48 01 f2 add %rsi,%rdx
const BYTE* litPtr = dctx->litPtr;
367a: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi
3681: 48 89 b4 24 d8 00 00 mov %rsi,0xd8(%rsp)
3688: 00
3689: 4c 8b a7 c0 75 00 00 mov 0x75c0(%rdi),%r12
const BYTE* const litEnd = litPtr + dctx->litSize;
3690: 49 01 f4 add %rsi,%r12
BYTE* op = ostart;
3693: 4c 89 e9 mov %r13,%rcx
if (nbSeq) {
3696: 45 85 c9 test %r9d,%r9d
3699: 0f 84 7c 15 00 00 je 4c1b <ZSTD_decompressSequencesLong_bmi2+0x15bb>
369f: 48 8b af c8 74 00 00 mov 0x74c8(%rdi),%rbp
36a6: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax
36ad: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp)
36b4: 00
36b5: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax
36bc: 48 89 84 24 e8 00 00 mov %rax,0xe8(%rsp)
36c3: 00
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
36c4: 41 83 f9 09 cmp $0x9,%r9d
dctx->fseEntropy = 1;
36c8: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi)
36cf: 00 00 00
{ int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
36d2: 44 8b b7 3c 68 00 00 mov 0x683c(%rdi),%r14d
36d9: 4c 89 b4 24 98 00 00 mov %r14,0x98(%rsp)
36e0: 00
36e1: f2 0f 10 87 40 68 00 movsd 0x6840(%rdi),%xmm0
36e8: 00
36e9: 0f 57 c9 xorps %xmm1,%xmm1
36ec: 0f 14 c1 unpcklps %xmm1,%xmm0
36ef: 0f 11 84 24 a0 00 00 movups %xmm0,0xa0(%rsp)
36f6: 00
36f7: b9 08 00 00 00 mov $0x8,%ecx
int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
36fc: 41 0f 4c c9 cmovl %r9d,%ecx
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
3700: 4d 85 c0 test %r8,%r8
3703: 74 79 je 377e <ZSTD_decompressSequencesLong_bmi2+0x11e>
3705: 48 89 94 24 f8 00 00 mov %rdx,0xf8(%rsp)
370c: 00
370d: 4c 89 a4 24 b8 00 00 mov %r12,0xb8(%rsp)
3714: 00
bitD->start = (const char*)srcBuffer;
3715: 4c 89 54 24 58 mov %r10,0x58(%rsp)
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
371a: 49 8d 42 08 lea 0x8(%r10),%rax
371e: 48 89 44 24 60 mov %rax,0x60(%rsp)
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
3723: 49 83 f8 08 cmp $0x8,%r8
3727: 72 74 jb 379d <ZSTD_decompressSequencesLong_bmi2+0x13d>
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
3729: 4b 8d 04 02 lea (%r10,%r8,1),%rax
372d: 48 83 c0 f8 add $0xfffffffffffffff8,%rax
3731: 48 89 44 24 50 mov %rax,0x50(%rsp)
3736: 4b 8b 74 02 f8 mov -0x8(%r10,%r8,1),%rsi
bitD->bitContainer = MEM_readLEST(bitD->ptr);
373b: 48 89 74 24 40 mov %rsi,0x40(%rsp)
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
3740: 43 0f b6 44 10 ff movzbl -0x1(%r8,%r10,1),%eax
3746: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
3748: 0f 84 2f 01 00 00 je 387d <ZSTD_decompressSequencesLong_bmi2+0x21d>
374e: 89 4c 24 3c mov %ecx,0x3c(%rsp)
return __builtin_clz (val) ^ 31;
3752: 0f bd c0 bsr %eax,%eax
3755: f7 d0 not %eax
3757: 83 c8 e0 or $0xffffffe0,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
375a: 83 c0 09 add $0x9,%eax
375d: 89 44 24 48 mov %eax,0x48(%rsp)
3761: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
3768: 49 83 f8 88 cmp $0xffffffffffffff88,%r8
RETURN_ERROR_IF(
376c: 0f 87 dc 14 00 00 ja 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
3772: 49 89 ec mov %rbp,%r12
3775: 49 83 c0 f8 add $0xfffffffffffffff8,%r8
3779: e9 d1 00 00 00 jmpq 384f <ZSTD_decompressSequencesLong_bmi2+0x1ef>
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
377e: 0f 29 4c 24 50 movaps %xmm1,0x50(%rsp)
3783: 0f 29 4c 24 40 movaps %xmm1,0x40(%rsp)
3788: 48 c7 44 24 60 00 00 movq $0x0,0x60(%rsp)
378f: 00 00
3791: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
3798: e9 b1 14 00 00 jmpq 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
bitD->ptr = bitD->start;
379d: 4c 89 54 24 50 mov %r10,0x50(%rsp)
bitD->bitContainer = *(const BYTE*)(bitD->start);
37a2: 41 0f b6 12 movzbl (%r10),%edx
37a6: 48 89 54 24 40 mov %rdx,0x40(%rsp)
switch(srcSize)
37ab: 49 8d 40 fe lea -0x2(%r8),%rax
37af: 48 83 f8 05 cmp $0x5,%rax
37b3: 49 89 ec mov %rbp,%r12
37b6: 77 6d ja 3825 <ZSTD_decompressSequencesLong_bmi2+0x1c5>
37b8: ff 24 c5 00 00 00 00 jmpq *0x0(,%rax,8)
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
37bf: 41 0f b6 42 06 movzbl 0x6(%r10),%eax
37c4: 48 c1 e0 30 shl $0x30,%rax
37c8: 48 09 c2 or %rax,%rdx
37cb: 48 89 54 24 40 mov %rdx,0x40(%rsp)
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
37d0: 41 0f b6 42 05 movzbl 0x5(%r10),%eax
37d5: 48 c1 e0 28 shl $0x28,%rax
37d9: 48 01 c2 add %rax,%rdx
37dc: 48 89 54 24 40 mov %rdx,0x40(%rsp)
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
37e1: 41 0f b6 42 04 movzbl 0x4(%r10),%eax
37e6: 48 c1 e0 20 shl $0x20,%rax
37ea: 48 01 c2 add %rax,%rdx
37ed: 48 89 54 24 40 mov %rdx,0x40(%rsp)
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
37f2: 41 0f b6 42 03 movzbl 0x3(%r10),%eax
37f7: 48 c1 e0 18 shl $0x18,%rax
37fb: 48 01 c2 add %rax,%rdx
37fe: 48 89 54 24 40 mov %rdx,0x40(%rsp)
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
3803: 41 0f b6 42 02 movzbl 0x2(%r10),%eax
3808: 48 c1 e0 10 shl $0x10,%rax
380c: 48 01 c2 add %rax,%rdx
380f: 48 89 54 24 40 mov %rdx,0x40(%rsp)
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
3814: 41 0f b6 42 01 movzbl 0x1(%r10),%eax
3819: 48 c1 e0 08 shl $0x8,%rax
381d: 48 01 c2 add %rax,%rdx
3820: 48 89 54 24 40 mov %rdx,0x40(%rsp)
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
3825: 43 0f b6 44 10 ff movzbl -0x1(%r8,%r10,1),%eax
382b: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
382d: 74 4e je 387d <ZSTD_decompressSequencesLong_bmi2+0x21d>
382f: 48 89 d6 mov %rdx,%rsi
3832: 89 4c 24 3c mov %ecx,0x3c(%rsp)
return __builtin_clz (val) ^ 31;
3836: 0f bd c0 bsr %eax,%eax
3839: f7 d0 not %eax
383b: 83 c8 e0 or $0xffffffe0,%eax
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
383e: 41 c1 e0 03 shl $0x3,%r8d
3842: 44 29 c0 sub %r8d,%eax
3845: 83 c0 49 add $0x49,%eax
3848: 89 44 24 48 mov %eax,0x48(%rsp)
384c: 45 31 c0 xor %r8d,%r8d
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
384f: 48 8b 0f mov (%rdi),%rcx
3852: 48 89 cd mov %rcx,%rbp
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
3855: 8b 49 04 mov 0x4(%rcx),%ecx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
3858: 01 c8 add %ecx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
385a: 89 c2 mov %eax,%edx
385c: f6 da neg %dl
385e: c4 e2 eb f7 d6 shrx %rdx,%rsi,%rdx
3863: 23 14 8d 00 00 00 00 and 0x0(,%rcx,4),%edx
bitD->bitsConsumed += nbBits;
386a: 89 44 24 48 mov %eax,0x48(%rsp)
386e: 48 89 54 24 68 mov %rdx,0x68(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3873: 83 f8 40 cmp $0x40,%eax
3876: 76 19 jbe 3891 <ZSTD_decompressSequencesLong_bmi2+0x231>
3878: 49 89 f3 mov %rsi,%r11
387b: eb 6c jmp 38e9 <ZSTD_decompressSequencesLong_bmi2+0x289>
387d: c7 44 24 48 00 00 00 movl $0x0,0x48(%rsp)
3884: 00
3885: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
388c: e9 bd 13 00 00 jmpq 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
if (bitD->ptr >= bitD->limitPtr) {
3891: 49 83 f8 08 cmp $0x8,%r8
3895: 7d 31 jge 38c8 <ZSTD_decompressSequencesLong_bmi2+0x268>
if (bitD->ptr == bitD->start) {
3897: 4d 85 c0 test %r8,%r8
389a: 0f 84 0a 02 00 00 je 3aaa <ZSTD_decompressSequencesLong_bmi2+0x44a>
38a0: 4b 8d 0c 02 lea (%r10,%r8,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
38a4: 89 c6 mov %eax,%esi
38a6: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
38a9: 48 29 f1 sub %rsi,%rcx
38ac: 4c 39 d1 cmp %r10,%rcx
38af: 44 89 c1 mov %r8d,%ecx
38b2: 0f 43 ce cmovae %esi,%ecx
bitD->ptr -= nbBytes;
38b5: 49 29 c8 sub %rcx,%r8
38b8: 4b 8d 34 02 lea (%r10,%r8,1),%rsi
38bc: 48 89 74 24 50 mov %rsi,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
38c1: c1 e1 03 shl $0x3,%ecx
38c4: 29 c8 sub %ecx,%eax
38c6: eb 14 jmp 38dc <ZSTD_decompressSequencesLong_bmi2+0x27c>
bitD->ptr -= bitD->bitsConsumed >> 3;
38c8: 89 c1 mov %eax,%ecx
38ca: c1 e9 03 shr $0x3,%ecx
38cd: 49 29 c8 sub %rcx,%r8
38d0: 4b 8d 0c 02 lea (%r10,%r8,1),%rcx
38d4: 48 89 4c 24 50 mov %rcx,0x50(%rsp)
bitD->bitsConsumed &= 7;
38d9: 83 e0 07 and $0x7,%eax
38dc: 89 44 24 48 mov %eax,0x48(%rsp)
38e0: 4f 8b 1c 02 mov (%r10,%r8,1),%r11
38e4: 4c 89 5c 24 40 mov %r11,0x40(%rsp)
DStatePtr->table = dt + 1;
38e9: 48 83 c5 08 add $0x8,%rbp
38ed: 48 89 ac 24 48 01 00 mov %rbp,0x148(%rsp)
38f4: 00
38f5: 48 89 6c 24 70 mov %rbp,0x70(%rsp)
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
38fa: 48 8b 4f 10 mov 0x10(%rdi),%rcx
38fe: 49 89 cf mov %rcx,%r15
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
3901: 8b 49 04 mov 0x4(%rcx),%ecx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
3904: 01 c8 add %ecx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
3906: 89 c6 mov %eax,%esi
3908: 40 f6 de neg %sil
390b: c4 c2 cb f7 f3 shrx %rsi,%r11,%rsi
3910: 23 34 8d 00 00 00 00 and 0x0(,%rcx,4),%esi
bitD->bitsConsumed += nbBits;
3917: 89 44 24 48 mov %eax,0x48(%rsp)
391b: 48 89 74 24 78 mov %rsi,0x78(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3920: 83 f8 40 cmp $0x40,%eax
3923: 4c 89 dd mov %r11,%rbp
3926: 77 58 ja 3980 <ZSTD_decompressSequencesLong_bmi2+0x320>
if (bitD->ptr >= bitD->limitPtr) {
3928: 49 83 f8 08 cmp $0x8,%r8
392c: 7d 31 jge 395f <ZSTD_decompressSequencesLong_bmi2+0x2ff>
if (bitD->ptr == bitD->start) {
392e: 4d 85 c0 test %r8,%r8
3931: 0f 84 7e 01 00 00 je 3ab5 <ZSTD_decompressSequencesLong_bmi2+0x455>
3937: 4b 8d 0c 02 lea (%r10,%r8,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
393b: 89 c5 mov %eax,%ebp
393d: c1 ed 03 shr $0x3,%ebp
if (bitD->ptr - nbBytes < bitD->start) {
3940: 48 29 e9 sub %rbp,%rcx
3943: 4c 39 d1 cmp %r10,%rcx
3946: 44 89 c1 mov %r8d,%ecx
3949: 0f 43 cd cmovae %ebp,%ecx
bitD->ptr -= nbBytes;
394c: 49 29 c8 sub %rcx,%r8
394f: 4b 8d 2c 02 lea (%r10,%r8,1),%rbp
3953: 48 89 6c 24 50 mov %rbp,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
3958: c1 e1 03 shl $0x3,%ecx
395b: 29 c8 sub %ecx,%eax
395d: eb 14 jmp 3973 <ZSTD_decompressSequencesLong_bmi2+0x313>
bitD->ptr -= bitD->bitsConsumed >> 3;
395f: 89 c1 mov %eax,%ecx
3961: c1 e9 03 shr $0x3,%ecx
3964: 49 29 c8 sub %rcx,%r8
3967: 4b 8d 0c 02 lea (%r10,%r8,1),%rcx
396b: 48 89 4c 24 50 mov %rcx,0x50(%rsp)
bitD->bitsConsumed &= 7;
3970: 83 e0 07 and $0x7,%eax
3973: 89 44 24 48 mov %eax,0x48(%rsp)
3977: 4b 8b 2c 02 mov (%r10,%r8,1),%rbp
397b: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3980: 4c 89 ac 24 c8 00 00 mov %r13,0xc8(%rsp)
3987: 00
DStatePtr->table = dt + 1;
3988: 49 83 c7 08 add $0x8,%r15
398c: 4c 89 bc 24 40 01 00 mov %r15,0x140(%rsp)
3993: 00
3994: 4c 89 bc 24 80 00 00 mov %r15,0x80(%rsp)
399b: 00
399c: 48 89 bc 24 38 01 00 mov %rdi,0x138(%rsp)
39a3: 00
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
39a4: 48 8b 5f 08 mov 0x8(%rdi),%rbx
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
39a8: 8b 4b 04 mov 0x4(%rbx),%ecx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
39ab: 01 c8 add %ecx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
39ad: 89 c7 mov %eax,%edi
39af: 40 f6 df neg %dil
39b2: c4 62 c3 f7 dd shrx %rdi,%rbp,%r11
39b7: 44 23 1c 8d 00 00 00 and 0x0(,%rcx,4),%r11d
39be: 00
39bf: 4d 29 e5 sub %r12,%r13
bitD->bitsConsumed += nbBits;
39c2: 89 44 24 48 mov %eax,0x48(%rsp)
39c6: 4c 89 9c 24 88 00 00 mov %r11,0x88(%rsp)
39cd: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
39ce: 83 f8 41 cmp $0x41,%eax
39d1: 44 89 4c 24 04 mov %r9d,0x4(%rsp)
39d6: 4c 89 64 24 10 mov %r12,0x10(%rsp)
39db: 72 17 jb 39f4 <ZSTD_decompressSequencesLong_bmi2+0x394>
39dd: 45 89 cf mov %r9d,%r15d
DStatePtr->table = dt + 1;
39e0: 48 83 c3 08 add $0x8,%rbx
39e4: 48 89 9c 24 90 00 00 mov %rbx,0x90(%rsp)
39eb: 00
39ec: 45 31 d2 xor %r10d,%r10d
39ef: e9 5a 05 00 00 jmpq 3f4e <ZSTD_decompressSequencesLong_bmi2+0x8ee>
39f4: 48 89 9c 24 10 01 00 mov %rbx,0x110(%rsp)
39fb: 00
if (bitD->ptr >= bitD->limitPtr) {
39fc: 49 83 f8 08 cmp $0x8,%r8
3a00: 4c 89 94 24 f0 00 00 mov %r10,0xf0(%rsp)
3a07: 00
3a08: 7d 70 jge 3a7a <ZSTD_decompressSequencesLong_bmi2+0x41a>
3a0a: 45 31 d2 xor %r10d,%r10d
if (bitD->ptr == bitD->start) {
3a0d: 4d 85 c0 test %r8,%r8
3a10: 48 8b 9c 24 10 01 00 mov 0x110(%rsp),%rbx
3a17: 00
3a18: 0f 84 9f 00 00 00 je 3abd <ZSTD_decompressSequencesLong_bmi2+0x45d>
3a1e: 48 8b ac 24 f0 00 00 mov 0xf0(%rsp),%rbp
3a25: 00
3a26: 49 8d 0c 28 lea (%r8,%rbp,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
3a2a: 89 c7 mov %eax,%edi
3a2c: c1 ef 03 shr $0x3,%edi
if (bitD->ptr - nbBytes < bitD->start) {
3a2f: 48 29 f9 sub %rdi,%rcx
3a32: 48 39 e9 cmp %rbp,%rcx
3a35: 44 89 c1 mov %r8d,%ecx
3a38: 0f 43 cf cmovae %edi,%ecx
bitD->ptr -= nbBytes;
3a3b: 49 29 c8 sub %rcx,%r8
3a3e: 49 8d 3c 28 lea (%r8,%rbp,1),%rdi
3a42: 48 89 7c 24 50 mov %rdi,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
3a47: c1 e1 03 shl $0x3,%ecx
3a4a: 29 c8 sub %ecx,%eax
3a4c: 89 44 24 48 mov %eax,0x48(%rsp)
3a50: 4c 89 44 24 28 mov %r8,0x28(%rsp)
3a55: 4a 8b 6c 05 00 mov 0x0(%rbp,%r8,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
3a5a: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3a5f: 48 8d 4b 08 lea 0x8(%rbx),%rcx
3a63: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp)
3a6a: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3a6b: 83 f8 40 cmp $0x40,%eax
3a6e: 76 60 jbe 3ad0 <ZSTD_decompressSequencesLong_bmi2+0x470>
3a70: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
3a75: e9 d4 04 00 00 jmpq 3f4e <ZSTD_decompressSequencesLong_bmi2+0x8ee>
bitD->ptr -= bitD->bitsConsumed >> 3;
3a7a: 89 c1 mov %eax,%ecx
3a7c: c1 e9 03 shr $0x3,%ecx
3a7f: 49 29 c8 sub %rcx,%r8
3a82: 4b 8d 0c 02 lea (%r10,%r8,1),%rcx
3a86: 48 89 4c 24 50 mov %rcx,0x50(%rsp)
bitD->bitsConsumed &= 7;
3a8b: 83 e0 07 and $0x7,%eax
3a8e: 89 44 24 48 mov %eax,0x48(%rsp)
3a92: 4c 89 44 24 28 mov %r8,0x28(%rsp)
3a97: 4b 8b 2c 02 mov (%r10,%r8,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr);
3a9b: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3aa0: 48 8b 9c 24 10 01 00 mov 0x110(%rsp),%rbx
3aa7: 00
3aa8: eb 1a jmp 3ac4 <ZSTD_decompressSequencesLong_bmi2+0x464>
3aaa: 45 31 c0 xor %r8d,%r8d
3aad: 49 89 f3 mov %rsi,%r11
3ab0: e9 34 fe ff ff jmpq 38e9 <ZSTD_decompressSequencesLong_bmi2+0x289>
3ab5: 45 31 c0 xor %r8d,%r8d
3ab8: e9 c3 fe ff ff jmpq 3980 <ZSTD_decompressSequencesLong_bmi2+0x320>
3abd: 31 c9 xor %ecx,%ecx
3abf: 48 89 4c 24 28 mov %rcx,0x28(%rsp)
3ac4: 48 8d 4b 08 lea 0x8(%rbx),%rcx
3ac8: 48 89 8c 24 90 00 00 mov %rcx,0x90(%rsp)
3acf: 00
3ad0: 31 c9 xor %ecx,%ecx
3ad2: 48 89 4c 24 08 mov %rcx,0x8(%rsp)
3ad7: 8b 4c 24 3c mov 0x3c(%rsp),%ecx
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3adb: 85 c9 test %ecx,%ecx
3add: bf 00 00 00 00 mov $0x0,%edi
3ae2: 0f 49 f9 cmovns %ecx,%edi
3ae5: 48 89 7c 24 20 mov %rdi,0x20(%rsp)
3aea: 0f 13 84 24 e0 00 00 movlps %xmm0,0xe0(%rsp)
3af1: 00
3af2: 4c 8d 94 24 60 01 00 lea 0x160(%rsp),%r10
3af9: 00
3afa: 4c 8b 4c 24 28 mov 0x28(%rsp),%r9
3aff: e9 ce 00 00 00 jmpq 3bd2 <ZSTD_decompressSequencesLong_bmi2+0x572>
3b04: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
3b0b: 00 00 00
3b0e: 66 90 xchg %ax,%ax
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
3b10: 44 01 d8 add %r11d,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
3b13: 89 c2 mov %eax,%edx
3b15: f6 da neg %dl
3b17: c4 e2 eb f7 d5 shrx %rdx,%rbp,%rdx
3b1c: 44 89 de mov %r11d,%esi
3b1f: 23 14 b5 00 00 00 00 and 0x0(,%rsi,4),%edx
3b26: 8b bc 24 20 01 00 00 mov 0x120(%rsp),%edi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
3b2d: 01 f8 add %edi,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
3b2f: 89 c6 mov %eax,%esi
3b31: 40 f6 de neg %sil
3b34: c4 62 cb f7 dd shrx %rsi,%rbp,%r11
3b39: 89 fe mov %edi,%esi
3b3b: 44 23 1c b5 00 00 00 and 0x0(,%rsi,4),%r11d
3b42: 00
DStatePtr->state = DInfo.nextState + lowBits;
3b43: 48 03 94 24 08 01 00 add 0x108(%rsp),%rdx
3b4a: 00
3b4b: 4c 03 9c 24 18 01 00 add 0x118(%rsp),%r11
3b52: 00
3b53: 8b bc 24 24 01 00 00 mov 0x124(%rsp),%edi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
3b5a: 01 f8 add %edi,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
3b5c: 89 c6 mov %eax,%esi
3b5e: 40 f6 de neg %sil
3b61: c4 e2 cb f7 f5 shrx %rsi,%rbp,%rsi
3b66: 89 ff mov %edi,%edi
3b68: 23 34 bd 00 00 00 00 and 0x0(,%rdi,4),%esi
3b6f: 48 89 54 24 68 mov %rdx,0x68(%rsp)
3b74: 4c 89 9c 24 88 00 00 mov %r11,0x88(%rsp)
3b7b: 00
3b7c: 48 03 b4 24 c0 00 00 add 0xc0(%rsp),%rsi
3b83: 00
bitD->bitsConsumed += nbBits;
3b84: 89 44 24 48 mov %eax,0x48(%rsp)
prefetchPos += sequence.litLength;
3b88: 4d 01 fd add %r15,%r13
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;
3b8b: 4d 39 e5 cmp %r12,%r13
3b8e: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi
3b93: 48 0f 42 bc 24 e8 00 cmovb 0xe8(%rsp),%rdi
3b9a: 00 00
DStatePtr->state = DInfo.nextState + lowBits;
3b9c: 48 89 74 24 78 mov %rsi,0x78(%rsp)
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.
3ba1: 4c 01 ef add %r13,%rdi
3ba4: 4c 29 e7 sub %r12,%rdi
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
3ba7: 0f 18 0f prefetcht0 (%rdi)
3baa: 0f 18 4f 40 prefetcht0 0x40(%rdi)
sequences[seqNb] = sequence;
3bae: 4d 89 7a f0 mov %r15,-0x10(%r10)
return prefetchPos + sequence.matchLength;
3bb2: 49 01 cd add %rcx,%r13
sequences[seqNb] = sequence;
3bb5: 49 89 4a f8 mov %rcx,-0x8(%r10)
3bb9: 4d 89 22 mov %r12,(%r10)
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
3bbc: 48 83 44 24 08 01 addq $0x1,0x8(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3bc2: 49 83 c2 18 add $0x18,%r10
3bc6: 4d 89 e6 mov %r12,%r14
3bc9: 83 f8 40 cmp $0x40,%eax
3bcc: 0f 87 6d 03 00 00 ja 3f3f <ZSTD_decompressSequencesLong_bmi2+0x8df>
if (bitD->ptr >= bitD->limitPtr) {
3bd2: 49 83 f9 08 cmp $0x8,%r9
3bd6: 7d 48 jge 3c20 <ZSTD_decompressSequencesLong_bmi2+0x5c0>
if (bitD->ptr == bitD->start) {
3bd8: 4d 85 c9 test %r9,%r9
3bdb: 0f 84 32 02 00 00 je 3e13 <ZSTD_decompressSequencesLong_bmi2+0x7b3>
3be1: 48 8b bc 24 f0 00 00 mov 0xf0(%rsp),%rdi
3be8: 00
3be9: 4a 8d 0c 0f lea (%rdi,%r9,1),%rcx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
3bed: 89 c5 mov %eax,%ebp
3bef: c1 ed 03 shr $0x3,%ebp
if (bitD->ptr - nbBytes < bitD->start) {
3bf2: 48 29 e9 sub %rbp,%rcx
3bf5: 48 39 f9 cmp %rdi,%rcx
3bf8: 44 89 c9 mov %r9d,%ecx
3bfb: 0f 43 cd cmovae %ebp,%ecx
bitD->ptr -= nbBytes;
3bfe: 49 29 c9 sub %rcx,%r9
3c01: 4a 8d 2c 0f lea (%rdi,%r9,1),%rbp
3c05: 48 89 6c 24 50 mov %rbp,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
3c0a: c1 e1 03 shl $0x3,%ecx
3c0d: 29 c8 sub %ecx,%eax
3c0f: eb 2b jmp 3c3c <ZSTD_decompressSequencesLong_bmi2+0x5dc>
3c11: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
3c18: 00 00 00
3c1b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
bitD->ptr -= bitD->bitsConsumed >> 3;
3c20: 89 c1 mov %eax,%ecx
3c22: c1 e9 03 shr $0x3,%ecx
3c25: 49 29 c9 sub %rcx,%r9
3c28: 48 8b bc 24 f0 00 00 mov 0xf0(%rsp),%rdi
3c2f: 00
3c30: 4a 8d 0c 0f lea (%rdi,%r9,1),%rcx
3c34: 48 89 4c 24 50 mov %rcx,0x50(%rsp)
bitD->bitsConsumed &= 7;
3c39: 83 e0 07 and $0x7,%eax
3c3c: 89 44 24 48 mov %eax,0x48(%rsp)
3c40: 4a 8b 2c 0f mov (%rdi,%r9,1),%rbp
3c44: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3c49: 4c 89 4c 24 28 mov %r9,0x28(%rsp)
3c4e: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx
3c53: 48 39 4c 24 20 cmp %rcx,0x20(%rsp)
3c58: 0f 84 d0 02 00 00 je 3f2e <ZSTD_decompressSequencesLong_bmi2+0x8ce>
3c5e: 4c 89 ac 24 d0 00 00 mov %r13,0xd0(%rsp)
3c65: 00
3c66: 4c 89 8c 24 30 01 00 mov %r9,0x130(%rsp)
3c6d: 00
3c6e: 48 89 6c 24 18 mov %rbp,0x18(%rsp)
3c73: 4c 89 74 24 30 mov %r14,0x30(%rsp)
3c78: 48 8b 8c 24 48 01 00 mov 0x148(%rsp),%rcx
3c7f: 00
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
3c80: 0f b7 1c d1 movzwl (%rcx,%rdx,8),%ebx
3c84: 0f b6 7c d1 02 movzbl 0x2(%rcx,%rdx,8),%edi
3c89: 44 0f b6 74 d1 03 movzbl 0x3(%rcx,%rdx,8),%r14d
3c8f: 44 8b 4c d1 04 mov 0x4(%rcx,%rdx,8),%r9d
3c94: 48 8b 8c 24 10 01 00 mov 0x110(%rsp),%rcx
3c9b: 00
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
3c9c: 42 0f b7 54 d9 08 movzwl 0x8(%rcx,%r11,8),%edx
3ca2: 48 89 94 24 18 01 00 mov %rdx,0x118(%rsp)
3ca9: 00
3caa: 46 0f b6 44 d9 0a movzbl 0xa(%rcx,%r11,8),%r8d
3cb0: 42 0f b6 54 d9 0b movzbl 0xb(%rcx,%r11,8),%edx
3cb6: 89 94 24 20 01 00 00 mov %edx,0x120(%rsp)
3cbd: 46 8b 5c d9 0c mov 0xc(%rcx,%r11,8),%r11d
3cc2: 48 8b 8c 24 40 01 00 mov 0x140(%rsp),%rcx
3cc9: 00
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
3cca: 44 0f b7 2c f1 movzwl (%rcx,%rsi,8),%r13d
3ccf: 0f b6 6c f1 02 movzbl 0x2(%rcx,%rsi,8),%ebp
3cd4: 48 89 bc 24 28 01 00 mov %rdi,0x128(%rsp)
3cdb: 00
BYTE const totalBits = llBits+mlBits+ofBits;
3cdc: 41 8d 14 38 lea (%r8,%rdi,1),%edx
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
3ce0: 0f b6 7c f1 03 movzbl 0x3(%rcx,%rsi,8),%edi
3ce5: 89 bc 24 24 01 00 00 mov %edi,0x124(%rsp)
3cec: 44 8b 7c f1 04 mov 0x4(%rcx,%rsi,8),%r15d
3cf1: 83 fd 02 cmp $0x2,%ebp
3cf4: 4c 89 ac 24 c0 00 00 mov %r13,0xc0(%rsp)
3cfb: 00
3cfc: 48 89 9c 24 08 01 00 mov %rbx,0x108(%rsp)
3d03: 00
if (ofBits > 1) {
3d04: 72 5a jb 3d60 <ZSTD_decompressSequencesLong_bmi2+0x700>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
3d06: c4 e2 f9 f7 74 24 18 shlx %rax,0x18(%rsp),%rsi
3d0d: 89 ef mov %ebp,%edi
3d0f: 40 f6 df neg %dil
bitD->bitsConsumed += nbBits;
3d12: 01 e8 add %ebp,%eax
3d14: 89 44 24 48 mov %eax,0x48(%rsp)
3d18: 48 8b 9c 24 e0 00 00 mov 0xe0(%rsp),%rbx
3d1f: 00
seqState->prevOffset[2] = seqState->prevOffset[1];
3d20: 48 89 9c 24 a8 00 00 mov %rbx,0xa8(%rsp)
3d27: 00
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
3d28: c4 e2 c3 f7 f6 shrx %rdi,%rsi,%rsi
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
3d2d: 4c 01 fe add %r15,%rsi
3d30: 48 89 f7 mov %rsi,%rdi
3d33: 4d 89 cf mov %r9,%r15
3d36: 4c 89 d9 mov %r11,%rcx
3d39: 45 89 f3 mov %r14d,%r11d
3d3c: 4c 8b 74 24 30 mov 0x30(%rsp),%r14
3d41: 4c 89 b4 24 a0 00 00 mov %r14,0xa0(%rsp)
3d48: 00
3d49: 48 89 bc 24 98 00 00 mov %rdi,0x98(%rsp)
3d50: 00
3d51: 49 89 fc mov %rdi,%r12
3d54: 4c 89 f7 mov %r14,%rdi
3d57: eb 2b jmp 3d84 <ZSTD_decompressSequencesLong_bmi2+0x724>
3d59: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
if (LIKELY((ofBits == 0))) {
3d60: 40 84 ed test %bpl,%bpl
3d63: 48 8b bc 24 e0 00 00 mov 0xe0(%rsp),%rdi
3d6a: 00
3d6b: 0f 85 ba 00 00 00 jne 3e2b <ZSTD_decompressSequencesLong_bmi2+0x7cb>
3d71: 4d 89 cf mov %r9,%r15
U32 const ll0 = (llBase == 0);
3d74: 45 85 ff test %r15d,%r15d
3d77: 4c 89 d9 mov %r11,%rcx
3d7a: 45 89 f3 mov %r14d,%r11d
if (LIKELY(!ll0))
3d7d: 74 bd je 3d3c <ZSTD_decompressSequencesLong_bmi2+0x6dc>
3d7f: 4c 8b 64 24 30 mov 0x30(%rsp),%r12
3d84: 4c 8b 8c 24 30 01 00 mov 0x130(%rsp),%r9
3d8b: 00
3d8c: 4c 8b ac 24 d0 00 00 mov 0xd0(%rsp),%r13
3d93: 00
3d94: 4c 8b b4 24 28 01 00 mov 0x128(%rsp),%r14
3d9b: 00
3d9c: 40 00 ea add %bpl,%dl
if (mlBits > 0)
3d9f: 45 84 c0 test %r8b,%r8b
3da2: 74 2c je 3dd0 <ZSTD_decompressSequencesLong_bmi2+0x770>
3da4: 48 8b 6c 24 18 mov 0x18(%rsp),%rbp
3da9: c4 e2 f9 f7 f5 shlx %rax,%rbp,%rsi
3dae: 48 89 fb mov %rdi,%rbx
3db1: 44 89 c7 mov %r8d,%edi
3db4: 40 f6 df neg %dil
3db7: c4 e2 c3 f7 f6 shrx %rdi,%rsi,%rsi
3dbc: 48 89 df mov %rbx,%rdi
bitD->bitsConsumed += nbBits;
3dbf: 44 01 c0 add %r8d,%eax
3dc2: 89 44 24 48 mov %eax,0x48(%rsp)
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
3dc6: 48 01 f1 add %rsi,%rcx
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
3dc9: 80 fa 1f cmp $0x1f,%dl
3dcc: 73 0c jae 3dda <ZSTD_decompressSequencesLong_bmi2+0x77a>
3dce: eb 13 jmp 3de3 <ZSTD_decompressSequencesLong_bmi2+0x783>
3dd0: 48 8b 6c 24 18 mov 0x18(%rsp),%rbp
3dd5: 80 fa 1f cmp $0x1f,%dl
3dd8: 72 09 jb 3de3 <ZSTD_decompressSequencesLong_bmi2+0x783>
3dda: 83 f8 40 cmp $0x40,%eax
3ddd: 0f 86 84 00 00 00 jbe 3e67 <ZSTD_decompressSequencesLong_bmi2+0x807>
if (llBits > 0)
3de3: 45 84 f6 test %r14b,%r14b
3de6: 48 89 bc 24 e0 00 00 mov %rdi,0xe0(%rsp)
3ded: 00
3dee: 0f 84 1c fd ff ff je 3b10 <ZSTD_decompressSequencesLong_bmi2+0x4b0>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
3df4: c4 e2 f9 f7 d5 shlx %rax,%rbp,%rdx
3df9: 44 89 f6 mov %r14d,%esi
3dfc: 40 f6 de neg %sil
3dff: c4 e2 cb f7 d2 shrx %rsi,%rdx,%rdx
bitD->bitsConsumed += nbBits;
3e04: 44 01 f0 add %r14d,%eax
3e07: 89 44 24 48 mov %eax,0x48(%rsp)
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
3e0b: 49 01 d7 add %rdx,%r15
3e0e: e9 fd fc ff ff jmpq 3b10 <ZSTD_decompressSequencesLong_bmi2+0x4b0>
3e13: 45 31 c9 xor %r9d,%r9d
3e16: 48 8b 4c 24 08 mov 0x8(%rsp),%rcx
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
3e1b: 48 39 4c 24 20 cmp %rcx,0x20(%rsp)
3e20: 0f 85 38 fe ff ff jne 3c5e <ZSTD_decompressSequencesLong_bmi2+0x5fe>
3e26: e9 03 01 00 00 jmpq 3f2e <ZSTD_decompressSequencesLong_bmi2+0x8ce>
3e2b: 49 89 fc mov %rdi,%r12
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
3e2e: 41 83 f9 01 cmp $0x1,%r9d
3e32: 41 83 d7 00 adc $0x0,%r15d
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
3e36: c4 e2 f9 f7 74 24 18 shlx %rax,0x18(%rsp),%rsi
3e3d: 48 c1 ee 3f shr $0x3f,%rsi
bitD->bitsConsumed += nbBits;
3e41: 83 c0 01 add $0x1,%eax
3e44: 89 44 24 48 mov %eax,0x48(%rsp)
3e48: 4c 01 fe add %r15,%rsi
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
3e4b: 48 83 fe 03 cmp $0x3,%rsi
3e4f: 75 6f jne 3ec0 <ZSTD_decompressSequencesLong_bmi2+0x860>
3e51: 48 8b 4c 24 30 mov 0x30(%rsp),%rcx
3e56: 48 8d 79 ff lea -0x1(%rcx),%rdi
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
3e5a: 48 83 ff 01 cmp $0x1,%rdi
3e5e: 48 83 d7 00 adc $0x0,%rdi
3e62: 4c 89 d9 mov %r11,%rcx
3e65: eb 72 jmp 3ed9 <ZSTD_decompressSequencesLong_bmi2+0x879>
3e67: 4c 8b 4c 24 28 mov 0x28(%rsp),%r9
if (bitD->ptr >= bitD->limitPtr) {
3e6c: 49 83 f9 08 cmp $0x8,%r9
3e70: 7d 77 jge 3ee9 <ZSTD_decompressSequencesLong_bmi2+0x889>
3e72: 49 89 f8 mov %rdi,%r8
if (bitD->ptr == bitD->start) {
3e75: 4d 85 c9 test %r9,%r9
3e78: 0f 84 9e 00 00 00 je 3f1c <ZSTD_decompressSequencesLong_bmi2+0x8bc>
3e7e: 48 8b bc 24 f0 00 00 mov 0xf0(%rsp),%rdi
3e85: 00
3e86: 4a 8d 14 0f lea (%rdi,%r9,1),%rdx
{ U32 nbBytes = bitD->bitsConsumed >> 3;
3e8a: 89 c6 mov %eax,%esi
3e8c: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
3e8f: 48 29 f2 sub %rsi,%rdx
3e92: 48 39 fa cmp %rdi,%rdx
3e95: 44 89 ca mov %r9d,%edx
3e98: 0f 43 d6 cmovae %esi,%edx
bitD->ptr -= nbBytes;
3e9b: 49 29 d1 sub %rdx,%r9
3e9e: 4a 8d 34 0f lea (%rdi,%r9,1),%rsi
3ea2: 48 89 74 24 50 mov %rsi,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
3ea7: c1 e2 03 shl $0x3,%edx
3eaa: 29 d0 sub %edx,%eax
3eac: 89 44 24 48 mov %eax,0x48(%rsp)
3eb0: 4a 8b 2c 0f mov (%rdi,%r9,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr); /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
3eb4: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3eb9: 4c 89 4c 24 28 mov %r9,0x28(%rsp)
3ebe: eb 66 jmp 3f26 <ZSTD_decompressSequencesLong_bmi2+0x8c6>
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
3ec0: 48 8b bc f4 98 00 00 mov 0x98(%rsp,%rsi,8),%rdi
3ec7: 00
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
3ec8: 48 83 ff 01 cmp $0x1,%rdi
3ecc: 48 83 d7 00 adc $0x0,%rdi
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
3ed0: 48 83 fe 01 cmp $0x1,%rsi
3ed4: 4c 89 d9 mov %r11,%rcx
3ed7: 74 08 je 3ee1 <ZSTD_decompressSequencesLong_bmi2+0x881>
3ed9: 4c 89 a4 24 a8 00 00 mov %r12,0xa8(%rsp)
3ee0: 00
3ee1: 4d 89 cf mov %r9,%r15
3ee4: e9 50 fe ff ff jmpq 3d39 <ZSTD_decompressSequencesLong_bmi2+0x6d9>
bitD->ptr -= bitD->bitsConsumed >> 3;
3ee9: 89 c2 mov %eax,%edx
3eeb: c1 ea 03 shr $0x3,%edx
3eee: 49 29 d1 sub %rdx,%r9
3ef1: 48 8b b4 24 f0 00 00 mov 0xf0(%rsp),%rsi
3ef8: 00
3ef9: 4a 8d 14 0e lea (%rsi,%r9,1),%rdx
3efd: 48 89 54 24 50 mov %rdx,0x50(%rsp)
bitD->bitsConsumed &= 7;
3f02: 83 e0 07 and $0x7,%eax
3f05: 89 44 24 48 mov %eax,0x48(%rsp)
3f09: 4a 8b 2c 0e mov (%rsi,%r9,1),%rbp
bitD->bitContainer = MEM_readLEST(bitD->ptr);
3f0d: 48 89 6c 24 40 mov %rbp,0x40(%rsp)
3f12: 4c 89 4c 24 28 mov %r9,0x28(%rsp)
3f17: e9 c7 fe ff ff jmpq 3de3 <ZSTD_decompressSequencesLong_bmi2+0x783>
3f1c: 31 d2 xor %edx,%edx
3f1e: 48 89 54 24 28 mov %rdx,0x28(%rsp)
3f23: 45 31 c9 xor %r9d,%r9d
3f26: 4c 89 c7 mov %r8,%rdi
3f29: e9 b5 fe ff ff jmpq 3de3 <ZSTD_decompressSequencesLong_bmi2+0x783>
3f2e: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
3f33: 4c 8b 64 24 10 mov 0x10(%rsp),%r12
3f38: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
3f3d: eb 21 jmp 3f60 <ZSTD_decompressSequencesLong_bmi2+0x900>
3f3f: 4c 8b 54 24 08 mov 0x8(%rsp),%r10
3f44: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
3f49: 4c 8b 64 24 10 mov 0x10(%rsp),%r12
3f4e: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
3f55: 44 3b 54 24 3c cmp 0x3c(%rsp),%r10d
RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, "");
3f5a: 0f 8c ee 0c 00 00 jl 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
3f60: 48 8b 8c 24 f8 00 00 mov 0xf8(%rsp),%rcx
3f67: 00
3f68: 48 83 c1 e0 add $0xffffffffffffffe0,%rcx
3f6c: 48 89 8c 24 08 01 00 mov %rcx,0x108(%rsp)
3f73: 00
3f74: 48 8b 8c 24 c8 00 00 mov 0xc8(%rsp),%rcx
3f7b: 00
3f7c: 48 89 4c 24 18 mov %rcx,0x18(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
3f81: 83 f8 41 cmp $0x41,%eax
3f84: 0f 83 fc 07 00 00 jae 4786 <ZSTD_decompressSequencesLong_bmi2+0x1126>
3f8a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
if (bitD->ptr >= bitD->limitPtr) {
3f90: 4c 8b 44 24 50 mov 0x50(%rsp),%r8
3f95: 4c 8b 4c 24 60 mov 0x60(%rsp),%r9
3f9a: 4d 39 c8 cmp %r9,%r8
3f9d: 73 31 jae 3fd0 <ZSTD_decompressSequencesLong_bmi2+0x970>
if (bitD->ptr == bitD->start) {
3f9f: 48 8b 4c 24 58 mov 0x58(%rsp),%rcx
3fa4: 49 39 c8 cmp %rcx,%r8
3fa7: 74 43 je 3fec <ZSTD_decompressSequencesLong_bmi2+0x98c>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
3fa9: 89 c2 mov %eax,%edx
3fab: c1 ea 03 shr $0x3,%edx
if (bitD->ptr - nbBytes < bitD->start) {
3fae: 4c 89 c7 mov %r8,%rdi
3fb1: 48 29 d7 sub %rdx,%rdi
3fb4: 44 89 c6 mov %r8d,%esi
3fb7: 29 ce sub %ecx,%esi
3fb9: 48 39 cf cmp %rcx,%rdi
3fbc: 0f 43 f2 cmovae %edx,%esi
bitD->ptr -= nbBytes;
3fbf: 49 29 f0 sub %rsi,%r8
3fc2: 4c 89 44 24 50 mov %r8,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
3fc7: c1 e6 03 shl $0x3,%esi
3fca: 29 f0 sub %esi,%eax
3fcc: eb 12 jmp 3fe0 <ZSTD_decompressSequencesLong_bmi2+0x980>
3fce: 66 90 xchg %ax,%ax
bitD->ptr -= bitD->bitsConsumed >> 3;
3fd0: 89 c1 mov %eax,%ecx
3fd2: c1 e9 03 shr $0x3,%ecx
3fd5: 49 29 c8 sub %rcx,%r8
3fd8: 4c 89 44 24 50 mov %r8,0x50(%rsp)
bitD->bitsConsumed &= 7;
3fdd: 83 e0 07 and $0x7,%eax
3fe0: 89 44 24 48 mov %eax,0x48(%rsp)
3fe4: 49 8b 08 mov (%r8),%rcx
3fe7: 48 89 4c 24 40 mov %rcx,0x40(%rsp)
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
3fec: 45 39 fa cmp %r15d,%r10d
3fef: 0f 8d a1 07 00 00 jge 4796 <ZSTD_decompressSequencesLong_bmi2+0x1136>
3ff5: 4c 89 54 24 20 mov %r10,0x20(%rsp)
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
3ffa: 48 8b 4c 24 68 mov 0x68(%rsp),%rcx
3fff: 48 8b 74 24 70 mov 0x70(%rsp),%rsi
4004: 44 0f b7 3c ce movzwl (%rsi,%rcx,8),%r15d
4009: 0f b6 54 ce 02 movzbl 0x2(%rsi,%rcx,8),%edx
400e: 0f b6 6c ce 03 movzbl 0x3(%rsi,%rcx,8),%ebp
4013: 8b 4c ce 04 mov 0x4(%rsi,%rcx,8),%ecx
4017: 48 89 4c 24 08 mov %rcx,0x8(%rsp)
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
401c: 48 8b 8c 24 90 00 00 mov 0x90(%rsp),%rcx
4023: 00
4024: 48 8b b4 24 88 00 00 mov 0x88(%rsp),%rsi
402b: 00
402c: 44 0f b7 34 f1 movzwl (%rcx,%rsi,8),%r14d
4031: 0f b6 7c f1 02 movzbl 0x2(%rcx,%rsi,8),%edi
4036: 44 0f b6 64 f1 03 movzbl 0x3(%rcx,%rsi,8),%r12d
403c: 8b 4c f1 04 mov 0x4(%rcx,%rsi,8),%ecx
4040: 48 89 8c 24 e0 00 00 mov %rcx,0xe0(%rsp)
4047: 00
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
4048: 48 8b 8c 24 80 00 00 mov 0x80(%rsp),%rcx
404f: 00
4050: 48 8b 74 24 78 mov 0x78(%rsp),%rsi
4055: 44 0f b7 1c f1 movzwl (%rcx,%rsi,8),%r11d
405a: 0f b6 5c f1 02 movzbl 0x2(%rcx,%rsi,8),%ebx
405f: 48 89 54 24 30 mov %rdx,0x30(%rsp)
BYTE const totalBits = llBits+mlBits+ofBits;
4064: 44 8d 14 17 lea (%rdi,%rdx,1),%r10d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
4068: 0f b6 54 f1 03 movzbl 0x3(%rcx,%rsi,8),%edx
406d: 8b 4c f1 04 mov 0x4(%rcx,%rsi,8),%ecx
4071: 83 fb 02 cmp $0x2,%ebx
4074: 89 ac 24 d0 00 00 00 mov %ebp,0xd0(%rsp)
407b: 4c 89 8c 24 18 01 00 mov %r9,0x118(%rsp)
4082: 00
if (ofBits > 1) {
4083: 0f 82 c7 00 00 00 jb 4150 <ZSTD_decompressSequencesLong_bmi2+0xaf0>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
4089: c4 e2 f9 f7 74 24 40 shlx %rax,0x40(%rsp),%rsi
4090: 41 89 d9 mov %ebx,%r9d
4093: 41 f6 d9 neg %r9b
4096: c4 e2 b3 f7 f6 shrx %r9,%rsi,%rsi
bitD->bitsConsumed += nbBits;
409b: 01 d8 add %ebx,%eax
409d: 89 44 24 48 mov %eax,0x48(%rsp)
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
40a1: 48 01 ce add %rcx,%rsi
seqState->prevOffset[1] = seqState->prevOffset[0];
40a4: 0f 10 84 24 98 00 00 movups 0x98(%rsp),%xmm0
40ab: 00
40ac: 0f 11 84 24 a0 00 00 movups %xmm0,0xa0(%rsp)
40b3: 00
40b4: 48 89 b4 24 c0 00 00 mov %rsi,0xc0(%rsp)
40bb: 00
40bc: 48 89 b4 24 98 00 00 mov %rsi,0x98(%rsp)
40c3: 00
40c4: 41 00 da add %bl,%r10b
if (mlBits > 0)
40c7: 40 84 ff test %dil,%dil
40ca: 74 1f je 40eb <ZSTD_decompressSequencesLong_bmi2+0xa8b>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
40cc: c4 e2 f9 f7 4c 24 40 shlx %rax,0x40(%rsp),%rcx
40d3: 89 fe mov %edi,%esi
40d5: 40 f6 de neg %sil
40d8: c4 e2 cb f7 c9 shrx %rsi,%rcx,%rcx
bitD->bitsConsumed += nbBits;
40dd: 01 f8 add %edi,%eax
40df: 89 44 24 48 mov %eax,0x48(%rsp)
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
40e3: 48 01 8c 24 e0 00 00 add %rcx,0xe0(%rsp)
40ea: 00
40eb: 41 89 d1 mov %edx,%r9d
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
40ee: 41 80 fa 1f cmp $0x1f,%r10b
40f2: 0f 82 98 00 00 00 jb 4190 <ZSTD_decompressSequencesLong_bmi2+0xb30>
40f8: 83 f8 40 cmp $0x40,%eax
40fb: 48 8b 6c 24 30 mov 0x30(%rsp),%rbp
4100: 0f 87 8f 00 00 00 ja 4195 <ZSTD_decompressSequencesLong_bmi2+0xb35>
if (bitD->ptr >= bitD->limitPtr) {
4106: 4c 3b 84 24 18 01 00 cmp 0x118(%rsp),%r8
410d: 00
410e: 0f 83 40 05 00 00 jae 4654 <ZSTD_decompressSequencesLong_bmi2+0xff4>
if (bitD->ptr == bitD->start) {
4114: 48 8b 4c 24 58 mov 0x58(%rsp),%rcx
4119: 49 39 c8 cmp %rcx,%r8
411c: 74 77 je 4195 <ZSTD_decompressSequencesLong_bmi2+0xb35>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
411e: 89 c6 mov %eax,%esi
4120: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
4123: 4c 89 c7 mov %r8,%rdi
4126: 48 29 f7 sub %rsi,%rdi
4129: 44 89 c2 mov %r8d,%edx
412c: 29 ca sub %ecx,%edx
412e: 48 39 cf cmp %rcx,%rdi
4131: 0f 43 d6 cmovae %esi,%edx
bitD->ptr -= nbBytes;
4134: 49 29 d0 sub %rdx,%r8
4137: 4c 89 44 24 50 mov %r8,0x50(%rsp)
bitD->bitsConsumed -= nbBytes*8;
413c: c1 e2 03 shl $0x3,%edx
413f: 29 d0 sub %edx,%eax
4141: e9 1e 05 00 00 jmpq 4664 <ZSTD_decompressSequencesLong_bmi2+0x1004>
4146: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
414d: 00 00 00
if (LIKELY((ofBits == 0))) {
4150: 84 db test %bl,%bl
4152: 0f 85 b1 03 00 00 jne 4509 <ZSTD_decompressSequencesLong_bmi2+0xea9>
U32 const ll0 = (llBase == 0);
4158: 83 7c 24 08 00 cmpl $0x0,0x8(%rsp)
if (LIKELY(!ll0))
415d: 0f 84 ee 03 00 00 je 4551 <ZSTD_decompressSequencesLong_bmi2+0xef1>
offset = seqState->prevOffset[0];
4163: 48 8b 8c 24 98 00 00 mov 0x98(%rsp),%rcx
416a: 00
416b: 48 89 8c 24 c0 00 00 mov %rcx,0xc0(%rsp)
4172: 00
4173: 41 00 da add %bl,%r10b
if (mlBits > 0)
4176: 40 84 ff test %dil,%dil
4179: 0f 85 4d ff ff ff jne 40cc <ZSTD_decompressSequencesLong_bmi2+0xa6c>
417f: e9 67 ff ff ff jmpq 40eb <ZSTD_decompressSequencesLong_bmi2+0xa8b>
4184: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
418b: 00 00 00
418e: 66 90 xchg %ax,%ax
4190: 48 8b 6c 24 30 mov 0x30(%rsp),%rbp
4195: 48 8b 74 24 40 mov 0x40(%rsp),%rsi
if (llBits > 0)
419a: 40 84 ed test %bpl,%bpl
419d: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi
41a2: 74 19 je 41bd <ZSTD_decompressSequencesLong_bmi2+0xb5d>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
41a4: c4 e2 f9 f7 ce shlx %rax,%rsi,%rcx
41a9: 89 ea mov %ebp,%edx
41ab: f6 da neg %dl
41ad: c4 e2 eb f7 c9 shrx %rdx,%rcx,%rcx
bitD->bitsConsumed += nbBits;
41b2: 01 e8 add %ebp,%eax
41b4: 89 44 24 48 mov %eax,0x48(%rsp)
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
41b8: 48 01 4c 24 08 add %rcx,0x8(%rsp)
41bd: 8b 94 24 d0 00 00 00 mov 0xd0(%rsp),%edx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
41c4: 01 d0 add %edx,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
41c6: 89 c1 mov %eax,%ecx
41c8: f6 d9 neg %cl
41ca: c4 e2 f3 f7 ce shrx %rcx,%rsi,%rcx
41cf: 89 d2 mov %edx,%edx
41d1: 23 0c 95 00 00 00 00 and 0x0(,%rdx,4),%ecx
DStatePtr->state = DInfo.nextState + lowBits;
41d8: 4c 01 f9 add %r15,%rcx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
41db: 44 01 e0 add %r12d,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
41de: 89 c2 mov %eax,%edx
41e0: f6 da neg %dl
41e2: c4 e2 eb f7 d6 shrx %rdx,%rsi,%rdx
41e7: 44 89 e5 mov %r12d,%ebp
41ea: 23 14 ad 00 00 00 00 and 0x0(,%rbp,4),%edx
41f1: 48 89 4c 24 68 mov %rcx,0x68(%rsp)
41f6: 4c 01 f2 add %r14,%rdx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
41f9: 44 01 c8 add %r9d,%eax
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
41fc: 89 c1 mov %eax,%ecx
41fe: f6 d9 neg %cl
4200: c4 e2 f3 f7 ce shrx %rcx,%rsi,%rcx
4205: 44 89 ce mov %r9d,%esi
4208: 23 0c b5 00 00 00 00 and 0x0(,%rsi,4),%ecx
420f: 48 89 94 24 88 00 00 mov %rdx,0x88(%rsp)
4216: 00
4217: 4c 01 d9 add %r11,%rcx
bitD->bitsConsumed += nbBits;
421a: 89 44 24 48 mov %eax,0x48(%rsp)
421e: 48 89 4c 24 78 mov %rcx,0x78(%rsp)
4223: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litEnd, prefixStart, dictStart, dictEnd);
4228: 44 89 d0 mov %r10d,%eax
422b: 83 e0 07 and $0x7,%eax
422e: 4c 8d 04 40 lea (%rax,%rax,2),%r8
4232: 4a 8b 94 c4 50 01 00 mov 0x150(%rsp,%r8,8),%rdx
4239: 00
423a: 4a 8b 9c c4 58 01 00 mov 0x158(%rsp,%r8,8),%rbx
4241: 00
4242: 4a 8b ac c4 60 01 00 mov 0x160(%rsp,%r8,8),%rbp
4249: 00
const BYTE* const iLitEnd = *litPtr + sequence.litLength;
424a: 48 8b 8c 24 d8 00 00 mov 0xd8(%rsp),%rcx
4251: 00
4252: 48 8d 04 11 lea (%rcx,%rdx,1),%rax
if (UNLIKELY(
4256: 48 3b 84 24 b8 00 00 cmp 0xb8(%rsp),%rax
425d: 00
425e: 0f 87 c0 01 00 00 ja 4424 <ZSTD_decompressSequencesLong_bmi2+0xdc4>
4264: 4c 8d 1c 13 lea (%rbx,%rdx,1),%r11
4268: 4a 8d 34 1f lea (%rdi,%r11,1),%rsi
426c: 48 3b b4 24 08 01 00 cmp 0x108(%rsp),%rsi
4273: 00
4274: 0f 87 aa 01 00 00 ja 4424 <ZSTD_decompressSequencesLong_bmi2+0xdc4>
427a: 4c 8d 34 17 lea (%rdi,%rdx,1),%r14
427e: 4d 89 f7 mov %r14,%r15
4281: 49 29 ef sub %rbp,%r15
ZSTD_memcpy(dst, src, 16);
4284: 0f 10 01 movups (%rcx),%xmm0
4287: 0f 11 07 movups %xmm0,(%rdi)
if (UNLIKELY(sequence.litLength > 16)) {
428a: 48 83 fa 11 cmp $0x11,%rdx
428e: 0f 83 e5 01 00 00 jae 4479 <ZSTD_decompressSequencesLong_bmi2+0xe19>
*litPtr = iLitEnd; /* update for next sequence */
4294: 48 89 84 24 d8 00 00 mov %rax,0xd8(%rsp)
429b: 00
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
429c: 4c 89 f0 mov %r14,%rax
429f: 4c 8b 64 24 10 mov 0x10(%rsp),%r12
42a4: 4c 29 e0 sub %r12,%rax
42a7: 48 39 e8 cmp %rbp,%rax
42aa: 73 74 jae 4320 <ZSTD_decompressSequencesLong_bmi2+0xcc0>
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
42ac: 4c 89 f0 mov %r14,%rax
42af: 48 2b 84 24 00 01 00 sub 0x100(%rsp),%rax
42b6: 00
42b7: 48 39 e8 cmp %rbp,%rax
42ba: 0f 82 a3 09 00 00 jb 4c63 <ZSTD_decompressSequencesLong_bmi2+0x1603>
42c0: 4c 89 44 24 30 mov %r8,0x30(%rsp)
42c5: 4c 89 ac 24 d0 00 00 mov %r13,0xd0(%rsp)
42cc: 00
42cd: 4d 89 dd mov %r11,%r13
match = dictEnd + (match - prefixStart);
42d0: 4d 29 e7 sub %r12,%r15
42d3: 48 8b 8c 24 e8 00 00 mov 0xe8(%rsp),%rcx
42da: 00
42db: 4a 8d 34 39 lea (%rcx,%r15,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
42df: 48 8d 04 1e lea (%rsi,%rbx,1),%rax
42e3: 48 39 c8 cmp %rcx,%rax
42e6: 0f 86 94 00 00 00 jbe 4380 <ZSTD_decompressSequencesLong_bmi2+0xd20>
{ size_t const length1 = dictEnd - match;
42ec: 4c 89 fa mov %r15,%rdx
42ef: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
42f2: 4c 89 f7 mov %r14,%rdi
42f5: e8 00 00 00 00 callq 42fa <ZSTD_decompressSequencesLong_bmi2+0xc9a>
op = oLitEnd + length1;
42fa: 4d 29 fe sub %r15,%r14
sequence.matchLength -= length1;
42fd: 4c 01 fb add %r15,%rbx
4300: 4d 89 e7 mov %r12,%r15
4303: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
4308: 4d 89 eb mov %r13,%r11
430b: 4c 8b ac 24 d0 00 00 mov 0xd0(%rsp),%r13
4312: 00
4313: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
4318: 4c 8b 44 24 30 mov 0x30(%rsp),%r8
431d: eb 06 jmp 4325 <ZSTD_decompressSequencesLong_bmi2+0xcc5>
431f: 90 nop
4320: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
4325: 48 83 fd 10 cmp $0x10,%rbp
4329: 0f 82 92 01 00 00 jb 44c1 <ZSTD_decompressSequencesLong_bmi2+0xe61>
432f: 41 0f 10 07 movups (%r15),%xmm0
4333: 41 0f 11 06 movups %xmm0,(%r14)
if (16 >= length) return;
4337: 48 83 fb 11 cmp $0x11,%rbx
433b: 7c 3a jl 4377 <ZSTD_decompressSequencesLong_bmi2+0xd17>
433d: 4c 01 f3 add %r14,%rbx
do {
4340: 49 83 c7 10 add $0x10,%r15
4344: b8 10 00 00 00 mov $0x10,%eax
4349: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
ZSTD_memcpy(dst, src, 16);
4350: 41 0f 10 44 07 f0 movups -0x10(%r15,%rax,1),%xmm0
4356: 41 0f 11 04 06 movups %xmm0,(%r14,%rax,1)
435b: 41 0f 10 04 07 movups (%r15,%rax,1),%xmm0
4360: 41 0f 11 44 06 10 movups %xmm0,0x10(%r14,%rax,1)
while (op < oend);
4366: 49 8d 0c 06 lea (%r14,%rax,1),%rcx
436a: 48 83 c1 20 add $0x20,%rcx
436e: 48 83 c0 20 add $0x20,%rax
4372: 48 39 d9 cmp %rbx,%rcx
}
4375: 72 d9 jb 4350 <ZSTD_decompressSequencesLong_bmi2+0xcf0>
4377: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
437c: eb 2c jmp 43aa <ZSTD_decompressSequencesLong_bmi2+0xd4a>
437e: 66 90 xchg %ax,%ax
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
4380: 4c 89 f7 mov %r14,%rdi
4383: 48 89 da mov %rbx,%rdx
4386: e8 00 00 00 00 callq 438b <ZSTD_decompressSequencesLong_bmi2+0xd2b>
438b: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
4390: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
4395: 4d 89 eb mov %r13,%r11
4398: 4c 8b ac 24 d0 00 00 mov 0xd0(%rsp),%r13
439f: 00
43a0: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
43a5: 4c 8b 44 24 30 mov 0x30(%rsp),%r8
43aa: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
43ae: 0f 87 9a 08 00 00 ja 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
prefetchPos += sequence.litLength;
43b4: 49 01 d5 add %rdx,%r13
43b7: 48 8b b4 24 c0 00 00 mov 0xc0(%rsp),%rsi
43be: 00
{ const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;
43bf: 49 39 f5 cmp %rsi,%r13
43c2: 4c 8b 64 24 10 mov 0x10(%rsp),%r12
43c7: 4c 89 e0 mov %r12,%rax
43ca: 48 0f 42 84 24 e8 00 cmovb 0xe8(%rsp),%rax
43d1: 00 00
43d3: 4a 8d 0c c4 lea (%rsp,%r8,8),%rcx
43d7: 48 81 c1 50 01 00 00 add $0x150,%rcx
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.
43de: 4c 01 e8 add %r13,%rax
43e1: 48 29 f0 sub %rsi,%rax
PREFETCH_L1(match); PREFETCH_L1(match+CACHELINE_SIZE); /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */
43e4: 0f 18 08 prefetcht0 (%rax)
43e7: 0f 18 48 40 prefetcht0 0x40(%rax)
43eb: 48 8b 84 24 e0 00 00 mov 0xe0(%rsp),%rax
43f2: 00
return prefetchPos + sequence.matchLength;
43f3: 49 01 c5 add %rax,%r13
sequences[seqNb & STORED_SEQS_MASK] = sequence;
43f6: 48 89 11 mov %rdx,(%rcx)
43f9: 48 89 41 08 mov %rax,0x8(%rcx)
43fd: 48 89 71 10 mov %rsi,0x10(%rcx)
4401: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
op += oneSeqSize;
4406: 4c 01 d9 add %r11,%rcx
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
4409: 41 83 c2 01 add $0x1,%r10d
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
440d: 8b 44 24 48 mov 0x48(%rsp),%eax
4411: 48 89 4c 24 18 mov %rcx,0x18(%rsp)
4416: 83 f8 41 cmp $0x41,%eax
4419: 0f 82 71 fb ff ff jb 3f90 <ZSTD_decompressSequencesLong_bmi2+0x930>
441f: e9 62 03 00 00 jmpq 4786 <ZSTD_decompressSequencesLong_bmi2+0x1126>
4424: 48 8b b4 24 f8 00 00 mov 0xf8(%rsp),%rsi
442b: 00
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
442c: 48 89 d9 mov %rbx,%rcx
442f: 4c 89 c3 mov %r8,%rbx
4432: 49 89 e8 mov %rbp,%r8
4435: 4c 8d 8c 24 d8 00 00 lea 0xd8(%rsp),%r9
443c: 00
443d: ff b4 24 e8 00 00 00 pushq 0xe8(%rsp)
4444: ff b4 24 08 01 00 00 pushq 0x108(%rsp)
444b: ff 74 24 20 pushq 0x20(%rsp)
444f: ff b4 24 d0 00 00 00 pushq 0xd0(%rsp)
4456: e8 25 08 00 00 callq 4c80 <ZSTD_execSequenceEnd>
445b: 49 89 d8 mov %rbx,%r8
445e: 4c 8b 54 24 40 mov 0x40(%rsp),%r10
4463: 48 83 c4 20 add $0x20,%rsp
4467: 49 89 c3 mov %rax,%r11
446a: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
446f: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
4474: e9 31 ff ff ff jmpq 43aa <ZSTD_decompressSequencesLong_bmi2+0xd4a>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
4479: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
447d: 0f 10 41 10 movups 0x10(%rcx),%xmm0
4481: 0f 11 47 10 movups %xmm0,0x10(%rdi)
if (16 >= length) return;
4485: 48 83 fa 11 cmp $0x11,%rdx
4489: 0f 8c 05 fe ff ff jl 4294 <ZSTD_decompressSequencesLong_bmi2+0xc34>
op += 16;
448f: 48 8d 57 20 lea 0x20(%rdi),%rdx
do {
4493: 48 83 c1 30 add $0x30,%rcx
4497: 31 f6 xor %esi,%esi
ZSTD_memcpy(dst, src, 16);
4499: 0f 10 44 31 f0 movups -0x10(%rcx,%rsi,1),%xmm0
449e: 0f 11 04 32 movups %xmm0,(%rdx,%rsi,1)
44a2: 0f 10 04 31 movups (%rcx,%rsi,1),%xmm0
44a6: 0f 11 44 32 10 movups %xmm0,0x10(%rdx,%rsi,1)
while (op < oend);
44ab: 48 8d 3c 32 lea (%rdx,%rsi,1),%rdi
44af: 48 83 c7 20 add $0x20,%rdi
44b3: 48 83 c6 20 add $0x20,%rsi
44b7: 4c 39 f7 cmp %r14,%rdi
}
44ba: 72 dd jb 4499 <ZSTD_decompressSequencesLong_bmi2+0xe39>
44bc: e9 d3 fd ff ff jmpq 4294 <ZSTD_decompressSequencesLong_bmi2+0xc34>
if (offset < 8) {
44c1: 48 83 fd 07 cmp $0x7,%rbp
44c5: 0f 87 a3 00 00 00 ja 456e <ZSTD_decompressSequencesLong_bmi2+0xf0e>
int const sub2 = dec64table[offset];
44cb: 48 63 04 ad 00 00 00 movslq 0x0(,%rbp,4),%rax
44d2: 00
(*op)[0] = (*ip)[0];
44d3: 41 8a 0f mov (%r15),%cl
44d6: 41 88 0e mov %cl,(%r14)
(*op)[1] = (*ip)[1];
44d9: 41 8a 4f 01 mov 0x1(%r15),%cl
44dd: 41 88 4e 01 mov %cl,0x1(%r14)
(*op)[2] = (*ip)[2];
44e1: 41 8a 4f 02 mov 0x2(%r15),%cl
44e5: 41 88 4e 02 mov %cl,0x2(%r14)
(*op)[3] = (*ip)[3];
44e9: 41 8a 4f 03 mov 0x3(%r15),%cl
44ed: 41 88 4e 03 mov %cl,0x3(%r14)
*ip += dec32table[offset];
44f1: 8b 0c ad 00 00 00 00 mov 0x0(,%rbp,4),%ecx
44f8: 49 8d 34 0f lea (%r15,%rcx,1),%rsi
*ip -= sub2;
44fc: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
44ff: 41 8b 04 0f mov (%r15,%rcx,1),%eax
4503: 41 89 46 04 mov %eax,0x4(%r14)
4507: eb 6e jmp 4577 <ZSTD_decompressSequencesLong_bmi2+0xf17>
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
4509: 83 7c 24 08 01 cmpl $0x1,0x8(%rsp)
450e: 83 d1 00 adc $0x0,%ecx
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
4511: c4 e2 f9 f7 74 24 40 shlx %rax,0x40(%rsp),%rsi
4518: 48 c1 ee 3f shr $0x3f,%rsi
bitD->bitsConsumed += nbBits;
451c: 83 c0 01 add $0x1,%eax
451f: 89 44 24 48 mov %eax,0x48(%rsp)
4523: 48 01 ce add %rcx,%rsi
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
4526: 48 83 fe 03 cmp $0x3,%rsi
452a: 0f 85 58 01 00 00 jne 4688 <ZSTD_decompressSequencesLong_bmi2+0x1028>
4530: 48 8b 8c 24 98 00 00 mov 0x98(%rsp),%rcx
4537: 00
4538: 48 83 c1 ff add $0xffffffffffffffff,%rcx
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
453c: 48 83 f9 01 cmp $0x1,%rcx
4540: 48 83 d1 00 adc $0x0,%rcx
4544: 48 89 8c 24 c0 00 00 mov %rcx,0xc0(%rsp)
454b: 00
454c: e9 55 01 00 00 jmpq 46a6 <ZSTD_decompressSequencesLong_bmi2+0x1046>
seqState->prevOffset[1] = seqState->prevOffset[0];
4551: 48 8b 8c 24 98 00 00 mov 0x98(%rsp),%rcx
4558: 00
offset = seqState->prevOffset[1];
4559: 48 8b b4 24 a0 00 00 mov 0xa0(%rsp),%rsi
4560: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
4561: 48 89 8c 24 a0 00 00 mov %rcx,0xa0(%rsp)
4568: 00
4569: e9 46 fb ff ff jmpq 40b4 <ZSTD_decompressSequencesLong_bmi2+0xa54>
ZSTD_memcpy(dst, src, 8);
456e: 49 8b 07 mov (%r15),%rax
4571: 49 89 06 mov %rax,(%r14)
*ip += 8;
4574: 4c 89 fe mov %r15,%rsi
if (sequence.matchLength > 8) {
4577: 48 83 fb 09 cmp $0x9,%rbx
457b: 0f 82 f6 fd ff ff jb 4377 <ZSTD_decompressSequencesLong_bmi2+0xd17>
4581: 48 8d 4e 08 lea 0x8(%rsi),%rcx
4585: 49 8d 56 08 lea 0x8(%r14),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
4589: 48 89 d7 mov %rdx,%rdi
458c: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
458f: 49 8d 04 1e lea (%r14,%rbx,1),%rax
4593: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
4597: 0f 8f 4a 01 00 00 jg 46e7 <ZSTD_decompressSequencesLong_bmi2+0x1087>
459d: 4d 89 c4 mov %r8,%r12
do {
45a0: 49 8d 7e 10 lea 0x10(%r14),%rdi
45a4: 48 39 f8 cmp %rdi,%rax
45a7: 48 89 fb mov %rdi,%rbx
45aa: 48 0f 47 d8 cmova %rax,%rbx
45ae: 4c 29 f3 sub %r14,%rbx
45b1: 48 83 c3 f7 add $0xfffffffffffffff7,%rbx
45b5: 48 83 fb 18 cmp $0x18,%rbx
45b9: 0f 82 9d 01 00 00 jb 475c <ZSTD_decompressSequencesLong_bmi2+0x10fc>
45bf: 48 39 f8 cmp %rdi,%rax
45c2: 48 0f 47 f8 cmova %rax,%rdi
45c6: 4c 29 f7 sub %r14,%rdi
45c9: 48 83 c7 07 add $0x7,%rdi
45cd: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
45d1: 48 8d 2c 3e lea (%rsi,%rdi,1),%rbp
45d5: 48 39 ea cmp %rbp,%rdx
45d8: 73 0c jae 45e6 <ZSTD_decompressSequencesLong_bmi2+0xf86>
45da: 4c 01 f7 add %r14,%rdi
45dd: 48 39 f9 cmp %rdi,%rcx
45e0: 0f 82 76 01 00 00 jb 475c <ZSTD_decompressSequencesLong_bmi2+0x10fc>
45e6: 48 c1 eb 03 shr $0x3,%rbx
45ea: 48 83 c3 01 add $0x1,%rbx
45ee: 49 89 d8 mov %rbx,%r8
45f1: 49 83 e0 fc and $0xfffffffffffffffc,%r8
45f5: 49 8d 78 fc lea -0x4(%r8),%rdi
45f9: 49 89 f9 mov %rdi,%r9
45fc: 49 c1 e9 02 shr $0x2,%r9
4600: 49 83 c1 01 add $0x1,%r9
4604: 48 85 ff test %rdi,%rdi
4607: 0f 84 28 01 00 00 je 4735 <ZSTD_decompressSequencesLong_bmi2+0x10d5>
460d: 4c 89 cf mov %r9,%rdi
4610: 48 83 e7 fe and $0xfffffffffffffffe,%rdi
4614: 48 f7 df neg %rdi
4617: 31 ed xor %ebp,%ebp
ZSTD_memcpy(dst, src, 8);
4619: 0f 10 44 ee 08 movups 0x8(%rsi,%rbp,8),%xmm0
461e: 0f 10 4c ee 18 movups 0x18(%rsi,%rbp,8),%xmm1
4623: 41 0f 11 44 ee 08 movups %xmm0,0x8(%r14,%rbp,8)
4629: 41 0f 11 4c ee 18 movups %xmm1,0x18(%r14,%rbp,8)
462f: 0f 10 44 ee 28 movups 0x28(%rsi,%rbp,8),%xmm0
4634: 0f 10 4c ee 38 movups 0x38(%rsi,%rbp,8),%xmm1
4639: 41 0f 11 44 ee 28 movups %xmm0,0x28(%r14,%rbp,8)
463f: 41 0f 11 4c ee 38 movups %xmm1,0x38(%r14,%rbp,8)
4645: 48 83 c5 08 add $0x8,%rbp
4649: 48 83 c7 02 add $0x2,%rdi
464d: 75 ca jne 4619 <ZSTD_decompressSequencesLong_bmi2+0xfb9>
464f: e9 e3 00 00 00 jmpq 4737 <ZSTD_decompressSequencesLong_bmi2+0x10d7>
bitD->ptr -= bitD->bitsConsumed >> 3;
4654: 89 c1 mov %eax,%ecx
4656: c1 e9 03 shr $0x3,%ecx
4659: 49 29 c8 sub %rcx,%r8
465c: 4c 89 44 24 50 mov %r8,0x50(%rsp)
bitD->bitsConsumed &= 7;
4661: 83 e0 07 and $0x7,%eax
4664: 89 44 24 48 mov %eax,0x48(%rsp)
4668: 49 8b 08 mov (%r8),%rcx
466b: 48 89 4c 24 40 mov %rcx,0x40(%rsp)
4670: 48 8b 74 24 40 mov 0x40(%rsp),%rsi
if (llBits > 0)
4675: 40 84 ed test %bpl,%bpl
4678: 48 8b 7c 24 18 mov 0x18(%rsp),%rdi
467d: 0f 85 21 fb ff ff jne 41a4 <ZSTD_decompressSequencesLong_bmi2+0xb44>
4683: e9 35 fb ff ff jmpq 41bd <ZSTD_decompressSequencesLong_bmi2+0xb5d>
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
4688: 48 8b 8c f4 98 00 00 mov 0x98(%rsp,%rsi,8),%rcx
468f: 00
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
4690: 48 83 f9 01 cmp $0x1,%rcx
4694: 48 83 d1 00 adc $0x0,%rcx
4698: 48 89 8c 24 c0 00 00 mov %rcx,0xc0(%rsp)
469f: 00
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
46a0: 48 83 fe 01 cmp $0x1,%rsi
46a4: 74 10 je 46b6 <ZSTD_decompressSequencesLong_bmi2+0x1056>
46a6: 48 8b 8c 24 a0 00 00 mov 0xa0(%rsp),%rcx
46ad: 00
46ae: 48 89 8c 24 a8 00 00 mov %rcx,0xa8(%rsp)
46b5: 00
seqState->prevOffset[1] = seqState->prevOffset[0];
46b6: 48 8b 8c 24 98 00 00 mov 0x98(%rsp),%rcx
46bd: 00
46be: 48 89 8c 24 a0 00 00 mov %rcx,0xa0(%rsp)
46c5: 00
46c6: 48 8b 8c 24 c0 00 00 mov 0xc0(%rsp),%rcx
46cd: 00
seqState->prevOffset[0] = offset = temp;
46ce: 48 89 8c 24 98 00 00 mov %rcx,0x98(%rsp)
46d5: 00
46d6: 41 00 da add %bl,%r10b
if (mlBits > 0)
46d9: 40 84 ff test %dil,%dil
46dc: 0f 85 ea f9 ff ff jne 40cc <ZSTD_decompressSequencesLong_bmi2+0xa6c>
46e2: e9 04 fa ff ff jmpq 40eb <ZSTD_decompressSequencesLong_bmi2+0xa8b>
ZSTD_memcpy(dst, src, 16);
46e7: 0f 10 01 movups (%rcx),%xmm0
46ea: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
46ed: 48 83 fb 19 cmp $0x19,%rbx
46f1: 0f 8c 73 fd ff ff jl 446a <ZSTD_decompressSequencesLong_bmi2+0xe0a>
op += 16;
46f7: 49 83 c6 18 add $0x18,%r14
do {
46fb: 48 83 c6 28 add $0x28,%rsi
46ff: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
4701: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
4706: 41 0f 11 04 0e movups %xmm0,(%r14,%rcx,1)
470b: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
470f: 41 0f 11 44 0e 10 movups %xmm0,0x10(%r14,%rcx,1)
while (op < oend);
4715: 49 8d 14 0e lea (%r14,%rcx,1),%rdx
4719: 48 83 c2 20 add $0x20,%rdx
471d: 48 83 c1 20 add $0x20,%rcx
4721: 48 39 c2 cmp %rax,%rdx
}
4724: 72 db jb 4701 <ZSTD_decompressSequencesLong_bmi2+0x10a1>
4726: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
472b: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
4730: e9 3a fd ff ff jmpq 446f <ZSTD_decompressSequencesLong_bmi2+0xe0f>
4735: 31 ed xor %ebp,%ebp
4737: 41 f6 c1 01 test $0x1,%r9b
473b: 74 12 je 474f <ZSTD_decompressSequencesLong_bmi2+0x10ef>
ZSTD_memcpy(dst, src, 8);
473d: 0f 10 04 e9 movups (%rcx,%rbp,8),%xmm0
4741: 0f 10 4c e9 10 movups 0x10(%rcx,%rbp,8),%xmm1
4746: 0f 11 04 ea movups %xmm0,(%rdx,%rbp,8)
474a: 0f 11 4c ea 10 movups %xmm1,0x10(%rdx,%rbp,8)
} while (op < oend);
474f: 4c 39 c3 cmp %r8,%rbx
4752: 74 1b je 476f <ZSTD_decompressSequencesLong_bmi2+0x110f>
4754: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
4758: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
ZSTD_memcpy(dst, src, 8);
475c: 48 8b 31 mov (%rcx),%rsi
475f: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
4762: 48 83 c2 08 add $0x8,%rdx
4766: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
476a: 48 39 c2 cmp %rax,%rdx
476d: 72 ed jb 475c <ZSTD_decompressSequencesLong_bmi2+0x10fc>
476f: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
4774: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
4779: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
477e: 4d 89 e0 mov %r12,%r8
4781: e9 24 fc ff ff jmpq 43aa <ZSTD_decompressSequencesLong_bmi2+0xd4a>
4786: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
478d: 45 39 fa cmp %r15d,%r10d
RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, "");
4790: 0f 8c b8 04 00 00 jl 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
seqNb -= seqAdvance;
4796: 44 2b 54 24 3c sub 0x3c(%rsp),%r10d
for ( ; seqNb<nbSeq ; seqNb++) {
479b: 45 39 fa cmp %r15d,%r10d
479e: 0f 8d 23 04 00 00 jge 4bc7 <ZSTD_decompressSequencesLong_bmi2+0x1567>
47a4: 4c 89 e7 mov %r12,%rdi
47a7: 4c 8b ac 24 c8 00 00 mov 0xc8(%rsp),%r13
47ae: 00
47af: 4c 8b a4 24 b8 00 00 mov 0xb8(%rsp),%r12
47b6: 00
47b7: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
47bc: 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);
47c0: 44 89 d0 mov %r10d,%eax
47c3: 83 e0 07 and $0x7,%eax
47c6: 48 8d 04 40 lea (%rax,%rax,2),%rax
47ca: 48 8b 94 c4 50 01 00 mov 0x150(%rsp,%rax,8),%rdx
47d1: 00
47d2: 4c 8b b4 c4 58 01 00 mov 0x158(%rsp,%rax,8),%r14
47d9: 00
47da: 4c 8b 84 c4 60 01 00 mov 0x160(%rsp,%rax,8),%r8
47e1: 00
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
47e2: 4d 8d 1c 16 lea (%r14,%rdx,1),%r11
47e6: 4a 8d 04 19 lea (%rcx,%r11,1),%rax
47ea: 48 3b 84 24 08 01 00 cmp 0x108(%rsp),%rax
47f1: 00
47f2: 48 89 4c 24 18 mov %rcx,0x18(%rsp)
if (UNLIKELY(
47f7: 0f 87 5d 01 00 00 ja 495a <ZSTD_decompressSequencesLong_bmi2+0x12fa>
47fd: 4c 8b 8c 24 d8 00 00 mov 0xd8(%rsp),%r9
4804: 00
4805: 49 8d 04 11 lea (%r9,%rdx,1),%rax
4809: 4c 39 e0 cmp %r12,%rax
480c: 0f 87 48 01 00 00 ja 495a <ZSTD_decompressSequencesLong_bmi2+0x12fa>
4812: 48 8d 2c 11 lea (%rcx,%rdx,1),%rbp
4816: 48 89 eb mov %rbp,%rbx
4819: 4c 29 c3 sub %r8,%rbx
ZSTD_memcpy(dst, src, 16);
481c: 41 0f 10 01 movups (%r9),%xmm0
4820: 0f 11 01 movups %xmm0,(%rcx)
if (UNLIKELY(sequence.litLength > 16)) {
4823: 48 83 fa 11 cmp $0x11,%rdx
4827: 4c 89 c6 mov %r8,%rsi
482a: 0f 83 76 01 00 00 jae 49a6 <ZSTD_decompressSequencesLong_bmi2+0x1346>
*litPtr = iLitEnd; /* update for next sequence */
4830: 48 89 84 24 d8 00 00 mov %rax,0xd8(%rsp)
4837: 00
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
4838: 48 89 e8 mov %rbp,%rax
483b: 48 29 f8 sub %rdi,%rax
483e: 48 39 f0 cmp %rsi,%rax
4841: 49 89 f0 mov %rsi,%r8
4844: 73 6c jae 48b2 <ZSTD_decompressSequencesLong_bmi2+0x1252>
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
4846: 48 89 e8 mov %rbp,%rax
4849: 48 2b 84 24 00 01 00 sub 0x100(%rsp),%rax
4850: 00
4851: 4c 39 c0 cmp %r8,%rax
4854: 0f 82 09 04 00 00 jb 4c63 <ZSTD_decompressSequencesLong_bmi2+0x1603>
485a: 4d 89 ef mov %r13,%r15
485d: 4d 89 dd mov %r11,%r13
4860: 4c 89 54 24 20 mov %r10,0x20(%rsp)
match = dictEnd + (match - prefixStart);
4865: 48 29 fb sub %rdi,%rbx
4868: 48 8b 8c 24 e8 00 00 mov 0xe8(%rsp),%rcx
486f: 00
4870: 48 8d 34 19 lea (%rcx,%rbx,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
4874: 4a 8d 04 36 lea (%rsi,%r14,1),%rax
4878: 48 39 c8 cmp %rcx,%rax
487b: 0f 86 93 00 00 00 jbe 4914 <ZSTD_decompressSequencesLong_bmi2+0x12b4>
{ size_t const length1 = dictEnd - match;
4881: 48 89 da mov %rbx,%rdx
4884: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
4887: 48 89 ef mov %rbp,%rdi
488a: 4c 89 44 24 08 mov %r8,0x8(%rsp)
488f: e8 00 00 00 00 callq 4894 <ZSTD_decompressSequencesLong_bmi2+0x1234>
4894: 4c 8b 44 24 08 mov 0x8(%rsp),%r8
op = oLitEnd + length1;
4899: 48 29 dd sub %rbx,%rbp
sequence.matchLength -= length1;
489c: 49 01 de add %rbx,%r14
489f: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi
48a4: 48 89 fb mov %rdi,%rbx
48a7: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
48ac: 4d 89 eb mov %r13,%r11
48af: 4d 89 fd mov %r15,%r13
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
48b2: 49 83 f8 10 cmp $0x10,%r8
48b6: 0f 82 41 01 00 00 jb 49fd <ZSTD_decompressSequencesLong_bmi2+0x139d>
48bc: 0f 10 03 movups (%rbx),%xmm0
48bf: 0f 11 45 00 movups %xmm0,0x0(%rbp)
if (16 >= length) return;
48c3: 49 83 fe 11 cmp $0x11,%r14
48c7: 7c 3b jl 4904 <ZSTD_decompressSequencesLong_bmi2+0x12a4>
48c9: 49 01 ee add %rbp,%r14
do {
48cc: 48 83 c3 10 add $0x10,%rbx
48d0: b8 10 00 00 00 mov $0x10,%eax
48d5: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
48dc: 00 00 00
48df: 90 nop
ZSTD_memcpy(dst, src, 16);
48e0: 0f 10 44 03 f0 movups -0x10(%rbx,%rax,1),%xmm0
48e5: 0f 11 44 05 00 movups %xmm0,0x0(%rbp,%rax,1)
48ea: 0f 10 04 03 movups (%rbx,%rax,1),%xmm0
48ee: 0f 11 44 05 10 movups %xmm0,0x10(%rbp,%rax,1)
while (op < oend);
48f3: 48 8d 0c 28 lea (%rax,%rbp,1),%rcx
48f7: 48 83 c1 20 add $0x20,%rcx
48fb: 48 83 c0 20 add $0x20,%rax
48ff: 4c 39 f1 cmp %r14,%rcx
}
4902: 72 dc jb 48e0 <ZSTD_decompressSequencesLong_bmi2+0x1280>
4904: 44 8b 7c 24 04 mov 0x4(%rsp),%r15d
4909: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
490d: 76 31 jbe 4940 <ZSTD_decompressSequencesLong_bmi2+0x12e0>
490f: e9 3a 03 00 00 jmpq 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
4914: 48 89 ef mov %rbp,%rdi
4917: 4c 89 f2 mov %r14,%rdx
491a: e8 00 00 00 00 callq 491f <ZSTD_decompressSequencesLong_bmi2+0x12bf>
491f: 8b 44 24 04 mov 0x4(%rsp),%eax
4923: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi
4928: 4c 8b 54 24 20 mov 0x20(%rsp),%r10
492d: 4d 89 eb mov %r13,%r11
4930: 4d 89 fd mov %r15,%r13
4933: 41 89 c7 mov %eax,%r15d
4936: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
493a: 0f 87 0e 03 00 00 ja 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
4940: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
4945: 4c 01 d9 add %r11,%rcx
for ( ; seqNb<nbSeq ; seqNb++) {
4948: 41 83 c2 01 add $0x1,%r10d
494c: 45 39 fa cmp %r15d,%r10d
494f: 0f 85 6b fe ff ff jne 47c0 <ZSTD_decompressSequencesLong_bmi2+0x1160>
4955: e9 82 02 00 00 jmpq 4bdc <ZSTD_decompressSequencesLong_bmi2+0x157c>
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
495a: 48 89 cf mov %rcx,%rdi
495d: 48 8b b4 24 f8 00 00 mov 0xf8(%rsp),%rsi
4964: 00
4965: 4c 89 f1 mov %r14,%rcx
4968: 4c 8d 8c 24 d8 00 00 lea 0xd8(%rsp),%r9
496f: 00
4970: ff b4 24 e8 00 00 00 pushq 0xe8(%rsp)
4977: ff b4 24 08 01 00 00 pushq 0x108(%rsp)
497e: ff 74 24 20 pushq 0x20(%rsp)
4982: 41 54 push %r12
4984: 4c 89 d5 mov %r10,%rbp
4987: e8 f4 02 00 00 callq 4c80 <ZSTD_execSequenceEnd>
498c: 49 89 ea mov %rbp,%r10
498f: 48 8b 7c 24 30 mov 0x30(%rsp),%rdi
4994: 48 83 c4 20 add $0x20,%rsp
4998: 49 89 c3 mov %rax,%r11
499b: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
499f: 76 9f jbe 4940 <ZSTD_decompressSequencesLong_bmi2+0x12e0>
49a1: e9 a8 02 00 00 jmpq 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
49a6: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
49aa: 41 0f 10 41 10 movups 0x10(%r9),%xmm0
49af: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
49b4: 0f 11 41 10 movups %xmm0,0x10(%rcx)
if (16 >= length) return;
49b8: 48 83 fa 11 cmp $0x11,%rdx
49bc: 0f 8c 6e fe ff ff jl 4830 <ZSTD_decompressSequencesLong_bmi2+0x11d0>
49c2: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
op += 16;
49c7: 4c 8d 41 20 lea 0x20(%rcx),%r8
do {
49cb: 49 83 c1 30 add $0x30,%r9
49cf: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
49d1: 41 0f 10 44 09 f0 movups -0x10(%r9,%rcx,1),%xmm0
49d7: 41 0f 11 04 08 movups %xmm0,(%r8,%rcx,1)
49dc: 41 0f 10 04 09 movups (%r9,%rcx,1),%xmm0
49e1: 41 0f 11 44 08 10 movups %xmm0,0x10(%r8,%rcx,1)
while (op < oend);
49e7: 49 8d 14 08 lea (%r8,%rcx,1),%rdx
49eb: 48 83 c2 20 add $0x20,%rdx
49ef: 48 83 c1 20 add $0x20,%rcx
49f3: 48 39 ea cmp %rbp,%rdx
}
49f6: 72 d9 jb 49d1 <ZSTD_decompressSequencesLong_bmi2+0x1371>
49f8: e9 33 fe ff ff jmpq 4830 <ZSTD_decompressSequencesLong_bmi2+0x11d0>
if (offset < 8) {
49fd: 49 83 f8 07 cmp $0x7,%r8
4a01: 77 36 ja 4a39 <ZSTD_decompressSequencesLong_bmi2+0x13d9>
int const sub2 = dec64table[offset];
4a03: 4a 63 04 85 00 00 00 movslq 0x0(,%r8,4),%rax
4a0a: 00
(*op)[0] = (*ip)[0];
4a0b: 8a 0b mov (%rbx),%cl
4a0d: 88 4d 00 mov %cl,0x0(%rbp)
(*op)[1] = (*ip)[1];
4a10: 8a 4b 01 mov 0x1(%rbx),%cl
4a13: 88 4d 01 mov %cl,0x1(%rbp)
(*op)[2] = (*ip)[2];
4a16: 8a 4b 02 mov 0x2(%rbx),%cl
4a19: 88 4d 02 mov %cl,0x2(%rbp)
(*op)[3] = (*ip)[3];
4a1c: 8a 4b 03 mov 0x3(%rbx),%cl
4a1f: 88 4d 03 mov %cl,0x3(%rbp)
*ip += dec32table[offset];
4a22: 42 8b 0c 85 00 00 00 mov 0x0(,%r8,4),%ecx
4a29: 00
4a2a: 48 8d 34 0b lea (%rbx,%rcx,1),%rsi
*ip -= sub2;
4a2e: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
4a31: 8b 04 0b mov (%rbx,%rcx,1),%eax
4a34: 89 45 04 mov %eax,0x4(%rbp)
4a37: eb 0a jmp 4a43 <ZSTD_decompressSequencesLong_bmi2+0x13e3>
ZSTD_memcpy(dst, src, 8);
4a39: 48 8b 03 mov (%rbx),%rax
4a3c: 48 89 45 00 mov %rax,0x0(%rbp)
*ip += 8;
4a40: 48 89 de mov %rbx,%rsi
if (sequence.matchLength > 8) {
4a43: 49 83 fe 09 cmp $0x9,%r14
4a47: 0f 82 b7 fe ff ff jb 4904 <ZSTD_decompressSequencesLong_bmi2+0x12a4>
4a4d: 4d 89 df mov %r11,%r15
4a50: 4d 89 d3 mov %r10,%r11
4a53: 48 8d 4e 08 lea 0x8(%rsi),%rcx
4a57: 48 8d 55 08 lea 0x8(%rbp),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
4a5b: 48 89 d7 mov %rdx,%rdi
4a5e: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
4a61: 49 8d 04 2e lea (%r14,%rbp,1),%rax
4a65: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
4a69: 0f 8f b1 00 00 00 jg 4b20 <ZSTD_decompressSequencesLong_bmi2+0x14c0>
do {
4a6f: 48 8d 7d 10 lea 0x10(%rbp),%rdi
4a73: 48 39 f8 cmp %rdi,%rax
4a76: 49 89 fa mov %rdi,%r10
4a79: 4c 0f 47 d0 cmova %rax,%r10
4a7d: 49 29 ea sub %rbp,%r10
4a80: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
4a84: 49 83 fa 18 cmp $0x18,%r10
4a88: 0f 82 f5 00 00 00 jb 4b83 <ZSTD_decompressSequencesLong_bmi2+0x1523>
4a8e: 48 39 f8 cmp %rdi,%rax
4a91: 48 0f 47 f8 cmova %rax,%rdi
4a95: 48 29 ef sub %rbp,%rdi
4a98: 48 83 c7 f7 add $0xfffffffffffffff7,%rdi
4a9c: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
4aa0: 48 8d 1c 3e lea (%rsi,%rdi,1),%rbx
4aa4: 48 83 c3 10 add $0x10,%rbx
4aa8: 48 39 da cmp %rbx,%rdx
4aab: 73 10 jae 4abd <ZSTD_decompressSequencesLong_bmi2+0x145d>
4aad: 48 01 ef add %rbp,%rdi
4ab0: 48 83 c7 10 add $0x10,%rdi
4ab4: 48 39 f9 cmp %rdi,%rcx
4ab7: 0f 82 c6 00 00 00 jb 4b83 <ZSTD_decompressSequencesLong_bmi2+0x1523>
4abd: 49 c1 ea 03 shr $0x3,%r10
4ac1: 49 83 c2 01 add $0x1,%r10
4ac5: 4d 89 d0 mov %r10,%r8
4ac8: 49 83 e0 fc and $0xfffffffffffffffc,%r8
4acc: 49 8d 78 fc lea -0x4(%r8),%rdi
4ad0: 49 89 f9 mov %rdi,%r9
4ad3: 49 c1 e9 02 shr $0x2,%r9
4ad7: 49 83 c1 01 add $0x1,%r9
4adb: 48 85 ff test %rdi,%rdi
4ade: 74 7c je 4b5c <ZSTD_decompressSequencesLong_bmi2+0x14fc>
4ae0: 4c 89 cf mov %r9,%rdi
4ae3: 48 83 e7 fe and $0xfffffffffffffffe,%rdi
4ae7: 48 f7 df neg %rdi
4aea: 31 db xor %ebx,%ebx
ZSTD_memcpy(dst, src, 8);
4aec: 0f 10 44 de 08 movups 0x8(%rsi,%rbx,8),%xmm0
4af1: 0f 10 4c de 18 movups 0x18(%rsi,%rbx,8),%xmm1
4af6: 0f 11 44 dd 08 movups %xmm0,0x8(%rbp,%rbx,8)
4afb: 0f 11 4c dd 18 movups %xmm1,0x18(%rbp,%rbx,8)
4b00: 0f 10 44 de 28 movups 0x28(%rsi,%rbx,8),%xmm0
4b05: 0f 10 4c de 38 movups 0x38(%rsi,%rbx,8),%xmm1
4b0a: 0f 11 44 dd 28 movups %xmm0,0x28(%rbp,%rbx,8)
4b0f: 0f 11 4c dd 38 movups %xmm1,0x38(%rbp,%rbx,8)
4b14: 48 83 c3 08 add $0x8,%rbx
4b18: 48 83 c7 02 add $0x2,%rdi
4b1c: 75 ce jne 4aec <ZSTD_decompressSequencesLong_bmi2+0x148c>
4b1e: eb 3e jmp 4b5e <ZSTD_decompressSequencesLong_bmi2+0x14fe>
ZSTD_memcpy(dst, src, 16);
4b20: 0f 10 01 movups (%rcx),%xmm0
4b23: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
4b26: 49 83 fe 19 cmp $0x19,%r14
4b2a: 7c 6a jl 4b96 <ZSTD_decompressSequencesLong_bmi2+0x1536>
op += 16;
4b2c: 48 83 c5 18 add $0x18,%rbp
do {
4b30: 48 83 c6 28 add $0x28,%rsi
4b34: 31 c9 xor %ecx,%ecx
ZSTD_memcpy(dst, src, 16);
4b36: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
4b3b: 0f 11 44 0d 00 movups %xmm0,0x0(%rbp,%rcx,1)
4b40: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
4b44: 0f 11 44 0d 10 movups %xmm0,0x10(%rbp,%rcx,1)
while (op < oend);
4b49: 48 8d 14 29 lea (%rcx,%rbp,1),%rdx
4b4d: 48 83 c2 20 add $0x20,%rdx
4b51: 48 83 c1 20 add $0x20,%rcx
4b55: 48 39 c2 cmp %rax,%rdx
}
4b58: 72 dc jb 4b36 <ZSTD_decompressSequencesLong_bmi2+0x14d6>
4b5a: eb 3a jmp 4b96 <ZSTD_decompressSequencesLong_bmi2+0x1536>
4b5c: 31 db xor %ebx,%ebx
4b5e: 41 f6 c1 01 test $0x1,%r9b
4b62: 74 12 je 4b76 <ZSTD_decompressSequencesLong_bmi2+0x1516>
ZSTD_memcpy(dst, src, 8);
4b64: 0f 10 04 d9 movups (%rcx,%rbx,8),%xmm0
4b68: 0f 10 4c d9 10 movups 0x10(%rcx,%rbx,8),%xmm1
4b6d: 0f 11 04 da movups %xmm0,(%rdx,%rbx,8)
4b71: 0f 11 4c da 10 movups %xmm1,0x10(%rdx,%rbx,8)
} while (op < oend);
4b76: 4d 39 c2 cmp %r8,%r10
4b79: 74 1b je 4b96 <ZSTD_decompressSequencesLong_bmi2+0x1536>
4b7b: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
4b7f: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
ZSTD_memcpy(dst, src, 8);
4b83: 48 8b 31 mov (%rcx),%rsi
4b86: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
4b89: 48 83 c2 08 add $0x8,%rdx
4b8d: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
4b91: 48 39 c2 cmp %rax,%rdx
4b94: 72 ed jb 4b83 <ZSTD_decompressSequencesLong_bmi2+0x1523>
4b96: 4c 8b ac 24 c8 00 00 mov 0xc8(%rsp),%r13
4b9d: 00
4b9e: 4c 8b a4 24 b8 00 00 mov 0xb8(%rsp),%r12
4ba5: 00
4ba6: 8b 44 24 04 mov 0x4(%rsp),%eax
4baa: 48 8b 7c 24 10 mov 0x10(%rsp),%rdi
4baf: 4d 89 da mov %r11,%r10
4bb2: 4d 89 fb mov %r15,%r11
4bb5: 41 89 c7 mov %eax,%r15d
4bb8: 49 83 fb 88 cmp $0xffffffffffffff88,%r11
4bbc: 0f 86 7e fd ff ff jbe 4940 <ZSTD_decompressSequencesLong_bmi2+0x12e0>
4bc2: e9 87 00 00 00 jmpq 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
4bc7: 4c 8b ac 24 c8 00 00 mov 0xc8(%rsp),%r13
4bce: 00
4bcf: 4c 8b a4 24 b8 00 00 mov 0xb8(%rsp),%r12
4bd6: 00
4bd7: 48 8b 4c 24 18 mov 0x18(%rsp),%rcx
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
4bdc: 8b 84 24 98 00 00 00 mov 0x98(%rsp),%eax
4be3: 48 8b 94 24 38 01 00 mov 0x138(%rsp),%rdx
4bea: 00
4beb: 89 82 3c 68 00 00 mov %eax,0x683c(%rdx)
4bf1: 8b 84 24 a0 00 00 00 mov 0xa0(%rsp),%eax
4bf8: 89 82 40 68 00 00 mov %eax,0x6840(%rdx)
4bfe: 8b 84 24 a8 00 00 00 mov 0xa8(%rsp),%eax
4c05: 89 82 44 68 00 00 mov %eax,0x6844(%rdx)
{ size_t const lastLLSize = litEnd - litPtr;
4c0b: 48 8b b4 24 d8 00 00 mov 0xd8(%rsp),%rsi
4c12: 00
4c13: 48 8b 94 24 f8 00 00 mov 0xf8(%rsp),%rdx
4c1a: 00
4c1b: 49 29 f4 sub %rsi,%r12
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
4c1e: 48 29 ca sub %rcx,%rdx
4c21: 49 c7 c3 ba ff ff ff mov $0xffffffffffffffba,%r11
4c28: 49 39 d4 cmp %rdx,%r12
4c2b: 77 21 ja 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
if (op != NULL) {
4c2d: 48 85 c9 test %rcx,%rcx
4c30: 74 16 je 4c48 <ZSTD_decompressSequencesLong_bmi2+0x15e8>
ZSTD_memcpy(op, litPtr, lastLLSize);
4c32: 48 89 cf mov %rcx,%rdi
4c35: 4c 89 e2 mov %r12,%rdx
4c38: 48 89 cb mov %rcx,%rbx
4c3b: e8 00 00 00 00 callq 4c40 <ZSTD_decompressSequencesLong_bmi2+0x15e0>
op += lastLLSize;
4c40: 4c 01 e3 add %r12,%rbx
4c43: 49 89 db mov %rbx,%r11
4c46: eb 03 jmp 4c4b <ZSTD_decompressSequencesLong_bmi2+0x15eb>
4c48: 45 31 db xor %r11d,%r11d
return op-ostart;
4c4b: 4d 29 eb sub %r13,%r11
return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
4c4e: 4c 89 d8 mov %r11,%rax
4c51: 48 81 c4 18 02 00 00 add $0x218,%rsp
4c58: 5b pop %rbx
4c59: 41 5c pop %r12
4c5b: 41 5d pop %r13
4c5d: 41 5e pop %r14
4c5f: 41 5f pop %r15
4c61: 5d pop %rbp
4c62: c3 retq
4c63: 49 c7 c3 ec ff ff ff mov $0xffffffffffffffec,%r11
4c6a: eb e2 jmp 4c4e <ZSTD_decompressSequencesLong_bmi2+0x15ee>
4c6c: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
4c73: 00 00 00
4c76: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
4c7d: 00 00 00
0000000000004c80 <ZSTD_execSequenceEnd>:
{
4c80: 55 push %rbp
4c81: 41 57 push %r15
4c83: 41 56 push %r14
4c85: 41 55 push %r13
4c87: 41 54 push %r12
4c89: 53 push %rbx
4c8a: 48 83 ec 18 sub $0x18,%rsp
4c8e: 48 89 f5 mov %rsi,%rbp
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
4c91: 4c 8d 34 11 lea (%rcx,%rdx,1),%r14
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
4c95: 48 29 fe sub %rdi,%rsi
4c98: 48 c7 c0 ba ff ff ff mov $0xffffffffffffffba,%rax
4c9f: 49 39 f6 cmp %rsi,%r14
4ca2: 0f 87 ac 09 00 00 ja 5654 <ZSTD_execSequenceEnd+0x9d4>
4ca8: 48 8b 74 24 50 mov 0x50(%rsp),%rsi
4cad: 4d 8b 21 mov (%r9),%r12
RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
4cb0: 4c 29 e6 sub %r12,%rsi
4cb3: 48 c7 c0 ec ff ff ff mov $0xffffffffffffffec,%rax
4cba: 48 39 d6 cmp %rdx,%rsi
4cbd: 0f 82 91 09 00 00 jb 5654 <ZSTD_execSequenceEnd+0x9d4>
4cc3: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11
4cc8: 4c 8d 2c 17 lea (%rdi,%rdx,1),%r13
4ccc: 49 8d 34 14 lea (%r12,%rdx,1),%rsi
4cd0: 48 89 74 24 10 mov %rsi,0x10(%rsp)
4cd5: 48 83 c5 e0 add $0xffffffffffffffe0,%rbp
if (length < 8) {
4cd9: 48 83 fa 07 cmp $0x7,%rdx
4cdd: 7f 6a jg 4d49 <ZSTD_execSequenceEnd+0xc9>
while (op < oend) *op++ = *ip++;
4cdf: 48 85 d2 test %rdx,%rdx
4ce2: 0f 8e 4a 03 00 00 jle 5032 <ZSTD_execSequenceEnd+0x3b2>
4ce8: 49 89 ef mov %rbp,%r15
4ceb: 48 8d 57 01 lea 0x1(%rdi),%rdx
4cef: 49 39 d5 cmp %rdx,%r13
4cf2: 49 89 d3 mov %rdx,%r11
4cf5: 4d 0f 47 dd cmova %r13,%r11
4cf9: 49 29 fb sub %rdi,%r11
4cfc: 49 83 fb 20 cmp $0x20,%r11
4d00: 72 22 jb 4d24 <ZSTD_execSequenceEnd+0xa4>
4d02: 49 39 d5 cmp %rdx,%r13
4d05: 49 0f 47 d5 cmova %r13,%rdx
4d09: 48 89 d6 mov %rdx,%rsi
4d0c: 48 29 fe sub %rdi,%rsi
4d0f: 4c 01 e6 add %r12,%rsi
4d12: 48 39 fe cmp %rdi,%rsi
4d15: 0f 86 59 01 00 00 jbe 4e74 <ZSTD_execSequenceEnd+0x1f4>
4d1b: 49 39 d4 cmp %rdx,%r12
4d1e: 0f 83 50 01 00 00 jae 4e74 <ZSTD_execSequenceEnd+0x1f4>
4d24: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11
4d29: 4c 89 fd mov %r15,%rbp
4d2c: 0f 1f 40 00 nopl 0x0(%rax)
4d30: 41 0f b6 14 24 movzbl (%r12),%edx
4d35: 49 83 c4 01 add $0x1,%r12
4d39: 88 17 mov %dl,(%rdi)
4d3b: 48 83 c7 01 add $0x1,%rdi
4d3f: 4c 39 ef cmp %r13,%rdi
4d42: 72 ec jb 4d30 <ZSTD_execSequenceEnd+0xb0>
4d44: e9 e9 02 00 00 jmpq 5032 <ZSTD_execSequenceEnd+0x3b2>
if (oend <= oend_w) {
4d49: 49 39 ed cmp %rbp,%r13
4d4c: 76 10 jbe 4d5e <ZSTD_execSequenceEnd+0xde>
if (op <= oend_w) {
4d4e: 49 89 ea mov %rbp,%r10
4d51: 49 29 fa sub %rdi,%r10
4d54: 73 54 jae 4daa <ZSTD_execSequenceEnd+0x12a>
4d56: 49 89 ff mov %rdi,%r15
4d59: e9 aa 00 00 00 jmpq 4e08 <ZSTD_execSequenceEnd+0x188>
ZSTD_memcpy(dst, src, 16);
4d5e: 41 0f 10 04 24 movups (%r12),%xmm0
4d63: 0f 11 07 movups %xmm0,(%rdi)
if (16 >= length) return;
4d66: 48 83 fa 11 cmp $0x11,%rdx
4d6a: 0f 8c c2 02 00 00 jl 5032 <ZSTD_execSequenceEnd+0x3b2>
do {
4d70: 49 83 c4 10 add $0x10,%r12
4d74: ba 10 00 00 00 mov $0x10,%edx
4d79: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
ZSTD_memcpy(dst, src, 16);
4d80: 41 0f 10 44 14 f0 movups -0x10(%r12,%rdx,1),%xmm0
4d86: 0f 11 04 17 movups %xmm0,(%rdi,%rdx,1)
4d8a: 41 0f 10 04 14 movups (%r12,%rdx,1),%xmm0
4d8f: 0f 11 44 17 10 movups %xmm0,0x10(%rdi,%rdx,1)
while (op < oend);
4d94: 48 8d 34 17 lea (%rdi,%rdx,1),%rsi
4d98: 48 83 c6 20 add $0x20,%rsi
4d9c: 48 83 c2 20 add $0x20,%rdx
4da0: 4c 39 ee cmp %r13,%rsi
}
4da3: 72 db jb 4d80 <ZSTD_execSequenceEnd+0x100>
4da5: e9 88 02 00 00 jmpq 5032 <ZSTD_execSequenceEnd+0x3b2>
4daa: 4d 89 f3 mov %r14,%r11
4dad: 49 89 ee mov %rbp,%r14
ZSTD_memcpy(dst, src, 16);
4db0: 41 0f 10 04 24 movups (%r12),%xmm0
4db5: 0f 11 07 movups %xmm0,(%rdi)
if (16 >= length) return;
4db8: 49 83 fa 11 cmp $0x11,%r10
4dbc: 7c 36 jl 4df4 <ZSTD_execSequenceEnd+0x174>
do {
4dbe: 49 8d 6c 24 10 lea 0x10(%r12),%rbp
4dc3: bb 10 00 00 00 mov $0x10,%ebx
4dc8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
4dcf: 00
ZSTD_memcpy(dst, src, 16);
4dd0: 0f 10 44 1d f0 movups -0x10(%rbp,%rbx,1),%xmm0
4dd5: 0f 11 04 1f movups %xmm0,(%rdi,%rbx,1)
4dd9: 0f 10 44 1d 00 movups 0x0(%rbp,%rbx,1),%xmm0
4dde: 0f 11 44 1f 10 movups %xmm0,0x10(%rdi,%rbx,1)
while (op < oend);
4de3: 48 8d 34 1f lea (%rdi,%rbx,1),%rsi
4de7: 48 83 c6 20 add $0x20,%rsi
4deb: 48 83 c3 20 add $0x20,%rbx
4def: 4c 39 f6 cmp %r14,%rsi
}
4df2: 72 dc jb 4dd0 <ZSTD_execSequenceEnd+0x150>
ip += oend_w - op;
4df4: 4d 01 d4 add %r10,%r12
4df7: 4d 89 f7 mov %r14,%r15
4dfa: 4c 89 de mov %r11,%rsi
4dfd: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11
4e02: 4c 89 f5 mov %r14,%rbp
4e05: 49 89 f6 mov %rsi,%r14
while (op < oend) *op++ = *ip++;
4e08: 4d 39 fd cmp %r15,%r13
4e0b: 0f 86 21 02 00 00 jbe 5032 <ZSTD_execSequenceEnd+0x3b2>
4e11: 48 89 d3 mov %rdx,%rbx
4e14: 4c 29 fb sub %r15,%rbx
4e17: 48 01 fb add %rdi,%rbx
4e1a: 48 83 fb 20 cmp $0x20,%rbx
4e1e: 0f 82 ec 01 00 00 jb 5010 <ZSTD_execSequenceEnd+0x390>
4e24: 49 8d 34 1c lea (%r12,%rbx,1),%rsi
4e28: 49 39 f7 cmp %rsi,%r15
4e2b: 73 09 jae 4e36 <ZSTD_execSequenceEnd+0x1b6>
4e2d: 4d 39 ec cmp %r13,%r12
4e30: 0f 82 da 01 00 00 jb 5010 <ZSTD_execSequenceEnd+0x390>
4e36: 48 89 6c 24 08 mov %rbp,0x8(%rsp)
4e3b: 48 89 0c 24 mov %rcx,(%rsp)
4e3f: 4c 89 d9 mov %r11,%rcx
4e42: 48 89 de mov %rbx,%rsi
4e45: 48 83 e6 e0 and $0xffffffffffffffe0,%rsi
4e49: 48 89 f5 mov %rsi,%rbp
4e4c: 4c 8d 56 e0 lea -0x20(%rsi),%r10
4e50: 4c 89 d6 mov %r10,%rsi
4e53: 48 c1 ee 05 shr $0x5,%rsi
4e57: 48 83 c6 01 add $0x1,%rsi
4e5b: 41 89 f3 mov %esi,%r11d
4e5e: 41 83 e3 03 and $0x3,%r11d
4e62: 49 83 fa 60 cmp $0x60,%r10
4e66: 0f 83 ed 00 00 00 jae 4f59 <ZSTD_execSequenceEnd+0x2d9>
4e6c: 45 31 d2 xor %r10d,%r10d
4e6f: e9 57 01 00 00 jmpq 4fcb <ZSTD_execSequenceEnd+0x34b>
while (op < oend) *op++ = *ip++;
4e74: 4d 89 da mov %r11,%r10
4e77: 49 83 e2 e0 and $0xffffffffffffffe0,%r10
4e7b: 49 8d 52 e0 lea -0x20(%r10),%rdx
4e7f: 48 89 d3 mov %rdx,%rbx
4e82: 48 c1 eb 05 shr $0x5,%rbx
4e86: 48 83 c3 01 add $0x1,%rbx
4e8a: 89 dd mov %ebx,%ebp
4e8c: 83 e5 03 and $0x3,%ebp
4e8f: 48 83 fa 60 cmp $0x60,%rdx
4e93: 73 04 jae 4e99 <ZSTD_execSequenceEnd+0x219>
4e95: 31 f6 xor %esi,%esi
4e97: eb 77 jmp 4f10 <ZSTD_execSequenceEnd+0x290>
4e99: 48 83 e3 fc and $0xfffffffffffffffc,%rbx
4e9d: 48 f7 db neg %rbx
4ea0: 31 f6 xor %esi,%esi
4ea2: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
4ea9: 00 00 00
4eac: 0f 1f 40 00 nopl 0x0(%rax)
4eb0: 41 0f 10 04 34 movups (%r12,%rsi,1),%xmm0
4eb5: 41 0f 10 4c 34 10 movups 0x10(%r12,%rsi,1),%xmm1
4ebb: 0f 11 04 37 movups %xmm0,(%rdi,%rsi,1)
4ebf: 0f 11 4c 37 10 movups %xmm1,0x10(%rdi,%rsi,1)
4ec4: 41 0f 10 44 34 20 movups 0x20(%r12,%rsi,1),%xmm0
4eca: 41 0f 10 4c 34 30 movups 0x30(%r12,%rsi,1),%xmm1
4ed0: 0f 11 44 37 20 movups %xmm0,0x20(%rdi,%rsi,1)
4ed5: 0f 11 4c 37 30 movups %xmm1,0x30(%rdi,%rsi,1)
4eda: 41 0f 10 44 34 40 movups 0x40(%r12,%rsi,1),%xmm0
4ee0: 41 0f 10 4c 34 50 movups 0x50(%r12,%rsi,1),%xmm1
4ee6: 0f 11 44 37 40 movups %xmm0,0x40(%rdi,%rsi,1)
4eeb: 0f 11 4c 37 50 movups %xmm1,0x50(%rdi,%rsi,1)
4ef0: 41 0f 10 44 34 60 movups 0x60(%r12,%rsi,1),%xmm0
4ef6: 41 0f 10 4c 34 70 movups 0x70(%r12,%rsi,1),%xmm1
4efc: 0f 11 44 37 60 movups %xmm0,0x60(%rdi,%rsi,1)
4f01: 0f 11 4c 37 70 movups %xmm1,0x70(%rdi,%rsi,1)
4f06: 48 83 ee 80 sub $0xffffffffffffff80,%rsi
4f0a: 48 83 c3 04 add $0x4,%rbx
4f0e: 75 a0 jne 4eb0 <ZSTD_execSequenceEnd+0x230>
4f10: 48 85 ed test %rbp,%rbp
4f13: 74 28 je 4f3d <ZSTD_execSequenceEnd+0x2bd>
4f15: 48 83 c6 10 add $0x10,%rsi
4f19: 48 f7 dd neg %rbp
4f1c: 0f 1f 40 00 nopl 0x0(%rax)
4f20: 41 0f 10 44 34 f0 movups -0x10(%r12,%rsi,1),%xmm0
4f26: 41 0f 10 0c 34 movups (%r12,%rsi,1),%xmm1
4f2b: 0f 11 44 37 f0 movups %xmm0,-0x10(%rdi,%rsi,1)
4f30: 0f 11 0c 37 movups %xmm1,(%rdi,%rsi,1)
4f34: 48 83 c6 20 add $0x20,%rsi
4f38: 48 ff c5 inc %rbp
4f3b: 75 e3 jne 4f20 <ZSTD_execSequenceEnd+0x2a0>
4f3d: 4d 39 d3 cmp %r10,%r11
4f40: 4c 8b 5c 24 58 mov 0x58(%rsp),%r11
4f45: 4c 89 fd mov %r15,%rbp
4f48: 0f 84 e4 00 00 00 je 5032 <ZSTD_execSequenceEnd+0x3b2>
4f4e: 4d 01 d4 add %r10,%r12
4f51: 4c 01 d7 add %r10,%rdi
4f54: e9 d7 fd ff ff jmpq 4d30 <ZSTD_execSequenceEnd+0xb0>
while (op < oend) *op++ = *ip++;
4f59: 48 83 e6 fc and $0xfffffffffffffffc,%rsi
4f5d: 48 f7 de neg %rsi
4f60: 45 31 d2 xor %r10d,%r10d
4f63: 43 0f 10 04 14 movups (%r12,%r10,1),%xmm0
4f68: 43 0f 10 4c 14 10 movups 0x10(%r12,%r10,1),%xmm1
4f6e: 43 0f 11 04 17 movups %xmm0,(%r15,%r10,1)
4f73: 43 0f 11 4c 17 10 movups %xmm1,0x10(%r15,%r10,1)
4f79: 43 0f 10 44 14 20 movups 0x20(%r12,%r10,1),%xmm0
4f7f: 43 0f 10 4c 14 30 movups 0x30(%r12,%r10,1),%xmm1
4f85: 43 0f 11 44 17 20 movups %xmm0,0x20(%r15,%r10,1)
4f8b: 43 0f 11 4c 17 30 movups %xmm1,0x30(%r15,%r10,1)
4f91: 43 0f 10 44 14 40 movups 0x40(%r12,%r10,1),%xmm0
4f97: 43 0f 10 4c 14 50 movups 0x50(%r12,%r10,1),%xmm1
4f9d: 43 0f 11 44 17 40 movups %xmm0,0x40(%r15,%r10,1)
4fa3: 43 0f 11 4c 17 50 movups %xmm1,0x50(%r15,%r10,1)
4fa9: 43 0f 10 44 14 60 movups 0x60(%r12,%r10,1),%xmm0
4faf: 43 0f 10 4c 14 70 movups 0x70(%r12,%r10,1),%xmm1
4fb5: 43 0f 11 44 17 60 movups %xmm0,0x60(%r15,%r10,1)
4fbb: 43 0f 11 4c 17 70 movups %xmm1,0x70(%r15,%r10,1)
4fc1: 49 83 ea 80 sub $0xffffffffffffff80,%r10
4fc5: 48 83 c6 04 add $0x4,%rsi
4fc9: 75 98 jne 4f63 <ZSTD_execSequenceEnd+0x2e3>
4fcb: 4d 85 db test %r11,%r11
4fce: 74 26 je 4ff6 <ZSTD_execSequenceEnd+0x376>
4fd0: 49 83 c2 10 add $0x10,%r10
4fd4: 49 f7 db neg %r11
4fd7: 43 0f 10 44 14 f0 movups -0x10(%r12,%r10,1),%xmm0
4fdd: 43 0f 10 0c 14 movups (%r12,%r10,1),%xmm1
4fe2: 43 0f 11 44 17 f0 movups %xmm0,-0x10(%r15,%r10,1)
4fe8: 43 0f 11 0c 17 movups %xmm1,(%r15,%r10,1)
4fed: 49 83 c2 20 add $0x20,%r10
4ff1: 49 ff c3 inc %r11
4ff4: 75 e1 jne 4fd7 <ZSTD_execSequenceEnd+0x357>
4ff6: 48 39 dd cmp %rbx,%rbp
4ff9: 48 89 ee mov %rbp,%rsi
4ffc: 49 89 cb mov %rcx,%r11
4fff: 48 8b 0c 24 mov (%rsp),%rcx
5003: 48 8b 6c 24 08 mov 0x8(%rsp),%rbp
5008: 74 28 je 5032 <ZSTD_execSequenceEnd+0x3b2>
500a: 49 01 f4 add %rsi,%r12
500d: 49 01 f7 add %rsi,%r15
5010: 4c 29 fa sub %r15,%rdx
5013: 48 01 d7 add %rdx,%rdi
5016: 31 d2 xor %edx,%edx
5018: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
501f: 00
5020: 41 0f b6 1c 14 movzbl (%r12,%rdx,1),%ebx
5025: 41 88 1c 17 mov %bl,(%r15,%rdx,1)
5029: 48 83 c2 01 add $0x1,%rdx
502d: 48 39 d7 cmp %rdx,%rdi
5030: 75 ee jne 5020 <ZSTD_execSequenceEnd+0x3a0>
5032: 4c 89 eb mov %r13,%rbx
5035: 4c 29 c3 sub %r8,%rbx
5038: 48 8b 54 24 10 mov 0x10(%rsp),%rdx
*litPtr = iLitEnd;
503d: 49 89 11 mov %rdx,(%r9)
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
5040: 4c 89 ea mov %r13,%rdx
5043: 4c 29 da sub %r11,%rdx
5046: 4c 39 c2 cmp %r8,%rdx
5049: 73 4a jae 5095 <ZSTD_execSequenceEnd+0x415>
RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, "");
504b: 4c 89 ea mov %r13,%rdx
504e: 48 2b 54 24 60 sub 0x60(%rsp),%rdx
5053: 4c 39 c2 cmp %r8,%rdx
5056: 0f 82 f8 05 00 00 jb 5654 <ZSTD_execSequenceEnd+0x9d4>
505c: 48 8b 44 24 68 mov 0x68(%rsp),%rax
match = dictEnd - (prefixStart-match);
5061: 4c 29 db sub %r11,%rbx
5064: 48 8d 34 18 lea (%rax,%rbx,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
5068: 48 8d 14 0e lea (%rsi,%rcx,1),%rdx
506c: 48 39 c2 cmp %rax,%rdx
506f: 0f 86 79 01 00 00 jbe 51ee <ZSTD_execSequenceEnd+0x56e>
{ size_t const length1 = dictEnd - match;
5075: 48 89 da mov %rbx,%rdx
5078: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
507b: 4c 89 ef mov %r13,%rdi
507e: 4d 89 df mov %r11,%r15
5081: 49 89 cc mov %rcx,%r12
5084: e8 00 00 00 00 callq 5089 <ZSTD_execSequenceEnd+0x409>
5089: 4c 89 e1 mov %r12,%rcx
op = oLitEnd + length1;
508c: 49 29 dd sub %rbx,%r13
sequence.matchLength -= length1;
508f: 48 01 d9 add %rbx,%rcx
ptrdiff_t const diff = op - ip;
5092: 4c 89 fb mov %r15,%rbx
5095: 4c 89 e8 mov %r13,%rax
BYTE* const oend = op + length;
5098: 4e 8d 3c 29 lea (%rcx,%r13,1),%r15
if (length < 8) {
509c: 48 83 f9 07 cmp $0x7,%rcx
50a0: 7f 71 jg 5113 <ZSTD_execSequenceEnd+0x493>
while (op < oend) *op++ = *ip++;
50a2: 48 85 c9 test %rcx,%rcx
50a5: 0f 8e a6 05 00 00 jle 5651 <ZSTD_execSequenceEnd+0x9d1>
50ab: 49 8d 55 01 lea 0x1(%r13),%rdx
50af: 49 39 d7 cmp %rdx,%r15
50b2: 48 89 d0 mov %rdx,%rax
50b5: 49 0f 47 c7 cmova %r15,%rax
50b9: 4c 29 e8 sub %r13,%rax
50bc: 48 83 f8 20 cmp $0x20,%rax
50c0: 0f 82 ba 02 00 00 jb 5380 <ZSTD_execSequenceEnd+0x700>
50c6: 49 39 d7 cmp %rdx,%r15
50c9: 49 0f 47 d7 cmova %r15,%rdx
50cd: 48 89 d6 mov %rdx,%rsi
50d0: 4c 29 ee sub %r13,%rsi
50d3: 48 01 de add %rbx,%rsi
50d6: 49 39 f5 cmp %rsi,%r13
50d9: 73 09 jae 50e4 <ZSTD_execSequenceEnd+0x464>
50db: 48 39 d3 cmp %rdx,%rbx
50de: 0f 82 9c 02 00 00 jb 5380 <ZSTD_execSequenceEnd+0x700>
50e4: 4d 89 f0 mov %r14,%r8
50e7: 48 89 c2 mov %rax,%rdx
50ea: 48 83 e2 e0 and $0xffffffffffffffe0,%rdx
50ee: 48 8d 7a e0 lea -0x20(%rdx),%rdi
50f2: 48 89 fe mov %rdi,%rsi
50f5: 48 c1 ee 05 shr $0x5,%rsi
50f9: 48 83 c6 01 add $0x1,%rsi
50fd: 89 f5 mov %esi,%ebp
50ff: 83 e5 03 and $0x3,%ebp
5102: 48 83 ff 60 cmp $0x60,%rdi
5106: 0f 83 ba 01 00 00 jae 52c6 <ZSTD_execSequenceEnd+0x646>
510c: 31 ff xor %edi,%edi
510e: e9 1d 02 00 00 jmpq 5330 <ZSTD_execSequenceEnd+0x6b0>
5113: 48 29 d8 sub %rbx,%rax
if (offset < 8) {
5116: 48 83 f8 07 cmp $0x7,%rax
511a: 0f 87 ad 00 00 00 ja 51cd <ZSTD_execSequenceEnd+0x54d>
int const sub2 = dec64table[offset];
5120: 48 63 34 85 00 00 00 movslq 0x0(,%rax,4),%rsi
5127: 00
(*op)[0] = (*ip)[0];
5128: 8a 13 mov (%rbx),%dl
512a: 41 88 55 00 mov %dl,0x0(%r13)
(*op)[1] = (*ip)[1];
512e: 8a 53 01 mov 0x1(%rbx),%dl
5131: 41 88 55 01 mov %dl,0x1(%r13)
(*op)[2] = (*ip)[2];
5135: 8a 53 02 mov 0x2(%rbx),%dl
5138: 41 88 55 02 mov %dl,0x2(%r13)
(*op)[3] = (*ip)[3];
513c: 8a 53 03 mov 0x3(%rbx),%dl
513f: 41 88 55 03 mov %dl,0x3(%r13)
*ip += dec32table[offset];
5143: 8b 04 85 00 00 00 00 mov 0x0(,%rax,4),%eax
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
514a: 8b 14 03 mov (%rbx,%rax,1),%edx
*ip += dec32table[offset];
514d: 48 01 c3 add %rax,%rbx
*ip -= sub2;
5150: 48 29 f3 sub %rsi,%rbx
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
5153: 41 89 55 04 mov %edx,0x4(%r13)
*ip += 8;
5157: 48 8d 43 08 lea 0x8(%rbx),%rax
*op += 8;
515b: 49 8d 55 08 lea 0x8(%r13),%rdx
if (oend <= oend_w) {
515f: 49 39 ef cmp %rbp,%r15
5162: 77 7d ja 51e1 <ZSTD_execSequenceEnd+0x561>
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
5164: 48 89 d6 mov %rdx,%rsi
5167: 48 29 c6 sub %rax,%rsi
BYTE* const oend = op + length;
516a: 4c 8d 1c 0a lea (%rdx,%rcx,1),%r11
516e: 48 83 fe 0f cmp $0xf,%rsi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
5172: 0f 8f 86 00 00 00 jg 51fe <ZSTD_execSequenceEnd+0x57e>
do {
5178: 49 8d 7d 10 lea 0x10(%r13),%rdi
517c: 49 39 fb cmp %rdi,%r11
517f: 48 89 fe mov %rdi,%rsi
5182: 49 0f 47 f3 cmova %r11,%rsi
5186: 4c 29 ee sub %r13,%rsi
5189: 48 83 c6 f7 add $0xfffffffffffffff7,%rsi
518d: 48 83 fe 18 cmp $0x18,%rsi
5191: 0f 82 49 03 00 00 jb 54e0 <ZSTD_execSequenceEnd+0x860>
5197: 4d 89 f2 mov %r14,%r10
519a: 49 39 fb cmp %rdi,%r11
519d: 49 0f 47 fb cmova %r11,%rdi
51a1: 4c 29 ef sub %r13,%rdi
51a4: 48 83 c7 07 add $0x7,%rdi
51a8: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
51ac: 48 8d 2c 3b lea (%rbx,%rdi,1),%rbp
51b0: 48 39 ea cmp %rbp,%rdx
51b3: 0f 83 e0 01 00 00 jae 5399 <ZSTD_execSequenceEnd+0x719>
51b9: 4c 01 ef add %r13,%rdi
51bc: 48 39 f8 cmp %rdi,%rax
51bf: 0f 83 d4 01 00 00 jae 5399 <ZSTD_execSequenceEnd+0x719>
51c5: 4d 89 d6 mov %r10,%r14
51c8: e9 13 03 00 00 jmpq 54e0 <ZSTD_execSequenceEnd+0x860>
ZSTD_memcpy(dst, src, 8);
51cd: 48 8b 03 mov (%rbx),%rax
51d0: 49 89 45 00 mov %rax,0x0(%r13)
*ip += 8;
51d4: 48 8d 43 08 lea 0x8(%rbx),%rax
*op += 8;
51d8: 49 8d 55 08 lea 0x8(%r13),%rdx
if (oend <= oend_w) {
51dc: 49 39 ef cmp %rbp,%r15
51df: 76 83 jbe 5164 <ZSTD_execSequenceEnd+0x4e4>
if (op <= oend_w) {
51e1: 48 39 ea cmp %rbp,%rdx
51e4: 76 65 jbe 524b <ZSTD_execSequenceEnd+0x5cb>
51e6: 48 89 d5 mov %rdx,%rbp
51e9: e9 58 03 00 00 jmpq 5546 <ZSTD_execSequenceEnd+0x8c6>
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
51ee: 4c 89 ef mov %r13,%rdi
51f1: 48 89 ca mov %rcx,%rdx
51f4: e8 00 00 00 00 callq 51f9 <ZSTD_execSequenceEnd+0x579>
51f9: e9 53 04 00 00 jmpq 5651 <ZSTD_execSequenceEnd+0x9d1>
ZSTD_memcpy(dst, src, 16);
51fe: 0f 10 00 movups (%rax),%xmm0
5201: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
5204: 48 83 f9 11 cmp $0x11,%rcx
5208: 0f 8c 43 04 00 00 jl 5651 <ZSTD_execSequenceEnd+0x9d1>
op += 16;
520e: 49 83 c5 18 add $0x18,%r13
do {
5212: 48 83 c3 28 add $0x28,%rbx
5216: 31 c0 xor %eax,%eax
5218: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
521f: 00
ZSTD_memcpy(dst, src, 16);
5220: 0f 10 44 03 f0 movups -0x10(%rbx,%rax,1),%xmm0
5225: 41 0f 11 44 05 00 movups %xmm0,0x0(%r13,%rax,1)
522b: 0f 10 04 03 movups (%rbx,%rax,1),%xmm0
522f: 41 0f 11 44 05 10 movups %xmm0,0x10(%r13,%rax,1)
while (op < oend);
5235: 4a 8d 14 28 lea (%rax,%r13,1),%rdx
5239: 48 83 c2 20 add $0x20,%rdx
523d: 48 83 c0 20 add $0x20,%rax
5241: 4c 39 da cmp %r11,%rdx
}
5244: 72 da jb 5220 <ZSTD_execSequenceEnd+0x5a0>
5246: e9 06 04 00 00 jmpq 5651 <ZSTD_execSequenceEnd+0x9d1>
ZSTD_wildcopy(op, ip, oend_w - op, ovtype);
524b: 49 89 ea mov %rbp,%r10
524e: 49 29 d2 sub %rdx,%r10
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
5251: 48 89 d6 mov %rdx,%rsi
5254: 48 29 c6 sub %rax,%rsi
5257: 48 83 fe 0f cmp $0xf,%rsi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
525b: 7f 27 jg 5284 <ZSTD_execSequenceEnd+0x604>
do {
525d: 49 8d 75 10 lea 0x10(%r13),%rsi
5261: 48 39 f5 cmp %rsi,%rbp
5264: 48 89 f7 mov %rsi,%rdi
5267: 48 0f 47 fd cmova %rbp,%rdi
526b: 4c 29 ef sub %r13,%rdi
526e: 48 83 c7 f7 add $0xfffffffffffffff7,%rdi
5272: 48 83 ff 18 cmp $0x18,%rdi
5276: 0f 83 8b 01 00 00 jae 5407 <ZSTD_execSequenceEnd+0x787>
527c: 48 89 c6 mov %rax,%rsi
527f: e9 ac 02 00 00 jmpq 5530 <ZSTD_execSequenceEnd+0x8b0>
ZSTD_memcpy(dst, src, 16);
5284: 0f 10 00 movups (%rax),%xmm0
5287: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
528a: 49 83 fa 11 cmp $0x11,%r10
528e: 0f 8c af 02 00 00 jl 5543 <ZSTD_execSequenceEnd+0x8c3>
op += 16;
5294: 49 8d 55 18 lea 0x18(%r13),%rdx
do {
5298: 48 83 c3 28 add $0x28,%rbx
529c: 31 f6 xor %esi,%esi
ZSTD_memcpy(dst, src, 16);
529e: 0f 10 44 33 f0 movups -0x10(%rbx,%rsi,1),%xmm0
52a3: 0f 11 04 32 movups %xmm0,(%rdx,%rsi,1)
52a7: 0f 10 04 33 movups (%rbx,%rsi,1),%xmm0
52ab: 0f 11 44 32 10 movups %xmm0,0x10(%rdx,%rsi,1)
while (op < oend);
52b0: 48 8d 3c 32 lea (%rdx,%rsi,1),%rdi
52b4: 48 83 c7 20 add $0x20,%rdi
52b8: 48 83 c6 20 add $0x20,%rsi
52bc: 48 39 ef cmp %rbp,%rdi
}
52bf: 72 dd jb 529e <ZSTD_execSequenceEnd+0x61e>
52c1: e9 7d 02 00 00 jmpq 5543 <ZSTD_execSequenceEnd+0x8c3>
while (op < oend) *op++ = *ip++;
52c6: 48 83 e6 fc and $0xfffffffffffffffc,%rsi
52ca: 48 f7 de neg %rsi
52cd: 31 ff xor %edi,%edi
52cf: 0f 10 04 3b movups (%rbx,%rdi,1),%xmm0
52d3: 0f 10 4c 3b 10 movups 0x10(%rbx,%rdi,1),%xmm1
52d8: 41 0f 11 44 3d 00 movups %xmm0,0x0(%r13,%rdi,1)
52de: 41 0f 11 4c 3d 10 movups %xmm1,0x10(%r13,%rdi,1)
52e4: 0f 10 44 3b 20 movups 0x20(%rbx,%rdi,1),%xmm0
52e9: 0f 10 4c 3b 30 movups 0x30(%rbx,%rdi,1),%xmm1
52ee: 41 0f 11 44 3d 20 movups %xmm0,0x20(%r13,%rdi,1)
52f4: 41 0f 11 4c 3d 30 movups %xmm1,0x30(%r13,%rdi,1)
52fa: 0f 10 44 3b 40 movups 0x40(%rbx,%rdi,1),%xmm0
52ff: 0f 10 4c 3b 50 movups 0x50(%rbx,%rdi,1),%xmm1
5304: 41 0f 11 44 3d 40 movups %xmm0,0x40(%r13,%rdi,1)
530a: 41 0f 11 4c 3d 50 movups %xmm1,0x50(%r13,%rdi,1)
5310: 0f 10 44 3b 60 movups 0x60(%rbx,%rdi,1),%xmm0
5315: 0f 10 4c 3b 70 movups 0x70(%rbx,%rdi,1),%xmm1
531a: 41 0f 11 44 3d 60 movups %xmm0,0x60(%r13,%rdi,1)
5320: 41 0f 11 4c 3d 70 movups %xmm1,0x70(%r13,%rdi,1)
5326: 48 83 ef 80 sub $0xffffffffffffff80,%rdi
532a: 48 83 c6 04 add $0x4,%rsi
532e: 75 9f jne 52cf <ZSTD_execSequenceEnd+0x64f>
5330: 48 85 ed test %rbp,%rbp
5333: 74 29 je 535e <ZSTD_execSequenceEnd+0x6de>
5335: 48 83 c7 10 add $0x10,%rdi
5339: 48 f7 dd neg %rbp
533c: 0f 1f 40 00 nopl 0x0(%rax)
5340: 0f 10 44 3b f0 movups -0x10(%rbx,%rdi,1),%xmm0
5345: 0f 10 0c 3b movups (%rbx,%rdi,1),%xmm1
5349: 41 0f 11 44 3d f0 movups %xmm0,-0x10(%r13,%rdi,1)
534f: 41 0f 11 4c 3d 00 movups %xmm1,0x0(%r13,%rdi,1)
5355: 48 83 c7 20 add $0x20,%rdi
5359: 48 ff c5 inc %rbp
535c: 75 e2 jne 5340 <ZSTD_execSequenceEnd+0x6c0>
535e: 48 39 d0 cmp %rdx,%rax
5361: 75 08 jne 536b <ZSTD_execSequenceEnd+0x6eb>
5363: 4c 89 c0 mov %r8,%rax
5366: e9 e9 02 00 00 jmpq 5654 <ZSTD_execSequenceEnd+0x9d4>
536b: 48 01 d3 add %rdx,%rbx
536e: 49 01 d5 add %rdx,%r13
5371: 4d 89 c6 mov %r8,%r14
5374: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
537b: 00 00 00
537e: 66 90 xchg %ax,%ax
5380: 0f b6 03 movzbl (%rbx),%eax
5383: 48 83 c3 01 add $0x1,%rbx
5387: 41 88 45 00 mov %al,0x0(%r13)
538b: 49 83 c5 01 add $0x1,%r13
538f: 4d 39 fd cmp %r15,%r13
5392: 72 ec jb 5380 <ZSTD_execSequenceEnd+0x700>
5394: e9 b8 02 00 00 jmpq 5651 <ZSTD_execSequenceEnd+0x9d1>
do {
5399: 48 c1 ee 03 shr $0x3,%rsi
539d: 48 83 c6 01 add $0x1,%rsi
53a1: 49 89 f0 mov %rsi,%r8
53a4: 49 83 e0 fc and $0xfffffffffffffffc,%r8
53a8: 49 8d 78 fc lea -0x4(%r8),%rdi
53ac: 49 89 f9 mov %rdi,%r9
53af: 49 c1 e9 02 shr $0x2,%r9
53b3: 49 83 c1 01 add $0x1,%r9
53b7: 48 85 ff test %rdi,%rdi
53ba: 0f 84 e9 00 00 00 je 54a9 <ZSTD_execSequenceEnd+0x829>
53c0: 4c 89 cd mov %r9,%rbp
53c3: 48 83 e5 fe and $0xfffffffffffffffe,%rbp
53c7: 48 f7 dd neg %rbp
53ca: 31 ff xor %edi,%edi
ZSTD_memcpy(dst, src, 8);
53cc: 0f 10 44 3b 08 movups 0x8(%rbx,%rdi,1),%xmm0
53d1: 0f 10 4c 3b 18 movups 0x18(%rbx,%rdi,1),%xmm1
53d6: 41 0f 11 44 3d 08 movups %xmm0,0x8(%r13,%rdi,1)
53dc: 41 0f 11 4c 3d 18 movups %xmm1,0x18(%r13,%rdi,1)
53e2: 0f 10 44 3b 28 movups 0x28(%rbx,%rdi,1),%xmm0
53e7: 0f 10 4c 3b 38 movups 0x38(%rbx,%rdi,1),%xmm1
53ec: 41 0f 11 44 3d 28 movups %xmm0,0x28(%r13,%rdi,1)
53f2: 41 0f 11 4c 3d 38 movups %xmm1,0x38(%r13,%rdi,1)
53f8: 48 83 c7 40 add $0x40,%rdi
53fc: 48 83 c5 02 add $0x2,%rbp
5400: 75 ca jne 53cc <ZSTD_execSequenceEnd+0x74c>
5402: e9 a4 00 00 00 jmpq 54ab <ZSTD_execSequenceEnd+0x82b>
5407: 4d 89 f3 mov %r14,%r11
do {
540a: 48 39 f5 cmp %rsi,%rbp
540d: 49 89 ec mov %rbp,%r12
5410: 48 0f 47 f5 cmova %rbp,%rsi
5414: 4c 29 ee sub %r13,%rsi
5417: 48 83 c6 07 add $0x7,%rsi
541b: 48 83 e6 f8 and $0xfffffffffffffff8,%rsi
541f: 48 8d 2c 33 lea (%rbx,%rsi,1),%rbp
5423: 48 39 ea cmp %rbp,%rdx
5426: 73 16 jae 543e <ZSTD_execSequenceEnd+0x7be>
5428: 4c 01 ee add %r13,%rsi
542b: 48 39 f0 cmp %rsi,%rax
542e: 73 0e jae 543e <ZSTD_execSequenceEnd+0x7be>
5430: 48 89 c6 mov %rax,%rsi
5433: 4d 89 de mov %r11,%r14
5436: 4c 89 e5 mov %r12,%rbp
5439: e9 f2 00 00 00 jmpq 5530 <ZSTD_execSequenceEnd+0x8b0>
543e: 48 c1 ef 03 shr $0x3,%rdi
5442: 48 83 c7 01 add $0x1,%rdi
5446: 49 89 f8 mov %rdi,%r8
5449: 49 83 e0 fc and $0xfffffffffffffffc,%r8
544d: 49 8d 70 fc lea -0x4(%r8),%rsi
5451: 49 89 f1 mov %rsi,%r9
5454: 49 c1 e9 02 shr $0x2,%r9
5458: 49 83 c1 01 add $0x1,%r9
545c: 48 85 f6 test %rsi,%rsi
545f: 0f 84 93 00 00 00 je 54f8 <ZSTD_execSequenceEnd+0x878>
5465: 4c 89 ce mov %r9,%rsi
5468: 48 83 e6 fe and $0xfffffffffffffffe,%rsi
546c: 48 f7 de neg %rsi
546f: 31 ed xor %ebp,%ebp
ZSTD_memcpy(dst, src, 8);
5471: 0f 10 44 2b 08 movups 0x8(%rbx,%rbp,1),%xmm0
5476: 0f 10 4c 2b 18 movups 0x18(%rbx,%rbp,1),%xmm1
547b: 41 0f 11 44 2d 08 movups %xmm0,0x8(%r13,%rbp,1)
5481: 41 0f 11 4c 2d 18 movups %xmm1,0x18(%r13,%rbp,1)
5487: 0f 10 44 2b 28 movups 0x28(%rbx,%rbp,1),%xmm0
548c: 0f 10 4c 2b 38 movups 0x38(%rbx,%rbp,1),%xmm1
5491: 41 0f 11 44 2d 28 movups %xmm0,0x28(%r13,%rbp,1)
5497: 41 0f 11 4c 2d 38 movups %xmm1,0x38(%r13,%rbp,1)
549d: 48 83 c5 40 add $0x40,%rbp
54a1: 48 83 c6 02 add $0x2,%rsi
54a5: 75 ca jne 5471 <ZSTD_execSequenceEnd+0x7f1>
54a7: eb 51 jmp 54fa <ZSTD_execSequenceEnd+0x87a>
54a9: 31 ff xor %edi,%edi
54ab: 41 f6 c1 01 test $0x1,%r9b
54af: 74 12 je 54c3 <ZSTD_execSequenceEnd+0x843>
54b1: 0f 10 04 38 movups (%rax,%rdi,1),%xmm0
54b5: 0f 10 4c 38 10 movups 0x10(%rax,%rdi,1),%xmm1
54ba: 0f 11 04 3a movups %xmm0,(%rdx,%rdi,1)
54be: 0f 11 4c 3a 10 movups %xmm1,0x10(%rdx,%rdi,1)
} while (op < oend);
54c3: 4c 39 c6 cmp %r8,%rsi
54c6: 4d 89 d6 mov %r10,%r14
54c9: 0f 84 82 01 00 00 je 5651 <ZSTD_execSequenceEnd+0x9d1>
54cf: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
54d3: 4a 8d 04 c0 lea (%rax,%r8,8),%rax
54d7: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
54de: 00 00
ZSTD_memcpy(dst, src, 8);
54e0: 48 8b 30 mov (%rax),%rsi
54e3: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
54e6: 48 83 c2 08 add $0x8,%rdx
54ea: 48 83 c0 08 add $0x8,%rax
} while (op < oend);
54ee: 4c 39 da cmp %r11,%rdx
54f1: 72 ed jb 54e0 <ZSTD_execSequenceEnd+0x860>
54f3: e9 59 01 00 00 jmpq 5651 <ZSTD_execSequenceEnd+0x9d1>
54f8: 31 ed xor %ebp,%ebp
54fa: 41 f6 c1 01 test $0x1,%r9b
54fe: 74 12 je 5512 <ZSTD_execSequenceEnd+0x892>
ZSTD_memcpy(dst, src, 8);
5500: 0f 10 04 28 movups (%rax,%rbp,1),%xmm0
5504: 0f 10 4c 28 10 movups 0x10(%rax,%rbp,1),%xmm1
5509: 0f 11 04 2a movups %xmm0,(%rdx,%rbp,1)
550d: 0f 11 4c 2a 10 movups %xmm1,0x10(%rdx,%rbp,1)
} while (op < oend);
5512: 4c 39 c7 cmp %r8,%rdi
5515: 4d 89 de mov %r11,%r14
5518: 4c 89 e5 mov %r12,%rbp
551b: 74 26 je 5543 <ZSTD_execSequenceEnd+0x8c3>
551d: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
5521: 4a 8d 34 c0 lea (%rax,%r8,8),%rsi
5525: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
552c: 00 00 00
552f: 90 nop
ZSTD_memcpy(dst, src, 8);
5530: 48 8b 3e mov (%rsi),%rdi
5533: 48 89 3a mov %rdi,(%rdx)
COPY8(op, ip)
5536: 48 83 c2 08 add $0x8,%rdx
553a: 48 83 c6 08 add $0x8,%rsi
} while (op < oend);
553e: 48 39 ea cmp %rbp,%rdx
5541: 72 ed jb 5530 <ZSTD_execSequenceEnd+0x8b0>
ip += oend_w - op;
5543: 4c 01 d0 add %r10,%rax
while (op < oend) *op++ = *ip++;
5546: 49 39 ef cmp %rbp,%r15
5549: 0f 86 02 01 00 00 jbe 5651 <ZSTD_execSequenceEnd+0x9d1>
554f: 48 89 ce mov %rcx,%rsi
5552: 48 29 ee sub %rbp,%rsi
5555: 4a 8d 14 2e lea (%rsi,%r13,1),%rdx
5559: 48 83 fa 20 cmp $0x20,%rdx
555d: 0f 82 ce 00 00 00 jb 5631 <ZSTD_execSequenceEnd+0x9b1>
5563: 48 01 c6 add %rax,%rsi
5566: 4c 01 ee add %r13,%rsi
5569: 48 39 f5 cmp %rsi,%rbp
556c: 73 09 jae 5577 <ZSTD_execSequenceEnd+0x8f7>
556e: 4c 39 f8 cmp %r15,%rax
5571: 0f 82 ba 00 00 00 jb 5631 <ZSTD_execSequenceEnd+0x9b1>
5577: 49 89 d0 mov %rdx,%r8
557a: 49 83 e0 e0 and $0xffffffffffffffe0,%r8
557e: 49 8d 78 e0 lea -0x20(%r8),%rdi
5582: 48 89 fe mov %rdi,%rsi
5585: 48 c1 ee 05 shr $0x5,%rsi
5589: 48 83 c6 01 add $0x1,%rsi
558d: 89 f3 mov %esi,%ebx
558f: 83 e3 03 and $0x3,%ebx
5592: 48 83 ff 60 cmp $0x60,%rdi
5596: 73 04 jae 559c <ZSTD_execSequenceEnd+0x91c>
5598: 31 ff xor %edi,%edi
559a: eb 62 jmp 55fe <ZSTD_execSequenceEnd+0x97e>
559c: 48 83 e6 fc and $0xfffffffffffffffc,%rsi
55a0: 48 f7 de neg %rsi
55a3: 31 ff xor %edi,%edi
55a5: 0f 10 04 38 movups (%rax,%rdi,1),%xmm0
55a9: 0f 10 4c 38 10 movups 0x10(%rax,%rdi,1),%xmm1
55ae: 0f 11 44 3d 00 movups %xmm0,0x0(%rbp,%rdi,1)
55b3: 0f 11 4c 3d 10 movups %xmm1,0x10(%rbp,%rdi,1)
55b8: 0f 10 44 38 20 movups 0x20(%rax,%rdi,1),%xmm0
55bd: 0f 10 4c 38 30 movups 0x30(%rax,%rdi,1),%xmm1
55c2: 0f 11 44 3d 20 movups %xmm0,0x20(%rbp,%rdi,1)
55c7: 0f 11 4c 3d 30 movups %xmm1,0x30(%rbp,%rdi,1)
55cc: 0f 10 44 38 40 movups 0x40(%rax,%rdi,1),%xmm0
55d1: 0f 10 4c 38 50 movups 0x50(%rax,%rdi,1),%xmm1
55d6: 0f 11 44 3d 40 movups %xmm0,0x40(%rbp,%rdi,1)
55db: 0f 11 4c 3d 50 movups %xmm1,0x50(%rbp,%rdi,1)
55e0: 0f 10 44 38 60 movups 0x60(%rax,%rdi,1),%xmm0
55e5: 0f 10 4c 38 70 movups 0x70(%rax,%rdi,1),%xmm1
55ea: 0f 11 44 3d 60 movups %xmm0,0x60(%rbp,%rdi,1)
55ef: 0f 11 4c 3d 70 movups %xmm1,0x70(%rbp,%rdi,1)
55f4: 48 83 ef 80 sub $0xffffffffffffff80,%rdi
55f8: 48 83 c6 04 add $0x4,%rsi
55fc: 75 a7 jne 55a5 <ZSTD_execSequenceEnd+0x925>
55fe: 48 85 db test %rbx,%rbx
5601: 74 23 je 5626 <ZSTD_execSequenceEnd+0x9a6>
5603: 48 83 c7 10 add $0x10,%rdi
5607: 48 f7 db neg %rbx
560a: 0f 10 44 38 f0 movups -0x10(%rax,%rdi,1),%xmm0
560f: 0f 10 0c 38 movups (%rax,%rdi,1),%xmm1
5613: 0f 11 44 3d f0 movups %xmm0,-0x10(%rbp,%rdi,1)
5618: 0f 11 4c 3d 00 movups %xmm1,0x0(%rbp,%rdi,1)
561d: 48 83 c7 20 add $0x20,%rdi
5621: 48 ff c3 inc %rbx
5624: 75 e4 jne 560a <ZSTD_execSequenceEnd+0x98a>
5626: 49 39 d0 cmp %rdx,%r8
5629: 74 26 je 5651 <ZSTD_execSequenceEnd+0x9d1>
562b: 4c 01 c0 add %r8,%rax
562e: 4c 01 c5 add %r8,%rbp
5631: 48 29 e9 sub %rbp,%rcx
5634: 49 01 cd add %rcx,%r13
5637: 31 c9 xor %ecx,%ecx
5639: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
5640: 0f b6 14 08 movzbl (%rax,%rcx,1),%edx
5644: 88 54 0d 00 mov %dl,0x0(%rbp,%rcx,1)
5648: 48 83 c1 01 add $0x1,%rcx
564c: 49 39 cd cmp %rcx,%r13
564f: 75 ef jne 5640 <ZSTD_execSequenceEnd+0x9c0>
5651: 4c 89 f0 mov %r14,%rax
}
5654: 48 83 c4 18 add $0x18,%rsp
5658: 5b pop %rbx
5659: 41 5c pop %r12
565b: 41 5d pop %r13
565d: 41 5e pop %r14
565f: 41 5f pop %r15
5661: 5d pop %rbp
5662: c3 retq
5663: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
566a: 00 00 00
566d: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5674: 00 00 00
5677: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
567e: 00 00
0000000000005680 <ZSTD_decompressSequences_bmi2>:
{
5680: 55 push %rbp
5681: 41 57 push %r15
5683: 41 56 push %r14
5685: 41 55 push %r13
5687: 41 54 push %r12
5689: 53 push %rbx
568a: 48 81 ec d8 00 00 00 sub $0xd8,%rsp
5691: 49 89 f2 mov %rsi,%r10
BYTE* const oend = ostart + maxDstSize;
5694: 48 01 f2 add %rsi,%rdx
const BYTE* litPtr = dctx->litPtr;
5697: 48 8b b7 a0 75 00 00 mov 0x75a0(%rdi),%rsi
569e: 48 89 b4 24 88 00 00 mov %rsi,0x88(%rsp)
56a5: 00
56a6: 48 8b af c0 75 00 00 mov 0x75c0(%rdi),%rbp
const BYTE* const litEnd = litPtr + dctx->litSize;
56ad: 48 01 f5 add %rsi,%rbp
56b0: 4c 89 54 24 08 mov %r10,0x8(%rsp)
if (nbSeq) {
56b5: 45 85 c9 test %r9d,%r9d
56b8: 0f 84 ea 0a 00 00 je 61a8 <ZSTD_decompressSequences_bmi2+0xb28>
56be: 48 8b b7 c8 74 00 00 mov 0x74c8(%rdi),%rsi
56c5: 48 8b 87 d0 74 00 00 mov 0x74d0(%rdi),%rax
56cc: 48 89 84 24 b0 00 00 mov %rax,0xb0(%rsp)
56d3: 00
56d4: 48 8b 87 d8 74 00 00 mov 0x74d8(%rdi),%rax
56db: 48 89 84 24 a8 00 00 mov %rax,0xa8(%rsp)
56e2: 00
dctx->fseEntropy = 1;
56e3: c7 87 2c 75 00 00 01 movl $0x1,0x752c(%rdi)
56ea: 00 00 00
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
56ed: f2 0f 10 8f 3c 68 00 movsd 0x683c(%rdi),%xmm1
56f4: 00
56f5: 0f 57 c0 xorps %xmm0,%xmm0
56f8: 0f 14 c8 unpcklps %xmm0,%xmm1
56fb: 0f 11 4c 24 68 movups %xmm1,0x68(%rsp)
5700: 8b 87 44 68 00 00 mov 0x6844(%rdi),%eax
5706: 48 89 44 24 78 mov %rax,0x78(%rsp)
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
570b: 4d 85 c0 test %r8,%r8
570e: 74 7f je 578f <ZSTD_decompressSequences_bmi2+0x10f>
bitD->start = (const char*)srcBuffer;
5710: 48 89 4c 24 28 mov %rcx,0x28(%rsp)
bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
5715: 48 8d 41 08 lea 0x8(%rcx),%rax
5719: 48 89 44 24 30 mov %rax,0x30(%rsp)
if (srcSize >= sizeof(bitD->bitContainer)) { /* normal case */
571e: 49 83 f8 08 cmp $0x8,%r8
5722: 48 89 b4 24 b8 00 00 mov %rsi,0xb8(%rsp)
5729: 00
572a: 72 7b jb 57a7 <ZSTD_decompressSequences_bmi2+0x127>
bitD->ptr = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
572c: 4a 8d 04 01 lea (%rcx,%r8,1),%rax
5730: 48 83 c0 f8 add $0xfffffffffffffff8,%rax
5734: 48 89 44 24 20 mov %rax,0x20(%rsp)
5739: 4e 8b 74 01 f8 mov -0x8(%rcx,%r8,1),%r14
bitD->bitContainer = MEM_readLEST(bitD->ptr);
573e: 4c 89 74 24 10 mov %r14,0x10(%rsp)
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
5743: 41 0f b6 44 08 ff movzbl -0x1(%r8,%rcx,1),%eax
5749: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
574b: 0f 84 76 01 00 00 je 58c7 <ZSTD_decompressSequences_bmi2+0x247>
5751: 4c 89 94 24 90 00 00 mov %r10,0x90(%rsp)
5758: 00
return __builtin_clz (val) ^ 31;
5759: 44 0f bd d8 bsr %eax,%r11d
575d: 41 f7 d3 not %r11d
5760: 41 83 cb e0 or $0xffffffe0,%r11d
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0; /* ensures bitsConsumed is always set */
5764: 41 83 c3 09 add $0x9,%r11d
5768: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
576d: 49 c7 c7 ec ff ff ff mov $0xffffffffffffffec,%r15
5774: 49 83 f8 88 cmp $0xffffffffffffff88,%r8
RETURN_ERROR_IF(
5778: 0f 87 58 01 00 00 ja 58d6 <ZSTD_decompressSequences_bmi2+0x256>
577e: 48 89 ac 24 80 00 00 mov %rbp,0x80(%rsp)
5785: 00
5786: 49 83 c0 f8 add $0xfffffffffffffff8,%r8
578a: e9 d3 00 00 00 jmpq 5862 <ZSTD_decompressSequences_bmi2+0x1e2>
if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
578f: 0f 29 44 24 20 movaps %xmm0,0x20(%rsp)
5794: 0f 29 44 24 10 movaps %xmm0,0x10(%rsp)
5799: 48 c7 44 24 30 00 00 movq $0x0,0x30(%rsp)
57a0: 00 00
57a2: e9 28 01 00 00 jmpq 58cf <ZSTD_decompressSequences_bmi2+0x24f>
bitD->ptr = bitD->start;
57a7: 48 89 4c 24 20 mov %rcx,0x20(%rsp)
bitD->bitContainer = *(const BYTE*)(bitD->start);
57ac: 44 0f b6 31 movzbl (%rcx),%r14d
57b0: 4c 89 74 24 10 mov %r14,0x10(%rsp)
switch(srcSize)
57b5: 49 8d 40 fe lea -0x2(%r8),%rax
57b9: 48 83 f8 05 cmp $0x5,%rax
57bd: 48 89 ac 24 80 00 00 mov %rbp,0x80(%rsp)
57c4: 00
57c5: 77 67 ja 582e <ZSTD_decompressSequences_bmi2+0x1ae>
57c7: ff 24 c5 00 00 00 00 jmpq *0x0(,%rax,8)
case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
57ce: 0f b6 41 06 movzbl 0x6(%rcx),%eax
57d2: 48 c1 e0 30 shl $0x30,%rax
57d6: 49 09 c6 or %rax,%r14
57d9: 4c 89 74 24 10 mov %r14,0x10(%rsp)
case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
57de: 0f b6 41 05 movzbl 0x5(%rcx),%eax
57e2: 48 c1 e0 28 shl $0x28,%rax
57e6: 49 01 c6 add %rax,%r14
57e9: 4c 89 74 24 10 mov %r14,0x10(%rsp)
case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
57ee: 0f b6 41 04 movzbl 0x4(%rcx),%eax
57f2: 48 c1 e0 20 shl $0x20,%rax
57f6: 49 01 c6 add %rax,%r14
57f9: 4c 89 74 24 10 mov %r14,0x10(%rsp)
case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
57fe: 0f b6 41 03 movzbl 0x3(%rcx),%eax
5802: 48 c1 e0 18 shl $0x18,%rax
5806: 49 01 c6 add %rax,%r14
5809: 4c 89 74 24 10 mov %r14,0x10(%rsp)
case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
580e: 0f b6 41 02 movzbl 0x2(%rcx),%eax
5812: 48 c1 e0 10 shl $0x10,%rax
5816: 49 01 c6 add %rax,%r14
5819: 4c 89 74 24 10 mov %r14,0x10(%rsp)
case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) << 8;
581e: 0f b6 41 01 movzbl 0x1(%rcx),%eax
5822: 48 c1 e0 08 shl $0x8,%rax
5826: 49 01 c6 add %rax,%r14
5829: 4c 89 74 24 10 mov %r14,0x10(%rsp)
{ BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
582e: 41 0f b6 44 08 ff movzbl -0x1(%r8,%rcx,1),%eax
5834: 85 c0 test %eax,%eax
bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
5836: 0f 84 8b 00 00 00 je 58c7 <ZSTD_decompressSequences_bmi2+0x247>
583c: 4c 89 94 24 90 00 00 mov %r10,0x90(%rsp)
5843: 00
return __builtin_clz (val) ^ 31;
5844: 44 0f bd d8 bsr %eax,%r11d
5848: 41 f7 d3 not %r11d
584b: 41 83 cb e0 or $0xffffffe0,%r11d
bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
584f: 41 c1 e0 03 shl $0x3,%r8d
5853: 45 29 c3 sub %r8d,%r11d
5856: 41 83 c3 49 add $0x49,%r11d
585a: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
585f: 45 31 c0 xor %r8d,%r8d
ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
5862: 4c 8b 17 mov (%rdi),%r10
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
5865: 41 8b 72 04 mov 0x4(%r10),%esi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
5869: 41 01 f3 add %esi,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
586c: 44 89 d8 mov %r11d,%eax
586f: f6 d8 neg %al
5871: c4 42 fb f7 e6 shrx %rax,%r14,%r12
5876: 44 23 24 b5 00 00 00 and 0x0(,%rsi,4),%r12d
587d: 00
bitD->bitsConsumed += nbBits;
587e: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5883: 4c 89 64 24 38 mov %r12,0x38(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
5888: 41 83 fb 40 cmp $0x40,%r11d
588c: 77 74 ja 5902 <ZSTD_decompressSequences_bmi2+0x282>
if (bitD->ptr >= bitD->limitPtr) {
588e: 49 83 f8 08 cmp $0x8,%r8
5892: 7d 4a jge 58de <ZSTD_decompressSequences_bmi2+0x25e>
if (bitD->ptr == bitD->start) {
5894: 4d 85 c0 test %r8,%r8
5897: 0f 84 c1 09 00 00 je 625e <ZSTD_decompressSequences_bmi2+0xbde>
589d: 4a 8d 34 01 lea (%rcx,%r8,1),%rsi
{ U32 nbBytes = bitD->bitsConsumed >> 3;
58a1: 44 89 d8 mov %r11d,%eax
58a4: c1 e8 03 shr $0x3,%eax
if (bitD->ptr - nbBytes < bitD->start) {
58a7: 48 29 c6 sub %rax,%rsi
58aa: 48 39 ce cmp %rcx,%rsi
58ad: 44 89 c6 mov %r8d,%esi
58b0: 0f 43 f0 cmovae %eax,%esi
bitD->ptr -= nbBytes;
58b3: 49 29 f0 sub %rsi,%r8
58b6: 4a 8d 04 01 lea (%rcx,%r8,1),%rax
58ba: 48 89 44 24 20 mov %rax,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
58bf: c1 e6 03 shl $0x3,%esi
58c2: 41 29 f3 sub %esi,%r11d
58c5: eb 2d jmp 58f4 <ZSTD_decompressSequences_bmi2+0x274>
58c7: c7 44 24 18 00 00 00 movl $0x0,0x18(%rsp)
58ce: 00
58cf: 49 c7 c7 ec ff ff ff mov $0xffffffffffffffec,%r15
58d6: 4c 89 f8 mov %r15,%rax
58d9: e9 09 09 00 00 jmpq 61e7 <ZSTD_decompressSequences_bmi2+0xb67>
bitD->ptr -= bitD->bitsConsumed >> 3;
58de: 44 89 de mov %r11d,%esi
58e1: c1 ee 03 shr $0x3,%esi
58e4: 49 29 f0 sub %rsi,%r8
58e7: 4a 8d 34 01 lea (%rcx,%r8,1),%rsi
58eb: 48 89 74 24 20 mov %rsi,0x20(%rsp)
bitD->bitsConsumed &= 7;
58f0: 41 83 e3 07 and $0x7,%r11d
58f4: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
58f9: 4e 8b 34 01 mov (%rcx,%r8,1),%r14
58fd: 4c 89 74 24 10 mov %r14,0x10(%rsp)
DStatePtr->table = dt + 1;
5902: 49 83 c2 08 add $0x8,%r10
5906: 4c 89 54 24 40 mov %r10,0x40(%rsp)
590b: 48 89 bc 24 a0 00 00 mov %rdi,0xa0(%rsp)
5912: 00
ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
5913: 4c 8b 6f 10 mov 0x10(%rdi),%r13
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
5917: 41 8b 75 04 mov 0x4(%r13),%esi
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
591b: 41 01 f3 add %esi,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
591e: 44 89 d8 mov %r11d,%eax
5921: f6 d8 neg %al
5923: c4 42 fb f7 fe shrx %rax,%r14,%r15
5928: 44 23 3c b5 00 00 00 and 0x0(,%rsi,4),%r15d
592f: 00
bitD->bitsConsumed += nbBits;
5930: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5935: 4c 89 7c 24 48 mov %r15,0x48(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
593a: 41 83 fb 40 cmp $0x40,%r11d
593e: 77 5d ja 599d <ZSTD_decompressSequences_bmi2+0x31d>
if (bitD->ptr >= bitD->limitPtr) {
5940: 49 83 f8 08 cmp $0x8,%r8
5944: 7d 33 jge 5979 <ZSTD_decompressSequences_bmi2+0x2f9>
if (bitD->ptr == bitD->start) {
5946: 4d 85 c0 test %r8,%r8
5949: 0f 84 17 09 00 00 je 6266 <ZSTD_decompressSequences_bmi2+0xbe6>
594f: 4a 8d 04 01 lea (%rcx,%r8,1),%rax
{ U32 nbBytes = bitD->bitsConsumed >> 3;
5953: 44 89 de mov %r11d,%esi
5956: c1 ee 03 shr $0x3,%esi
if (bitD->ptr - nbBytes < bitD->start) {
5959: 48 29 f0 sub %rsi,%rax
595c: 48 39 c8 cmp %rcx,%rax
595f: 44 89 c0 mov %r8d,%eax
5962: 0f 43 c6 cmovae %esi,%eax
bitD->ptr -= nbBytes;
5965: 49 29 c0 sub %rax,%r8
5968: 4a 8d 34 01 lea (%rcx,%r8,1),%rsi
596c: 48 89 74 24 20 mov %rsi,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
5971: c1 e0 03 shl $0x3,%eax
5974: 41 29 c3 sub %eax,%r11d
5977: eb 16 jmp 598f <ZSTD_decompressSequences_bmi2+0x30f>
bitD->ptr -= bitD->bitsConsumed >> 3;
5979: 44 89 d8 mov %r11d,%eax
597c: c1 e8 03 shr $0x3,%eax
597f: 49 29 c0 sub %rax,%r8
5982: 4a 8d 04 01 lea (%rcx,%r8,1),%rax
5986: 48 89 44 24 20 mov %rax,0x20(%rsp)
bitD->bitsConsumed &= 7;
598b: 41 83 e3 07 and $0x7,%r11d
598f: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5994: 4e 8b 34 01 mov (%rcx,%r8,1),%r14
5998: 4c 89 74 24 10 mov %r14,0x10(%rsp)
DStatePtr->table = dt + 1;
599d: 49 83 c5 08 add $0x8,%r13
59a1: 4c 89 6c 24 50 mov %r13,0x50(%rsp)
59a6: 48 8b 84 24 a0 00 00 mov 0xa0(%rsp),%rax
59ad: 00
ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
59ae: 48 8b 70 08 mov 0x8(%rax),%rsi
DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
59b2: 8b 46 04 mov 0x4(%rsi),%eax
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
59b5: 41 01 c3 add %eax,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
59b8: 44 89 df mov %r11d,%edi
59bb: 40 f6 df neg %dil
59be: c4 c2 c3 f7 fe shrx %rdi,%r14,%rdi
59c3: 23 3c 85 00 00 00 00 and 0x0(,%rax,4),%edi
bitD->bitsConsumed += nbBits;
59ca: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
59cf: 48 89 7c 24 58 mov %rdi,0x58(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
59d4: 41 83 fb 40 cmp $0x40,%r11d
59d8: 44 89 4c 24 04 mov %r9d,0x4(%rsp)
59dd: 77 53 ja 5a32 <ZSTD_decompressSequences_bmi2+0x3b2>
59df: 4a 8d 1c 01 lea (%rcx,%r8,1),%rbx
if (bitD->ptr >= bitD->limitPtr) {
59e3: 49 83 f8 08 cmp $0x8,%r8
59e7: 7d 2a jge 5a13 <ZSTD_decompressSequences_bmi2+0x393>
if (bitD->ptr == bitD->start) {
59e9: 4d 85 c0 test %r8,%r8
59ec: 74 44 je 5a32 <ZSTD_decompressSequences_bmi2+0x3b2>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
59ee: 45 89 de mov %r11d,%r14d
59f1: 41 c1 ee 03 shr $0x3,%r14d
if (bitD->ptr - nbBytes < bitD->start) {
59f5: 48 89 d8 mov %rbx,%rax
59f8: 4c 29 f0 sub %r14,%rax
59fb: 48 39 c8 cmp %rcx,%rax
59fe: 45 0f 43 c6 cmovae %r14d,%r8d
bitD->ptr -= nbBytes;
5a02: 4c 29 c3 sub %r8,%rbx
5a05: 48 89 5c 24 20 mov %rbx,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
5a0a: 41 c1 e0 03 shl $0x3,%r8d
5a0e: 45 29 c3 sub %r8d,%r11d
5a11: eb 12 jmp 5a25 <ZSTD_decompressSequences_bmi2+0x3a5>
bitD->ptr -= bitD->bitsConsumed >> 3;
5a13: 44 89 d8 mov %r11d,%eax
5a16: c1 e8 03 shr $0x3,%eax
5a19: 48 29 c3 sub %rax,%rbx
5a1c: 48 89 5c 24 20 mov %rbx,0x20(%rsp)
bitD->bitsConsumed &= 7;
5a21: 41 83 e3 07 and $0x7,%r11d
5a25: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5a2a: 48 8b 03 mov (%rbx),%rax
5a2d: 48 89 44 24 10 mov %rax,0x10(%rsp)
DStatePtr->table = dt + 1;
5a32: 48 83 c6 08 add $0x8,%rsi
5a36: 48 89 74 24 60 mov %rsi,0x60(%rsp)
5a3b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
__asm__("nop");
5a40: 90 nop
5a41: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a48: 00 00 00
5a4b: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a52: 00 00 00
5a55: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a5c: 00 00 00
5a5f: 90 nop
__asm__("nop");
5a60: 90 nop
5a61: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a68: 00 00 00
5a6b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
__asm__(".p2align 4");
5a70: 48 89 94 24 98 00 00 mov %rdx,0x98(%rsp)
5a77: 00
5a78: 48 8d 42 e0 lea -0x20(%rdx),%rax
5a7c: 48 89 84 24 c0 00 00 mov %rax,0xc0(%rsp)
5a83: 00
5a84: 48 8b 84 24 90 00 00 mov 0x90(%rsp),%rax
5a8b: 00
5a8c: 48 89 44 24 08 mov %rax,0x8(%rsp)
5a91: eb 4b jmp 5ade <ZSTD_decompressSequences_bmi2+0x45e>
5a93: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5a9a: 00 00 00
5a9d: 0f 1f 00 nopl (%rax)
bitD->ptr -= bitD->bitsConsumed >> 3;
5aa0: 4c 89 d8 mov %r11,%rax
5aa3: 48 c1 e8 03 shr $0x3,%rax
5aa7: 48 29 c1 sub %rax,%rcx
5aaa: 48 89 4c 24 20 mov %rcx,0x20(%rsp)
bitD->bitsConsumed &= 7;
5aaf: 41 83 e3 07 and $0x7,%r11d
5ab3: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5ab8: 48 8b 01 mov (%rcx),%rax
5abb: 48 89 44 24 10 mov %rax,0x10(%rsp)
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
5ac0: 4c 8b 64 24 38 mov 0x38(%rsp),%r12
5ac5: 4c 8b 54 24 40 mov 0x40(%rsp),%r10
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
5aca: 48 8b 74 24 60 mov 0x60(%rsp),%rsi
5acf: 48 8b 7c 24 58 mov 0x58(%rsp),%rdi
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
5ad4: 4c 8b 6c 24 50 mov 0x50(%rsp),%r13
5ad9: 4c 8b 7c 24 48 mov 0x48(%rsp),%r15
ZSTD_seqSymbol const llDInfo = seqState->stateLL.table[seqState->stateLL.state];
5ade: 43 0f b7 1c e2 movzwl (%r10,%r12,8),%ebx
5ae3: 47 0f b6 4c e2 02 movzbl 0x2(%r10,%r12,8),%r9d
5ae9: 47 0f b6 44 e2 03 movzbl 0x3(%r10,%r12,8),%r8d
5aef: 43 8b 54 e2 04 mov 0x4(%r10,%r12,8),%edx
ZSTD_seqSymbol const mlDInfo = seqState->stateML.table[seqState->stateML.state];
5af4: 0f b7 2c fe movzwl (%rsi,%rdi,8),%ebp
5af8: 0f b6 4c fe 02 movzbl 0x2(%rsi,%rdi,8),%ecx
5afd: 44 0f b6 64 fe 03 movzbl 0x3(%rsi,%rdi,8),%r12d
5b03: 44 8b 74 fe 04 mov 0x4(%rsi,%rdi,8),%r14d
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
5b08: 43 0f b7 44 fd 00 movzwl 0x0(%r13,%r15,8),%eax
5b0e: 43 0f b6 7c fd 02 movzbl 0x2(%r13,%r15,8),%edi
BYTE const totalBits = llBits+mlBits+ofBits;
5b14: 42 8d 34 09 lea (%rcx,%r9,1),%esi
ZSTD_seqSymbol const ofDInfo = seqState->stateOffb.table[seqState->stateOffb.state];
5b18: 47 0f b6 54 fd 03 movzbl 0x3(%r13,%r15,8),%r10d
5b1e: 47 8b 7c fd 04 mov 0x4(%r13,%r15,8),%r15d
5b23: 83 ff 02 cmp $0x2,%edi
5b26: 48 89 84 24 d0 00 00 mov %rax,0xd0(%rsp)
5b2d: 00
5b2e: 48 89 ac 24 c8 00 00 mov %rbp,0xc8(%rsp)
5b35: 00
if (ofBits > 1) {
5b36: 0f 82 04 02 00 00 jb 5d40 <ZSTD_decompressSequences_bmi2+0x6c0>
5b3c: 45 89 c5 mov %r8d,%r13d
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
5b3f: c4 e2 a1 f7 6c 24 10 shlx %r11,0x10(%rsp),%rbp
5b46: 89 f8 mov %edi,%eax
5b48: f6 d8 neg %al
5b4a: c4 62 fb f7 c5 shrx %rax,%rbp,%r8
bitD->bitsConsumed += nbBits;
5b4f: 41 01 fb add %edi,%r11d
5b52: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/); /* <= (ZSTD_WINDOWLOG_MAX-1) bits */
5b57: 4d 01 f8 add %r15,%r8
seqState->prevOffset[1] = seqState->prevOffset[0];
5b5a: 0f 10 44 24 68 movups 0x68(%rsp),%xmm0
5b5f: 0f 11 44 24 70 movups %xmm0,0x70(%rsp)
5b64: 4c 89 44 24 68 mov %r8,0x68(%rsp)
5b69: 40 00 fe add %dil,%sil
if (mlBits > 0)
5b6c: 84 c9 test %cl,%cl
5b6e: 74 1c je 5b8c <ZSTD_decompressSequences_bmi2+0x50c>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
5b70: c4 e2 a1 f7 44 24 10 shlx %r11,0x10(%rsp),%rax
5b77: 89 cf mov %ecx,%edi
5b79: 40 f6 df neg %dil
5b7c: c4 e2 c3 f7 c0 shrx %rdi,%rax,%rax
bitD->bitsConsumed += nbBits;
5b81: 41 01 cb add %ecx,%r11d
5b84: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
5b89: 49 01 c6 add %rax,%r14
if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))
5b8c: 40 80 fe 1f cmp $0x1f,%sil
5b90: 72 0a jb 5b9c <ZSTD_decompressSequences_bmi2+0x51c>
5b92: 41 83 fb 40 cmp $0x40,%r11d
5b96: 0f 86 46 03 00 00 jbe 5ee2 <ZSTD_decompressSequences_bmi2+0x862>
5b9c: 48 8b 74 24 10 mov 0x10(%rsp),%rsi
if (llBits > 0)
5ba1: 45 84 c9 test %r9b,%r9b
5ba4: 74 1b je 5bc1 <ZSTD_decompressSequences_bmi2+0x541>
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
5ba6: c4 e2 a1 f7 c6 shlx %r11,%rsi,%rax
5bab: 44 89 cf mov %r9d,%edi
5bae: 40 f6 df neg %dil
5bb1: c4 e2 c3 f7 c0 shrx %rdi,%rax,%rax
bitD->bitsConsumed += nbBits;
5bb6: 45 01 cb add %r9d,%r11d
5bb9: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
5bbe: 48 01 c2 add %rax,%rdx
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
5bc1: 45 01 eb add %r13d,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
5bc4: 44 89 d8 mov %r11d,%eax
5bc7: f6 d8 neg %al
5bc9: c4 e2 fb f7 c6 shrx %rax,%rsi,%rax
5bce: 44 89 e9 mov %r13d,%ecx
5bd1: 23 04 8d 00 00 00 00 and 0x0(,%rcx,4),%eax
DStatePtr->state = DInfo.nextState + lowBits;
5bd8: 48 01 d8 add %rbx,%rax
5bdb: 48 89 44 24 38 mov %rax,0x38(%rsp)
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
5be0: 45 01 e3 add %r12d,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
5be3: 44 89 d8 mov %r11d,%eax
5be6: f6 d8 neg %al
5be8: c4 e2 fb f7 c6 shrx %rax,%rsi,%rax
5bed: 44 89 e1 mov %r12d,%ecx
5bf0: 23 04 8d 00 00 00 00 and 0x0(,%rcx,4),%eax
5bf7: 48 03 84 24 c8 00 00 add 0xc8(%rsp),%rax
5bfe: 00
5bff: 48 89 44 24 58 mov %rax,0x58(%rsp)
return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
5c04: 45 01 d3 add %r10d,%r11d
return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
5c07: 44 89 d8 mov %r11d,%eax
5c0a: f6 d8 neg %al
5c0c: c4 e2 fb f7 c6 shrx %rax,%rsi,%rax
5c11: 44 89 d1 mov %r10d,%ecx
5c14: 23 04 8d 00 00 00 00 and 0x0(,%rcx,4),%eax
5c1b: 48 03 84 24 d0 00 00 add 0xd0(%rsp),%rax
5c22: 00
bitD->bitsConsumed += nbBits;
5c23: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5c28: 48 89 44 24 48 mov %rax,0x48(%rsp)
size_t const sequenceLength = sequence.litLength + sequence.matchLength;
5c2d: 4e 8d 3c 32 lea (%rdx,%r14,1),%r15
5c31: 48 8b 44 24 08 mov 0x8(%rsp),%rax
5c36: 4c 01 f8 add %r15,%rax
5c39: 48 3b 84 24 c0 00 00 cmp 0xc0(%rsp),%rax
5c40: 00
if (UNLIKELY(
5c41: 0f 87 ab 01 00 00 ja 5df2 <ZSTD_decompressSequences_bmi2+0x772>
5c47: 48 8b 8c 24 88 00 00 mov 0x88(%rsp),%rcx
5c4e: 00
5c4f: 48 8d 04 11 lea (%rcx,%rdx,1),%rax
5c53: 48 3b 84 24 80 00 00 cmp 0x80(%rsp),%rax
5c5a: 00
5c5b: 0f 87 91 01 00 00 ja 5df2 <ZSTD_decompressSequences_bmi2+0x772>
5c61: 48 8b 74 24 08 mov 0x8(%rsp),%rsi
5c66: 4c 8d 2c 16 lea (%rsi,%rdx,1),%r13
5c6a: 4c 89 ed mov %r13,%rbp
5c6d: 4c 29 c5 sub %r8,%rbp
ZSTD_memcpy(dst, src, 16);
5c70: 0f 10 01 movups (%rcx),%xmm0
5c73: 0f 11 06 movups %xmm0,(%rsi)
if (UNLIKELY(sequence.litLength > 16)) {
5c76: 48 83 fa 11 cmp $0x11,%rdx
5c7a: 0f 83 b7 01 00 00 jae 5e37 <ZSTD_decompressSequences_bmi2+0x7b7>
*litPtr = iLitEnd; /* update for next sequence */
5c80: 48 89 84 24 88 00 00 mov %rax,0x88(%rsp)
5c87: 00
if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
5c88: 4c 89 e8 mov %r13,%rax
5c8b: 4c 8b a4 24 b8 00 00 mov 0xb8(%rsp),%r12
5c92: 00
5c93: 4c 29 e0 sub %r12,%rax
5c96: 4c 39 c0 cmp %r8,%rax
5c99: 73 4d jae 5ce8 <ZSTD_decompressSequences_bmi2+0x668>
RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
5c9b: 4c 89 e8 mov %r13,%rax
5c9e: 48 2b 84 24 b0 00 00 sub 0xb0(%rsp),%rax
5ca5: 00
5ca6: 4c 39 c0 cmp %r8,%rax
5ca9: 0f 82 20 fc ff ff jb 58cf <ZSTD_decompressSequences_bmi2+0x24f>
match = dictEnd + (match - prefixStart);
5caf: 4c 29 e5 sub %r12,%rbp
5cb2: 48 8b 8c 24 a8 00 00 mov 0xa8(%rsp),%rcx
5cb9: 00
5cba: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
if (match + sequence.matchLength <= dictEnd) {
5cbe: 4a 8d 04 36 lea (%rsi,%r14,1),%rax
5cc2: 48 39 c8 cmp %rcx,%rax
5cc5: 0f 86 a5 00 00 00 jbe 5d70 <ZSTD_decompressSequences_bmi2+0x6f0>
{ size_t const length1 = dictEnd - match;
5ccb: 48 89 ea mov %rbp,%rdx
5cce: 48 f7 da neg %rdx
ZSTD_memmove(oLitEnd, match, length1);
5cd1: 4c 89 ef mov %r13,%rdi
5cd4: 4c 89 c3 mov %r8,%rbx
5cd7: e8 00 00 00 00 callq 5cdc <ZSTD_decompressSequences_bmi2+0x65c>
5cdc: 49 89 d8 mov %rbx,%r8
op = oLitEnd + length1;
5cdf: 49 29 ed sub %rbp,%r13
sequence.matchLength -= length1;
5ce2: 49 01 ee add %rbp,%r14
5ce5: 4c 89 e5 mov %r12,%rbp
if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {
5ce8: 49 83 f8 10 cmp $0x10,%r8
5cec: 0f 82 a6 01 00 00 jb 5e98 <ZSTD_decompressSequences_bmi2+0x818>
5cf2: 0f 10 45 00 movups 0x0(%rbp),%xmm0
5cf6: 41 0f 11 45 00 movups %xmm0,0x0(%r13)
if (16 >= length) return;
5cfb: 49 83 fe 11 cmp $0x11,%r14
5cff: 7c 7a jl 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
5d01: 4d 01 ee add %r13,%r14
do {
5d04: 48 83 c5 10 add $0x10,%rbp
5d08: b8 10 00 00 00 mov $0x10,%eax
5d0d: 0f 1f 00 nopl (%rax)
ZSTD_memcpy(dst, src, 16);
5d10: 0f 10 44 05 f0 movups -0x10(%rbp,%rax,1),%xmm0
5d15: 41 0f 11 44 05 00 movups %xmm0,0x0(%r13,%rax,1)
5d1b: 0f 10 44 05 00 movups 0x0(%rbp,%rax,1),%xmm0
5d20: 41 0f 11 44 05 10 movups %xmm0,0x10(%r13,%rax,1)
while (op < oend);
5d26: 4a 8d 0c 28 lea (%rax,%r13,1),%rcx
5d2a: 48 83 c1 20 add $0x20,%rcx
5d2e: 48 83 c0 20 add $0x20,%rax
5d32: 4c 39 f1 cmp %r14,%rcx
}
5d35: 72 d9 jb 5d10 <ZSTD_decompressSequences_bmi2+0x690>
5d37: eb 42 jmp 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
5d39: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
if (LIKELY((ofBits == 0))) {
5d40: 40 84 ff test %dil,%dil
5d43: 0f 85 e0 01 00 00 jne 5f29 <ZSTD_decompressSequences_bmi2+0x8a9>
5d49: 45 89 c5 mov %r8d,%r13d
U32 const ll0 = (llBase == 0);
5d4c: 85 d2 test %edx,%edx
if (LIKELY(!ll0))
5d4e: 0f 84 16 02 00 00 je 5f6a <ZSTD_decompressSequences_bmi2+0x8ea>
offset = seqState->prevOffset[0];
5d54: 4c 8b 44 24 68 mov 0x68(%rsp),%r8
5d59: 40 00 fe add %dil,%sil
if (mlBits > 0)
5d5c: 84 c9 test %cl,%cl
5d5e: 0f 85 0c fe ff ff jne 5b70 <ZSTD_decompressSequences_bmi2+0x4f0>
5d64: e9 23 fe ff ff jmpq 5b8c <ZSTD_decompressSequences_bmi2+0x50c>
5d69: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
ZSTD_memmove(oLitEnd, match, sequence.matchLength);
5d70: 4c 89 ef mov %r13,%rdi
5d73: 4c 89 f2 mov %r14,%rdx
5d76: e8 00 00 00 00 callq 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
5d7b: 8b 44 24 04 mov 0x4(%rsp),%eax
5d7f: 49 83 ff 88 cmp $0xffffffffffffff88,%r15
if (UNLIKELY(ZSTD_isError(oneSeqSize)))
5d83: 0f 87 4d fb ff ff ja 58d6 <ZSTD_decompressSequences_bmi2+0x256>
op += oneSeqSize;
5d89: 4c 01 7c 24 08 add %r15,0x8(%rsp)
5d8e: 44 8b 5c 24 18 mov 0x18(%rsp),%r11d
if (UNLIKELY(!--nbSeq))
5d93: 83 c0 ff add $0xffffffff,%eax
5d96: 0f 84 bc 03 00 00 je 6158 <ZSTD_decompressSequences_bmi2+0xad8>
5d9c: 41 83 fb 40 cmp $0x40,%r11d
5da0: 89 44 24 04 mov %eax,0x4(%rsp)
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
5da4: 0f 87 16 fd ff ff ja 5ac0 <ZSTD_decompressSequences_bmi2+0x440>
if (bitD->ptr >= bitD->limitPtr) {
5daa: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx
5daf: 48 3b 4c 24 30 cmp 0x30(%rsp),%rcx
5db4: 0f 83 e6 fc ff ff jae 5aa0 <ZSTD_decompressSequences_bmi2+0x420>
if (bitD->ptr == bitD->start) {
5dba: 48 8b 54 24 28 mov 0x28(%rsp),%rdx
5dbf: 48 39 d1 cmp %rdx,%rcx
5dc2: 0f 84 f8 fc ff ff je 5ac0 <ZSTD_decompressSequences_bmi2+0x440>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
5dc8: 4c 89 d8 mov %r11,%rax
5dcb: 48 c1 e8 03 shr $0x3,%rax
if (bitD->ptr - nbBytes < bitD->start) {
5dcf: 48 89 ce mov %rcx,%rsi
5dd2: 48 29 c6 sub %rax,%rsi
5dd5: 89 cf mov %ecx,%edi
5dd7: 29 d7 sub %edx,%edi
5dd9: 48 39 d6 cmp %rdx,%rsi
5ddc: 0f 43 f8 cmovae %eax,%edi
bitD->ptr -= nbBytes;
5ddf: 48 29 f9 sub %rdi,%rcx
5de2: 48 89 4c 24 20 mov %rcx,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
5de7: c1 e7 03 shl $0x3,%edi
5dea: 41 29 fb sub %edi,%r11d
5ded: e9 c1 fc ff ff jmpq 5ab3 <ZSTD_decompressSequences_bmi2+0x433>
5df2: 48 8b 7c 24 08 mov 0x8(%rsp),%rdi
5df7: 48 8b b4 24 98 00 00 mov 0x98(%rsp),%rsi
5dfe: 00
return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
5dff: 4c 89 f1 mov %r14,%rcx
5e02: 4c 8d 8c 24 88 00 00 lea 0x88(%rsp),%r9
5e09: 00
5e0a: ff b4 24 a8 00 00 00 pushq 0xa8(%rsp)
5e11: ff b4 24 b8 00 00 00 pushq 0xb8(%rsp)
5e18: ff b4 24 c8 00 00 00 pushq 0xc8(%rsp)
5e1f: ff b4 24 98 00 00 00 pushq 0x98(%rsp)
5e26: e8 55 ee ff ff callq 4c80 <ZSTD_execSequenceEnd>
5e2b: 48 83 c4 20 add $0x20,%rsp
5e2f: 49 89 c7 mov %rax,%r15
5e32: e9 44 ff ff ff jmpq 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
5e37: 48 83 c2 f0 add $0xfffffffffffffff0,%rdx
ZSTD_memcpy(dst, src, 16);
5e3b: 0f 10 41 10 movups 0x10(%rcx),%xmm0
5e3f: 48 8b 74 24 08 mov 0x8(%rsp),%rsi
5e44: 0f 11 46 10 movups %xmm0,0x10(%rsi)
if (16 >= length) return;
5e48: 48 83 fa 11 cmp $0x11,%rdx
5e4c: 0f 8c 2e fe ff ff jl 5c80 <ZSTD_decompressSequences_bmi2+0x600>
5e52: 48 8b 54 24 08 mov 0x8(%rsp),%rdx
op += 16;
5e57: 48 83 c2 20 add $0x20,%rdx
do {
5e5b: 48 83 c1 30 add $0x30,%rcx
5e5f: 31 f6 xor %esi,%esi
5e61: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
5e68: 00 00 00
5e6b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
ZSTD_memcpy(dst, src, 16);
5e70: 0f 10 44 31 f0 movups -0x10(%rcx,%rsi,1),%xmm0
5e75: 0f 11 04 32 movups %xmm0,(%rdx,%rsi,1)
5e79: 0f 10 04 31 movups (%rcx,%rsi,1),%xmm0
5e7d: 0f 11 44 32 10 movups %xmm0,0x10(%rdx,%rsi,1)
while (op < oend);
5e82: 48 8d 3c 32 lea (%rdx,%rsi,1),%rdi
5e86: 48 83 c7 20 add $0x20,%rdi
5e8a: 48 83 c6 20 add $0x20,%rsi
5e8e: 4c 39 ef cmp %r13,%rdi
}
5e91: 72 dd jb 5e70 <ZSTD_decompressSequences_bmi2+0x7f0>
5e93: e9 e8 fd ff ff jmpq 5c80 <ZSTD_decompressSequences_bmi2+0x600>
if (offset < 8) {
5e98: 49 83 f8 07 cmp $0x7,%r8
5e9c: 0f 87 d7 00 00 00 ja 5f79 <ZSTD_decompressSequences_bmi2+0x8f9>
int const sub2 = dec64table[offset];
5ea2: 4a 63 04 85 00 00 00 movslq 0x0(,%r8,4),%rax
5ea9: 00
(*op)[0] = (*ip)[0];
5eaa: 8a 4d 00 mov 0x0(%rbp),%cl
5ead: 41 88 4d 00 mov %cl,0x0(%r13)
(*op)[1] = (*ip)[1];
5eb1: 8a 4d 01 mov 0x1(%rbp),%cl
5eb4: 41 88 4d 01 mov %cl,0x1(%r13)
(*op)[2] = (*ip)[2];
5eb8: 8a 4d 02 mov 0x2(%rbp),%cl
5ebb: 41 88 4d 02 mov %cl,0x2(%r13)
(*op)[3] = (*ip)[3];
5ebf: 8a 4d 03 mov 0x3(%rbp),%cl
5ec2: 41 88 4d 03 mov %cl,0x3(%r13)
*ip += dec32table[offset];
5ec6: 42 8b 0c 85 00 00 00 mov 0x0(,%r8,4),%ecx
5ecd: 00
5ece: 48 8d 34 29 lea (%rcx,%rbp,1),%rsi
*ip -= sub2;
5ed2: 48 29 c6 sub %rax,%rsi
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
5ed5: 8b 44 0d 00 mov 0x0(%rbp,%rcx,1),%eax
5ed9: 41 89 45 04 mov %eax,0x4(%r13)
5edd: e9 a2 00 00 00 jmpq 5f84 <ZSTD_decompressSequences_bmi2+0x904>
if (bitD->ptr >= bitD->limitPtr) {
5ee2: 48 8b 74 24 20 mov 0x20(%rsp),%rsi
5ee7: 48 3b 74 24 30 cmp 0x30(%rsp),%rsi
5eec: 0f 83 dc 00 00 00 jae 5fce <ZSTD_decompressSequences_bmi2+0x94e>
if (bitD->ptr == bitD->start) {
5ef2: 48 8b 7c 24 28 mov 0x28(%rsp),%rdi
5ef7: 48 39 fe cmp %rdi,%rsi
5efa: 0f 84 9c fc ff ff je 5b9c <ZSTD_decompressSequences_bmi2+0x51c>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
5f00: 44 89 d8 mov %r11d,%eax
5f03: c1 e8 03 shr $0x3,%eax
if (bitD->ptr - nbBytes < bitD->start) {
5f06: 48 89 f5 mov %rsi,%rbp
5f09: 48 29 c5 sub %rax,%rbp
5f0c: 89 f1 mov %esi,%ecx
5f0e: 29 f9 sub %edi,%ecx
5f10: 48 39 fd cmp %rdi,%rbp
5f13: 0f 43 c8 cmovae %eax,%ecx
bitD->ptr -= nbBytes;
5f16: 48 29 ce sub %rcx,%rsi
5f19: 48 89 74 24 20 mov %rsi,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
5f1e: c1 e1 03 shl $0x3,%ecx
5f21: 41 29 cb sub %ecx,%r11d
5f24: e9 b7 00 00 00 jmpq 5fe0 <ZSTD_decompressSequences_bmi2+0x960>
offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
5f29: 83 fa 01 cmp $0x1,%edx
5f2c: 41 83 d7 00 adc $0x0,%r15d
return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
5f30: c4 62 a1 f7 6c 24 10 shlx %r11,0x10(%rsp),%r13
5f37: 49 c1 ed 3f shr $0x3f,%r13
bitD->bitsConsumed += nbBits;
5f3b: 41 83 c3 01 add $0x1,%r11d
5f3f: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5f44: 4d 01 fd add %r15,%r13
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
5f47: 49 83 fd 03 cmp $0x3,%r13
5f4b: 0f 85 a1 00 00 00 jne 5ff2 <ZSTD_decompressSequences_bmi2+0x972>
5f51: 45 89 c5 mov %r8d,%r13d
5f54: 4c 8b 44 24 68 mov 0x68(%rsp),%r8
5f59: 49 83 c0 ff add $0xffffffffffffffff,%r8
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
5f5d: 49 83 f8 01 cmp $0x1,%r8
5f61: 49 83 d0 00 adc $0x0,%r8
5f65: e9 a1 00 00 00 jmpq 600b <ZSTD_decompressSequences_bmi2+0x98b>
seqState->prevOffset[1] = seqState->prevOffset[0];
5f6a: 48 8b 44 24 68 mov 0x68(%rsp),%rax
offset = seqState->prevOffset[1];
5f6f: 4c 8b 44 24 70 mov 0x70(%rsp),%r8
5f74: e9 a1 00 00 00 jmpq 601a <ZSTD_decompressSequences_bmi2+0x99a>
ZSTD_memcpy(dst, src, 8);
5f79: 48 8b 45 00 mov 0x0(%rbp),%rax
5f7d: 49 89 45 00 mov %rax,0x0(%r13)
*ip += 8;
5f81: 48 89 ee mov %rbp,%rsi
if (sequence.matchLength > 8) {
5f84: 49 83 fe 09 cmp $0x9,%r14
5f88: 0f 82 ed fd ff ff jb 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
5f8e: 48 8d 4e 08 lea 0x8(%rsi),%rcx
5f92: 49 8d 55 08 lea 0x8(%r13),%rdx
ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
5f96: 48 89 d7 mov %rdx,%rdi
5f99: 48 29 cf sub %rcx,%rdi
BYTE* const oend = op + length;
5f9c: 4f 8d 1c 2e lea (%r14,%r13,1),%r11
5fa0: 48 83 ff 0f cmp $0xf,%rdi
if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
5fa4: 7f 7e jg 6024 <ZSTD_decompressSequences_bmi2+0x9a4>
do {
5fa6: 49 8d 7d 10 lea 0x10(%r13),%rdi
5faa: 49 39 fb cmp %rdi,%r11
5fad: 49 89 fa mov %rdi,%r10
5fb0: 4d 0f 47 d3 cmova %r11,%r10
5fb4: 4d 29 ea sub %r13,%r10
5fb7: 49 83 c2 f7 add $0xfffffffffffffff7,%r10
5fbb: 49 83 fa 18 cmp $0x18,%r10
5fbf: 0f 83 a6 00 00 00 jae 606b <ZSTD_decompressSequences_bmi2+0x9eb>
5fc5: 8b 44 24 04 mov 0x4(%rsp),%eax
5fc9: e9 72 01 00 00 jmpq 6140 <ZSTD_decompressSequences_bmi2+0xac0>
bitD->ptr -= bitD->bitsConsumed >> 3;
5fce: 44 89 d8 mov %r11d,%eax
5fd1: c1 e8 03 shr $0x3,%eax
5fd4: 48 29 c6 sub %rax,%rsi
5fd7: 48 89 74 24 20 mov %rsi,0x20(%rsp)
bitD->bitsConsumed &= 7;
5fdc: 41 83 e3 07 and $0x7,%r11d
5fe0: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
5fe5: 48 8b 06 mov (%rsi),%rax
5fe8: 48 89 44 24 10 mov %rax,0x10(%rsp)
5fed: e9 aa fb ff ff jmpq 5b9c <ZSTD_decompressSequences_bmi2+0x51c>
5ff2: 4d 89 ef mov %r13,%r15
5ff5: 45 89 c5 mov %r8d,%r13d
{ size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];
5ff8: 4e 8b 44 fc 68 mov 0x68(%rsp,%r15,8),%r8
temp += !temp; /* 0 is not valid; input is corrupted; force offset to 1 */
5ffd: 49 83 f8 01 cmp $0x1,%r8
6001: 49 83 d0 00 adc $0x0,%r8
if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];
6005: 49 83 ff 01 cmp $0x1,%r15
6009: 74 0a je 6015 <ZSTD_decompressSequences_bmi2+0x995>
600b: 48 8b 44 24 70 mov 0x70(%rsp),%rax
6010: 48 89 44 24 78 mov %rax,0x78(%rsp)
seqState->prevOffset[1] = seqState->prevOffset[0];
6015: 48 8b 44 24 68 mov 0x68(%rsp),%rax
601a: 48 89 44 24 70 mov %rax,0x70(%rsp)
601f: e9 40 fb ff ff jmpq 5b64 <ZSTD_decompressSequences_bmi2+0x4e4>
ZSTD_memcpy(dst, src, 16);
6024: 0f 10 01 movups (%rcx),%xmm0
6027: 0f 11 02 movups %xmm0,(%rdx)
if (16 >= length) return;
602a: 49 83 fe 19 cmp $0x19,%r14
602e: 0f 8c 47 fd ff ff jl 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
op += 16;
6034: 49 83 c5 18 add $0x18,%r13
do {
6038: 48 83 c6 28 add $0x28,%rsi
603c: 31 c9 xor %ecx,%ecx
603e: 66 90 xchg %ax,%ax
ZSTD_memcpy(dst, src, 16);
6040: 0f 10 44 0e f0 movups -0x10(%rsi,%rcx,1),%xmm0
6045: 41 0f 11 44 0d 00 movups %xmm0,0x0(%r13,%rcx,1)
604b: 0f 10 04 0e movups (%rsi,%rcx,1),%xmm0
604f: 41 0f 11 44 0d 10 movups %xmm0,0x10(%r13,%rcx,1)
while (op < oend);
6055: 4a 8d 14 29 lea (%rcx,%r13,1),%rdx
6059: 48 83 c2 20 add $0x20,%rdx
605d: 48 83 c1 20 add $0x20,%rcx
6061: 4c 39 da cmp %r11,%rdx
}
6064: 72 da jb 6040 <ZSTD_decompressSequences_bmi2+0x9c0>
6066: e9 10 fd ff ff jmpq 5d7b <ZSTD_decompressSequences_bmi2+0x6fb>
do {
606b: 49 39 fb cmp %rdi,%r11
606e: 49 0f 47 fb cmova %r11,%rdi
6072: 4c 29 ef sub %r13,%rdi
6075: 48 83 c7 f7 add $0xfffffffffffffff7,%rdi
6079: 48 83 e7 f8 and $0xfffffffffffffff8,%rdi
607d: 48 8d 2c 3e lea (%rsi,%rdi,1),%rbp
6081: 48 83 c5 10 add $0x10,%rbp
6085: 48 39 ea cmp %rbp,%rdx
6088: 73 15 jae 609f <ZSTD_decompressSequences_bmi2+0xa1f>
608a: 4c 01 ef add %r13,%rdi
608d: 48 83 c7 10 add $0x10,%rdi
6091: 48 39 f9 cmp %rdi,%rcx
6094: 73 09 jae 609f <ZSTD_decompressSequences_bmi2+0xa1f>
6096: 8b 44 24 04 mov 0x4(%rsp),%eax
609a: e9 a1 00 00 00 jmpq 6140 <ZSTD_decompressSequences_bmi2+0xac0>
609f: 49 c1 ea 03 shr $0x3,%r10
60a3: 49 83 c2 01 add $0x1,%r10
60a7: 4d 89 d0 mov %r10,%r8
60aa: 49 83 e0 fc and $0xfffffffffffffffc,%r8
60ae: 49 8d 78 fc lea -0x4(%r8),%rdi
60b2: 49 89 f9 mov %rdi,%r9
60b5: 49 c1 e9 02 shr $0x2,%r9
60b9: 49 83 c1 01 add $0x1,%r9
60bd: 48 85 ff test %rdi,%rdi
60c0: 8b 44 24 04 mov 0x4(%rsp),%eax
60c4: 74 44 je 610a <ZSTD_decompressSequences_bmi2+0xa8a>
60c6: 4c 89 cf mov %r9,%rdi
60c9: 48 83 e7 fe and $0xfffffffffffffffe,%rdi
60cd: 48 f7 df neg %rdi
60d0: 31 ed xor %ebp,%ebp
ZSTD_memcpy(dst, src, 8);
60d2: 0f 10 44 ee 08 movups 0x8(%rsi,%rbp,8),%xmm0
60d7: 0f 10 4c ee 18 movups 0x18(%rsi,%rbp,8),%xmm1
60dc: 41 0f 11 44 ed 08 movups %xmm0,0x8(%r13,%rbp,8)
60e2: 41 0f 11 4c ed 18 movups %xmm1,0x18(%r13,%rbp,8)
60e8: 0f 10 44 ee 28 movups 0x28(%rsi,%rbp,8),%xmm0
60ed: 0f 10 4c ee 38 movups 0x38(%rsi,%rbp,8),%xmm1
60f2: 41 0f 11 44 ed 28 movups %xmm0,0x28(%r13,%rbp,8)
60f8: 41 0f 11 4c ed 38 movups %xmm1,0x38(%r13,%rbp,8)
60fe: 48 83 c5 08 add $0x8,%rbp
6102: 48 83 c7 02 add $0x2,%rdi
6106: 75 ca jne 60d2 <ZSTD_decompressSequences_bmi2+0xa52>
6108: eb 02 jmp 610c <ZSTD_decompressSequences_bmi2+0xa8c>
610a: 31 ed xor %ebp,%ebp
610c: 41 f6 c1 01 test $0x1,%r9b
6110: 74 12 je 6124 <ZSTD_decompressSequences_bmi2+0xaa4>
6112: 0f 10 04 e9 movups (%rcx,%rbp,8),%xmm0
6116: 0f 10 4c e9 10 movups 0x10(%rcx,%rbp,8),%xmm1
611b: 0f 11 04 ea movups %xmm0,(%rdx,%rbp,8)
611f: 0f 11 4c ea 10 movups %xmm1,0x10(%rdx,%rbp,8)
} while (op < oend);
6124: 4d 39 c2 cmp %r8,%r10
6127: 0f 84 52 fc ff ff je 5d7f <ZSTD_decompressSequences_bmi2+0x6ff>
612d: 4a 8d 14 c2 lea (%rdx,%r8,8),%rdx
6131: 4a 8d 0c c1 lea (%rcx,%r8,8),%rcx
6135: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
613c: 00 00 00
613f: 90 nop
ZSTD_memcpy(dst, src, 8);
6140: 48 8b 31 mov (%rcx),%rsi
6143: 48 89 32 mov %rsi,(%rdx)
COPY8(op, ip)
6146: 48 83 c2 08 add $0x8,%rdx
614a: 48 83 c1 08 add $0x8,%rcx
} while (op < oend);
614e: 4c 39 da cmp %r11,%rdx
6151: 72 ed jb 6140 <ZSTD_decompressSequences_bmi2+0xac0>
6153: e9 27 fc ff ff jmpq 5d7f <ZSTD_decompressSequences_bmi2+0x6ff>
6158: 41 83 fb 40 cmp $0x40,%r11d
615c: 48 8b ac 24 80 00 00 mov 0x80(%rsp),%rbp
6163: 00
6164: 48 8b 94 24 98 00 00 mov 0x98(%rsp),%rdx
616b: 00
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
616c: 0f 86 87 00 00 00 jbe 61f9 <ZSTD_decompressSequences_bmi2+0xb79>
{ U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
6172: 8b 44 24 68 mov 0x68(%rsp),%eax
6176: 48 8b 8c 24 a0 00 00 mov 0xa0(%rsp),%rcx
617d: 00
617e: 89 81 3c 68 00 00 mov %eax,0x683c(%rcx)
6184: 8b 44 24 70 mov 0x70(%rsp),%eax
6188: 89 81 40 68 00 00 mov %eax,0x6840(%rcx)
618e: 8b 44 24 78 mov 0x78(%rsp),%eax
6192: 89 81 44 68 00 00 mov %eax,0x6844(%rcx)
{ size_t const lastLLSize = litEnd - litPtr;
6198: 48 8b b4 24 88 00 00 mov 0x88(%rsp),%rsi
619f: 00
61a0: 4c 8b 94 24 90 00 00 mov 0x90(%rsp),%r10
61a7: 00
61a8: 48 29 f5 sub %rsi,%rbp
RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
61ab: 48 2b 54 24 08 sub 0x8(%rsp),%rdx
61b0: 48 c7 c0 ba ff ff ff mov $0xffffffffffffffba,%rax
61b7: 48 39 d5 cmp %rdx,%rbp
61ba: 77 2b ja 61e7 <ZSTD_decompressSequences_bmi2+0xb67>
if (op != NULL) {
61bc: 48 83 7c 24 08 00 cmpq $0x0,0x8(%rsp)
61c2: 74 1e je 61e2 <ZSTD_decompressSequences_bmi2+0xb62>
61c4: 48 8b 5c 24 08 mov 0x8(%rsp),%rbx
ZSTD_memcpy(op, litPtr, lastLLSize);
61c9: 48 89 df mov %rbx,%rdi
61cc: 48 89 ea mov %rbp,%rdx
61cf: 4d 89 d6 mov %r10,%r14
61d2: e8 00 00 00 00 callq 61d7 <ZSTD_decompressSequences_bmi2+0xb57>
61d7: 4d 89 f2 mov %r14,%r10
op += lastLLSize;
61da: 48 01 eb add %rbp,%rbx
61dd: 48 89 d8 mov %rbx,%rax
61e0: eb 02 jmp 61e4 <ZSTD_decompressSequences_bmi2+0xb64>
61e2: 31 c0 xor %eax,%eax
return op-ostart;
61e4: 4c 29 d0 sub %r10,%rax
return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
61e7: 48 81 c4 d8 00 00 00 add $0xd8,%rsp
61ee: 5b pop %rbx
61ef: 41 5c pop %r12
61f1: 41 5d pop %r13
61f3: 41 5e pop %r14
61f5: 41 5f pop %r15
61f7: 5d pop %rbp
61f8: c3 retq
if (bitD->ptr >= bitD->limitPtr) {
61f9: 48 8b 4c 24 20 mov 0x20(%rsp),%rcx
61fe: 48 3b 4c 24 30 cmp 0x30(%rsp),%rcx
6203: 73 34 jae 6239 <ZSTD_decompressSequences_bmi2+0xbb9>
6205: 48 89 e8 mov %rbp,%rax
if (bitD->ptr == bitD->start) {
6208: 48 8b 6c 24 28 mov 0x28(%rsp),%rbp
620d: 48 39 e9 cmp %rbp,%rcx
6210: 74 5c je 626e <ZSTD_decompressSequences_bmi2+0xbee>
{ U32 nbBytes = bitD->bitsConsumed >> 3;
6212: 4c 89 d8 mov %r11,%rax
6215: 48 c1 e8 03 shr $0x3,%rax
if (bitD->ptr - nbBytes < bitD->start) {
6219: 48 89 ce mov %rcx,%rsi
621c: 48 29 c6 sub %rax,%rsi
621f: 89 cf mov %ecx,%edi
6221: 29 ef sub %ebp,%edi
6223: 48 39 ee cmp %rbp,%rsi
6226: 0f 43 f8 cmovae %eax,%edi
bitD->ptr -= nbBytes;
6229: 48 29 f9 sub %rdi,%rcx
622c: 48 89 4c 24 20 mov %rcx,0x20(%rsp)
bitD->bitsConsumed -= nbBytes*8;
6231: c1 e7 03 shl $0x3,%edi
6234: 41 29 fb sub %edi,%r11d
6237: eb 13 jmp 624c <ZSTD_decompressSequences_bmi2+0xbcc>
bitD->ptr -= bitD->bitsConsumed >> 3;
6239: 4c 89 d8 mov %r11,%rax
623c: 48 c1 e8 03 shr $0x3,%rax
6240: 48 29 c1 sub %rax,%rcx
6243: 48 89 4c 24 20 mov %rcx,0x20(%rsp)
bitD->bitsConsumed &= 7;
6248: 41 83 e3 07 and $0x7,%r11d
624c: 44 89 5c 24 18 mov %r11d,0x18(%rsp)
6251: 48 8b 01 mov (%rcx),%rax
6254: 48 89 44 24 10 mov %rax,0x10(%rsp)
6259: e9 71 f6 ff ff jmpq 58cf <ZSTD_decompressSequences_bmi2+0x24f>
625e: 45 31 c0 xor %r8d,%r8d
6261: e9 9c f6 ff ff jmpq 5902 <ZSTD_decompressSequences_bmi2+0x282>
6266: 45 31 c0 xor %r8d,%r8d
6269: e9 2f f7 ff ff jmpq 599d <ZSTD_decompressSequences_bmi2+0x31d>
626e: 49 c7 c7 ec ff ff ff mov $0xffffffffffffffec,%r15
if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
6275: 41 83 fb 40 cmp $0x40,%r11d
6279: 48 89 c5 mov %rax,%rbp
627c: 0f 82 54 f6 ff ff jb 58d6 <ZSTD_decompressSequences_bmi2+0x256>
6282: e9 eb fe ff ff jmpq 6172 <ZSTD_decompressSequences_bmi2+0xaf2>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment