Created
May 29, 2021 17:51
-
-
Save danlark1/62390556e36f6c1cb227734034cfcf33 to your computer and use it in GitHub Desktop.
clang_objdump
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
zstd_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