name string | code string | asm string | file string |
|---|---|---|---|
doctest::(anonymous namespace)::XmlWriter::~XmlWriter() | XmlWriter::~XmlWriter() {
while( !m_tags.empty() )
endElement();
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0xee80
movq %rbx, %rdi
callq 0xdb08
jmp 0xee6c
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xee98
movq (%rax), %rsi
incq %rsi
callq 0x4370
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x15362
movq %rax, %rdi
callq 0x135db
| /ad65537[P]moptional/include/doctest.h |
doctest::IReporter* doctest::detail::reporterCreator<doctest::(anonymous namespace)::JUnitReporter>(doctest::ContextOptions const&) | IReporter* reporterCreator(const ContextOptions& o) {
return new Reporter(o);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xd0, %edi
callq 0x4350
movq %rax, %rbx
leaq 0x11d30(%rip), %rax # 0x20bf8
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0xb67c
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rb... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_case_start(doctest::TestCaseData const&) | void test_case_start(const TestCaseData& in) override {
testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
timer.start();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x17(%rsi)
movq %rsi, %rdi
jns 0xf939
movq (%r14), %rdi
callq 0x5a4a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x1359e
movq 0x20(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x1359e
leaq 0x98(%rbx), %... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::JUnitReporter::test_case_reenter(doctest::TestCaseData const&) | void test_case_reenter(const TestCaseData& in) override {
testCaseData.addTime(timer.getElapsedSeconds());
testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
deepestSubcaseStackNames.clear();
timer.start();
testCaseData.add(skipPathFromF... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x98(%rdi), %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x44f0
imulq $0xf4240, (%r12), %rax # imm = 0xF4240
addq 0x8(%r12), %rax
subq 0x78(%r15), %rax
movq %rax, %xmm0
punpckldq 0x777d(%rip)... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::report_query(doctest::QueryData const&) | void report_query(const QueryData& in) override {
if(opt.version) {
printVersion();
} else if(opt.help) {
printHelp();
} else if(opt.list_reporters) {
printRegisteredReporters();
} else if(opt.count || opt.list_test_cases) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
cmpb $0x1, 0x87(%rax)
jne 0x1137d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12e5a
cmpb $0x1, 0x86(%rax)
jne 0x11d2d
movq %rbx, %rdi
callq 0x12e5a
mov... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_run_start() | void test_run_end(const TestRunStats& p) override {
separator_to_stream();
s << std::dec;
auto totwidth = int(std::ceil(log10((std::max(p.numTestCasesPassingFilters, static_cast<unsigned>(p.numAsserts))) + 1)));
auto passwidth = int(std::ceil(log10((std::max(p.numTestCas... | pushq %rbx
movq %rdi, %rbx
callq 0x12e5a
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x55bc
leaq 0x6920(%rip), %rsi # 0x18a21
movl $0xa, %edx
movq %rbx, %rdi
callq 0x43b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x55bc
leaq 0x6ea1(%rip), %rsi # 0x18fc0
movl $0x1e, %edx
movq %rbx, %rdi
popq %rbx
jm... | /ad65537[P]moptional/include/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::test_case_exception(doctest::TestCaseException const&) | void test_case_exception(const TestCaseException& e) override {
if(tc->m_no_output)
return;
logTestStart();
file_line_to_stream(tc->m_file.c_str(), tc->m_line, " ");
successOrFailColoredStringToStream(false, e.is_crash ? assertType::is_require :
... | movq 0x68(%rdi), %rax
cmpb $0x0, 0x3a(%rax)
je 0x128df
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13048
movq (%rbx), %rax
movq 0x68(%rbx), %rcx
cmpb $0x0, 0x17(%rcx)
movq %rcx, %rsi
jns 0x12908
movq (%rcx), %rsi
movl 0x18(%rcx), %edx
leaq 0x... | /ad65537[P]moptional/include/doctest.h |
doctest::detail::ContextState::finalizeTestCaseData() | void finalizeTestCaseData() {
seconds = timer.getElapsedSeconds();
// update the non-atomic counters
numAsserts += numAssertsCurrentTest_atomic;
numAssertsFailed += numAssertsFailedCurrentTest_atomic;
numAssertsCurrentTest = numAssertsCurrentTest_atomic... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x44f0
imulq $0xf4240, (%r14), %rax # imm = 0xF4240
addq 0x8(%r14), %rax
subq 0x10f8(%rbx), %rax
movq %rax, %xmm0
punpckldq 0x3a37(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1... | /ad65537[P]moptional/include/doctest.h |
kwsysProcessKill | static void kwsysProcessKill(pid_t process_id)
{
#if defined(__linux__) || defined(__CYGWIN__)
DIR* procdir;
#endif
/* Suspend the process to be sure it will not create more children. */
kill(process_id, SIGSTOP);
#if defined(__CYGWIN__)
/* Some Cygwin versions seem to need help here. Give up our time slice... | pushq %rbp
movq %rsp, %rbp
subq $0x14f0, %rsp # imm = 0x14F0
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x13, %esi
callq 0x11610
leaq 0x268972(%rip), %rdi # 0x2afec4
callq 0x10ec0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x476f2
movq -0x10(%rbp), %rdi
callq 0x11330
movq %rax, -0x1428(%rbp)
cmpq $0x... | /JKorbelRA[P]CMake/Source/kwsys/ProcessUNIX.c |
archive_entry_pathname_utf8 | const char *
archive_entry_pathname_utf8(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_utf8(
entry->archive, &entry->ae_pathname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x210, %rsi # imm = 0x210
leaq -0x18(%rbp), %rdx
callq 0xabd30
cmpl $0x0, %eax
jne 0x5cad6
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5caf9
callq 0x11940
cmpl $0xc,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c |
tree_free | static void
tree_free(struct tree *t)
{
int i;
if (t == NULL)
return;
archive_string_free(&t->path);
#if defined(USE_READDIR_R)
free(t->dirent);
#endif
free(t->sparse_list);
for (i = 0; i < t->max_filesystem_id; i++)
free(t->filesystem_table[i].allocation_ptr);
free(t->filesystem_table);
free(t);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6ae05
jmp 0x6ae7b
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0xaaa10
movq -0x8(%rbp), %rax
movq 0x1c8(%rax), %rdi
callq 0x10470
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x200(%rcx), %eax
jge 0x6... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
next_entry | static int
next_entry(struct archive_read_disk *a, struct tree *t,
struct archive_entry *entry)
{
const struct stat *st; /* info to use for this entry */
const struct stat *lst;/* lstat() information */
const char *name;
int delayed, delayed_errno, descend, r;
struct archive_string delayed_str;
delayed = ARC... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
tree_enter_initial_dir | static int
tree_enter_initial_dir(struct tree *t)
{
int r = 0;
if ((t->flags & onInitialDir) == 0) {
r = fchdir(t->initial_dir_fd);
if (r == 0) {
t->flags &= ~onWorkingDir;
t->flags |= onInitialDir;
}
}
return (r);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
jne 0x6b778
movq -0x8(%rbp), %rax
movl 0x64(%rax), %edi
callq 0x107e0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6b776
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
file_seek | static int64_t
file_seek(struct archive *a, void *client_data, int64_t request, int whence)
{
struct read_file_data *mine = (struct read_file_data *)client_data;
int64_t r;
/* We use off_t here because lseek() is declared that way. */
/* See above for notes about when off_t is less than 64 bits. */
r = lseek(mine... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x10720
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c |
compress_bidder_bid | static int
compress_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *buffer;
ssize_t avail;
int bits_checked;
(void)self; /* UNUSED */
/* Shortest valid compress file is 3 bytes. */
buffer = __archive_read_filter_ahead(filter, 3, &avail);
if (b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3, %esi
leaq -0x28(%rbp), %rdx
callq 0x66750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6e9b6
movl $0x0, -0x4(%rbp)
jmp 0x6ea22
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_compress.c |
archive_read_support_filter_zstd | int
archive_read_support_filter_zstd(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "zstd",
&zstd_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if HAVE_ZSTD_H && HAVE_LIBZSTD
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x24ad46(%rip), %rdx # 0x2be549
leaq 0x2b11fe(%rip), %rcx # 0x324a08
callq 0x665b0
cmpl $0x0, %eax
je 0x7381d
movl $0xffffffe2, -0x4(%rbp) # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_zstd.c |
atol16 | static int64_t
atol16(const char *p, unsigned char_cnt)
{
int64_t l;
int digit;
l = 0;
while (char_cnt-- > 0) {
if (*p >= 'a' && *p <= 'f')
digit = *p - 'a' + 10;
else if (*p >= 'A' && *p <= 'F')
digit = *p - 'A' + 10;
else if (*p >= '0' && *p <= '9')
digit = *p - '0';
else
return (l);
p++;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jbe 0x7d0d9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x7d051
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
find_newc_header | static int
find_newc_header(struct archive_read *a)
{
const void *h;
const char *p, *q;
size_t skip, skipped = 0;
ssize_t bytes;
for (;;) {
h = __archive_read_ahead(a, newc_header_size, &bytes);
if (h == NULL)
return (ARCHIVE_FATAL);
p = h;
q = p + bytes;
/* Try the typical case first, then go into ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x6e, %esi
leaq -0x40(%rbp), %rdx
callq 0x66710
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7d12d
movl $0xffffffe2, -0x4(%rbp) # imm = 0xFFFFFFE2
jmp 0x7d2b1
movq -0x18(%rbp), %rax
movq %rax, -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
record_hardlink | static int
record_hardlink(struct archive_read *a,
struct cpio *cpio, struct archive_entry *entry)
{
struct links_entry *le;
dev_t dev;
int64_t ino;
if (archive_entry_nlink(entry) <= 1)
return (ARCHIVE_OK);
dev = archive_entry_dev(entry);
ino = archive_entry_ino64(entry);
/*
* First look in the l... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5ca10
cmpl $0x1, %eax
ja 0x7d38e
movl $0x0, -0x4(%rbp)
jmp 0x7d586
movq -0x20(%rbp), %rdi
callq 0x5c0a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c970
movq %rax, -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
archive_read_support_format_empty | int
archive_read_support_format_empty(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_empty");
r = __archive_read_register_format(a,
NULL,
"empty",
archive_read_format_e... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x235da7(%rip), %rcx # 0x2b3360
callq 0xe9670
movl %eax, -0x20(%rbp)
cmpl $-0x1e, -0x20(%rbp)
jne 0x7d5d0
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_empty.c |
archive_read_format_iso9660_bid | static int
archive_read_format_iso9660_bid(struct archive_read *a, int best_bid)
{
struct iso9660 *iso9660;
ssize_t bytes_read;
const unsigned char *p;
int seenTerminator;
/* If there's already a better bid than we can ever
make, don't bother testing. */
if (best_bid > 48)
return (-1);
iso9660 = (struct ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x30, -0x14(%rbp)
jle 0x7d891
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7da3f
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xc000, %esi ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_format_iso9660_options | static int
archive_read_format_iso9660_options(struct archive_read *a,
const char *key, const char *val)
{
struct iso9660 *iso9660;
iso9660 = (struct iso9660 *)(a->format->data);
if (strcmp(key, "joliet") == 0) {
if (val == NULL || strcmp(val, "off") == 0 ||
strcmp(val, "ignore") == 0 ||
strcmp(val, "d... | 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 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x235a55(%rip), %rsi # 0x2b34d6
callq 0x114f0
cmpl $0x0, %eax
jne 0x7db07
cmpq $0x0, -0x2... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_format_iso9660_read_header | static int
archive_read_format_iso9660_read_header(struct archive_read *a,
struct archive_entry *entry)
{
struct iso9660 *iso9660;
struct file_info *file;
int r, rd_r = ARCHIVE_OK;
iso9660 = (struct iso9660 *)(a->format->data);
if (!a->archive.archive_format) {
a->archive.archive_format = ARCHIVE_FORMAT_IS... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x7dbb0
movq -0x10(%rbp), %rax
movl $0x40000, 0x10(%rax) # imm = 0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_format_iso9660_read_data | static int
archive_read_format_iso9660_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
ssize_t bytes_read;
struct iso9660 *iso9660;
iso9660 = (struct iso9660 *)(a->format->data);
if (iso9660->entry_bytes_unconsumed) {
__archive_read_consume(a, iso9660->entry_bytes_uncon... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0xe0(%rax)
je 0x7e40b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isPVD | static int
isPVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
int32_t location;
int i;
/* Type of the Primary Volume Descriptor must be 1. */
if (h[PVD_type_offset] != 1)
return (0);
/* PVD version must be 1. */
if (h[PVD_versi... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0x7e808
movl $0x0, -0x4(%rbp)
jmp 0x7ea6e
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1, %eax
je 0x7e821
movl $0x0, -0x4(%rbp)
jmp 0x7ea6e
movq -0x18(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isJolietSVD | static int
isJolietSVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
/* Check if current sector is a kind of Supplementary Volume
* Descriptor. */
if (!isSVD(iso9660, h))
return (0);
/* FIXME: do more validations according to jol... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7ee30
cmpl $0x0, %eax
jne 0x7eaae
movl $0x0, -0x4(%rbp)
jmp 0x7ebe7
movq -0x18(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isBootRecord | static int
isBootRecord(struct iso9660 *iso9660, const unsigned char *h)
{
(void)iso9660; /* UNUSED */
/* Type of the Volume Descriptor Boot Record must be 0. */
if (h[0] != 0)
return (0);
/* Volume Descriptor Version must be 1. */
if (h[6] != 1)
return (0);
return (1);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x7ec11
movl $0x0, -0x4(%rbp)
jmp 0x7ec2e
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1, %eax
je 0x7ec27
movl $0x0, -0x4(%rbp)
jmp 0x7ec2e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isEVD | static int
isEVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
int32_t location;
(void)iso9660; /* UNUSED */
/* Type of the Enhanced Volume Descriptor must be 2. */
if (h[PVD_type_offset] != 2)
return (0);
/* EVD version must be... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x7ec68
movl $0x0, -0x4(%rbp)
jmp 0x7ee23
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x2, %eax
je 0x7ec81
movl $0x0, -0x4(%rbp)
jmp 0x7ee23
movq -0x18(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isSVD | static int
isSVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
int32_t location;
(void)iso9660; /* UNUSED */
/* Type 2 means it's a SVD. */
if (h[SVD_type_offset] != 2)
return (0);
/* Reserved field must be 0. */
if (!isNull(is... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x7ee58
movl $0x0, -0x4(%rbp)
jmp 0x7efbc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x48, %edx
movl $0x8, %ecx
callq 0x7f110
cmpl $0x0, %eax
jne 0x7ee80
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isVolumePartition | static int
isVolumePartition(struct iso9660 *iso9660, const unsigned char *h)
{
int32_t location;
/* Type of the Volume Partition Descriptor must be 3. */
if (h[0] != 3)
return (0);
/* Volume Descriptor Version must be 1. */
if (h[6] != 1)
return (0);
/* Unused Field */
if (h[7] != 0)
return (0);
locat... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3, %eax
je 0x7eff8
movl $0x0, -0x4(%rbp)
jmp 0x7f07e
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1, %eax
je 0x7f00e
movl $0x0, -0x4(%rbp)
jmp 0x7f07e
movq -0x18(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isVDSetTerminator | static int
isVDSetTerminator(struct iso9660 *iso9660, const unsigned char *h)
{
(void)iso9660; /* UNUSED */
/* Type of the Volume Descriptor Set Terminator must be 255. */
if (h[0] != 255)
return (0);
/* Volume Descriptor Version must be 1. */
if (h[6] != 1)
return (0);
/* Reserved field must be 0. */
if ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x7f0b7
movl $0x0, -0x4(%rbp)
jmp 0x7f0f9
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x1, %eax
je 0x7f0cd
movl $0x0, -0x4(%rbp)
jmp 0x7f0f9
movq -0x10(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_be32dec | static inline uint32_t
archive_be32dec(const void *pp)
{
unsigned char const *p = (unsigned char const *)pp;
/* Store into unsigned temporaries before left shifting, to avoid
promotion to signed int and then left shifting into the sign bit,
which is undefined behaviour. */
unsigned int p3 = p[3];
unsigned int p2... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_endian.h |
choose_volume | static int
choose_volume(struct archive_read *a, struct iso9660 *iso9660)
{
struct file_info *file;
int64_t skipsize;
struct vd *vd;
const void *block;
char seenJoliet;
vd = &(iso9660->primary);
if (!iso9660->opt_support_joliet)
iso9660->seenJoliet = 0;
if (iso9660->seenJoliet &&
vd->location > iso9660->jo... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xbc, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7f2e0
movq -0x18(%rbp), %rax
movb $0x0, 0x2a(%rax)
movq -0x18(%rbp), %rax
movsbl 0x2a(%rax), %eax
cmpl $0x0, %eax
je ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
next_entry_seek | static int
next_entry_seek(struct archive_read *a, struct iso9660 *iso9660,
struct file_info **pfile)
{
struct file_info *file;
int r;
r = next_cache_entry(a, iso9660, pfile);
if (r != ARCHIVE_OK)
return (r);
file = *pfile;
/* Don't waste time seeking for zero-length bodies. */
if (file->size == 0)
fil... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x814b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x7f5d9
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f69a
movq -0x20... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
build_pathname_utf16be | static int
build_pathname_utf16be(unsigned char *p, size_t max, size_t *len,
struct file_info *file)
{
if (file->parent != NULL && file->parent->utf16be_bytes > 0) {
if (build_pathname_utf16be(p, max, len, file->parent) != 0)
return (-1);
p[*len] = 0;
p[*len + 1] = '/';
*len += 2;
}
if (file->utf16be_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7f73c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0xc8(%rax)
jbe 0x7f73c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
build_pathname | static const char *
build_pathname(struct archive_string *as, struct file_info *file, int depth)
{
// Plain ISO9660 only allows 8 dir levels; if we get
// to 1000, then something is very, very wrong.
if (depth > 1000) {
return NULL;
}
if (file->parent != NULL && archive_strlen(&file->parent->name) > 0) {
if (b... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x3e8, -0x1c(%rbp) # imm = 0x3E8
jle 0x7f839
movq $0x0, -0x8(%rbp)
jmp 0x7f8cc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7f88d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0xb0(%ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
parse_file_info | static struct file_info *
parse_file_info(struct archive_read *a, struct file_info *parent,
const unsigned char *isodirrec, size_t reclen)
{
struct iso9660 *iso9660;
struct file_info *file, *filep;
size_t name_len;
const unsigned char *rr_start, *rr_end;
const unsigned char *p;
size_t dr_len;
uint64_t fsize,... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7f91f
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x68(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
heap_add_entry | static int
heap_add_entry(struct archive_read *a, struct heap_queue *heap,
struct file_info *file, uint64_t key)
{
uint64_t file_key, parent_key;
int hole, parent;
/* Expand our pending files list as necessary. */
if (heap->used >= heap->allocated) {
struct file_info **new_pending_files;
int new_size = hea... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x8034d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movl %eax, -0x4c(%rbp)
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
toi | static unsigned int
toi(const void *p, int n)
{
const unsigned char *v = (const unsigned char *)p;
if (n > 1)
return v[0] + 256 * toi(v + 1, n - 1);
if (n == 1)
return v[0];
return (0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jle 0x80459
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
register_CE | static int
register_CE(struct archive_read *a, int32_t location,
struct file_info *file)
{
struct iso9660 *iso9660;
struct read_ce_queue *heap;
struct read_ce_req *p;
uint64_t offset, parent_offset;
int hole, parent;
iso9660 = (struct iso9660 *)(a->format->data);
offset = ((uint64_t)location) * (uint64_t)is... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rax
movq -0x28(%rbp), %rcx
imulq 0xa8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
isodate17 | static time_t
isodate17(const unsigned char *v)
{
struct tm tm;
int offset;
time_t t;
memset(&tm, 0, sizeof(tm));
tm.tm_year = (v[0] - '0') * 1000 + (v[1] - '0') * 100
+ (v[2] - '0') * 10 + (v[3] - '0')
- 1900;
tm.tm_mon = (v[4] - '0') * 10 + (v[5] - '0');
tm.tm_mday = (v[6] - '0') * 10 + (v[7] - '0')... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10810
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
subl $0x30, %eax
imull $0x3e8, %eax, %eax # imm = 0x3E8
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
subl $0x30, %ecx
imull $0x64, %ec... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
next_cache_entry | static int
next_cache_entry(struct archive_read *a, struct iso9660 *iso9660,
struct file_info **pfile)
{
struct file_info *file;
struct {
struct file_info *first;
struct file_info **last;
} empty_files;
int64_t number;
int count;
file = cache_get_entry(iso9660);
if (file != NULL) {
*pfile = file;
re... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x81a00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x814ef
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x819ec
jmp 0x814f1
mov... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
cache_get_entry | static inline struct file_info *
cache_get_entry(struct iso9660 *iso9660)
{
struct file_info *file;
if ((file = iso9660->cache_files.first) != NULL) {
iso9660->cache_files.first = file->next;
if (iso9660->cache_files.first == NULL)
iso9660->cache_files.last =
&(iso9660->cache_files.first);
}
return (... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x81a56
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x81a54
movq -0x8(%rbp), %rcx
addq $0x80... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
heap_get_entry | static struct file_info *
heap_get_entry(struct heap_queue *heap)
{
uint64_t a_key, b_key, c_key;
int a, b, c;
struct file_info *r, *tmp;
if (heap->used < 1)
return (NULL);
/*
* The first file in the list is the earliest; we'll return this.
*/
r = heap->files[0];
/*
* Move the last item in the heap to... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jge 0x81a7f
movq $0x0, -0x8(%rbp)
jmp 0x81bb5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %ecx
addl $-0x1, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
rede_add_entry | static inline int
rede_add_entry(struct file_info *file)
{
struct file_info *re;
/*
* Find "RE" entry.
*/
re = file->parent;
while (re != NULL && !re->re)
re = re->parent;
if (re == NULL)
return (-1);
file->re_next = NULL;
*re->rede_files.last = file;
re->rede_files.last = &(file->re_next);
return (0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x81cf0
movq -0x18(%rbp), %rax
cmpb $0x0, 0x4a(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
read_CE | static int
read_CE(struct archive_read *a, struct iso9660 *iso9660)
{
struct read_ce_queue *heap;
const unsigned char *b, *p, *end;
struct file_info *file;
size_t step;
int r;
/* Read data which RRIP "CE" extension points. */
heap = &(iso9660->read_ce_req);
step = iso9660->logical_block_size;
while (heap->cnt... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x8(%rcx)
movb %al, -0x4d(%rbp)
je 0x822c5
movq -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
zisofs_read_data | static int
zisofs_read_data(struct archive_read *a,
const void **buff, size_t *size, int64_t *offset)
{
struct iso9660 *iso9660;
struct zisofs *zisofs;
const unsigned char *p;
size_t avail;
ssize_t bytes_read;
size_t uncompressed_size;
int r;
iso9660 = (struct iso9660 *)(a->format->data);
zisofs = &iso96... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
release_files | static void
release_files(struct iso9660 *iso9660)
{
struct content *con, *connext;
struct file_info *file;
file = iso9660->use_files;
while (file != NULL) {
struct file_info *next = file->use_next;
archive_string_free(&file->name);
archive_string_free(&file->symlink);
free(file->utf16be_name);
con = fi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x82e09
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0xaaa10
movq -0x20(%rbp), %rdi
addq $0xd8, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.c |
archive_read_support_format_lha | int
archive_read_support_format_lha(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct lha *lha;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_format_lha");
lha = (struct lha *)calloc(1, sizeof(*lha));
if (lha == NULL) {
archive_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x231197(%rip), %rcx # 0x2b3fd0
callq 0xe9670
movl %eax, -0x28(%rbp)
cmpl $-0x1e, -0x28(%rbp)
jne 0x82e53
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
archive_read_format_lha_read_data_skip | static int
archive_read_format_lha_read_data_skip(struct archive_read *a)
{
struct lha *lha;
int64_t bytes_skipped;
lha = (struct lha *)(a->format->data);
if (lha->entry_unconsumed) {
/* Consume as much as the decompressor actually used. */
__archive_read_consume(a, lha->entry_unconsumed);
lha->entry_uncons... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x83d36
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x66cc0
movq -0x18(%rbp), %rax
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
archive_read_format_lha_cleanup | static int
archive_read_format_lha_cleanup(struct archive_read *a)
{
struct lha *lha = (struct lha *)(a->format->data);
lzh_decode_free(&(lha->strm));
archive_string_free(&(lha->dirname));
archive_string_free(&(lha->filename));
archive_string_free(&(lha->uname));
archive_string_free(&(lha->gname));
archive_wstr... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x170, %rdi # imm = 0x170
callq 0x88850
movq -0x10(%rbp), %rdi
addq $0xe0, %rdi
callq 0xaaa10
movq -0x10(%rbp), %rdi
addq $0xf8,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_check_header_format | static size_t
lha_check_header_format(const void *h)
{
const unsigned char *p = h;
size_t next_skip_bytes;
switch (p[H_METHOD_OFFSET+3]) {
/*
* "-lh0-" ... "-lh7-" "-lhd-"
* "-lzs-" "-lz5-"
*/
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case 'd':
case 's':
next_skip_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %eax
addl $-0x2d, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4d, %eax
ja 0x83fae
movq -0x28(%rbp), %rax
leaq 0x22fb7b(%rip), %rcx # 0x2b3a00
movslq (%rcx,%rax,4), %rax
add... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_crc16_init | static void
lha_crc16_init(void)
{
unsigned int i;
static int crc16init = 0;
if (crc16init)
return;
crc16init = 1;
for (i = 0; i < 256; i++) {
unsigned int j;
uint16_t crc = (uint16_t)i;
for (j = 8; j; j--)
crc = (crc >> 1) ^ ((crc & 1) * 0xA001);
crc16tbl[0][i] = crc;
}
for (i = 0; i < 256; i++)... | pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x2a7115(%rip) # 0x32b0f0
je 0x83fe2
jmp 0x840be
movl $0x1, 0x2a7104(%rip) # 0x32b0f0
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp) # imm = 0x100
jae 0x84053
movl -0x4(%rbp), %eax
movw %ax, -0xa(%rbp)
movl $0x8, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x84034
movzwl -0xa(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_read_file_header_3 | static int
lha_read_file_header_3(struct archive_read *a, struct lha *lha)
{
const unsigned char *p;
size_t extdsize;
int err;
uint16_t header_crc;
if ((p = __archive_read_ahead(a, H3_FIXED_SIZE, NULL)) == NULL)
return (truncated_error(a));
if (archive_le16dec(p + H3_FIELD_LEN_OFFSET) != 4)
goto invalid;
l... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x8498d
movq -0x10(%rbp), %rdi
callq 0x840c0
movl %eax, -0x4(%rbp)
jmp 0x84af1
movq -0x20(%rbp), %rdi... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_parse_linkname | static int
lha_parse_linkname(struct archive_wstring *linkname,
struct archive_wstring *pathname)
{
wchar_t * linkptr;
size_t symlen;
linkptr = wcschr(pathname->s, L'|');
if (linkptr != NULL) {
symlen = wcslen(linkptr + 1);
archive_wstrncpy(linkname, linkptr+1, symlen);
*linkptr = 0;
pathname->length... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x7c, %esi
callq 0x11590
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x84b88
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
callq 0x11110
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_crc16 | static uint16_t
lha_crc16(uint16_t crc, const void *pp, size_t len)
{
const unsigned char *p = (const unsigned char *)pp;
const uint16_t *buff;
const union {
uint32_t i;
char c[4];
} u = { 0x01020304 };
if (len == 0)
return crc;
/* Process unaligned address. */
if (((uintptr_t)p) & (uintptr_t)0x1) {
cr... | pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x22e81b(%rip), %eax # 0x2b422c
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x85a28
movw -0x4(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x85d0b
movq -0x20(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_win_time | static time_t
lha_win_time(uint64_t wintime, long *ns)
{
#define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
if (wintime >= EPOC_TIME) {
wintime -= EPOC_TIME; /* 1970-01-01 00:00:00 (UTC) */
if (ns != NULL)
*ns = (long)(wintime % 10000000) * 100;
return (wintime / 10000000);
} else {
if (ns != NULL)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movabsq $0x19db1ded53e8000, %rax # imm = 0x19DB1DED53E8000
cmpq %rax, -0x10(%rbp)
jb 0x85db5
movq -0x10(%rbp), %rax
movabsq $0x19db1ded53e8000, %rcx # imm = 0x19DB1DED53E8000
subq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x85da1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lha_end_of_entry | static int
lha_end_of_entry(struct archive_read *a)
{
struct lha *lha = (struct lha *)(a->format->data);
int r = ARCHIVE_EOF;
if (!lha->end_of_entry_cleanup) {
if ((lha->setflag & CRC_IS_SET) &&
lha->crc != lha->entry_crc_calculated) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"LHa data C... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x12d(%rax)
jne 0x85eb1
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x85ea6... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode | static int
lzh_decode(struct lzh_stream *strm, int last)
{
struct lzh_dec *ds = strm->ds;
int avail_in;
int r;
if (ds->error)
return (ds->error);
avail_in = strm->avail_in;
do {
if (ds->state < ST_GET_LITERAL)
r = lzh_read_blocks(strm, last);
else
r = lzh_decode_blocks(strm, last);
} while (r == 10... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x154(%rax)
je 0x86617
movq -0x20(%rbp), %rax
movl 0x154(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x86671
movq -0x10(%rbp), %rax
mo... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_huffman_init | static int
lzh_huffman_init(struct huffman *hf, size_t len_size, int tbl_bits)
{
int bits;
if (hf->bitlen == NULL) {
hf->bitlen = malloc(len_size * sizeof(hf->bitlen[0]));
if (hf->bitlen == NULL)
return (ARCHIVE_FATAL);
}
if (hf->tbl == NULL) {
if (tbl_bits < HTBL_BITS)
bits = tbl_bits;
else
bits ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x866cf
movq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0x116e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_read_blocks | static int
lzh_read_blocks(struct lzh_stream *strm, int last)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br *br = &(ds->br);
int c = 0, i;
unsigned rbits;
for (;;) {
switch (ds->state) {
case ST_RD_BLOCK:
/*
* Read a block number indicates how many blocks
* we will handle. The block is composed of... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x9, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_blocks | static int
lzh_decode_blocks(struct lzh_stream *strm, int last)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br bre = ds->br;
struct huffman *lt = &(ds->lt);
struct huffman *pt = &(ds->pt);
unsigned char *w_buff = ds->w_buff;
unsigned char *lt_bitlen = lt->bitlen;
unsigned char *pt_bitlen = pt->bitlen;
int block... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x38, %rax
movq %rax... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_br_fillup | static int
lzh_br_fillup(struct lzh_stream *strm, struct lzh_br *br)
{
int n = CACHE_BITS - br->cache_avail;
for (;;) {
const int x = n >> 3;
if (strm->avail_in >= x) {
switch (x) {
case 8:
br->cache_buffer =
((uint64_t)strm->next_in[0]) << 56 |
((uint64_t)strm->next_in[1]) << 48 |
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rcx
movl $0x40, %eax
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x20(%rbp), %eax
jl 0x87b37
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_make_fake_table | static int
lzh_make_fake_table(struct huffman *hf, uint16_t c)
{
if (c >= hf->len_size)
return (0);
hf->tbl[0] = c;
hf->max_bits = 0;
hf->shift_bits = 0;
hf->bitlen[hf->tbl[0]] = 0;
return (1);
} | pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x87c04
movl $0x0, -0x4(%rbp)
jmp 0x87c47
movw -0x12(%rbp), %cx
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x58(... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_read_pt_bitlen | static int
lzh_read_pt_bitlen(struct lzh_stream *strm, int start, int end)
{
struct lzh_dec *ds = strm->ds;
struct lzh_br *br = &(ds->br);
int c, i;
for (i = start; i < end; ) {
/*
* bit pattern the number we need
* 000 -> 0
* 001 -> 1
* 010 -> 2
*... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_huffman | static inline int
lzh_decode_huffman(struct huffman *hf, unsigned rbits)
{
int c;
/*
* At first search an index table for a bit pattern.
* If it fails, search a huffman tree for.
*/
c = hf->tbl[rbits >> hf->shift_bits];
if (c < hf->len_avail || hf->len_avail == 0)
return (c);
/* This bit pattern needs to b... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl 0x5c(%rcx), %ecx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %e... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_huffman_tree | static int
lzh_decode_huffman_tree(struct huffman *hf, unsigned rbits, int c)
{
struct htree_t *ht;
int extlen;
ht = hf->tree;
extlen = hf->shift_bits;
while (c >= hf->len_avail) {
c -= hf->len_avail;
if (extlen-- <= 0 || c >= hf->tree_used)
return (0);
if (rbits & (1U << extlen))
c = ht[c].left;
el... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x8883d
movq -0x10... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
lzh_decode_free | static void
lzh_decode_free(struct lzh_stream *strm)
{
if (strm->ds == NULL)
return;
free(strm->ds->w_buff);
lzh_huffman_free(&(strm->ds->lt));
lzh_huffman_free(&(strm->ds->pt));
free(strm->ds);
strm->ds = NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x88869
jmp 0x888b8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x10470
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x38, %rdi
callq 0x888c0
movq -0x8(%rbp), %rax
movq 0x30... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_lha.c |
archive_read_support_format_mtree | int
archive_read_support_format_mtree(struct archive *_a)
{
static const struct archive_rb_tree_ops rb_ops = {
mtree_cmp_node, mtree_cmp_key,
};
struct archive_read *a = (struct archive_read *)_a;
struct mtree *mtree;
int r;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_supp... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
leaq 0x22bc07(%rip), %rcx # 0x2b4530
callq 0xe9670
movl %eax, -0x28(%rbp)
cmpl $-0x1e, -0x28(%rbp)
jne 0x88943
movl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
mtree_bid | static int
mtree_bid(struct archive_read *a, int best_bid)
{
const char *signature = "#mtree";
const char *p;
(void)best_bid; /* UNUSED */
/* Now let's look at the actual header and see if it matches. */
p = __archive_read_ahead(a, strlen(signature), NULL);
if (p == NULL)
return (-1);
if (memcmp(p, signatur... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x22baae(%rip), %rax # 0x2b4574
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x109c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_mtree_options | static int
archive_read_format_mtree_options(struct archive_read *a,
const char *key, const char *val)
{
struct mtree *mtree;
mtree = (struct mtree *)(a->format->data);
if (strcmp(key, "checkfs") == 0) {
/* Allows to read information missing from the mtree from the file system */
if (val == NULL || val[0] ... | 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 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x22b9db(%rip), %rsi # 0x2b456c
callq 0x114f0
cmpl $0x0, %eax
jne 0x88bcf
cmpq $0x0, -0x2... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
read_header | static int
read_header(struct archive_read *a, struct archive_entry *entry)
{
struct mtree *mtree;
char *p;
int r, use_next;
mtree = (struct mtree *)(a->format->data);
if (mtree->fd >= 0) {
close(mtree->fd);
mtree->fd = -1;
}
if (mtree->entries == NULL) {
mtree->resolver = archive_entry_linkresolver_new... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0x88c23
movq -0x20(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x105b0
movq -0x20(%rbp), %rax
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
skip | static int
skip(struct archive_read *a)
{
struct mtree *mtree;
mtree = (struct mtree *)(a->format->data);
if (mtree->fd >= 0) {
close(mtree->fd);
mtree->fd = -1;
}
return (ARCHIVE_OK);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0x88fff
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x105b0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x30(%rax) #... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
detect_form | static int
detect_form(struct archive_read *a, int *is_form_d)
{
const char *p;
ssize_t avail, ravail;
ssize_t detected_bytes = 0, len, nl;
int entry_cnt = 0, multiline = 0;
int form_D = 0;/* The archive is generated by `NetBSD mtree -D'
* (In this source we call it `form D') . */
if (is_form_d != NULL)
*is... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8916e
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
next_line | static ssize_t
next_line(struct archive_read *a,
const char **b, ssize_t *avail, ssize_t *ravail, ssize_t *nl)
{
ssize_t len;
int quit;
quit = 0;
if (*avail == 0) {
*nl = 0;
len = 0;
} else
len = get_line_size(*b, *avail, nl);
/*
* Read bytes more while it does not reach the end of line.
*/
while... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x89552
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x38(%rbp)
jmp 0x8956d
movq -0x18... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
bid_keyword_list | static int
bid_keyword_list(const char *p, ssize_t len, int unset, int last_is_path)
{
int l;
int keycnt = 0;
while (len > 0 && *p) {
int blank = 0;
/* Test whether there are blank characters in the line. */
while (len >0 && (*p == ' ' || *p == '\t')) {
++p;
--len;
blank = 1;
}
if (*p == '\n' |... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
jle 0x89739
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
bid_entry | static int
bid_entry(const char *p, ssize_t len, ssize_t nl, int *last_is_path)
{
int f = 0;
static const unsigned char safe_char[256] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */
/* !"$%&'()*+,-./ EXCLUSION:( )(#) */
0, 1, 1,... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
get_line_size | static ssize_t
get_line_size(const char *b, ssize_t avail, ssize_t *nlsize)
{
ssize_t len;
len = 0;
while (len < avail) {
switch (*b) {
case '\0':/* Non-ascii character or control character. */
if (nlsize != NULL)
*nlsize = 0;
return (-1);
case '\r':
if (avail-len > 1 && b[1] == '\n') {
if (n... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x89c83
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x89bea
jmp 0x89bd6
movl -0x2c(%rbp), %eax
subl $0xa, %ea... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
bid_keycmp | static int
bid_keycmp(const char *p, const char *key, ssize_t len)
{
int match_len = 0;
while (len > 0 && *p && *key) {
if (*p == *key) {
--len;
++p;
++key;
++match_len;
continue;
}
return (0);/* Not match */
}
if (*key != '\0')
return (0);/* Not match */
/* A following character should be... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x25(%rbp)
jle 0x89cf4
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x89cf4
movq -0x18(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
bid_keyword | static int
bid_keyword(const char *p, ssize_t len)
{
static const char * const keys_c[] = {
"content", "contents", "cksum", NULL
};
static const char * const keys_df[] = {
"device", "flags", NULL
};
static const char * const keys_g[] = {
"gid", "gname", NULL
};
static const char * const keys_il[] = {
"i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x12, %eax
ja 0x89e9f
movq -0x30(%rbp), %rax
leaq 0x22a41c(%rip), %rcx # 0x2b4230
movslq (%rcx,%rax,4), %rax
addq %rcx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
read_mtree | static int
read_mtree(struct archive_read *a, struct mtree *mtree)
{
ssize_t len;
uintmax_t counter;
char *p, *s;
struct mtree_option *global;
struct mtree_entry *last_entry;
int r, is_form_d;
mtree->archive_format = ARCHIVE_FORMAT_MTREE;
mtree->archive_format_name = "mtree";
global = NULL;
last_entry = NUL... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x80000, 0x34(%rax) # imm = 0x80000
movq -0x18(%rbp), %rax
leaq 0x22a63f(%rip), %rcx # 0x2b4575
movq %rcx, 0x38(%rax)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parse_file | static int
parse_file(struct archive_read *a, struct archive_entry *entry,
struct mtree *mtree, struct mtree_entry *mentry, int *use_next)
{
const char *path;
struct stat st_storage, *st;
struct mtree_entry *mp;
struct archive_entry *sparse_entry;
int r = ARCHIVE_OK, r1, parsed_kws;
mentry->used = 1;
/* In... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0xe4(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x39(%rax)
movq -0x18(%rbp), %rdi
movl $0x8000, %esi # imm = 0x8000
c... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
readline | static ssize_t
readline(struct archive_read *a, struct mtree *mtree, char **start,
ssize_t limit)
{
ssize_t bytes_read;
ssize_t total_size = 0;
ssize_t find_off = 0;
const void *t;
void *nl;
char *u;
/* Accumulate line in a line buffer. */
for (;;) {
/* Read some more. */
t = __archive_read_ahead(a, 1,... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x30(%rbp), %rdx
callq 0x66710
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x8a9a2
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
process_add_entry | static int
process_add_entry(struct archive_read *a, struct mtree *mtree,
struct mtree_option **global, const char *line, ssize_t line_len,
struct mtree_entry **last_entry, int is_form_d)
{
struct mtree_entry *entry;
struct mtree_option *iter;
const char *next, *eq, *name, *end;
size_t name_len, len;
int r... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x40, %edi
callq 0x116e0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x8abed
movq -0x10(%rbp), %rax
movq %rax, -0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
process_global_set | static int
process_global_set(struct archive_read *a,
struct mtree_option **global, const char *line)
{
const char *next, *eq;
size_t len;
int r;
line += 4;
for (;;) {
next = line + strspn(line, " \t\r\n");
if (*next == '\0')
return (ARCHIVE_OK);
line = next;
next = line + strcspn(line, " \t\r\n");... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x2295e8(%rip), %rsi # 0x2b466b
callq 0x10e10
movq %rax, %rcx
movq -... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
process_global_unset | static int
process_global_unset(struct archive_read *a,
struct mtree_option **global, const char *line)
{
const char *next;
size_t len;
line += 6;
if (strchr(line, '=') != NULL) {
archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
"/unset shall not contain `='");
return ARCHIVE_FATAL;
}
for (;;) {... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3d, %esi
callq 0x10d60
cmpq $0x0, %rax
je 0x8b1c7
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFF... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parse_escapes | static void
parse_escapes(char *src, struct mtree_entry *mentry)
{
char *dest = src;
char c;
if (mentry != NULL && strcmp(src, ".") == 0)
mentry->full = 1;
while (*src != '\0') {
c = *src++;
if (c == '/' && mentry != NULL)
mentry->full = 1;
if (c == '\\') {
switch (src[0]) {
case '0':
if (src... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8b2cc
movq -0x8(%rbp), %rdi
leaq 0x2344d6(%rip), %rsi # 0x2bf790
callq 0x114f0
cmpl $0x0, %eax
jne 0x8b2cc
movq -0x10(%rbp), %rax
movb $0x1, 0x38(%rax)
jmp... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
add_option | static int
add_option(struct archive_read *a, struct mtree_option **global,
const char *value, size_t len)
{
struct mtree_option *opt;
if ((opt = malloc(sizeof(*opt))) == NULL) {
archive_set_error(&a->archive, errno, "Can't allocate memory");
return (ARCHIVE_FATAL);
}
if ((opt->value = malloc(len + 1)) == ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x10, %edi
callq 0x116e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8b519
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x11940
movq -0x38(%rbp), %rdi
movl (%rax), %esi
l... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
remove_option | static void
remove_option(struct mtree_option **global, const char *value, size_t len)
{
struct mtree_option *iter, *last;
last = NULL;
for (iter = *global; iter != NULL; last = iter, iter = iter->next) {
if (strncmp(iter->value, value, len) == 0 &&
(iter->value[len] == '\0' ||
iter->value[len] == '=... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8b64b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rd... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parse_keyword | static int
parse_keyword(struct archive_read *a, struct mtree *mtree,
struct archive_entry *entry, struct mtree_option *opt, int *parsed_kws)
{
char *val, *key;
key = opt->value;
if (*key == '\0')
return (ARCHIVE_OK);
if (strcmp(key, "nochange") == 0) {
*parsed_kws |= MTREE_HAS_NOCHANGE;
return (ARCHIV... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8b7a3
movl $0x0, -0x4(%rbp)
jm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
mtree_atol | static int64_t
mtree_atol(char **p, int base)
{
int64_t l, limit;
int digit, last_digit_limit;
if (base == 0) {
if (**p != '0')
base = 10;
else if ((*p)[1] == 'x' || (*p)[1] == 'X') {
*p += 2;
base = 16;
} else {
base = 8;
}
}
if (**p == '-') {
limit = INT64_MIN / base;
last_digit_limit =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8c47f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x8c43d
movl $0xa, -0x14(%rbp)
jmp 0x8c47d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parse_digest | static int
parse_digest(struct archive_read *a, struct archive_entry *entry,
const char *digest, int type)
{
unsigned char digest_buf[64];
int high, low;
size_t i, j, len;
switch (type) {
case ARCHIVE_ENTRY_DIGEST_MD5:
len = sizeof(entry->digest.md5);
break;
case ARCHIVE_ENTRY_DIGEST_RMD160:
len = size... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x98(%rbp)
subl $0x5, %eax
ja 0x8c702
movq -0x98(%rbp), %rax
leaq 0x227d65(%rip), %rcx # 0x2b4410
movslq (%rcx,%rax,4), ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
get_time_t_max | static int64_t
get_time_t_max(void)
{
#if defined(TIME_T_MAX)
return TIME_T_MAX;
#else
/* ISO C allows time_t to be a floating-point type,
but POSIX requires an integer type. The following
should work on any system that follows the POSIX
conventions. */
if (((time_t)0) < ((time_t)-1)) {
/* Time_t is u... | pushq %rbp
movq %rsp, %rbp
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
la_strsep | static char *
la_strsep(char **sp, const char *sep)
{
char *p, *s;
if (sp == NULL || *sp == NULL || **sp == '\0')
return(NULL);
s = *sp;
p = s + strcspn(s, sep);
if (*p != '\0')
*p++ = '\0';
*sp = p;
return(s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8c8d0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8c8d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x8c8da
movq $0x0, -0x8(%rbp)
jmp 0x8c939
movq -0x10(%rbp), %ra... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parsedigit | static int
parsedigit(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
else if (c >= 'a' && c <= 'f')
return c - 'a';
else if (c >= 'A' && c <= 'F')
return c - 'A';
else
return -1;
} | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x8c978
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x8c978
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x8c9bb
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x8c996
movsbl -0x5(%rbp), %eax
cm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
parse_hex_nibble | static int
parse_hex_nibble(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'a' && c <= 'f')
return 10 + c - 'a';
#if 0
/* XXX: Is uppercase something we should support? */
if (c >= 'A' && c <= 'F')
return 10 + c - 'A';
#endif
return -1;
} | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x8c9e8
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x8c9e8
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ca10
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x8ca09
movsbl -0x5(%rbp), %eax
cm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_mtree.c |
archive_read_format_rar_bid | static int
archive_read_format_rar_bid(struct archive_read *a, int best_bid)
{
const char *p;
/* If there's already a bid > 30, we'll never win. */
if (best_bid > 30)
return (-1);
if ((p = __archive_read_ahead(a, 7, NULL)) == NULL)
return (-1);
if (memcmp(p, RAR_SIGNATURE, 7) == 0)
return (30);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1e, -0x14(%rbp)
jle 0x8cb71
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8ccc2
movq -0x10(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x66710
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x8cb9... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_header | static int
archive_read_format_rar_read_header(struct archive_read *a,
struct archive_entry *entry)
{
const void *h;
const char *p;
struct rar *rar;
size_t skip;
char head_type;
int ret;
unsigned flags;
unsigned long crc32_expected;
a->archive.archive_format = ARCH... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0xd0000, 0x10(%rax) # imm = 0xD0000
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8cdd5
movq -0x10(%rbp), %rax
leaq 0x227dce(%rip), %rcx # 0x2b4b9f
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %r... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_data | static int
archive_read_format_rar_read_data(struct archive_read *a, const void **buff,
size_t *size, int64_t *offset)
{
struct rar *rar = (struct rar *)(a->format->data);
int ret;
if (rar->has_encrypted_entries == ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW) {
rar->has_encrypte... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $-0x1, 0x4f50(%rax)
jne 0x8d3a5
movq -0x30(%rbp), %rax
movl $0x0, 0x4... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.c |
archive_read_format_rar_read_data_skip | static int
archive_read_format_rar_read_data_skip(struct archive_read *a)
{
struct rar *rar;
int64_t bytes_skipped;
int ret;
rar = (struct rar *)(a->format->data);
if (rar->bytes_unconsumed > 0) {
/* Consume as much as the decompressor actually used. */
__archive_read_consume(a, rar->bytes_uncon... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x818(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
jle 0x8d55f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rsi
callq 0x66cc0
movq -0x18(%rbp), %rax
movq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_rar.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.