name string | code string | asm string | file string |
|---|---|---|---|
block_buffer_encode | static lzma_ret
block_buffer_encode(lzma_block *block, const lzma_allocator *allocator,
const uint8_t *in, size_t in_size,
uint8_t *out, size_t *out_pos, size_t out_size,
bool try_to_compress)
{
// Validate the arguments.
if (block == NULL || (in == NULL && in_size != 0) || out == NULL
|| out_pos == NULL || ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9bd96f
cmpq $0x0, -0x20(%rbp)
jn... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_buffer_encoder.c |
lzma_filter_flags_encode | extern LZMA_API(lzma_ret)
lzma_filter_flags_encode(const lzma_filter *filter,
uint8_t *out, size_t *out_pos, size_t out_size)
{
// Filter ID
if (filter->id >= LZMA_FILTER_RESERVED_START)
return LZMA_PROG_ERROR;
return_if_error(lzma_vli_encode(filter->id, NULL,
out, out_pos, out_size));
// Size of Propertie... | 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 -0x10(%rbp), %rax
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
cmpq %rcx, (%rax)
jb 0x9c0267
movl $0xb, -0x4(%rbp)
jmp 0x9c034a
jmp 0x9c0269
movq -0x10(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_flags_encoder.c |
lzma_index_init | extern LZMA_API(lzma_index *)
lzma_index_init(const lzma_allocator *allocator)
{
lzma_index *i = index_init_plain(allocator);
if (i == NULL)
return NULL;
index_stream *s = index_stream_init(0, 0, 1, 0, allocator);
if (s == NULL) {
lzma_free(i, allocator);
return NULL;
}
index_tree_append(&i->streams, &s->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9c03f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9c038a
movq $0x0, -0x8(%rbp)
jmp 0x9c03d9
movq -0x10(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rdi
movq %rcx, %rsi
callq 0x9c0470
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index.c |
index_init_plain | static lzma_index *
index_init_plain(const lzma_allocator *allocator)
{
lzma_index *i = lzma_alloc(sizeof(lzma_index), allocator);
if (i != NULL) {
index_tree_init(&i->streams);
i->uncompressed_size = 0;
i->total_size = 0;
i->record_count = 0;
i->index_list_size = 0;
i->prealloc = INDEX_GROUP_SIZE;
i->c... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x50, %edi
callq 0x9a3040
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9c0465
movq -0x10(%rbp), %rdi
callq 0x9c2360
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rb... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index.c |
lzma_index_iter_next | extern LZMA_API(lzma_bool)
lzma_index_iter_next(lzma_index_iter *iter, lzma_index_iter_mode mode)
{
// Catch unsupported mode values.
if ((unsigned int)(mode) > LZMA_INDEX_ITER_NONEMPTY_BLOCK)
return true;
const lzma_index *i = iter->internal[ITER_INDEX].p;
const index_stream *stream = iter->internal[ITER_STREAM... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jbe 0x9c1a4e
movb $0x1, -0x1(%rbp)
jmp 0x9c1c80
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index.c |
lzma_index_iter_locate | extern LZMA_API(lzma_bool)
lzma_index_iter_locate(lzma_index_iter *iter, lzma_vli target)
{
const lzma_index *i = iter->internal[ITER_INDEX].p;
// If the target is past the end of the file, return immediately.
if (i->uncompressed_size <= target)
return true;
// Locate the Stream containing the target offset.
c... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
ja 0x9c2176
movb $0x1, -0x1(%rbp)
jmp 0x9c22a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index.c |
lzma_index_encoder_init | extern lzma_ret
lzma_index_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_index *i)
{
lzma_next_coder_init(&lzma_index_encoder_init, next, allocator);
if (i == NULL)
return LZMA_PROG_ERROR;
if (next->coder == NULL) {
next->coder = lzma_alloc(sizeof(lzma_index_coder), allocato... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x1f(%rip), %rax # 0x9c2440
cmpq 0x10(%rcx), %rax
je 0x9c2472
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a32d0
movq -0x10(%rbp), %rax
leaq -0x3d(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index_encoder.c |
lzma_index_hash_decode | extern LZMA_API(lzma_ret)
lzma_index_hash_decode(lzma_index_hash *index_hash, const uint8_t *in,
size_t *in_pos, size_t in_size)
{
// Catch zero input buffer here, because in contrast to Index encoder
// and decoder functions, applications call this function directly
// instead of via lzma_code(), which does the b... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jb 0x9c2ee1
movl $0xa, -0x4(%rbp)
jmp 0x9c33e3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index_hash.c |
lzma_vli_decode | extern LZMA_API(lzma_ret)
lzma_vli_decode(lzma_vli *restrict vli, size_t *vli_pos,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size)
{
// If we haven't been given vli_pos, work in single-call mode.
size_t vli_pos_internal = 0;
if (vli_pos == NULL) {
vli_pos = &vli_pos_internal;
*vli = 0;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9c3915
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq (%rax... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/vli_decoder.c |
lz_encode | static lzma_ret
lz_encode(void *coder_ptr, const lzma_allocator *allocator,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size,
uint8_t *restrict out, size_t *restrict out_pos,
size_t out_size, lzma_action action)
{
lzma_coder *coder = coder_ptr;
while (*out_pos < out_size
&& (*in_pos < i... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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 -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rbp), %rax
movq (... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lzma_mf_is_supported | extern LZMA_API(lzma_bool)
lzma_mf_is_supported(lzma_match_finder mf)
{
bool ret = false;
#ifdef HAVE_MF_HC3
if (mf == LZMA_MF_HC3)
ret = true;
#endif
#ifdef HAVE_MF_HC4
if (mf == LZMA_MF_HC4)
ret = true;
#endif
#ifdef HAVE_MF_BT2
if (mf == LZMA_MF_BT2)
ret = true;
#endif
#ifdef HAVE_MF_BT3
if (mf == LZM... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x0, -0x5(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x9c4795
movb $0x1, -0x5(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0x9c479f
movb $0x1, -0x5(%rbp)
cmpl $0x12, -0x4(%rbp)
jne 0x9c47a9
movb $0x1, -0x5(%rbp)
cmpl $0x13, -0x4(%rbp)
jne 0x9c47b3
movb $0x1, -0x5(%rbp)
cmpl $0x14, -0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
move_window | static void
move_window(lzma_mf *mf)
{
// Align the move to a multiple of 16 bytes. Some LZ-based encoders
// like LZMA use the lowest bits of mf->read_pos to know the
// alignment of the uncompressed data. We also get better speed
// for memmove() with aligned buffers.
assert(mf->read_pos > mf->keep_size_before);... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x9c4a5e
jmp 0x9c4a7d
leaq 0x20ddcf(%rip), %rdi # 0xbd2834
leaq 0x20dcca(%rip), %rsi # 0xbd2736
movl $0x34, %edx
leaq 0x20dde0(%rip), %rcx # 0xbd2858
call... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lzma_mf_hc4_find | extern uint32_t
lzma_mf_hc4_find(lzma_mf *mf, lzma_match *matches)
{
header_find(false, 4);
hash_4_calc();
uint32_t delta2 = pos - mf->hash[hash_2_value];
const uint32_t delta3
= pos - mf->hash[FIX_3_HASH_SIZE + hash_3_value];
const uint32_t cur_match = mf->hash[FIX_4_HASH_SIZE + hash_value];
mf->hash[hash_... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9c4e60
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x4c(%rbp), %eax
ja 0x9c5678
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x9c56... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
lzma_mf_bt2_find | extern uint32_t
lzma_mf_bt2_find(lzma_mf *mf, lzma_match *matches)
{
header_find(true, 2);
hash_2_calc();
const uint32_t cur_match = mf->hash[hash_value];
mf->hash[hash_value] = pos;
bt_find(1);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c4e60
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x24(%rbp), %eax
ja 0x9c5c25
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x9c5c... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
lzma_mf_bt4_skip | extern void
lzma_mf_bt4_skip(lzma_mf *mf, uint32_t amount)
{
do {
header_skip(true, 4);
hash_4_calc();
const uint32_t cur_match
= mf->hash[FIX_4_HASH_SIZE + hash_value];
mf->hash[hash_2_value] = pos;
mf->hash[FIX_3_HASH_SIZE + hash_3_value] = pos;
mf->hash[FIX_4_HASH_SIZE + hash_value] = pos;
bt_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9c4e60
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x10(%rbp), %eax
ja 0x9c6ec3
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x9c6f0e
cmpl $0x4, -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
normalize | static void
normalize(lzma_mf *mf)
{
assert(mf->read_pos + mf->offset == MUST_NORMALIZE_POS);
// In future we may not want to touch the lowest bits, because there
// may be match finders that use larger resolution than one byte.
const uint32_t subvalue
= (MUST_NORMALIZE_POS - mf->cyclic_size);
// & ~((UINT3... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
cmpl $-0x1, %eax
jne 0x9c70a1
jmp 0x9c70c0
leaq 0x20bb36(%rip), %rdi # 0xbd2bde
leaq 0x20b824(%rip), %rsi # 0xbd28d3
movl $0x6e, %edx
leaq 0x20bb53(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
ZSTD_createCCtx_advanced | ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
{
ZSTD_STATIC_ASSERT(zcss_init==0);
ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
{ ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_customMalloc(sizeof(ZSTD_CCtx), cu... | 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 0x9c74b0
movq $0x0, -0x8(%rbp)
jmp 0x9c75... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_freeCCtx | size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
{
if (cctx==NULL) return 0; /* support free on NULL */
RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
"not compatible with static CCtx");
{
int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);
ZSTD_freeCCtxCon... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9c79bd
movq $0x0, -0x8(%rbp)
jmp 0x9c7a2f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x308(%rax)
je 0x9c79d5
movq $-0x40, -0x8(%rbp)
jmp 0x9c7a2f
movq -0x10(%rbp), %rdi
addq $0x230, %rdi # imm = 0x230
movq -0x10(%rbp), %rs... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_CCtxParams_init_internal | static void ZSTD_CCtxParams_init_internal(ZSTD_CCtx_params* cctxParams, ZSTD_parameters const* params, int compressionLevel)
{
assert(!ZSTD_checkCParams(params->cParams));
ZSTD_memset(cctxParams, 0, sizeof(*cctxParams));
cctxParams->cParams = params->cParams;
cctxParams->fParams = params->fParams;
/... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0xb0, %edx
callq 0x3b780
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(%rc... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_CCtx_refCDict | size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
{
RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
"Can't ref a dict when ctx not in init stage.");
/* Free the existing local cdict (if any) to save memory. */
ZSTD_clearAllDicts(cctx);
cctx->cdict = cdi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd80(%rax)
je 0x9c99d7
movq $-0x3c, -0x8(%rbp)
jmp 0x9c99f7
movq -0x10(%rbp), %rdi
callq 0x9c9890
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xdd0(%rax)
movq $0x0, -0x8(%rbp)
movq -... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_getCParams_internal | static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
{
U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x9d8ae0
movq %rax, -0x28(%rbp)
cmpq $0x40000, -0x28(%rbp) # i... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_estimateCCtxSize_usingCCtxParams | size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
{
ZSTD_compressionParameters const cParams =
ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
ZSTD_useRowMatchFinderMode_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMo... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x2c(%rbp), %rdi
movq $-0x1, %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x9ca060
movq -0x10(%rbp), %rax
movl 0x90(%rax), %edi
leaq -0x2c(%rbp), %rsi
callq 0x9ca400
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %ra... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_copyCCtx | size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)
{
ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
ZSTD_buffered_policy_e const zbuff = srcCCtx->bufferedPolicy;
ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
if (pledgedS... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x209d71(%rip), %rax # 0xbd4cbc
movq %rax, -0x24(%rbp)
movl 0x209d6f(%rip), %eax # 0xbd4cc4
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xd30(%rax), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_dictNCountRepeat | static FSE_repeat ZSTD_dictNCountRepeat(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue)
{
U32 s;
if (dictMaxSymbolValue < maxSymbolValue) {
return FSE_repeat_check;
}
for (s = 0; s <= maxSymbolValue; ++s) {
if (normalizedCounter[s] == 0) {
retu... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x9ccb3f
movl $0x1, -0x4(%rbp)
jmp 0x9ccb7b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
ja 0x9ccb74
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_writeEpilogue | static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
{
BYTE* const ostart = (BYTE*)dst;
BYTE* op = ostart;
size_t fhSize = 0;
DEBUGLOG(4, "ZSTD_writeEpilogue");
RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
/* special case : empty fram... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9cd362
movq $-0x3c, -0x8(%rbp)
jmp 0x9cd484
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
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 0x9ca150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %ecx, %ecx
leaq -0x30(%rbp), %r8
leaq 0x2... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
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 0x9d1310
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /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 0x9d27f0
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_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_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 0x3cb70
cmpq $0x0, -0x18(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_shouldAttachDict | static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
const ZSTD_CCtx_params* params,
U64 pledgedSrcSize)
{
size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
int const dedicatedDictSearch = cdict->matchState.dedicated... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x168(%rax), %eax
movl %eax, %ecx
leaq 0x1fe51d(%rip), %rax # 0xbd5050
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xdc(%rax), %eax
movl %eax, -0x24(%rbp)
movb $0x1... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
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 0x9d8b12
jmp 0x9d8afb
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x9d8b14
jmp 0x9d8b05
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0x9d8b1e
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.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 0x9d9ce0
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 |
ZSTD_encodeSequences | size_t ZSTD_encodeSequences(
void* dst, size_t dstCapacity,
FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
seqDef const* ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
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, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress_sequences.c |
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 0x9da050
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x18(%r... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/../common/bitstream.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_seqDecompressedSize | static size_t ZSTD_seqDecompressedSize(seqStore_t const* seqStore, const seqDef* sequences, size_t nbSeq, size_t litSize, int lastSequence) {
const seqDef* const sstart = sequences;
const seqDef* const send = sequences + nbSeq;
const seqDef* sp = sstart;
size_t matchLengthSum = 0;
size_t litLengthSu... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp... | /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 |
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_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_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 0xa4fb08
jmp 0xa4fae1
movl -0xbc(%rbp), %eax
subl $0x5, %eax
je 0xa4fbac
jmp 0xa4faf2
movl -0xbc... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_lazy.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 0xa7a611
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 0xa7afe3
jmp 0xa7afcc
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xa7aff4
jmp 0xa7afd6
movl -0x1c(%... | /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 0xa7b6a0
cmpl $0x0, %eax
je 0xa7b621
callq 0xa7b660
cmpl $0x0, %eax
je 0xa7b611
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0xa7b64f
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_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_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 0xadaf00
cmpl $0x0, %eax
je 0xadb051
callq 0xadb090
cmpl $0x0, %eax
je 0xadb041
movq -0x10(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0xadb07f
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 |
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 0xadb0a0
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 |
ZSTD_optLdm_maybeAddMatch | static void ZSTD_optLdm_maybeAddMatch(ZSTD_match_t* matches, U32* nbMatches,
ZSTD_optLdm_t* optLdm, U32 currPosInBlock) {
U32 posDiff = currPosInBlock - optLdm->startPosInBlock;
/* Note: ZSTD_match_t actually contains offCode and matchLength (before subtracting MINMATCH) */... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
subl 0x28(%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x28(%rcx), %eax
subl -0x20(%rbp), %ea... | /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 0xadc46d
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_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 0xade6bd
movq $-0x46, -0x8(%rbp)
jmp 0xade6fd
cmpq $0x0, -0x10(%rbp)
jne 0xade6e1
cmpq $0x0, -0x28(%rbp)
jne 0xade6d5
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_loadDictionary_advanced | size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType)
{
RETURN_ERROR_IF(dctx->stre... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x760c(%rax)
je 0xadf1c5
movq $-0x3c, -0x8(%rbp)
jmp 0xadf26c
movq -0x10(%rbp), %rdi
callq 0xadca40
cmpq $0x0, -0x18(%rbp)
je 0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_DCtx_getParameter | size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
{
switch (param) {
case ZSTD_d_windowLogMax:
*value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);
return 0;
case ZSTD_d_format:
*value = (int)dctx->format;
return 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x64, %eax
je 0xadfc33
jmp 0xadfc00
movl -0x24(%rbp), %eax
subl $0x3e8, %eax # imm = 0x3E8
je 0xadfc57
jmp 0xadfc0c
movl -0x24(%rbp), %eax
subl ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.c |
ZSTD_checkOutBuffer | static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
{
ZSTD_outBuffer const expect = zds->expectedOutBuffer;
/* No requirement when ZSTD_obm_stable is not enabled. */
if (zds->outBufferMode != ZSTD_bm_stable)
return 0;
/* Any buffer is allowed in zdss_init, th... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x7678(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x7680(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x7688(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x7670(%rax)
je 0xae0ec8
movq $0x0, -0x8(%rbp)
jm... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/decompress/zstd_decompress.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/decompress/../common/mem.h |
FSE_readNCount_bmi2 | size_t FSE_readNCount_bmi2(
short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
const void* headerBuffer, size_t hbSize, int bmi2)
{
#if DYNAMIC_BMI2
if (bmi2) {
return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
}
#endif
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xae1db0
addq $0x30, ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/entropy_common.c |
HUF_readStats_wksp | size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats,
U32* nbSymbolsPtr, U32* tableLogPtr,
const void* src, size_t srcSize,
void* workSpace, size_t wkspSize,
int bmi2)
{
#if DYNAMIC_BMI2
if (bmi2) {
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x28(%rbp), %eax
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(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/entropy_common.c |
FSE_buildDTable_raw | size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
{
void* ptr = dt;
FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
void* dPtr = dt + 1;
FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
const unsigned tableSize = 1 << nbBits;
const unsigned tableMask = tableSize - 1;
con... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/fse_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 0xae4c45
movl $0x3, -0x4(%rbp)
jmp 0xae4d39
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0xae4c68
movq -0x10(%rbp), %rdi
callq 0xae4ff0
movl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/bitstream.h |
XXH_swap32 | static U32 XXH_swap32 (U32 x)
{
return ((x << 24) & 0xff000000 ) |
((x << 8) & 0x00ff0000 ) |
((x >> 8) & 0x0000ff00 ) |
((x >> 24) & 0x000000ff );
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x18, %eax
andl $0xff000000, %eax # imm = 0xFF000000
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/common/xxhash.c |
FSE_normalizeCount | size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
const unsigned* count, size_t total,
unsigned maxSymbolValue, unsigned useLowProbCount)
{
/* Sanity checks */
if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
if (tableLog < FSE_MIN... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xaebb9f
movl $0xb, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jae 0xaebbb2
movq $-0x1, -0x8(%rbp)
jmp 0xaebe0c
cmpl $0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.c |
FSE_buildCTable_raw | size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
{
const unsigned tableSize = 1 << nbBits;
const unsigned tableMask = tableSize - 1;
const unsigned maxSymbolValue = tableMask;
void* const ptr = ct;
U16* const tableU16 = ( (U16*) ptr) + 2;
void* const FSCT = ((U32*)ptr) + 1 /* header ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/fse_compress.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 |
HUF_readCTable | size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)
{
BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; /* init not required, even though some static analyzer may complain */
U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1]; /* large enough for v... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x174(%rbp)
movl $0x0, -0x178(%rbp)
leaq -0x130(%rbp), %rdi
leaq -0x170(%rbp), %rdx
movq -0x20(%rbp), %r9
movq -0x28(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/huf_compress.c |
HUF_sort | static void HUF_sort(nodeElt* huffNode, const unsigned* count, U32 maxSymbolValue, rankPos* rankPosition)
{
int n;
int const maxSymbolValue1 = (int)maxSymbolValue + 1;
/* Compute base and set curr to base.
* For symbol s let lowerRank = BIT_highbit32(count[n]+1) and rank = lowerRank + 1.
* Then 2... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx # imm = 0x100
callq 0x3b780
movl $0x0, -0x24(%rbp)
movl... | /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_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 0xaeff40
cmpl $0x0, %eax
je 0xaefffc
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0xaf0030
jmp 0xaf0020
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 |
uv__tcp_keepalive | int uv__tcp_keepalive(int fd, int on, unsigned int delay) {
if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on)))
return UV__ERR(errno);
#ifdef TCP_KEEPIDLE
if (on) {
int intvl = 1; /* 1 second; same as default on Win32 */
int cnt = 10; /* 10 retries; same as hardcoded on Win32 */
if (s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x3ccf0
cmpl $0x0, %eax
je 0xb20c06
callq 0x3e130
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_cond_timedwait | int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) {
int r;
struct timespec ts;
#if defined(__MVS__)
struct timeval tv;
#endif
#if defined(__APPLE__) && defined(__MACH__)
ts.tv_sec = timeout / NANOSEC;
ts.tv_nsec = timeout % NANOSEC;
r = pthread_cond_timedwait_relative_np(cond, mut... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %edi, %edi
callq 0xb263d0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
movq -0x20... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_tty_get_winsize | int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
struct winsize ws;
int err;
do
err = ioctl(uv__stream_fd(tty), TIOCGWINSZ, &ws);
while (err == -1 && errno == EINTR);
if (err == -1)
return UV__ERR(errno);
*width = ws.ws_col;
*height = ws.ws_row;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %edi
movl $0x5413, %esi # imm = 0x5413
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x3b2f0
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x2c(%rbp)
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
cmpxchgi | UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval)) {
#if defined(__i386__) || defined(__x86_64__)
int out;
__asm__ __volatile__ ("lock; cmpxchg %2, %1;"
: "=a" (out), "+m" (*(volatile int*) ptr)
: "r" (newval), "0" (oldval)
: "mem... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %eax
lock
cmpxchgl %edx, (%rcx)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/atomic-ops.h |
read_models | static int read_models(unsigned int numcpus, uv_cpu_info_t* ci) {
#if defined(__PPC__)
static const char model_marker[] = "cpu\t\t: ";
static const char speed_marker[] = "clock\t\t: ";
#else
static const char model_marker[] = "model name\t: ";
static const char speed_marker[] = "cpu MHz\t\t: ";
#endif
const c... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0x7869b(%rip), %rdi # 0xb9f079
callq 0xb0fbb0
movq %rax, -0x440(%rbp)
cmpq $0x0, -0x440(%rbp)
jne 0xb26a08
callq 0x3e130
movq %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_interface_addresses | int uv_interface_addresses(uv_interface_address_t** addresses, int* count) {
#ifndef HAVE_IFADDRS_H
*count = 0;
*addresses = NULL;
return UV_ENOSYS;
#else
struct ifaddrs *addrs, *ent;
uv_interface_address_t* address;
int i;
struct sockaddr_ll *sll;
*count = 0;
*addresses = NULL;
if (getifaddrs(&ad... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x3df30
cmpl $0x0, %eax
je 0xb26f47
callq 0x3e130
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_fs_event_stop | int uv_fs_event_stop(uv_fs_event_t* handle) {
struct watcher_list* w;
if (!uv__is_active(handle))
return 0;
w = find_watcher(handle->loop, handle->wd);
assert(w != NULL);
handle->wd = -1;
handle->path = NULL;
uv__handle_stop(handle);
QUEUE_REMOVE(&handle->watchers);
maybe_free_watcher_list(w, ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0xb27cc7
movl $0x0, -0x4(%rbp)
jmp 0xb27da9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x80(%rax), %esi
callq 0xb28180
movq %rax, -0x18(%rbp)
c... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv_get_process_title | int uv_get_process_title(char* buffer, size_t size) {
if (buffer == NULL || size == 0)
return UV_EINVAL;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
uv_once(&process_title_mutex_once, init_process_title_mutex_once);
uv_mutex_lock(&proce... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb299ce
cmpq $0x0, -0x18(%rbp)
jne 0xb299da
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xb29a78
cmpq $0x0, 0x3dfa2e(%rip) # 0xf09410
jne 0xb299f0
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
uv_inet_pton | int uv_inet_pton(int af, const char* src, void* dst) {
if (src == NULL || dst == NULL)
return UV_EINVAL;
switch (af) {
case AF_INET:
return (inet_pton4(src, dst));
case AF_INET6: {
int len;
char tmp[UV__INET6_ADDRSTRLEN], *s, *p;
s = (char*) src;
p = strchr(src, '%');
if (p != NULL)... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb2a941
cmpq $0x0, -0x18(%rbp)
jne 0xb2a94d
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xb2a9f5
movl -0x8(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $0x2, %eax
je 0xb2a967
jmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
slide_hash | local void slide_hash(s)
deflate_state *s;
{
unsigned n, m;
Posf *p;
uInt wsize = s->w_size;
n = s->hash_size;
p = &s->head[n];
do {
m = *--p;
*p = (Pos)(m >= wsize ? m - wsize : NIL);
} while (--n);
n = wsize;
#ifndef FASTEST
p = &s->prev[n];
do {
m ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movl -0xc(%rbp), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_gzseek64 | z_off64_t ZEXPORT gzseek64(file, offset, whence)
gzFile file;
z_off64_t offset;
int whence;
{
unsigned n;
z_off64_t ret;
gz_statep state;
/* get internal structure and check integrity */
if (file == NULL)
return -1;
state = (gz_statep)file;
if (state->mode != GZ_READ && ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb32c77
movq $-0x1, -0x8(%rbp)
jmp 0xb32ef9
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x1c4f, 0x18(%rax) # imm = 0x1C4F
je 0xb32ca6
movq -0x30... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzlib.c |
cm_zlib_gzread | int ZEXPORT gzread(file, buf, len)
gzFile file;
voidp buf;
unsigned len;
{
gz_statep state;
/* get internal structure */
if (file == NULL)
return -1;
state = (gz_statep)file;
/* check that we're reading and that there's no (serious) error */
if (state->mode != GZ_READ ||
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb33446
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb334da
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1c4f, 0x18(%rax) # imm = 0x1C... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzread.c |
gz_fetch | local int gz_fetch(state)
gz_statep state;
{
z_streamp strm = &(state->strm);
do {
switch(state->how) {
case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
if (gz_look(state) == -1)
return -1;
if (state->how == LOOK)
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xb33e45
jmp 0xb33e2a
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xb33e7a
jmp 0xb33e34
movl -0x1c(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzread.c |
gz_look | local int gz_look(state)
gz_statep state;
{
z_streamp strm = &(state->strm);
/* allocate read buffers and inflate memory */
if (state->size == 0) {
/* allocate buffers */
state->in = (unsigned char *)malloc(state->want);
state->out = (unsigned char *)malloc(state->want << 1);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xb34125
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, %edi
callq 0x3e578
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%r... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzread.c |
gz_write | local z_size_t gz_write(state, buf, len)
gz_statep state;
voidpc buf;
z_size_t len;
{
z_size_t put = len;
/* if len is zero, avoid unnecessary operations */
if (len == 0)
return 0;
/* allocate memory if this is the first time through */
if (state->size == 0 && gz_init(state) ==... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb347a0
movq $0x0, -0x8(%rbp)
jmp 0xb349b2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xb347c5
movq -0x10(%rbp), %rdi
callq 0xb... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzwrite.c |
gz_init | local int gz_init(state)
gz_statep state;
{
int ret;
z_streamp strm = &(state->strm);
/* allocate input buffer (double size for gzprintf) */
state->in = (unsigned char *)malloc(state->want << 1);
if (state->in == NULL) {
gz_error(state, Z_MEM_ERROR, "out of memory");
return -1;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %edi
callq 0x3e578
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq ... | /JKorbelRA[P]CMake/Utilities/cmzlib/gzwrite.c |
cm_zlib_inflateInit2_ | int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
z_streamp strm;
int windowBits;
const char *version;
int stream_size;
{
int ret;
struct inflate_state FAR *state;
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
stream_size != (int)(sizeof(z_stream)))
return Z_VERS... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb35bd5
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl 0x6e972(%rip), %ecx # 0xba453d
cmpl %ecx, %eax
jne 0xb35bd5
cmpl $0x70, -0x24(%rbp)
je 0xb35be1... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
fixedtables | local void fixedtables(state)
struct inflate_state FAR *state;
{
#ifdef BUILDFIXED
static int virgin = 1;
static code *lenfix, *distfix;
static code fixed[544];
/* build fixed huffman tables if first call (may not be thread safe) */
if (virgin) {
unsigned sym, bits;
static code *nex... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0xacd2d(%rip), %rcx # 0xbe5230
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0xad513(%rip), %rcx # 0xbe5a30
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x7c(%rax)
popq %rbp
retq
... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateUndermine | int ZEXPORT inflateUndermine(strm, subvert)
z_streamp strm;
int subvert;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
state->sane = !subvert;
return Z_OK;
#el... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb359c0
cmpl $0x0, %eax
je 0xb38fb6
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xb38fd7
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, 0... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib__tr_align | void ZLIB_INTERNAL _tr_align(s)
deflate_state *s;
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %eax
movl $0x10, %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0xb39e85
movl $0x2, -0x10(%rbp)
movl -0x10(%rbp), %eax
movzwl %ax, %edx
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %ecx
shll %cl,... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
build_tree | local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
int elems = desc->stat_desc->elems;
int n, m; /* iterate over heap elements */
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
pqdownheap | local void pqdownheap(s, tree, k)
deflate_state *s;
ct_data *tree; /* the tree to restore */
int k; /* node to move down */
{
int v = s->heap[k];
int j = k << 1; /* left son of k */
while (j <= s->heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s-... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0xbc0(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14b4(%rcx), %eax
... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
gen_codes | local void gen_codes (tree, max_code, bl_count)
ct_data *tree; /* the tree to decorate */
int max_code; /* largest code with non zero frequency */
ushf *bl_count; /* number of codes at each bit length */
{
ush next_code[MAX_BITS+1]; /* next code value for each bit len... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x1, -0x48(%rbp)
cmpl $0xf, -0x48(%rbp)
jg 0xb3beac
movl -0x44(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ec... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
adler32_combine_ | local uLong adler32_combine_(adler1, adler2, len2)
uLong adler1;
uLong adler2;
z_off64_t len2;
{
unsigned long sum1;
unsigned long sum2;
unsigned rem;
/* for negative len, return invalid adler32 as a clue for debugging */
if (len2 < 0)
return 0xffffffffUL;
/* the derivation... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0xb3d345
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0xb3d44d
movq -0x20(%rbp), %rax
movl $0xfff1, %ecx # imm = 0xFFF1
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzlib/adler32.c |
pause_if_needed() | void pause_if_needed() {
#ifdef _WIN32
// For Windows, prompt for a keystroke before the Gnuplot object goes out of scope so that
// the gnuplot window doesn't get closed.
std::cout << "Press enter to exit." << std::endl;
std::cin.get();
#endif
} | retq
| /dstahlke[P]gnuplot-iostream/example-misc.cc |
demo_binary() | void demo_binary() {
Gnuplot gp;
std::vector<std::pair<double, double>> xy_pts_A;
for(double x=-2; x<2; x+=0.01) {
double y = x*x*x;
xy_pts_A.emplace_back(x, y);
}
std::vector<std::pair<double, double>> xy_pts_B;
for(double alpha=0; alpha<1; alpha+=1.0/24.0) {
double th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x2a0, %rsp # imm = 0x2A0
leaq 0xa8f3(%rip), %rsi # 0x10241
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x7ab6
leaq 0xd8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7af2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5190
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %r14... | /dstahlke[P]gnuplot-iostream/example-misc.cc |
demo_tmpfile() | void demo_tmpfile() {
Gnuplot gp;
std::vector<std::pair<double, double>> xy_pts_A;
for(double x=-2; x<2; x+=0.01) {
double y = x*x*x;
xy_pts_A.emplace_back(x, y);
}
std::vector<std::pair<double, double>> xy_pts_B;
for(double alpha=0; alpha<1; alpha+=1.0/24.0) {
double t... | pushq %r15
pushq %r14
pushq %rbx
subq $0x2a0, %rsp # imm = 0x2A0
leaq 0xa5cf(%rip), %rsi # 0x10241
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x7ab6
leaq 0xd8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7af2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5190
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %r14... | /dstahlke[P]gnuplot-iostream/example-misc.cc |
demo_image() | void demo_image() {
// Example of plotting an image. Of course you are free (and encouraged) to
// use Blitz or Armadillo rather than std::vector in these situations.
Gnuplot gp;
std::vector<std::vector<double>> image;
for(int j=0; j<100; j++) {
std::vector<double> row;
for(int i=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
leaq 0x935b(%rip), %rsi # 0x10241
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x7ab6
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7af2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5190
xorpd %... | /dstahlke[P]gnuplot-iostream/example-misc.cc |
gnuplotio::Gnuplot::Gnuplot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit Gnuplot(const std::string &_cmd="") :
FileHandleWrapper(open_cmdline(_cmd)),
boost::iostreams::stream<boost::iostreams::file_descriptor_sink>(
fh_fileno(),
#if BOOST_VERSION >= 104400
boost::iostreams::never_close_handle
#else
false
#endif
),
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc0(%rdi), %rbx
movq %rbx, %rdi
callq 0x5140
movq %r15, %rdi
callq 0x8222
leaq 0x90(%r14), %rdi
movq %rax, 0x90(%r14)
movb %dl, 0x98(%r14)
leaq 0x11845(%rip), %r15 # 0x19378
movq %r15, (%r14)
leaq 0x11863(%rip), %r12 # ... | /dstahlke[P]gnuplot-iostream/gnuplot-iostream.h |
gnuplotio::Gnuplot::Gnuplot(_IO_FILE*) | explicit Gnuplot(FILE *_fh) :
FileHandleWrapper(_fh, 0),
boost::iostreams::stream<boost::iostreams::file_descriptor_sink>(
fh_fileno(),
#if BOOST_VERSION >= 104400
boost::iostreams::never_close_handle
#else
false
#endif
),
feedback(nullptr),
tm... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc0(%rdi), %rbx
movq %rbx, %rdi
callq 0x5140
leaq 0x90(%r14), %rdi
movq %r15, 0x90(%r14)
movb $0x0, 0x98(%r14)
leaq 0x1156c(%rip), %r15 # 0x19378
movq %r15, (%r14)
leaq 0x1158a(%rip), %r12 # 0x193a0
movq %r12, 0xc0(%r14... | /dstahlke[P]gnuplot-iostream/gnuplot-iostream.h |
virtual thunk to gnuplotio::Gnuplot::~Gnuplot() | ~Gnuplot() {
if(debug_messages) {
std::cerr << "ending gnuplot session" << std::endl;
}
// FIXME - boost's close method calls close() on the file descriptor, but we need to
// use sometimes use pclose instead. For now, just skip calling boost's close and use
// flus... | movq (%rdi), %rax
addq -0x18(%rax), %rdi
jmp 0x7c7c
| /dstahlke[P]gnuplot-iostream/gnuplot-iostream.h |
virtual thunk to gnuplotio::Gnuplot::~Gnuplot() | ~Gnuplot() {
if(debug_messages) {
std::cerr << "ending gnuplot session" << std::endl;
}
// FIXME - boost's close method calls close() on the file descriptor, but we need to
// use sometimes use pclose instead. For now, just skip calling boost's close and use
// flus... | movq (%rdi), %rax
addq -0x18(%rax), %rdi
jmp 0x8508
| /dstahlke[P]gnuplot-iostream/gnuplot-iostream.h |
gnuplotio::Gnuplot::get_default_cmd[abi:cxx11]() | static std::string get_default_cmd() {
GNUPLOT_MSVC_WARNING_4996_PUSH
char *from_env = std::getenv("GNUPLOT_IOSTREAM_CMD");
GNUPLOT_MSVC_WARNING_4996_POP
if(from_env && from_env[0]) {
return from_env;
} else {
return GNUPLOT_DEFAULT_COMMAND;
}
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8184(%rip), %rdi # 0x106cb
callq 0x53c0
testq %rax, %rax
je 0x8563
cmpb $0x0, (%rax)
je 0x8563
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x8572
leaq 0x8176(%rip), %rsi # 0x106e0
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x7ab6
movq %rbx, %rax
... | /dstahlke[P]gnuplot-iostream/gnuplot-iostream.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.