name string | code string | asm string | file string |
|---|---|---|---|
unicode_to_utf16le | static size_t
unicode_to_utf16le(char *p, size_t remaining, uint32_t uc)
{
char *utf16 = p;
if (uc > 0xffff) {
/* We have a code point that won't fit into a
* wchar_t; convert it to a surrogate pair. */
if (remaining < 4)
return (0);
uc -= 0x10000;
archive_le16enc(utf16, ((uc >> 10) & 0x3ff) + 0xD800);... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xffff, -0x1c(%rbp) # imm = 0xFFFF
jbe 0x93eaf3
cmpq $0x4, -0x18(%rbp)
jae 0x93eaa5
movq $0x0, -0x8(%rbp)
jmp 0x93eb1b
movl -0x1c(%rbp), %eax
subl $0x10... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_be16dec | static inline uint16_t
archive_be16dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p1 = p[1];
unsigned int p0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll $0x8, %eax
orl -0x14(%rbp), %eax
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
get_nfd | static int
get_nfd(uint32_t *cp1, uint32_t *cp2, uint32_t uc)
{
int t, b;
/*
* These are not converted to NFD on Mac OS.
*/
if ((uc >= 0x2000 && uc <= 0x2FFF) ||
(uc >= 0xF900 && uc <= 0xFAFF) ||
(uc >= 0x2F800 && uc <= 0x2FAFF))
return (0);
/*
* Those code points are not converted to NFD on Mac ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x2000, -0x1c(%rbp) # imm = 0x2000
jb 0x93f271
cmpl $0x2fff, -0x1c(%rbp) # imm = 0x2FFF
jbe 0x93f295
cmpl $0xf900, -0x1c(%rbp) # imm = 0xF900
jb 0x93f283
cmpl $0xfaff, -0x1c(%rbp) # imm = 0xFAFF
jbe 0x93f29... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
get_nfc | static uint32_t
get_nfc(uint32_t uc, uint32_t uc2)
{
int t, b;
t = 0;
b = sizeof(u_composition_table)/sizeof(u_composition_table[0]) -1;
while (b >= t) {
int m = (t + b) / 2;
if (u_composition_table[m].cp1 < uc)
t = m + 1;
else if (u_composition_table[m].cp1 > uc)
b = m - 1;
else if (u_composition_ta... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x3a2, -0x14(%rbp) # imm = 0x3A2
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x93f47f
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
best_effort_strncat_from_utf16 | static int
best_effort_strncat_from_utf16(struct archive_string *as, const void *_p,
size_t bytes, struct archive_string_conv *sc, int be)
{
const char *utf16 = (const char *)_p;
char *mbs;
uint32_t uc;
int n, ret;
(void)sc; /* UNUSED */
/*
* Other case, we should do the best effort.
* If all character a... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x20(%rbp), %rsi
ad... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
invalid_mbs | static int
invalid_mbs(const void *_p, size_t n, struct archive_string_conv *sc)
{
const char *p = (const char *)_p;
size_t r;
#if HAVE_MBRTOWC
mbstate_t shift_state;
memset(&shift_state, 0, sizeof(shift_state));
#else
/* Clear the shift state before starting. */
mbtowc(NULL, NULL, 0);
#endif
while (n) {
wch... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3b780
cmpq $0x0, -0x18(%rbp)
je 0x93f6a9
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x3c(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_string.c |
archive_compressor_bzip2_options | static int
archive_compressor_bzip2_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')
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1fe1d8(%rip), %rsi # 0xb45593
callq 0x3dbb0
cmpl $0x0, %eax
jne 0x947426
cmpq $0x0, -0x20(%rbp)
je 0x9473f... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_compressor_bzip2_close | static int
archive_compressor_bzip2_close(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
/* Finish compression cycle. */
ret = drive_compressor(f, data, 1);
if (ret == ARCHIVE_OK) {
/* Write the last block */
ret = __archive_write_filter(f->next_filter,
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x9477b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x94749d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.c |
archive_compressor_bzip2_open | static int
archive_compressor_bzip2_open(struct archive_write_filter *f)
{
struct private_data *data = (struct private_data *)f->data;
int ret;
if (data->compressed == NULL) {
size_t bs = 65536, bpb;
if (f->archive->magic == ARCHIVE_WRITE_MAGIC) {
/* Buffer size should be a multiple number of the of bytes
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x947610
movq $0x10000, -0x28(%rbp) # imm = 0x10000
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0xb0c5c0de, (%rax) # imm = 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_bzip2.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 ==... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x947c33
movl $0x0, -0x4(%rbp)
jmp 0x947f50
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_add_filter_compress.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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x27c36a(%rip), %rcx # 0xbc6896
callq 0x9770c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1e, -0x2c(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_binary.c |
archive_write_odc_free | static int
archive_write_odc_free(struct archive_write *a)
{
struct cpio *cpio;
cpio = (struct cpio *)a->format_data;
free(cpio->ino_list);
free(cpio);
a->format_data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3e548
movq -0x10(%rbp), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq $0x0, 0xf8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
get_sconv | static struct archive_string_conv *
get_sconv(struct archive_write *a)
{
struct cpio *cpio;
struct archive_string_conv *sconv;
cpio = (struct cpio *)a->format_data;
sconv = cpio->opt_sconv;
if (sconv == NULL) {
if (!cpio->init_default_conversion) {
cpio->sconv_default =
archive_string_default_conversi... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x94c4d3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x94c4c7
movq -0x8(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
format_octal | static int
format_octal(int64_t v, void *p, int digits)
{
int64_t max;
int ret;
max = (((int64_t)1) << (digits * 3)) - 1;
if (v >= 0 && v <= max) {
format_octal_recursive(v, (char *)p, digits);
ret = 0;
} else {
format_octal_recursive(max, (char *)p, digits);
ret = -1;
}
return (ret);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
imull $0x3, -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x94ca45
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_set_format_gnutar | int
archive_write_set_format_gnutar(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct gnutar *gnutar;
gnutar = (struct gnutar *)calloc(1, sizeof(*gnutar));
if (gnutar == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate gnutar data");
return (ARCHIVE_FATAL);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x3e570
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x94cce1
movq -0x18(%rbp), %rdi
movl $0xc, %esi
leaq 0x279f0b(%rip), %rdx # 0xbc6bd9
movb $0x0, %al
callq 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_gnutar_header | static int
archive_write_gnutar_header(struct archive_write *a,
struct archive_entry *entry)
{
char buff[512];
int r, ret, ret2 = ARCHIVE_OK;
int tartype;
struct gnutar *gnutar;
struct archive_string_conv *sconv;
struct archive_entry *entry_main;
gnutar = (struct gnutar *)a->format_data;
/* Setup default... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x22c(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x94cef3
movq -0x238(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_gnutar_finish_entry | static int
archive_write_gnutar_finish_entry(struct archive_write *a)
{
struct gnutar *gnutar;
int ret;
gnutar = (struct gnutar *)a->format_data;
ret = __archive_write_nulls(a, (size_t)
(gnutar->entry_bytes_remaining + gnutar->entry_padding));
gnutar->entry_bytes_remaining = gnutar->entry_padding = 0;
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rsi
callq 0x9410c0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_gnutar.c |
archive_write_set_format_iso9660 | int
archive_write_set_format_iso9660(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct iso9660 *iso9660;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_iso9660");
/* If another format was already registered, unregister it. */
if (a-... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x27936f(%rip), %rcx # 0xbc73a8
callq 0x9770c0
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0x94e053
movl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
iso9660_options | static int
iso9660_options(struct archive_write *a, const char *key, const char *value)
{
struct iso9660 *iso9660 = a->format_data;
const char *p;
int r;
switch (key[0]) {
case 'a':
if (strcmp(key, "abstract-file") == 0) {
r = get_str_opt(a,
&(iso9660->abstract_file_identifier),
ABSTRACT_FILE_S... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
addl $-0x61, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0x19, %eax
ja 0x94f677
movq -0x48... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0xf0, %esi
callq 0x3e570
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x951493
movq $0x0, -0x8(%rbp)
jmp 0x951551
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_add_child_tail | static int
isoent_add_child_tail(struct isoent *parent, struct isoent *child)
{
if (!__archive_rb_tree_insert_node(
&(parent->rbtree), (struct archive_rb_node *)child))
return (0);
child->chnext = NULL;
*parent->children.last = child;
parent->children.last = &(child->chnext);
parent->children.cnt++;
child... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
callq 0x8f19d0
cmpl $0x0, %eax
jne 0x9521f2
movl $0x0, -0x4(%rbp)
jmp 0x952299
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_free | static void
_isoent_free(struct isoent *isoent)
{
struct extr_rec *er, *er_next;
free(isoent->children_sorted);
free(isoent->identifier);
er = isoent->extr_rec_list.first;
while (er != NULL) {
er_next = er->next;
free(er);
er = er_next;
}
free(isoent);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x3e548
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9523c1
movq -0x10(%rbp), %rax
movq 0x808(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_init_zstream | static int
zisofs_init_zstream(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
int r;
iso9660->zisofs.stream.next_in = NULL;
iso9660->zisofs.stream.avail_in = 0;
iso9660->zisofs.stream.total_in = 0;
iso9660->zisofs.stream.total_out = 0;
if (iso9660->zisofs.stream_valid)
r = deflateReset(&... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x248(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x250(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x258(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x270(%rax)
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_to_temp | static int
write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
ssize_t written;
const unsigned char *b;
b = (const unsigned char *)buff;
while (s) {
written = write(iso9660->temp_fd, b, s);
if (written < 0) {
archive_set_error(&a->archive, errno,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9529e8
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x38(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_iso9660_data | static ssize_t
write_iso9660_data(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
size_t ws;
if (iso9660->temp_fd < 0) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Couldn't create temporary file");
return (ARCHIVE_FATAL);
}
ws = s;
if (iso9660-... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x952a51
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x274b... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_detect_magic | static void
zisofs_detect_magic(struct archive_write *a, const void *buff, size_t s)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file = iso9660->cur_file;
const unsigned char *p, *endp;
const unsigned char *magic_buff;
uint32_t uncompressed_size;
unsigned char header_size;
unsigned char log2_bs;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8ea740
movq %rax, -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
wb_write_to_temp | static int
wb_write_to_temp(struct archive_write *a, const void *buff, size_t s)
{
const char *xp = buff;
size_t xs = s;
/*
* If a written data size is big enough to use system-call
* and there is no waiting data, this calls write_to_temp() in
* order to reduce a extra memory copy.
*/
if (wb_remaining(a) =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
cmpq $0x10000, 0x102e0(%rax) # imm = 0x10000
jne 0x95350e
cmpq $0x4000... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
wb_write_padding_to_temp | static int
wb_write_padding_to_temp(struct archive_write *a, int64_t csize)
{
size_t ns;
int ret;
ns = (size_t)(csize % LOGICAL_BLOCK_SIZE);
if (ns != 0)
ret = write_null(a, LOGICAL_BLOCK_SIZE - ns);
else
ret = ARCHIVE_OK;
return (ret);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x800, %ecx # imm = 0x800
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x953600
movq -0x8(%rbp), %rdi
movl $0x800, %esi # imm = 0x800
subq -0x18(%rbp), %rsi
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
archive_le32dec | static inline uint32_t
archive_le32dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p3 = p[3];
unsigned int p2... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
wb_set_offset | static int
wb_set_offset(struct archive_write *a, int64_t off)
{
struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
int64_t used, ext_bytes;
if (iso9660->wbuff_type != WB_TO_TEMP) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"Internal Programming error: iso9660:wb_set_offset()");
return (... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x102e8(%rax)
je 0x9536bf
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq 0x27413f(%rip), %rdx # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_find_out_boot_file | static int
isoent_find_out_boot_file(struct archive_write *a, struct isoent *rootent)
{
struct iso9660 *iso9660 = a->format_data;
/* Find a isoent of the boot file. */
iso9660->el_torito.boot = isoent_find_entry(rootent,
iso9660->el_torito.boot_filename.s);
if (iso9660->el_torito.boot == NULL) {
archive_set... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10328(%rax), %rsi
callq 0x956360
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10340(%rax)
movq -0x20(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_rewind_boot_file | static int
zisofs_rewind_boot_file(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
struct isofile *file;
unsigned char *rbuff;
ssize_t r;
size_t remaining, rbuff_size;
struct zisofs_extract zext;
int64_t read_offset, write_offset, new_offset;
int fd, ret = ARCHIVE_OK;
file = iso9660->el_t... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x120(%rbp)
movq -0x18(%rbp), %rax
movq 0x10340(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xc0(%rax), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_clone_tree | static int
isoent_clone_tree(struct archive_write *a, struct isoent **nroot,
struct isoent *root)
{
struct isoent *np, *xroot, *newent;
np = root;
xroot = NULL;
do {
newent = isoent_clone(np);
if (newent == NULL) {
archive_set_error(&a->archive, ENOMEM,
"Can't allocate memory");
return (ARCHIV... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x956b80
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x95430b
movq -0x10(%rbp), %rdi
movl $0xc, %esi
le... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_setup_file_location | static void
isoent_setup_file_location(struct iso9660 *iso9660, int location)
{
struct isoent *isoent;
struct isoent *np;
struct isofile *file;
size_t size;
int block;
int depth;
int joliet;
int symlocation;
int total_block;
iso9660->total_file_block = 0;
if ((isoent = iso9660->el_torito.catalog) != NULL) {... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x10320(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9548d1
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0xa4(%rax)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
setup_boot_information | static int
setup_boot_information(struct archive_write *a)
{
struct iso9660 *iso9660 = a->format_data;
struct isoent *np;
int64_t size;
uint32_t sum;
unsigned char buff[4096];
np = iso9660->el_torito.boot;
lseek(iso9660->temp_fd,
np->file->content.offset_of_temp + 64, SEEK_SET);
size = archive_entry_size(... | pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10340(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_VD | static int
write_VD(struct archive_write *a, struct vdd *vdd)
{
struct iso9660 *iso9660;
unsigned char *bp;
uint16_t volume_set_size = 1;
char identifier[256];
enum VD_type vdt;
enum vdc vdc;
unsigned char vd_ver, fst_ver;
int r;
iso9660 = a->format_data;
switch (vdd->vdd_type) {
case VDD_JOLIET:
vdt = VD... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw $0x1, -0x2a(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x144(%rbp)
testl %eax, %eax
je 0x954ebd
jmp 0x954e5b
mov... | /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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x952710
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x95bc90
movq -0x18(%rbp), %rax
movq 0x272514(%ri... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_information_block | static int
write_information_block(struct archive_write *a)
{
struct iso9660 *iso9660;
char buf[128];
const char *v;
int opt, r;
struct archive_string info;
size_t info_size = LOGICAL_BLOCK_SIZE *
NON_ISO_FILE_SYSTEM_INFORMATION_BLOCK;
iso9660 = (struct iso9660 *)a->format_data;
if (info_size > wb_re... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq $0x800, -0xd0(%rbp) # imm = 0x800
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0xd0(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x102e0(%rcx), %rax
jbe 0x95563c
movq -0x10(%rbp), %rdi
callq 0x952810
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_path_table | static int
write_path_table(struct archive_write *a, int type_m, struct vdd *vdd)
{
int depth, r;
size_t path_table_size;
r = ARCHIVE_OK;
path_table_size = 0;
for (depth = 0; depth < vdd->max_depth; depth++) {
r = _write_path_table(a, type_m, depth, vdd);
if (r < 0)
return (r);
path_table_size += r;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x955e70
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x24(... | /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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x95ccf0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
write_rr_ER | static int
write_rr_ER(struct archive_write *a)
{
unsigned char *p;
p = wb_buffptr(a);
memset(p, 0, LOGICAL_BLOCK_SIZE);
p[0] = 'E';
p[1] = 'R';
p[3] = 0x01;
p[2] = RRIP_ER_SIZE;
p[4] = RRIP_ER_ID_SIZE;
p[5] = RRIP_ER_DSC_SIZE;
p[6] = RRIP_ER_SRC_SIZE;
p[7] = 0x01;
memcpy(&p[8], rrip_identifier, p[4]);
m... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x952710
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx # imm = 0x800
callq 0x3b780
movq -0x10(%rbp), %rax
movb $0x45, (%rax)
movq -0x10(%rbp), %rax
movb $0x52, 0x1(%rax)
movq -0x10(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_find_entry | static struct isoent *
isoent_find_entry(struct isoent *rootent, const char *fn)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
char name[_MAX_FNAME];/* Included null terminator size. */
#elif defined(NAME_MAX) && NAME_MAX >= 255
char name[NAME_MAX+1];
#else
char name[256];
#endif
struct isoent *isoent, *np;
int l;... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq $0x0, -0x120(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x100, %esi # imm = 0x100
callq 0x9522b0
movl %eax, -0x124(%rbp)
cmpl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_extract | static ssize_t
zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
const unsigned char *p, size_t bytes)
{
size_t avail;
int r;
if (!zisofs->initialized) {
ssize_t rs = zisofs_extract_init(a, zisofs, p, bytes);
if (rs < 0)
return (rs);
if (!zisofs->initialized) {
/* We need more d... | 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 -0x18(%rbp), %rax
movb 0x18(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x956506
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
zisofs_extract_init | static ssize_t
zisofs_extract_init(struct archive_write *a, struct zisofs_extract *zisofs,
const unsigned char *p, size_t bytes)
{
size_t avail = bytes;
size_t _ceil, xsize;
/* Allocate block pointers buffer. */
_ceil = (size_t)((zisofs->pz_uncompressed_size +
(((int64_t)1) << zisofs->pz_log2_bs) - 1)
>> z... | 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 -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
addq %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_collect_dirs | static int
isoent_collect_dirs(struct vdd *vdd, struct isoent *rootent, int depth)
{
struct isoent *np;
if (rootent == NULL)
rootent = vdd->rootent;
np = rootent;
do {
/* Register current directory to pathtable. */
path_table_add_entry(&(vdd->pathtbl[depth]), np);
if (np->subdirs.first != NULL && depth + ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x956ce5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isofile_connect_hardlink_files | static void
isofile_connect_hardlink_files(struct iso9660 *iso9660)
{
struct archive_rb_node *n;
struct hardlink *hl;
struct isofile *target, *nf;
ARCHIVE_RB_TREE_FOREACH(n, &(iso9660->hardlink_rbtree)) {
hl = (struct hardlink *)n;
/* The first entry must be a hardlink target. */
target = hl->file_list.firs... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0xa8, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8f1ec0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x956fce
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
calculate_path_table_size | static void
calculate_path_table_size(struct vdd *vdd)
{
int depth, size;
struct path_table *pt;
pt = vdd->pathtbl;
size = 0;
for (depth = 0; depth < vdd->max_depth; depth++) {
struct isoent **ptbl;
int i, cnt;
if ((cnt = pt[depth].cnt) == 0)
break;
ptbl = pt[depth].sorted;
for (i = 0; i < cnt; i++... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x9574c6
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_remove_child | static void
isoent_remove_child(struct isoent *parent, struct isoent *child)
{
struct isoent *ent;
/* Remove a child entry from children chain. */
ent = parent->children.first;
while (ent->chnext != child)
ent = ent->chnext;
if ((ent->chnext = ent->chnext->chnext) == NULL)
parent->children.last = &(ent->chnex... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x957578
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x95755c
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
idr_init | static void
idr_init(struct iso9660 *iso9660, struct vdd *vdd, struct idr *idr)
{
idr->idrent_pool = NULL;
idr->pool_size = 0;
if (vdd->vdd_type != VDD_JOLIET) {
if (iso9660->opt.iso_level <= 3) {
memcpy(idr->char_map, d_characters_map,
sizeof(idr->char_map));
} else {
memcpy(idr->char_map, d1_char... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x957abc
movq -0x8(%rbp), %rax
movl 0x10370(%rax), %eax
shrl $0xe, %eax
and... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_gen_joliet_identifier | static int
isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
unsigned char *p;
size_t l;
int r;
size_t ffmax, parent_len;
static const struct archive_rb_tree_ops rb_ops = {
isoent_cmp_node_joliet, isoent_cmp_key_jolie... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x957afd
movl $0x0, -0x4(%rbp)
jmp 0x957f29
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10370(%rax), %ea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_iso9660.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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
leaq 0x2626ea(%rip), %rcx # 0xbc8533
callq 0x9770c0
movl %eax, -0x24(%rbp)
cmpl $-0x1e, -0x24(%rbp)
jne 0x965e63
movl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
archive_write_shar_close | static int
archive_write_shar_close(struct archive_write *a)
{
struct shar *shar;
int ret;
/*
* TODO: Accumulate list of directory names/modes and
* fix them all up at end-of-archive.
*/
shar = (struct shar *)a->format_data;
/*
* Only write the end-of-archive markers if the archive was
* actually star... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x9666de
movl $0x0, -0x4(%rbp)
jmp 0x966732
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
leaq 0x261fc8(%rip), %rsi # 0xbc86b5
callq 0x9387... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
archive_write_shar_finish_entry | static int
archive_write_shar_finish_entry(struct archive_write *a)
{
const char *g, *p, *u;
struct shar *shar;
int ret;
shar = (struct shar *)a->format_data;
if (shar->entry == NULL)
return (0);
if (shar->dump) {
/* Finish uuencoded data. */
if (shar->has_data) {
if (shar->outpos > 0)
uuencode_lin... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x966a32
movl $0x0, -0x4(%rbp)
jmp 0x966d28
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x966c7e
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
uuencode_line | static int
_uuencode_line(struct archive_write *a, struct shar *shar, const char *inbuf, size_t len)
{
char *buf;
size_t alloc_len;
/* len <= 45 -> expanded to 60 + len byte + new line */
alloc_len = shar->work.length + 62;
if (archive_string_ensure(&shar->work, alloc_len) == NULL) {
archive_set_error(&a->archi... | 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 -0x18(%rbp), %rax
movq 0x68(%rax), %rax
addq $0x3e, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x38(%rbp), %rsi
callq 0x938530
cmpq $0x0, %rax
jne 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_shar.c |
arc4_stir | static void
arc4_stir(void)
{
int done, fd, i;
struct {
struct timeval tv;
pid_t pid;
uint8_t rnd[KEYSIZE];
} rdat;
if (!rs_initialized) {
arc4_init();
rs_initialized = 1;
}
done = 0;
fd = open(RANDOMDEV, O_RDONLY | O_CLOEXEC, 0);
if (fd >= 0) {
if (read(fd, &rdat, KEYSIZE) == KEYSIZE)
done = ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
cmpl $0x0, 0x585cd2(%rip) # 0xf08f04
jne 0x983243
callq 0x9833b0
movl $0x1, 0x585cc1(%rip) # 0xf08f04
movl $0x0, -0x4(%rbp)
leaq 0x1dcedc(%rip), %rdi # 0xb6012d
movl $0x80000, %esi # imm = 0x80000
xorl %edx, %edx
movb $0x0, %al
callq 0x3d280
movl %eax, -0x8(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.c |
read_SubStreamsInfo | static int
read_SubStreamsInfo(struct archive_read *a, struct _7z_substream_info *ss,
struct _7z_folder *f, size_t numFolders)
{
const unsigned char *p;
uint64_t *usizes;
size_t unpack_streams;
int type;
unsigned i;
uint32_t numDigests;
memset(ss, 0, sizeof(*ss));
for (i = 0; i < numFolders; i++)
f[i].n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3b780
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpq -0x28(%rbp), %rax
jae 0x98979c
movq -0x20(%rbp), %rax
movl -0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x991562
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x991771
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x991581
movl $0xfffffffe, -0x4(%rbp) ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
BZ2_bzReadOpen | BZFILE* BZ_API(BZ2_bzReadOpen)
( int* bzerror,
FILE* f,
int verbosity,
int small,
void* unused,
int nUnused )
{
bzFile* bzf = NULL;
int ret;
BZ_SETERR(BZ_OK);
if (f == ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x993fe7
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x993ffc
movq ... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
copy_output_until_stop | static
Bool copy_output_until_stop ( EState* s )
{
Bool progress_out = False;
while (True) {
/*-- no output space? --*/
if (s->strm->avail_out == 0) break;
/*-- block done? --*/
if (s->state_out_pos >= s->numZ) break;
progress_out = True;
*(s->strm->next_out) = s->zbits[s->... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x994fde
jmp 0x995079
movq -0x8(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jl 0x994ff3
jmp 0x995079
movb $0x1, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
add_pair_to_block | static
void add_pair_to_block ( EState* s )
{
Int32 i;
UChar ch = (UChar)(s->state_in_ch);
for (i = 0; i < s->state_in_len; i++) {
BZ_UPDATE_CRC( s->blockCRC, ch );
}
s->inUse[s->state_in_ch] = True;
switch (s->state_in_len) {
case 1:
s->block[s->nblock] = (UChar)ch; s->nblock++;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movb %al, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x995488
movq -0x8(%rbp), %rax
movl 0x288(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
movl 0x288(%rax), %eax... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.c |
sendMTFValues | static
void sendMTFValues ( EState* s )
{
Int32 v, t, i, j, gs, ge, totc, bt, bc, iter;
Int32 nSelectors, alphaSize, minLen, maxLen, selCtr;
Int32 nGroups, nBytes;
/*--
UChar len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
is a global since the decoder also needs it.
Int32 code[BZ_N_GROUPS][BZ_MAX_ALPHA_... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x3, 0x290(%rax)
jl 0x995fc9
movq 0x563f21(%rip), %rax # 0xef9ec0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %edx
movq -0x8(%rbp), %rax
movl 0... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
makeMaps_e | static
void makeMaps_e ( EState* s )
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->unseqToSeq[i] = s->nInUse;
s->nInUse++;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jge 0x99a297
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x99a28a
movq -0x8(%rbp), %rax
movl 0x7c(%rax), %eax
movb %al, %dl
movq -... | /JKorbelRA[P]CMake/Utilities/cmbzip2/compress.c |
fallbackSort | static
void fallbackSort ( UInt32* fmap,
UInt32* eclass,
UInt32* bhtab,
Int32 nblock,
Int32 verb )
{
Int32 ftab[257];
Int32 ftabCopy[256];
Int32 H, i, j, k, l, r, cc, cc1;
Int32 nNotDone;
Int32 nBhtab;
UChar* eclass8... | pushq %rbp
movq %rsp, %rbp
subq $0x870, %rsp # imm = 0x870
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x860(%rbp)
cmpl $0x4, -0x20(%rbp)
jl 0x99ec57
movq 0x55b27a(%rip), %rax # 0xef9ec0
movq (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
fallbackQSort3 | static
void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass,
Int32 loSt,
Int32 hiSt )
{
Int32 unLo, unHi, ltLo, gtHi, n, m;
Int32 sp, lo, hi;
UInt32 med, r, r3;
Int32 stackLo[FALLBACK_QSORT_STACK_SIZE];
Int32 stackHi[FALLBACK_QSORT_STA... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x14(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl %ecx, -0x1e0(%rbp,%rax,4)
movl -0x18(%rbp), %ecx
movslq -0x3... | /JKorbelRA[P]CMake/Utilities/cmbzip2/blocksort.c |
BZ2_hbMakeCodeLengths | void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
{
/*--
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
--*/
Int32 nNodes, nHeap, n1, n... | pushq %rbp
movq %rsp, %rbp
subq $0x14b0, %rsp # imm = 0x14B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9a1ad7
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne... | /JKorbelRA[P]CMake/Utilities/cmbzip2/huffman.c |
lzma_crc32 | extern LZMA_API(uint32_t)
lzma_crc32(const uint8_t *buf, size_t size, uint32_t crc)
{
crc = ~crc;
#ifdef WORDS_BIGENDIAN
crc = bswap32(crc);
#endif
if (size > 8) {
// Fix the alignment, if needed. The if statement above
// ensures that this won't read past the end of buf[].
while ((uintptr_t)(buf) & 7) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpq $0x8, -0x10(%rbp)
jbe 0x9a24c3
jmp 0x9a2329
movq -0x8(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x9a237b
movq -0x8(%rbp), %rax
movq %ra... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/crc32_fast.c |
lzma_alone_decoder_init | extern lzma_ret
lzma_alone_decoder_init(lzma_next_coder *next, const lzma_allocator *allocator,
uint64_t memlimit, bool picky)
{
lzma_next_coder_init(&lzma_alone_decoder_init, next, allocator);
lzma_alone_coder *coder = next->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_alone_coder), allocator);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x29(%rip), %rax # 0x9a2540
cmpq 0x10(%rcx), %rax
je 0x9a257c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9a32d... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c |
alone_decoder_memconfig | static lzma_ret
alone_decoder_memconfig(void *coder_ptr, uint64_t *memusage,
uint64_t *old_memlimit, uint64_t new_memlimit)
{
lzma_alone_coder *coder = coder_ptr;
*memusage = coder->memusage;
*old_memlimit = coder->memlimit;
if (new_memlimit != 0) {
if (new_memlimit < coder->memusage)
return LZMA_MEMLIMIT_... | 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
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/alone_decoder.c |
lzma_alloc_zero | extern void * lzma_attribute((__malloc__)) lzma_attr_alloc_size(1)
lzma_alloc_zero(size_t size, const lzma_allocator *allocator)
{
// Some calloc() variants return NULL if called with size == 0.
if (size == 0)
size = 1;
void *ptr;
if (allocator != NULL && allocator->alloc != NULL) {
ptr = allocator->alloc(all... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9a30cf
movq $0x1, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9a3116
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9a3116
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdi
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/common.c |
decoder_find | static const lzma_filter_decoder *
decoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(decoders); ++i)
if (decoders[i].id == id)
return decoders + i;
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x9a3c6a
movq -0x18(%rbp), %rcx
leaq 0x55596e(%rip), %rax # 0xef95a0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x9a3c5a
movq -0x18(%rbp), %rcx
leaq 0x555953(%rip), %rax # 0xef95a0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_decoder.c |
encoder_find | static const lzma_filter_encoder *
encoder_find(lzma_vli id)
{
for (size_t i = 0; i < ARRAY_SIZE(encoders); ++i)
if (encoders[i].id == id)
return encoders + i;
return NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x9, -0x18(%rbp)
jae 0x9a3e94
leaq 0x555862(%rip), %rax # 0xef96c0
imulq $0x38, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x9a3e84
leaq 0x55584a(%rip), %rax # 0xef96c0
imulq $0x38, -0x18(%rbp), %rcx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
lzma_raw_encoder | extern LZMA_API(lzma_ret)
lzma_raw_encoder(lzma_stream *strm, const lzma_filter *options)
{
lzma_next_strm_init(lzma_raw_coder_init, strm, options,
(lzma_filter_find)(&encoder_find), true);
strm->internal->supported_actions[LZMA_RUN] = true;
strm->internal->supported_actions[LZMA_SYNC_FLUSH] = true;
strm->inter... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x9a4052
movq -0x10(%rbp), %rdi
callq 0x9a3400
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9a406c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a40db
jmp 0x9a406e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.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... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9a3e40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9a420d
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movl $0xb, %e... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/filter_encoder.c |
wait_for_work | static bool
wait_for_work(lzma_stream_coder *coder, mythread_condtime *wait_abs,
bool *has_blocked, bool has_input)
{
if (coder->timeout != 0 && !*has_blocked) {
// Every time when stream_encode_mt() is called via
// lzma_code(), *has_blocked starts as false. We set it
// to true here and calculate the absolut... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %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), %rax
cmpl $0x0, 0x130(%rax)
je 0x9a7126
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
jne 0x9a7126
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
get_thread | static lzma_ret
get_thread(lzma_stream_coder *coder, const lzma_allocator *allocator)
{
// If there are no free output subqueues, there is no
// point to try getting a thread.
if (!lzma_outq_has_buf(&coder->outq))
return LZMA_OK;
// If there is a free structure on the stack, use it.
mythread_sync(coder->mutex) ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x100, %rdi # imm = 0x100
callq 0x9a7500
testb $0x1, %al
jne 0x9a72b0
movl $0x0, -0x4(%rbp)
jmp 0x9a74a2
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9a72d4
movq -0x10(%rbp), %rdi
addq... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
initialize_new_thread | static lzma_ret
initialize_new_thread(lzma_stream_coder *coder,
const lzma_allocator *allocator)
{
worker_thread *thr = &coder->threads[coder->threads_initialized];
thr->in = lzma_alloc(coder->block_size, allocator);
if (thr->in == NULL)
return LZMA_MEM_ERROR;
if (mythread_mutex_init(&thr->mutex))
goto erro... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x144(%rcx), %ecx
imulq $0x1c0, %rcx, %rcx # imm = 0x1C0
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(... | /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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x9a777f
movq -0x10(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x9a6d60
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x9a... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
worker_error | static void
worker_error(worker_thread *thr, lzma_ret ret)
{
assert(ret != LZMA_OK);
assert(ret != LZMA_STREAM_END);
mythread_sync(thr->coder->mutex) {
if (thr->coder->thread_error == LZMA_OK)
thr->coder->thread_error = ret;
mythread_cond_signal(&thr->coder->cond);
}
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x9a8247
jmp 0x9a8266
leaq 0x22594d(%rip), %rdi # 0xbcdb9b
leaq 0x225550(%rip), %rsi # 0xbcd7a5
movl $0xb8, %edx
leaq 0x225949(%rip), %rcx # 0xbcdbaa
callq 0x3b440
cmpl $0x1, -0xc(%rbp)
je 0x9a826e
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_encoder_mt.c |
lzma_stream_flags_compare | extern LZMA_API(lzma_ret)
lzma_stream_flags_compare(
const lzma_stream_flags *a, const lzma_stream_flags *b)
{
// We can compare only version 0 structures.
if (a->version != 0 || b->version != 0)
return LZMA_OPTIONS_ERROR;
// Check type
if ((unsigned int)(a->check) > LZMA_CHECK_ID_MAX
|| (unsigned int)(b->c... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9a84a2
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9a84ae
movl $0x8, -0x4(%rbp)
jmp 0x9a8543
movq -0x10(%rbp), %rax
cmpl $0xf, 0x10(%rax)
ja 0x9a84c2
movq -0x18(%rbp), %rax
cmpl $0x... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_common.c |
lzma_stream_header_decode | extern LZMA_API(lzma_ret)
lzma_stream_header_decode(lzma_stream_flags *options, const uint8_t *in)
{
// Magic
if (memcmp(in, lzma_header_magic, sizeof(lzma_header_magic)) != 0)
return LZMA_FORMAT_ERROR;
// Verify the CRC32 so we can distinguish between corrupt
// and unsupported files.
const uint32_t crc = lzma... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2257af(%rip), %rsi # 0xbcdd6a
movl $0x6, %edx
callq 0x3c770
cmpl $0x0, %eax
je 0x9a85d3
movl $0x7, -0x4(%rbp)
jmp 0x9a8646
movq -0x18(%rbp), %rdi
addq $0x6, %rdi
movl $0x2, %esi
xorl %edx, %edx
cal... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_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 0x9a87c0
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 |
is_backward_size_valid | static inline bool
is_backward_size_valid(const lzma_stream_flags *options)
{
return options->backward_size >= LZMA_BACKWARD_SIZE_MIN
&& options->backward_size <= LZMA_BACKWARD_SIZE_MAX
&& (options->backward_size & 3) == 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x4, 0x8(%rcx)
movb %al, -0x9(%rbp)
jb 0x9a89e7
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movabsq $0x400000000, %rdx # imm = 0x400000000
cmpq %rdx, 0x8(%rcx)
movb %al, -0x9(%rbp)
ja 0x9a89e7
movq -0x8(%rbp), %rax
movq 0x8(%rax... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/common/stream_flags_common.h |
lzma_delta_coder_memusage | extern uint64_t
lzma_delta_coder_memusage(const void *options)
{
const lzma_options_delta *opt = options;
if (opt == NULL || opt->type != LZMA_DELTA_TYPE_BYTE
|| opt->dist < LZMA_DELTA_DIST_MIN
|| opt->dist > LZMA_DELTA_DIST_MAX)
return UINT64_MAX;
return sizeof(lzma_delta_coder);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jb 0x9a8b87
movq -0x18(%rbp), %rax
cmpl $0x100, 0x4(%rax) # imm = 0x100
jbe 0x9a8b91
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_common.c |
lzma_delta_props_decode | extern lzma_ret
lzma_delta_props_decode(void **options, const lzma_allocator *allocator,
const uint8_t *props, size_t props_size)
{
if (props_size != 1)
return LZMA_OPTIONS_ERROR;
lzma_options_delta *opt
= lzma_alloc(sizeof(lzma_options_delta), allocator);
if (opt == NULL)
return LZMA_MEM_ERROR;
opt->typ... | 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 $0x1, -0x28(%rbp)
je 0x9a8ce8
movl $0x8, -0x4(%rbp)
jmp 0x9a8d37
movq -0x18(%rbp), %rsi
movl $0x28, %edi
callq 0x9a3040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a8d0a
... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_decoder.c |
lzma_delta_props_encode | extern lzma_ret
lzma_delta_props_encode(const void *options, uint8_t *out)
{
// The caller must have already validated the options, so it's
// LZMA_PROG_ERROR if they are invalid.
if (lzma_delta_coder_memusage(options) == UINT64_MAX)
return LZMA_PROG_ERROR;
const lzma_options_delta *opt = options;
out[0] = opt-... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9a8b50
cmpq $-0x1, %rax
jne 0x9a9008
movl $0xb, -0x4(%rbp)
jmp 0x9a9029
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movb %al, %cl
movq -0... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/delta/delta_encoder.c |
lzma2_decoder_init | static lzma_ret
lzma2_decoder_init(lzma_lz_decoder *lz, const lzma_allocator *allocator,
const void *opt, lzma_lz_options *lz_options)
{
lzma_lzma2_coder *coder = lz->coder;
if (coder == NULL) {
coder = lzma_alloc(sizeof(lzma_lzma2_coder), allocator);
if (coder == NULL)
return LZMA_MEM_ERROR;
lz->coder = ... | 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 -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9a9b06
movq -0x18(%rbp), %rsi
movl $0xb8, %edi
callq 0x9a3040
movq %rax, -0x30(%rbp)
cmpq $... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma2_decoder.c |
lzma_lzma_decoder_create | extern lzma_ret
lzma_lzma_decoder_create(lzma_lz_decoder *lz, const lzma_allocator *allocator,
const void *opt, lzma_lz_options *lz_options)
{
if (lz->coder == NULL) {
lz->coder = lzma_alloc(sizeof(lzma_lzma1_decoder), allocator);
if (lz->coder == NULL)
return LZMA_MEM_ERROR;
lz->code = &lzma_decode;
lz-... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9ab03a
movq -0x18(%rbp), %rsi
movl $0x6ec0, %edi # imm = 0x6EC0
callq 0x9a3040
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_decoder.c |
lzma_decoder_reset | static void
lzma_decoder_reset(void *coder_ptr, const void *opt)
{
lzma_lzma1_decoder *coder = coder_ptr;
const lzma_options_lzma *options = opt;
// NOTE: We assume that lc/lp/pb are valid since they were
// successfully decoded with lzma_lzma_decode_properties().
// Calculate pos_mask. We don't need pos_bits as... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_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 |
encode_init | static bool
encode_init(lzma_lzma1_encoder *coder, lzma_mf *mf)
{
assert(mf_position(mf) == 0);
if (mf->read_pos == mf->read_limit) {
if (mf->action == LZMA_RUN)
return false; // We cannot do anything.
// We are finishing (we cannot get here when flushing).
assert(mf->write_pos == mf->read_pos);
assert(m... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b3420
cmpl $0x0, %eax
jne 0x9b3310
jmp 0x9b332f
leaq 0x21b7fd(%rip), %rdi # 0xbceb14
leaq 0x21b69a(%rip), %rsi # 0xbce9b8
movl $0x10e, %edx # imm = 0x10E
leaq 0x21b7ff(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.c |
literal_init | static inline void
literal_init(probability (*probs)[LITERAL_CODER_SIZE],
uint32_t lc, uint32_t lp)
{
assert(lc + lp <= LZMA_LCLP_MAX);
const uint32_t coders = 1U << (lc + lp);
for (uint32_t i = 0; i < coders; ++i)
for (uint32_t j = 0; j < LITERAL_CODER_SIZE; ++j)
bit_reset(probs[i][j]);
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x4, %eax
ja 0x9b3d7f
jmp 0x9b3d9e
leaq 0x21ab3c(%rip), %rdi # 0xbce8c2
leaq 0x21ab4e(%rip), %rsi # 0xbce8db
movl $0x85, %edx
leaq 0x21abba(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_common.h |
rc_shift_low | static inline bool
rc_shift_low(lzma_range_encoder *rc,
uint8_t *out, size_t *out_pos, size_t out_size)
{
if ((uint32_t)(rc->low) < (uint32_t)(0xFF000000)
|| (uint32_t)(rc->low >> 32) != 0) {
do {
if (*out_pos == out_size)
return true;
out[*out_pos] = rc->cache + (uint8_t)(rc->low >> 32);
++*out_p... | 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
movq (%rax), %rax
cmpl $0xff000000, %eax # imm = 0xFF000000
jb 0x9b44f6
movq -0x10(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
cmpl $0x0, %eax
je 0x9b457c
jmp 0x9b44f8
m... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/rangecoder/range_encoder.h |
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 0x9b4eb0
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/lzma/lzma_encoder.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 |
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 |
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 |
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 |
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 # 0x9ba8a0
movl $0x8, %r8d
movl $0x5, ... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/simple/x86.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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb $-0x80, (%rax,%rcx)
cmpq $0x38, -0x10(%rbp)
je 0x9bb12b
cmpq $0x4... | /JKorbelRA[P]CMake/Utilities/cmliblzma/liblzma/check/sha256.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.