name string | code string | asm string | file string |
|---|---|---|---|
ZSTD_createCDict | ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)
{
ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movq $-0x1, %rdx
movl $0x2, %r8d
callq 0x13c700
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
leaq -0x30(%rbp), %r8
leaq 0x1... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_createCDict_byReference | ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)
{
ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movq $-0x1, %rdx
movl $0x2, %r8d
callq 0x13c700
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
leaq -0x30(%rb... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_initStaticCDict | const ZSTD_CDict* ZSTD_initStaticCDict(
void* workspace, size_t workspaceSize,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rsi, -0x150(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
xorl %edi, %edi
callq 0x13c9b0
movq -0x150(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBegin_usingCDict_internal | static size_t ZSTD_compressBegin_usingCDict_internal(
ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,
ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)
{
ZSTD_CCtx_params cctxParams;
DEBUGLOG(4, "ZSTD_compressBegin_usingCDict_internal");
RETURN_ERROR_IF(cdict==NULL, ... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdx, -0x24(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %r8, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x141110
movq $-0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_resetCStream | size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
{
/* temporary : 0 interpreted as "unknown" during transition period.
* Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
* 0 will be interpreted as "empty" in the future.
*/
U64 const pledgedSrcSize = (ps... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1415e4
movq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1415ec
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x13... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_initCStream_internal | size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
const void* dict, size_t dictSize, const ZSTD_CDict* cdict,
const ZSTD_CCtx_params* params,
unsigned long long pledgedSrcSize)
{
DEBUGLOG(4, "ZSTD_initCStream_internal");
FORWARD_IF_ERROR( ZSTD_CCtx_r... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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
movl $0x1, %esi
callq 0x13c0c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x13a5b0
cmpl $0x0, %eax
je 0x1416... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_initCStream_usingCDict_advanced | size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
const ZSTD_CDict* cdict,
ZSTD_frameParameters fParams,
unsigned long long pledgedSrcSize)
{
DEBUGLOG(4, "ZSTD_initCStream... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x24(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x24(%rbp), %rax
movq %rax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x13c0c0
movq %rax, -0x48(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_CCtxParams_setZstdParams | static void ZSTD_CCtxParams_setZstdParams(
ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params)
{
assert(!ZSTD_checkCParams(params->cParams));
cctxParams->cParams = params->cParams;
cctxParams->fParams = params->fParams;
/* Should not matter, as all cParams are presumed properly defined.... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x4(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xc(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x14(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_initCStream_srcSize | size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
{
/* temporary : 0 interpreted as "unknown" during transition period.
* Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
* 0 will be interpreted as "empty" in the future.
*/
U... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x141b67
movq $-0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x141b6f
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressStream2 | size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
ZSTD_outBuffer* output,
ZSTD_inBuffer* input,
ZSTD_EndDirective endOp)
{
DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
/* check conditions */
RETURN_ERROR_I... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x141d96
movq $-0x46, -0x8(%rbp)
jmp 0x141eb0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_nextInputSizeHint_MTorST | static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
{
#ifdef ZSTD_MULTITHREAD
if (cctx->appliedParams.nbWorkers >= 1) {
assert(cctx->mtctx != NULL);
return ZSTDMT_nextInputSizeHint(cctx->mtctx);
}
#endif
return ZSTD_nextInputSizeHint(cctx);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x149b20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_CCtx_init_compressStream2 | static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
ZSTD_EndDirective endOp,
size_t inSize) {
ZSTD_CCtx_params params = cctx->requestedParams;
ZSTD_prefixDict const prefixDict = cctx->prefixDict;
FORWARD_IF_E... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
leaq -0xd0(%rbp), %rdi
movl $0xb0, %edx
callq 0x101e0
movq -0x10(%rbp), %rax
movq 0xdd8(%rax), %rcx
movq %rcx, -0xe8(%rbp)
movq 0xde0(%rax), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_checkBufferStability | static size_t ZSTD_checkBufferStability(ZSTD_CCtx const* cctx,
ZSTD_outBuffer const* output,
ZSTD_inBuffer const* input,
ZSTD_EndDirective endOp)
{
if (cctx->appliedParams.inBufferMode == ZSTD_bm_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x13c(%rax)
jne 0x14236e
movq -0x10(%rbp), %rax
movq 0xd88(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xd90(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xd98(%rax), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressStream_generic | static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
ZSTD_outBuffer* output,
ZSTD_inBuffer* input,
ZSTD_EndDirective const flushMode)
{
const char* const istart = (const char*)input-... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x142405
movq -0x30(%rbp), %rax
movq -0x20(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressStream2_simpleArgs | size_t ZSTD_compressStream2_simpleArgs (
ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity, size_t* dstPos,
const void* src, size_t srcSize, size_t* srcPos,
ZSTD_EndDirective endOp)
{
ZSTD_outBuffer output = { dst... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressSequences | size_t ZSTD_compressSequences(ZSTD_CCtx* const cctx, void* dst, size_t dstCapacity,
const ZSTD_Sequence* inSeqs, size_t inSeqsSize,
const void* src, size_t srcSize) {
BYTE* op = (BYTE*)dst;
size_t cSize = 0;
size_t compressedBlocksSize = 0;
siz... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %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 -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressSequences_internal | static size_t ZSTD_compressSequences_internal(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const ZSTD_Sequence* inSeqs, size_t inSeqsSize,
const void* src, size_t srcSize) {
s... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %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 $0x0, -0x40(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x10,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_endStream | size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
{
ZSTD_inBuffer input = { NULL, 0, 0 };
size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
FORWARD_IF_ERROR( remainingToFlush , "ZSTD_compressStream2 failed");
if (zcs->appliedParams.nbWorkers > 0) retur... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10810
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movl $0x2, %ecx
callq 0x141d60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_cwksp_clear | MEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {
DEBUGLOG(4, "cwksp: clearing!");
#if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
/* To validate that the context re-use logic is sound, and that we don't
* access stuff that this compression hasn't initialized, we re-"poison"
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_assert_internal_consistency | MEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {
(void)ws;
assert(ws->workspace <= ws->objectEnd);
assert(ws->objectEnd <= ws->tableEnd);
assert(ws->objectEnd <= ws->tableValidEnd);
assert(ws->tableEnd <= ws->allocStart);
assert(ws->tableValidEnd <= ws->allocStart);
a... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_mark_tables_dirty | MEM_STATIC void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws) {
DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_dirty");
#if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
/* To validate that the table re-use logic is sound, and that we don't
* access table space that we haven't cleaned, we... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1438c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_mark_tables_clean | MEM_STATIC void ZSTD_cwksp_mark_tables_clean(ZSTD_cwksp* ws) {
DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_clean");
assert(ws->tableValidEnd >= ws->objectEnd);
assert(ws->tableValidEnd <= ws->allocStart);
if (ws->tableValidEnd < ws->tableEnd) {
ws->tableValidEnd = ws->tableEnd;
}
ZSTD_cwk... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x14439e
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1438c0
addq $0x10, %rsp
popq %rbp
r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_window_init | MEM_STATIC void ZSTD_window_init(ZSTD_window_t* window) {
ZSTD_memset(window, 0, sizeof(*window));
window->base = (BYTE const*)"";
window->dictBase = (BYTE const*)"";
window->dictLimit = 1; /* start from 1, so that 1st position is valid */
window->lowLimit = 1; /* it ensures first and later C... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10810
movq -0x8(%rbp), %rax
leaq 0x17262e(%rip), %rcx # 0x2b6f45
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x17261f(%rip), %rcx # 0x2b6f45
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_cwksp_reserve_internal | MEM_STATIC void* ZSTD_cwksp_reserve_internal(
ZSTD_cwksp* ws, size_t bytes, ZSTD_cwksp_alloc_phase_e phase) {
void* alloc;
if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0) {
return NULL;
}
#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x144a00
movq %rax, %rdi
callq 0x13a5b0
cmpl $0x0, %eax
jne 0x1449d3
cmpq $0x0, -0x18(%rbp)
jne 0x1449dd
movq $0x0, -0x8(%rbp)
jmp 0x1449f6
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_reserve_internal_buffer_space | MEM_STATIC void* ZSTD_cwksp_reserve_internal_buffer_space(ZSTD_cwksp* ws, size_t const bytes) {
void* const alloc = (BYTE*)ws->allocStart - bytes;
void* const bottom = ws->tableEnd;
DEBUGLOG(5, "cwksp: reserving %p %zd bytes, %zd bytes remaining",
alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1438c0
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_clear_tables | MEM_STATIC void ZSTD_cwksp_clear_tables(ZSTD_cwksp* ws) {
DEBUGLOG(4, "cwksp: clearing tables!");
#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
/* We don't do this when the workspace is statically allocated, because
* when that is the case, we have no capability to hook into the... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x1438c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_reserve_table | MEM_STATIC void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, size_t bytes) {
const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned;
void* alloc;
void* end;
void* top;
if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) {
return NULL;
}
alloc = ws->tableEnd;
en... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x144a00
movq %rax, %rdi
callq 0x13a5b0
cmpl $0x0, %eax
je 0x144ccc
movq $0x0, -0x8(%rbp)
jmp 0x144d29
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_cwksp_clean_tables | MEM_STATIC void ZSTD_cwksp_clean_tables(ZSTD_cwksp* ws) {
DEBUGLOG(4, "cwksp: ZSTD_cwksp_clean_tables");
assert(ws->tableValidEnd >= ws->objectEnd);
assert(ws->tableValidEnd <= ws->allocStart);
if (ws->tableValidEnd < ws->tableEnd) {
ZSTD_memset(ws->tableValidEnd, 0, (BYTE*)ws->tableEnd - (BYTE*... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x144da0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
subq %rax, %rdx
xorl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_buildSequencesStatistics | static ZSTD_symbolEncodingTypeStats_t
ZSTD_buildSequencesStatistics(seqStore_t* seqStorePtr, size_t nbSeq,
const ZSTD_fseCTables_t* prevEntropy, ZSTD_fseCTables_t* nextEntropy,
BYTE* dst, const BYTE* const dstEnd,
ZSTD_strategy strategy... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rsi, -0x28(%rbp)
movq %rdx, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compress_frameChunk | static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
U32 lastFrameChunk)
{
size_t blockSize = cctx->blockSize;
size_t remaining = srcSize;
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x270(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBlock_internal | static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize, U32 frame)
{
/* This the upper bound for the length of an rle block.
* This isn't the actual upper bound. Find... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movl $0x19, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_window_correctOverflow | MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
U32 maxDist, void const* src)
{
/* preemptive overflow correction:
* 1. correction is large enough:
* lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
* 1<<windowLog <... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_reduceIndex | static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
{
{ U32 const hSize = (U32)1 << params->cParams.hashLog;
ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
}
if (ZSTD_allocateChainTable(params->cParams.strategy, params->useRowMatchFi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x145f60
movq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_reduceTable | static void ZSTD_reduceTable(U32* const table, U32 const size, U32 const reducerValue)
{
ZSTD_reduceTable_internal(table, size, reducerValue, 0);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %eax
movq %rdx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_reduceTable_btlazy2 | static void ZSTD_reduceTable_btlazy2(U32* const table, U32 const size, U32 const reducerValue)
{
ZSTD_reduceTable_internal(table, size, reducerValue, 1);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movl %edx, -0x38(%rbp)
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x38(%rbp), %eax
movq %rdx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %eax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_checkDictValidity | MEM_STATIC void
ZSTD_checkDictValidity(const ZSTD_window_t* window,
const void* blockEnd,
U32 maxDist,
U32* loadedDictEndPtr,
const ZSTD_matchState_t** dictMatchStatePtr)
{
assert(loadedDictEndPtr != NULL);
... | 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)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_compressBlock_targetCBlockSize | static size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
U32 lastBlock)
{
size_t cSize = 0;
const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize)... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1464f0
movq %rax, -0x48(%rbp)
movq -0x4... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_noCompressBlock | MEM_STATIC size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
{
U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
dstSize_tooSmall, "dst buf t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x0, %eax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_buildSeqStore | static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
{
ZSTD_matchState_t* const ms = &zc->blockState.matchState;
DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
/* Assert that we have correctly flushed the ctx params into the m... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $0xf0, %rax
movq 0xc4(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBlock_targetCBlockSize_body | static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const size_t bss, U32 lastBlock)
{
DEBUGLOG(6, "Attempting ZSTD_compressSuperBlock()");
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x146a42
movq -0x10(%rbp), %rax
cmpl $0x0, 0x330(%rax)
jne 0x146999
movq -0x10(%rbp), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_assertEqualCParams | static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
ZSTD_compressionParameters cParams2)
{
(void)cParams1;
(void)cParams2;
assert(cParams1.windowLog == cParams2.windowLog);
assert(cParams1.chainLog == cParams2.chainLog);
assert(cParams1... | pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_isRLE | static int ZSTD_isRLE(const BYTE* src, size_t length) {
const BYTE* ip = src;
const BYTE value = ip[0];
const size_t valueST = (size_t)((U64)value * 0x0101010101010101ULL);
const size_t unrollSize = sizeof(size_t) * 4;
const size_t unrollMask = unrollSize - 1;
const size_t prefixLength = length ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
movq %rax, -0x30(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.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 0x146eda
movq -0x18(%rbp), %rdi
callq 0x146fc0
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 0x145410
cmpl $0x0, %eax
je 0x147021
callq 0x147060
cmpl $0x0, %eax
je 0x147011
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x14704f
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_compressBlock_splitBlock_internal | static size_t ZSTD_compressBlock_splitBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity,
const void* src, size_t blockSize, U32 lastBlock, U32 nbSeq) {
size_t cSize = 0;
const BYTE* ip = (const BYTE*)src;
BYTE* op = (BYTE*)dst;
U32 partition... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_deriveSeqStoreChunk | static void ZSTD_deriveSeqStoreChunk(seqStore_t* resultSeqStore,
const seqStore_t* originalSeqStore,
size_t startIdx, size_t endIdx) {
BYTE* const litEnd = originalSeqStore->lit;
size_t literalsBytes;
size_t literalsBytesPreceding = 0;
... | 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 -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x50, %edx
callq 0x101e0
cmpq $0x0, -0x18(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize | static size_t ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(seqStore_t* seqStore, const ZSTD_CCtx* zc) {
ZSTD_entropyCTablesMetadata_t entropyMetadata;
FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(seqStore,
&zc->blockState.prevCBlock->entropy,
&zc->blockState.nextCBl... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xc00(%rax), %rsi
movq -0x20(%rbp), %rax
movq 0xc08(%rax), %rdx
movq -0x20(%rbp), %rcx
addq $0xc0, %rcx
movq -0x20(%rbp), %rax
movq 0xd28(%rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_estimateBlockSize | static size_t ZSTD_estimateBlockSize(const BYTE* literals, size_t litSize,
const BYTE* ofCodeTable,
const BYTE* llCodeTable,
const BYTE* mlCodeTable,
size_t nbSeq,
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_estimateBlockSize_literal | static size_t ZSTD_estimateBlockSize_literal(const BYTE* literals, size_t litSize,
const ZSTD_hufCTables_t* huf,
const ZSTD_hufCTablesMetadata_t* hufMetadata,
void* workspace, ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
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 -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xff, -0x44(%rbp)
cmpq $0x400, -0x18(%rbp) # imm = 0x400
setae... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_estimateBlockSize_symbolType | static size_t ZSTD_estimateBlockSize_symbolType(symbolEncodingType_e type,
const BYTE* codeTable, size_t nbSeq, unsigned maxCode,
const FSE_CTable* fseCTable,
const U32* additionalBits,
short const* defaultNorm, U32 defaultN... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq 0x28(%rbp), %rax
movq %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_seqStore_resolveOffCodes | static void ZSTD_seqStore_resolveOffCodes(repcodes_t* const dRepcodes, repcodes_t* const cRepcodes,
seqStore_t* const seqStore, U32 const nbSeq) {
U32 idx = 0;
for (; idx < nbSeq; ++idx) {
seqDef* const seq = seqStore->sequencesStart + idx;
U32 const ll0... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x148345
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_entropyCompressSeqStore | MEM_STATIC size_t
ZSTD_entropyCompressSeqStore(seqStore_t* seqStorePtr,
const ZSTD_entropyCTables_t* prevEntropy,
ZSTD_entropyCTables_t* nextEntropy,
const ZSTD_CCtx_params* cctxParams,
void* dst, size_t dstCapacity,... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
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 -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_copyBlockSequences | static void ZSTD_copyBlockSequences(ZSTD_CCtx* zc)
{
const seqStore_t* seqStore = ZSTD_getSeqStore(zc);
const seqDef* seqStoreSeqs = seqStore->sequencesStart;
size_t seqStoreSeqSize = seqStore->sequences - seqStoreSeqs;
size_t seqStoreLiteralsSize = (size_t)(seqStore->lit - seqStore->litStart);
size... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13a200
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
writeBlockHeader | static void writeBlockHeader(void* op, size_t cSize, size_t blockSize, U32 lastBlock) {
U32 const cBlockHeader = cSize == 1 ?
lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :
lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);
MEM_writeLE24(op, cBlo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x1487d3
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x1487e6
movl -0x1c(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_resolveRepcodeToRawOffset | static U32 ZSTD_resolveRepcodeToRawOffset(const U32 rep[ZSTD_REP_NUM], const U32 offCode, const U32 ll0) {
U32 const adjustedOffCode = offCode + ll0;
assert(offCode < ZSTD_REP_NUM);
if (adjustedOffCode == ZSTD_REP_NUM) {
/* litlength == 0 and offCode == 2 implies selection of first repcode - 1 */
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jne 0x14882b
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x148838
movq -0x10(%rbp), %rax
movl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_updateRep | MEM_STATIC repcodes_t ZSTD_updateRep(U32 const rep[3], U32 const offset, U32 const ll0)
{
repcodes_t newReps;
if (offset >= ZSTD_REP_NUM) { /* full offset */
newReps.rep[2] = rep[1];
newReps.rep[1] = rep[0];
newReps.rep[0] = offset - ZSTD_REP_MOVE;
} else { /* repcode */
U... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
cmpl $0x3, -0x1c(%rbp)
jb 0x148872
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0xc(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_entropyCompressSeqStore_internal | MEM_STATIC size_t
ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
const ZSTD_entropyCTables_t* prevEntropy,
ZSTD_entropyCTables_t* nextEntropy,
const ZSTD_CCtx_params* cctxParams,
void* dst... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movq -0x40(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compress_insertDictionary | static size_t
ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
ZSTD_matchState_t* ms,
ldmState_t* ls,
ZSTD_cwksp* ws,
const ZSTD_CCtx_params* params,
const void* ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
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)
cmpq $0x0, -0x38(%rbp)
je 0x148fcc
cmpq $0x8, 0x10(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_resetCCtx_byAttachingCDict | static size_t
ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
const ZSTD_CDict* cdict,
ZSTD_CCtx_params params,
U64 pledgedSrcSize,
ZSTD_buffered_policy_e zbuff)
{
DEBUGLOG(4, "ZSTD_resetCCtx_byAttachingCDict() pledgedS... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq 0x150(%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq 0x158(%rcx), %rdx
movq %rdx, -0x38(%rbp)
movq 0x160(%rcx), %rdx
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_loadZstdDictionary | static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
ZSTD_matchState_t* ms,
ZSTD_cwksp* ws,
ZSTD_CCtx_params const* params,
const void* dict, size_t d... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
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 -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_cwksp_slack_space_required | MEM_STATIC size_t ZSTD_cwksp_slack_space_required(void) {
/* For alignment, the wksp will always allocate an additional n_1=[1, 64] bytes
* to align the beginning of tables section, as well as another n_2=[0, 63] bytes
* to align the beginning of the aligned secion.
*
* n_1 + n_2 == 64 bytes if ... | pushq %rbp
movq %rsp, %rbp
movq $0x40, -0x8(%rbp)
movl $0x40, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_selectSequenceCopier | static ZSTD_sequenceCopier ZSTD_selectSequenceCopier(ZSTD_sequenceFormat_e mode) {
ZSTD_sequenceCopier sequenceCopier = NULL;
assert(ZSTD_cParam_withinBounds(ZSTD_c_blockDelimiters, mode));
if (mode == ZSTD_sf_explicitBlockDelimiters) {
return ZSTD_copySequencesToSeqStoreExplicitBlockDelim;
} el... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x149da2
leaq 0x34(%rip), %rax # 0x149dd0
movq %rax, -0x8(%rbp)
jmp 0x149dbf
cmpl $0x0, -0xc(%rbp)
jne 0x149db5
leaq 0x6f1(%rip), %rax # 0x14a4a0
movq %rax, -0x8(%rbp)
jmp 0x149dbf
jmp 0x149db7
movq -0x18(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_copySequencesToSeqStoreExplicitBlockDelim | static size_t ZSTD_copySequencesToSeqStoreExplicitBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
const void* src, size_t blockSize) ... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x90(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rcx, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xb8(%rbp)
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_copySequencesToSeqStoreNoBlockDelim | static size_t ZSTD_copySequencesToSeqStoreNoBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
const void* src, size_t blockSize) {
U32 idx = se... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x90(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rcx, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xb8(%rbp)
movq -0x98(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
movq -0x98(%rbp), %rax
movl 0x4(%rax), %eax
movl %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_validateSequence | static size_t ZSTD_validateSequence(U32 offCode, U32 matchLength,
size_t posInSrc, U32 windowLog, size_t dictSize, U32 minMatch) {
size_t offsetBound;
U32 windowSize = 1 << windowLog;
/* posInSrc represents the amount of data the the decoder would decode up to this point.... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x1c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x14ae4b
movl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.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 0x14b02d
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_getCParamRowSize | static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
{
switch (mode) {
case ZSTD_cpm_unknown:
case ZSTD_cpm_noAttachDict:
case ZSTD_cpm_createCDict:
break;
case ZSTD_cpm_attachDict:
dictSize = 0;
break;
default:
assert(0);
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x14b0c2
jmp 0x14b0ab
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x14b0c4
jmp 0x14b0b5
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x14b0ce
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_fseBitCost | size_t ZSTD_fseBitCost(
FSE_CTable const* ctable,
unsigned const* count,
unsigned const max)
{
unsigned const kAccuracyLog = 8;
size_t cost = 0;
unsigned s;
FSE_CState_t cstate;
FSE_initCState(&cstate, ctable);
if (ZSTD_getFSEMaxSymbolValue(ctable) < max) {
DEBUGLOG(5, "Repea... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x14b220
movq -0x10(%rbp), %rdi
callq 0x14b2d0
cmpl -0x1c(%rbp), %eax
jae 0x14b18a
movq $-0x1, -0x8(%rbp)
jmp... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
FSE_initCState | MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
{
const void* ptr = ct;
const U16* u16ptr = (const U16*) ptr;
const U32 tableLog = MEM_read16(ptr);
statePtr->value = (ptrdiff_t)1<<tableLog;
statePtr->stateTable = u16ptr+2;
statePtr->symbolTT = ct + 1 + (tableLog ? (1... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x14c290
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/fse.h |
FSE_bitCost | MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
{
const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
U32 const threshold = (minNbBits+1) << 16... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %eax
shrl $0x10, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
shll ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/fse.h |
ZSTD_crossEntropyCost | size_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,
unsigned const* count, unsigned const max)
{
unsigned const shift = 8 - accuracyLog;
size_t cost = 0;
unsigned s;
assert(accuracyLog <= 8);
for (s = 0; s <= max; ++s) {
unsigned const normAcc =... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x8, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
ja 0x14b43e
movq -0x8(%rbp), %rax
movl -0x2c(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
ZSTD_selectEncodingType | symbolEncodingType_e
ZSTD_selectEncodingType(
FSE_repeat* repeatMode, unsigned const* count, unsigned const max,
size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,
FSE_CTable const* prevCTable,
short const* defaultNorm, U32 defaultNormLog,
ZSTD_defaultPolicy_e const ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x28(%rbp), %rax
cmpq -... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
ZSTD_entropyCost | static size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)
{
unsigned cost = 0;
unsigned s;
assert(total > 0);
for (s = 0; s <= max; ++s) {
unsigned norm = (unsigned)((256 * count[s]) / total);
if (count[s] != 0 && norm == 0)
norm = 1;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x14b814
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shll $0x8, %eax
movl %eax, %eax
xorl %ecx, %ecx
movl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
ZSTD_buildCTable | size_t
ZSTD_buildCTable(void* dst, size_t dstCapacity,
FSE_CTable* nextCTable, U32 FSELog, symbolEncodingType_e type,
unsigned* count, U32 max,
const BYTE* codeTable, size_t nbSeq,
const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
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,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
BIT_initCStream | MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
void* startPtr, size_t dstCapacity)
{
bitC->bitContainer = 0;
bitC->bitPos = 0;
bitC->startPtr = (char*)startPtr;
bitC->ptr = bitC->startPtr;
bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContain... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/bitstream.h |
FSE_initCState2 | MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
{
FSE_initCState(statePtr, ct);
{ const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
const U16* stateTable = (const U16*)(statePtr->stateTable);... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x14b220
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/fse.h |
BIT_flushBits | MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
{
size_t const nbBytes = bitC->bitPos >> 3;
assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
assert(bitC->ptr <= bitC->endPtr);
MEM_writeLEST(bitC->ptr, bitC->bitContainer);
bitC->ptr += nbBytes;
if (bitC->ptr > bitC->endPtr) bitC->ptr = b... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x14c600
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/bitstream.h |
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 |
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_compressSuperBlock | size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
void* dst, size_t dstCapacity,
void const* src, size_t srcSize,
unsigned lastBlock) {
ZSTD_entropyCTablesMetadata_t entropyMetadata;
FORWARD_IF_ERROR(ZSTD_buildBlockEntropy... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x48(%rbp)
movl %r9d, -0x4c(%rbp)
movq -0x28(%rbp), %rdi
addq $0x338, %rdi # imm = 0x338
movq -0x28(%rb... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.c |
ZSTD_compressSubBlock_multi | static size_t ZSTD_compressSubBlock_multi(const seqStore_t* seqStorePtr,
const ZSTD_compressedBlockState_t* prevCBlock,
ZSTD_compressedBlockState_t* nextCBlock,
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.c |
ZSTD_getSequenceLength | MEM_STATIC ZSTD_sequenceLength ZSTD_getSequenceLength(seqStore_t const* seqStore, seqDef const* seq)
{
ZSTD_sequenceLength seqLen;
seqLen.litLength = seq->litLength;
seqLen.matchLength = seq->matchLength + MINMATCH;
if (seqStore->longLengthPos == (U32)(seq - seqStore->sequencesStart)) {
if (seqS... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x6(%rax), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/zstd_internal.h |
ZSTD_estimateSubBlockSize | static size_t ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,
const BYTE* ofCodeTable,
const BYTE* llCodeTable,
const BYTE* mlCodeTable,
size_t ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x38(%rbp), %eax
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.c |
ZSTD_compressSubBlock | static size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,
const ZSTD_entropyCTablesMetadata_t* entropyMetadata,
const seqDef* sequences, size_t nbSeq,
const BYTE* literals, size_t litSize,
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl 0x68(%rbp), %eax
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movl 0x50(%rbp), %eax
movl 0x48(%rbp), %eax
movl 0x40(%rbp), %eax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.c |
ZSTD_needSequenceEntropyTables | static int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t const* fseMetadata)
{
if (fseMetadata->llType == set_compressed || fseMetadata->llType == set_rle)
return 1;
if (fseMetadata->mlType == set_compressed || fseMetadata->mlType == set_rle)
return 1;
if (fseMetadata->ofType == s... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
je 0x14d51a
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x14d523
movl $0x1, -0x4(%rbp)
jmp 0x14d564
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x14d537
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x14d540
movl $0x1, -0x4... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.c |
ZSTD_noCompressBlock | MEM_STATIC size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)
{
U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);
RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,
dstSize_tooSmall, "dst buf t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x0, %eax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_internal.h |
ZSTD_estimateSubBlockSize_sequences | static size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,
const BYTE* llCodeTable,
const BYTE* mlCodeTable,
size_t nbSeq,
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
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 $0x3, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_superblock.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 |
MEM_writeLE16 | MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
{
if (MEM_isLittleEndian()) {
MEM_write16(memPtr, val);
} else {
BYTE* p = (BYTE*)memPtr;
p[0] = (BYTE)val;
p[1] = (BYTE)(val>>8);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
callq 0x14e250
cmpl $0x0, %eax
je 0x14e2dc
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x14e310
jmp 0x14e300
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %ax
movb %al, %cl
movq -0x18(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/mem.h |
ZSTD_fillDoubleHashTable | void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
void const* end, ZSTD_dictTableLoadMethod_e dtlm)
{
const ZSTD_compressionParameters* const cParams = &ms->cParams;
U32* const hashLarge = ms->hashTable;
U32 const hBitsL = cParams->hashLog;
U32 const mls = cParams->min... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %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_double_fast.c |
ZSTD_compressBlock_doubleFast | size_t ZSTD_compressBlock_doubleFast(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
const U32 mls = ms->cParams.minMatch;
switch(mls)
{
default: /* includes case 3 */
case 4 :
return ZSTD_compressBlock_doubleFast_generi... | pushq %rbp
movq %rsp, %rbp
subq $0x1e80, %rsp # imm = 0x1E80
movq %rdi, -0x1730(%rbp)
movq %rsi, -0x1738(%rbp)
movq %rdx, -0x1740(%rbp)
movq %rcx, -0x1748(%rbp)
movq %r8, -0x1750(%rbp)
movq -0x1730(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x1754(%rbp)
movl -0x1754(%rbp), %eax
addl $-0x4, %eax
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_double_fast.c |
ZSTD_compressBlock_doubleFast_dictMatchState | size_t ZSTD_compressBlock_doubleFast_dictMatchState(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize)
{
const U32 mls = ms->cParams.minMatch;
switch(mls)
{
default: /* includes case 3 */
case 4 :
return ZSTD_compressBlock_do... | pushq %rbp
movq %rsp, %rbp
subq $0x1e80, %rsp # imm = 0x1E80
movq %rdi, -0x1730(%rbp)
movq %rsi, -0x1738(%rbp)
movq %rdx, -0x1740(%rbp)
movq %rcx, -0x1748(%rbp)
movq %r8, -0x1750(%rbp)
movq -0x1730(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x1754(%rbp)
movl -0x1754(%rbp), %eax
addl $-0x4, %eax
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_double_fast.c |
ZSTD_compressBlock_doubleFast_extDict | size_t ZSTD_compressBlock_doubleFast_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_doubleFas... | 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_double_fast.c |
ZSTD_compressBlock_doubleFast_extDict_generic | static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
void const* src, size_t srcSize,
U32 const mls /* template */)
{
ZSTD_compressionParameters const* cParams = &ms->cParams;
U32* const hashLong = ms->hashTable;... | pushq %rbp
movq %rsp, %rbp
subq $0xd80, %rsp # imm = 0xD80
movq %rdi, -0x8b0(%rbp)
movq %rsi, -0x8b8(%rbp)
movq %rdx, -0x8c0(%rbp)
movq %rcx, -0x8c8(%rbp)
movq %r8, -0x8d0(%rbp)
movl %r9d, -0x8d4(%rbp)
movq -0x8b0(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x8e0(%rbp)
movq -0x8b0(%rbp), %rax
movq 0x60(%rax), %... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_double_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 0x16e03b
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 0x16e0cc
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 0x16e24a
movq -0x18(%rbp), %rdi
callq 0x16e520
m... | /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 0x16e4bd
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_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 0x16df10
cmpl $0x0, %eax
je 0x16e581
callq 0x16e5c0
cmpl $0x0, %eax
je 0x16e571
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x16e5af
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 |
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.