name string | code string | asm string | file string |
|---|---|---|---|
qpdf_oh_new_real_from_double | qpdf_oh
qpdf_oh_new_real_from_double(qpdf_data qpdf, double value, int decimal_places)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_real_from_double");
return new_object(qpdf, QPDFObjectHandle::newReal(value, decimal_places));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %edx
callq 0x68ff0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9aa3
callq 0x69d60
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_string | qpdf_oh
qpdf_oh_new_string(qpdf_data qpdf, char const* str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_string");
return new_object(qpdf, QPDFObjectHandle::newString(str));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x6e7c0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x69060
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9bb4
callq 0x69d60
leaq 0x2... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_unicode_string | qpdf_oh
qpdf_oh_new_unicode_string(qpdf_data qpdf, char const* utf8_str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_unicode_string");
return new_object(qpdf, QPDFObjectHandle::newUnicodeString(utf8_str));
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x6e7c0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6e2a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9c5a
callq 0x69d60
leaq 0x2... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_binary_string | qpdf_oh
qpdf_oh_new_binary_string(qpdf_data qpdf, char const* str, size_t length)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_binary_string");
return new_object(qpdf, QPDFObjectHandle::newString(std::string(str, length)));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x68bb0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x69060
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi,... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_array | qpdf_oh
qpdf_oh_new_array(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_array");
return new_object(qpdf, QPDFObjectHandle::newArray());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6a890
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9e36
callq 0x69d60
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_stream | qpdf_oh
qpdf_oh_new_stream(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_stream");
return new_object(qpdf, qpdf->qpdf->newStream());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6d330
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9ee7
callq 0x69d60
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_set_array_item | void
qpdf_oh_set_array_item(qpdf_data qpdf, qpdf_oh oh, int at, qpdf_oh item)
{
do_with_oh_void(qpdf, oh, [qpdf, at, item](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_set_array_item");
o.setArrayItem(at, qpdf_oh_item_internal(qpdf, item));
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
leaq 0x5c31(%rip), %rcx # 0x1afca8
movq %rcx, 0x18(%rax)
leaq 0x5c84(%rip), %rcx # 0x1afd06
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1a4... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_insert_item | void
qpdf_oh_insert_item(qpdf_data qpdf, qpdf_oh oh, int at, qpdf_oh item)
{
do_with_oh_void(qpdf, oh, [qpdf, at, item](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_insert_item");
o.insertItem(at, qpdf_oh_item_internal(qpdf, item));
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
movl %edx, 0x8(%rax)
movl %ecx, 0xc(%rax)
leaq 0x5c35(%rip), %rcx # 0x1afd2e
movq %rcx, 0x18(%rax)
leaq 0x5c88(%rip), %rcx # 0x1afd8c
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1a4... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_erase_item | void
qpdf_oh_erase_item(qpdf_data qpdf, qpdf_oh oh, int at)
{
do_with_oh_void(qpdf, oh, [at](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_erase_item");
o.eraseItem(at);
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movl %edx, (%rax)
leaq 0x5c43(%rip), %rcx # 0x1afe36
movq %rcx, 0x18(%rax)
leaq 0x5c46(%rip), %rcx # 0x1afe44
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1a4577
movq 0x10(%rsp), %rax
testq %rax, %rax... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_remove_key | void
qpdf_oh_remove_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
do_with_oh_void(qpdf, oh, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_remove_key");
o.removeKey(key);
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdx, (%rax)
leaq 0x5c61(%rip), %rcx # 0x1aff84
movq %rcx, 0x18(%rax)
leaq 0x5cca(%rip), %rcx # 0x1afff8
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1a4577
movq 0x10(%rsp), %rax
testq %rax, %rax... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_dict | qpdf_oh
qpdf_oh_get_dict(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<qpdf_oh>(qpdf, oh, return_null(qpdf), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_dict");
return new_object(qpdf, o.getDict());
});
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rdi, (%rdx)
leaq 0x1f5b(%rip), %rax # 0x1ac3b0
movq %rax, 0x18(%rdx)
leaq 0x1f58(%rip), %rax # 0x1ac3b8
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
m... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_generation | int
qpdf_oh_get_generation(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<int>(qpdf, oh, return_T<int>(0), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_generation");
return o.getGeneration();
});
} | pushq %rbx
subq $0x50, %rsp
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rax, (%rdx)
leaq 0x3e78(%rip), %rax # 0x1ae492
movq %rax, 0x18(%rdx)
leaq 0x3e73(%rip), %rax # 0x1ae498
movq %rax, 0x10(%rdx)
leaq 0x10(%rsp), %rcx
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_unparse | char const*
qpdf_oh_unparse(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_unparse");
qpdf->tmp_string = o.unparse();
return qpdf->tmp_string.c_str();
... | pushq %rbx
subq $0x50, %rsp
leaq 0x28547(%rip), %rax # 0x1d2c26
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rcx, (%rdx)
leaq 0x2f2e(%rip), %rax # 0x1ad62e
movq %rax, 0x18(%rdx)
leaq 0x2f2b(%rip), %rax # 0x1ad636
movq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_unparse_binary | char const*
qpdf_oh_unparse_binary(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_unparse_binary");
qpdf->tmp_string = o.unparseBinary();
return qpdf->... | pushq %rbx
subq $0x50, %rsp
leaq 0x28375(%rip), %rax # 0x1d2c26
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rcx, (%rdx)
leaq 0x2d5c(%rip), %rax # 0x1ad62e
movq %rax, 0x18(%rdx)
leaq 0x2d59(%rip), %rax # 0x1ad636
movq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_copy_foreign_object | qpdf_oh
qpdf_oh_copy_foreign_object(qpdf_data qpdf, qpdf_data other_qpdf, qpdf_oh foreign_oh)
{
return do_with_oh<qpdf_oh>(
other_qpdf, foreign_oh, return_uninitialized(qpdf), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_copy_foreign_object");
return new_objec... | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
leaq 0x1536(%rip), %rcx # 0x1abee2
movq %rcx, 0x18(%rax)
leaq 0x1533(%rip), %rcx # 0x1abeea
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
m... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_page_content_data | QPDF_ERROR_CODE
qpdf_oh_get_page_content_data(qpdf_data qpdf, qpdf_oh page_oh, unsigned char** bufp, size_t* len)
{
return trap_errors(qpdf, [page_oh, bufp, len](qpdf_data q) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_page_content_data");
auto o = qpdf_oh_item_internal(q, page_oh);
Pl_Buff... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movl $0x18, %edi
callq 0x68ab0
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_replace_stream_data | void
qpdf_oh_replace_stream_data(
qpdf_data qpdf,
qpdf_oh stream_oh,
unsigned char const* buf,
size_t len,
qpdf_oh filter_oh,
qpdf_oh decode_parms_oh)
{
do_with_oh_void(
qpdf, stream_oh, [qpdf, buf, len, filter_oh, decode_parms_oh](QPDFObjectHandle& o) {
QTC::TC("qpdf", "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, 0xc(%rsp)
movq %rdi, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movl $0x20, %edi
callq 0x68ab0
movq %r13, (%rax)
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_page_n | qpdf_oh
qpdf_get_page_n(qpdf_data qpdf, size_t i)
{
QTC::TC("qpdf", "qpdf-c called qpdf_get_page_n");
qpdf_oh result = 0;
QPDF_ERROR_CODE code = trap_errors(
qpdf, [&result, i](qpdf_data q) { result = new_object(q, q->qpdf->getAllPages().at(i)); });
if ((code & QPDF_ERRORS) || (result == 0)) {
... | pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rcx, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x5b3b(%rip), %rcx # 0x1b08ea
movq %rcx, 0x18(%rax)
leaq 0x5b86(%rip), %rcx # 0x1b094... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_update_all_pages_cache | QPDF_ERROR_CODE
qpdf_update_all_pages_cache(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_update_all_pages_cache");
return trap_errors(qpdf, [](qpdf_data q) { q->qpdf->updateAllPagesCache(); });
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x5b1f(%rip), %rax # 0x1b0968
movq %rax, 0x18(%rsi)
leaq 0x5b20(%rip), %rax # 0x1b0974
movq %rax, 0x10(%rsi)
callq 0x1a2ac5
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aae76
movq %rsp, %rdi
movq %rdi, %rs... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_find_page_by_oh | int
qpdf_find_page_by_oh(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_find_page_by_oh");
return do_with_oh<int>(qpdf, oh, return_T<int>(-1), [qpdf](QPDFObjectHandle& o) {
return qpdf->qpdf->findPage(o);
});
} | pushq %rbx
subq $0x50, %rsp
leaq 0xc(%rsp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rax, (%rdx)
leaq 0x3517(%rip), %rax # 0x1ae492
movq %rax, 0x18(%rdx)
leaq 0x3512(%rip), %rax # 0x1ae498
movq %rax, 0x10(... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_push_inherited_attributes_to_page | QPDF_ERROR_CODE
qpdf_push_inherited_attributes_to_page(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_push_inherited_attributes_to_page");
return trap_errors(qpdf, [](qpdf_data q) { q->qpdf->pushInheritedAttributesToPage(); });
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x59b4(%rip), %rax # 0x1b0a04
movq %rax, 0x18(%rsi)
leaq 0x59b5(%rip), %rax # 0x1b0a10
movq %rax, 0x10(%rsi)
callq 0x1a2ac5
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ab07d
movq %rsp, %rdi
movq %rdi, %rs... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_add_page | QPDF_ERROR_CODE
qpdf_add_page(qpdf_data qpdf, qpdf_data newpage_qpdf, qpdf_oh newpage, QPDF_BOOL first)
{
QTC::TC("qpdf", "qpdf-c called qpdf_add_page");
auto page = qpdf_oh_item_internal(newpage_qpdf, newpage);
return trap_errors(qpdf, [&page, first](qpdf_data q) { q->qpdf->addPage(page, first); });
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x1ab170
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r15, (%rsi)
movl %ebx, 0x8(%rsi)
leaq 0x5942(%rip), %rax # 0x1b0a28
movq %rax, 0x18(%rsi)
lea... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_add_page_at | QPDF_ERROR_CODE
qpdf_add_page_at(
qpdf_data qpdf, qpdf_data newpage_qpdf, qpdf_oh newpage, QPDF_BOOL before, qpdf_oh refpage)
{
QTC::TC("qpdf", "qpdf-c called qpdf_add_page_at");
auto page = qpdf_oh_item_internal(newpage_qpdf, newpage);
auto ref = qpdf_oh_item_internal(qpdf, refpage);
return trap_er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %r12d
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x1ab170
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1ab170
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_create_from_json_data | QPDF_ERROR_CODE
qpdf_create_from_json_data(qpdf_data qpdf, char const* buffer, unsigned long long size)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = "json buffer";
qpdf->buffer = buffer;
qpdf->size = size;
auto b = new Buffer(QUtil::unsigned_char_pointer(buffer), QIntC::to_size(size));
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2ea52(%rip), %rax # 0x1da378
movq %rax, 0x78(%rdi)
movq %rsi, 0x80(%rdi)
movq %rdx, 0x88(%rdi)
movl $0x8, %edi
callq 0x68ab0
movq %rax, %r14
movq %r12, %rdi
callq 0x6bb40
movq %r14, %rdi
movq %rax, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_update_from_json_data | QPDF_ERROR_CODE
qpdf_update_from_json_data(qpdf_data qpdf, char const* buffer, unsigned long long size)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
auto b = new Buffer(QUtil::unsigned_char_pointer(buffer), QIntC::to_size(size));
auto is = std::make_shared<BufferInputSource>(qpdf->filename, b, true);
status... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x8, %edi
callq 0x68ab0
movq %rax, %r14
movq %r12, %rdi
callq 0x6bb40
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x6e870
leaq 0x40(%rsp), %r8
movq %r14, (%r8)
leaq 0x78(%rbx), %rcx
leaq 0xe(%rsp... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_c_wrap(_qpdf_data*, std::function<void ()>) | qpdflogger_handle
qpdf_get_logger(qpdf_data qpdf)
{
return new _qpdflogger_handle(qpdf->qpdf->getLogger());
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rsi, (%rax)
leaq 0x51fb(%rip), %rcx # 0x1b1078
movq %rcx, 0x18(%rax)
leaq 0x5204(%rip), %rcx # 0x1b108c
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x10(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_data::_qpdf_data() | _qpdf_data() = default; | leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x40(%rdi)
xorl %eax, %eax
movq %rax, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0xc0(%rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
qpdf_data::~_qpdf_data() | ~_qpdf_data() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
leaq 0x138(%rbx), %rax
cmpq %rax, %rdi
je 0x1b119c
movq (%rax), %rsi
incq %rsi
callq 0x68760
leaq 0xf0(%rbx), %rdi
callq 0x6cf60
leaq 0xb8(%rbx), %rdi
callq 0x1b12ae
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x1b11c5
callq 0x69d60
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
qpdfjob_set_logger | void
qpdfjob_set_logger(qpdfjob_handle j, qpdflogger_handle logger)
{
j->j.setLogger(logger->l);
} | pushq %rbx
subq $0x10, %rsp
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1b2f00
movq 0x95eee(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x1b2efc
incl 0x8(%rax)
jmp 0x1b2f00
lock
incl 0x8(%rax)
movq %rsp, %rsi
callq 0x6eb80
movq 0x8(%rsp), %rdi
testq %rdi, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_get_logger | qpdflogger_handle
qpdfjob_get_logger(qpdfjob_handle j)
{
return new _qpdflogger_handle(j->j.getLogger());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x10, %edi
callq 0x68ab0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6ec70
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b3c5c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2f77
callq 0x69d60
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_initialize_from_argv | int
qpdfjob_initialize_from_argv(qpdfjob_handle j, char const* const argv[])
{
return wrap_qpdfjob(j, [argv](qpdfjob_handle jh) {
jh->j.initializeFromArgv(argv);
return 0;
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rsi, (%rax)
leaq 0x84c(%rip), %rcx # 0x1b3816
movq %rcx, 0x18(%rax)
leaq 0x857(%rip), %rcx # 0x1b382c
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x1b302e
movl %eax, %ebx
movq 0x10(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
wrap_qpdfjob(_qpdfjob_handle*, std::function<int (_qpdfjob_handle*)>) | static int
wrap_qpdfjob(qpdfjob_handle j, std::function<int(qpdfjob_handle j)> fn)
{
try {
return fn(j);
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n";
}
return QPDFJob::EXIT_ERROR;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x10(%rsi)
je 0x1b305e
movq %rsi, %rax
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq *0x18(%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x6e740
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x1b3184
movq %rbx, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_initialize_from_json | int
qpdfjob_initialize_from_json(qpdfjob_handle j, char const* json)
{
return wrap_qpdfjob(j, [json](qpdfjob_handle jh) {
jh->j.setMessagePrefix("qpdfjob json");
jh->j.initializeFromJson(json);
return 0;
});
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rsi, (%rax)
leaq 0x63d(%rip), %rcx # 0x1b3884
movq %rcx, 0x18(%rax)
leaq 0x6fe(%rip), %rcx # 0x1b3950
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x1b302e
movl %eax, %ebx
movq 0x10(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run | int
qpdfjob_run(qpdfjob_handle j)
{
QUtil::setLineBuf(stdout);
return wrap_qpdfjob(j, [](qpdfjob_handle jh) {
jh->j.run();
return jh->j.getExitCode();
});
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x9595e(%rip), %rax # 0x248c18
movq (%rax), %rdi
callq 0x6e830
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x6a4(%rip), %rax # 0x1b3976
movq %rax, 0x18(%rsi)
leaq 0x6af(%rip), %rax # 0x1b398c
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_create_qpdf | qpdf_data
qpdfjob_create_qpdf(qpdfjob_handle j)
{
QUtil::setLineBuf(stdout);
try {
auto qpdf = j->j.createQPDF();
return qpdf ? new _qpdf_data(std::move(qpdf)) : nullptr;
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x958cd(%rip), %rax # 0x248c18
movq (%rax), %rdi
callq 0x6e830
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x69670
cmpq $0x0, 0x8(%rsp)
je 0x1b3384
movl $0x148, %edi # imm = 0x148
callq 0x68ab0
movq %rax, %r15
leaq 0x8(%rsp)... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_write_qpdf | int
qpdfjob_write_qpdf(qpdfjob_handle j, qpdf_data qpdf)
{
QUtil::setLineBuf(stdout);
return wrap_qpdfjob(j, [qpdf](qpdfjob_handle jh) {
jh->j.writeQPDF(*(qpdf->qpdf));
return jh->j.getExitCode();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x9570a(%rip), %rax # 0x248c18
movq (%rax), %rdi
callq 0x6e830
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rbx, (%rsi)
leaq 0x477(%rip), %rax # 0x1b39a4
movq %rax, 0x18(%rsi)
leaq 0x488(%rip)... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
run_with_handle(std::function<int (_qpdfjob_handle*)>) | static int
run_with_handle(std::function<int(qpdfjob_handle)> fn)
{
auto j = qpdfjob_init();
int status = fn(j);
if (status == 0) {
status = qpdfjob_run(j);
}
qpdfjob_cleanup(&j);
return status;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x6ddd0
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%r14)
je 0x1b3665
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movl %eax, %ebp
testl %eax, %eax
jne 0x1b3652
movq %rbx, %rdi
callq 0x6ad80
movl %eax, %ebp
movq... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run_from_json | int
qpdfjob_run_from_json(char const* json)
{
return run_with_handle(
[json](qpdfjob_handle j) { return qpdfjob_initialize_from_json(j, json); });
} | pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
leaq 0x348(%rip), %rcx # 0x1b3a4e
movq %rcx, 0x18(%rax)
leaq 0x34b(%rip), %rcx # 0x1b3a5c
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x1b3613
movl %eax, %ebx
movq 0x10(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_register_progress_reporter | void
qpdfjob_register_progress_reporter(
qpdfjob_handle j, void (*report_progress)(int percent, void* data), void* data)
{
j->j.registerProgressReporter(std::bind(report_progress, std::placeholders::_1, data));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movl $0x10, %edi
callq 0x68ab0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r12)
movq 0x95745(%rip), %rax # 0x248ef0
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdf_data::_qpdf_data(std::unique_ptr<QPDF, std::default_delete<QPDF>>&&) | _qpdf_data(std::unique_ptr<QPDF>&& qpdf) :
qpdf(std::move(qpdf)) {} | pushq %rbx
movq %rdi, %rbx
callq 0x1b3b52
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
leaq 0x68(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movb %al, 0x68... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
qpdflogger_create | qpdflogger_handle
qpdflogger_create()
{
return new _qpdflogger_handle(QPDFLogger::create());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x10, %edi
callq 0x68ab0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6b570
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1b3d48
movq 0x950a6(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x1b3d44
incl 0x8(%rax)
jmp... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
set_log_dest(QPDFLogger*, void (QPDFLogger::*)(std::shared_ptr<Pipeline>), qpdf_log_dest_e, char const*, int (*)(char const*, unsigned long, void*), void*) | static void
set_log_dest(
QPDFLogger* l,
void (QPDFLogger::*method)(std::shared_ptr<Pipeline>),
qpdf_log_dest_e dest,
char const* identifier,
qpdf_log_fn_t fn,
void* udata)
{
set_log_dest(
l, std::bind(std::mem_fn(method), l, std::placeholders::_1), dest, identifier, fn, udata);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x18, %edi
callq 0x68ab0
movq %r12, (%rax)
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
qpdflogger_set_save | void
qpdflogger_set_save(
qpdflogger_handle l, qpdf_log_dest_e dest, qpdf_log_fn_t fn, void* udata, int only_if_not_set)
{
auto method = std::bind(
std::mem_fn(&QPDFLogger::setSave), l->l.get(), std::placeholders::_1, only_if_not_set);
set_log_dest(l->l.get(), method, dest, "save logger", fn, udata)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq (%rdi), %r12
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movl $0x20, %edi
callq 0x68ab0
movq 0x94d88(%rip), %rcx # 0x248ca0
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
check_openssl(int) | static void
check_openssl(int status)
{
if (status != 1) {
// OpenSSL creates a "queue" of errors; copy the first (innermost) error to the exception
// message.
char buf[256] = "";
ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
std::string what = "OpenSSL error: ";
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
cmpl $0x1, %edi
jne 0x1b4540
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r14
popq %r15
jmp 0x6ddb0
leaq 0x20(%rsp), %rbx
movl $0x100, %edx # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x69950
callq 0x6d5c0
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_init(int) | void
QPDFCrypto_openssl::SHA2_init(int bits)
{
static const EVP_MD* md = EVP_sha512();
switch (bits) {
case 256:
md = EVP_sha256();
break;
case 384:
md = EVP_sha384();
break;
case 512:
md = EVP_sha512();
break;
default:
bad_bits(bits);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movb 0x992c2(%rip), %al # 0x24d900
testb %al, %al
je 0x1b46b9
cmpl $0x100, %r14d # imm = 0x100
je 0x1b466f
cmpl $0x180, %r14d # imm = 0x180
je 0x1b4668
cmpl $0x200, %r14d ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::MD5_finalize() | void
QPDFCrypto_openssl::MD5_finalize()
{
#ifdef QPDF_OPENSSL_1
auto md = EVP_MD_CTX_md(md_ctx);
#else
auto md = EVP_MD_CTX_get0_md(md_ctx);
#endif
if (md) {
check_openssl(EVP_DigestFinal(md_ctx, md_out + 0, nullptr));
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6b7e0
testq %rax, %rax
je 0x1b4982
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x68770
movl %eax, %edi
popq %rbx
jmp 0x1b451e
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_finalize() | void
QPDFCrypto_openssl::SHA2_finalize()
{
#ifdef QPDF_OPENSSL_1
auto md = EVP_MD_CTX_md(md_ctx);
#else
auto md = EVP_MD_CTX_get0_md(md_ctx);
#endif
if (md) {
check_openssl(EVP_DigestFinal(md_ctx, md_out + 0, nullptr));
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6b7e0
testq %rax, %rax
je 0x1b49b0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x68770
movl %eax, %edi
popq %rbx
jmp 0x1b451e
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_digest[abi:cxx11]() | std::string
QPDFCrypto_openssl::SHA2_digest()
{
return {reinterpret_cast<char*>(md_out), sha2_bits / 8};
} | pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rsi), %rax
movq 0x58(%rsi), %rcx
shrq $0x3, %rcx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
leaq (%rsi,%rcx), %rdx
addq $0x18, %rdx
movq %rax, %rsi
callq 0x68bb0
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::RC4_init(unsigned char const*, int) | void
QPDFCrypto_openssl::RC4_init(unsigned char const* key_data, int key_len)
{
#ifdef QPDF_OPENSSL_1
static auto const rc4 = EVP_rc4();
#else
static auto const rc4 = RC4Loader::getRC4();
#endif
check_openssl(EVP_CIPHER_CTX_reset(cipher_ctx));
if (key_len == -1) {
key_len = QIntC::to_int(strlen(... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movb 0x98f16(%rip), %al # 0x24d910
testb %al, %al
je 0x1b4a83
movq 0x10(%r14), %rdi
callq 0x6f140
movl %eax, %edi
callq 0x1b451e
cmpl $-0x1, %r15d
jne 0x1b4a33
movq %rbx, %rdi
callq 0x6a120
movq %rax, %r15
testq $-0x80000000, %rax ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
(anonymous namespace)::RC4Loader::getRC4() | EVP_CIPHER const*
RC4Loader::getRC4()
{
static auto loader = std::shared_ptr<RC4Loader>(new RC4Loader());
return loader->rc4;
} | pushq %r14
pushq %rbx
pushq %rax
movb 0x98e52(%rip), %al # 0x24d928
testb %al, %al
je 0x1b4aed
movq 0x98e37(%rip), %rax # 0x24d918
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x98e34(%rip), %rdi # 0x24d928
callq 0x69d10
testl %eax, %eax
je 0x1b4ada
movl $0x18, %edi
callq 0x68ab0
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
(anonymous namespace)::RC4Loader::RC4Loader() | RC4Loader::RC4Loader()
{
libctx = OSSL_LIB_CTX_new();
if (libctx == nullptr) {
throw std::runtime_error("unable to create openssl library context");
return;
}
legacy = OSSL_PROVIDER_load(libctx, "legacy");
if (legacy == nullptr) {
OSSL_LIB_CTX_free(libctx);
throw std:... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6c680
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1b4cff
leaq 0x26011(%rip), %rsi # 0x1dacdd
movq %rax, %rdi
callq 0x6d2b0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rax, %rax
je 0x1b4d1d
leaq 0xaccd(%rip), %rsi # 0x1bf9b4
xorl %edx, %edx
callq 0x6a8a0... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
backward::SourceFile::get_lines(unsigned int, unsigned int, std::vector<std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&) | lines_t &get_lines(unsigned line_start, unsigned line_count, lines_t &lines) {
using namespace std;
// This function make uses of the dumbest algo ever:
// 1) seek(0)
// 2) read lines one by one and discard until line_start
// 3) read line one by one until line_start + line_count
//
// If yo... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x178(%rsp)
movl %esi, 0x174(%rsp)
movl %edx, 0x170(%rsp)
movq %rcx, 0x168(%rsp)
movq 0x178(%rsp), %rdi
movq %rdi, 0x70(%rsp)
callq 0xde2e0
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x14de0
movq 0x70(%rsp), %rdi
callq 0xde2e0
m... | /diatomic[P]diy/tests/backward/backward.hpp |
inipp::Format<char>::global_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | const std::basic_string<CharT> global_symbol(const std::basic_string<CharT>& sec_name, const std::basic_string<CharT>& name) const {
return local_symbol(sec_name + char_interpol_sep + name);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0xe(%rsi), %ebp
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x8d7c
movq 0x8(%r12), ... | /mcmtroffaes[P]inipp/inipp/inipp.h |
inipp::Ini<wchar_t>::Ini() | Ini(std::shared_ptr<Format<CharT>> fmt) : format(fmt) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x30(%rdi), %r14
movq %r14, 0x38(%rdi)
movq %r14, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
addq $0x48, %rdi
lea... | /mcmtroffaes[P]inipp/inipp/inipp.h |
inipp::Ini<wchar_t>::global_symbols[abi:cxx11]() const | const Symbols global_symbols() const {
Symbols result;
for (const auto & sec : sections)
for (const auto & val : sec.second)
result.emplace_back(format->global_symbol(sec.first, val.first), val.second);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %rcx
movq %rcx, 0x10(%rsp)
cmpq %rcx, %rax
je 0xbaa2
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq 0x58(%rax), %r13
movq %ra... | /mcmtroffaes[P]inipp/inipp/inipp.h |
fmp4_stream::emsg::parse(char const*, unsigned int) | void emsg::parse(const char *ptr, unsigned int data_size)
{
full_box::parse(ptr);
uint64_t offset = full_box::size();
if (version_ == 0)
{
scheme_id_uri_ = std::string(ptr + offset);
//cout << "scheme_id_uri: " << scheme_id_uri << endl;
offset = offset + scheme_id_uri_.size() + 1;
value_ = std::str... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5290
movq -0xe0(%rbp), %rdi
callq 0xbf60
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, -0x20(%rbp)
mov... | /unifiedstreaming[P]fmp4-ingest/ingest-tools/event/fmp4stream.cpp |
fmp4_stream::emsg::write_emsg_as_mpd_event(std::ostream&, unsigned long) const | void emsg::write_emsg_as_mpd_event(std::ostream &ostr, uint64_t base_time) const
{
ostr << "<event "
<< "presentationtime=" << '"' << (this->version_ ? presentation_time_ : base_time + presentation_time_delta_) << '"' << " " \
<< "duration=" << '"' << event_duration_ << '"' << " " \
<< "id=" << '"' << id_... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcc19(%rip), %rsi # 0x14643
callq 0x31f0
movq %rax, %rdi
leaq 0xcc12(%rip), %rsi # 0x1464b
callq 0... | /unifiedstreaming[P]fmp4-ingest/ingest-tools/event/fmp4stream.cpp |
void Qentem::TestOutPut::Print<char const*, char [2], unsigned long, char [10], char const*, char [9], char [33], char [19], Qentem::StringStream<char>, char [4]>(char const* const&, char const (&) [2], unsigned long const&, char const (&) [10], char const* const&, char const (&) [9], char const (&) [33], char const (&... | inline static void Print(const Values_T &...values) {
if (GetStreamCache() == nullptr) {
#if __cplusplus > 201402L
(std::wcout << ... << values);
#else
const int dummy[sizeof...(Values_T)] = {(std::wcout << values, 0)...};
(void)dummy;
#endif
} else {
#if __cplusplus... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x68(%rsp), %rax
movq %r9, %r12
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0xd2f1(%rip), %rax # 0... | /HaniAmmar[P]Qentem-Engine/Include/QTest.hpp |
QPDFObject::getDescription[abi:cxx11]() (.cold.1) | std::string
QPDFObject::getDescription()
{
qpdf_offset_t shift = (getTypeCode() == ::ot_dictionary) ? 2
: (getTypeCode() == ::ot_array) ? 1
: 0;
if (object_description) {
switch (object_description->index()) {
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq 0x1d5b26(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x1a46a
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x1a472
pushq $-0x1
popq %rax
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x1a47d
movq (%rdi), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFObject.cc |
read_bits(unsigned char const*&, unsigned long&, unsigned long&, unsigned long) | static unsigned long long
read_bits(unsigned char const*& p, size_t& bit_offset, size_t& bits_available, size_t bits_wanted)
{
// View p as a stream of bits:
// 76543210 76543210 ....
// bit_offset is the bit number within the first byte that marks
// the first bit that we would read.
if (bits_wa... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %r14
cmpq %rcx, (%rdx)
jb 0x1d3b0
cmpq $0x20, %r15
ja 0x1d412
testq %r15, %r15
je 0x1d3a0
movq (%rdi), %r9
xorl %eax, %eax
movq (%rsi), %r10
leal 0x1(%r10), %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
shll %cl, %r8d
notb %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/bits_functions.hh |
BitStream::skipToNextByte() | void
BitStream::skipToNextByte()
{
if (bit_offset != 7) {
size_t bits_to_skip = bit_offset + 1;
if (bits_available < bits_to_skip) {
throw std::logic_error("INTERNAL ERROR: overflow skipping to next byte in bitstream");
}
bit_offset = 7;
++p;
bits_availabl... | pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
cmpq $0x7, %rax
je 0x1d630
incq %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
jb 0x1d638
movq $0x7, 0x18(%rdi)
incq 0x10(%rdi)
movq %rcx, 0x20(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x13fa22(%rip), %rsi # ... | /jberkenbilt[P]qpdf/libqpdf/BitStream.cc |
BitWriter::writeBitsSigned(long long, unsigned long) | void
BitWriter::writeBitsSigned(long long val, size_t bits)
{
unsigned long long uval = 0;
if (val < 0) {
uval = (1ULL << bits) + static_cast<unsigned long long>(val);
} else {
uval = static_cast<unsigned long long>(val);
}
writeBits(uval, bits);
} | movq %rdx, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rsi, %rdx
sarq $0x3f, %rdx
andq %rax, %rdx
addq %rsi, %rdx
leaq 0x8(%rdi), %rax
movq (%rdi), %r8
leaq 0x10(%rdi), %rsi
movq %rax, %rdi
jmp 0x1db86
nop
| /jberkenbilt[P]qpdf/libqpdf/BitWriter.cc |
Buffer::copy() const | Buffer
Buffer::copy() const
{
auto result = Buffer(m->size);
if (m->size) {
memcpy(result.m->buf, m->buf, m->size);
}
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x28(%rax), %rsi
callq 0x1ddbe
movq (%r14), %rax
movq 0x28(%rax), %rdx
testq %rdx, %rdx
je 0x1dffe
movq (%rbx), %rcx
movq 0x30(%rcx), %rdi
movq 0x30(%rax), %rsi
callq 0x19080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
... | /jberkenbilt[P]qpdf/libqpdf/Buffer.cc |
BufferInputSource::seek(long long, int) | void
BufferInputSource::seek(qpdf_offset_t offset, int whence)
{
switch (whence) {
case SEEK_SET:
this->cur_offset = offset;
break;
case SEEK_END:
QIntC::range_check(this->max_offset, offset);
this->cur_offset = this->max_offset + offset;
break;
case SEEK_CUR:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpl $0x2, %edx
je 0x1e423
cmpl $0x1, %edx
je 0x1e3e9
testl %edx, %edx
je 0x1e458
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x13eeaf(%rip), %rsi # 0x15d27a
movq %rax, %rdi
callq 0x19970
movq 0x1d1c16(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/BufferInputSource.cc |
FileInputSource::setFilename(char const*) | void
FileInputSource::setFilename(char const* filename)
{
this->close_file = true;
this->filename = filename;
this->file = QUtil::safe_fopen(filename, "rb");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0xa8(%rdi)
leaq 0xb0(%rdi), %r15
movq 0xb8(%rdi), %r12
movq %rsi, %rdi
callq 0x19420
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x19580
leaq 0x13debd(%rip), %rsi # 0x15d4d4
movq... | /jberkenbilt[P]qpdf/libqpdf/FileInputSource.cc |
FileInputSource::findAndSkipNextEOL() | qpdf_offset_t
FileInputSource::findAndSkipNextEOL()
{
qpdf_offset_t result = 0;
bool done = false;
char buf[10240];
while (!done) {
qpdf_offset_t cur_offset = QUtil::tell(this->file);
size_t len = this->read(buf, sizeof(buf));
if (len == 0) {
done = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2828, %rsp # imm = 0x2828
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %r13
xorl %r12d, %r12d
movq %r14, 0x18(%rsp)
movq 0xd0(%rbx), %rdi
callq 0x13e221
movq %rax, 0x10(%rsp)
movq (%rbx), %rax
movl $0x2800, %e... | /jberkenbilt[P]qpdf/libqpdf/FileInputSource.cc |
FileInputSource::read(char*, unsigned long) | size_t
FileInputSource::read(char* buffer, size_t length)
{
this->last_offset = QUtil::tell(this->file);
size_t len = fread(buffer, 1, length, this->file);
if (len == 0) {
if (ferror(this->file)) {
throw QPDFExc(
qpdf_e_system,
this->filename,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd0(%rdi), %rdi
callq 0x13e221
movq %rax, 0x8(%r14)
movq 0xd0(%r14), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x19620
movq %rax, %rbx
testq %rax, %rax
jne 0x1ff35
mo... | /jberkenbilt[P]qpdf/libqpdf/FileInputSource.cc |
QPDFExc::~QPDFExc() | ~QPDFExc() noexcept override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1c9c49(%rip), %rax # 0x1e9e28
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x201fa
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x20212
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x18... | /jberkenbilt[P]qpdf/include/qpdf/QPDFExc.hh |
JSON::JSON_string::write(Pipeline*, unsigned long) const | void
JSON::JSON_string::write(Pipeline* p, size_t) const
{
*p << std::string("\"") + Writer::encode_string(utf8) + "\"";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x145a96(%rip), %rsi # 0x166a3a
leaq 0x145a90(%rip), %rdx # 0x166a3b
leaq 0x40(%rsp), %rdi
callq 0x1ef84
addq $0x10, %r14
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x211bc
movq 0x4... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::parse() | JSON
JSONParser::parse()
{
while (!done) {
getToken();
handleToken();
}
if (parser_state != ps_done) {
QTC::TC("libtests", "JSON parse premature EOF");
throw std::runtime_error("JSON: premature end of input");
}
auto const& tos = stack.back().item;
if (reactor && ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, 0xc8(%rsp)
cmpb $0x0, 0x4040(%rsi)
je 0x239c7
cmpl $0x9, 0x4070(%rbx)
jne 0x24d6c
movq 0x4080(%rbx), %r14
movq 0x8(%rbx), %rdi
movq -0x10(%r14), %rax
testq %rdi, %rdi
je 0x24844
testq %rax, %rax
movq 0xc8(%rsp)... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_number::~JSON_number() | ~JSON_number() override = default; | movq %rdi, %rax
leaq 0x1c28d2(%rip), %rcx # 0x1e9eb8
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x27601
movq (%rax), %rsi
incq %rsi
jmp 0x190e0
retq
| /jberkenbilt[P]qpdf/include/qpdf/JSON.hh |
MD5::print() | void
MD5::print()
{
Digest digest_val;
digest(digest_val);
unsigned int i;
for (i = 0; i < 16; ++i) {
printf("%02x", digest_val[i]);
}
printf("\n");
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x30(%rax)
leaq 0x13418c(%rip), %rbx # 0x15e122
xorl %r14d, %r14d
movzbl (%rsp,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x19070
incq %r14
cm... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
MD5::getDataChecksum[abi:cxx11](char const*, unsigned long) | std::string
MD5::getDataChecksum(char const* buf, size_t len)
{
MD5 m;
m.encodeDataIncrementally(buf, len);
return m.unparse();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x29c08
movq (%r15), %r15
movq %r12, %rdi
callq 0x13e063
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *0x20(%rcx)
leaq 0x8(%rsp), %rsi
movq %... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
MD5::checkFileChecksum(char const*, char const*, long long) | bool
MD5::checkFileChecksum(char const* const checksum, char const* filename, qpdf_offset_t up_to_offset)
{
bool result = false;
try {
std::string actual_checksum = getFileChecksum(filename, up_to_offset);
result = (checksum == actual_checksum);
} catch (std::runtime_error const&) {
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2a116
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19a80
testl %eax, %eax
sete %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a219
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movl %ebx, %eax
addq $0x... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
warn(QPDF&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
warn(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
{
qpdf.warn(qpdf_e_damaged_pdf, get_description(node), 0, msg);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2fc72
movq %r14, %rdi
movl $0x5, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x3a6d8
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a95d
movq 0x10(%rsp), %rsi
incq ... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
Pl_Base64::encode(unsigned char const*, unsigned long) | void
Pl_Base64::encode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
this->buf[this->pos++] = *p;
if (this->pos == 3) {
flush();
}
++p;
--len;
}
} | testq %rdx, %rdx
je 0x32444
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movq 0x38(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%r15)
movb %al, 0x34(%r15,%rcx)
cmpq $0x3, 0x38(%r15)
jne 0x32431
movq %r15, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::flush_encode() | void
Pl_Base64::flush_encode()
{
int outval = ((this->buf[0] << 16) | (this->buf[1] << 8) | (this->buf[2]));
unsigned char out[4] = {
to_uc(outval >> 18),
to_uc(0x3f & (outval >> 12)),
to_uc(0x3f & (outval >> 6)),
to_uc(0x3f & outval),
};
for (size_t i = 0; i < 4; ++i) {
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x34(%rdi), %eax
movl %eax, %ecx
shll $0x10, %ecx
movzbl 0x35(%rdi), %edx
shll $0x8, %edx
movzbl 0x36(%rdi), %esi
movl %esi, %edi
orl %edx, %edi
orl %ecx, %edx
shrb $0x2, %al
movb %al, 0xc(%rsp)
shrl $0xc, %edx
andb $0x3f, %dl
movb %dl, 0xd(%rsp)
shrl $0x6, %edi
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
QIntC::IntConverter<int, unsigned long, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19b00
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b50
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
Pl_DCT::decompress(void*, Buffer*) | void
Pl_DCT::decompress(void* cinfo_p, Buffer* b)
{
auto* cinfo = reinterpret_cast<jpeg_decompress_struct*>(cinfo_p);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
jpeg_create_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x290, %edx # imm = 0x290
movq %rsi, %rdi
movl $0x50, %esi
callq 0x195f0
movq 0x1bd712(%rip), %rcx # 0x1f10f0
movq 0x8(%r14), %rax
testq %rcx, %rcx
jle 0x339eb
movq %rcx, 0x58(%rax... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_Flate::Members::Members(unsigned long, Pl_Flate::action_e) | Pl_Flate::Members::Members(size_t out_bufsize, action_e action) :
out_bufsize(out_bufsize),
action(action),
initialized(false),
zdata(nullptr)
{
this->outbuf = QUtil::make_shared_array<unsigned char>(out_bufsize);
// Indirect through zdata to reach the z_stream so we don't have to include zlib.h... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movl %edx, 0x18(%rdi)
movb $0x0, 0x1c(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
movq %rsi, %rdi
callq 0x194e0
leaq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::write(unsigned char const*, unsigned long) | void
Pl_Flate::write(unsigned char const* data, size_t len)
{
if (m->outbuf == nullptr) {
throw std::logic_error(
this->identifier + ": Pl_Flate: write() called after finish() called");
}
if (m->zopfli_buf) {
m->zopfli_buf->append(reinterpret_cast<char const*>(data), len);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
cmpq $0x0, (%rax)
je 0x3443d
movq %rdx, %rbx
movq %rsi, %r15
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x343f1
movq %r15, %rsi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_PNGFilter::finish() | void
Pl_PNGFilter::finish()
{
if (this->pos) {
// write partial row
processRow();
}
this->prev_row = nullptr;
this->cur_row = buf1.get();
this->pos = 0;
memset(this->cur_row, 0, this->bytes_per_row + 1);
next()->finish();
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x36ee5
movq %rbx, %rdi
callq 0x36c00
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rdi
movq %rdi, 0x40(%rbx)
movq %rax, 0x70(%rbx)
movl 0x34(%rbx), %edx
incl %edx
xorl %esi, %esi
callq 0x19330
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%ra... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
QPDF::validatePDFVersion(char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
QPDF::validatePDFVersion(char const*& p, std::string& version)
{
bool valid = util::is_digit(*p);
if (valid) {
while (util::is_digit(*p)) {
version.append(1, *p++);
}
if ((*p == '.') && util::is_digit(*(p + 1))) {
version.append(1, *p++);
while (u... | pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3a2cd
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movsbl (%rax), %r8d
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19640
movq (%r14), %rax
movb (%rax), %cl
... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::removeSecurityRestrictions() | void
QPDF::removeSecurityRestrictions()
{
auto root = getRoot();
root.removeKey("/Perms");
auto acroform = root.getKey("/AcroForm");
if (acroform.isDictionary() && acroform.hasKey("/SigFlags")) {
acroform.replaceKey("/SigFlags", QPDFObjectHandle::newInteger(0));
}
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rsi
leaq 0x38(%rsp), %rdi
callq 0x3d0d4
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x121a52(%rip), %rsi # 0x15fc0c
leaq 0x121a51(%rip), %rdx # 0x15fc12
leaq 0x8(%rsp), %rdi
callq 0x1ef84
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xfc4ee
movq 0x8(%rs... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
(anonymous namespace)::ResourceReplacer::handleToken(QPDFTokenizer::Token const&) | void
ResourceReplacer::handleToken(QPDFTokenizer::Token const& token)
{
bool wrote = false;
if (token.getType() == QPDFTokenizer::tt_name) {
std::string name = QPDFObjectHandle::newName(token.getValue()).getName();
if (to_replace.count(name) && to_replace[name].count(offset)) {
QTC::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, (%rsi)
jne 0x56d1e
leaq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xc7f42
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xc275e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x56c81
callq 0x1ef14
leaq 0x18... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
qpdf::Tokenizer::nextToken(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | bool
Tokenizer::nextToken(InputSource& input, std::string const& context, size_t max_len)
{
if (state != st_inline_image) {
reset();
}
qpdf_offset_t offset = input.fastTell();
while (state != st_token_ready) {
char ch;
if (!input.fastRead(ch)) {
presentEOF();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0xd, (%rdi)
je 0xe2818
movq %rbx, %rdi
callq 0xe11b0
cmpq $0x0, 0x90(%r14)
je 0xe2853
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, %r13
movq 0xa0(%r14), %rcx
subq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
(anonymous namespace)::QPDFWordTokenFinder::check() | bool
QPDFWordTokenFinder::check()
{
// Find a word token matching the given string, preceded by a delimiter, and followed by a
// delimiter or EOF.
Tokenizer tokenizer;
tokenizer.nextToken(is, "finder", str.size() + 2);
qpdf_offset_t pos = is.tell();
if (tokenizer.getType() != tt::tt_word || tok... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xe13e4
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x973b4(%rip), %rsi # 0x17a3a6
leaq 0x973b3(%rip), %rdx # 0x17a3ac
movq %rsp, %rdi
callq 0x1ef84
movq 0x18(%rbx), %rcx
addq $0x2... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
QPDFWriter::Members::Members(QPDF&) | QPDFWriter::Members::Members(QPDF& pdf) :
pdf(pdf),
root_og(pdf.getRoot().getObjGen().isIndirect() ? pdf.getRoot().getObjGen() : QPDFObjGen(-1, 0))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3d0d4
movq %r15, %rdi
callq 0xc4770
testl %eax, %eax
je 0xe33c5
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3d0d4
movq %rsp, %rdi
callq 0xc4770
movq %rax, 0x8(%rbx)
movq 0x8(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::QPDFWriter(QPDF&, char const*) | QPDFWriter::QPDFWriter(QPDF& pdf, char const* filename) :
m(new Members(pdf))
{
setOutputFilename(filename);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x430, %edi # imm = 0x430
callq 0x19180
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xe3372
movq %r15, (%r14)
leaq 0x8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf5fb0
movq %r14, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setOutputMemory() | void
QPDFWriter::setOutputMemory()
{
m->filename = "memory buffer";
m->buffer_pipeline = new Pl_Buffer("qpdf output");
m->to_delete.push_back(std::shared_ptr<Pipeline>(m->buffer_pipeline));
initializePipelineStack(m->buffer_pipeline);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x96782(%rip), %rcx # 0x17a4c4
movq %rcx, 0x10(%rax)
movl $0x38, %edi
callq 0x19180
movq %rax, %r14
leaq 0x9675e(%rip), %rsi # 0x17a4b8
movq %rax, %rdi
xorl %edx, %edx
callq 0x32a4c
movq (%rbx), %r15
movq %r14, 0x28(%r15)
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setMinimumPDFVersion(PDFVersion const&) | void
QPDFWriter::setMinimumPDFVersion(PDFVersion const& v)
{
std::string version;
int extension_level;
v.getVersion(version, extension_level);
setMinimumPDFVersion(version, extension_level);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rdx
movq %rax, %rdi
callq 0x308de
movl 0x4(%rsp), %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe3ee6
movq 0x8(%rsp), %rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR5EncryptionParameters(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool) | void
QPDFWriter::setR5EncryptionParameters(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
bool encryp... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %eax
movl %r8d, %r9d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x60(%rsp), %dl
movb 0x68(%rsp), %sil
movb 0x70(%rsp), %dil
movl 0x78(%rsp), %r10d
leaq 0x8(%rsp), %r8
xorl %r11d, %r11d
movl %r11d, (%r8)
movq %r11, 0x8(%r8)
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::bytesNeeded(long long) | unsigned int
QPDFWriter::bytesNeeded(long long n)
{
unsigned int bytes = 0;
while (n) {
++bytes;
n >>= 8;
}
return bytes;
} | xorl %eax, %eax
testq %rsi, %rsi
je 0xe7a0c
movq %rsi, %rcx
incl %eax
sarq $0x8, %rcx
cmpq $0xff, %rsi
movq %rcx, %rsi
ja 0xe79fa
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::openObject(int) | int
QPDFWriter::openObject(int objid)
{
if (objid == 0) {
objid = m->next_objid++;
}
m->new_obj[objid].xref = QPDFXRefEntry(m->pipeline->getCount());
writeString(std::to_string(objid));
writeString(" 0 obj\n");
return objid;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r8
movq (%rdi), %rdi
testl %esi, %esi
jne 0xe8449
movl 0x298(%rdi), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0x298(%rdi)
movq 0x1c8(%rdi), %rcx
movq 0x248(%rdi), %rax
movq 0x38(%rcx), %rdx
leaq 0x8(%rdx), %rsi
add... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getOriginalID1[abi:cxx11]() | std::string
QPDFWriter::getOriginalID1()
{
QPDFObjectHandle trailer = m->pdf.getTrailer();
if (trailer.hasKey("/ID")) {
return trailer.getKey("/ID").getArrayItem(0).getStringValue();
} else {
return "";
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3d520
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8db7e(%rip), %rsi # 0x17a4eb
leaq 0x8db7a(%rip), %rdx # 0x17a4ee
movq %rsp, %rdi
callq 0x1ef84
leaq 0x20(%rsp), %rdi
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializeSpecialStreams() | void
QPDFWriter::initializeSpecialStreams()
{
// Mark all page content streams in case we are filtering or normalizing.
std::vector<QPDFObjectHandle> pages = m->pdf.getAllPages();
int num = 0;
for (auto& page: pages) {
m->page_object_to_seq[page.getObjGen()] = ++num;
QPDFObjectHandle con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x1398a0
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x5758e
movq (%r15), %rdi
movq 0x8(%r15), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rdi
je 0xef707
xorl %ebp, %eb... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::write() | void
QPDFWriter::write()
{
doWriteSetup();
// Set up progress reporting. For linearized files, we write two passes. events_expected is an
// approximation, but it's good enough for progress reporting, which is mostly a guess anyway.
m->events_expected = QIntC::to_int(m->pdf.getObjectCount() * (m->linea... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xefee2
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x12bae6
movq %rax, %r14
movq (%rbx), %rax
movb 0x4a(%rax), %cl
shlq %cl, %r14
testq $-0x80000000, %r14 # imm = 0x80000000
je 0xf0529
movq %r14, %rdi
callq 0x6271e
movq (%rbx), %rax
movl %r14d, 0x420(%rax)
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeHeader() | void
QPDFWriter::writeHeader()
{
writeString("%PDF-");
writeString(m->final_pdf_version);
if (m->pclm) {
// PCLm version
writeString("\n%PCLm 1.0\n");
} else {
// This string of binary characters would not be valid UTF-8, so it really should be treated
// as binary.
... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x1c8(%rax), %rdi
leaq 0x6cb21(%rip), %rsi # 0x15f856
movl $0x5, %edx
callq 0xf57a4
movq (%rbx), %rax
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
movq 0x1c8(%rax), %rdi
callq 0xf57a4
movq (%rbx), %rax
movq 0x1c8(%rax), %rdi
cmpb $0x1, 0x4b(%rax)
jne 0xf2d7a
leaq 0x8... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObjectsStandard() | void
QPDFWriter::enqueueObjectsStandard()
{
if (m->preserve_unreferenced_objects) {
QTC::TC("qpdf", "QPDFWriter preserve unreferenced standard");
for (auto const& oh: m->pdf.getAllObjects()) {
enqueueObject(oh);
}
}
// Put root first on queue.
QPDFObjectHandle traile... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpb $0x1, 0x43(%rax)
jne 0xf4b1a
movq (%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x12bb2a
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0xf4b12
leaq 0x40(%rsp), %r14
movq 0xfb4b7(%rip), %r13 ... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
ObjTable<QPDFWriter::NewObject>::large_element(unsigned long) | T&
large_element(size_t idx)
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < min_sparse) {
min_sparse = idx;
}
if (idx < max_size) {
return sparse_elements[idx];
}
throw std::runtime_error("Impossibly large object id ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb 0xfac49(%rip), %al # 0x1f1350
testb %al, %al
je 0xf6739
movq (%rsp), %rax
cmpq 0x48(%rbx), %rax
jae 0xf6719
movq %rax, 0x48(%rbx)
cmpq 0xfac28(%rip), %rax # 0x1f1348
jae 0xf6740
addq $0x18, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf678... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
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.