name string | code string | asm string | file string |
|---|---|---|---|
ZSTD_getLowestMatchIndex | MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.lowLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 const... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x16e62b
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_fillHashTable | void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
const void* const end,
ZSTD_dictTableLoadMethod_e dtlm)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashTable = ms->hashTable;
U32 const hBits = cParams->hashLog;
U32 const m... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x44(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x5... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_fast.c |
ZSTD_compressBlock_fast | size_t ZSTD_compressBlock_fast(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
U32 const mls = ms->cParams.minMatch;
assert(ms->dictMatchState == NULL);
switch(mls)
{
default: /* includes case 3 */
case 4 :
return ZS... | pushq %rbp
movq %rsp, %rbp
subq $0xca0, %rsp # imm = 0xCA0
movq %rdi, -0xa90(%rbp)
movq %rsi, -0xa98(%rbp)
movq %rdx, -0xaa0(%rbp)
movq %rcx, -0xaa8(%rbp)
movq %r8, -0xab0(%rbp)
movq -0xa90(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0xab4(%rbp)
movl -0xab4(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_fast.c |
ZSTD_compressBlock_fast_dictMatchState | size_t ZSTD_compressBlock_fast_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
U32 const mls = ms->cParams.minMatch;
assert(ms->dictMatchState != NULL);
switch(mls)
{
default: /* includes case 3 */
case 4 :
... | pushq %rbp
movq %rsp, %rbp
subq $0x1240, %rsp # imm = 0x1240
movq %rdi, -0xf90(%rbp)
movq %rsi, -0xf98(%rbp)
movq %rdx, -0xfa0(%rbp)
movq %rcx, -0xfa8(%rbp)
movq %r8, -0xfb0(%rbp)
movq -0xf90(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0xfb4(%rbp)
movl -0xfb4(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_fast.c |
ZSTD_compressBlock_fast_extDict | size_t ZSTD_compressBlock_fast_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
U32 const mls = ms->cParams.minMatch;
switch(mls)
{
default: /* includes case 3 */
case 4 :
return ZSTD_compressBlock_fast_extDict_ge... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x3, %ea... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_fast.c |
ZSTD_compressBlock_fast_extDict_generic | static size_t ZSTD_compressBlock_fast_extDict_generic(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize, U32 const mls)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashTable = ms->hashTable;
U32 const hlog = ... | pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp # imm = 0x6F0
movq %rdi, -0x490(%rbp)
movq %rsi, -0x498(%rbp)
movq %rdx, -0x4a0(%rbp)
movq %rcx, -0x4a8(%rbp)
movq %r8, -0x4b0(%rbp)
movl %r9d, -0x4b4(%rbp)
movq -0x490(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x4c0(%rbp)
movq -0x490(%rbp), %rax
movq 0x60(%rax), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_fast.c |
MEM_swap64 | MEM_STATIC U64 MEM_swap64(U64 in)
{
#if defined(_MSC_VER) /* Visual Studio */
return _byteswap_uint64(in);
#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap64))
return __builtin_bswap64(in);
#else
return ((in << 56) & 0xff... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
bswapq %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/mem.h |
ZSTD_getLowestPrefixIndex | MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.dictLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 con... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x17daeb
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_NbCommonBytes | static unsigned ZSTD_NbCommonBytes (size_t val)
{
if (MEM_isLittleEndian()) {
if (MEM_64bits()) {
# if defined(_MSC_VER) && defined(_WIN64)
# if STATIC_BMI2
return _tzcnt_u64(val) >> 3;
# else
unsigned long r = 0;
return _BitScanForwa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x17d9c0
cmpl $0x0, %eax
je 0x17dd81
callq 0x17ddc0
cmpl $0x0, %eax
je 0x17dd71
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x17ddaf
movq -0x10(%rbp), %rax
tzcntl %eax, %eax
sarl $0x3, %eax
movl %eax, -0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_count_2segments | MEM_STATIC size_t
ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
{
const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
size_t const matchLength = ZSTD_count(ip, match, vEnd);
if (match + matchLength != mEnd) return m... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x17e02c
movq -0x10(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_getLowestMatchIndex | MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.lowLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 const... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x17e0db
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_dedicatedDictSearch_lazy_loadDictionary | void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip)
{
const BYTE* const base = ms->window.base;
U32 const target = (U32)(ip - base);
U32* const hashTable = ms->hashTable;
U32* const chainTable = ms->chainTable;
U32 const chainSize = 1 << ms->cParams.chainLo... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x38... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_insertAndFindFirstIndex | U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
const ZSTD_compressionParameters* const cParams = &ms->cParams;
return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x90(%rbp)
movq %rsi, -0x98(%rbp)
movq -0x90(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rax
movl 0x100(%rax), %eax
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_compressBlock_lazy_extDict | size_t ZSTD_compressBlock_lazy_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x2f0(%rbp)
movq %rsi, -0x2f8(%rbp)
movq %rdx, -0x300(%rbp)
movq %rcx, -0x308(%rbp)
movq %r8, -0x310(%rbp)
movq -0x2f0(%rbp), %rdi
movq -0x2f8(%rbp), %rsi
movq -0x300(%rbp), %rdx
movq -0x308(%rbp), %rcx
movq -0x310(%rbp), %rax
movq %rdi, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_compressBlock_lazy2_extDict | size_t ZSTD_compressBlock_lazy2_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);
} | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x2f0(%rbp)
movq %rsi, -0x2f8(%rbp)
movq %rdx, -0x300(%rbp)
movq %rcx, -0x308(%rbp)
movq %r8, -0x310(%rbp)
movq -0x2f0(%rbp), %rdi
movq -0x2f8(%rbp), %rsi
movq -0x300(%rbp), %rdx
movq -0x308(%rbp), %rcx
movq -0x310(%rbp), %rax
movq %rdi, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_compressBlock_btlazy2_extDict | size_t ZSTD_compressBlock_btlazy2_extDict(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);
} | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x2f0(%rbp)
movq %rsi, -0x2f8(%rbp)
movq %rdx, -0x300(%rbp)
movq %rcx, -0x308(%rbp)
movq %r8, -0x310(%rbp)
movq -0x2f0(%rbp), %rdi
movq -0x2f8(%rbp), %rsi
movq -0x300(%rbp), %rdx
movq -0x308(%rbp), %rcx
movq -0x310(%rbp), %rax
movq %rdi, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_compressBlock_lazy_extDict_row | size_t ZSTD_compressBlock_lazy_extDict_row(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x3e0, %rsp # imm = 0x3E0
movq %rdi, -0x2f0(%rbp)
movq %rsi, -0x2f8(%rbp)
movq %rdx, -0x300(%rbp)
movq %rcx, -0x308(%rbp)
movq %r8, -0x310(%rbp)
movq -0x2f0(%rbp), %rdi
movq -0x2f8(%rbp), %rsi
movq -0x300(%rbp), %rdx
movq -0x308(%rbp), %rcx
movq -0x310(%rbp), %rax
movq %rdi, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_BtFindBestMatch_selectMLS | static size_t
ZSTD_BtFindBestMatch_selectMLS ( ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr)
{
switch(ms->cParams.minMatch)
{
default : /* includes case 3 */
case 4 : return ZSTD_BtFindBestMatch(ms, ip, ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rsi, -0xa8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq -0xa0(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0xbc(%rbp)
subl $0x4, %eax
je 0x1b3ca8
jmp 0x1b3c81
movl -0xbc(%rbp), %eax
subl $0x5, %eax
je 0x1b3d4c
jmp 0x1b3c92
movl -0xbc... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_HcFindBestMatch_dictMatchState_selectMLS | static size_t ZSTD_HcFindBestMatch_dictMatchState_selectMLS (
ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr)
{
switch(ms->cParams.minMatch)
{
default : /* includes case 3 */
case 4 : return ZSTD_... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x918, %rsp # imm = 0x918
movq %rdi, -0x7c8(%rbp)
movq %rsi, -0x7d0(%rbp)
movq %rdx, -0x7d8(%rbp)
movq %rcx, -0x7e0(%rbp)
movq -0x7c8(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x7e4(%rbp)
subl $0x4, %eax
je 0x1bed19
jmp 0x1becf2
movl -0x7e4(%rbp), %eax
subl $0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_BtFindBestMatch_dictMatchState_selectMLS | static size_t ZSTD_BtFindBestMatch_dictMatchState_selectMLS (
ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr)
{
switch(ms->cParams.minMatch)
{
default : /* includes case 3 */
case 4 : return ZSTD_... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rsi, -0xa8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq -0xa0(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0xbc(%rbp)
subl $0x4, %eax
je 0x1c20a8
jmp 0x1c2081
movl -0xbc(%rbp), %eax
subl $0x5, %eax
je 0x1c214c
jmp 0x1c2092
movl -0xbc... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_getLowestPrefixIndex | MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.dictLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 con... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x1db26b
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_row_fillHashCache | static void ZSTD_row_fillHashCache(ZSTD_matchState_t* ms, const BYTE* base,
U32 const rowLog, U32 const mls,
U32 idx, const BYTE* const iLimit)
{
U32 const* const hashTable = ms->hashTable;
U16 const* const tagTable = ms->tagTable;
U32 co... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x44(%rbp)
movl %ecx, -0x48(%rbp)
movl %r8d, -0x4c(%rbp)
movq %r9, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x68(%rbp)
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_count_2segments | MEM_STATIC size_t
ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
{
const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
size_t const matchLength = ZSTD_count(ip, match, vEnd);
if (match + matchLength != mEnd) return m... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x1db4fc
movq -0x10(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_count | MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
{
const BYTE* const pStart = pIn;
const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
if (pIn < pInLoopLimit) {
{ size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
if (diff) r... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $-0x7, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1db67a
movq -0x18(%rbp), %rdi
callq 0x1dcd70
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_highbit32 | MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */
{
assert(val != 0);
{
# if defined(_MSC_VER) /* Visual */
# if STATIC_BMI2 == 1
return _lzcnt_u32(val)^31;
# else
unsigned long r=0;
return _BitScanReverse(&r, val) ? (unsigned)... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bsrl %eax, %eax
xorl $0x1f, %eax
xorl $0x1f, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/zstd_internal.h |
ZSTD_DUBT_findBestMatch | static size_t
ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend,
size_t* offsetPtr,
U32 const mls,
const ZSTD_dictMode_e dictMode)
{
const ZSTD_compressionParameters* const cPara... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x3c(%rbp)
movl %r9d, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_getLowestMatchIndex | MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.lowLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 const... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x1dc1ab
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_insertDUBT1 | static void
ZSTD_insertDUBT1(ZSTD_matchState_t* ms,
U32 curr, const BYTE* inputEnd,
U32 nbCompares, U32 btLow,
const ZSTD_dictMode_e dictMode)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const bt = ms->chainTable;
U32 const btLog... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %ra... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_DUBT_findBetterDictMatch | static size_t
ZSTD_DUBT_findBetterDictMatch (
ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend,
size_t* offsetPtr,
size_t bestLength,
U32 nbCompares,
U32 const mls,
const ZSTD_dictMode_e dictMode)
{
const ZSTD_matchState_t * const dms = ms->... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x50(%rbp)
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_VecMask_next | static U32 ZSTD_VecMask_next(ZSTD_VecMask val) {
# if defined(_MSC_VER) /* Visual */
unsigned long r=0;
return _BitScanForward(&r, val) ? (U32)r : 0;
# elif defined(__GNUC__) && (__GNUC__ >= 3)
return (U32)__builtin_ctz(val);
# else
/* Software ctz version: http://graphics.stanford.edu/~seander/... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
tzcntl %eax, %eax
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_NbCommonBytes | static unsigned ZSTD_NbCommonBytes (size_t val)
{
if (MEM_isLittleEndian()) {
if (MEM_64bits()) {
# if defined(_MSC_VER) && defined(_WIN64)
# if STATIC_BMI2
return _tzcnt_u64(val) >> 3;
# else
unsigned long r = 0;
return _BitScanForwa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1b07c0
cmpl $0x0, %eax
je 0x1dcdd1
callq 0x1dce10
cmpl $0x0, %eax
je 0x1dcdc1
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x1dcdff
movq -0x10(%rbp), %rax
tzcntl %eax, %eax
sarl $0x3, %eax
movl %eax, -0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_safecopyLiterals | static void ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w) {
assert(iend > ilimit_w);
if (ip <= ilimit_w) {
ZSTD_wildcopy(op, ip, ilimit_w - ip, ZSTD_no_overlap);
op += ilimit_w - ip;
ip = ilimit_w;
}
while (ip < iend) *op++ = *ip++;... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
ja 0x1dcfcd
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rsi
subq %rsi, %rax
movq %rdx, -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_HcFindBestMatch_extDict_selectMLS | FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
ZSTD_matchState_t* ms,
const BYTE* ip, const BYTE* const iLimit,
size_t* offsetPtr)
{
switch(ms->cParams.minMatch)
{
default : /* includes case 3 */
case 4 : retu... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x918, %rsp # imm = 0x918
movq %rdi, -0x7c8(%rbp)
movq %rsi, -0x7d0(%rbp)
movq %rdx, -0x7d8(%rbp)
movq %rcx, -0x7e0(%rbp)
movq -0x7c8(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x7e4(%rbp)
subl $0x4, %eax
je 0x1dd099
jmp 0x1dd072
movl -0x7e4(%rbp), %eax
subl $0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.c |
ZSTD_ldm_adjustParameters | void ZSTD_ldm_adjustParameters(ldmParams_t* params,
ZSTD_compressionParameters const* cParams)
{
params->windowLog = cParams->windowLog;
ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);
DEBUGLOG(4, "ZSTD_ldm_adjustParameters");
if (!params->bucketSize... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1eb45e
movq -0x8(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x1eb473
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_getTableSize | size_t ZSTD_ldm_getTableSize(ldmParams_t params)
{
size_t const ldmHSize = ((size_t)1) << params.hashLog;
size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);
size_t const ldmBucketSize = ((size_t)1) << (params.hashLog - ldmBucketSizeLog);
size_t const totalSize = ZSTD_cwksp_alloc_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x4(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x28(%rbp), %rcx
movq %rax, -0x8(%rbp)
movl 0x8(%rcx), %eax
cmpl 0x4(%rcx), %eax
jae 0x1eb559
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_cwksp_alloc_size | MEM_STATIC size_t ZSTD_cwksp_alloc_size(size_t size) {
if (size == 0)
return 0;
#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
return size + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
#else
return size;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1eb5f9
movq $0x0, -0x8(%rbp)
jmp 0x1eb601
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_ldm_fillHashTable | void ZSTD_ldm_fillHashTable(
ldmState_t* ldmState, const BYTE* ip,
const BYTE* iend, ldmParams_t const* params)
{
U32 const minMatchLength = params->minMatchLength;
U32 const hBits = params->hashLog - params->bucketSizeLog;
BYTE const* const base = ldmState->window.base;
BYTE con... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_gear_init | static void ZSTD_ldm_gear_init(ldmRollingHashState_t* state, ldmParams_t const* params)
{
unsigned maxBitsInMask = MIN(params->minMatchLength, 64);
unsigned hashRateLog = params->hashRateLog;
state->rolling = ~(U32)0;
/* The choice of the splitting criterion is subject to two conditions:
* 1. i... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x40, 0xc(%rax)
jae 0x1eb842
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1eb84c
movl $0x40, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1eb84c
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_gear_feed | static size_t ZSTD_ldm_gear_feed(ldmRollingHashState_t* state,
BYTE const* data, size_t size,
size_t* splits, unsigned* numSplits)
{
size_t n;
U64 hash, mask;
hash = state->rolling;
mask = state->stopMask;
n = 0;
#define GEAR_ITER_O... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_generateSequences | size_t ZSTD_ldm_generateSequences(
ldmState_t* ldmState, rawSeqStore_t* sequences,
ldmParams_t const* params, void const* src, size_t srcSize)
{
U32 const maxDist = 1U << params->windowLog;
BYTE const* const istart = (BYTE const*)src;
BYTE const* const iend = istart + srcSize;
size_t con... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_window_enforceMaxDist | MEM_STATIC void
ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
const void* blockEnd,
U32 maxDist,
U32* loadedDictEndPtr,
const ZSTD_matchState_t** dictMatchStatePtr)
{
U32 const blockEndIdx = (U32)((BYTE const*)blo... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1ec0fb
movq -0x20(%rbp), %rax
movl (%rax), %eax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_ldm_generateSequences_internal | static size_t ZSTD_ldm_generateSequences_internal(
ldmState_t* ldmState, rawSeqStore_t* rawSeqStore,
ldmParams_t const* params, void const* src, size_t srcSize)
{
/* LDM parameters */
int const extDict = ZSTD_window_hasExtDict(ldmState->window);
U32 const minMatchLength = params->minMatchLen... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_skipSequences | void ZSTD_ldm_skipSequences(rawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch) {
while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {
rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;
if (srcSize <= seq->litLength) {
/* Skip past srcSize literals */
seq... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jbe 0x1ecbb1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_blockCompress | size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
ZSTD_useRowMatchFinderMode_e useRowMatchFinder,
void const* src, size_t srcSize)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
unsigned const minMatch = c... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq 0x10(%rbp), %rax
movq %rdi, -0x90(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rcx, -0xa8(%rbp)
movl %r8d, -0xac(%rbp)
movq %r9, -0xb8(%rbp)
movq -0x98(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_fillFastTables | static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
void const* end)
{
const BYTE* const iend = (const BYTE*)end;
switch(ms->cParams.strategy)
{
case ZSTD_fast:
ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast);
break;
case ZSTD_dfast:
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x108(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x1ed583
jmp 0x1ed56c
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1ed594
jmp 0x1ed576
movl -0x1c(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_gear_reset | static void ZSTD_ldm_gear_reset(ldmRollingHashState_t* state,
BYTE const* data, size_t minMatchLength)
{
U64 hash = state->rolling;
size_t n = 0;
#define GEAR_ITER_ONCE() do { \
hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; \
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
cmpq -0x18(%rbp), %rax
jae 0x1ed72e
jmp 0x1ed647
movq -0x20(%rbp), %rax
shlq %rax
movq -0x10(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_countBackwardsMatch_2segments | static size_t ZSTD_ldm_countBackwardsMatch_2segments(
const BYTE* pIn, const BYTE* pAnchor,
const BYTE* pMatch, const BYTE* pMatchBase,
const BYTE* pExtDictStart, const BYTE* pExtDictEnd)
{
size_t matchLength = ZSTD_ldm_countBackwardsMatch(pIn, pAnchor, pM... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1edad0
movq %rax, -0x40(%rbp)
movq -0x20... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_ldm_countBackwardsMatch | static size_t ZSTD_ldm_countBackwardsMatch(
const BYTE* pIn, const BYTE* pAnchor,
const BYTE* pMatch, const BYTE* pMatchBase)
{
size_t matchLength = 0;
while (pIn > pAnchor && pMatch > pMatchBase && pIn[-1] == pMatch[-1]) {
pIn--;
pMatch--;
matchLength++;
}
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x29(%rbp)
jbe 0x1edb22
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_ldm.c |
ZSTD_NbCommonBytes | static unsigned ZSTD_NbCommonBytes (size_t val)
{
if (MEM_isLittleEndian()) {
if (MEM_64bits()) {
# if defined(_MSC_VER) && defined(_WIN64)
# if STATIC_BMI2
return _tzcnt_u64(val) >> 3;
# else
unsigned long r = 0;
return _BitScanForwa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1edc40
cmpl $0x0, %eax
je 0x1edbc1
callq 0x1edc00
cmpl $0x0, %eax
je 0x1edbb1
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x1edbef
movq -0x10(%rbp), %rax
tzcntl %eax, %eax
sarl $0x3, %eax
movl %eax, -0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_safecopyLiterals | static void ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w) {
assert(iend > ilimit_w);
if (ip <= ilimit_w) {
ZSTD_wildcopy(op, ip, ilimit_w - ip, ZSTD_no_overlap);
op += ilimit_w - ip;
ip = ilimit_w;
}
while (ip < iend) *op++ = *ip++;... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
ja 0x1edded
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rsi
subq %rsi, %rax
movq %rdx, -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_updateTree | void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movl 0x100(%rax), %eax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_initStats_ultra | static void
ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
seqStore_t* seqStore,
U32 rep[ZSTD_REP_NUM],
const void* src, size_t srcSize)
{
U32 tmpRep[ZSTD_REP_NUM]; /* updated rep codes will sink here */
ZSTD_memcpy(tmpRep, rep, sizeof(tmpRep));
DEBUGL... | pushq %rbp
movq %rsp, %rbp
subq $0x1980, %rsp # imm = 0x1980
movq %rdi, -0x13e8(%rbp)
movq %rsi, -0x13f0(%rbp)
movq %rdx, -0x13f8(%rbp)
movq %rcx, -0x1400(%rbp)
movq %r8, -0x1408(%rbp)
movq -0x13f8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x1414(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x140c(%rbp)
movq -0x13e... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_insertBt1 | static U32 ZSTD_insertBt1(
ZSTD_matchState_t* ms,
const BYTE* const ip, const BYTE* const iend,
U32 const mls, const int extDict)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashTable = ms->hashTable;
U32 const hashLog = c... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movl %r8d, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x48(%rbp)
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_count | MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
{
const BYTE* const pStart = pIn;
const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
if (pIn < pInLoopLimit) {
{ size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
if (diff) r... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $-0x7, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x24d15a
movq -0x18(%rbp), %rdi
callq 0x24d590
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_count_2segments | MEM_STATIC size_t
ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
{
const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
size_t const matchLength = ZSTD_count(ip, match, vEnd);
if (match + matchLength != mEnd) return m... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jae 0x24d28c
movq -0x10(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
MEM_swap64 | MEM_STATIC U64 MEM_swap64(U64 in)
{
#if defined(_MSC_VER) /* Visual Studio */
return _byteswap_uint64(in);
#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap64))
return __builtin_bswap64(in);
#else
return ((in << 56) & 0xff... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
bswapq %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/mem.h |
ZSTD_NbCommonBytes | static unsigned ZSTD_NbCommonBytes (size_t val)
{
if (MEM_isLittleEndian()) {
if (MEM_64bits()) {
# if defined(_MSC_VER) && defined(_WIN64)
# if STATIC_BMI2
return _tzcnt_u64(val) >> 3;
# else
unsigned long r = 0;
return _BitScanForwa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x24d4a0
cmpl $0x0, %eax
je 0x24d5f1
callq 0x24d630
cmpl $0x0, %eax
je 0x24d5e1
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x24d61f
movq -0x10(%rbp), %rax
tzcntl %eax, %eax
sarl $0x3, %eax
movl %eax, -0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_rescaleFreqs | static void
ZSTD_rescaleFreqs(optState_t* const optPtr,
const BYTE* const src, size_t const srcSize,
int const optLevel)
{
int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
optPtr->priceType = zop_d... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24e2e0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x24dc48
cmpq $0x400, -0x18(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_optLdm_processMatchCandidate | static void ZSTD_optLdm_processMatchCandidate(ZSTD_optLdm_t* optLdm, ZSTD_match_t* matches, U32* nbMatches,
U32 currPosInBlock, U32 remainingBytes) {
if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) {
return;
}
if (currPo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x24dd18
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x24dd1a
jmp 0x2... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_rawLiteralsCost | static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
const optState_t* const optPtr,
int optLevel)
{
if (litLength == 0) return 0;
if (!ZSTD_compressedLiterals(optPtr))
return (litLength << 3) * BITCOST_MULTIPLI... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x24de78
movl $0x0, -0x4(%rbp)
jmp 0x24df28
movq -0x20(%rbp), %rdi
callq 0x24e2e0
cmpl $0x0, %eax
jne 0x24de97
movl -0x14(%rbp), %eax
shll $0x3, %eax
shll $0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_updateStats | static void ZSTD_updateStats(optState_t* const optPtr,
U32 litLength, const BYTE* literals,
U32 offsetCode, U32 matchLength)
{
/* literals */
if (ZSTD_compressedLiterals(optPtr)) {
U32 u;
for (u=0; u < litLength; u++)
optPtr->... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24e2e0
cmpl $0x0, %eax
je 0x24e07c
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x24e06d
movq -0x8(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_optLdm_skipRawSeqStoreBytes | static void ZSTD_optLdm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes) {
U32 currPos = (U32)(rawSeqStore->posInSequence + nbBytes);
while (currPos && rawSeqStore->pos < rawSeqStore->size) {
rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos];
if (currPos >= currSeq.litLength + ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x10(%rbp), %rax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x24e24c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %ra... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_downscaleStat | static U32 ZSTD_downscaleStat(unsigned* table, U32 lastEltIndex, int malus)
{
U32 s, sum=0;
DEBUGLOG(5, "ZSTD_downscaleStat (nbElts=%u)", (unsigned)lastEltIndex+1);
assert(ZSTD_FREQ_DIV+malus > 0 && ZSTD_FREQ_DIV+malus < 31);
for (s=0; s<lastEltIndex+1; s++) {
table[s] = 1 + (table[s] >> (ZSTD_F... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x24e443
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %edx
movl -0x10(%rbp), %e... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_getLowestMatchIndex | MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, unsigned windowLog)
{
U32 const maxDistance = 1U << windowLog;
U32 const lowestValid = ms->window.lowLimit;
U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;
U32 const... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x24e48b
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_readMINMATCH | MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
{
switch (length)
{
default :
case 4 : return MEM_read32(memPtr);
case 3 : if (MEM_isLittleEndian())
return MEM_read32(memPtr)<<8;
else
return MEM_read32(memPtr)>>8;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x3, %eax
je 0x24e506
jmp 0x24e4ec
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0x24e4f8
jmp 0x24e4f6
jmp 0x24e4f8
movq -0x10(%rbp), %rdi
callq 0x24d410
movl %eax, -0x4(%rbp)
jmp 0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_insertAndFindFirstIndexHash3 | static U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_matchState_t* ms,
U32* nextToUpdate3,
const BYTE* const ip)
{
U32* const hashTable3 = ms->hashTable3;
U32 const hashLog3 = ms->hashLog3;
const BYTE* const base = ms-... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
MEM_swap32 | MEM_STATIC U32 MEM_swap32(U32 in)
{
#if defined(_MSC_VER) /* Visual Studio */
return _byteswap_ulong(in);
#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap32))
return __builtin_bswap32(in);
#else
return ((in << 24) & 0xff0... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bswapl %eax
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/mem.h |
ZSTD_fracWeight | MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)
{
U32 const stat = rawStat + 1;
U32 const hb = ZSTD_highbit32(stat);
U32 const BWeight = hb * BITCOST_MULTIPLIER;
U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
U32 const weight = BWeight + FWeight;
assert(hb + BITCOST_ACCURACY < 31);
return... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x24e820
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl -0xc(%rbp), %ecx
shrl %cl, %eax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_opt.c |
ZSTD_safecopyLiterals | static void ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w) {
assert(iend > ilimit_w);
if (ip <= ilimit_w) {
ZSTD_wildcopy(op, ip, ilimit_w - ip, ZSTD_no_overlap);
op += ilimit_w - ip;
ip = ilimit_w;
}
while (ip < iend) *op++ = *ip++;... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x60(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x60(%rbp), %rax
ja 0x24ea0d
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rsi
subq %rsi, %rax
movq %rdx, -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_initStaticDCtx | ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
{
ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
if ((size_t)workspace & 7) return NULL; /* 8-aligned */
if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL; /* minimum size */
ZSTD_initDCtx_internal(dctx);
dctx->staticSize = ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x24ec30
movq $0x0, -0x8(%rbp)
jmp 0x24ec7a
cmpq $0x276d8, -0x18(%rbp) # imm = 0x276D8
jae 0x24ec44
movq $0x0, -0x8(%rbp)
jm... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_createDCtx_advanced | ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
{
if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
{ ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);
if (!dctx) return NULL;
dctx->customMem = customMem;
ZSTD_initDCtx_in... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rcx)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, 0x8(%rcx)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
cmpl $0x0, %eax
je 0x24edf0
movq $0x0, -0x8(%rbp)
jmp 0x24ee... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_freeDCtx | size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
{
if (dctx==NULL) return 0; /* support free on NULL */
RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
{ ZSTD_customMem const cMem = dctx->customMem;
ZSTD_clearDict(dctx);
ZSTD_customFree(dctx->inBuff, cMem);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24eed0
movq $0x0, -0x8(%rbp)
jmp 0x24efcd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x75d0(%rax)
je 0x24eeeb
movq $-0x40, -0x8(%rbp)
jmp 0x24efcd
movq -0x10(%rbp), %rax
movq 0x75a8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x75b0(%rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_getFrameHeader_advanced | size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
{
const BYTE* ip = (const BYTE*)src;
size_t const minInputSize = ZSTD_startingInputLength(format);
ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr)); /* not strictly necessary, but static analyzer d... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edi
callq 0x24f670
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10810
movq -0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_findDecompressedSize | unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
{
unsigned long long totalDstSize = 0;
while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {
U32 const magicNumber = MEM_readLE32(src);
if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_STAR... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %edi, %edi
callq 0x24f670
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jb 0x24f8fe
movq -0x10(%rbp), %rdi
callq 0x24f170
movl %eax, -0x24(%rbp)
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
readSkippableFrameSize | static size_t readSkippableFrameSize(void const* src, size_t srcSize)
{
size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
U32 sizeU32;
RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
RETURN_ERROR_IF((U3... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x24f959
movq $-0x48, -0x8(%rbp)
jmp 0x24f9a5
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x24f170
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x8, %eax
cmpl -0x24(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_findFrameSizeInfo | static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
{
ZSTD_frameSizeInfo frameSizeInfo;
ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
if (ZSTD_isLegacy(src, srcSize))
return ZSTD_findFrameSize... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10810
cmpq $0x8, -0x20(%rbp)
jb 0x24fab3
movq -0x18(%rbp), %rdi
callq 0x24f170
andl $-0x10, %eax
cmpl $0x184d2a50, %eax # imm = 0x184D2A50
jne 0x24fab3
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_getDDict | static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
{
switch (dctx->dictUses) {
default:
assert(0 /* Impossible */);
/* fall-through */
case ZSTD_dont_use:
ZSTD_clearDict(dctx);
return NULL;
case ZSTD_use_indefinitely:
return dctx->ddict;
case ZSTD_use_onc... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x75f8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $-0x1, %eax
je 0x250128
jmp 0x250100
movl -0x14(%rbp), %eax
testl %eax, %eax
je 0x250115
jmp 0x250109
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x250139
jmp 0x250113
jmp 0x250115... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decompress | size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{
#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
size_t regenSize;
ZSTD_DCtx* const dctx = ZSTD_createDCtx();
RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
regenSize = ZSTD_decompressDCtx(dctx, ds... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
callq 0x24ee70
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x250192
movq $-0x40, -0x8(%rbp)
jmp 0x2501c0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decompressContinue | size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{
DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
/* Sanity check */
RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "no... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x250990
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_nextSrcSizeToDecompressWithInputSize | static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {
if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))
return dctx->expected;
if (dctx->bType != bt_raw)
return dctx->expected;
return MIN(MAX(inputSize, 1), dctx-... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x7524(%rax)
je 0x2509ca
movq -0x10(%rbp), %rax
cmpl $0x4, 0x7524(%rax)
je 0x2509ca
movq -0x10(%rbp), %rax
movq 0x74e0(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x250a52
movq -0x10(%rbp), %rax
cmpl $0x0, 0x7520(%rax)
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_decodeFrameHeader | static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
{
size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
if (ZSTD_isError(result)) return result; /* invalid header */
RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x74e8, %rdi # imm = 0x74E8
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x7590(%rax), %ecx
callq 0x24f2c0
movq %rax, -0x28(%rbp)
movq -0x2... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_copyRawBlock | static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
DEBUGLOG(5, "ZSTD_copyRawBlock");
RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
if (dst == NULL) {
if (srcSize == 0) return 0;
RETURN_ERROR(dstBuffer_nu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x250bdc
movq $-0x46, -0x8(%rbp)
jmp 0x250c19
cmpq $0x0, -0x10(%rbp)
jne 0x250c00
cmpq $0x0, -0x28(%rbp)
jne 0x250bf4
movq $0x0, -0x8(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_setRleBlock | static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
BYTE b,
size_t regenSize)
{
RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
if (dst == NULL) {
if (regenSize == 0) return 0;
RETURN_ERROR(dstBuffer_null, ""... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x250c5d
movq $-0x46, -0x8(%rbp)
jmp 0x250c9d
cmpq $0x0, -0x10(%rbp)
jne 0x250c81
cmpq $0x0, -0x28(%rbp)
jne 0x250c75
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
HIST_count_simple | unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
const void* src, size_t srcSize)
{
const BYTE* ip = (const BYTE*)src;
const BYTE* const end = ip + srcSize;
unsigned maxSymbolValue = *maxSymbolValuePtr;
unsigned largestCount=0;
ZSTD_memset(count, 0... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/hist.c |
HUF_compressWeights | static size_t HUF_compressWeights(void* dst, size_t dstSize, const void* weightTable, size_t wtSize, void* workspace, size_t workspaceSize)
{
BYTE* const ostart = (BYTE*) dst;
BYTE* op = ostart;
BYTE* const oend = ostart + dstSize;
unsigned maxSymbolValue = HUF_TABLELOG_MAX;
U32 tableLog = MAX_FSE_... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq -0x18(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_buildCTable_wksp | size_t HUF_buildCTable_wksp (HUF_CElt* tree, const unsigned* count, U32 maxSymbolValue, U32 maxNbBits, void* workSpace, size_t wkspSize)
{
HUF_buildCTable_wksp_tables* const wksp_tables = (HUF_buildCTable_wksp_tables*)workSpace;
nodeElt* const huffNode0 = wksp_tables->huffNodeTbl;
nodeElt* const huffNode = ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_compress_internal | static size_t
HUF_compress_internal (void* dst, size_t dstSize,
const void* src, size_t srcSize,
unsigned maxSymbolValue, unsigned huffLog,
HUF_nbStreams_e nbStreams,
void* workSpace_align4, size_t wkspSize,
HUF... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x40(%rbp), %eax
movl 0x38(%rbp), %eax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
MEM_swap32 | MEM_STATIC U32 MEM_swap32(U32 in)
{
#if defined(_MSC_VER) /* Visual Studio */
return _byteswap_ulong(in);
#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap32))
return __builtin_bswap32(in);
#else
return ((in << 24) & 0xff0... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bswapl %eax
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/mem.h |
HUF_DEltX1_set4 | static U64 HUF_DEltX1_set4(BYTE symbol, BYTE nbBits) {
U64 D4;
if (MEM_isLittleEndian()) {
D4 = symbol + (nbBits << 8);
} else {
D4 = (symbol << 8) + nbBits;
}
D4 *= 0x0001000100010001ULL;
return D4;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
callq 0x26b170
cmpl $0x0, %eax
je 0x263643
movzbl -0x1(%rbp), %eax
movzbl -0x2(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
cltq
movq %rax, -0x10(%rbp)
jmp 0x263656
movzbl -0x1(%rbp), %eax
shll $0x8, %eax
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_readDTableX2_wksp | size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
const void* src, size_t srcSize,
void* workSpace, size_t wkspSize)
{
U32 tableLog, maxW, sizeOfSort, nbSymbols;
DTableDesc dtd = HUF_getDTableDesc(DTable);
U32 const maxTableLog = dtd.maxTableLog;
size_t... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2635f0
movl %eax, -0x44(%rbp)
movzbl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_fillDTableX2 | static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
const sortedSymbol_t* sortedList, const U32 sortedListSize,
const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
const U32 nbBitsBaseline, U32* wksp, size... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq 0x20(%rbp), %rax
movq %ra... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress1X2_usingDTable_internal | HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
HUF_DGEN(HUF_decompress4X2_usingDTable_internal)
size_t HUF_decompress1X2_usingDTable(
void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize,
const HUF_DTable* DTable)
{
DTableDesc dtd = HUF_getDTableDesc(DTable);
if (dtd.tableType != 1... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x258(%rbp)
movq %rsi, -0x260(%rbp)
movq %rdx, -0x268(%rbp)
movq %rcx, -0x270(%rbp)
movq %r8, -0x278(%rbp)
movl %r9d, -0x27c(%rbp)
movq -0x258(%rbp), %rdi
movq -0x260(%rbp), %rsi
movq -0x268(%rbp), %rdx
movq -0x270(%rbp), %rcx
movq -0x278... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress1X2_DCtx_wksp | size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize,
void* workSpace, size_t wkspSize)
{
const BYTE* ip = (const BYTE*) cSrc;
size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
HUF_decompress4X_usingDTable_bmi2 | size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{
DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
(void)dtd;
assert(dtd.tableType == 0);
return HUF_decompress4X1_usingDTab... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2635f0
movl %eax, -0x30(%rbp)
movzbl -0x2f(%rbp), %eax
cmpl $0x0, %eax
je 0x26aaa8
movq -0x8(%rbp), %rdi
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/huf_decompress.c |
BIT_reloadDStream | MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
{
if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8)) /* overflow detected, like end of stream */
return BIT_DStream_overflow;
if (bitD->ptr >= bitD->limitPtr) {
return BIT_reloadDStreamFast(bitD);
}
if (bitD->pt... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpq $0x40, %rax
jbe 0x26b5a5
movl $0x3, -0x4(%rbp)
jmp 0x26b699
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x26b5c8
movq -0x10(%rbp), %rdi
callq 0x26b6c0
movl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/../common/bitstream.h |
ZSTD_copyDDictParameters | void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{
DEBUGLOG(4, "ZSTD_copyDDictParameters");
assert(dctx != NULL);
assert(ddict != NULL);
dctx->dictID = ddict->dictID;
dctx->prefixStart = ddict->dictContent;
dctx->virtualStart = ddict->dictContent;
dctx->dictEnd = (cons... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x6ab4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x75f0(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x74c8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_ddict.c |
ZSTD_initDDict_internal | static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
if ((dictLoadMethod == ZSTD_dl... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpl $0x1, -0x24(%rbp)
je 0x26bccf
cmpq $0x0, -0x18(%rbp)
je 0x26bccf
cmpq $0x0, -0x20(%rbp)
jne 0x26bcf7
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rb... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_ddict.c |
MEM_swap32 | MEM_STATIC U32 MEM_swap32(U32 in)
{
#if defined(_MSC_VER) /* Visual Studio */
return _byteswap_ulong(in);
#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
|| (defined(__clang__) && __has_builtin(__builtin_bswap32))
return __builtin_bswap32(in);
#else
return ((in << 24) & 0xff0... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
bswapl %eax
popq %rbp
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/../common/mem.h |
rhash_get_hash_length | RHASH_API int rhash_get_hash_length(unsigned hash_id)
{
const rhash_info* info = rhash_info_by_id(hash_id);
return (int)(info ? (info->flags & F_BS32 ?
BASE32_LENGTH(info->digest_size) : info->digest_size * 2) : 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x273b60
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x273aa6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x273a8d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x3, %rax
addq $0x4, ... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/rhash.c |
rhash_md5_process_block | static void rhash_md5_process_block(unsigned state[4], const unsigned* x)
{
register unsigned a, b, c, d;
a = state[0];
b = state[1];
c = state[2];
d = state[3];
MD5_ROUND1(a, b, c, d, x[ 0], 7, 0xd76aa478);
MD5_ROUND1(d, a, b, c, x[ 1], 12, 0xe8c7b756);
MD5_ROUND1(c, d, a, b, x[ 2], 17, 0x242070db);
MD5_ROU... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/md5.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.