name string | code string | asm string | file string |
|---|---|---|---|
isodate17 | static time_t
isodate17(const unsigned char *v)
{
struct tm tm;
int offset;
time_t t;
memset(&tm, 0, sizeof(tm));
tm.tm_year = (v[0] - '0') * 1000 + (v[1] - '0') * 100
+ (v[2] - '0') * 10 + (v[3] - '0')
- 1900;
tm.tm_mon = (v[4] - '0') * 10 + (v[5] - '0');
tm.tm_mday = (v[6] - '0') * 10 + (v[7] - '0')... | subq $0x38, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movzbl (%rdi), %eax
imull $0x3e8, %eax, %eax # imm = 0x3E8
movzbl 0x1(%rdi), %ecx
imull $0x64, %ecx, %ecx
addl %eax, %ecx
movzbl 0x2(%rdi), %eax
leal (%rax,%rax,4), %eax
movzbl 0x3(%rdi), %edx
leal (%rcx,%rax,2), %eax
leal -0xd7b... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
next_cache_entry | static int
next_cache_entry(struct archive_read *a, struct iso9660 *iso9660,
struct file_info **pfile)
{
struct file_info *file;
struct {
struct file_info *first;
struct file_info **last;
} empty_files;
int64_t number;
int count;
file = cache_get_entry(iso9660);
if (file != NULL) {
*pfile = file;
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x80(%rsi), %rbp
movq 0x80(%rsi), %rax
testq %rax, %rax
je 0x47c5a9
movq 0x10(%rax), %rcx
movq %rcx, (%rbp)
testq %rcx, %rcx
jne 0x47c595
movq %rbp, 0x88(%r14)
movq %rax, (%rbx)
xorl %eax, %eax
addq $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_format_lha_read_data_skip | static int
archive_read_format_lha_read_data_skip(struct archive_read *a)
{
struct lha *lha;
int64_t bytes_skipped;
lha = (struct lha *)(a->format->data);
if (lha->entry_unconsumed) {
/* Consume as much as the decompressor actually used. */
__archive_read_consume(a, lha->entry_unconsumed);
lha->entry_uncons... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r15
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x47f323
movq %r14, %rdi
callq 0x46c7ce
movq $0x0, 0x10(%r15)
xorl %ebx, %ebx
cmpb $0x0, 0x12d(%r15)
jne 0x47f351
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x46c7ce
testq %rax, %rax
js 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_end_of_entry | static int
lha_end_of_entry(struct archive_read *a)
{
struct lha *lha = (struct lha *)(a->format->data);
int r = ARCHIVE_EOF;
if (!lha->end_of_entry_cleanup) {
if ((lha->setflag & CRC_IS_SET) &&
lha->crc != lha->entry_crc_calculated) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"LHa data C... | pushq %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movl $0x1, %eax
cmpb $0x0, 0x12d(%rbx)
jne 0x47fff7
testb $0x8, 0x40(%rbx)
je 0x47fff0
movzwl 0xc2(%rbx), %ecx
cmpw 0x18(%rbx), %cx
je 0x47fff0
leaq 0x18a04a(%rip), %rdx # 0x60a029
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x498bac
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
read_data | static int
read_data(struct archive_read *a, const void **buff, size_t *size,
int64_t *offset)
{
size_t bytes_to_read;
ssize_t bytes_read;
struct mtree *mtree;
mtree = (struct mtree *)(a->format->data);
if (mtree->fd < 0) {
*buff = NULL;
*offset = 0;
*size = 0;
return (ARCHIVE_EOF);
}
if (mtree->buf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq 0x818(%rdi), %rax
movq (%rax), %r13
movl 0x30(%r13), %ebp
testl %ebp, %ebp
js 0x481579
movq %rdi, %rbx
movq 0x20(%r13), %rax
testq %rax, %rax
jne 0x48153c
movq $0x10000, 0x18(%r13) # imm ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
detect_form | static int
detect_form(struct archive_read *a, int *is_form_d)
{
const char *p;
ssize_t avail, ravail;
ssize_t detected_bytes = 0, len, nl;
int entry_cnt = 0, multiline = 0;
int form_D = 0;/* The archive is generated by `NetBSD mtree -D'
* (In this source we call it `form D') . */
if (is_form_d != NULL)
*is... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
testq %rsi, %rsi
je 0x4816e9
movl $0x0, (%r14)
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
movq 0x28(%rsp), %rdi
callq 0x46c4a0
testq %rax, %rax
je 0x481bb9
movq %rax, %rbx
movq %r14, 0x30(%rsp)
leaq 0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
get_line_size | static ssize_t
get_line_size(const char *b, ssize_t avail, ssize_t *nlsize)
{
ssize_t len;
len = 0;
while (len < avail) {
switch (*b) {
case '\0':/* Non-ascii character or control character. */
if (nlsize != NULL)
*nlsize = 0;
return (-1);
case '\r':
if (avail-len > 1 && b[1] == '\n') {
if (n... | movq %rsi, %rax
testq %rsi, %rsi
jle 0x481e41
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %esi
cmpl $0xd, %esi
je 0x481e05
cmpl $0xa, %esi
je 0x481e27
testl %esi, %esi
je 0x481e3a
incq %rcx
cmpq %rcx, %rax
jne 0x481de9
jmp 0x481e41
subq %rcx, %rax
cmpq $0x2, %rax
jl 0x481e27
cmpb $0xa, 0x1(%rdi,%rcx)
jne 0x481e27
testq %rdx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
bid_keycmp | static int
bid_keycmp(const char *p, const char *key, ssize_t len)
{
int match_len = 0;
while (len > 0 && *p && *key) {
if (*p == *key) {
--len;
++p;
++key;
++match_len;
continue;
}
return (0);/* Not match */
}
if (*key != '\0')
return (0);/* Not match */
/* A following character should be... | pushq %rbx
xorl %eax, %eax
testq %rdx, %rdx
jle 0x481e8f
leaq (%rdi,%rdx), %r8
leaq (%rsi,%rdx), %r9
movq %rdx, %r10
incq %r10
xorl %ecx, %ecx
movb (%rdi,%rcx), %r11b
testb %r11b, %r11b
je 0x481e93
movb (%rsi,%rcx), %bl
testb %bl, %bl
je 0x481ea7
cmpb %bl, %r11b
jne 0x481ed8
incq %rcx
decq %r10
cmpq $0x1, %r10
jg 0x481... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_rar_bid | static int
archive_read_format_rar_bid(struct archive_read *a, int best_bid)
{
const char *p;
/* If there's already a bid > 30, we'll never win. */
if (best_bid > 30)
return (-1);
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return (-1);
if (memcmp(p, RAR_SIGNATURE, 7) == 0)
return (30);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x1e, %esi
jg 0x483092
movq %rdi, %rbx
movl $0x7, %esi
xorl %edx, %edx
callq 0x46c4a0
testq %rax, %rax
je 0x483092
movl $0x21726152, %ecx # imm = 0x21726152
xorl (%rax), %ecx
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_header | static int
archive_read_format_rar_read_header(struct archive_read *a,
struct archive_entry *entry)
{
const void *h;
const char *p;
struct rar *rar;
size_t skip;
char head_type;
int ret;
unsigned flags;
unsigned long crc32_expected;
a->archive.archive_format = ARCH... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movl $0xd0000, 0x10(%rdi) # imm = 0xD0000
cmpq $0x0, 0x18(%rdi)
jne 0x483158
leaq 0x187bbb(%rip), %rax # 0x60ad0f
movq %rax, 0x18(%rbx)
movq 0x818(%rbx), %rax
movq (%rax), %r14
cmpl $-0x1, 0x4f50(%r1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
rar_read_ahead | static const void *
rar_read_ahead(struct archive_read *a, size_t min, ssize_t *avail)
{
struct rar *rar = (struct rar *)(a->format->data);
const void *h = __archive_read_ahead(a, min, avail);
int ret;
if (avail)
{
if (a->archive.read_data_is_posix_read && *avail > (ssize_t)a->archive.read_data_requested)... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x818(%r15), %rax
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x46c4a0
testq %rbx, %rbx
je 0x485255
cmpb $0x0, 0x80(%r15)
movq (%rbx), %rcx
je 0x4851e4
movq 0x88(%r15), %rdx
cmpq %rdx,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
expand | static int64_t
expand(struct archive_read *a, int64_t end)
{
static const unsigned char lengthbases[] =
{ 0, 1, 2, 3, 4, 5, 6,
7, 8, 10, 12, 14, 16, 20,
24, 28, 32, 40, 48, 56, 64,
80, 96, 112, 128, 160, 192, 224 };
static const unsigned char lengthbits[] =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq 0x818(%rdi), %rax
movq (%rax), %r12
movq 0x360(%r12), %r14
movq 0x3a8(%r12), %rax
cmpq %rsi, %rax
cmovlq %rax, %rsi
cmpq %rsi, %r14
jge 0x486af9
movq %rsi, 0x88(%rsp)
cmpb $0x0, 0x3d2(%r12)
jne 0x486afc
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
ppmd_read | static Byte
ppmd_read(void *p)
{
struct archive_read *a = ((IByteIn*)p)->a;
struct rar *rar = (struct rar *)(a->format->data);
struct rar_br *br = &(rar->br);
Byte b;
if (!rar_br_read_ahead(a, br, 8))
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
"Truncated RAR file d... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movq 0x818(%rbx), %rax
movq (%rax), %r15
movl 0x4f38(%r15), %ecx
cmpl $0x7, %ecx
jg 0x487507
leaq 0x4f30(%r15), %rsi
movq %rbx, %rdi
callq 0x4871e4
testl %eax, %eax
setne %al
movl 0x4f38(%r15), %ecx
cmpl $0x8, %ecx
setge %dl
orb %al, %dl
je 0x48751d
movq 0x4f30(%r15), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
make_table_recurse | static int
make_table_recurse(struct archive_read *a, struct huffman_code *code, int node,
struct huffman_table_entry *table, int depth,
int maxdepth)
{
int currtablesize, i, ret = (ARCHIVE_OK);
if (!code->tree)
{
archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x4(%rsp)
movq (%rsi), %r10
testq %r10, %r10
je 0x487a08
movq %rdi, 0x10(%rsp)
testl %edx, %edx
js 0x487a14
movq %rcx, %rbp
movl 0x4(%rsp), %r12d
movl %r12d, %eax
negl %eax
movl %eax, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
subl %r8d, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
delete_program_code | static void
delete_program_code(struct rar_program_code *prog)
{
while (prog)
{
struct rar_program_code *next = prog->next;
free(prog->staticdata);
free(prog->globalbackup);
free(prog);
prog = next;
}
} | testq %rdi, %rdi
je 0x487dfd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x30(%rbx), %r14
callq 0x3be90
movq 0x10(%rbx), %rdi
callq 0x3be90
movq %rbx, %rdi
callq 0x3be90
movq %r14, %rbx
testq %r14, %r14
jne 0x487dd1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
rar5_options | static int rar5_options(struct archive_read *a, const char *key,
const char *val) {
(void) a;
(void) key;
(void) val;
/* No options supported in this version. Return the ARCHIVE_WARN code
* to signal the options supervisor that the unpacker didn't handle
* setting this option. */
return ARCHIVE_WARN;
} | movl $0xffffffec, %eax # imm = 0xFFFFFFEC
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
rar5_read_data_skip | static int rar5_read_data_skip(struct archive_read *a) {
struct rar5* rar = get_context(a);
if(rar->main.solid) {
/* In solid archives, instead of skipping the data, we need to
* extract it, and dispose the result. The side effect of this
* operation will be setting up the initial window buffer state
* ne... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r15
testb $0x1, 0x2c(%r15)
jne 0x489757
movq 0x4ba8(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46c7ce
movq %rax, %rcx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpq %r14, %rcx
jne 0x489751
movq $0x0, 0x4ba8(%r15)
xorl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
process_head_file_extra | static int process_head_file_extra(struct archive_read* a,
struct archive_entry* e, struct rar5* rar, ssize_t extra_data_size)
{
size_t extra_field_size;
size_t extra_field_id = 0;
int ret = ARCHIVE_FATAL;
size_t var_size;
while(extra_data_size > 0) {
if(!read_var_sized(a, &extra_field_size, &var_size))
... | testq %rcx, %rcx
jle 0x48acc3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2098, %rsp # imm = 0x2098
movq %rcx, %r12
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x52f8(%rdx), %rax
movq %rax, 0x50(%rsp)
leaq 0x5300(%rdx), %rax
movq %rax, 0x48(%rsp)
leaq 0x4bd0(%rdx), %rax
movq %rax,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
free_filters | static void free_filters(struct rar5* rar) {
struct cdeque* d = &rar->cstate.filters;
/* Free any remaining filters. All filters should be naturally
* consumed by the unpacking function, so remaining filters after
* unpacking normally mean that unpacking wasn't successful.
* But still of course we shouldn't le... | pushq %rbx
movq %rdi, %rbx
movzwl 0x4b3e(%rdi), %eax
testw %ax, %ax
je 0x48ad2f
movq 0x4b40(%rbx), %rcx
movzwl 0x4b38(%rbx), %edx
movq (%rcx,%rdx,8), %rdi
incl %edx
andw 0x4b3c(%rbx), %dx
movw %dx, 0x4b38(%rbx)
decl %eax
movw %ax, 0x4b3e(%rbx)
callq 0x3be90
movzwl 0x4b3e(%rbx), %eax
jmp 0x48acf1
movw $0x0, 0x4b3e(%rbx)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
verify_global_checksums | static int verify_checksums(struct archive_read* a) {
int verify_crc;
struct rar5* rar = get_context(a);
/* Check checksums only when actually unpacking the data. There's no
* need to calculate checksum when we're skipping data in solid archives
* (skipping in solid archives is the same thing as unpacking compr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x818(%rdi), %rax
movq (%rax), %r12
xorl %ebx, %ebx
cmpl $0x0, 0x8(%r12)
jne 0x48ae9e
movq %rdi, %r14
movl 0x4bec(%r12), %eax
testl %eax, %eax
je 0x48ae29
cmpl %eax, 0x4bf0(%r12)
jne 0x48ae83
cmpb $0x0, 0x52f0(%r12)
jle 0x48ae9e
leaq 0x4c18(%r12), %rdi
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
advance_multivolume | static int advance_multivolume(struct archive_read* a) {
int lret;
struct rar5* rar = get_context(a);
/* A small state machine that will skip unnecessary data, needed to
* switch from one multivolume to another. Such skipping is needed if
* we want to be an stream-oriented (instead of file-oriented)
* unpacke... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movb 0x2c(%r14), %cl
testb $0x4, %cl
jne 0x48b021
movq %rbx, %rdi
callq 0x48b09c
cmpl $-0xa, %eax
je 0x48aff8
cmpl $-0x1e, %eax
je 0x48b035
cmpl $-0x19, %eax
je 0x48b035
movb 0x2c(%r14), %cl
testb $0x4, %cl
je 0x48b035
andb $-0x5,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
decode_number | static int decode_number(struct archive_read* a, struct decode_table* table,
const uint8_t* p, uint16_t* num)
{
int i, bits, dist, ret;
uint16_t bitfield;
uint32_t pos;
struct rar5* rar = get_context(a);
if(ARCHIVE_OK != (ret = read_bits_16(a, rar, p, &bitfield))) {
return ret;
}
bitfield &= 0xfffe;
if... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r15
leaq 0xe(%rsp), %rcx
movq %r15, %rsi
callq 0x48b456
testl %eax, %eax
jne 0x48b44c
movzwl 0xe(%rsp), %eax
andl $-0x2, %eax
movl 0x84(%r14), %edx
cmpl %eax, 0x4(%r14,%rdx,4)
jle 0x48b3e6
movb $0x10, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar5.c |
archive_read_format_raw_read_header | static int
archive_read_format_raw_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct raw_info *info;
info = (struct raw_info *)(a->format->data);
if (info->end_of_file)
return (ARCHIVE_EOF);
a->archive.archive_format = ARCHIVE_FORMAT_RAW;
a->archive.archive_format_name = "raw";
arc... | movq 0x818(%rdi), %rax
movq (%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x48b81e
movl $0x1, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x90000, 0x10(%rdi) # imm = 0x90000
leaq 0x18a793(%rip), %rax # 0x615fc9
movq %rax, 0x18(%rdi)
leaq 0x17e036(%rip), %rsi # 0x609877
movq %rbx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_raw.c |
checksum | static int
checksum(struct archive_read *a, const void *h)
{
const unsigned char *bytes;
const struct archive_entry_header_ustar *header;
int check, sum;
size_t i;
(void)a; /* UNUSED */
bytes = (const unsigned char *)h;
header = (const struct archive_entry_header_ustar *)h;
/* Checksum field must hold an octa... | pushq %rbx
movq %rdi, %rbx
addq $0x94, %rdi
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
leal -0x30(%rcx), %edx
cmpl $0x8, %edx
jae 0x48c24d
incq %rax
cmpq $0x8, %rax
jne 0x48c236
jmp 0x48c25d
cmpl $0x20, %ecx
je 0x48c242
testl %ecx, %ecx
je 0x48c242
xorl %ecx, %ecx
jmp 0x48c33e
movl $0x8, %esi
callq 0x48c3a9
xorl %ecx, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
tar_atol | static int64_t
tar_atol(const char *p, size_t char_cnt)
{
/*
* Technically, GNU tar considers a field to be in base-256
* only if the first byte is 0xff or 0x80.
*/
if (*p & 0x80)
return (tar_atol256(p, char_cnt));
return (tar_atol8(p, char_cnt));
} | movb (%rdi), %dl
testb %dl, %dl
js 0x48c3b9
movl $0x8, %edx
jmp 0x48c463
movl %edx, %eax
shrb $0x6, %al
andb $0x1, %al
movl %edx, %ecx
andb $0x3f, %cl
movzbl %dl, %r8d
movzbl %cl, %ecx
xorl %r9d, %r9d
testb %al, %al
cmovnel %r8d, %ecx
movl $0xff, %r8d
cmovel %r9d, %r8d
cmpq $0x9, %rsi
jb 0x48c403
leaq 0x1(%rdi), %r9
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
tar_read_header | static int
tar_read_header(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, size_t *unconsumed)
{
ssize_t bytes;
int err, eof_vol_header;
const char *h;
const struct archive_entry_header_ustar *header;
const struct archive_entry_header_gnutar *gnuheader;
eof_vol_header = 0;
/* Loop unt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rcx), %rsi
leaq 0x20(%rsp), %rbp
leaq 0x188178(%rip), %r14 # 0x614700
movq %rdi, 0x8(%rsp)
testq %rsi, %rsi
je 0x48c5a1
movq %r12, %rdi
callq 0x46c7ce
movq $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
header_old_tar | static int
header_old_tar(struct archive_read *a, struct tar *tar,
struct archive_entry *entry, const void *h)
{
const struct archive_entry_header_ustar *header;
int err = ARCHIVE_OK, err2;
/* Copy filename over (to ensure null termination). */
header = (const struct archive_entry_header_ustar *)h;
if (archiv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x190(%rsi), %rcx
movl $0x64, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x467ebf
xorl %r13d, %r13d
movl $0x0, %ebp
testl %eax, %eax
je 0x48e5b8
movq 0x190(%rbx), %rsi
leaq 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
read_body_to_string | static int
read_body_to_string(struct archive_read *a, struct tar *tar,
struct archive_string *as, const void *h, size_t *unconsumed)
{
int64_t size;
const struct archive_entry_header_ustar *header;
const void *src;
(void)tar; /* UNUSED */
header = (const struct archive_entry_header_ustar *)h;
size = tar_at... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x7c(%rdx), %rdi
movl $0xc, %esi
callq 0x48c3a9
cmpq $0x100001, %rax # imm = 0x100001
jb 0x48e75c
leaq 0x17d5ed(%rip), %rdx # 0x60bd3f
movq %r12, %rdi
movl $0x16, %esi
jmp 0x48e7cd
movq %rax, %r15
leaq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_tar.c |
warc_rdhdr | static int
_warc_rdhdr(struct archive_read *a, struct archive_entry *entry)
{
#define HDR_PROBE_LEN (12U)
struct warc_s *w = a->format->data;
unsigned int ver;
const char *buf;
ssize_t nrd;
const char *eoh;
/* for the file name, saves some strndup()'ing */
warc_string_t fnam;
/* warc record type, not that we r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %r12
movq 0x818(%rdi), %rax
movq (%rax), %rbp
leaq 0x38(%rsp), %rbx
movl $0xc, %esi
movq %rbx, %rdx
callq 0x46c4a0
movq (%rbx), %rsi
testq %rsi, %rsi
js 0x48f8aa
movq %rax, %r15
leaq 0x30(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_warc.c |
archive_read_format_zip_options | static int
archive_read_format_zip_options(struct archive_read *a,
const char *key, const char *val)
{
struct zip *zip;
int ret = ARCHIVE_FAILED;
zip = (struct zip *)(a->format->data);
if (strcmp(key, "compat-2x") == 0) {
/* Handle filenames as libarchive 2.x */
zip->init_default_conversion = (val != NULL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r12
leaq 0x179351(%rip), %rsi # 0x609654
movq %r15, %rdi
callq 0x3aed0
testl %eax, %eax
je 0x490376
leaq 0x178e72(%rip), %rsi # 0x609188
movq %r15, %rdi
callq 0x3aed0
testl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
process_extra | static int
process_extra(struct archive_read *a, struct archive_entry *entry,
const char *p, size_t extra_length, struct zip_entry* zip_entry)
{
unsigned offset = 0;
struct zip *zip = (struct zip *)(a->format->data);
if (extra_length == 0) {
return ARCHIVE_OK;
}
if (extra_length < 4) {
size_t i = 0;
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x8(%rsp)
testq %rcx, %rcx
je 0x49221f
movq %rcx, %r14
movq %rdx, %r15
cmpq $0x3, %rcx
ja 0x492226
xorl %eax, %eax
cmpb $0x0, (%r15,%rax)
jne 0x492800
incq %rax
cmpq %rax, %r14
jne 0x49220c
xorl %eax, %eax
jmp 0x492871
movq %rs... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
zip_read_data_zipx_zstd | static int
zip_read_data_zipx_zstd(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct zip *zip = (struct zip *)(a->format->data);
ssize_t bytes_avail = 0, in_bytes, to_consume;
const void *compressed_buff;
int r;
size_t ret;
uint64_t total_out;
ZSTD_outBuffer out;
ZSTD_inBuff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x818(%rdi), %rax
movq (%rax), %r14
movq $0x0, (%rsp)
cmpb $0x0, 0xa1(%r14)
je 0x494182
movq %rsp, %r13
movl $0x1, %esi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x46c4a0
movq (%r13), %rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_zip.c |
archive_string_append | static struct archive_string *
archive_string_append(struct archive_string *as, const char *p, size_t s)
{
if (archive_string_ensure(as, as->length + s + 1) == NULL)
return (NULL);
if (s)
memmove(as->s + as->length, p, s);
as->length += s;
as->s[as->length] = 0;
return (as);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x494928
testq %rax, %rax
je 0x49482a
testq %r14, %r14
je 0x494818
movq (%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x39480
addq 0x8(%rbx), %r14
movq %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_wstrncat | struct archive_wstring *
archive_wstrncat(struct archive_wstring *as, const wchar_t *p, size_t n)
{
size_t s;
const wchar_t *pp;
/* Like strlen(p), except won't examine positions beyond p[n]. */
s = 0;
pp = p;
while (s < n && *pp) {
pp++;
s++;
}
if ((as = archive_wstring_append(as, p, s)) == NULL)
__arch... | pushq %rax
testq %rdx, %rdx
je 0x494a22
movq %rdx, %rax
xorl %edx, %edx
cmpl $0x0, (%rsi,%rdx,4)
je 0x494a24
incq %rdx
cmpq %rdx, %rax
jne 0x494a0f
movq %rax, %rdx
jmp 0x494a24
xorl %edx, %edx
callq 0x494885
testq %rax, %rax
je 0x494a30
popq %rcx
retq
leaq 0x112eff(%rip), %rsi # 0x5a7936
movl $0x1, %edi
callq 0x498c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_mstring_copy_mbs_len | int
archive_mstring_copy_mbs_len(struct archive_mstring *aes, const char *mbs,
size_t len)
{
if (mbs == NULL) {
aes->aes_set = 0;
return (0);
}
aes->aes_set = AES_SET_MBS; /* Only MBS form is set now. */
archive_strncpy(&(aes->aes_mbs), mbs, len);
archive_string_empty(&(aes->aes_utf8));
archive_wstring_em... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4957ac
movl $0x1, 0x60(%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4949c7
movq %r14, 0x20(%rbx)
movq %r14, 0x38(%rbx)
jmp 0x4957b3
movl $0x0, 0x60(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_mstring_copy_utf8 | int
archive_mstring_copy_utf8(struct archive_mstring *aes, const char *utf8)
{
if (utf8 == NULL) {
aes->aes_set = 0;
return (0);
}
aes->aes_set = AES_SET_UTF8;
archive_string_empty(&(aes->aes_mbs));
archive_string_empty(&(aes->aes_wcs));
archive_strncpy(&(aes->aes_utf8), utf8, strlen(utf8));
retur... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x49588d
movq %rsi, %rbx
movl $0x2, 0x60(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x38(%r14)
movq %rax, 0x20(%r14)
addq $0x18, %r14
movq %rsi, %rdi
callq 0x39d50
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x4949c7
movq %rbx, %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
canonical_charset_name | static const char *
canonical_charset_name(const char *charset)
{
char cs[16];
char *p;
const char *s;
if (charset == NULL || charset[0] == '\0'
|| strlen(charset) > 15)
return (charset);
/* Copy name to uppercase. */
p = cs;
s = charset;
while (*s) {
char c = *s++;
if (c >= 'a' && c <= 'z')
c -... | testq %rdi, %rdi
je 0x495a0c
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb (%rdi), %r14b
testb %r14b, %r14b
je 0x495a01
movq %rbx, %rdi
callq 0x39d50
cmpq $0xf, %rax
jbe 0x495a0f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
xorl %eax, %eax
leal -0x61(%r14), %ecx
leal -0x2... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
unicode_to_utf8 | static size_t
unicode_to_utf8(char *p, size_t remaining, uint32_t uc)
{
char *_p = p;
/* Invalid Unicode char maps to Replacement character */
if (uc > UNICODE_MAX)
uc = UNICODE_R_CHAR;
/* Translate code point to UTF8 */
if (uc <= 0x7f) {
if (remaining == 0)
return (0);
*p++ = (char)uc;
} else if (uc <=... | cmpl $0x110000, %edx # imm = 0x110000
movl $0xfffd, %ecx # imm = 0xFFFD
cmovbl %edx, %ecx
cmpl $0x7f, %ecx
ja 0x49831a
testq %rsi, %rsi
je 0x498378
leaq 0x1(%rdi), %rax
movb %cl, (%rdi)
jmp 0x4983a9
cmpl $0x7ff, %ecx # imm = 0x7FF
ja 0x498340
cmpq $0x2, %rsi
jb 0x498378
movl %ecx, %eax
shrl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
_archive_mktemp | int
__archive_mktemp(const char *tmpdir)
{
struct archive_string temp_name;
int fd = -1;
archive_string_init(&temp_name);
if (tmpdir == NULL) {
if (get_tempdir(&temp_name) != ARCHIVE_OK)
goto exit_tmpfile;
} else {
archive_strcpy(&temp_name, tmpdir);
if (temp_name.s[temp_name.length-1] != '/')
archive... | pushq %r14
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
je 0x498cf8
movq %rdi, %rbx
jmp 0x498d12
leaq 0x17a9d8(%rip), %rdi # 0x6136d7
callq 0x3ab20
testq %rax, %rax
leaq 0x17a9d0(%rip), %rbx # 0x6136de
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x39d50
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_util.c |
la_verify_filetype | static int
la_verify_filetype(mode_t mode, __LA_MODE_T filetype) {
int ret = 0;
switch (filetype) {
case AE_IFREG:
ret = (S_ISREG(mode));
break;
case AE_IFDIR:
ret = (S_ISDIR(mode));
break;
case AE_IFLNK:
ret = (S_ISLNK(mode));
break;
case AE_IFSOCK:
ret = (S_ISSOCK(mode));
break;
case AE_IFCHR:... | addl $0xfffff000, %esi # imm = 0xFFFFF000
roll $0x14, %esi
xorl %eax, %eax
cmpl $0xb, %esi
ja 0x49b946
leaq 0x178016(%rip), %rcx # 0x6138f0
movslq (%rcx,%rsi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
andl $0xf000, %edi # imm = 0xF000
cmpl $0x1000, %edi # imm = 0x1000
jmp 0x49b943
andl $0xf000, %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
set_times | static int
set_times(struct archive_write_disk *a,
int fd, int mode, const char *name,
time_t atime, long atime_nanos,
time_t birthtime, long birthtime_nanos,
time_t mtime, long mtime_nanos,
time_t cctime, long ctime_nanos)
{
/* Note: set_time doesn't use libarchive return conventions!
* It uses ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rsp), %rax
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rsp, %rax
testl %esi, %esi
js 0x49b97d
movl %esi, %edi
movq %rax, %rsi
callq 0x39550
jmp 0x49b992
movl $0xffffff9c, %edi # imm = 0xFFFFFF9C
movq %rdx, %rsi
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
new_fixup | static struct fixup_entry *
new_fixup(struct archive_write_disk *a, const char *pathname)
{
struct fixup_entry *fe;
fe = (struct fixup_entry *)calloc(1, sizeof(struct fixup_entry));
if (fe == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory for a fixup");
return (NULL);
}
fe->next =... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0xb0, %esi
callq 0x3bed8
movq %rax, %rbx
testq %rax, %rax
je 0x49c1a9
movq 0x98(%r14), %rax
movq %rax, (%rbx)
movq %rbx, 0x98(%r14)
movq %r15, %rdi
callq 0x3be70
movq %rax, 0xa8(%rbx)
jmp 0x49c1bf
leaq 0x177a18(%rip), %rdx # 0x613... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
lazy_stat | static int
lazy_stat(struct archive_write_disk *a)
{
if (a->pst != NULL) {
/* Already have stat() data available. */
return (ARCHIVE_OK);
}
#ifdef HAVE_FSTAT
if (a->fd >= 0 && fstat(a->fd, &a->st) == 0) {
a->pst = &a->st;
return (ARCHIVE_OK);
}
#endif
/*
* XXX At this point, symlinks should not be hit, o... | pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpq $0x0, 0x1a8(%rdi)
jne 0x49c6f3
movq %rdi, %r14
movl 0x204(%rdi), %edi
testl %edi, %edi
js 0x49c6b3
leaq 0x118(%r14), %r15
movq %r15, %rsi
callq 0x3b0d0
testl %eax, %eax
je 0x49c6ec
movq 0x1b8(%r14), %rdi
leaq 0x118(%r14), %r15
movq %r15, %rsi
callq 0x39870
testl %ea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_disk_posix.c |
archive_compressor_compress_write | static int
archive_compressor_compress_write(struct archive_write_filter *f,
const void *buff, size_t length)
{
struct private_data *state = (struct private_data *)f->data;
int i;
int ratio;
int c, disp, ret;
const unsigned char *bp;
if (length == 0)
return ARCHIVE_OK;
bp = buff;
if (state->in_count ==... | xorl %eax, %eax
testq %rdx, %rdx
je 0x49d08b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%rdi), %rbp
cmpq $0x0, (%rbp)
je 0x49cee4
movq %rdi, (%rsp)
jmp 0x49cf06
movzbl (%r15), %ecx
movl %ecx, 0x65164(%rbp)
movq $0x1, (%rbp)
decq %r14
je 0x49d07... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.c |
archive_compressor_gzip_options | static int
archive_compressor_gzip_options(struct archive_write_filter *f, const char *key,
const char *value)
{
struct private_data *data = (struct private_data *)f->data;
if (strcmp(key, "compression-level") == 0) {
if (value == NULL || !(value[0] >= '0' && value[0] <= '9') ||
value[1] != '\0')
retu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x40(%rdi), %r15
leaq 0x12beed(%rip), %rsi # 0x5c94d9
movq %r14, %rdi
callq 0x3aed0
testl %eax, %eax
je 0x49d628
leaq 0x12bde5(%rip), %rsi # 0x5c93e4
movq %r14, %rdi
callq 0x3aed0
movl %eax, %ecx
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_gzip.c |
archive_write_add_filter_xz | int
archive_write_add_filter_xz(struct archive *_a)
{
struct archive_write_filter *f;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_xz");
f = __archive_write_allocate_filter(_a);
r = common_setup(f);
if (r == ARCHIVE_OK) {
f->code = ARCHIVE_FILTER_XZ;
f... | pushq %rbx
movq %rdi, %rbx
leaq 0x176779(%rip), %rcx # 0x614080
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x4b87c0
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x49d94d
movq %rbx, %rdi
callq 0x49923d
movq %rax, %rbx
movq %rax, %rdi
callq 0x49d94f
te... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
archive_compressor_xz_close | static int
archive_compressor_xz_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
data->total_out +=
data->compressed_buffer_size - data->stream.avail_out;
ret = __archive_write_filter... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rbx
movq %rbx, %rsi
movl $0x1, %edx
callq 0x49df58
movl %eax, %ebp
testl %eax, %eax
jne 0x49ddf2
movq 0x128(%rbx), %rsi
movq 0x130(%rbx), %rdx
subq 0x28(%rbx), %rdx
addq %rdx, 0x138(%rbx)
movq 0x10(%r14), %rdi
callq 0x499285
movl %eax, %ebp
cmpl $0x9, 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_xz.c |
drive_compressor | static int
drive_compressor(struct archive_write_filter *f,
struct private_data *data, int finishing, const void *src, size_t length)
{
ZSTD_inBuffer in = (ZSTD_inBuffer) { src, length, 0 };
for (;;) {
if (data->out.pos == data->out.size) {
const int ret = __archive_write_filter(f->next_filter,
data-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %rcx, (%r15)
movq %r8, 0x8(%r15)
movq $0x0, 0x10(%r15)
leaq 0x18(%rsi), %r12
movq 0x28(%rbx), %rdx
cmpq 0x20(%rbx), %rdx
jne 0x49e3f0
movq 0x10(%r14), %rdi
movq (%r12),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_zstd.c |
archive_write_set_format_cpio_binary | static int
archive_write_set_format_cpio_binary(struct archive *_a, int format)
{
struct archive_write *a = (struct archive_write *)_a;
struct cpio *cpio;
if (sizeof(struct cpio_binary_header) != HSIZE) {
archive_set_error(&a->archive, EINVAL,
"Binary cpio format not supported on this platform");
return (... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x175e5b(%rip), %rcx # 0x61439e
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x4b87c0
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x49e645
movq 0x138(%r14), %rax
testq %rax, %rax
je 0x49e571
movq %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
archive_write_newc_close | static int
archive_write_newc_close(struct archive_write *a)
{
int er;
struct archive_entry *trailer;
trailer = archive_entry_new();
archive_entry_set_nlink(trailer, 1);
archive_entry_set_size(trailer, 0);
archive_entry_set_pathname(trailer, "TRAILER!!!");
/* Bypass the required data checks. */
er = write_head... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x466d09
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x467e43
movq %r14, %rdi
xorl %esi, %esi
callq 0x467f31
leaq 0x16a747(%rip), %rsi # 0x60976b
movq %r14, %rdi
callq 0x467e4e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49f099
movl %eax, %ebx
movq %r14, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
write_header | static int
write_header(struct archive_write *a, struct archive_entry *entry)
{
int64_t ino;
struct cpio *cpio;
const char *p, *path;
int pathlength, ret, ret_final;
char h[c_header_size];
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
size_t len;
int pad;
cpio = (struct cpio *)a->forma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xf8(%rdi), %rbp
callq 0x49f06a
movq %rax, %r15
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rcx
callq 0x467266
testl %eax, %eax
je 0x49f0ee
callq 0x3b610
cmpl $0xc, (%rax)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_newc.c |
archive_format_gnutar_header | static int
archive_format_gnutar_header(struct archive_write *a, char h[512],
struct archive_entry *entry, int tartype)
{
unsigned int checksum;
int i, ret;
size_t copy_length;
const char *p;
struct gnutar *gnutar;
gnutar = (struct gnutar *)a->format_data;
ret = 0;
/*
* The "template header" already in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq 0xf8(%rdi), %r14
leaq 0x174290(%rip), %rsi # 0x614870
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
callq 0x39260
movq %r15, 0x10(%rsp)
addl $-0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
isoent_new | static struct isoent *
isoent_new(struct isofile *file)
{
struct isoent *isoent;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node, isoent_cmp_key,
};
isoent = calloc(1, sizeof(*isoent));
if (isoent == NULL)
return (NULL);
isoent->file = file;
isoent->children.first = NULL;
isoent->childre... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0xf0, %esi
callq 0x3bed8
movq %rax, %rbx
testq %rax, %rax
je 0x4a3d0a
movq %r14, 0x18(%rbx)
leaq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
leaq 0x2e032e(%rip), %rsi # 0x783ff0
callq 0x46af58
leaq 0x50(%rbx), %rax
xorl %ecx, %ec... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_VD_boot_record | static int
write_VD_boot_record(struct archive_write *a)
{
struct iso9660 *iso9660;
unsigned char *bp;
iso9660 = a->format_data;
bp = wb_buffptr(a) -1;
/* Volume Descriptor Type */
set_VD_bp(bp, VDT_BOOT_RECORD, 1);
/* Boot System Identifier */
memcpy(bp+8, "EL TORITO SPECIFICATION", 23);
set_unused_field_bp(... | pushq %rbx
movq %rdi, %rbx
movq 0xf8(%rdi), %rax
movq %rax, %rdi
subq 0x102e0(%rax), %rdi
movb $0x0, 0x102dc(%rdi)
movl $0x30304443, 0x102dd(%rdi) # imm = 0x30304443
movw $0x131, 0x102e1(%rdi) # imm = 0x131
movups 0x16fc4d(%rip), %xmm0 # 0x6153e3
movups %xmm0, 0x102e3(%rdi)
movabsq $0x4e4f495441434946, %rcx # imm =... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_directory_descriptors | static int
write_directory_descriptors(struct archive_write *a, struct vdd *vdd)
{
struct isoent *np;
int depth, r;
depth = 0;
np = vdd->rootent;
do {
struct extr_rec *extr;
r = _write_directory_descriptors(a, vdd, np, depth);
if (r < 0)
return (r);
if (vdd->vdd_type != VDD_JOLIET) {
/*
* This ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rsi), %r12
xorl %ecx, %ecx
movq %rdi, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
movq 0xf8(%r15), %rbp
movq %rbp, %rbx
subq 0x102e0(%rbp), %rbx
leaq 0x102dc(%rbx), %r14
movl 0x8(%r13), %r9d
movl $0x800, %esi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_gen_iso9660_identifier | static int
isoent_gen_iso9660_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
char *p;
int l, r;
const char *char_map;
char allow_ldots, allow_multidot, allow_period, allow_vernum;
int fnmax, ffmax, dnmax;
static const struct archive_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movl 0x38(%rsi), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x4a735f
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rax
movq %rax, 0x38(%rsp)
movl 0x10370(%rax), %eax
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x7, %ecx
cmpl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_cmp_iso9660_identifier | static int
isoent_cmp_iso9660_identifier(const struct isoent *p1, const struct isoent *p2)
{
const char *s1, *s2;
int cmp;
int l;
s1 = p1->identifier;
s2 = p2->identifier;
/* Compare File Name */
l = p1->ext_off;
if (l > p2->ext_off)
l = p2->ext_off;
cmp = memcmp(s1, s2, l);
if (cmp != 0)
return (cmp);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
movq 0xa8(%rsi), %r15
movslq 0xb0(%r14), %r12
movslq 0xb0(%rsi), %rbp
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movslq %eax, %r13
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r13, %rdx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
archive_write_pax_data | static ssize_t
archive_write_pax_data(struct archive_write *a, const void *buff, size_t s)
{
struct pax *pax;
size_t ws;
size_t total;
int ret;
pax = (struct pax *)a->format_data;
/*
* According to GNU PAX format 1.0, write a sparse map
* before the body.
*/
if (archive_strlen(&(pax->sparse_map))) {
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rbp
movq 0x48(%rbp), %rdx
testq %rdx, %rdx
je 0x4add96
movq 0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x4992bf
testl %eax, %eax
jne 0x4add89
movq 0x58(%rbp), %rsi
movq %r15, %rdi
c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
get_entry_uname | static int
get_entry_uname(struct archive_write *a, struct archive_entry *entry,
const char **name, size_t *length, struct archive_string_conv *sc)
{
int r;
r = archive_entry_uname_l(entry, name, length, sc);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x46753d
testl %eax, %eax
je 0x4adff7
callq 0x3b610
movq %rax, %rcx
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
cmpl $0xc, (%rcx)
jne 0x4adff9
leaq 0x16675f(%rip), %rdx # 0x614740
movq %rbx, %rdi
movl $0xc, %esi
xorl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
sparse_list_add | static int
sparse_list_add(struct pax *pax, int64_t offset, int64_t length)
{
int64_t last_offset;
int r;
if (pax->sparse_tail == NULL)
last_offset = 0;
else {
last_offset = pax->sparse_tail->offset +
pax->sparse_tail->remaining;
}
if (last_offset < offset) {
/* Add a hole block. */
r = _sparse_lis... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x4ae633
movq 0x18(%rax), %rsi
addq 0x10(%rax), %rsi
jmp 0x4ae635
xorl %esi, %esi
movq %r14, %rdx
subq %rsi, %rdx
jle 0x4ae654
movq %r15, %rdi
movl $0x1, %ecx
callq 0x4aec3c
testl %eax, %eax
je 0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_pax.c |
archive_write_raw_header | static int
archive_write_raw_header(struct archive_write *a, struct archive_entry *entry)
{
struct raw *raw = (struct raw *)a->format_data;
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_set_error(&a->archive, ERANGE,
"Raw format only supports filetype AE_IFREG");
return (ARCHIVE_FATAL);
}
if... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r14
movq %rsi, %rdi
callq 0x466dcb
cmpl $0x8000, %eax # imm = 0x8000
jne 0x4aedb5
movl (%r14), %eax
testl %eax, %eax
jle 0x4aedd8
leaq 0x167261(%rip), %rdx # 0x616014
jmp 0x4aedbc
leaq 0x16722d(%rip), %rdx # 0x615fe9
movq %rbx, %rdi
movl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_raw.c |
archive_write_set_format_shar | int
archive_write_set_format_shar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct shar *shar;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_shar");
/* If someone else was already registered, unregister them. */
if (a->format_free... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x167285(%rip), %rcx # 0x6160aa
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x4b87c0
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x4aeee7
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x4aee53
movq %rbx, %rdi
callq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
blake2s_final | int blake2s_final( blake2s_state *S, void *out, size_t outlen )
{
uint8_t buffer[BLAKE2S_OUTBYTES] = {0};
size_t i;
if( out == NULL || outlen < S->outlen )
return -1;
if( blake2s_is_lastblock( S ) )
return -1;
blake2s_increment_counter( S, ( uint32_t )S->buflen );
blake2s_set_lastblock( S );
me... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x4b5b94
movq %rdx, %rbx
movq %rdi, %r15
cmpq %rdx, 0x78(%rdi)
ja 0x4b5b94
cmpl $0x0, 0x28(%r15)
jne 0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2s_ref.c |
archive_acl_to_text_w | wchar_t *
archive_acl_to_text_w(struct archive_acl *acl, ssize_t *text_len, int flags,
struct archive *a)
{
int count;
ssize_t length;
size_t len;
const wchar_t *wname;
const wchar_t *prefix;
wchar_t separator;
struct archive_acl_entry *ap;
int id, r, want_type;
wchar_t *wp, *ws;
want_type = archive_acl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rdi), %eax
testl $0x3c00, %eax # imm = 0x3C00
je 0x4b6206
testl $0x300, %eax # imm = 0x300
jne 0x4b645a
movl $0x3c00, %r15d # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
pbkdf2_sha1 | static int
pbkdf2_sha1(const char *pw, size_t pw_len, const uint8_t *salt,
size_t salt_len, unsigned rounds, uint8_t *derived_key,
size_t derived_key_len) {
(void)pw; /* UNUSED */
(void)pw_len; /* UNUSED */
(void)salt; /* UNUSED */
(void)salt_len; /* UNUSED */
(void)rounds; /* UNUSED */
(void)derived_key;... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cryptor.c |
SplitBlock | static void SplitBlock(CPpmd8 *p, void *ptr, unsigned oldIndx, unsigned newIndx)
{
unsigned i, nu = I2U(oldIndx) - I2U(newIndx);
ptr = (Byte *)ptr + U2B(I2U(newIndx));
if (I2U(i = U2I(nu)) != nu)
{
unsigned k = I2U(--i);
InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);
}
InsertNode(p, ptr, i);
} | movl %edx, %eax
movzbl 0x80(%rdi,%rax), %edx
movl %ecx, %eax
movzbl 0x80(%rdi,%rax), %eax
subl %eax, %edx
leaq (%rax,%rax,2), %rax
leaq (%rsi,%rax,4), %rax
leal -0x1(%rdx), %ecx
movzbl 0xa6(%rdi,%rcx), %ecx
movzbl 0x80(%rdi,%rcx), %esi
cmpl %esi, %edx
jne 0x4bc477
movq 0x38(%rdi), %rsi
jmp 0x4bc4c1
decl %ecx
movzbl 0x8... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
read_Bools | static int
read_Bools(struct archive_read *a, unsigned char *data, size_t num)
{
const unsigned char *p;
unsigned i, mask = 0, avail = 0;
for (i = 0; i < num; i++) {
if (mask == 0) {
if ((p = header_bytes(a, 1)) == NULL)
return (-1);
avail = *p;
mask = 0x80;
}
data[i] = (avail & mask)?1:0;
mask... | testq %rdx, %rdx
je 0x4c3495
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movl $0x1, %ebp
xorl %eax, %eax
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0x4c347e
movl $0x1, %esi
movq %r15, %rdi
callq 0x4bff4d
testq %rax, %rax
je 0x4c3498
movzbl (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c |
7z_finish_entry | static int
_7z_finish_entry(struct archive_write *a)
{
struct _7zip *zip;
size_t s;
ssize_t r;
zip = (struct _7zip *)a->format_data;
if (zip->cur_file == NULL)
return (ARCHIVE_OK);
while (zip->entry_bytes_remaining > 0) {
s = (size_t)zip->entry_bytes_remaining;
if (s > a->null_length)
s = a->null_lengt... | pushq %r15
pushq %r14
pushq %rbx
movq 0xf8(%rdi), %r15
xorl %ebx, %ebx
cmpq $0x0, 0x10(%r15)
je 0x4c48b1
movq %rdi, %r14
movq 0x68(%r15), %rax
testq %rax, %rax
je 0x4c4888
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %r14, %rdi
callq 0x4c47e6
testq %rax, %rax
jns 0x4c4859
movl %eax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
compression_code_deflate | static int
compression_code_deflate(struct archive *a,
struct la_zstream *lastrm, enum la_zaction action)
{
z_stream *strm;
int r;
strm = (z_stream *)lastrm->real_stream;
/* zlib.h is not const-correct, so we need this one bit
* of ugly hackery to convert a const * pointer to
* a non-const pointer. */
str... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x48(%rsi), %r15
movq %rax, (%r15)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%r15)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%r15)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%r15)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%r15)
movq 0x28(%rsi), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
compression_end_lzma | static int
compression_end_lzma(struct archive *a, struct la_zstream *lastrm)
{
lzma_stream *strm;
(void)a; /* UNUSED */
strm = (lzma_stream *)lastrm->real_stream;
lzma_end(strm);
free(strm);
lastrm->valid = 0;
lastrm->real_stream = NULL;
return (ARCHIVE_OK);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x48(%rsi), %r14
movq %r14, %rdi
callq 0x4d3ad5
movq %r14, %rdi
callq 0x3be90
movl $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
archive_write_ar_data | static ssize_t
archive_write_ar_data(struct archive_write *a, const void *buff, size_t s)
{
struct ar_w *ar;
int ret;
ar = (struct ar_w *)a->format_data;
if (s > ar->entry_bytes_remaining)
s = (size_t)ar->entry_bytes_remaining;
if (ar->is_strtab > 0) {
if (ar->has_strtab > 0) {
archive_set_error(&a->archi... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0xf8(%rdi), %r13
movq (%r13), %rax
cmpq %rdx, %rax
cmovbq %rax, %rbx
cmpl $0x0, 0x10(%r13)
jle 0x4c6d20
cmpl $0x0, 0x14(%r13)
jle 0x4c6cf0
leaq 0x142208(%rip), %rdx # 0x608ee0
movq %r14, %rdi
movl $0x16, %esi
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
format_decimal | static int
format_decimal(int64_t v, char *p, int s)
{
int len;
char *h;
len = s;
h = p;
/* Negative values in ar header are meaningless, so use 0. */
if (v < 0) {
while (len-- > 0)
*p++ = '0';
return (-1);
}
p += s;
do {
*--p = (char)('0' + (v % 10));
v /= 10;
} while (--s > 0 && v > 0);
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
testq %rdi, %rdi
js 0x4c6ed8
movq %rdi, %rdx
movl %ebx, %ecx
leaq (%rsi,%rcx), %r14
xorl %r10d, %r10d
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %r14, %r8
movl %ebx, %r13d
movl %r13d, %r12d
movq %rdx, %rd... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
BZ2_bzCompress | int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
{
Bool progress;
EState* s;
if (strm == NULL) return BZ_PARAM_ERROR;
s = strm->state;
if (s == NULL) return BZ_PARAM_ERROR;
if (s->strm != strm) return BZ_PARAM_ERROR;
preswitch:
switch (s->mode) {
case BZ_M_IDLE:
return... | pushq %r14
pushq %rbx
pushq %rax
movl $0xfffffffe, %ebx # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x4c7229
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x4c7229
movq (%r14), %rax
cmpq %rdi, %rax
je 0x4c7233
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x8(%r14), %ecx
xorl %ebx, %ebx
cmpl $0x2, %ecx
jne... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzWriteOpen | BZFILE* BZ_API(BZ2_bzWriteOpen)
( int* bzerror,
FILE* f,
int blockSize100k,
int verbosity,
int workFactor )
{
Int32 ret;
bzFile* bzf = NULL;
BZ_SETERR(BZ_OK);
if (f == NULL ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4c87b3
movl $0x0, (%rbx)
cmpl $0x4, %ebp
ja 0x4c87e8
testq %r13, %r13
je 0x4c87e8
leal -0xa(%r15), %eax
cmpl $-0x9, %eax
jb 0x4c87e8
cmpl $... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
mainGtU | static
__inline__
Bool mainGtU ( UInt32 i1,
UInt32 i2,
UChar* block,
UInt16* quadrant,
UInt32 nblock,
Int32* budget )
{
Int32 k;
UChar c1, c2;
UInt16 s1, s2;
AssertD ( i1 != i2, "mainGtU" );
/* 1 */
c1 = block[i1]; c2... | movl %edi, %eax
movl %esi, %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0x4d2885
leal 0x1(%rdi), %eax
leal 0x1(%rsi), %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0x4d2885
leal 0x2(%rdi), %eax
leal 0x2(%rsi), %r10d
movb (%rdx,%r10), %r10b
cmpb %r10b, (%rdx,%rax)
jne 0x4d2885
leal 0x3(%rdi), %e... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
lzma_alloc | extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
lzma_alloc(size_t size, const lzma_allocator *allocator)
{
// Some malloc() variants return NULL if called with size == 0.
if (size == 0)
size = 1;
void *ptr;
if (allocator != NULL && allocator->alloc != NULL)
ptr = allocator->alloc(allocator-... | movq %rdi, %rdx
cmpq $0x1, %rdi
adcq $0x0, %rdx
testq %rsi, %rsi
je 0x4d3605
movq (%rsi), %rax
testq %rax, %rax
je 0x4d3605
movq 0x10(%rsi), %rdi
movl $0x1, %esi
jmpq *%rax
movq %rdx, %rdi
jmp 0x3bee0
| /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_code | extern LZMA_API(lzma_ret)
lzma_code(lzma_stream *strm, lzma_action action)
{
// Sanity checks
if ((strm->next_in == NULL && strm->avail_in != 0)
|| (strm->next_out == NULL && strm->avail_out != 0)
|| strm->internal == NULL
|| strm->internal->next.code == NULL
|| (unsigned int)(action) > LZMA_ACTION_MAX
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r10d
movq %rdi, %rbx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x4d396f
movq 0x18(%rbx), %r9
testq %r9, %r9
je 0x4d3984
movq 0x38(%rbx), %rcx
testq %rcx, %rcx
je 0x4d3a39
movq 0x18(%rcx), %r11
testq %r11, %r11
sete %al
cmpl $0x5, %r10d
setae %sil
orb %al, %sil
j... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_memlimit_set | extern LZMA_API(lzma_ret)
lzma_memlimit_set(lzma_stream *strm, uint64_t new_memlimit)
{
// Dummy variables to simplify memconfig functions
uint64_t old_memlimit;
uint64_t memusage;
if (strm == NULL || strm->internal == NULL
|| strm->internal->next.memconfig == NULL)
return LZMA_PROG_ERROR;
// Zero is a spec... | movl $0xb, %eax
testq %rdi, %rdi
je 0x4d3c19
movq 0x38(%rdi), %rdx
testq %rdx, %rdx
je 0x4d3c19
movq 0x38(%rdx), %r8
testq %r8, %r8
je 0x4d3c19
subq $0x18, %rsp
movq %rsi, %rcx
cmpq $0x1, %rsi
adcq $0x0, %rcx
movq (%rdx), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq *%r8
addq $0x18, %rsp
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
lzma_properties_size | extern LZMA_API(lzma_ret)
lzma_properties_size(uint32_t *size, const lzma_filter *filter)
{
const lzma_filter_encoder *const fe = encoder_find(filter->id);
if (fe == NULL) {
// Unknown filter - if the Filter ID is a proper VLI,
// return LZMA_OPTIONS_ERROR instead of LZMA_PROG_ERROR,
// because it's possible th... | movq (%rsi), %rax
xorl %ecx, %ecx
leaq 0x2b180d(%rip), %rdx # 0x785730
cmpq %rax, (%rcx,%rdx)
je 0x4d3f41
addq $0x38, %rcx
cmpq $0x1f8, %rcx # imm = 0x1F8
jne 0x4d3f23
shrq $0x3f, %rax
leal (%rax,%rax,2), %eax
addl $0x8, %eax
retq
movq 0x20(%rcx,%rdx), %rax
testq %rax, %rax
je 0x4d3f51
movq 0x8(%rsi), %rs... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
stream_encoder_init | static lzma_ret
stream_encoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
const lzma_filter *filters, lzma_check check)
{
lzma_next_coder_init(&stream_encoder_init, next, allocator);
if (filters == NULL)
return LZMA_PROG_ERROR;
lzma_stream_coder *coder = next->coder;
if (coder == NULL) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq -0x1e(%rip), %r15 # 0x4d473c
cmpq %r15, 0x10(%rdi)
je 0x4d476b
movq %r12, %rdi
movq %r14, %rsi
callq 0x4d3721
movq %r15, 0x10(%r12)
testq %rbx, %rbx
je 0x4d478a
movq (%r12),... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder.c |
get_options | static lzma_ret
get_options(const lzma_mt *options, lzma_options_easy *opt_easy,
const lzma_filter **filters, uint64_t *block_size,
uint64_t *outbuf_size_max)
{
// Validate some of the options.
if (options == NULL)
return LZMA_PROG_ERROR;
if (options->flags != 0 || options->threads == 0
|| options->threads... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4d51dd
movq %rdi, %r12
movl $0x8, %ebp
cmpl $0x0, (%rdi)
jne 0x4d51e2
movl $0xffffbfff, %eax # imm = 0xFFFFBFFF
addl 0x4(%r12), %eax
cmpl $0xffffc000, %eax # imm = 0xFFFFC000
jb 0x4d51e2
movq %r8, %rbx
movq %r... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
get_progress | static void
get_progress(void *coder_ptr, uint64_t *progress_in, uint64_t *progress_out)
{
lzma_stream_coder *coder = coder_ptr;
// Lock coder->mutex to prevent finishing threads from moving their
// progress info from the worker_thread structure to lzma_stream_coder.
mythread_sync(coder->mutex) {
*progress_in =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x168(%rdi), %r14
movq %r14, %rdi
callq 0x398c0
testl %eax, %eax
jne 0x4d5d21
movq 0x158(%r12), %rax
movq %rax, (%r15)
movq 0x160(%r12), %rax
movq %rax, (%rbx)
cmpl $0x0, 0x144(%r12)
je 0x4d... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
threads_stop | static void
threads_stop(lzma_stream_coder *coder, bool wait_for_threads)
{
// Tell the threads to stop.
for (uint32_t i = 0; i < coder->threads_initialized; ++i) {
mythread_sync(coder->threads[i].mutex) {
coder->threads[i].state = THR_STOP;
mythread_cond_signal(&coder->threads[i].cond);
}
}
if (!wait_fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x144(%rdi)
je 0x4d5fc6
movl %esi, %ebp
movq %rdi, %rbx
movl $0x160, %r14d # imm = 0x160
xorl %r15d, %r15d
movq 0x138(%rbx), %rdi
addq %r14, %rdi
callq 0x398c0
testl %eax, %eax
jne 0x4d5ff0
movq 0x138(%rbx), %rax
leaq (%rax,%r14), %rdi
addq $0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
worker_start | static MYTHREAD_RET_TYPE
worker_start(void *thr_ptr)
{
worker_thread *thr = thr_ptr;
worker_state state = THR_IDLE; // Init to silence a warning
while (true) {
// Wait for work.
mythread_sync(thr->mutex) {
while (true) {
// The thread is already idle so if we are
// requested to stop, just set the st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x160(%rdi), %r12
leaq 0x188(%rdi), %r15
leaq 0x30(%rdi), %rbp
leaq 0x88(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0xb0(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0x40(%rdi), %r14
movq %r14, (%rsp)
movq %rbp, 0x8(%rsp)
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
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... | testq %rdx, %rdx
je 0x4d773c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
testq %rax, %rax
jne 0x4d770b
movl $0x100a8, %edi # imm = 0x100A8
movq %r14, %rsi
callq 0x4d35e2
testq %rax, %rax
je 0x4d7782
movq %rax, (%r12)
l... | /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 |... | movq 0x8(%rsi), %rcx
movl $0xb, %eax
testq %rcx, %rcx
je 0x4d7d65
cmpl $0x0, (%rdi)
je 0x4d7d66
retq
movl 0x14(%rcx), %edx
cmpl %edx, 0x24(%rdi)
jne 0x4d7d80
movl 0x28(%rdi), %eax
cmpl 0x18(%rcx), %eax
jne 0x4d7d80
movl 0x2c(%rdi), %esi
xorl %eax, %eax
cmpl 0x1c(%rcx), %esi
je 0x4d7d65
movl $0x8, %eax
cmpl $0x4, %edx
j... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_encoder.c |
lzma_lzma_encoder_memusage | extern uint64_t
lzma_lzma_encoder_memusage(const void *options)
{
if (!is_options_valid(options))
return UINT64_MAX;
lzma_lz_options lz_options;
set_lz_options(&lz_options, options);
const uint64_t lz_memusage = lzma_lz_encoder_memusage(&lz_options);
if (lz_memusage == UINT64_MAX)
return UINT64_MAX;
return... | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x4dc7f8
movl %eax, %ecx
movq $-0x1, %rax
testb %cl, %cl
je 0x4dca2e
movq %rsp, %rdi
movq $0x1000, (%rdi) # imm = 0x1000
movl (%rbx), %eax
movq %rax, 0x8(%rdi)
movq $0x1001, 0x10(%rdi) # imm = 0x1001
movq $0x111, 0x18(%rdi) # imm = 0x111
movl 0x24(%rbx)... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
lzma_check_size | extern LZMA_API(uint32_t)
lzma_check_size(lzma_check type)
{
if ((unsigned int)(type) > LZMA_CHECK_ID_MAX)
return UINT32_MAX;
// See file-format.txt section 2.1.1.2.
static const uint8_t check_sizes[LZMA_CHECK_ID_MAX + 1] = {
0,
4, 4, 4,
8, 8, 8,
16, 16, 16,
32, 32, 32,
64, 64, 64
};
return check_s... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0xf, %edi
ja 0x4e04c4
movl %edi, %eax
leaq 0x13c730(%rip), %rcx # 0x61cbf0
movzbl (%rax,%rcx), %eax
retq
| /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/check.c |
lzma_sha256_finish | extern void
lzma_sha256_finish(lzma_check_state *check)
{
// Add padding as described in RFC 3174 (it describes SHA-1 but
// the same padding style is used for SHA-256 too).
size_t pos = check->state.sha256.size & 0x3F;
check->buffer.u8[pos++] = 0x80;
while (pos != 64 - 8) {
if (pos == 64) {
process(check);
... | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
andl $0x3f, %eax
movb $-0x80, %cl
movb %cl, (%rbx,%rax)
cmpq $0x3f, %rax
je 0x4e1847
leaq 0x1(%rax), %rdx
xorl %ecx, %ecx
cmpq $0x37, %rax
movq %rdx, %rax
jne 0x4e182d
jmp 0x4e1855
movq %rbx, %rdi
callq 0x4e06c9
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x4e182d
movq 0x60(%rbx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/sha256.c |
lzma_index_stream_size | extern LZMA_API(lzma_vli)
lzma_index_stream_size(const lzma_index *i)
{
// Stream Header + Blocks + Index + Stream Footer
return LZMA_STREAM_HEADER_SIZE + i->total_size
+ index_size(i->record_count, i->index_list_size)
+ LZMA_STREAM_HEADER_SIZE;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x38(%rbx), %r14
callq 0x4e553c
incl %eax
addq %r14, %rax
addq $0x4, %rax
js 0x4e35e2
movq 0x28(%rbx), %rcx
addq $0x3, %rax
andq $-0x4, %rax
addq %rcx, %rax
addq $0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13be93(%rip), %rdi ... | /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... | movb $0x1, %al
cmpl $0x3, %esi
ja 0x4e41f5
pushq %rax
movq 0x108(%rdi), %rcx
cmpl $0x1, %esi
jne 0x4e4061
xorl %r8d, %r8d
jmp 0x4e40bb
movq 0x120(%rdi), %rdx
cmpq $0x2, %rdx
je 0x4e40b4
cmpq $0x1, %rdx
je 0x4e4082
testq %rdx, %rdx
jne 0x4e405c
leaq 0x110(%rdi), %rdx
jmp 0x4e40b8
movq 0x110(%rdi), %rdx
movq 0x20(%rdx), ... | /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 %r15
pushq %r14
pushq %rbx
movq 0x100(%rdi), %rcx
movb $0x1, %al
cmpq %rsi, 0x20(%rcx)
jbe 0x4e45f3
movq %rsi, %r14
movq %rdi, %rbx
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
movq %r14, %rdx
callq 0x4e4637
testq %rax, %rax
je 0x4e45f9
movq %rax, %r15
subq (%rax), %r14
movq 0x38(%rax), %rdi
movq 0x40(%rax), %rsi
movq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/index.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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r9
testq %rsi, %rsi
je 0x4e5331
movq (%rsi), %r10
testq %r10, %r10
je 0x4e5356
movl $0xb, %eax
cmpq $0x8, %r10
ja 0x4e5455
movq (%rdi), %r11
jmp 0x4e5360
movq $0x0, (%rdi)
movq (%r9), %rbx
movl $0x9, %eax
cmpq %r8, %rbx
jae 0x4e5455
leaq -0x8(%rsp), %rs... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/vli_decoder.c |
lzma_vli_size | extern LZMA_API(uint32_t)
lzma_vli_size(lzma_vli vli)
{
if (vli > LZMA_VLI_MAX)
return 0;
uint32_t i = 0;
do {
vli >>= 7;
++i;
} while (vli != 0);
assert(i <= LZMA_VLI_BYTES_MAX);
return i;
} | testq %rdi, %rdi
js 0x4e5560
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rdi, %rcx
shrq $0x7, %rcx
incl %eax
cmpq $0x7f, %rdi
movq %rcx, %rdi
ja 0x4e5549
cmpl $0x9, %eax
jae 0x4e5563
incl %eax
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x13a5a8(%rip), %rdi # 0x61fb13
leaq 0x13a5b9(%rip), %rsi # 0x61fb2b
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/vli_size.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 %r15
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4e5e1d
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rcx, %rsi
callq *%rax
testl %eax, %eax
jne 0x4e5e22
addq $0x98, %r15
addq $0x10, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lz/lz_encoder.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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rdi), %eax
movl 0x24(%rdi), %ecx
subl %eax, %ecx
movl 0x60(%rdi), %edi
cmpl %ecx, %edi
jbe 0x4e6c04
movl 0x68(%rbx), %edx
cmpl $0x3, %ecx
jae 0x4e6bed
testl %edx, %edx
jne 0x4e6bf4
leaq 0x1392d5(%rip), %rdi # 0x61feaa
leaq 0x1391ae(%rip), %r... | /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 %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x30(%rsp)
sete %al
cmpq $0x0, 0x38(%rsp)
sete %cl
xorb %al, %cl
jne 0x4e73c7
leaq 0x30(%rsp), %r14
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movl $0xdf8, %edi # imm = 0xDF8
callq 0x4e72a7
testq %rax, %rax
je 0x4e73... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_mergeBlockDelimiters | size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize) {
size_t in = 0;
size_t out = 0;
for (; in < seqsSize; ++in) {
if (sequences[in].offset == 0 && sequences[in].matchLength == 0) {
if (in != seqsSize - 1) {
sequences[in+1].litLength += sequences[i... | xorl %eax, %eax
testq %rsi, %rsi
je 0x4e9366
movq %rdi, %rcx
cmpl $0x0, (%rcx)
jne 0x4e933c
cmpl $0x0, 0x8(%rcx)
je 0x4e9358
movq %rax, %rdx
shlq $0x4, %rdx
movups (%rcx), %xmm0
movups %xmm0, (%rdi,%rdx)
incq %rax
addq $0x10, %rcx
decq %rsi
jne 0x4e9331
jmp 0x4e9366
cmpq $0x1, %rsi
je 0x4e934d
movl 0x4(%rcx), %edx
addl... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_compress_insertDictionary | static size_t
ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
ZSTD_matchState_t* ms,
ldmState_t* ls,
ZSTD_cwksp* ws,
const ZSTD_CCtx_params* params,
const void* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rsi, %r13
movl 0x58(%rsp), %ecx
movq 0x50(%rsp), %r15
testq %r9, %r9
setne %al
cmpq $0x8, %r15
setae %sil
testb %sil, %al
jne 0x4eff72
xorl %eax, %eax
cmpl $0x2, %ecx
setne %al
shll $0x5, %eax
addq $-0x20, %rax
jmp ... | /JKorbelRA[P]CMake/Utilities/cmzstd/lib/compress/zstd_compress.c |
ZSTD_copySequencesToSeqStoreNoBlockDelim | static size_t ZSTD_copySequencesToSeqStoreNoBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition* seqPos,
const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
const void* src, size_t blockSize) {
U32 idx = se... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, %r10
movq %rdi, %r14
movl 0x4(%rsi), %r12d
movq %r9, 0x30(%rsp)
leal (%r9,%r12), %edi
movq 0xdd0(%r14), %rax
testq %rax, %rax
je 0x4f073a
addq $0x8, %rax
jmp 0x4f074f
... | /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.