name string | code string | asm string | file string |
|---|---|---|---|
sort_dir_list | static struct fixup_entry *
sort_dir_list(struct fixup_entry *p)
{
struct fixup_entry *a, *b, *t;
if (p == NULL)
return (NULL);
/* A one-item list is already sorted. */
if (p->next == NULL)
return (p);
/* Step 1: split the list. */
t = p;
a = p->next->next;
while (a != NULL) {
/* Step a twice, t once. *... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1652b5
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x16532b
movq (%rax), %rcx
movq %rbx, %rax
testq %rcx, %rcx
je 0x165276
movq %rbx, %rax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x16526c
movq (%rcx), %rcx
jmp 0x16526e
xorl %ecx, %ecx
... | /mmatuska[P]libarchive/libarchive/archive_write_disk_posix.c |
set_times | static int
set_times(struct archive_write_disk *a,
int fd, int mode, const char *name,
time_t atime, long atime_nanos,
time_t birthtime, long birthtime_nanos,
time_t mtime, long mtime_nanos,
time_t cctime, long ctime_nanos)
{
/* Note: set_time doesn't use libarchive return conventions!
* It uses ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rsp), %rax
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rsp, %rax
testl %esi, %esi
js 0x1653f4
movl %esi, %edi
movq %rax, %rsi
callq 0x14210
jmp 0x165409
movl $0xffffff9c, %edi # imm = 0xFFFFFF9C
movq %rdx, %rsi
movq ... | /mmatuska[P]libarchive/libarchive/archive_write_disk_posix.c |
write_data_block | static ssize_t
write_data_block(struct archive_write_disk *a, const char *buff, size_t size)
{
uint64_t start_size = size;
ssize_t bytes_written = 0;
ssize_t block_size = 0, bytes_to_write;
if (size == 0)
return (ARCHIVE_OK);
if (a->filesize == 0 || a->fd < 0) {
archive_set_error(&a->archive, 0,
"Attem... | testq %rdx, %rdx
je 0x166484
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x220(%rdi)
je 0x166465
cmpl $0x0, 0x204(%rbx)
js 0x166465
movq %rdx, %r14
movq %rsi, %r15
testb $0x10, 0x201(%rbx)
jne 0x166487
movq $0x0, (%rsp)
jmp 0x1664b9
leaq 0x72265(%rip), %rdx ... | /mmatuska[P]libarchive/libarchive/archive_write_disk_posix.c |
archive_write_open_fd | int
archive_write_open_fd(struct archive *a, int fd)
{
struct write_fd_data *mine;
mine = malloc(sizeof(*mine));
if (mine == NULL) {
archive_set_error(a, ENOMEM, "No memory");
return (ARCHIVE_FATAL);
}
mine->fd = fd;
#if defined(__CYGWIN__) || defined(_WIN32)
setmode(mine->fd, O_BINARY);
#endif
return (arch... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x4, %edi
callq 0x14cd0
testq %rax, %rax
je 0x1669dc
movl %ebp, (%rax)
leaq 0x44(%rip), %rdx # 0x1669fe
leaq 0xfd(%rip), %rcx # 0x166abe
leaq 0x14e(%rip), %r9 # 0x166b16
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
addq $0x8,... | /mmatuska[P]libarchive/libarchive/archive_write_open_fd.c |
file_free | static int
file_free(struct archive *a, void *client_data)
{
struct write_fd_data *mine = (struct write_fd_data *)client_data;
(void)a; /* UNUSED */
if (mine == NULL)
return (ARCHIVE_OK);
free(mine);
return (ARCHIVE_OK);
} | testq %rsi, %rsi
je 0x166b28
pushq %rax
movq %rsi, %rdi
callq 0x14220
addq $0x8, %rsp
xorl %eax, %eax
retq
| /mmatuska[P]libarchive/libarchive/archive_write_open_fd.c |
open_filename | static int
open_filename(struct archive *a, int mbs_fn, const void *filename)
{
struct write_file_data *mine;
int r;
mine = calloc(1, sizeof(*mine));
if (mine == NULL) {
archive_set_error(a, ENOMEM, "No memory");
return (ARCHIVE_FATAL);
}
if (mbs_fn)
r = archive_mstring_copy_mbs(&mine->filename, filename);... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x70, %esi
callq 0x14be0
testq %rax, %rax
je 0x166cad
movq %rax, %r15
leaq 0x8(%rax), %rdi
movq %r14, %rsi
testl %ebp, %ebp
je 0x166c62
callq 0x15e961
jmp 0x166c67
callq 0x15e9eb
testl %eax, %eax... | /mmatuska[P]libarchive/libarchive/archive_write_open_filename.c |
file_write | static ssize_t
file_write(struct archive *a, void *client_data, const void *buff,
size_t length)
{
struct write_file_data *mine;
ssize_t bytesWritten;
mine = (struct write_file_data *)client_data;
for (;;) {
bytesWritten = write(mine->fd, buff, length);
if (bytesWritten <= 0) {
if (errno == EINTR)
c... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl (%r12), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14e20
testq %rax, %rax
jg 0x166eff
callq 0x14de0
movl (%rax), %esi
cmpl $0x4, %esi
je 0x166ec7
leaq 0x63cb4(%rip), %rdx # 0x1caba2
movq %rb... | /mmatuska[P]libarchive/libarchive/archive_write_open_filename.c |
file_free | static int
file_free(struct archive *a, void *client_data)
{
struct write_file_data *mine = (struct write_file_data *)client_data;
(void)a; /* UNUSED */
if (mine == NULL)
return (ARCHIVE_OK);
archive_mstring_clean(&mine->filename);
free(mine);
return (ARCHIVE_OK);
} | testq %rsi, %rsi
je 0x166f44
pushq %rbx
movq %rsi, %rbx
leaq 0x8(%rsi), %rdi
callq 0x15e5eb
movq %rbx, %rdi
callq 0x14220
popq %rbx
xorl %eax, %eax
retq
| /mmatuska[P]libarchive/libarchive/archive_write_open_filename.c |
memory_write_open | static int
memory_write_open(struct archive *a, void *client_data)
{
struct write_memory_data *mine;
mine = client_data;
mine->used = 0;
if (mine->client_size != NULL)
*mine->client_size = mine->used;
/* Disable padding if it hasn't been set explicitly. */
if (-1 == archive_write_get_bytes_in_last_block(a))
a... | pushq %rbx
movq %rdi, %rbx
movq $0x0, (%rsi)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x166feb
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x162b23
cmpl $-0x1, %eax
jne 0x167005
movq %rbx, %rdi
movl $0x1, %esi
callq 0x162ae7
xorl %eax, %eax
popq %rbx
retq
| /mmatuska[P]libarchive/libarchive/archive_write_open_memory.c |
memory_write_free | static int
memory_write_free(struct archive *a, void *client_data)
{
struct write_memory_data *mine;
(void)a; /* UNUSED */
mine = client_data;
if (mine == NULL)
return (ARCHIVE_OK);
free(mine);
return (ARCHIVE_OK);
} | testq %rsi, %rsi
je 0x16707f
pushq %rax
movq %rsi, %rdi
callq 0x14220
addq $0x8, %rsp
xorl %eax, %eax
retq
| /mmatuska[P]libarchive/libarchive/archive_write_open_memory.c |
archive_filter_b64encode_write | static int
archive_filter_b64encode_write(struct archive_write_filter *f, const void *buff,
size_t length)
{
struct private_b64encode *state = (struct private_b64encode *)f->data;
const unsigned char *p = buff;
int ret = ARCHIVE_OK;
if (length == 0)
return (ret);
if (state->hold_len) {
while (state->hold... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x167427
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %r13
cmpq $0x0, 0x40(%r13)
je 0x167378
movq 0x40(%r13), %rax
cmpq $0x39, %rax
setb %cl
jae 0x16737d
movb (%r14), %cl
incq %r14
leaq 0x1(%rax), %rsi
m... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_b64encode.c |
la_b64_encode | static void
la_b64_encode(struct archive_string *as, const unsigned char *p, size_t len)
{
int c;
for (; len >= 3; p += 3, len -= 3) {
c = p[0] >> 2;
archive_strappend_char(as, base64[c]);
c = ((p[0] & 0x03) << 4) | ((p[1] & 0xf0) >> 4);
archive_strappend_char(as, base64[c]);
c = ((p[1] & 0x0f) << 2) | ((p... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x713e4(%rip), %r12 # 0x1d88b0
cmpq $0x3, %rdx
jb 0x16754a
movzbl (%r14), %eax
shrl $0x2, %eax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x15d9ed
movzbl (%r14), %eax
shll $0x4, %eax
andl $0x30, %eax
movz... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_b64encode.c |
archive_write_lrzip_options | static int
archive_write_lrzip_options(struct archive_write_filter *f, const char *key,
const char *value)
{
struct write_lrzip *data = (struct write_lrzip *)f->data;
if (strcmp(key, "compression") == 0) {
if (value == NULL)
return (ARCHIVE_WARN);
else if (strcmp(value, "bzip2") == 0)
data->compression... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x48(%rdi), %r15
leaq 0x57253(%rip), %rsi # 0x1bf91a
movq %rbx, %rdi
callq 0x14b40
testl %eax, %eax
je 0x168720
leaq 0x55fbf(%rip), %rsi # 0x1be699
movq %rbx, %rdi
callq 0x14b40
movl $0xffffffec, %ebx # imm = 0xFFFFFFEC
testq %r14, %r14... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_lrzip.c |
archive_write_add_filter_program | int
archive_write_add_filter_program(struct archive *_a, const char *cmd)
{
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
static const char prefix[] = "Program: ";
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_progr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x162ba2
movq %rax, %rbx
leaq 0x6fe1f(%rip), %rcx # 0x1d8c00
movq %r15, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFF... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_program.c |
archive_write_add_filter_zstd | int
archive_write_add_filter_zstd(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct archive_write_filter *f = __archive_write_allocate_filter(_a);
struct private_data *data;
archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_add_filter_zstd"... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x162ba2
movq %rax, %r15
leaq 0x6ee61(%rip), %rcx # 0x1d8f58
movq %rbx, %rdi
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %r12d # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x16a1ed
movl ... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_zstd.c |
archive_compressor_zstd_options | static int
archive_compressor_zstd_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) {
intmax_t level;
if (string_to_number(value, &level) != ARCHIVE_OK) {
return (ARCHIVE_WAR... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x48(%rdi), %rbx
leaq 0x543a1(%rip), %rsi # 0x1be699
movq %r15, %rdi
callq 0x14b40
testl %eax, %eax
je 0x16a425
leaq 0x559a4(%rip), %rsi # 0x1bfcb3
movq %r15, %rdi
callq 0x14b40
testl %eax, %eax
je 0x16a45b
leaq 0x55a08(... | /mmatuska[P]libarchive/libarchive/archive_write_add_filter_zstd.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 %rbx
movq 0xf8(%rdi), %rbx
movq 0x28(%rbx), %rax
testq %rax, %rax
jne 0x16f03a
cmpl $0x0, 0x38(%rbx)
jne 0x16f036
callq 0x15e0bb
movq %rax, 0x30(%rbx)
movl $0x1, 0x38(%rbx)
movq 0x30(%rbx), %rax
popq %rbx
retq
| /mmatuska[P]libarchive/libarchive/archive_write_set_format_cpio_odc.c |
archive_write_set_format_filter_by_ext_def | int
archive_write_set_format_filter_by_ext_def(struct archive *a, const char *filename, const char * def_ext)
{
int names_index = get_array_index(filename);
if (names_index < 0)
names_index = get_array_index(def_ext);
if (names_index >= 0)
{
int format_state = (names[names_index].format)(a);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x16f56d
testl %eax, %eax
jns 0x16f5fc
movq %r15, %rdi
callq 0x16f56d
testl %eax, %eax
js 0x16f628
movl %eax, %eax
leaq (%rax,%rax,2), %r14
leaq 0x98073(%rip), %r15 # 0x207680
movq %rbx, %rdi
callq *0x8(%r15,%r14,... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_filter_by_ext.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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0xf0, %esi
callq 0x14be0
testq %rax, %rax
je 0x1737c7
movq %rax, %rbx
movq %r14, 0x18(%rax)
addq $0x28, %rax
xorl %r15d, %r15d
movq %r15, 0x28(%rbx)
movq %rax, 0x30(%rbx)
leaq 0x40(%rbx), %rdi
leaq 0x94039(%rip), %rsi # 0x2077b8
callq 0x127199
l... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_traverse_tree | static int
isoent_traverse_tree(struct archive_write *a, struct vdd* vdd)
{
struct iso9660 *iso9660 = a->format_data;
struct isoent *np;
struct idr idr;
int depth;
int r;
int (*genid)(struct archive_write *, struct isoent *, struct idr *);
idr_init(iso9660, vdd, &idr);
np = vdd->rootent;
depth = 0;
if (vdd->... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq 0xf8(%rdi), %rbx
movq $0x0, 0x20(%rsp)
movl $0x0, 0x48(%rsp)
cmpl $0x1, 0x8(%rsi)
jne 0x176265
leaq 0x418(%rip), %rax # 0x17667b
jmp 0x1762d4
leaq 0x58(%rsp), %rdi
testb $0x1, 0x10372(%rbx)... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_gen_iso9660_identifier | static int
isoent_gen_iso9660_identifier(struct archive_write *a, struct isoent *isoent,
struct idr *idr)
{
struct iso9660 *iso9660;
struct isoent *np;
char *p;
int l, r;
const char *char_map;
char allow_ldots, allow_multidot, allow_period, allow_vernum;
int fnmax, ffmax, dnmax;
static const struct archive_... | movq %rdx, %r8
movl 0x38(%rsi), %edx
xorl %eax, %eax
testl %edx, %edx
je 0x176ee6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0xf8(%rdi), %rax
movq %rax, 0x40(%rsp)
movl 0x10370(%rax), %eax
movl %eax, %ebx
shrl $0xe, %ebx
andl $0x7, %ebx
cmpl $... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_cmp_joliet_identifier | static int
isoent_cmp_joliet_identifier(const struct isoent *p1, const struct isoent *p2)
{
const unsigned char *s1, *s2;
int cmp;
int l;
s1 = (const unsigned char *)p1->identifier;
s2 = (const unsigned char *)p2->identifier;
/* Compare File Name */
l = p1->ext_off;
if (l > p2->ext_off)
l = p2->ext_off;
cm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
movq 0xa8(%rsi), %r15
movslq 0xb0(%r14), %r12
movslq 0xb0(%rsi), %rbp
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movslq %eax, %r13
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r13, %rdx... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_cmp_iso9660_identifier | static int
isoent_cmp_iso9660_identifier(const struct isoent *p1, const struct isoent *p2)
{
const char *s1, *s2;
int cmp;
int l;
s1 = p1->identifier;
s2 = p2->identifier;
/* Compare File Name */
l = p1->ext_off;
if (l > p2->ext_off)
l = p2->ext_off;
cmp = memcmp(s1, s2, l);
if (cmp != 0)
return (cmp);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
movq 0xa8(%rsi), %r15
movslq 0xb0(%r14), %r12
movslq 0xb0(%rsi), %rbp
cmpl %ebp, %r12d
movl %ebp, %eax
cmovll %r12d, %eax
movslq %eax, %r13
movq %rdi, (%rsp)
movq %r15, %rsi
movq %r13, %rdx... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
set_time_915 | static void
set_time_915(unsigned char *p, time_t t)
{
struct tm tm;
get_tmfromtime(&tm, &t);
set_num_711(p+0, tm.tm_year);
set_num_711(p+1, tm.tm_mon+1);
set_num_711(p+2, tm.tm_mday);
set_num_711(p+3, tm.tm_hour);
set_num_711(p+4, tm.tm_min);
set_num_711(p+5, tm.tm_sec);
set_num_712(p+6, (char)(get_gmoffset(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
callq 0x14bd0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x141e0
movb 0x14(%r15), %al
movb %al, (%rbx)
movb 0x10(%r15), %al
incb %al
movb %al, 0x1(%rbx)
movb 0xc(%r15), %al
movb %al, 0x2(%rbx)
movb 0x8(%r... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
extra_close_record | static void
extra_close_record(struct ctl_extr_rec *ctl, int ce_size)
{
int padding = 0;
if (ce_size > 0)
extra_tell_used_size(ctl, ce_size);
/* Padding. */
if (ctl->cur_len & 0x01) {
ctl->cur_len++;
if (ctl->bp != NULL)
ctl->bp[ctl->cur_len] = 0;
padding = 1;
}
if (ctl->use_extr) {
if (ctl->ce_ptr ... | testl %esi, %esi
jle 0x1789bc
cmpl $0x0, (%rdi)
je 0x1789b9
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0xe0(%rax), %rax
testq %rax, %rax
je 0x1789b9
addl %esi, 0x4(%rax)
addl %esi, 0x20(%rdi)
movslq 0x20(%rdi), %rax
xorl %ecx, %ecx
testb $0x1, %al
je 0x1789de
incq %rax
movl %eax, 0x20(%rdi)
movq 0x8(%rdi), %rdx
m... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
set_str_a_characters_bp | static int
set_str_a_characters_bp(struct archive_write *a, unsigned char *bp,
int from, int to, const char *s, enum vdc vdc)
{
int r;
switch (vdc) {
case VDC_STD:
set_str(bp+from, s, to - from + 1, 0x20,
a_characters_map);
r = ARCHIVE_OK;
break;
case VDC_LOWERCASE:
set_str(bp+from, s, to - from ... | leal -0x2(%r9), %eax
cmpl $0x2, %eax
jb 0x178a33
pushq %rax
cmpl $0x1, %r9d
je 0x178a4a
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
testl %r9d, %r9d
jne 0x178a6a
movl %edx, %eax
addq %rax, %rsi
subl %edx, %ecx
incl %ecx
movslq %ecx, %rdx
leaq 0x61b2f(%rip), %rcx # 0x1da560
jmp 0x178a5d
movl %edx, %eax
addq %rax... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
set_str | static void
set_str(unsigned char *p, const char *s, size_t l, char f, const char *map)
{
unsigned char c;
if (s == NULL)
s = "";
while ((c = *s++) != 0 && l > 0) {
if (c >= 0x80 || map[c] == 0)
{
/* illegal character */
if (c >= 'a' && c <= 'z') {
/* convert c from a-z to A-Z */
c -= 0x20;
... | pushq %rbx
testq %rsi, %rsi
leaq 0x4e4f9(%rip), %rax # 0x1c730b
cmovneq %rsi, %rax
movb (%rax), %sil
testb %sil, %sil
sete %r8b
testq %rdx, %rdx
setne %r11b
sete %r9b
orb %r8b, %r9b
jne 0x178e88
leaq -0x1(%rdx), %r8
xorl %r9d, %r9d
movl $0x5f, %r10d
testb %sil, %sil
js 0x178e4d
movzbl %sil, %r11d
cmpb $0x0, (%rcx,%... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
set_option_info | static void
set_option_info(struct archive_string *info, int *opt, const char *key,
enum keytype type, ...)
{
va_list ap;
char prefix;
const char *s;
int d;
prefix = (*opt==0)? ' ':',';
va_start(ap, type);
switch (type) {
case KEY_FLG:
d = va_arg(ap, int);
archive_string_sprintf(info, "%c%s%s",
... | pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rbx
leaq 0x20(%rsp), %rdx
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x179045
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
isoent_free_all | static void
isoent_free_all(struct isoent *isoent)
{
struct isoent *np, *np_temp;
if (isoent == NULL)
return;
np = isoent;
for (;;) {
if (np->dir) {
if (np->children.first != NULL) {
/* Enter to sub directories. */
np = np->children.first;
continue;
}
}
for (;;) {
np_temp = np;
if (... | testq %rdi, %rdi
je 0x1792a0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r14, %rbx
testb $0x2, 0xe8(%r14)
je 0x179270
movq 0x28(%rbx), %r14
testq %r14, %r14
jne 0x17925a
movq 0x70(%rbx), %r14
testq %r14, %r14
jne 0x17928f
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x173f52
cmpq %rbx, %r14
movq %r14, %rbx
jn... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_iso9660.c |
archive_write_set_format_mtree_default | static int
archive_write_set_format_mtree_default(struct archive *_a, const char *fn)
{
struct archive_write *a = (struct archive_write *)_a;
struct mtree_writer *mtree;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, ARCHIVE_STATE_NEW, fn);
if (a->format_free != NULL)
(a->format_free)(a);
if ((mtree = calloc(1,... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %r14
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x179438
movq 0x138(%r14), %rax
testq %rax, %rax
je 0x179338
movq %r14, %rdi
callq *%rax
movl $0x1, %edi
mo... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
archive_write_mtree_header | static int
archive_write_mtree_header(struct archive_write *a,
struct archive_entry *entry)
{
struct mtree_writer *mtree= a->format_data;
struct mtree_entry *mtree_entry;
int r, r2;
if (mtree->first) {
mtree->first = 0;
archive_strcat(&mtree->buf, "#mtree\n");
if ((mtree->keys & SET_KEYS) == 0)
mtree-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
movq %rdi, %r13
movq 0xf8(%rdi), %r15
cmpl $0x0, 0x70(%r15)
je 0x17990e
movl $0x0, 0x70(%r15)
leaq 0x58(%r15), %rdi
leaq 0x60ec1(%rip), %rsi # 0x1da7b2
callq 0x15d9d9
testl $0x380238, 0x120(%... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
archive_write_mtree_close | static int
archive_write_mtree_close(struct archive_write *a)
{
struct mtree_writer *mtree= a->format_data;
int ret;
if (mtree->root != NULL) {
ret = write_mtree_entry_tree(a);
if (ret != ARCHIVE_OK)
return (ARCHIVE_FATAL);
}
archive_write_set_bytes_in_last_block(&a->archive, 1);
return __archive_write_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0xf8(%rdi), %r14
movq 0x8(%r14), %rbp
testq %rbp, %rbp
je 0x17a5cd
leaq 0xb8(%r14), %r15
leaq 0xc0(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0xc8(%r14), %rax
movq %rax, (%rsp)
leaq 0xd0(%r14), %rax
movq %rax, 0x10(%rsp)
... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
mtree_entry_free | static void
mtree_entry_free(struct mtree_entry *me)
{
archive_string_free(&me->parentdir);
archive_string_free(&me->basename);
archive_string_free(&me->pathname);
archive_string_free(&me->symlink);
archive_string_free(&me->uname);
archive_string_free(&me->gname);
archive_string_free(&me->fflags_text);
free(me-... | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x15d886
leaq 0x50(%rbx), %rdi
callq 0x15d886
leaq 0x68(%rbx), %rdi
callq 0x15d886
leaq 0x80(%rbx), %rdi
callq 0x15d886
leaq 0x98(%rbx), %rdi
callq 0x15d886
leaq 0xb0(%rbx), %rdi
callq 0x15d886
leaq 0xc8(%rbx), %rdi
callq 0x15d886
movq 0x28(%rbx), %rdi
callq 0x14220
mov... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
write_global | static void
write_global(struct mtree_writer *mtree)
{
struct archive_string setstr;
struct archive_string unsetstr;
struct attr_counter_set *acs;
int keys, oldkeys, effkeys;
archive_string_init(&setstr);
archive_string_init(&unsetstr);
keys = mtree->keys & SET_KEYS;
oldkeys = mtree->set.keys;
effkeys = keys;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movl 0x88(%rdi), %ebp
movl 0x120(%rdi), %ecx
movl %ecx, %r15d
andl $0x380238, %r15d # imm... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
mtree_indent | static void
mtree_indent(struct mtree_writer *mtree)
{
int i, fn, nd, pd;
const char *r, *s, *x;
if (mtree->classic) {
if (mtree->indent) {
nd = 0;
pd = mtree->depth * 4;
} else {
nd = mtree->depth?4:0;
pd = 0;
}
} else
nd = pd = 0;
fn = 1;
s = r = mtree->ebuf.s;
x = NULL;
while (*r == ' ')... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
xorl %r12d, %r12d
cmpl $0x0, 0xd8(%rdi)
je 0x17bd94
cmpl $0x0, 0x128(%r14)
movl 0xdc(%r14), %eax
je 0x17bd99
shll $0x2, %eax
xorl %r15d, %r15d
movl %eax, %r12d
jmp 0x17bda6
xorl %r15d, %r15d
jmp 0x17bda6
xorl %r15d, %r15d... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_mtree.c |
archive_write_set_format_pax | int
archive_write_set_format_pax(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct pax *pax;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_pax");
if (a->format_free != NULL)
(a->format_free)(a);
pax = calloc(1, sizeof(*pax));
i... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5ee29(%rip), %rcx # 0x1daef9
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x17c1b2
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x17c0fe
movq %rbx, %rdi
callq ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_finish_entry | static int
archive_write_pax_finish_entry(struct archive_write *a)
{
struct pax *pax;
uint64_t remaining;
int ret;
pax = (struct pax *)a->format_data;
remaining = pax->entry_bytes_remaining;
if (remaining == 0) {
while (pax->sparse_list) {
struct sparse_block *sb;
if (!pax->sparse_list->is_hole)
rema... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf8(%rdi), %r15
movq (%r15), %r14
testq %r14, %r14
jne 0x17da6e
movq 0x60(%r15), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x17da6e
cmpl $0x0, 0x8(%rdi)
jne 0x17da5a
addq 0x18(%rdi), %r14
movq (%rdi), %r12
callq 0x14220
movq %r12, 0x60(%r15)
... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
get_entry_pathname | static int
get_entry_pathname(struct archive_write *a, struct archive_entry *entry,
const char **name, size_t *length, struct archive_string_conv *sc)
{
int r;
r = archive_entry_pathname_l(entry, name, length, sc);
if (r != 0) {
if (errno == ENOMEM) {
archive_set_error(&a->archive, ENOMEM,
"Can't al... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x121b25
testl %eax, %eax
je 0x17db4d
callq 0x14de0
movq %rax, %rcx
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
cmpl $0xc, (%rcx)
jne 0x17db4f
leaq 0x4e595(%rip), %rdx # 0x1cc0cc
movq %rbx, %rdi
movl $0xc, %esi
xorl ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
add_pax_attr_time | static void
add_pax_attr_time(struct archive_string *as, const char *key,
int64_t sec, unsigned long nanos)
{
int digit, i;
char *t;
/*
* Note that each byte contributes fewer than 3 base-10
* digits, so this will always be big enough.
*/
char tmp[1 + 3*sizeof(sec) + 1 + 3*sizeof(nanos)];
tmp[sizeof(tmp... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x31(%rsp), %r15
movb $0x0, (%r15)
movl $0xb, %r10d
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rsi
decl %r10d
movq %r8, %rax
mulq %rdi
movq %rdx, %r8
shrq $0x3, %r8
leaq (%... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
build_gnu_sparse_name | static char *
build_gnu_sparse_name(char *dest, const char *src)
{
const char *p;
/* Handle the null filename case. */
if (src == NULL || *src == '\0') {
strcpy(dest, "GNUSparseFile/blank");
return (dest);
}
/* Prune final '/' and other unwanted final elements. */
p = src + strlen(src);
for (;;) {
/* End... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x17e14c
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x17e14c
movq %r14, %rdi
callq 0x14520
movq %rax, %rdx
testq %rax, %rax
jle 0x17e119
leaq -0x1(%rdx), %rax
cmpb $0x2f, -0x1(%r14,%rdx)
je 0x17e105
cmpq $0x2, %rdx
jl 0x17e133
cmpb $0x2e, -0x1(%r14,%rdx)
jn... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
archive_write_pax_header_xattrs | static int
archive_write_pax_header_xattrs(struct archive_write *a,
struct pax *pax, struct archive_entry *entry)
{
int i = archive_entry_xattr_reset(entry);
while (i--) {
const char *name;
const void *value;
char *url_encoded_name = NULL, *encoded_name = NULL;
size_t size;
int r;
archive_entry_xatt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, 0x48(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdx, %rdi
callq 0x123923
movl %eax, %ebp
leaq 0x10(%rbx), %rax
movq %rax, 0x50(%rsp)
movq %rbx, 0x18(%rsp)
leaq 0x28(%rbx), %rax
movq %rax, 0x40(%rsp)
leaq 0x44650(%rip), ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
add_pax_attr_binary | static void
add_pax_attr_binary(struct archive_string *as, const char *key,
const char *value, size_t value_len)
{
int digits, i, len, next_ten;
char tmp[1 + 3 * sizeof(int)]; /* < 3 base-10 digits per byte */
/*-
* PAX attributes have the following layout:
* <len> <space> <key> <=> <value> <nl>
*/
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x14520
leal (%r14,%rax), %ecx
addl $0x3, %ecx
testl %ecx, %ecx
jle 0x17e710
xorl %eax, %eax
movl $0x1, %edx
movl $0xcccccccd, %esi # imm = 0xCCCCCCCD
movl %ecx, %edi
... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_pax.c |
archive_write_set_format_raw | int
archive_write_set_format_raw(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct raw *raw;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW, "archive_write_set_format_raw");
/* If someone else was already registered, unregister them. */
if (a->format_free != ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5c9c4(%rip), %rcx # 0x1db210
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x1, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x17e914
movq 0x138(%rbx), %rax
testq %rax, %rax
je 0x17e87a
movq %rbx, %rdi
callq ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_raw.c |
archive_write_shar_header | static int
archive_write_shar_header(struct archive_write *a, struct archive_entry *entry)
{
const char *linkname;
const char *name;
char *p, *pp;
struct shar *shar;
shar = (struct shar *)a->format_data;
if (!shar->wrote_header) {
archive_strcat(&shar->work, "#!/bin/sh\n");
archive_strcat(&shar->work, "# Thi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0xf8(%rdi), %r15
cmpl $0x0, 0x58(%r15)
jne 0x17eae3
leaq 0x60(%r15), %rbx
leaq 0x5c805(%rip), %rsi # 0x1db2c9
movq %rbx, %rdi
callq 0x15d9d9
leaq 0x23f16(%rip), %rsi # 0x1a29e9
movq %rbx,... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_shar.c |
_archive_write_format_header_ustar | int
__archive_write_format_header_ustar(struct archive_write *a, char h[512],
struct archive_entry *entry, int tartype, int strict,
struct archive_string_conv *sconv)
{
unsigned int checksum;
int i, r, ret;
size_t copy_length;
const char *p, *pp;
int mytartype;
ret = 0;
mytartype = -1;
/*
* The "temp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbp
movl %r8d, %r15d
movl %ecx, 0x24(%rsp)
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
leaq 0x5b9cb(%rip), %rsi # 0x1db4b0
movl $0x200, %edx # imm = 0x200
movq %rbx, %rdi
callq 0x140a0
leaq 0x38(%rsp), ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_ustar.c |
format_octal | static int
format_octal(int64_t v, char *p, int s)
{
int len;
len = s;
/* 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. */
while (s-- > 0) {
*--p = (char)('0' + (v & 7));
v >>= 3;
}
if (v ==... | pushq %rbx
testq %rdi, %rdi
js 0x1802ed
movslq %edx, %rax
addq %rax, %rsi
testl %eax, %eax
jle 0x1802d3
leal 0x1(%rdx), %eax
movl %edi, %ecx
andb $0x7, %cl
orb $0x30, %cl
movb %cl, -0x1(%rsi)
decq %rsi
shrq $0x3, %rdi
decl %eax
cmpl $0x1, %eax
jg 0x1802ba
testq %rdi, %rdi
je 0x180307
movl $0xffffffff, %ebx # imm ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_ustar.c |
file_create_virtual_dir | static struct file *
file_create_virtual_dir(struct archive_write *a, struct xar *xar,
const char *pathname)
{
struct file *file;
(void)xar; /* UNUSED */
file = file_new(a, NULL);
if (file == NULL)
return (NULL);
archive_entry_set_pathname(file->entry, pathname);
archive_entry_set_mode(file->entry, 0555 |... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1833e6
testq %rax, %rax
je 0x181467
movq %rax, %rbx
movq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0x12287e
movq 0x20(%rbx), %rdi
movl $0x416d, %esi # imm = 0x416D
callq 0x1227ec
orb $0x3, 0x168(%rbx)
movq %rbx, %r15
movq ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
xar_close | static int
xar_close(struct archive_write *a)
{
struct xar *xar;
unsigned char *wb;
uint64_t length;
int r;
xar = (struct xar *)a->format_data;
/* Empty! */
if (xar->root->children.first == NULL)
return (ARCHIVE_OK);
/* Save the length of all file extended attributes and contents. */
length = xar->temp_of... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0xf8(%rdi), %rbx
movq 0x18(%rbx), %rax
cmpq $0x0, 0x60(%rax)
je 0x18241d
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0x101b8(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127550
testq %rax, ... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
file_new | static struct file *
file_new(struct archive_write *a, struct archive_entry *entry)
{
struct file *file;
static const struct archive_rb_tree_ops rb_ops = {
file_cmp_node, file_cmp_key
};
file = calloc(1, sizeof(*file));
if (file == NULL)
return (NULL);
if (entry != NULL)
file->entry = archive_entry_clone(... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x170, %esi # imm = 0x170
callq 0x14be0
testq %rax, %rax
je 0x1834bc
movq %rax, %rbx
testq %r14, %r14
je 0x18341b
movq %r14, %rdi
callq 0x1212b0
jmp 0x183423
movq %r15, %rdi
callq 0x1214ed
movq %rax, 0x20(%rbx)
testq %rax,... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
file_free | static void
file_free(struct file *file)
{
struct heap_data *heap, *next_heap;
heap = file->xattr.first;
while (heap != NULL) {
next_heap = heap->next;
free(heap);
heap = next_heap;
}
archive_string_free(&(file->parentdir));
archive_string_free(&(file->basename));
archive_string_free(&(file->symlink));
a... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc0(%rdi), %rdi
testq %rdi, %rdi
je 0x1838ec
movq 0x8(%rdi), %r14
callq 0x14220
movq %r14, %rdi
testq %r14, %r14
jne 0x1838db
leaq 0x70(%rbx), %rdi
callq 0x15d886
leaq 0x88(%rbx), %rdi
callq 0x15d886
leaq 0xa0(%rbx), %rdi
callq 0x15d886
leaq 0x150(%rbx), %rdi
callq... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
xmlwrite_string | static int
xmlwrite_string(struct archive_write *a, struct xml_writer *writer,
const char *key, const char *value)
{
int r;
if (value == NULL)
return (ARCHIVE_OK);
r = xml_writer_start_element(writer, key);
if (r < 0) {
archive_set_error(&a->archive,
ARCHIVE_ERRNO_MISC,
"xml_writer_start_element(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x18475d
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdx, %rsi
callq 0x14820
testl %eax, %eax
js 0x184737
movq (%r14), %rdi
movq %r15, %rsi
callq 0x14920
testl %eax, %eax
js 0x184740
movq (%r14), %rdi
... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
xmlwrite_fstring | static int
xmlwrite_fstring(struct archive_write *a, struct xml_writer *writer,
const char *key, const char *fmt, ...)
{
struct xar *xar;
va_list ap;
xar = (struct xar *)a->format_data;
va_start(ap, fmt);
archive_string_empty(&xar->vstr);
archive_string_vsprintf(&xar->vstr, fmt, ap);
va_end(ap);
return (xmlwr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rsp), %rsi
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1847c9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
xmlwrite_heap | static int
xmlwrite_heap(struct archive_write *a, struct xml_writer *writer,
struct heap_data *heap)
{
const char *encname;
int r;
r = xmlwrite_fstring(a, writer, "length", "%ju", heap->length);
if (r < 0)
return (ARCHIVE_FATAL);
r = xmlwrite_fstring(a, writer, "offset", "%ju", heap->temp_offset);
if (r < 0)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdx), %r8
leaq 0x4a3a2(%rip), %rdx # 0x1cee5c
leaq 0x492c2(%rip), %rcx # 0x1cdd83
xorl %eax, %eax
callq 0x18476a
movl $0xffffffe2, %ebp # imm = 0xFFFFFFE2
testl %eax, %eax
js 0x184b9c
movq 0x1... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_xar.c |
archive_write_zip_set_compression_deflate | int
archive_write_zip_set_compression_deflate(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
int ret = ARCHIVE_FAILED;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_write_zip_set_compression_deflate");
if (a->ar... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x5710f(%rip), %rcx # 0x1dbdd0
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x7, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x184d0f
cmpl $0x50000, 0x10(%r14) # imm = 0x50000
jne 0x184cf9
movq 0xf8(%r14),... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_zip.c |
archive_write_zip_set_compression_store | int
archive_write_zip_set_compression_store(struct archive *_a)
{
struct archive_write *a = (struct archive_write *)_a;
struct zip *zip = a->format_data;
int ret = ARCHIVE_FAILED;
archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
ARCHIVE_STATE_NEW | ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA,
"archive_write_zip_set_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xf8(%rdi), %r15
leaq 0x571aa(%rip), %rcx # 0x1dc00b
movl $0xb0c5c0de, %esi # imm = 0xB0C5C0DE
movl $0x7, %edx
callq 0x18d4b2
movl $0xffffffe2, %ebx # imm = 0xFFFFFFE2
cmpl $-0x1e, %eax
je 0x184ea9
cmpl $0x50000, 0x10(%r14) # imm = 0x50000
jne 0x1... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_zip.c |
cd_alloc | static unsigned char *
cd_alloc(struct zip *zip, size_t length)
{
unsigned char *p;
if (zip->central_directory == NULL
|| (zip->central_directory_last->p + length
> zip->central_directory_last->buff + zip->central_directory_last->buff_size)) {
struct cd_segment *segment = calloc(1, sizeof(*segment));
if (... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe8(%rdi), %r12
testq %r12, %r12
je 0x187e50
movq 0xf0(%r14), %rax
movq 0x18(%rax), %rcx
addq %rbx, %rcx
movq 0x10(%rax), %rdx
addq 0x8(%rax), %rdx
cmpq %rdx, %rcx
jbe 0x187eb3
movl $0x1, %edi
movl $0x20, %esi
callq 0x14be0
tes... | /mmatuska[P]libarchive/libarchive/archive_write_set_format_zip.c |
_archive_create_child | int
__archive_create_child(const char *cmd, int *child_stdin, int *child_stdout,
pid_t *out_child)
{
pid_t child = -1;
int stdin_pipe[2], stdout_pipe[2], tmp;
#if HAVE_POSIX_SPAWNP
posix_spawn_file_actions_t actions;
int r;
#endif
struct archive_cmdline *cmdline;
cmdline = __archive_cmdline_allocate();
if (cm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
callq 0x120e72
movq %rax, %rbx
testq %rax, %rax
je 0x1883b5
movq %rbx, %rdi
movq %r13, %rsi
callq 0x120c09
testl %eax, %eax
j... | /mmatuska[P]libarchive/libarchive/filter_fork_posix.c |
blake2s_init_param | int blake2s_init_param( blake2s_state *S, const blake2s_param *P )
{
const unsigned char *p = ( const unsigned char * )( P );
size_t i;
blake2s_init0( S );
/* IV XOR ParamBlock */
for( i = 0; i < 8; ++i )
S->h[i] ^= load32( &p[i * 4] );
S->outlen = P->digest_length;
return 0;
} | xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x80(%rdi)
movaps 0x53a85(%rip), %xmm0 # 0x1dc2e0
movups %xmm0, (%rdi)
movaps 0x53a8b(%rip), %xmm0 # 0x1dc2f0
movups %xmm0, 0x10(%rdi)... | /mmatuska[P]libarchive/libarchive/archive_blake2s_ref.c |
blake2s_compress | static void blake2s_compress( blake2s_state *S, const uint8_t in[BLAKE2S_BLOCKBYTES] )
{
uint32_t m[16];
uint32_t v[16];
size_t i;
for( i = 0; i < 16; ++i ) {
m[i] = load32( in + i * sizeof( m[i] ) );
}
for( i = 0; i < 8; ++i ) {
v[i] = S->h[i];
}
v[ 8] = blake2s_IV[0];
v[ 9] = blake2s_IV[1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, -0x10(%rsp,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0x188959
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, -0x70(%rsp)
movaps %xmm0, -0x80(%rsp)
movaps 0x5394f(%rip), %xmm0 ... | /mmatuska[P]libarchive/libarchive/archive_blake2s_ref.c |
archive_acl_text_len | static size_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;
size_t length;
size_t len;
count = 0;
length = 0;
for (ap = a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movl %esi, %r14d
movq 0x8(%rdi), %r15
xorl %eax, %eax
testq %r15, %r15
je 0x18b105
testb $0x4, %bpl
sete %al
testl $0x300, %r14d # imm = 0x300
sete ... | /mmatuska[P]libarchive/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, 0x58(%rsp)
movl $0x5, 0x50(%rsp)
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $0x2ff, %edx # imm = 0x2FF
jg 0x18bbb8
cmpl $0x100, %edx # imm = 0x100
je 0x18bbdb
cmpl $0x200, %edx ... | /mmatuska[P]libarchive/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0xdeb0c4, %eax # imm = 0xDEB0C4
jle 0x18d4f6
cmpl $0xcad11c9, %eax # imm = 0xCAD11C9
je 0x18d511
cmpl $0xbadb0c5, %eax # imm = 0xBADB0C5
je 0x1... | /mmatuska[P]libarchive/libarchive/archive_check_magic.c |
write_all_states | static void
write_all_states(char *buff, unsigned int states)
{
unsigned int lowbit;
*buff = '\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(buff, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x0, (%rdi)
movl %esi, %ebp
negl %ebp
andl %esi, %ebp
je 0x18d6e4
movl %esi, %ebx
movq %rdi, %r14
leaq 0x43be0(%rip), %r15 # 0x1d123c
leaq 0x4f1de(%rip), %r12 # 0x1dc841
leaq 0x4f1de(%rip), %r13 # 0x1dc848
cmpl $0xf, %ebp
jg ... | /mmatuska[P]libarchive/libarchive/archive_check_magic.c |
_hmac_sha1_init | static int
__hmac_sha1_init(archive_hmac_sha1_ctx *ctx, const uint8_t *key, size_t key_len)
{
#if OPENSSL_VERSION_NUMBER >= 0x30000000L
EVP_MAC *mac;
char sha1[] = "SHA1";
OSSL_PARAM params[] = {
OSSL_PARAM_utf8_string("digest", sha1, sizeof(sha1) - 1),
OSSL_PARAM_END
};
mac = EVP_MAC_fetch(NULL, "HMAC", NUL... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rsp), %rax
movb $0x0, 0x4(%rax)
movl $0x31414853, (%rax) # imm = 0x31414853
leaq 0x4ce5f(%rip), %rcx # 0x1da7ab
movq %rcx, 0x10(%rsp)
movl $0x4, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq... | /mmatuska[P]libarchive/libarchive/archive_hmac.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
xorl %ecx, %ecx
movq %rdx, %rax
orq %r14, %rax
movl $0xffffffe7, %eax # imm = 0xFFFFFFE7
cmovel %ecx, %eax
testq %rdx, %rdx
je 0x18dbc1
movq %r9, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r14, %rcx
callq ... | /mmatuska[P]libarchive/libarchive/archive_options.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 * ... | movq %rdi, %rax
movq (%rdi), %rcx
movzbl (%rcx), %edi
cmpl $0xff, %edi
je 0x18e58f
movzbl 0x35a(%rdi,%rax), %r8d
addl $-0x3, %r8d
shlq $0x7, %r8
addq %rax, %r8
movzwl 0x2(%rcx), %r9d
leal (%rdi,%rdi,4), %r10d
leal (%rdi,%r10,2), %r10d
addl $0xb, %r10d
xorl %r11d, %r11d
cmpl %r9d, %r10d
setb %r11b
leaq (%r8,%r11,4), %r8... | /mmatuska[P]libarchive/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 %rbx
movq %rsi, %rbx
decl %edx
movzbl 0xa6(%rdi,%rdx), %edx
leal -0x1(%rcx), %eax
movzbl 0xa6(%rdi,%rax), %eax
cmpb %al, %dl
je 0x18f44d
cmpl $0x0, 0x128(%rdi,%rax,4)
je 0x18f443
movq 0x38(%rdi), %rsi
movl %eax, %r8d
movl 0x128(%rdi,%r8,4), %r9d
leaq (%rsi,%r9), %rax
movl 0x4(%rsi,%r9), %r9d
movl %r9d, 0x128(%rdi... | /mmatuska[P]libarchive/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 %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movl 0x60(%rdi), %eax
addq 0x38(%rdi), %rax
movq %rax, 0x50(%rdi)
movq 0x8(%rdi), %r14
cmpq %rsi, %r14
je 0x18f883
movq %rsi, %r15
movb (%r14), %al
decb %al
movb %al, (%r14)
je 0x18f79e
movzbl %al, %edx
addl $0x3, %edx
shrl %edx
movq %rbx, %rdi
movq %r14... | /mmatuska[P]libarchive/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rsi), %r13d
movq 0x38(%rdi), %rsi
testl %r13d, %r13d
je 0x18fdc8
movl 0x4(%rbx), %ecx
leaq (%rsi,%rcx), %rdx
leal 0x2(%r13), %eax
shrl %eax
movq %rax, 0x10(%rsp)
leal -0x1(%rax), ... | /mmatuska[P]libarchive/libarchive/archive_ppmd8.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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %r8d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
movzwl (%r12), %ebp
cmpl $0x1, %ebp
movl %edx, 0x8(%rsp)
jne 0x19084e
movzbl 0x3(%r12), %eax
shll $0x7, %eax
movq 0x40(%rbx), %rcx
movl 0x8(%r12)... | /mmatuska[P]libarchive/libarchive/archive_ppmd7.c |
Ppmd7_MakeEscFreq | static CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)
{
CPpmd_See *see;
unsigned nonMasked = p->MinContext->NumStats - numMasked;
if (p->MinContext->NumStats != 256)
{
see = p->See[p->NS2Indx[nonMasked - 1]] +
(nonMasked < (unsigned)SUFFIX(p->MinContext)->NumStats - p->... | movq %rdi, %rax
movq (%rdi), %r8
movzwl (%r8), %edi
cmpl $0x100, %edi # imm = 0x100
jne 0x190ec2
addq $0x4ac, %rax # imm = 0x4AC
movl $0x1, %esi
jmp 0x190f45
movl %edi, %ecx
subl %esi, %ecx
leal -0x1(%rcx), %r9d
movzbl 0x1ac(%rax,%r9), %r9d
shll $0x6, %r9d
addq %rax, %r9
movq 0x40(%rax), %r10
movl... | /mmatuska[P]libarchive/libarchive/archive_ppmd7.c |
UpdateModel | static void UpdateModel(CPpmd7 *p)
{
CPpmd_Void_Ref successor, fSuccessor = SUCCESSOR(p->FoundState);
CTX_PTR c;
unsigned s0, ns;
if (p->FoundState->Freq < MAX_FREQ / 4 && p->MinContext->Suffix != 0)
{
c = SUFFIX(p->MinContext);
if (c->NumStats == 1)
{
CPpmd_State *s = ONE_STATE(c);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movl 0x2(%rsi), %ebp
cmpb $0x1e, 0x1(%rsi)
ja 0x191338
movq (%rbx), %rax
movl 0x8(%rax), %eax
testq %rax, %rax
je 0x191338
movq 0x40(%rbx), %rcx
cmpw $0x1, (%rcx,%rax)
jne 0x1912c7
movb 0x3(%rcx,%rax... | /mmatuska[P]libarchive/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 %rbx
movl %esi, %ecx
cmpl $0x0, 0x38(%rdi)
je 0x191954
movl %ecx, %edx
cmpl $0x25, %edx
je 0x191924
incl %edx
movl %edx, %eax
movl 0x114(%rdi,%rax,4), %esi
testq %rsi, %rsi
je 0x1918ef
movq 0x40(%rdi), %r8
leaq (%r8,%rsi), %rbx
movl (%r8,%rsi), %esi
movl %esi, 0x114(%rdi,%rax,4)
movq %rbx, %rsi
callq 0x19120f
jmp... | /mmatuska[P]libarchive/libarchive/archive_ppmd7.c |
Catch::Detail::Approx::toString[abi:cxx11]() const | std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70c4a(%rip), %rax # 0x834e8
movq %rax, 0x28(%rsp)
callq 0x539a2
leaq 0x8(%rax), %rdi
callq 0x379ea
movq %rax, %r14
movq %rax, 0x30(%rsp)
callq 0x539a2
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %r14
movq %r14, 0x38(%rsp)
leaq 0x4... | /diatomic[P]diy/tests/catch.hpp |
Catch::Detail::Approx::setEpsilon(double) | void Approx::setEpsilon(double newEpsilon) {
CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
"Invalid Approx::epsilon: " << newEpsilon << '.'
<< " Approx::epsilon has to be in [0, 1]");
m_epsilon = newEpsilon;
} | pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x12b43
movsd 0x4b5bd(%rip), %xmm1 # 0x5e0f0
ucomisd %xmm0, %xmm1
jb 0x12b43
movsd %xmm0, (%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, (%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x23fa6
movq 0x10(%rbx), %rbx
leaq 0x4cc15(%rip), %rs... | /diatomic[P]diy/tests/catch.hpp |
Catch::operator<<(std::ostream&, Catch::LazyExpression const&) | auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
if( lazyExpr.m_isNegated )
os << "!";
if( lazyExpr ) {
if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
os << "(" << *lazyExpr.m_transientEx... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x12ca8
leaq 0x4d67a(%rip), %rsi # 0x60315
movl $0x1, %edx
movq %rbx, %rdi
callq 0x11630
movq (%r14), %rdi
testq %rdi, %rdi
je 0x12cf4
cmpb $0x1, 0x8(%r14)
jne 0x12cea
cmpb $0x1, 0x8(%rdi)
jne 0x12cea
leaq 0x4db28(%rip), %rsi ... | /diatomic[P]diy/tests/catch.hpp |
Catch::AssertionHandler::allowThrows() const | auto AssertionHandler::allowThrows() const -> bool {
return getCurrentContext().getConfig()->allowThrows();
} | pushq %rax
movq 0x74b80(%rip), %rdi # 0x87a00
testq %rdi, %rdi
je 0x12e8a
movq (%rdi), %rax
jmp 0x12ebe
movl $0x30, %edi
callq 0x11530
movq %rax, %rdi
leaq 0x6ffc2(%rip), %rax # 0x82e60
movq %rax, (%rdi)
leaq 0x70008(%rip), %rcx # 0x82eb0
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movu... | /diatomic[P]diy/tests/catch.hpp |
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef const&) | void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString ) {
handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x1319b
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x130d5
leaq 0x700b8(%rip), %rax # 0x83100
leaq 0x70(%rsp), %rcx
movq %rax, -0x68(%rcx)
leaq 0x700d0(%rip), %rax ... | /diatomic[P]diy/tests/catch.hpp |
Catch::Matchers::Equals(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl %edx, -0x8(%rdi)
movq %rsp, %r14
movq %r14, %rsi
movq %rax, %rdx
callq 0x1de3c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e148
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x131e4
movq 0x18(%rsp), %rsi
incq... | /diatomic[P]diy/tests/catch.hpp |
Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const | std::string AssertionResult::getExpressionInMacro() const {
std::string expr;
if( m_info.macroName.empty() )
expr = static_cast<std::string>(m_info.capturedExpression);
else {
expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
expr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x13564
movq 0x28(%r14), %rcx
leaq (%rax,%rcx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x118a0
movq... | /diatomic[P]diy/tests/catch.hpp |
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const | std::string AssertionResult::getExpandedExpression() const {
std::string expr = m_resultData.reconstructExpression();
return expr.empty()
? getExpression()
: expr;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x13244
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x136e1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x42364
jmp 0x136ec
movq %rbx,... | /diatomic[P]diy/tests/catch.hpp |
Catch::Config::Config(Catch::ConfigData const&) | Config::Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
// We need to trim filter specs to avoid trouble with superfluous
// whitespace (esp. important for bdd macros, as those are manually
// aligned with whitespace).
for (auto& elem : m_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
leaq 0x694d9(%rip), %rax # 0x82d80
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x364a8
movq 0x68(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq 0x70(%rbx), %rax
mov... | /diatomic[P]diy/tests/catch.hpp |
Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( sta... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x468c1(%rip), %r12 # 0x60469
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x11940
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x118e0
cmpq $-0x1, %r15
je 0... | /diatomic[P]diy/tests/catch.hpp |
Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
m_mode = None;
m_exclusion = false;
m_arg = m_tagAliases->expandAliases( arg );
m_escapeChars.clear();
m_substring.reserve(m_arg.size());
m_patternName.reserve(m_arg.size());
m_realPatternPos = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0xe0(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rax)
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x116c0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
c... | /diatomic[P]diy/tests/catch.hpp |
Catch::(anonymous namespace)::platformColourInstance() | ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x11080
movq %rax, %rbx
movl (%rax), %ebp
movq 0x6d7ee(%rip), %rdi # 0x87a00
testq %rdi, %rdi
je 0x1a21c
movq (%rdi), %rax
jmp 0x1a250
movl $0x30, %edi
callq 0x11530
movq %rax, %rdi
leaq 0x68c30(%rip), %rax # 0x82e60
movq %rax, (%rdi)
leaq 0x68c76(%ri... | /diatomic[P]diy/tests/catch.hpp |
Catch::formatReconstructedExpression(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
if( lhs.size() + rhs.size() < 40 &&
lhs.find('\n') == std::string::npos &&
rhs.find('\n') == std::string::npos )
os << lhs << " " << op << " " << rhs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r13
movq 0x8(%rsi), %rdx
movq 0x8(%r8), %rax
addq %rdx, %rax
leaq 0x46201(%rip), %r12 # 0x607ab
cmpq $0x27, %rax
ja 0x1a5f4
movq %rbp, %rdi
movl $0xa, %esi
xorl %ed... | /diatomic[P]diy/tests/catch.hpp |
Catch::Detail::parseEnums(Catch::StringRef) | std::vector<StringRef> parseEnums( StringRef enums ) {
auto enumValues = splitStringRef( enums, ',' );
std::vector<StringRef> parsed;
parsed.reserve( enumValues.size() );
for( auto const& enumValue : enumValues ) {
parsed.push_back(trim(extractInstanceName... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movl $0x2c, %ecx
callq 0x1a7e5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x3683a
movq (%rsp)... | /diatomic[P]diy/tests/catch.hpp |
Catch::splitStringRef(Catch::StringRef, char) | std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
std::vector<StringRef> subStrings;
std::size_t start = 0;
for(std::size_t pos = 0; pos < str.size(); ++pos ) {
if( str[pos] == delimiter ) {
if( pos - start > 1 )
subStrings.p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1a896
movl %ecx, %ebp
leaq 0x456a7(%rip), %r12 # 0x5fec3
xorl %r13d, %r13d
xorl %eax, %eax
cmpb %bpl,... | /diatomic[P]diy/tests/catch.hpp |
Catch::ExceptionTranslatorRegistry::registerTranslator(Catch::IExceptionTranslator const*) | void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
} | pushq %rbx
subq $0x10, %rsp
addq $0x8, %rdi
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x448ea
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1abed
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ac06
movq (%rdi), %rax
callq *0... | /diatomic[P]diy/tests/catch.hpp |
Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const | std::string ExceptionTranslatorRegistry::translateActiveException() const {
try {
#ifdef __OBJC__
// In Objective-C try objective-c exceptions first
@try {
return tryTranslators();
}
@catch (NSException *exception) {
return Catch::D... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x115f0
cmpq $0x0, (%r15)
je 0x1ac43
movq %rsp, %rdi
callq 0x11470
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ad78
jmp 0x1ac60
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x45291(%rip), %rsi # 0x5f... | /diatomic[P]diy/tests/catch.hpp |
Catch::handleSignal(int) | static void handleSignal( int sig ) {
char const * name = "<unknown signal>";
for (auto const& def : signalDefs) {
if (sig == def.id) {
name = def.name;
break;
}
}
// We need to restore previous signal handlers and let them do
... | pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movl $0x8, %eax
leaq 0x67fe2(%rip), %rcx # 0x82ef0
leaq 0x45d7a(%rip), %r14 # 0x60c8f
cmpl %ebx, -0x8(%rax,%rcx)
je 0x1af27
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x1af15
jmp 0x1af2b
movq (%rax,%rcx), %r14
callq 0x1afa0
movq 0x6cac9(%rip), %rdi # 0x87a00
testq... | /diatomic[P]diy/tests/catch.hpp |
Catch::ReporterConfig::ReporterConfig(std::shared_ptr<Catch::IConfig const> const&) | ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
: m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, (%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1b077
movq 0x6bf27(%rip), %rcx # 0x86f90
cmpb $0x0, (%rcx)
je 0x1b073
incl ... | /diatomic[P]diy/tests/catch.hpp |
Catch::ReporterConfig::ReporterConfig(std::shared_ptr<Catch::IConfig const> const&, std::ostream&) | ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
: m_stream( &_stream ), m_fullConfig( _fullConfig ) {} | movq %rdx, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x1b0ab
movq 0x6bef2(%rip), %rcx # 0x86f90
cmpb $0x0, (%rcx)
je 0x1b0a7
incl 0x8(%rax)
retq
lock
incl 0x8(%rax)
retq
| /diatomic[P]diy/tests/catch.hpp |
Catch::ReporterConfig::fullConfig() const | IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; } | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x1b0db
movq 0x6bec2(%rip), %rdx # 0x86f90
cmpb $0x0, (%rdx)
je 0x1b0d7
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /diatomic[P]diy/tests/catch.hpp |
Catch::GroupInfo::GroupInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | GroupInfo::GroupInfo( std::string const& _name,
std::size_t _groupIndex,
std::size_t _groupsCount )
: name( _name ),
groupIndex( _groupIndex ),
groupsCounts( _groupsCount )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x42364
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| /diatomic[P]diy/tests/catch.hpp |
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&) | AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x67e10(%rip), %rax # 0x82f60
movq %rax, (%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%r... | /diatomic[P]diy/tests/catch.hpp |
Catch::AssertionStats::~AssertionStats() | AssertionStats::~AssertionStats() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x67b53(%rip), %rax # 0x82f60
movq %rax, (%rdi)
addq $0x98, %rdi
callq 0x36b62
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x1b434
movq (%rax), %rsi
incq %rsi
callq 0x11560
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x1b44d
movq (%rbx), %rsi
incq %rs... | /diatomic[P]diy/tests/catch.hpp |
Catch::TestRunStats::TestRunStats(Catch::TestRunInfo const&, Catch::Totals const&, bool) | TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
Totals const& _totals,
bool _aborting )
: runInfo( _runInfo ),
totals( _totals ),
aborting( _aborting )
{} | pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x6775c(%rip), %rax # 0x82fe0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r15), %rax
movq %rax, 0x8(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x42364
movq 0x30(%r14), %rax
movq %rax, 0x58(... | /diatomic[P]diy/tests/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() = default; | movq %rdi, %rax
leaq 0x67702(%rip), %rcx # 0x82fe0
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x1b8f9
movq (%rax), %rsi
incq %rsi
jmp 0x11560
retq
| /diatomic[P]diy/tests/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x676db(%rip), %rax # 0x82fe0
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x1b920
movq (%rax), %rsi
incq %rsi
callq 0x11560
movl $0x68, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x11560
| /diatomic[P]diy/tests/catch.hpp |
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.