name string | code string | asm string | file string |
|---|---|---|---|
load32 | static BLAKE2_INLINE uint32_t load32( const void *src )
{
#if defined(NATIVE_LITTLE_ENDIAN)
uint32_t w;
memcpy(&w, src, sizeof w);
return w;
#else
const uint8_t *p = ( const uint8_t * )src;
return (( uint32_t )( p[0] ) << 0) |
(( uint32_t )( p[1] ) << 8) |
(( uint32_t )( p[2] ) << 16) |
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2_impl.h |
store32 | static BLAKE2_INLINE void store32( void *dst, uint32_t w )
{
#if defined(NATIVE_LITTLE_ENDIAN)
memcpy(dst, &w, sizeof w);
#else
uint8_t *p = ( uint8_t * )dst;
p[0] = (uint8_t)(w >> 0);
p[1] = (uint8_t)(w >> 8);
p[2] = (uint8_t)(w >> 16);
p[3] = (uint8_t)(w >> 24);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shrl $0x0, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2_impl.h |
store16 | static BLAKE2_INLINE void store16( void *dst, uint16_t w )
{
#if defined(NATIVE_LITTLE_ENDIAN)
memcpy(dst, &w, sizeof w);
#else
uint8_t *p = ( uint8_t * )dst;
*p++ = ( uint8_t )w; w >>= 8;
*p++ = ( uint8_t )w;
#endif
} | pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw -0xa(%rbp), %ax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movw %ax, -0xa(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2_impl.h |
blake2s_update | int blake2s_update( blake2s_state *S, const void *pin, size_t inlen )
{
const unsigned char * in = (const unsigned char *)pin;
if( inlen > 0 )
{
size_t left = S->buflen;
size_t fill = BLAKE2S_BLOCKBYTES - left;
if( inlen > fill )
{
S->buflen = 0;
memcpy( S->buf + left, in, fill ); /* F... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0xe1b28
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2s_ref.c |
blake2s | int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )
{
blake2s_state S[1];
/* Verify parameters */
if ( NULL == in && inlen > 0 ) return -1;
if ( NULL == out ) return -1;
if ( NULL == key && keylen > 0) return -1;
if( !outlen || outlen > BLAKE2S_OUTBYTES ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0xe4f1e
cmpq $0x0, -0x28(%rbp)
jbe 0xe4f1e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_blake2s_ref.c |
archive_acl_copy | void
archive_acl_copy(struct archive_acl *dest, struct archive_acl *src)
{
struct archive_acl_entry *ap, *ap2;
archive_acl_clear(dest);
dest->mode = src->mode;
ap = src->acl_head;
while (ap != NULL) {
ap2 = acl_new_entry(dest,
ap->type, ap->permset, ap->tag, ap->id);
if (ap2 != NULL)
archive_mstring... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe5060
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe519b
movq -0x8(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
acl_new_entry | static struct archive_acl_entry *
acl_new_entry(struct archive_acl *acl,
int type, int permset, int tag, int id)
{
struct archive_acl_entry *ap, *aq;
/* Type argument must be a valid NFS4 or POSIX.1e type.
* The type must agree with anything already set and
* the permset must be compatible. */
if (type & AR... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0x3c00, %eax # imm = 0x3C00
cmpl $0x0, %eax
je 0xe5210
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
andl $0xffffc3ff, %eax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_add_entry | int
archive_acl_add_entry(struct archive_acl *acl,
int type, int permset, int tag, int id, const char *name)
{
struct archive_acl_entry *ap;
if (acl_special(acl, type, permset, tag) == 0)
return ARCHIVE_OK;
ap = acl_new_entry(acl, type, permset, tag, id);
if (ap == NULL) {
/* XXX Error XXX */
return ARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0xe54e0
cmpl $0x0, %eax
jne 0xe546d
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_add_entry_w_len | int
archive_acl_add_entry_w_len(struct archive_acl *acl,
int type, int permset, int tag, int id, const wchar_t *name, size_t len)
{
struct archive_acl_entry *ap;
if (acl_special(acl, type, permset, tag) == 0)
return ARCHIVE_OK;
ap = acl_new_entry(acl, type, permset, tag, id);
if (ap == NULL) {
/* XXX Error... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0xe54e0
cmpl $0x0, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_count | int
archive_acl_count(struct archive_acl *acl, int want_type)
{
int count;
struct archive_acl_entry *ap;
count = 0;
ap = acl->acl_head;
while (ap != NULL) {
if ((ap->type & want_type) != 0)
count++;
ap = ap->next;
}
if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0))
count += 3;
retu... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe56ca
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0xe56bd
movl -0x10(%rbp), %eax
addl $0x1,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_reset | int
archive_acl_reset(struct archive_acl *acl, int want_type)
{
int count, cutoff;
count = archive_acl_count(acl, want_type);
/*
* If the only entries are the three standard ones,
* then don't return any ACL data. (In this case,
* client can just use chmod(2) to set permissions.)
*/
if ((want_type & ARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xe5680
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
je 0xe5744
movl $0x3, -0x14(%rbp)
jmp 0xe574b
movl $0x0, -0x14(%rbp)
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_text_len | static ssize_t
archive_acl_text_len(struct archive_acl *acl, int want_type, int flags,
int wide, struct archive *a, struct archive_string_conv *sc) {
struct archive_acl_entry *ap;
const char *name;
const wchar_t *wname;
int count, idlen, tmp, r;
ssize_t length;
size_t len;
count = 0;
length = 0;
for (ap =... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x4c(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_from_text_w | int
archive_acl_from_text_w(struct archive_acl *acl, const wchar_t *text,
int want_type)
{
struct {
const wchar_t *start;
const wchar_t *end;
} field[6], name;
const wchar_t *s, *st;
int numfields, fields, n, r, sol, ret;
int type, types, tag, permset, id;
size_t len;
wchar_t sep;
ret = ARCHIVE_OK;
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0xb8(%rbp)
movl $0x0, -0xc0(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xf4(%rbp)
subl $0x100, %eax # imm = 0x100
je 0xe70f0
jmp 0xe70bc
movl -0xf4(%rbp), %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
isint_w | static int
isint_w(const wchar_t *start, const wchar_t *end, int *result)
{
int n = 0;
if (start >= end)
return (0);
while (start < end) {
if (*start < L'0' || *start > L'9')
return (0);
if (n > (INT_MAX / 10) ||
(n == INT_MAX / 10 && (*start - L'0') > INT_MAX % 10)) {
n = INT_MAX;
} else {
n ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xe7e5d
movl $0x0, -0x4(%rbp)
jmp 0xe7ee1
jmp 0xe7e5f
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe7ed1
movq -0x10(%rbp), %rax
cmpl $0x30, (%rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
is_nfs4_perms_w | static int
is_nfs4_perms_w(const wchar_t *start, const wchar_t *end, int *permset)
{
const wchar_t *p = start;
while (p < end) {
switch (*p++) {
case L'r':
*permset |= ARCHIVE_ENTRY_ACL_READ_DATA;
break;
case L'w':
*permset |= ARCHIVE_ENTRY_ACL_WRITE_DATA;
break;
case L'x':
*permset |= ARCHIVE... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe8120
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %eax
addl $-0x2d, %eax
movl %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_from_text_l | int
archive_acl_from_text_l(struct archive_acl *acl, const char *text,
int want_type, struct archive_string_conv *sc)
{
struct {
const char *start;
const char *end;
} field[6], name;
const char *s, *st;
int numfields, fields, n, r, sol, ret;
int type, types, tag, permset, id;
size_t len;
char sep;
swi... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x104(%rbp)
subl $0x100, %eax # imm = 0x100
je 0xe8280
jmp 0xe824c
movl -0x104(%rbp), %eax
subl $0x200, %eax ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
ismode | static int
ismode(const char *start, const char *end, int *permset)
{
const char *p;
if (start >= end)
return (0);
p = start;
*permset = 0;
while (p < end) {
switch (*p++) {
case 'r': case 'R':
*permset |= ARCHIVE_ENTRY_ACL_READ;
break;
case 'w': case 'W':
*permset |= ARCHIVE_ENTRY_ACL_WRITE;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xe9196
movl $0x0, -0x4(%rbp)
jmp 0xe924b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
is_nfs4_flags | static int
is_nfs4_flags(const char *start, const char *end, int *permset)
{
const char *p = start;
while (p < end) {
switch(*p++) {
case 'f':
*permset |= ARCHIVE_ENTRY_ACL_ENTRY_FILE_INHERIT;
break;
case 'd':
*permset |= ARCHIVE_ENTRY_ACL_ENTRY_DIRECTORY_INHERIT;
break;
case 'i':
*permset |= ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe948d
movq -0x28(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
addl $-0x2d, %eax
movl %eax,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
archive_acl_add_entry_len_l | static int
archive_acl_add_entry_len_l(struct archive_acl *acl,
int type, int permset, int tag, int id, const char *name, size_t len,
struct archive_string_conv *sc)
{
struct archive_acl_entry *ap;
int r;
if (acl_special(acl, type, permset, tag) == 0)
return ARCHIVE_OK;
ap = acl_new_entry(acl, type, perm... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_acl.c |
_archive_check_magic | int
__archive_check_magic(struct archive *a, unsigned int magic,
unsigned int state, const char *function)
{
char states1[64];
char states2[64];
const char *handle_type;
/*
* If this isn't some form of archive handle,
* then the library user has screwed up so bad that
* we don't even have a reliable way ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xe97c0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0xe96cb
leaq 0x1d81d8(%rip), %rdi # 0x2c1884
callq 0xe9860
movq -0x20(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_check_magic.c |
errmsg | static void
errmsg(const char *m)
{
size_t s = strlen(m);
ssize_t written;
while (s > 0) {
written = write(2, m, s);
if (written <= 0)
return;
m += written;
s -= written;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x109c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xe98bc
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x2, %edi
callq 0x11990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jg 0xe989f
jmp 0xe98bc
movq -0x18(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_check_magic.c |
write_all_states | static char *
write_all_states(char *buff, unsigned int states)
{
unsigned int lowbit;
buff[0] = '\0';
/* A trick for computing the lowest set bit. */
while ((lowbit = states & (1 + ~states)) != 0) {
states &= ~lowbit; /* Clear the low bit. */
strcat(buff, state_name(lowbit));
if (states != 0)
strcat(bu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl -0xc(%rbp), %eax
movl -0xc(%rbp), %ecx
xorl $-0x1, %ecx
addl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0xe994c
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
andl -0xc... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_check_magic.c |
state_name | static const char *
state_name(unsigned s)
{
switch (s) {
case ARCHIVE_STATE_NEW: return ("new");
case ARCHIVE_STATE_HEADER: return ("header");
case ARCHIVE_STATE_DATA: return ("data");
case ARCHIVE_STATE_EOF: return ("eof");
case ARCHIVE_STATE_CLOSED: return ("closed");
case ARCHIVE_STATE_FATAL: return ("fata... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0xe99a8
jmp 0xe9974
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0xe99b5
jmp 0xe997e
movl -0x10(%rbp), %eax
subl $0x4, %eax
je 0xe99c2
jmp 0xe9988
movl -0x10(%rbp), %eax
subl $0x10, %eax
je 0xe99cf
jmp 0xe9992
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_check_magic.c |
_archive_cmdline_parse | int
__archive_cmdline_parse(struct archive_cmdline *data, const char *cmd)
{
struct archive_string as;
const char *p;
ssize_t al;
int r;
archive_string_init(&as);
/* Get first argument as a command path. */
al = get_argument(&as, cmd);
if (al < 0) {
r = ARCHIVE_FAILED;/* Invalid sequence. */
goto exit_fun... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xe9b60
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0xe9a5c
movl $0xffffffe7, -0x3c(%rbp) # imm = 0xFFFF... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cmdline.c |
cmdline_set_path | static int
cmdline_set_path(struct archive_cmdline *data, const char *path)
{
char *newptr;
newptr = realloc(data->path, strlen(path) + 1);
if (newptr == NULL)
return (ARCHIVE_FATAL);
data->path = newptr;
strcpy(data->path, path);
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x109c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x10260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe9cf8
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cmdline.c |
_archive_cmdline_free | int
__archive_cmdline_free(struct archive_cmdline *data)
{
if (data) {
free(data->path);
if (data->argv != NULL) {
int i;
for (i = 0; data->argv[i] != NULL; i++)
free(data->argv[i]);
free(data->argv);
}
free(data);
}
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe9eaa
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe9ea1
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cmdline.c |
aes_ctr_update | static int
aes_ctr_update(archive_crypto_ctx *ctx, const uint8_t * const in,
size_t in_len, uint8_t * const out, size_t *out_len)
{
uint8_t *const ebuf = ctx->encr_buf;
unsigned pos = ctx->encr_pos;
unsigned max = (unsigned)((in_len < *out_len)? in_len: *out_len);
unsigned i;
for (i = 0; i < max; ) {
if (po... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x44, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cryptor.c |
aes_ctr_encrypt_counter | static int
aes_ctr_encrypt_counter(archive_crypto_ctx *ctx)
{
int outl = 0;
int r;
r = EVP_EncryptInit_ex(ctx->ctx, ctx->type, NULL, ctx->key, NULL);
if (r == 0)
return -1;
r = EVP_EncryptUpdate(ctx->ctx, ctx->encr_buf, &outl, ctx->nonce,
AES_BLOCK_SIZE);
if (r == 0 || outl != AES_BLOCK_SIZE)
return -1;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
callq 0x10510
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_cryptor.c |
_archive_md5final | static int
__archive_md5final(archive_md5_ctx *ctx, void *md)
{
/* HACK: archive_write_set_format_xar.c is finalizing empty contexts, so
* this is meant to cope with that. Real fix is probably to fix
* archive_write_set_format_xar.c
*/
if (*ctx) {
EVP_DigestFinal(*ctx, md, NULL);
EVP_MD_CTX_free(*c... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xea475
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x102b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10d70
movq -0x8(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_digest.c |
next_entry | static struct links_entry *
next_entry(struct archive_entry_linkresolver *res, int mode)
{
struct links_entry *le;
size_t bucket;
/* Free a held entry. */
if (res->spare != NULL) {
archive_entry_free(res->spare->canonical);
archive_entry_free(res->spare->entry);
free(res->spare);
res->spare = NULL;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xeac15
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x5bf40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x5bf40
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_link_resolver.c |
find_entry | static struct links_entry *
find_entry(struct archive_entry_linkresolver *res,
struct archive_entry *entry)
{
struct links_entry *le;
size_t hash, bucket;
dev_t dev;
int64_t ino;
/* Free a held entry. */
if (res->spare != NULL) {
archive_entry_free(res->spare->canonical);
archive_entry_free(res-... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xeb006
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x5bf40
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x5bf40
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_link_resolver.c |
grow_hash | static void
grow_hash(struct archive_entry_linkresolver *res)
{
struct links_entry *le, **new_buckets;
size_t new_size;
size_t i, bucket;
/* Try to enlarge the bucket list. */
new_size = res->number_buckets * 2;
if (new_size < res->number_buckets)
return;
new_buckets = calloc(new_size, sizeof(struct links_ent... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xeb3de
jmp 0xeb4fb
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x11580
movq %rax, -0x18(%rbp)
cmpq $0x0,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_link_resolver.c |
_archive_get_date | time_t
__archive_get_date(time_t now, const char *p)
{
struct token tokens[256];
struct gdstate _gds;
struct token *lasttoken;
struct gdstate *gds;
struct tm local, *tm;
struct tm gmt, *gmt_ptr;
time_t Start;
time_t tod;
long tzone;
#if defined(HAVE__LOCALTIME64_S) || defined(HAVE__GMTIME64_S)
errno_t ter... | pushq %rbp
movq %rsp, %rbp
subq $0x1170, %rsp # imm = 0x1170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x10810
leaq -0x10a8(%rbp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x10810
leaq -0x10a8(%rbp), %rax
movq %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
difftm | static long
difftm (struct tm *a, struct tm *b)
{
int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
int days = (
/* difference in day of year */
a->tm_yday - b->tm_yday
/* + intervening leap days */
+ ((ay >> 2) - (by >> 2))
- (ay/100 - by/100)
+ ((ay/100 >> 2) - ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76b, %eax # imm = 0x76B
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76b, %eax # imm = 0x76B
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
nexttoken | static int
nexttoken(const char **in, time_t *value)
{
char c;
char buff[64];
for ( ; ; ) {
while (isspace((unsigned char)**in))
++*in;
/* Skip parenthesized comments. */
if (**in == '(') {
int Count = 0;
do {
c = *(*in)++;
if (c == '\0')
return c;
if (c == '(')
Count++;
el... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xebb45
callq 0x10350
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0xebb78
movq -0x1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
phrase | static int
phrase(struct gdstate *gds)
{
if (timephrase(gds))
return 1;
if (zonephrase(gds))
return 1;
if (datephrase(gds))
return 1;
if (dayphrase(gds))
return 1;
if (relunitphrase(gds)) {
if (gds->tokenp[0].token == tAGO) {
gds->RelSeconds = -gds->RelSeconds;
gds->RelMonth = -gds->RelMonth;
gd... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xec5b0
cmpl $0x0, %eax
je 0xebe96
movl $0x1, -0x4(%rbp)
jmp 0xec169
movq -0x10(%rbp), %rdi
callq 0xec8d0
cmpl $0x0, %eax
je 0xebeb0
movl $0x1, -0x4(%rbp)
jmp 0xec169
movq -0x10(%rbp), %rdi
callq 0xec9f0
cmpl $0x0, %eax
je 0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
Convert | static time_t
Convert(time_t Month, time_t Day, time_t Year,
time_t Hours, time_t Minutes, time_t Seconds,
time_t Timezone, enum DSTMODE DSTmode)
{
signed char DaysInMonth[12] = {
31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
time_t Julian;
int i;
struct tm *ltime;
#if defined(HAVE_LOCALTIME_R) || defined... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq 0x1d5843(%rip), %rax # 0x2c19f4
movq %rax, -0x44(%rbp)
movl 0x1d5841(%rip), %eax # 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
timephrase | static int
timephrase(struct gdstate *gds)
{
if (gds->tokenp[0].token == tUNUMBER
&& gds->tokenp[1].token == ':'
&& gds->tokenp[2].token == tUNUMBER
&& gds->tokenp[3].token == ':'
&& gds->tokenp[4].token == tUNUMBER) {
/* "12:14:18" or "22:08:07" */
++gds->HaveTime;
gds->Hour = gds->tokenp[0]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10b, (%rax) # imm = 0x10B
jne 0xec662
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3a, 0x10(%rax)
jne 0xec662
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10b, 0x20(%rax) # imm = 0x10B
jne 0xec662
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
zonephrase | static int
zonephrase(struct gdstate *gds)
{
if (gds->tokenp[0].token == tZONE
&& gds->tokenp[1].token == tDST) {
gds->HaveZone++;
gds->Timezone = gds->tokenp[0].value;
gds->DSTmode = DSTon;
gds->tokenp += 1;
return 1;
}
if (gds->tokenp[0].token == tZONE) {
gds->HaveZone++;
gds->Timezone = gds->t... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10c, (%rax) # imm = 0x10C
jne 0xec93c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x10d, 0x10(%rax) # imm = 0x10D
jne 0xec93c
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
dayphrase | static int
dayphrase(struct gdstate *gds)
{
if (gds->tokenp[0].token == tDAY) {
/* "tues", "wednesday," */
gds->HaveWeekDay++;
gds->DayOrdinal = 1;
gds->DayNumber = gds->tokenp[0].value;
gds->tokenp += 1;
if (gds->tokenp[0].token == ',')
gds->tokenp += 1;
return 1;
}
if (gds->tokenp[0].token == tUNU... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x105, (%rax) # imm = 0x105
jne 0xed0d4
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x68(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
DSTcorrect | static time_t
DSTcorrect(time_t Start, time_t Future)
{
time_t StartDay;
time_t FutureDay;
struct tm *ltime;
#if defined(HAVE_LOCALTIME_R) || defined(HAVE__LOCALTIME64_S)
struct tm tmbuf;
#endif
#if defined(HAVE__LOCALTIME64_S)
errno_t terr;
__time64_t tmptime;
#endif
#if defined(HAVE_LOCALTIME_R)
ltime = lo... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x103c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl $0x18, %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_getdate.c |
archive_set_either_option | int
_archive_set_either_option(struct archive *a, const char *m, const char *o, const char *v,
option_handler use_format_option, option_handler use_filter_option)
{
int r1, r2;
if (o == NULL && v == NULL)
return (ARCHIVE_OK);
if (o == NULL)
return (ARCHIVE_FAILED);
r1 = use_format_option(a, m, o, v);
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xed96a
cmpq $0x0, -0x28(%rbp)
jne 0xed96a
movl $0x0, -0x4(%rbp)
jmp 0xed9f4
cmpq $0x0, -0x20(%rbp)
jne 0xed97a
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_options.c |
pack_8_8 | static dev_t
pack_8_8(int n, unsigned long numbers[], const char **error)
{
dev_t dev = 0;
if (n == 2) {
dev = makedev_8_8(numbers[0], numbers[1]);
if ((unsigned long)major_8_8(dev) != numbers[0])
*error = iMajorError;
if ((unsigned long)minor_8_8(dev) != numbers[1])
*error = iMinorError;
} else
*erro... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0xedff9
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x8, %rax
andq $0xff00, %rax # imm = 0xFF00
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
andq $0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pack_dev.c |
pack_freebsd | static dev_t
pack_freebsd(int n, unsigned long numbers[], const char **error)
{
dev_t dev = 0;
if (n == 2) {
dev = makedev_freebsd(numbers[0], numbers[1]);
if ((unsigned long)major_freebsd(dev) != numbers[0])
*error = iMajorError;
if ((unsigned long)minor_freebsd(dev) != numbers[1])
*error = iMinorError;... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0xee247
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x8, %rax
andq $0xff00, %rax # imm = 0xFF00
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x0, %rcx
movabsq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pack_dev.c |
pack_netbsd | static dev_t
pack_netbsd(int n, unsigned long numbers[], const char **error)
{
dev_t dev = 0;
if (n == 2) {
dev = makedev_netbsd(numbers[0], numbers[1]);
if ((unsigned long)major_netbsd(dev) != numbers[0])
*error = iMajorError;
else if ((unsigned long)minor_netbsd(dev) != numbers[1])
*error = iMinorError... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0xee3f3
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x8, %rax
andq $0xfff00, %rax # imm = 0xFFF00
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0xc, %rcx
movabs... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pack_dev.c |
pack_14_18 | static dev_t
pack_14_18(int n, unsigned long numbers[], const char **error)
{
dev_t dev = 0;
if (n == 2) {
dev = makedev_14_18(numbers[0], numbers[1]);
if ((unsigned long)major_14_18(dev) != numbers[0])
*error = iMajorError;
if ((unsigned long)minor_14_18(dev) != numbers[1])
*error = iMinorError;
} else... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0xee578
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x12, %rax
movabsq $0xfffc0000, %rcx # imm = 0xFFFC0000
andq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pack_dev.c |
Ppmd8_Construct | void Ppmd8_Construct(CPpmd8 *p)
{
unsigned i, k, m;
p->Base = 0;
for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++)
{
unsigned step = (i >= 12 ? 4 : (i >> 2) + 1);
do { p->Units2Indx[k++] = (Byte)i; } while (--step);
p->Indx2Units[i] = (Byte)k;
}
p->NS2BSIndx[0] = (0 << 1);
p->NS2BSIndx[1] = (1 ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x26, -0xc(%rbp)
jae 0xee627
cmpl $0xc, -0xc(%rbp)
jb 0xee5cc
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0xee5d8
movl -0xc(%rbp), %eax
shrl $0x2, %eax
addl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_Alloc | Bool Ppmd8_Alloc(CPpmd8 *p, UInt32 size)
{
if (p->Base == 0 || p->Size != size)
{
Ppmd8_Free(p);
p->AlignOffset =
#ifdef PPMD_32BIT
(4 - size) & 3;
#else
4 - (size & 3);
#endif
if ((p->Base = (Byte *)malloc(p->AlignOffset + size)) == 0)
return False;
p->Size =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xee766
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xee7b7
movq -0x10(%rbp), %rdi
callq 0xee700
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl $0x4, %ecx
sub... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_Init | void Ppmd8_Init(CPpmd8 *p, unsigned maxOrder, unsigned restoreMethod)
{
p->MaxOrder = maxOrder;
p->RestoreMethod = restoreMethod;
RestartModel(p);
p->DummySee.Shift = PPMD_PERIOD_BITS;
p->DummySee.Summ = 0; /* unused */
p->DummySee.Count = 64; /* unused */
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x8(%rbp), %rdi
callq 0xee830
movq -0x8(%rbp), %rax
movb $0x7, 0x45e(%... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_MakeEscFreq | CPpmd_See *Ppmd8_MakeEscFreq(CPpmd8 *p, unsigned numMasked1, UInt32 *escFreq)
{
CPpmd_See *see;
if (p->MinContext->NumStats != 0xFF)
{
see = p->See[(unsigned)p->NS2Indx[(unsigned)p->MinContext->NumStats + 2] - 3] +
(p->MinContext->SummFreq > 11 * ((unsigned)p->MinContext->NumStats + 1)) +
2 * ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0xeecca
movq -0x8(%rbp), %rax
addq $0x460, %rax # imm = 0x460
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
movzbl (%rd... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_Update1 | void Ppmd8_Update1(CPpmd8 *p)
{
CPpmd_State *s = p->FoundState;
s->Freq += 4;
p->MinContext->SummFreq += 4;
if (s[0].Freq > s[-1].Freq)
{
SwapStates(&s[0], &s[-1]);
p->FoundState = --s;
if (s->Freq > MAX_FREQ)
Rescale(p);
}
NextContext(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
addl $0x4, %ecx
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x2(%rax), %ecx
addl $0x4, %ecx
movw %cx, 0x2(%rax)
movq -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Rescale | static void Rescale(CPpmd8 *p)
{
unsigned i, adder, sumFreq, escFreq;
CPpmd_State *stats = STATS(p->MinContext);
CPpmd_State *s = p->FoundState;
{
CPpmd_State tmp = *s;
for (; s != stats; s--)
s[0] = s[-1];
*s = tmp;
}
escFreq = p->MinContext->SummFreq - s->Freq;
s->Freq += 4;
adder = ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_Update1_0 | void Ppmd8_Update1_0(CPpmd8 *p)
{
p->PrevSuccess = (2 * p->FoundState->Freq >= p->MinContext->SummFreq);
p->RunLength += p->PrevSuccess;
p->MinContext->SummFreq += 4;
if ((p->FoundState->Freq += 4) > MAX_FREQ)
Rescale(p);
NextContext(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0x1(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd8_RangeDec_Init | Bool Ppmd8_RangeDec_Init(CPpmd8 *p)
{
unsigned i;
p->Low = 0;
p->Range = 0xFFFFFFFF;
p->Code = 0;
for (i = 0; i < 4; i++)
p->Code = (p->Code << 8) | p->Stream.In->Read(p->Stream.In);
return (p->Code < 0xFFFFFFFF);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0xefba7
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
RangeDec_Decode | static void RangeDec_Decode(CPpmd8 *p, UInt32 start, UInt32 size)
{
start *= p->Range;
p->Low += start;
p->Code -= start;
p->Range *= size;
while ((p->Low ^ (p->Low + p->Range)) < kTop ||
(p->Range < kBot && ((p->Range = (0 - p->Low) & (kBot - 1)), 1)))
{
p->Code = (p->Code << 8) | p->Stream.In->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x70(%rax), %ecx
movl %ecx, 0x70(%rax)
movl -0xc(%rbp), %edx
movq -0x8(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
ShrinkUnits | static void *ShrinkUnits(CPpmd8 *p, void *oldPtr, unsigned oldNU, unsigned newNU)
{
unsigned i0 = U2I(oldNU);
unsigned i1 = U2I(newNU);
if (i0 == i1)
return oldPtr;
if (p->FreeList[i1] != 0)
{
void *ptr = RemoveNode(p, i1);
MyMem12Cpy(ptr, oldPtr, newNU);
InsertNode(p, oldPtr, i0);
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl 0xa6(%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
RestoreModel | static void RestoreModel(CPpmd8 *p, CTX_PTR c1
#ifdef PPMD8_FREEZE_SUPPORT
, CTX_PTR fSuccessor
#endif
)
{
CTX_PTR c;
CPpmd_State *s;
RESET_TEXT(0);
for (c = p->MaxContext; c != c1; c = SUFFIX(c))
if (--(c->NumStats) == 0)
{
s = STATS(c);
c->Flags = (Byte)((c->Flags & 0x10) +... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
AllocUnits | static void *AllocUnits(CPpmd8 *p, unsigned indx)
{
UInt32 numBytes;
if (p->FreeList[indx] != 0)
return RemoveNode(p, indx);
numBytes = U2B(I2U(indx));
if (numBytes <= (UInt32)(p->HiUnit - p->LoUnit))
{
void *retVal = p->LoUnit;
p->LoUnit += numBytes;
return retVal;
}
return AllocUnitsRare... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpl $0x0, 0x128(%rax,%rcx,4)
je 0xf12e2
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xf07c0
movq %rax, -0x8(%rbp)
jmp 0xf134b
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
SpecialFreeUnit | static void SpecialFreeUnit(CPpmd8 *p, void *ptr)
{
if ((Byte *)ptr != p->UnitsStart)
InsertNode(p, ptr, 0);
else
{
#ifdef PPMD8_FREEZE_SUPPORT
*(UInt32 *)ptr = EMPTY_NODE; /* it's used for (Flags == 0xFF) check in RemoveBinContexts */
#endif
p->UnitsStart += UNIT_SIZE;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0xf16cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xf0610
jmp 0xf16df
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0xc, %rcx
movq %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
CutOff | static CPpmd_Void_Ref CutOff(CPpmd8 *p, CTX_PTR ctx, unsigned order)
{
int i;
unsigned tmp;
CPpmd_State *s;
if (!ctx->NumStats)
{
s = ONE_STATE(ctx);
if ((Byte *)Ppmd8_GetPtr(p, SUCCESSOR(s)) >= p->UnitsStart)
{
if (order < p->MaxOrder)
SetSuccessor(s, CutOff(p, CTX(SUCCESSOR(s)),... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xf19eb
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
MoveUnitsUp | static void *MoveUnitsUp(CPpmd8 *p, void *oldPtr, unsigned nu)
{
unsigned indx = U2I(nu);
void *ptr;
if ((Byte *)oldPtr > p->UnitsStart + 16 * 1024 || REF(oldPtr) > p->FreeList[indx])
return oldPtr;
ptr = RemoveNode(p, indx);
MyMem12Cpy(ptr, oldPtr, nu);
if ((Byte*)oldPtr != p->UnitsStart)
InsertNod... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl 0xa6(%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
addq $0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd8.c |
Ppmd7_Construct | static void Ppmd7_Construct(CPpmd7 *p)
{
unsigned i, k, m;
p->Base = 0;
for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++)
{
unsigned step = (i >= 12 ? 4 : (i >> 2) + 1);
do { p->Units2Indx[k++] = (Byte)i; } while(--step);
p->Indx2Units[i] = (Byte)k;
}
p->NS2BSIndx[0] = (0 << 1);
p->NS2BSIndx[1]... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x26, -0xc(%rbp)
jae 0xf2074
cmpl $0xc, -0xc(%rbp)
jb 0xf201c
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf2028
movl -0xc(%rbp), %eax
shrl $0x2, %eax
addl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd7_Alloc | static Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size)
{
if (p->Base == 0 || p->Size != size)
{
/* RestartModel() below assumes that p->Size >= UNIT_SIZE
(see the calculation of m->MinContext). */
if (size < UNIT_SIZE) {
return False;
}
Ppmd7_Free(p);
p->AlignOffset =
#ifdef PPMD_32B... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xf21a6
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0xf2209
cmpl $0xc, -0x14(%rbp)
jae 0xf21b5
movl $0x0, -0x4(%rbp)
jmp 0xf2210
movq -0x10(%rbp), %rdi
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd7_DecodeSymbol | static int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
{
size_t charMask[256 / sizeof(size_t)];
if (p->MinContext->NumStats != 1)
{
CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
unsigned i;
UInt32 count, hiCnt;
if ((count = rc->GetThreshold(rc, p->MinContext->SummFreq)) < (hiCnt = s->F... | pushq %rbp
movq %rsp, %rbp
subq $0x990, %rsp # imm = 0x990
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
je 0xf26f6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
addq %rcx... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd7_EncodeSymbol | static void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol)
{
size_t charMask[256 / sizeof(size_t)];
if (p->MinContext->NumStats != 1)
{
CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
UInt32 sum;
unsigned i;
if (s->Symbol == symbol)
{
RangeEnc_Encode(rc, 0, s->Freq, p... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl (%rax), %eax
cmpl $0x1, %eax
je 0xf300e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
RestartModel | static void RestartModel(CPpmd7 *p)
{
unsigned i, k, m;
memset(p->FreeList, 0, sizeof(p->FreeList));
p->Text = p->Base + p->AlignOffset;
p->HiUnit = p->Text + p->Size;
p->LoUnit = p->UnitsStart = p->HiUnit - p->Size / 8 / UNIT_SIZE * 7 * UNIT_SIZE;
p->GlueCount = 0;
p->OrderFall = p->MaxOrder;
p->RunL... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x114, %rdi # imm = 0x114
xorl %esi, %esi
movl $0x98, %edx
callq 0x10810
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Range_Normalize | static void Range_Normalize(CPpmd7z_RangeDec *p)
{
while (1)
{
if((p->Low ^ (p->Low + p->Range)) >= kTopValue)
{
if(p->Range >= p->Bottom)
break;
else
p->Range = ((uint32_t)(-(int32_t)p->Low)) & (p->Bottom - 1);
}
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stre... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x20(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0x18(%rdx), %ecx
xorl %ecx, %eax
cmpl $0x1000000, %eax # imm = 0x1000000
jb 0xf39ea
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Range_DecodeBit_RAR | static UInt32 Range_DecodeBit_RAR(void *pp, UInt32 size0)
{
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
UInt32 bit, value = p->p.GetThreshold(p, PPMD_BIN_SCALE);
if(value < size0)
{
bit = 0;
p->p.Decode(p, 0, size0);
}
else
{
bit = 1;
p->p.Decode(p, size0, PPMD_BIN_SCALE - size0);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movl $0x4000, %esi # imm = 0x4000
callq *%rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd_RangeDec_Init | static Bool Ppmd_RangeDec_Init(CPpmd7z_RangeDec *p)
{
unsigned i;
p->Low = p->Bottom = 0;
p->Range = 0xFFFFFFFF;
for (i = 0; i < 4; i++)
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
return (p->Code < 0xFFFFFFFF);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0xf3b97
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd7_Update1_0 | static void Ppmd7_Update1_0(CPpmd7 *p)
{
p->PrevSuccess = (2 * p->FoundState->Freq > p->MinContext->SummFreq);
p->RunLength += p->PrevSuccess;
p->MinContext->SummFreq += 4;
if ((p->FoundState->Freq += 4) > MAX_FREQ)
Rescale(p);
NextContext(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0x1(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
setg %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Ppmd7_Update1 | static void Ppmd7_Update1(CPpmd7 *p)
{
CPpmd_State *s = p->FoundState;
s->Freq += 4;
p->MinContext->SummFreq += 4;
if (s[0].Freq > s[-1].Freq)
{
SwapStates(&s[0], &s[-1]);
p->FoundState = --s;
if (s->Freq > MAX_FREQ)
Rescale(p);
}
NextContext(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
addl $0x4, %ecx
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl 0x2(%rax), %ecx
addl $0x4, %ecx
movw %cx, 0x2(%rax)
movq -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
Rescale | static void Rescale(CPpmd7 *p)
{
unsigned i, adder, sumFreq, escFreq;
CPpmd_State *stats = STATS(p->MinContext);
CPpmd_State *s = p->FoundState;
{
CPpmd_State tmp = *s;
for (; s != stats; s--)
s[0] = s[-1];
*s = tmp;
}
escFreq = p->MinContext->SummFreq - s->Freq;
s->Freq += 4;
adder = ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
AllocUnitsRare | static void *AllocUnitsRare(CPpmd7 *p, unsigned indx)
{
unsigned i;
void *retVal;
if (p->GlueCount == 0)
{
GlueFreeBlocks(p);
if (p->FreeList[indx] != 0)
return RemoveNode(p, indx);
}
i = indx;
do
{
if (++i == PPMD_NUM_INDEXES)
{
UInt32 numBytes = U2B(I2U(indx));
p->Glu... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0xf510a
movq -0x10(%rbp), %rdi
callq 0xf51e0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpl $0x0, 0x114(%rax,%rcx,4)
je 0xf5108
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
RangeEnc_EncodeBit_1 | static void RangeEnc_EncodeBit_1(CPpmd7z_RangeEnc *p, UInt32 size0)
{
UInt32 newBound = (p->Range >> 14) * size0;
p->Low += newBound;
p->Range -= newBound;
while (p->Range < kTopValue)
{
p->Range <<= 8;
RangeEnc_ShiftLow(p);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0xe, %eax
imull -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl -0x10(%rbp), %edx
movq -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_ppmd7.c |
archive_random | int
archive_random(void *buf, size_t nbytes)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
HCRYPTPROV hProv;
BOOL success;
success = CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT);
if (!success && GetLastError() == (DWORD)NTE_BAD_KEYSET) {
success = CryptAcquireContext(&hProv, N... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf5700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.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, 0x235de2(%rip) # 0x32b5c4
jne 0xf57f3
callq 0xf5960
movl $0x1, 0x235dd1(%rip) # 0x32b5c4
movl $0x0, -0x4(%rbp)
leaq 0x1b91cc(%rip), %rdi # 0x2ae9cd
movl $0x80000, %esi # imm = 0x80000
xorl %edx, %edx
movb $0x0, %al
callq 0x10ae0
movl %eax, -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.c |
arc4_getbyte | static inline uint8_t
arc4_getbyte(void)
{
uint8_t si, sj;
rs.i = (rs.i + 1);
si = rs.s[rs.i];
rs.j = (rs.j + si);
sj = rs.s[rs.j];
rs.s[rs.i] = sj;
rs.s[rs.j] = si;
return (rs.s[(si + sj) & 0xff]);
} | pushq %rbp
movq %rsp, %rbp
movzbl 0x235d11(%rip), %eax # 0x32b5cc
addl $0x1, %eax
movb %al, 0x235d08(%rip) # 0x32b5cc
movzbl 0x235d01(%rip), %eax # 0x32b5cc
movl %eax, %ecx
leaq 0x235cf8(%rip), %rax # 0x32b5cc
movb 0x2(%rax,%rcx), %al
movb %al, -0x1(%rbp)
movzbl 0x235ceb(%rip), %eax # 0x32b5cd
movzbl -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.c |
arc4_addrandom | static inline void
arc4_addrandom(uint8_t *dat, int datlen)
{
int n;
uint8_t si;
rs.i--;
for (n = 0; n < 256; n++) {
rs.i = (rs.i + 1);
si = rs.s[rs.i];
rs.j = (rs.j + si + dat[n % datlen]);
rs.s[rs.i] = rs.s[rs.j];
rs.s[rs.j] = si;
}
rs.j = rs.i;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb 0x235c0b(%rip), %al # 0x32b5cc
addb $-0x1, %al
movb %al, 0x235c03(%rip) # 0x32b5cc
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp) # imm = 0x100
jge 0xf5a7e
movzbl 0x235be8(%rip), %eax # 0x32b5cc
addl $0x1, %eax
movb %al, 0x235bd... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_random.c |
archive_read_add_passphrase | int
archive_read_add_passphrase(struct archive *_a, const char *passphrase)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_passphrase *p;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"archive_read_add_passphrase");
if (passphrase == NULL || passphrase[0] == '\0') {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x1cc0e3(%rip), %rcx # 0x2c1ba0
callq 0xe9670
movl %eax, -0x2c(%rbp)
cmpl $-0x1e, -0x2c(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.c |
archive_read_set_passphrase_callback | int
archive_read_set_passphrase_callback(struct archive *_a, void *client_data,
archive_passphrase_callback *cb)
{
struct archive_read *a = (struct archive_read *)_a;
archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW,
"archive_read_set_passphrase_callback");
a->passphrases.callback = cb;
a->pass... | 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 %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x1cbf5b(%rip), %rcx # 0x2c1bbc
callq 0xe9670
movl %eax, -0x2c(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_add_passphrase.c |
archive_read_format_7zip_read_header | static int
archive_read_format_7zip_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct _7zip *zip = (struct _7zip *)a->format->data;
struct _7zip_entry *zip_entry;
int r, ret = ARCHIVE_OK;
struct _7z_folder *folder = 0;
uint64_t fidx = 0;
/*
* It should be sufficient to call archive_rea... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpl $-0x1, 0x50f8(%rax)
jne 0xf6247
movq -0x20(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_7zip.c |
compression_code_ppmd | static int
compression_code_ppmd(struct archive *a,
struct la_zstream *lastrm, enum la_zaction action)
{
struct ppmd_stream *strm;
(void)a; /* UNUSED */
strm = (struct ppmd_stream *)lastrm->real_stream;
/* Copy encoded data if there are remaining bytes from previous call. */
if (strm->buff_bytes) {
uint8_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x4b40(%rax)
je 0x100d71
movq -0x28(%rbp), %rax
movq 0x4b30(%rax), %rax
movq -0x28(%rbp), %rdx
xorl %ecx,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
compression_end_ppmd | static int
compression_end_ppmd(struct archive *a, struct la_zstream *lastrm)
{
struct ppmd_stream *strm;
(void)a; /* UNUSED */
strm = (struct ppmd_stream *)lastrm->real_stream;
__archive_ppmd7_functions.Ppmd7_Free(&strm->ppmd7_context);
free(strm->buff);
free(strm);
lastrm->real_stream = NULL;
lastrm->valid ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x22561d(%rip), %rax # 0x326490
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq 0x4b28(%rax), %rdi
cal... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
compression_code_copy | static int
compression_code_copy(struct archive *a,
struct la_zstream *lastrm, enum la_zaction action)
{
size_t bytes;
(void)a; /* UNUSED */
if (lastrm->avail_out > lastrm->avail_in)
bytes = lastrm->avail_in;
else
bytes = lastrm->avail_out;
if (bytes) {
memcpy(lastrm->next_out, lastrm->next_in, bytes);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x100ef3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x100eff
movq -0x18(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
make_header | static int
make_header(struct archive_write *a, uint64_t offset, uint64_t pack_size,
uint64_t unpack_size, int codernum, struct coder *coders)
{
struct _7zip *zip = (struct _7zip *)a->format_data;
struct file *file;
int r;
uint8_t b, mask;
/*
* Make FilesInfo.
*/
r = enc_uint64(a, kHeader);
if (r < 0)
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x101790
movl %eax, -0x4c(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
enc_uint64 | static int
enc_uint64(struct archive_write *a, uint64_t val)
{
unsigned mask = 0x80;
uint8_t numdata[9];
int i;
numdata[0] = 0;
for (i = 1; i < (int)sizeof(numdata); i++) {
if (val < mask) {
numdata[0] |= (uint8_t)val;
break;
}
numdata[i] = (uint8_t)val;
val >>= 8;
numdata[0] |= mask;
mask >>= 1... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x80, -0x14(%rbp)
movb $0x0, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
cmpl $0x9, -0x24(%rbp)
jge 0x10180f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0x1017d6
movq -0x10(%rbp), %rax
movzbl %al, %ecx
movzbl -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
make_streamsInfo | static int
make_streamsInfo(struct archive_write *a, uint64_t offset, uint64_t pack_size,
uint64_t unpack_size, int num_coder, struct coder *coders, int substrm,
uint32_t header_crc)
{
struct _7zip *zip = (struct _7zip *)a->format_data;
uint8_t codec_buff[8];
int numFolders, fi;
int codec_size;
int i, r;
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpl... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
copy_out | static int
copy_out(struct archive_write *a, uint64_t offset, uint64_t length)
{
struct _7zip *zip;
int r;
zip = (struct _7zip *)a->format_data;
if (zip->temp_offset > 0 &&
lseek(zip->temp_fd, offset, SEEK_SET) < 0) {
archive_set_error(&(a->archive), errno, "lseek failed");
return (ARCHIVE_FATAL);
}
whi... | 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 -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x101e72
movq -0x28(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
ca... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
flush_wbuff | static int
flush_wbuff(struct archive_write *a)
{
struct _7zip *zip;
int r;
size_t s;
zip = (struct _7zip *)a->format_data;
s = sizeof(zip->wbuff) - zip->wbuff_remaining;
r = __archive_write_output(a, zip->wbuff, s);
if (r != ARCHIVE_OK)
return (r);
zip->wbuff_remaining = sizeof(zip->wbuff);
return (r);
} | 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), %rcx
movl $0xf000, %eax # imm = 0xF000
subq 0xf108(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x108, %rsi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
utcToFiletime | static uint64_t
utcToFiletime(time_t t, long ns)
{
uint64_t fileTime;
fileTime = t;
fileTime *= 10000000;
fileTime += ns / 100;
fileTime += EPOC_TIME;
return (fileTime);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
imulq $0x989680, -0x18(%rbp), %rax # imm = 0x989680
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x19db1ded53e8000... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
make_substreamsInfo | static int
make_substreamsInfo(struct archive_write *a, struct coder *coders)
{
struct _7zip *zip = (struct _7zip *)a->format_data;
struct file *file;
int r;
/*
* Make SubStreamsInfo.
*/
r = enc_uint64(a, kSubStreamsInfo);
if (r < 0)
return (r);
if (zip->total_number_nonempty_entry > 1 && coders->codec !... | 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 -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x101790
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x102411
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
file_free_register | static void
file_free_register(struct _7zip *zip)
{
struct file *file, *file_next;
file = zip->file_list.first;
while (file != NULL) {
file_next = file->next;
file_free(file);
file = file_next;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xf110(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x102691
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xff6b0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_7zip.c |
archive_write_set_format_ar_bsd | int
archive_write_set_format_ar_bsd(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_ar_bsd");
r = archive_write_set_format_ar(a);
if (r == ARCHIVE_OK) {
a->archive.archive_format = A... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x1bfdcf(%rip), %rcx # 0x2c2498
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0x1026e0
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
archive_write_set_format_ar | static int
archive_write_set_format_ar(struct archive_write *a)
{
struct ar_w *ar;
/* If someone else was already registered, unregister them. */
if (a->format_free != NULL)
(a->format_free)(a);
ar = (struct ar_w *)calloc(1, sizeof(*ar));
if (ar == NULL) {
archive_set_error(&a->archive, ENOMEM, "Can't alloca... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0x10274b
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl $0x1, %edi
movl $0x28, %esi
callq 0x11580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x102788
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
archive_write_set_format_ar_svr4 | int
archive_write_set_format_ar_svr4(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int r;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_ar_svr4");
r = archive_write_set_format_ar(a);
if (r == ARCHIVE_OK) {
a->archive.archive_format =... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %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 0x1bfc6f(%rip), %rcx # 0x2c24b8
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0x102860
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.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 %rbp
movq %rsp, %rbp
subq $0x30, %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 -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x102ffb
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
archive_write_ar_free | static int
archive_write_ar_free(struct archive_write *a)
{
struct ar_w *ar;
ar = (struct ar_w *)a->format_data;
if (ar == NULL)
return (ARCHIVE_OK);
if (ar->has_strtab > 0) {
free(ar->strtab);
ar->strtab = NULL;
}
free(ar);
a->format_data = NULL;
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10318b
movl $0x0, -0x4(%rbp)
jmp 0x1031cd
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x1031ae
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x104... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
ar_basename | static const char *
ar_basename(const char *path)
{
const char *endp, *startp;
endp = path + strlen(path) - 1;
/*
* For filename with trailing slash(es), we return
* NULL indicating an error.
*/
if (*endp == '/')
return (NULL);
/* Find the start of the base */
startp = endp;
while (startp > path && *(s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x109c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1032e5
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
format_octal | static int
format_octal(int64_t v, char *p, int s)
{
int len;
char *h;
len = s;
h = p;
/* Octal values can't be negative, so use 0. */
if (v < 0) {
while (len-- > 0)
*p++ = '0';
return (-1);
}
p += s; /* Start at the end and work backwards. */
do {
*--p = (char)('0' + (v & 7));
v >>= 3;
} while... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jge 0x10350a
jmp 0x1034da
movl -0x20(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_write_set_format_ar.c |
BZ2_bzCompressInit | int BZ_API(BZ2_bzCompressInit)
( bz_stream* strm,
int blockSize100k,
int verbosity,
int workFactor )
{
Int32 n;
EState* s;
if (!bz_config_ok()) return BZ_CONFIG_ERROR;
if (strm == NULL ||
bl... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x1039e0
cmpl $0x0, %eax
jne 0x1036bb
movl $0xfffffff7, -0x4(%rbp) # imm = 0xFFFFFFF7
jmp 0x1039cb
cmpq $0x0, -0x10(%rbp)
je 0x1036dd
cmpl $0x1, -0x14(%rbp)
jl 0x1036dd
cmpl $0x9... | /JKorbelRA[P]CMake/Utilities/cmbzip2/bzlib.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.