name string | code string | asm string | file string |
|---|---|---|---|
lzma2_decode | static lzma_ret
lzma2_decode(void *coder_ptr, lzma_dict *restrict dict,
const uint8_t *restrict in, size_t *restrict in_pos,
size_t in_size)
{
lzma_lzma2_coder *restrict coder = coder_ptr;
// With SEQ_LZMA it is possible that no new input is needed to do
// some progress. The rest of the sequences assume that t... | 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 %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpq -0x30(%rbp), %rcx
movb %al, -0x59(%rbp)
jb 0x11c293
mov... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_decoder.c |
dict_write | static inline void
dict_write(lzma_dict *restrict dict, const uint8_t *restrict in,
size_t *restrict in_pos, size_t in_size,
size_t *restrict left)
{
// NOTE: If we are being given more data than the size of the
// dictionary, it could be possible to optimize the LZ decoder
// so that not everything needs to go ... | 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)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x11c762
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_decoder.h |
lzma2_encoder_init | static lzma_ret
lzma2_encoder_init(lzma_lz_encoder *lz, const lzma_allocator *allocator,
const void *options, lzma_lz_options *lz_options)
{
if (options == NULL)
return LZMA_PROG_ERROR;
lzma_lzma2_coder *coder = lz->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_lzma2_coder), allocator);
if (cod... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11c83b
movl $0xb, -0x4(%rbp)
jmp 0x11c97c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11c8b6
movq -0x18(%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
lzma2_encode | static lzma_ret
lzma2_encode(void *coder_ptr, lzma_mf *restrict mf,
uint8_t *restrict out, size_t *restrict out_pos,
size_t out_size)
{
lzma_lzma2_coder *restrict coder = coder_ptr;
while (*out_pos < out_size)
switch (coder->sequence) {
case SEQ_INIT:
// If there's no input left and we are flushing or finish... | 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 -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jae 0x11cf35
movq -0x38(%rbp), %rax
movl (%rax), %ea... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
lzma2_encoder_options_update | static lzma_ret
lzma2_encoder_options_update(void *coder_ptr, const lzma_filter *filter)
{
lzma_lzma2_coder *coder = coder_ptr;
// New options can be set only when there is no incomplete chunk.
// This is the case at the beginning of the raw stream and right
// after LZMA_SYNC_FLUSH.
if (filter->options == NULL |... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x11cfb8
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x11cfc4
movl $0xb, -0x4(%rbp)
jmp 0x11d081
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
lzma2_header_uncompressed | static void
lzma2_header_uncompressed(lzma_lzma2_coder *coder)
{
assert(coder->uncompressed_size > 0);
assert(coder->uncompressed_size <= LZMA2_CHUNK_MAX);
// If this is the first chunk, we need to include dictionary
// reset indicator.
if (coder->need_dictionary_reset)
coder->buf[0] = 1;
else
coder->buf[0] ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jbe 0x11d0cc
jmp 0x11d0eb
leaq 0x1a903a(%rip), %rdi # 0x2c610d
leaq 0x1a8f28(%rip), %rsi # 0x2c6002
movl $0x71, %edx
leaq 0x1a9044(%rip), %rcx # 0x2c612a
callq 0x103e0
movq -0x8(%rbp), %rax
cmpq $0x100... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
lzma2_header_lzma | static void
lzma2_header_lzma(lzma_lzma2_coder *coder)
{
assert(coder->uncompressed_size > 0);
assert(coder->uncompressed_size <= LZMA2_UNCOMPRESSED_MAX);
assert(coder->compressed_size > 0);
assert(coder->compressed_size <= LZMA2_CHUNK_MAX);
size_t pos;
if (coder->need_properties) {
pos = 0;
if (coder->nee... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jbe 0x11d1cc
jmp 0x11d1eb
leaq 0x1a8f3a(%rip), %rdi # 0x2c610d
leaq 0x1a8e28(%rip), %rsi # 0x2c6002
movl $0x39, %edx
leaq 0x1a8fa3(%rip), %rcx # 0x2c6189
callq 0x103e0
movq -0x8(%rbp), %rax
cmpq $0x200... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
mf_read | static inline void
mf_read(lzma_mf *mf, uint8_t *out, size_t *out_pos, size_t out_size,
size_t *left)
{
const size_t out_avail = out_size - *out_pos;
const size_t copy_size = my_min(out_avail, *left);
assert(mf->read_ahead == 0);
assert(mf->read_pos >= *left);
memcpy(out + *out_pos, mf->buffer + mf->read_pos -... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x11d4a2... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.h |
lzma_decode | static lzma_ret
lzma_decode(void *coder_ptr, lzma_dict *restrict dictptr,
const uint8_t *restrict in,
size_t *restrict in_pos, size_t in_size)
{
lzma_lzma1_decoder *restrict coder = coder_ptr;
////////////////////
// Initialization //
////////////////////
{
const lzma_ret ret = rc_read_init(
&coder->rc... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
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 %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x6e6c, %rdi # imm = 0x6E6C
movq -0x20(%rbp), %rsi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_decoder.c |
read32le | static inline uint32_t
read32le(const uint8_t *buf)
{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
uint32_t num = read32ne(buf);
return conv32le(num);
#else
uint32_t num = (uint32_t)buf[0];
num |= (uint32_t)buf[1] << 8;
num |= (uint32_t)buf[2] << 16;
num |= (uint32_t)buf[3] << 24;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x125660
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
rc_read_init | static inline lzma_ret
rc_read_init(lzma_range_decoder *rc, const uint8_t *restrict in,
size_t *restrict in_pos, size_t in_size)
{
while (rc->init_bytes_left > 0) {
if (*in_pos == in_size)
return LZMA_OK;
// The first byte is always 0x00. It could have been omitted
// in LZMA2 but it wasn't, so one byte is... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jbe 0x12521d
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x1251b4
movl $0x0, -0x4(%rbp)
jmp 0x125224
movq -0x10(%rbp), %rax
cmpl $0x5... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/range_decoder.h |
encode_symbol | static void
encode_symbol(lzma_lzma1_encoder *coder, lzma_mf *mf,
uint32_t back, uint32_t len, uint32_t position)
{
const uint32_t pos_state = position & coder->pos_mask;
if (back == UINT32_MAX) {
// Literal i.e. eight-bit byte
assert(len == 1);
rc_bit(&coder->rc,
&coder->is_match[coder->state][pos_state... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
andl 0xb90(%rcx), %eax
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x125d4c
cmpl $0x1, -0x18(%rbp)
jne 0x125ce... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
length_encoder_reset | static void
length_encoder_reset(lzma_length_encoder *lencoder,
const uint32_t num_pos_states, const bool fast_mode)
{
bit_reset(lencoder->choice);
bit_reset(lencoder->choice2);
for (size_t pos_state = 0; pos_state < num_pos_states; ++pos_state) {
bittree_reset(lencoder->low[pos_state], LEN_LOW_BITS);
bittree... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movw $0x400, (%rax) # imm = 0x400
movq -0x8(%rbp), %rax
movw $0x400, 0x2(%rax) # imm = 0x400
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
set_lz_options | static void
set_lz_options(lzma_lz_options *lz_options, const lzma_options_lzma *options)
{
// LZ encoder initialization does the validation for these so we
// don't need to validate here.
lz_options->before_size = OPTS;
lz_options->dict_size = options->dict_size;
lz_options->after_size = LOOP_INPUT_MAX;
lz_optio... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x1000, (%rax) # imm = 0x1000
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x1001, 0x10(%rax) # imm = 0x1001
movq -0x8(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
write32ne | static inline void
write32ne(uint8_t *buf, uint32_t num)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
*(uint32_t *)buf = num;
#else
memcpy(buf, &num, sizeof(num));
#endif
return;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
rc_bittree | static inline void
rc_bittree(lzma_range_encoder *rc, probability *probs,
uint32_t bit_count, uint32_t symbol)
{
uint32_t model_index = 1;
do {
const uint32_t bit = (symbol >> --bit_count) & 1;
rc_bit(rc, &probs[model_index], bit);
model_index = (model_index << 1) + bit;
} while (bit_count != 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/range_encoder.h |
match | static inline void
match(lzma_lzma1_encoder *coder, const uint32_t pos_state,
const uint32_t distance, const uint32_t len)
{
update_match(coder->state);
length(&coder->rc, &coder->match_len_encoder, pos_state, len,
coder->fast_mode);
const uint32_t dist_slot = get_dist_slot(distance);
const uint32_t dist_sta... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x2e0(%rax), %edx
movl $0xa, %ecx
movl $0x7, %eax
cmpl $0x7, %edx
cmovbl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2e0(%rax)
movq -0x8(%rbp), %rdi
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
length | static inline void
length(lzma_range_encoder *rc, lzma_length_encoder *lc,
const uint32_t pos_state, uint32_t len, const bool fast_mode)
{
assert(len <= MATCH_LEN_MAX);
len -= MATCH_LEN_MIN;
if (len < LEN_LOW_SYMBOLS) {
rc_bit(rc, &lc->choice, 0);
rc_bittree(rc, lc->low[pos_state], LEN_LOW_BITS, len);
} else... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpl $0x111, -0x18(%rbp) # imm = 0x111
ja 0x127169
jmp 0x127188
leaq 0x19f4aa(%rip), %rdi # 0x2c661a
leaq 0x19f671(%rip), %rsi... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
length_update_prices | static void
length_update_prices(lzma_length_encoder *lc, const uint32_t pos_state)
{
const uint32_t table_size = lc->table_size;
lc->counters[pos_state] = table_size;
const uint32_t a0 = rc_bit_0_price(lc->choice);
const uint32_t a1 = rc_bit_1_price(lc->choice);
const uint32_t b0 = a1 + rc_bit_0_price(lc->choice... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4804(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, 0x4808(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x127460
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
rc_bittree_price | static inline uint32_t
rc_bittree_price(const probability *const probs,
const uint32_t bit_levels, uint32_t symbol)
{
uint32_t price = 0;
symbol += UINT32_C(1) << bit_levels;
do {
const uint32_t bit = symbol & 1;
symbol >>= 1;
price += rc_bit_price(probs[symbol], bit);
} while (symbol != 1);
return price... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
sh... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/price.h |
get_dist_slot | static inline uint32_t
get_dist_slot(uint32_t dist)
{
// If it is small enough, we can pick the result directly from
// the precalculated table.
if (dist < fastpos_limit(0, 0))
return lzma_fastpos[dist];
if (dist < fastpos_limit(0, 1))
return fastpos_result(dist, 0, 1);
return fastpos_result(dist, 0, 2);
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2000, -0x8(%rbp) # imm = 0x2000
jae 0x127595
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x1a34d4(%rip), %rax # 0x2caa60
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x1275d6
cmpl $0x2000000, -0x8(%rbp) # imm = 0x2000000
jae 0x1275bb
movl -0x8(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/fastpos.h |
rc_bittree_reverse | static inline void
rc_bittree_reverse(lzma_range_encoder *rc, probability *probs,
uint32_t bit_count, uint32_t symbol)
{
uint32_t model_index = 1;
do {
const uint32_t bit = symbol & 1;
symbol >>= 1;
rc_bit(rc, &probs[model_index], bit);
model_index = (model_index << 1) + bit;
} while (--bit_count != 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/range_encoder.h |
lzma_lzma_optimum_fast | extern void
lzma_lzma_optimum_fast(lzma_lzma1_encoder *restrict coder,
lzma_mf *restrict mf,
uint32_t *restrict back_res, uint32_t *restrict len_res)
{
const uint32_t nice_len = mf->nice_len;
uint32_t len_main;
uint32_t matches_count;
if (mf->read_ahead == 0) {
len_main = mf_find(mf, &matches_count, coder->m... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x38(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x12775c
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
addq $0x2f4,... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_fast.c |
read16ne | static inline uint16_t
read16ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint16_t *)buf;
#else
uint16_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
popq %rbp
retq
nopl (%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
read64ne | static inline uint64_t
read64ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint64_t *)buf;
#else
uint64_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
fill_dist_prices | static void
fill_dist_prices(lzma_lzma1_encoder *coder)
{
for (uint32_t dist_state = 0; dist_state < DIST_STATES; ++dist_state) {
uint32_t *const dist_slot_prices
= coder->dist_slot_prices[dist_state];
// Price to encode the dist_slot.
for (uint32_t dist_slot = 0;
dist_slot < coder->dist_table_size; ++... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x1281d0
movq -0x8(%rbp), %rax
addq $0x10290, %rax # imm = 0x10290
movl -0xc(%rbp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
fill_align_prices | static void
fill_align_prices(lzma_lzma1_encoder *coder)
{
for (uint32_t i = 0; i < ALIGN_SIZE; ++i)
coder->align_prices[i] = rc_bittree_reverse_price(
coder->dist_align, ALIGN_BITS, i);
coder->align_price_count = 0;
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0x12830c
movq -0x8(%rbp), %rdi
addq $0x71e0, %rdi # imm = 0x71E0
movl -0xc(%rbp), %edx
movl $0x4, %esi
callq 0x12aed0
movl %eax, %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, 0x10e9... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
helper2 | static inline uint32_t
helper2(lzma_lzma1_encoder *coder, uint32_t *reps, const uint8_t *buf,
uint32_t len_end, uint32_t position, const uint32_t cur,
const uint32_t nice_len, const uint32_t buf_avail_full)
{
uint32_t matches_count = coder->matches_count;
uint32_t new_len = coder->longest_match_length;
uint32_t ... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0xb0(%rbp)
movq %rsi, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movl %ecx, -0xc4(%rbp)
movl %r8d, -0xc8(%rbp)
movl %r9d, -0xcc(%rbp)
movq -0xb0(%rbp), %rax
movl 0xb84(%rax), %eax
movl %eax, -0xd0(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
backward | static void
backward(lzma_lzma1_encoder *restrict coder, uint32_t *restrict len_res,
uint32_t *restrict back_res, uint32_t cur)
{
coder->opts_end_index = cur;
uint32_t pos_mem = coder->opts[cur].pos_prev;
uint32_t back_mem = coder->opts[cur].back_prev;
do {
if (coder->opts[cur].prev_1_is_literal) {
make_li... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10edc(%rax)
movq -0x8(%rbp), %rax
addq $0x10ee4, %rax # imm = 0x10EE4
movl -0x1c(%rbp), %ecx
imulq $0x2c, %rcx, %rcx
a... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
rc_bittree_price | static inline uint32_t
rc_bittree_price(const probability *const probs,
const uint32_t bit_levels, uint32_t symbol)
{
uint32_t price = 0;
symbol += UINT32_C(1) << bit_levels;
do {
const uint32_t bit = symbol & 1;
symbol >>= 1;
price += rc_bit_price(probs[symbol], bit);
} while (symbol != 1);
return price... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
sh... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/price.h |
get_dist_slot | static inline uint32_t
get_dist_slot(uint32_t dist)
{
// If it is small enough, we can pick the result directly from
// the precalculated table.
if (dist < fastpos_limit(0, 0))
return lzma_fastpos[dist];
if (dist < fastpos_limit(0, 1))
return fastpos_result(dist, 0, 1);
return fastpos_result(dist, 0, 2);
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2000, -0x8(%rbp) # imm = 0x2000
jae 0x12ae85
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x19fbe4(%rip), %rax # 0x2caa60
movzbl (%rax,%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x12aec6
cmpl $0x2000000, -0x8(%rbp) # imm = 0x2000000
jae 0x12aeab
movl -0x8(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/fastpos.h |
rc_bittree_reverse_price | static inline uint32_t
rc_bittree_reverse_price(const probability *const probs,
uint32_t bit_levels, uint32_t symbol)
{
uint32_t price = 0;
uint32_t model_index = 1;
do {
const uint32_t bit = symbol & 1;
symbol >>= 1;
price += rc_bit_price(probs[model_index], bit);
model_index = (model_index << 1) + bit;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/price.h |
get_literal_price | static uint32_t
get_literal_price(const lzma_lzma1_encoder *const coder, const uint32_t pos,
const uint32_t prev_byte, const bool match_mode,
uint32_t match_byte, uint32_t symbol)
{
const probability *const subcoder = literal_subcoder(coder->literal,
coder->literal_context_bits, coder->literal_pos_mask,
pos,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq $0xb9c, %rax # imm = 0xB9C
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rcx
and... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
get_dist_len_price | static inline uint32_t
get_dist_len_price(const lzma_lzma1_encoder *const coder, const uint32_t dist,
const uint32_t len, const uint32_t pos_state)
{
const uint32_t dist_state = get_dist_state(len);
uint32_t price;
if (dist < FULL_DISTANCES) {
price = coder->dist_prices[dist_state][dist];
} else {
const uint... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x6, -0x10(%rbp)
jae 0x12b346
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x12b350
movl $0x3, %eax
movl %eax, -0x24(%rbp)
jmp 0x12b350
movl -0x24(%rbp), %eax
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_optimum_normal.c |
read64ne | static inline uint64_t
read64ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint64_t *)buf;
#else
uint64_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
get_dist_slot_2 | static inline uint32_t
get_dist_slot_2(uint32_t dist)
{
assert(dist >= FULL_DISTANCES);
if (dist < fastpos_limit(FULL_DISTANCES_BITS - 1, 0))
return fastpos_result(dist, FULL_DISTANCES_BITS - 1, 0);
if (dist < fastpos_limit(FULL_DISTANCES_BITS - 1, 1))
return fastpos_result(dist, FULL_DISTANCES_BITS - 1, 1);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jb 0x12b416
jmp 0x12b435
leaq 0x19baec(%rip), %rdi # 0x2c6f09
leaq 0x19bafc(%rip), %rsi # 0x2c6f20
movl $0x7f, %edx
leaq 0x19bb64(%rip), %rcx # 0x2c6f94
callq 0x103e0
cmpl $0x80000, -0x8(%rbp) # imm = 0x80000
jae 0x12b4... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/fastpos.h |
lzma_lzma_preset | extern LZMA_API(lzma_bool)
lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset)
{
const uint32_t level = preset & LZMA_PRESET_LEVEL_MASK;
const uint32_t flags = preset & ~LZMA_PRESET_LEVEL_MASK;
const uint32_t supported_flags = LZMA_PRESET_EXTREME;
if (level > 9 || (flags & ~supported_flags))
return tru... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $-0x20, %eax
movl %eax, -0x1c(%rbp)
movl $0x80000000, -0x20(%rbp) # imm = 0x80000000
cmpl $0x9, -0x18(%rbp)
ja 0x12b547
movl -0x1c(%rbp), %eax
andl $0x7ffff... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_presets.c |
lzma_simple_coder_init | extern lzma_ret
lzma_simple_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters,
size_t (*filter)(void *simple, uint32_t now_pos,
bool is_encoder, uint8_t *buffer, size_t size),
size_t simple_size, size_t unfiltered_max,
uint32_t alignment, bool is_encoder)
{
/... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %r10d
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)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_coder.c |
simple_code | static lzma_ret
simple_code(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_simple_coder *coder = coder_ptr;
// TODO: Add partial support for LZMA_... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %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)
cmpl $0x1, 0x20(%rbp)
jne 0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_coder.c |
copy_or_code | static lzma_ret
copy_or_code(lzma_simple_coder *coder, 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)
{
assert(!coder->end_was_reached);
if (coder->next.code == NULL) {
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movl 0x20(%rbp), %eax
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, -0x40(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
jne 0x12c7c8
jmp ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_coder.c |
call_filter | static size_t
call_filter(lzma_simple_coder *coder, uint8_t *buffer, size_t size)
{
const size_t filtered = coder->filter(coder->simple,
coder->now_pos, coder->is_encoder,
buffer, size);
coder->now_pos += filtered;
return filtered;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x60(%rcx), %esi
movq -0x8(%rbp), %rcx
movb 0x49(%rcx), %dl
movq -0x10(%rbp), %rcx
movq -0x18... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_coder.c |
lzma_simple_props_decode | extern lzma_ret
lzma_simple_props_decode(void **options, const lzma_allocator *allocator,
const uint8_t *props, size_t props_size)
{
if (props_size == 0)
return LZMA_OK;
if (props_size != 4)
return LZMA_OPTIONS_ERROR;
lzma_options_bcj *opt = lzma_alloc(
sizeof(lzma_options_bcj), allocator);
if (opt == NU... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12c978
movl $0x0, -0x4(%rbp)
jmp 0x12c9e5
cmpq $0x4, -0x28(%rbp)
je 0x12c988
movl $0x8, -0x4(%rbp)
jmp 0x12c9e5
movq -0x18(%rbp), %rsi
movl $0x4, %edi
call... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_decoder.c |
read32le | static inline uint32_t
read32le(const uint8_t *buf)
{
#if !defined(WORDS_BIGENDIAN) || defined(TUKLIB_FAST_UNALIGNED_ACCESS)
uint32_t num = read32ne(buf);
return conv32le(num);
#else
uint32_t num = (uint32_t)buf[0];
num |= (uint32_t)buf[1] << 8;
num |= (uint32_t)buf[2] << 16;
num |= (uint32_t)buf[3] << 24;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12ca20
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
read32ne | static inline uint32_t
read32ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint32_t *)buf;
#else
uint32_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
lzma_simple_props_encode | extern lzma_ret
lzma_simple_props_encode(const void *options, uint8_t *out)
{
const lzma_options_bcj *const opt = options;
// The default start offset is zero, so we don't need to store any
// options unless the start offset is non-zero.
if (opt == NULL || opt->start_offset == 0)
return LZMA_OK;
write32le(out,... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12cab8
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x12cac1
movl $0x0, -0x4(%rbp)
jmp 0x12cad7
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/simple_encoder.c |
write32ne | static inline void
write32ne(uint8_t *buf, uint32_t num)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
*(uint32_t *)buf = num;
#else
memcpy(buf, &num, sizeof(num));
#endif
return;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
x86_coder_init | static lzma_ret
x86_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters, bool is_encoder)
{
const lzma_ret ret = lzma_simple_coder_init(next, allocator, filters,
&x86_code, sizeof(lzma_simple_x86), 5, 1, is_encoder);
if (ret == LZMA_OK) {
lzma_simple_coder *coder... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
leaq 0x8f(%rip), %rcx # 0x12ce50
movl $0x8, %r8d
movl $0x5, ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/x86.c |
tuklib_cpucores | extern uint32_t
tuklib_cpucores(void)
{
uint32_t ret = 0;
#if defined(_WIN32) || defined(__CYGWIN__)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
ret = sysinfo.dwNumberOfProcessors;
#elif defined(TUKLIB_CPUCORES_SCHED_GETAFFINITY)
cpu_set_t cpu_mask;
if (sched_getaffinity(0, sizeof(cpu_mask), &cpu_mask) == 0)
... | pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_cpucores.c |
lzma_check_is_supported | extern LZMA_API(lzma_bool)
lzma_check_is_supported(lzma_check type)
{
if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
return false;
static const lzma_bool available_checks[LZMA_CHECK_ID_MAX + 1] = {
true, // LZMA_CHECK_NONE
#ifdef HAVE_CHECK_CRC32
true,
#else
false,
#endif
false, // Reserved
false, /... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xf, -0x8(%rbp)
jbe 0x12d183
movb $0x0, -0x1(%rbp)
jmp 0x12d195
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x19a211(%rip), %rax # 0x2c73a0
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/check.c |
lzma_check_init | extern void
lzma_check_init(lzma_check_state *check, lzma_check type)
{
switch (type) {
case LZMA_CHECK_NONE:
break;
#ifdef HAVE_CHECK_CRC32
case LZMA_CHECK_CRC32:
check->state.crc32 = 0;
break;
#endif
#ifdef HAVE_CHECK_CRC64
case LZMA_CHECK_CRC64:
check->state.crc64 = 0;
break;
#endif
#ifdef HAVE_CHEC... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xa, %rax
ja 0x12d228
movq -0x18(%rbp), %rax
leaq 0x19a179(%rip), %rcx # 0x2c7370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x12d22a
movq -0x8(%rbp), %rax
movl $0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/check.c |
lzma_check_update | extern void
lzma_check_update(lzma_check_state *check, lzma_check type,
const uint8_t *buf, size_t size)
{
switch (type) {
#ifdef HAVE_CHECK_CRC32
case LZMA_CHECK_CRC32:
check->state.crc32 = lzma_crc32(buf, size, check->state.crc32);
break;
#endif
#ifdef HAVE_CHECK_CRC64
case LZMA_CHECK_CRC64:
check->state.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x12d268
jmp 0x12d254
movl -0x24(%rbp), %eax
subl $0x4, %eax
je 0x12d287
jmp 0x12d25e
movl -0x24(%rbp), %eax
subl $0xa, %e... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/check.c |
lzma_sha256_update | extern void
lzma_sha256_update(const uint8_t *buf, size_t size, lzma_check_state *check)
{
// Copy the input data into a properly aligned temporary buffer.
// This way we can be called with arbitrarily sized buffers
// (no need to be multiple of 64 bytes), and the code works also
// on architectures that don't allo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x12d62e
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x20(%rbp)
movl $0x40, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
c... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/sha256.c |
lzma_block_buffer_bound64 | extern uint64_t
lzma_block_buffer_bound64(uint64_t uncompressed_size)
{
// If the data doesn't compress, we always use uncompressed
// LZMA2 chunks.
uint64_t lzma2_size = lzma2_bound(uncompressed_size);
if (lzma2_size == 0)
return 0;
// Take Block Padding into account.
lzma2_size = (lzma2_size + 3) & ~UINT64_C... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12fdc0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12fd9a
movq $0x0, -0x8(%rbp)
jmp 0x12fdb6
movq -0x18(%rbp), %rax
addq $0x3, %rax
andq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x5c, %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_buffer_encoder.c |
lzma_block_decoder_init | extern lzma_ret
lzma_block_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
lzma_block *block)
{
lzma_next_coder_init(&lzma_block_decoder_init, next, allocator);
// Validate the options. lzma_block_unpadded_size() does that for us
// except for Uncompressed Size and filters. Filters are valida... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x22(%rip), %rax # 0x130790
cmpq 0x10(%rcx), %rax
je 0x1307c5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
movq -0x10(%rbp), %rax
leaq -0x40(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_decoder.c |
lzma_block_encoder_init | extern lzma_ret
lzma_block_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
lzma_block *block)
{
lzma_next_coder_init(&lzma_block_encoder_init, next, allocator);
if (block == NULL)
return LZMA_PROG_ERROR;
// The contents of the structure may depend on the version so
// check the version fi... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x22(%rip), %rax # 0x130e90
cmpq 0x10(%rcx), %rax
je 0x130ec5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x115880
movq -0x10(%rbp), %rax
leaq -0x40(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_encoder.c |
block_encode | static lzma_ret
block_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_block_coder *coder = coder_ptr;
// Check that our amount of input stay... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movl 0x20(%rbp), %eax
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, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_encoder.c |
free_properties | static void
free_properties(lzma_block *block, const lzma_allocator *allocator)
{
// Free allocated filter options. The last array member is not
// touched after the initialization in the beginning of
// lzma_block_header_decode(), so we don't need to touch that here.
for (size_t i = 0; i < LZMA_FILTERS_MAX; ++i) {... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x131812
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1156f0
movq -0x8(%rbp... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_header_decoder.c |
read32ne | static inline uint32_t
read32ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint32_t *)buf;
#else
uint32_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
lzma_block_header_size | extern LZMA_API(lzma_ret)
lzma_block_header_size(lzma_block *block)
{
if (block->version > 1)
return LZMA_OPTIONS_ERROR;
// Block Header Size + Block Flags + CRC32.
uint32_t size = 1 + 1 + 4;
// Compressed Size
if (block->compressed_size != LZMA_VLI_UNKNOWN) {
const uint32_t add = lzma_vli_size(block->compre... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jbe 0x131861
movl $0x8, -0x4(%rbp)
jmp 0x131994
movl $0x6, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x10(%rax)
je 0x1318a9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1361a0
movl %eax, -0x18(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_header_encoder.c |
write32ne | static inline void
write32ne(uint8_t *buf, uint32_t num)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
*(uint32_t *)buf = num;
#else
memcpy(buf, &num, sizeof(num));
#endif
return;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
lzma_block_compressed_size | extern LZMA_API(lzma_ret)
lzma_block_compressed_size(lzma_block *block, lzma_vli unpadded_size)
{
// Validate everything but Uncompressed Size and filters.
if (lzma_block_unpadded_size(block) == 0)
return LZMA_PROG_ERROR;
const uint32_t container_size = block->header_size
+ lzma_check_size(block->check);
// ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x131c90
cmpq $0x0, %rax
jne 0x131c08
movl $0xb, -0x4(%rbp)
jmp 0x131c80
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x12d1a0
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/block_util.c |
lzma_filters_copy | extern LZMA_API(lzma_ret)
lzma_filters_copy(const lzma_filter *src, lzma_filter *dest,
const lzma_allocator *allocator)
{
if (src == NULL || dest == NULL)
return LZMA_PROG_ERROR;
lzma_ret ret;
size_t i;
for (i = 0; src[i].id != LZMA_VLI_UNKNOWN; ++i) {
// There must be a maximum of four filters plus
// the... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x131ec2
cmpq $0x0, -0x18(%rbp)
jne 0x131ece
movl $0xb, -0x4(%rbp)
jmp 0x13210c
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_common.c |
lzma_raw_coder_init | extern lzma_ret
lzma_raw_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter *options,
lzma_filter_find coder_find, bool is_encoder)
{
// Do some basic validation and get the number of filters.
size_t count;
return_if_error(validate_chain(options, &count));
// Set the filter fu... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1323e0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x132164
movl -0x3c(%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_common.c |
validate_chain | static lzma_ret
validate_chain(const lzma_filter *filters, size_t *count)
{
// There must be at least one filter.
if (filters == NULL || filters[0].id == LZMA_VLI_UNKNOWN)
return LZMA_PROG_ERROR;
// Number of non-last filters that may change the size of the data
// significantly (that is, more than 1-2 % or so).... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1323fd
movq -0x10(%rbp), %rax
cmpq $-0x1, (%rax)
jne 0x132409
movl $0xb, -0x4(%rbp)
jmp 0x13252f
movq $0x0, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_common.c |
lzma_raw_coder_memusage | extern uint64_t
lzma_raw_coder_memusage(lzma_filter_find coder_find,
const lzma_filter *filters)
{
// The chain has to have at least one filter.
{
size_t tmp;
if (validate_chain(filters, &tmp) != LZMA_OK)
return UINT64_MAX;
}
uint64_t total = 0;
size_t i = 0;
do {
const lzma_filter_coder *const fc
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1323e0
cmpl $0x0, %eax
je 0x13256f
movq $-0x1, -0x8(%rbp)
jmp 0x132639
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x30(%r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_common.c |
lzma_filter_flags_decode | extern LZMA_API(lzma_ret)
lzma_filter_flags_decode(
lzma_filter *filter, const lzma_allocator *allocator,
const uint8_t *in, size_t *in_pos, size_t in_size)
{
// Set the pointer to NULL so the caller can always safely free it.
filter->options = NULL;
// Filter ID
return_if_error(lzma_vli_decode(&filter->id, NU... | 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 $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %eax, %eax
movl %eax, ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_flags_decoder.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 0x132817
movl $0xb, -0x4(%rbp)
jmp 0x1328fa
jmp 0x132819
movq -0x10(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_flags_encoder.c |
lzma_lz_encoder_memusage | extern uint64_t
lzma_lz_encoder_memusage(const lzma_lz_options *lz_options)
{
// Old buffers must not exist when calling lz_encoder_prepare().
lzma_mf mf = {
.buffer = NULL,
.hash = NULL,
.son = NULL,
.hash_count = 0,
.sons_count = 0,
};
// Setup the size information into mf.
if (lz_encoder_prepare(&mf,... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x10810
movq -0x10(%rbp), %rdx
leaq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x136290
testb $0x1, %al
jne 0x13625c
jmp 0x136266
movq $-0x1, -0x8(%rbp)
jmp 0x136283
movl -0x1c(%... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lzma_lz_encoder_init | extern lzma_ret
lzma_lz_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter_info *filters,
lzma_ret (*lz_init)(lzma_lz_encoder *lz,
const lzma_allocator *allocator, const void *options,
lzma_lz_options *lz_options))
{
#ifdef HAVE_SMALL
// We need that the CRC32 table has be... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1367ca
movq -0x18(%rbp), %rsi
movl $0xe0, %edi
callq 0x1155f0
movq %rax, -0x30(%rbp)
cmpq $... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.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 |
lz_encoder_end | static void
lz_encoder_end(void *coder_ptr, const lzma_allocator *allocator)
{
lzma_coder *coder = coder_ptr;
lzma_next_end(&coder->next, allocator);
lzma_free(coder->mf.son, allocator);
lzma_free(coder->mf.hash, allocator);
lzma_free(coder->mf.buffer, allocator);
if (coder->lz.end != NULL)
coder->lz.end(cod... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
callq 0x115880
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1156f0
movq -0x18(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lz_encoder_update | static lzma_ret
lz_encoder_update(void *coder_ptr, const lzma_allocator *allocator,
const lzma_filter *filters_null lzma_attribute((__unused__)),
const lzma_filter *reversed_filters)
{
lzma_coder *coder = coder_ptr;
if (coder->lz.options_update == NULL)
return LZMA_PROG_ERROR;
return_if_error(coder->lz.optio... | 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
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x136a84
movl $0xb, -0x4(%rbp)
jmp 0x136acd
jmp 0x136a86
movq -0x30(%rbp), %rax
movq 0x18... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lz_encoder_init | static bool
lz_encoder_init(lzma_mf *mf, const lzma_allocator *allocator,
const lzma_lz_options *lz_options)
{
// Allocate the history buffer.
if (mf->buffer == NULL) {
// lzma_memcmplen() is used for the dictionary buffer
// so we need to allocate a few extra bytes to prevent
// it from reading past the end ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x136b4f
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x8, %eax
movl %eax, %eax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0x1155f0
movq %rax, %rcx
movq -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
fill_window | static lzma_ret
fill_window(lzma_coder *coder, const lzma_allocator *allocator,
const uint8_t *in, size_t *in_pos, size_t in_size,
lzma_action action)
{
assert(coder->mf.read_pos <= coder->mf.write_pos);
// Move the sliding window if needed.
if (coder->mf.read_pos >= coder->mf.size - coder->mf.keep_size_after)
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %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
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
ja 0x136db3
jmp 0x136dd2
leaq 0x193782... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.c |
lzma_mf_find | extern uint32_t
lzma_mf_find(lzma_mf *mf, uint32_t *count_ptr, lzma_match *matches)
{
// Call the match finder. It returns the number of length-distance
// pairs found.
// FIXME: Minimum count is zero, what _exactly_ is the maximum?
const uint32_t count = mf->find(mf, matches);
// Length of the longest match; ass... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
cmpl $0x0, -0x44(%rbp)
jbe 0x1373bf
movl $0x0, -0x4c(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
lzma_mf_hc3_find | extern uint32_t
lzma_mf_hc3_find(lzma_mf *mf, lzma_match *matches)
{
header_find(false, 3);
hash_3_calc();
const uint32_t delta2 = pos - mf->hash[hash_2_value];
const uint32_t cur_match = mf->hash[FIX_3_HASH_SIZE + hash_value];
mf->hash[hash_2_value] = pos;
mf->hash[FIX_3_HASH_SIZE + hash_value] = pos;
uint3... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x137410
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x4c(%rbp), %eax
ja 0x137468
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x1374... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
hc_find_func | static lzma_match *
hc_find_func(
const uint32_t len_limit,
const uint32_t pos,
const uint8_t *const cur,
uint32_t cur_match,
uint32_t depth,
uint32_t *const son,
const uint32_t cyclic_pos,
const uint32_t cyclic_size,
lzma_match *matches,
uint32_t len_best)
{
son[cyclic_pos] = cur_match;
while (t... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movl %r8d, -0x48(%rbp)
movq %r9, -0x50(%rbp)
movl -0x44(%rbp), %edx
movq -0x50(%rbp), %rax
movl ... | /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 0x137410
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x24(%rbp), %eax
ja 0x1381d5
movq -0x18(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x1382... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
lzma_mf_bt3_find | extern uint32_t
lzma_mf_bt3_find(lzma_mf *mf, lzma_match *matches)
{
header_find(true, 3);
hash_3_calc();
const uint32_t delta2 = pos - mf->hash[hash_2_value];
const uint32_t cur_match = mf->hash[FIX_3_HASH_SIZE + hash_value];
mf->hash[hash_2_value] = pos;
mf->hash[FIX_3_HASH_SIZE + hash_value] = pos;
uint32... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x137410
movl %eax, -0x4c(%rbp)
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x4c(%rbp), %eax
ja 0x138ae8
movq -0x40(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x138b... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
lzma_mf_bt3_skip | extern void
lzma_mf_bt3_skip(lzma_mf *mf, uint32_t amount)
{
do {
header_skip(true, 3);
hash_3_calc();
const uint32_t cur_match
= mf->hash[FIX_3_HASH_SIZE + hash_value];
mf->hash[hash_2_value] = pos;
mf->hash[FIX_3_HASH_SIZE + hash_value] = pos;
bt_skip();
} while (--amount != 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x137410
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
cmpl -0x10(%rbp), %eax
ja 0x138e73
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x138ebe
cmpl $0x3, -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder_mf.c |
read64ne | static inline uint64_t
read64ne(const uint8_t *buf)
{
#if defined(TUKLIB_FAST_UNALIGNED_ACCESS) \
&& defined(TUKLIB_USE_UNSAFE_TYPE_PUNNING)
return *(const uint64_t *)buf;
#else
uint64_t num;
memcpy(&num, buf, sizeof(num));
return num;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| /JKorbelRA[P]CMake/Utilities/cmliblzma/common/tuklib_integer.h |
ZSTD_loadCEntropy | size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
const void* const dict, size_t dictSize)
{
short offcodeNCount[MaxOff+1];
unsigned offcodeMaxValue = MaxOff;
const BYTE* dictPtr = (const BYTE*)dict; /* skip magic num and dict ID */
const BYTE* const ... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1f, -0x74(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %... | /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 0x13f0ef
movl $0x1, -0x4(%rbp)
jmp 0x13f12b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
ja 0x13f124
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
mov... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBegin_internal | static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
const void* dict, size_t dictSize,
ZSTD_dictContentType_e dictContentType,
ZSTD_dictTableLoadMethod_e dtlm,
const ZST... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x13f293
movq -0x38(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBegin_advanced | size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
const void* dict, size_t dictSize,
ZSTD_parameters params, unsigned long long pledgedSrcSize)
{
ZSTD_CCtx_params cctxParams;
ZSTD_CCtxParams_init_internal(&cctxParams, ¶ms, ZSTD_NO_CLEVEL);
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, %rax
leaq 0x10(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xd0(%rbp), %rdi
xorl %edx, %edx
callq 0x13a5d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
xo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressBegin_usingDict | size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
{
ZSTD_CCtx_params cctxParams;
{
ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);
ZSTD_CCtxParams_init... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rcx
leaq -0xf8(%rbp), %rdi
movq $-0x1, %rdx
xorl %r8d, %r8d
callq 0x13f600
cmpl $0x0, -0x1c(%rbp)
jne 0x13f59a
movl $... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compressEnd | size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize)
{
size_t endResult;
size_t const cSize = ZSTD_compressContinue_internal(cctx,
dst, dstCapacity, 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)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x1, %r9d
movl $0x1, (%rsp)
callq 0x13e840... | /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 0x13f912
movq $-0x3c, -0x8(%rbp)
jmp 0x13fa34
m... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compress_advanced | size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
const void* dict,size_t dictSize,
ZSTD_parameters params)
{
DEBUGLOG(4, "ZSTD_compress_advan... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
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 -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax)... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compress | size_t ZSTD_compress(void* dst, size_t dstCapacity,
const void* src, size_t srcSize,
int compressionLevel)
{
size_t result;
#if ZSTD_COMPRESS_HEAPMODE
ZSTD_CCtx* cctx = ZSTD_createCCtx();
RETURN_ERROR_IF(!cctx, memory_allocation, "ZSTD_createCCtx failed");
result = ZS... | pushq %rbp
movq %rsp, %rbp
subq $0xe40, %rsp # imm = 0xE40
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0xe28(%rbp), %rdi
leaq 0x18cd9b(%rip), %rax # 0x2ccac8
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_estimateCDictSize_advanced | size_t ZSTD_estimateCDictSize_advanced(
size_t dictSize, ZSTD_compressionParameters cParams,
ZSTD_dictLoadMethod_e dictLoadMethod)
{
DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
+ ZSTD_cwksp_alloc_size(HUF_WORKSPA... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1390, %edi # imm = 0x1390
callq 0x13fe40
movq %rax, -0x30(%rbp)
movl $0x1900, %edi # imm = 0x1900
callq 0x13fe40
movq -0x28(%rbp), %rsi
movq %rax, %rcx
movq -0... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_cwksp_alloc_size | MEM_STATIC size_t ZSTD_cwksp_alloc_size(size_t size) {
if (size == 0)
return 0;
#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
return size + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
#else
return size;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13fe59
movq $0x0, -0x8(%rbp)
jmp 0x13fe61
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_cwksp.h |
ZSTD_sizeof_matchState | static size_t
ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
const ZSTD_useRowMatchFinderMode_e useRowMatchFinder,
const U32 enableDedicatedDictSearch,
const U32 forCCtx)
{
/* chain table size should be 0 for fast or row-h... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x61(%rbp)
je 0x13feaf
c... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_createCDict_advanced | ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_compressionParameters cParams,
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
leaq 0x30(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0xb0, %edx
callq 0x10810
leaq -0xc8(%rbp), %rdi
xo... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_createCDict_advanced2 | ZSTDLIB_API ZSTD_CDict* ZSTD_createCDict_advanced2(
const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
const ZSTD_CCtx_params* originalCctxParams,
ZSTD_customMem customMem)
{
ZSTD_CCtx_params cctxParams = *original... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
leaq 0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movl $0xb0, %edx
callq 0x101e0
movq -0x178(%... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_dedicatedDictSearch_getCParams | static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
{
ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);
switch (cParams.strategy) {
case ZSTD_fast:
case ZSTD_dfa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %r8d
callq 0x13c700
movq -0x20(%rbp), %rdi
movl 0x18(%rdi), %eax
movl %eax, -0x14... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_dedicatedDictSearch_isSupported | static int ZSTD_dedicatedDictSearch_isSupported(
ZSTD_compressionParameters const* cParams)
{
return (cParams->strategy >= ZSTD_greedy)
&& (cParams->strategy <= ZSTD_lazy2)
&& (cParams->hashLog > cParams->chainLog)
&& (cParams->chainLog <= 24);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, 0x18(%rcx)
movb %al, -0x9(%rbp)
jb 0x1406b9
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x5, 0x18(%rcx)
movb %al, -0x9(%rbp)
ja 0x1406b9
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_createCDict_advanced_internal | static ZSTD_CDict* ZSTD_createCDict_advanced_internal(size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_compressionParameters cParams,
ZSTD_useRowMatchFinderMode_e useRowMatchFinder,
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %ecx, %eax
leaq 0x30(%rbp), %rcx
movq %rcx, -0x88(%rbp)
leaq 0x10(%rbp), %r8
movq %r8, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
cmpq $0x0, (%rcx)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpq... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_initCDict_internal | static size_t ZSTD_initCDict_internal(
ZSTD_CDict* cdict,
const void* dictBuffer, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod,
ZSTD_dictContentType_e dictContentType,
ZSTD_CCtx_params params)
{
DEBUGLOG(3, "ZSTD_... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x4(%rax), %rdx
movq %rdx, 0x150(%rcx)
movq 0xc(%rax), %rdx
movq %rdx, 0x158(%rcx)
movq ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_freeCDict | size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
{
if (cdict==NULL) return 0; /* support free on NULL */
{ ZSTD_customMem const cMem = cdict->customMem;
int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);
ZSTD_cwksp_free(&cdict->workspace, cMem);
if (!cdictInWorkspace) {... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x140b20
movq $0x0, -0x8(%rbp)
jmp 0x140bb7
movq -0x10(%rbp), %rax
movq 0x1368(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x1370(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x1378(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.