name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9abf
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
| /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 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9bcf
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x68760
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9bf0
callq 0x69d60
jmp 0x1a9bf0
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9c0b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9c75
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x68760
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9c96
callq 0x69d60
jmp 0x1a9c96
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a9cb1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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, %rdi
je 0x1a9d05
callq 0x69d60
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a9d1c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x68760
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9d3f
callq 0x69d60
jmp 0x1a9d3f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a9d56
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9e52
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
| /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, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9f03
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
| /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 0x1a4577
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa0a5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1aa0cf
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa0c7
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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 0x1a4577
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa127
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1aa151
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa149
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
je 0x1aa221
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1aa24b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa243
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
je 0x1aa351
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1aa37b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa373
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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)
movq %rdi, (%rcx)
leaq 0x5cc0(%rip), %rax # 0x1b0138
movq %rax, 0x18(%rcx)
leaq 0x5d0d(%rip), %rax # 0x1b0190
movq %rax, 0x10(%rcx)
callq 0x1a68d2
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa4a5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa4be
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x1aa507
jmp 0x1aa507
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa4e4
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa4fd
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1aa507
movq %rax, %rdi
callq 0x7cc8d
| /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
movaps %xmm0, (%rcx)
leaq 0x5b9e(%rip), %rax # 0x1b01d6
movq %rax, 0x18(%rcx)
leaq 0x5b9b(%rip), %rax # 0x1b01de
movq %rax, 0x10(%rcx)
callq 0x1a4c1e
movl %eax, %ebx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aa667
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x1aa680
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x1aa6cb
jmp 0x1aa6cb
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aa6a8
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x1aa6c1
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1aa6cb
movq %rax, %rdi
callq 0x7cc8d
| /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 %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movq %rdi, (%rcx)
leaq 0x5ad3(%rip), %rax # 0x1b01f6
movq %rax, 0x18(%rcx)
leaq 0x5b18(%rip), %rax # 0x1b0246
movq %rax, 0x10(%rcx)
callq 0x1a63df
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa751
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa76a
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x1aa7b4
jmp 0x1aa7b4
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa791
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa7aa
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1aa7b4
movq %rax, %rdi
callq 0x7cc8d
| /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->tmp_string.c_str();
});
} | 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 %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movq %rdi, (%rcx)
leaq 0x59ed(%rip), %rax # 0x1b02e2
movq %rax, 0x18(%rcx)
leaq 0x5a32(%rip), %rax # 0x1b0332
movq %rax, 0x10(%rcx)
callq 0x1a63df
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa923
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa93c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x1aa986
jmp 0x1aa986
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aa963
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aa97c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1aa986
movq %rax, %rdi
callq 0x7cc8d
| /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_object(qpdf, qpdf->qpdf->copyForeignObject(o));
});
} | 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)
movq %rdi, (%rcx)
leaq 0x5989(%rip), %rdi # 0x1b0358
movq %rdi, 0x18(%rcx)
leaq 0x5a26(%rip), %rdi # 0x1b0400
movq %rdi, 0x10(%rcx)
movq %rsi, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x1a68d2
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aaa04
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aaa1d
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x1aaa66
jmp 0x1aaa66
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aaa43
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aaa5c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1aaa66
movq %rax, %rdi
callq 0x7cc8d
| /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_Buffer buf("page contents");
o.pipePageContents(&buf);
buf.getMallocBuffer(bufp, len);
});
} | 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, (%r12)
leaq 0x5aaf(%rip), %rax # 0x1b0634
movq %rax, 0x18(%r12)
leaq 0x5b37(%rip), %rax # 0x1b06c8
movq %rax, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aabba
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aabed
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aabe5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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", "qpdf-c called qpdf_oh_replace_stream_data");
auto filter = qpdf_oh_item_internal(qpdf, filter_oh);
auto decode_parms = qpdf_oh_item_internal(qpdf, decode_parms_oh);
// XXX test with binary data with null
o.replaceStreamData(
std::string(reinterpret_cast<char const*>(buf), len), filter, decode_parms);
});
} | 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)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ebp, 0x18(%rax)
movl %ebx, 0x1c(%rax)
movq %rax, (%r12)
leaq 0x5ac4(%rip), %rax # 0x1b0732
movq %rax, 0x18(%r12)
leaq 0x5ba4(%rip), %rax # 0x1b081e
movq %rax, 0x10(%r12)
movq %r13, %rdi
movl 0xc(%rsp), %esi
movq %r12, %rdx
callq 0x1a4577
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aaca7
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1aacdc
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aacd4
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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)) {
return qpdf_oh_new_uninitialized(qpdf);
}
return result;
} | 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 # 0x1b0940
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x1a2ac5
movl %eax, %ebp
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aade1
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x2, %ebp
setae %cl
movl 0xc(%rsp), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1aadff
movq %rbx, %rdi
callq 0x6d8b0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1aae2c
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aae24
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1aaea2
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1aae9a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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(%rdx)
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm0, 0x10(%rcx)
movq %rdi, (%rcx)
leaq 0x5a32(%rip), %rax # 0x1b09d2
movq %rax, 0x18(%rcx)
leaq 0x5a33(%rip), %rax # 0x1b09de
movq %rax, 0x10(%rcx)
callq 0x1a4c1e
movl %eax, %ebx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1aafcf
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x1aafe8
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x1ab033
jmp 0x1ab033
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1ab010
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x1ab029
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
jmp 0x1ab033
movq %rax, %rdi
callq 0x7cc8d
| /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, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1ab0a9
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ab0a1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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)
leaq 0x59b3(%rip), %rax # 0x1b0aa4
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1ab118
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab127
callq 0x69d60
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ab168
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1ab151
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab160
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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_errors(
qpdf, [&page, before, &ref](qpdf_data q) { q->qpdf->addPageAt(page, before, ref); });
} | 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, (%rsp)
movl $0x18, %edi
callq 0x68ab0
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x53a7(%rip), %rax # 0x1b0acc
movq %rax, 0x18(%rsi)
leaq 0x546a(%rip), %rax # 0x1b0b9a
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ab755
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab764
callq 0x69d60
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab773
callq 0x69d60
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ab7a0
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1ab7ab
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x1ab7ab
movq %rax, %rdi
callq 0x7cc8d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab7bf
callq 0x69d60
jmp 0x1ab7bf
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab7ce
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
| /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));
auto is = std::make_shared<BufferInputSource>(qpdf->filename, b, true);
status = trap_errors(qpdf, [&is](qpdf_data q) { q->qpdf->createFromJSON(is); });
return status;
} | 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, %rsi
movq %r15, %rdx
callq 0x6e870
leaq 0x78(%rbx), %rcx
leaq 0x40(%rsp), %r8
movq %r14, (%r8)
leaq 0xe(%rsp), %r9
movb $0x1, (%r9)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x1b2bee
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
leaq 0x5384(%rip), %rax # 0x1b0d2c
movq %rax, 0x18(%rsi)
leaq 0x53eb(%rip), %rax # 0x1b0d9e
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1ab9da
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab9e9
callq 0x69d60
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1aba26
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1aba15
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1aba3e
callq 0x69d60
jmp 0x1aba3e
movq %rax, %rdi
callq 0x7cc8d
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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 = trap_errors(qpdf, [&is](qpdf_data q) { q->qpdf->updateFromJSON(is); });
return 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), %r9
movb $0x1, (%r9)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x1b2bee
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
leaq 0x5316(%rip), %rax # 0x1b0e60
movq %rax, 0x18(%rsi)
leaq 0x537d(%rip), %rax # 0x1b0ed2
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1a2ac5
movl %eax, %ebx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1abb7c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1abb8b
callq 0x69d60
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1abbc8
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1abbb7
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1abbe0
callq 0x69d60
jmp 0x1abbe0
movq %rax, %rdi
callq 0x7cc8d
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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
testq %rax, %rax
je 0x1abead
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1abed9
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1abed1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
nop
| /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), %rcx
movl %eax, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
movups %xmm0, 0x78(%rdi)
movups %xmm0, 0x88(%rdi)
movb %al, 0x98(%rdi)
movups %xmm0, 0xa0(%rdi)
movw $0x0, 0xb0(%rdi)
movq %rcx, 0xd0(%rdi)
movq %rcx, 0xd8(%rdi)
movq %rax, 0xe0(%rdi)
movl %eax, 0xe8(%rdi)
leaq 0xf8(%rdi), %rcx
movl %eax, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rcx, 0x108(%rdi)
movq %rcx, 0x110(%rdi)
leaq 0x138(%rdi), %rcx
movups %xmm0, 0x118(%rdi)
movq %rcx, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movb %al, 0x138(%rdi)
retq
| /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), %rax
cmpq %rax, %rdi
je 0x1b11dd
movq (%rax), %rsi
incq %rsi
callq 0x68760
leaq 0x40(%rbx), %rdi
callq 0x6ddc0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1b11f4
callq 0x69d60
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1b1202
callq 0x69d60
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1b1210
callq 0x69d60
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1b121f
popq %rbx
jmp 0x69d60
popq %rbx
retq
nop
| /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
je 0x1b2f17
callq 0x69d60
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2f2f
callq 0x69d60
movq %rbx, %rdi
callq 0x6b780
| /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 %r14
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2f99
callq 0x69d60
jmp 0x1b2f99
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x68760
movq %r14, %rdi
callq 0x6b780
| /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
testq %rax, %rax
je 0x1b2ffa
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1b3026
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b301e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
callq 0x683f0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6ec70
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
xorl %edx, %edx
callq 0x6db70
movq 0x18(%rsp), %r15
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6a110
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x6d1f0
leaq 0x21f39(%rip), %rsi # 0x1d4ff7
movq %rax, %rdi
callq 0x6bc60
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x6bc60
leaq 0x1fb41(%rip), %rsi # 0x1d2c25
movq %rax, %rdi
callq 0x6bc60
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b3107
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x68760
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3116
callq 0x69d60
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3125
callq 0x69d60
callq 0x6c2d0
movl $0x2, %eax
jmp 0x1b3054
movq %rax, %rbx
jmp 0x1b3161
movq %rax, %rbx
jmp 0x1b3170
movq %rax, %rbx
jmp 0x1b317f
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b3161
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x68760
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3170
callq 0x69d60
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b317f
callq 0x69d60
callq 0x6c2d0
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
testq %rax, %rax
je 0x1b3277
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1b32a3
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b329b
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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 0x1b302e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3302
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1b332e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3326
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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";
}
return nullptr;
} | 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), %rsi
movq %rax, %rdi
callq 0x1b3a82
jmp 0x1b3387
xorl %r15d, %r15d
leaq 0x8(%rsp), %rdi
callq 0xdf59a
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r14
movl $0x148, %esi # imm = 0x148
movq %r15, %rdi
callq 0x68760
jmp 0x1b33bb
movq %rdx, %r12
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdf59a
jmp 0x1b33cd
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0x1b34ea
movq %r14, %rdi
callq 0x683f0
movq %rax, %r14
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x6ec70
movq 0x28(%rsp), %rsi
leaq 0x38(%rsp), %rdi
xorl %edx, %edx
callq 0x6db70
movq 0x38(%rsp), %r15
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6a110
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x6d1f0
leaq 0x21bd1(%rip), %rsi # 0x1d4ff7
movq %rax, %rdi
callq 0x6bc60
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6bc60
leaq 0x1f7d9(%rip), %rsi # 0x1d2c25
movq %rax, %rdi
callq 0x6bc60
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b346f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1b347e
callq 0x69d60
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1b348d
callq 0x69d60
callq 0x6c2d0
xorl %r15d, %r15d
jmp 0x1b3391
movq %rax, %r14
jmp 0x1b34c7
movq %rax, %r14
jmp 0x1b34d6
movq %rax, %r14
jmp 0x1b34e5
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b34c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1b34d6
callq 0x69d60
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1b34e5
callq 0x69d60
callq 0x6c2d0
movq %r14, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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), %rax # 0x1b39c0
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x1b302e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b355d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x1b358b
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3583
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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 %rsp, %rdi
callq 0x6b490
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x6e740
| /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
testq %rax, %rax
je 0x1b3736
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
jmp 0x1b3762
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b375a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
movq %rax, 0x18(%r12)
movq 0x95839(%rip), %rax # 0x248ff0
movq %rax, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x6aad0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b37de
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1b380e
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3806
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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(%rbx)
leaq 0xc0(%rbx), %rcx
movl %eax, 0xc0(%rbx)
movq %rax, 0xc8(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movb %al, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
movw $0x0, 0xb0(%rbx)
movq %rcx, 0xd0(%rbx)
movq %rcx, 0xd8(%rbx)
movq %rax, 0xe0(%rbx)
movl %eax, 0xe8(%rbx)
leaq 0xf8(%rbx), %rcx
movl %eax, 0xf8(%rbx)
movq %rax, 0x100(%rbx)
movq %rcx, 0x108(%rbx)
movq %rcx, 0x110(%rbx)
leaq 0x138(%rbx), %rcx
movups %xmm0, 0x118(%rbx)
movq %rcx, 0x128(%rbx)
movq %rax, 0x130(%rbx)
movb %al, 0x138(%rbx)
popq %rbx
retq
nop
| /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 0x1b3d48
lock
incl 0x8(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b3d57
callq 0x69d60
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x68760
movq %r14, %rdi
callq 0x6b780
| /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)
movq $0x0, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, (%rbx)
leaq 0x377(%rip), %rax # 0x1b4198
movq %rax, 0x18(%rbx)
leaq 0x37c(%rip), %rax # 0x1b41a8
movq %rax, 0x10(%rbx)
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
callq 0x1b3fb1
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1b3e61
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b3e96
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x1b3e8e
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, (%r13)
leaq 0x401(%rip), %rax # 0x1b4336
movq %rax, 0x18(%r13)
leaq 0x40a(%rip), %rax # 0x1b434a
movq %rax, 0x10(%r13)
leaq 0x2696e(%rip), %rcx # 0x1da8b9
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
movq %r14, %r8
movq %rbx, %r9
callq 0x1b3fb1
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3f76
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b3fa9
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1b3fa1
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x6b780
movq %rax, %rdi
callq 0x7cc8d
| /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: ";
what += buf;
throw std::runtime_error(what);
}
ERR_clear_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 $0x100, %edx # imm = 0x100
movq %rax, %rdi
movq %rbx, %rsi
callq 0x698d0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x26712(%rip), %rsi # 0x1dac8b
leaq 0x2671a(%rip), %rdx # 0x1dac9a
movq %rsp, %r14
movq %r14, %rdi
callq 0x68bb0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b8d0
movl $0x10, %edi
callq 0x6a000
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0x695f0
movq 0x948eb(%rip), %rsi # 0x248ea0
movq 0x9480c(%rip), %rdx # 0x248dc8
movq %r14, %rdi
callq 0x6b420
movq %rax, %rbx
movq %r14, %rdi
callq 0x6cf40
jmp 0x1b45d4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b45ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rdi
callq 0x6b780
| /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);
return;
}
sha2_bits = static_cast<size_t>(bits);
check_openssl(EVP_MD_CTX_reset(md_ctx));
check_openssl(EVP_DigestInit_ex(md_ctx, md, nullptr));
} | 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 # imm = 0x200
jne 0x1b46ea
callq 0x6e2c0
jmp 0x1b4674
callq 0x6e990
jmp 0x1b4674
callq 0x68300
movq %rax, 0x9927d(%rip) # 0x24d8f8
movslq %r14d, %rax
movq %rax, 0x58(%rbx)
movq 0x8(%rbx), %rdi
callq 0x6a7f0
movl %eax, %edi
callq 0x1b451e
movq 0x8(%rbx), %rdi
movq 0x9925b(%rip), %rsi # 0x24d8f8
xorl %edx, %edx
callq 0x6d0f0
movl %eax, %edi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b451e
leaq 0x99240(%rip), %rdi # 0x24d900
callq 0x69d10
testl %eax, %eax
je 0x1b4642
callq 0x6e2c0
movq %rax, 0x9921f(%rip) # 0x24d8f8
leaq 0x99220(%rip), %rdi # 0x24d900
callq 0x6aef0
jmp 0x1b4642
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rsi
movq $0x18, (%rsi)
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x6ba80
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movups 0x2656c(%rip), %xmm0 # 0x1dac9b
movups %xmm0, (%rax)
movabsq $0x203a6874676e656c, %rdx # imm = 0x203A6874676E656C
movq %rdx, 0x10(%rax)
movq %rcx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, (%rax,%rcx)
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x1b47ab
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1b47a2
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x1b47a8
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x1b47ab
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x1b476f
addl $-0x3, %r15d
jmp 0x1b47ab
addl $-0x2, %r15d
jmp 0x1b47ab
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x48(%rsp), %rdi
movl $0x2d, %edx
callq 0x6b1f0
movl %r14d, %edi
addq 0x48(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x6c7a0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r12, %rcx
je 0x1b47ff
movq 0x38(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x1b481a
movl $0xf, %esi
cmpq %r13, 0x48(%rsp)
je 0x1b4815
movq 0x58(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x1b482b
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x6bfe0
jmp 0x1b4839
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x68b10
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
jne 0x1b4856
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
jmp 0x1b4863
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x68960
xorl %ebp, %ebp
movq 0x9471f(%rip), %rsi # 0x248fb8
movq 0x94688(%rip), %rdx # 0x248f28
movq %rbx, %rdi
callq 0x6b420
movq %rax, %r14
leaq 0x9904e(%rip), %rdi # 0x24d900
callq 0x6a270
jmp 0x1b492a
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b48df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
jmp 0x1b48df
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x1b48fe
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x68760
jmp 0x1b48fe
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b491d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x68760
jmp 0x1b491d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b492a
movq %rbx, %rdi
callq 0x6cf40
movq %r14, %rdi
callq 0x6b780
| /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(reinterpret_cast<const char*>(key_data)));
}
check_openssl(EVP_EncryptInit_ex(cipher_ctx, rc4, nullptr, nullptr, nullptr));
check_openssl(EVP_CIPHER_CTX_set_key_length(cipher_ctx, key_len));
check_openssl(EVP_EncryptInit_ex(cipher_ctx, nullptr, nullptr, key_data, nullptr));
} | 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 # imm = 0x80000000
je 0x1b4a33
movq %r15, %rdi
callq 0xb820c
movq 0x10(%r14), %rdi
movq 0x98eca(%rip), %rsi # 0x24d908
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x68f30
movl %eax, %edi
callq 0x1b451e
movq 0x10(%r14), %rdi
movl %r15d, %esi
callq 0x69d00
movl %eax, %edi
callq 0x1b451e
movq 0x10(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x68f30
movl %eax, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x1b451e
leaq 0x98e86(%rip), %rdi # 0x24d910
callq 0x69d10
testl %eax, %eax
je 0x1b4a02
callq 0x1b4acc
movq %rax, 0x98e65(%rip) # 0x24d908
leaq 0x98e66(%rip), %rdi # 0x24d910
callq 0x6aef0
jmp 0x1b4a02
movq %rax, %rbx
leaq 0x98e52(%rip), %rdi # 0x24d910
callq 0x6a270
movq %rbx, %rdi
callq 0x6b780
nop
| /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
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b4cb0
movq %rbx, %rdi
callq 0x1b4d9a
leaq 0x2f1(%rip), %rdi # 0x1b4e12
leaq 0x98df0(%rip), %rsi # 0x24d918
leaq 0x97e21(%rip), %rdx # 0x24c950
callq 0x6ce50
leaq 0x98ded(%rip), %rdi # 0x24d928
callq 0x6aef0
jmp 0x1b4ada
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x68760
jmp 0x1b4b57
movq %rax, %r14
leaq 0x98dca(%rip), %rdi # 0x24d928
callq 0x6a270
movq %r14, %rdi
callq 0x6b780
nop
| /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::runtime_error("unable to load openssl legacy provider");
return;
}
rc4 = EVP_CIPHER_fetch(libctx, "RC4", nullptr);
if (rc4 == nullptr) {
OSSL_PROVIDER_unload(legacy);
OSSL_LIB_CTX_free(libctx);
throw std::runtime_error("unable to load openssl rc4 algorithm");
return;
}
} | 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
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1b4d40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x25fa1(%rip), %rsi # 0x1dacb4
movq %rax, %rdi
callq 0x69460
jmp 0x1b4d6d
callq 0x6dee0
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x25fae(%rip), %rsi # 0x1dace4
movq %rax, %rdi
callq 0x69460
jmp 0x1b4d6d
movq (%rbx), %rdi
callq 0x687c0
movq 0x8(%rbx), %rdi
callq 0x6dee0
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x25fa6(%rip), %rsi # 0x1dad0b
movq %rax, %rdi
callq 0x69460
movq 0x9412c(%rip), %rsi # 0x248ea0
movq 0x9404d(%rip), %rdx # 0x248dc8
movq %rbx, %rdi
callq 0x6b420
jmp 0x1b4d87
jmp 0x1b4d87
movq %rax, %r14
movq %rbx, %rdi
callq 0x6cf40
movq %r14, %rdi
callq 0x6b780
| /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 you are getting snippets many time from the same file, it is
// somewhat a waste of CPU, feel free to benchmark and propose a
// better solution ;)
_file->clear();
_file->seekg(0);
string line;
unsigned line_idx;
for (line_idx = 1; line_idx < line_start; ++line_idx) {
std::getline(*_file, line);
if (!*_file) {
return lines;
}
}
// think of it like a lambda in C++98 ;)
// but look, I will reuse it two times!
// What a good boy am I.
struct isspace {
bool operator()(char c) { return std::isspace(c); }
};
bool started = false;
for (; line_idx < line_start + line_count; ++line_idx) {
getline(*_file, line);
if (!*_file) {
return lines;
}
if (!started) {
if (std::find_if(line.begin(), line.end(), not_isspace()) == line.end())
continue;
started = true;
}
lines.push_back(make_pair(line_idx, line));
}
lines.erase(
std::find_if(lines.rbegin(), lines.rend(), not_isempty()).base(),
lines.end());
return lines;
} | 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
movq (%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0x158(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xde2f0
movq 0x78(%rsp), %rdi
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
callq 0x14a80
leaq 0x138(%rsp), %rdi
callq 0x14b90
movl $0x1, 0x134(%rsp)
movl 0x134(%rsp), %eax
cmpl 0x174(%rsp), %eax
jae 0xdde4c
movq 0x70(%rsp), %rdi
callq 0xde320
movq %rax, 0x68(%rsp)
jmp 0xdddb2
movq 0x68(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x14160
jmp 0xdddc6
movq 0x70(%rsp), %rdi
callq 0xde320
movq %rax, 0x60(%rsp)
jmp 0xdddd7
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x143d0
movb %al, 0x5f(%rsp)
jmp 0xdddf1
movb 0x5f(%rsp), %al
testb $0x1, %al
jne 0xdddfb
jmp 0xdde34
movq 0x168(%rsp), %rax
movq %rax, 0x180(%rsp)
movl $0x1, 0x120(%rsp)
jmp 0xde10a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x128(%rsp)
movl %eax, 0x124(%rsp)
jmp 0xde127
jmp 0xdde36
movl 0x134(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x134(%rsp)
jmp 0xddd8d
movb $0x0, 0x11f(%rsp)
movl 0x134(%rsp), %eax
movl 0x174(%rsp), %ecx
addl 0x170(%rsp), %ecx
cmpl %ecx, %eax
jae 0xde011
movq 0x70(%rsp), %rdi
callq 0xde320
movq %rax, 0x50(%rsp)
jmp 0xdde82
movq 0x50(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0x14160
jmp 0xdde96
movq 0x70(%rsp), %rdi
callq 0xde320
movq %rax, 0x48(%rsp)
jmp 0xddea7
movq 0x48(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x143d0
movb %al, 0x47(%rsp)
jmp 0xddec1
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0xddecb
jmp 0xddeeb
movq 0x168(%rsp), %rax
movq %rax, 0x180(%rsp)
movl $0x1, 0x120(%rsp)
jmp 0xde10a
testb $0x1, 0x11f(%rsp)
jne 0xddf88
leaq 0x138(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x146e0
movq 0x30(%rsp), %rdi
movq %rax, 0x108(%rsp)
callq 0x144d0
movq %rax, 0x100(%rsp)
movq 0x108(%rsp), %rdi
movq 0x100(%rsp), %rsi
callq 0xde370
movq %rax, 0x38(%rsp)
jmp 0xddf41
movq 0x38(%rsp), %rax
movq %rax, 0x110(%rsp)
leaq 0x138(%rsp), %rdi
callq 0x144d0
movq %rax, 0xf0(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xde330
testb $0x1, %al
jne 0xddf7e
jmp 0xddf80
jmp 0xddfd5
movb $0x1, 0x11f(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0x134(%rsp), %rsi
leaq 0x138(%rsp), %rdx
callq 0xde3f0
jmp 0xddfb4
movq 0x28(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xde3c0
jmp 0xddfc8
leaq 0xc8(%rsp), %rdi
callq 0xde430
movl 0x134(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x134(%rsp)
jmp 0xdde54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x128(%rsp)
movl %eax, 0x124(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xde430
jmp 0xde127
movq 0x168(%rsp), %rsi
movq %rsi, 0x10(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xde560
movq 0x168(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xde5b0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
callq 0xde4f0
jmp 0xde063
leaq 0xb0(%rsp), %rdi
callq 0xde600
movq %rax, 0x8(%rsp)
jmp 0xde077
movq 0x8(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xdb9b0
movq 0x168(%rsp), %rdi
callq 0xdba30
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xdb9b0
movq 0x10(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xde450
movq %rax, (%rsp)
jmp 0xde0e3
movq (%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x180(%rsp)
movl $0x1, 0x120(%rsp)
leaq 0x138(%rsp), %rdi
callq 0x15038
movq 0x180(%rsp), %rax
addq $0x188, %rsp # imm = 0x188
retq
leaq 0x138(%rsp), %rdi
callq 0x15038
movq 0x128(%rsp), %rdi
callq 0x14e80
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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), %rsi
movl $0x1, %ecx
movq %r12, %rdi
xorl %edx, %edx
movl %ebp, %r8d
callq 0x45b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x40f0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9a5c
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x9a63
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rsi
leaq 0x28(%rsp), %rdx
movq %rsi, 0x8(%rdx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x987a
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9aa1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9ab8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9aeb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4370
jmp 0x9aeb
jmp 0x9ae8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9b02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbx, %rdi
callq 0x4580
| /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
leaq 0xf(%rsp), %rsi
callq 0xa17e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0xa258
movq %rbx, %rdi
callq 0xa2a4
movq %r15, %rdi
callq 0x4580
| /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 %rax, 0x8(%rsp)
leaq 0x48(%rax), %r15
cmpq %r15, %r13
je 0xba91
movq 0x8(%rsp), %rax
leaq 0x20(%rax), %rbp
leaq 0x20(%r13), %rcx
movq 0x48(%r14), %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0xbc2e
leaq 0x40(%r13), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc0b4
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xba81
movq 0x28(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x4370
movq %r13, %rdi
callq 0x43f0
movq %rax, %r13
cmpq %r15, %rax
jne 0xba3e
movq 0x8(%rsp), %rdi
callq 0x43f0
cmpq 0x10(%rsp), %rax
jne 0xba23
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xbadd
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0xbadd
movq 0x28(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x4370
movq %rbx, %rdi
callq 0xb9b6
movq %r14, %rdi
callq 0x4580
nop
| /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::string(ptr + offset);
//cout << "value: " << value << endl;
offset = offset + value_.size() + 1;
timescale_ = fmp4_read_uint32(ptr + offset);
offset += 4;
//cout << "timescale: " << timescale << endl;
presentation_time_delta_ = fmp4_read_uint32(ptr + offset);
offset += 4;
//cout << "presentation_time_delta: " << presentation_time_delta << endl;
event_duration_ = fmp4_read_uint32(ptr + offset);
offset += 4;
//cout << "event_duration: " << event_duration << endl;
id_ = fmp4_read_uint32(ptr + offset);
//cout << "id: " << id << endl;
offset += 4;
}
else
{
timescale_ = fmp4_read_uint32(ptr + offset);
//cout << "timescale: " << timescale << endl;
offset += 4;
presentation_time_ = fmp4_read_uint64(ptr + offset);
//cout << "presentation time: " << presentation_time << endl;
offset += 8;
event_duration_ = fmp4_read_uint32(ptr + offset);
//cout << "event duration: " << event_duration << endl;
offset += 4;
id_ = fmp4_read_uint32(ptr + offset);
offset += 4;
//cout << "id: " << id << endl;
scheme_id_uri_ = std::string(ptr + offset);
offset = offset + scheme_id_uri_.size() + 1;
//cout << "scheme_id_uri: " << scheme_id_uri << endl;
value_ = std::string(ptr + offset);
//cout << "value: " << value << endl;
offset = offset + value_.size() + 1;
}
for (unsigned int i = (unsigned int)offset; i < data_size; i++)
{
message_data_.push_back(*(ptr + (size_t)i));
}
} | 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)
movzbl 0x62(%rax), %eax
cmpl $0x0, %eax
jne 0x775d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xf0(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3410
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3bb0
jmp 0x758c
movq -0xe0(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x110(%rbp)
leaq -0x40(%rbp), %rsi
movq %rsi, -0x118(%rbp)
callq 0x32c0
movq -0x118(%rbp), %rdi
callq 0x34c8
leaq -0x41(%rbp), %rdi
callq 0x3250
movq -0x110(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x3160
movq %rax, %rcx
movq -0x108(%rbp), %rax
leaq 0x1(%rax,%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x100(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3410
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x3bb0
jmp 0x7628
movq -0xe0(%rbp), %rdi
addq $0x90, %rdi
leaq -0x78(%rbp), %rsi
callq 0x32c0
leaq -0x78(%rbp), %rdi
callq 0x34c8
leaq -0x79(%rbp), %rdi
callq 0x3250
movq -0xe0(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x120(%rbp)
addq $0x90, %rdi
callq 0x3160
movq %rax, %rcx
movq -0x120(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xb4(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xc4(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x798f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3250
jmp 0x79eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x3250
jmp 0x79eb
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq %rax, %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq %rax, %rdi
callq 0x4e50
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq %rax, %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xc0(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
addq %rax, %rdi
callq 0x4e10
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0xc4(%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x130(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x3410
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x3bb0
jmp 0x784c
movq -0xe0(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x150(%rbp)
leaq -0xa0(%rbp), %rsi
movq %rsi, -0x158(%rbp)
callq 0x32c0
movq -0x158(%rbp), %rdi
callq 0x34c8
leaq -0xa1(%rbp), %rdi
callq 0x3250
movq -0x150(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x148(%rbp)
callq 0x3160
movq %rax, %rcx
movq -0x148(%rbp), %rax
leaq 0x1(%rax,%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x3410
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0xc8(%rbp), %rdi
callq 0x3bb0
jmp 0x78f4
movq -0xe0(%rbp), %rdi
addq $0x90, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x32c0
leaq -0xc8(%rbp), %rdi
callq 0x34c8
leaq -0xc9(%rbp), %rdi
callq 0x3250
movq -0xe0(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x160(%rbp)
addq $0x90, %rdi
callq 0x3160
movq %rax, %rcx
movq -0x160(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x798f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa1(%rbp), %rdi
callq 0x3250
jmp 0x79eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc9(%rbp), %rdi
callq 0x3250
jmp 0x79eb
movq -0x20(%rbp), %rax
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x79e2
movq -0xe0(%rbp), %rdi
addq $0xc8, %rdi
movq -0x10(%rbp), %rax
movl -0xd0(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0xd1(%rbp)
leaq -0xd1(%rbp), %rsi
callq 0xc3b0
movl -0xd0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd0(%rbp)
jmp 0x7999
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
| /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_ << '"';
if (this->scheme_id_uri_.compare("urn:scte:scte35:2013:bin") == 0) // write binary scte as xml + bin as defined by scte-35
{
ostr << '>' << std::endl << " <signal xmlns=" << '"' << "http://www.scte.org/schemas/35/2016" << '"' << '>' << std::endl \
<< " <binary>" << base64_encode(this->message_data_.data(), (unsigned int)this->message_data_.size()) << "</binary>" << std::endl
<< " </signal>" << std::endl;
}
else {
ostr << " " << "contentencoding=" << '"' << "base64" << '"' << '>' << std::endl
<< base64_encode(this->message_data_.data(), (unsigned int)this->message_data_.size()) << std::endl;
}
ostr << "</event>" << std::endl;
} | 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 0x31f0
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x70(%rbp)
cmpb $0x0, 0x62(%rax)
je 0x7a6d
movq -0x78(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x80(%rbp)
jmp 0x7a82
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0xb4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x3070
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq %rax, %rdi
leaq 0xc7cc(%rip), %rsi # 0x14272
callq 0x31f0
movq %rax, %rdi
leaq 0xcba8(%rip), %rsi # 0x1465d
callq 0x31f0
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq %rax, %rdi
movq -0x78(%rbp), %rax
movl 0xc0(%rax), %esi
callq 0x3330
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq %rax, %rdi
leaq 0xc782(%rip), %rsi # 0x14272
callq 0x31f0
movq %rax, %rdi
leaq 0xcb68(%rip), %rsi # 0x14667
callq 0x31f0
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq %rax, %rdi
movq -0x78(%rbp), %rax
movl 0xc4(%rax), %esi
callq 0x3330
movq %rax, %rdi
movl $0x22, %esi
callq 0x32b0
movq -0x78(%rbp), %rdi
addq $0x70, %rdi
leaq 0xcb2c(%rip), %rsi # 0x1466b
callq 0x30a0
cmpl $0x0, %eax
jne 0x7cdb
movq -0x10(%rbp), %rdi
movl $0x3e, %esi
movl %esi, -0xb4(%rbp)
callq 0x32b0
movq %rax, %rdi
movq 0x1444d(%rip), %rsi # 0x1bfb8
movq %rsi, -0xb0(%rbp)
callq 0x3230
movq %rax, %rdi
leaq 0xcb03(%rip), %rsi # 0x14684
callq 0x31f0
movq %rax, %rdi
movl $0x22, %esi
movl %esi, -0xb8(%rbp)
callq 0x32b0
movq %rax, %rdi
leaq 0xcaf2(%rip), %rsi # 0x14695
callq 0x31f0
movl -0xb8(%rbp), %esi
movq %rax, %rdi
callq 0x32b0
movl -0xb4(%rbp), %esi
movq %rax, %rdi
callq 0x32b0
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
leaq 0xcadc(%rip), %rsi # 0x146b9
callq 0x31f0
movq -0x78(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0xc8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc3e0
movq -0xa8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0xbf40
movq -0xa0(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x131f0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x31d0
movq %rax, -0x88(%rbp)
jmp 0x7c4a
movq -0x88(%rbp), %rdi
leaq 0xca6e(%rip), %rsi # 0x146c6
callq 0x31f0
movq %rax, -0xc0(%rbp)
jmp 0x7c66
movq -0xc0(%rbp), %rdi
movq 0x14344(%rip), %rsi # 0x1bfb8
callq 0x3230
movq %rax, -0xc8(%rbp)
jmp 0x7c82
movq -0xc8(%rbp), %rdi
leaq 0xca40(%rip), %rsi # 0x146d0
callq 0x31f0
movq %rax, -0xd0(%rbp)
jmp 0x7c9e
movq -0xd0(%rbp), %rdi
movq 0x1430c(%rip), %rsi # 0x1bfb8
callq 0x3230
jmp 0x7cb3
leaq -0x38(%rbp), %rdi
callq 0x34c8
jmp 0x7de5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34c8
jmp 0x7e0d
movq -0x10(%rbp), %rdi
leaq 0xc58c(%rip), %rsi # 0x14272
callq 0x31f0
movq %rax, %rdi
leaq 0xc9e7(%rip), %rsi # 0x146dc
callq 0x31f0
movq %rax, %rdi
movl $0x22, %esi
movl %esi, -0xfc(%rbp)
callq 0x32b0
movq %rax, %rdi
leaq 0xc9d6(%rip), %rsi # 0x146ed
callq 0x31f0
movl -0xfc(%rbp), %esi
movq %rax, %rdi
callq 0x32b0
movq %rax, %rdi
movl $0x3e, %esi
callq 0x32b0
movq %rax, %rdi
movq 0x14277(%rip), %rsi # 0x1bfb8
callq 0x3230
movq -0x78(%rbp), %rdi
movq %rax, -0xe8(%rbp)
addq $0xc8, %rdi
movq %rdi, -0xf8(%rbp)
callq 0xc3e0
movq -0xf8(%rbp), %rdi
movq %rax, -0xf0(%rbp)
callq 0xbf40
movq -0xf0(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x131f0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x31d0
movq %rax, -0xd8(%rbp)
jmp 0x7dae
movq -0xd8(%rbp), %rdi
movq 0x141fc(%rip), %rsi # 0x1bfb8
callq 0x3230
jmp 0x7dc3
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0x7de5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x34c8
jmp 0x7e0d
movq -0x10(%rbp), %rdi
leaq 0xc904(%rip), %rsi # 0x146f4
callq 0x31f0
movq %rax, %rdi
movq 0x141b9(%rip), %rsi # 0x1bfb8
callq 0x3230
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
| /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 (&) [19], Qentem::StringStream<char> const&, char const (&) [4]) | 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 > 201402L
((*GetStreamCache()) << ... << values);
#else
const int dummy[sizeof...(Values_T)] = {((*GetStreamCache()) << values, 0)...};
(void)dummy;
#endif
}
} | 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 # 0x1e098
movq 0x50(%rsp), %r13
testq %rax, %rax
jne 0x10dba
movq 0xd220(%rip), %rax # 0x1dfd8
jmp 0x10dbe
addq $0x10, %rax
movq (%rdi), %rsi
movq %rax, %rdi
callq 0x1030
movq %rax, %rdi
movq %r15, %rsi
callq 0x1030
movq (%r14), %rsi
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1030
movq (%rbp), %rsi
movq %rax, %rdi
callq 0x1030
movq %rax, %rdi
movq %r12, %rsi
callq 0x1030
movq %rax, %rdi
movq %r13, %rsi
callq 0x1030
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x1030
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xd39c
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
| /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()) {
case 0:
{
// Simple template string
auto description = std::get<0>(*object_description);
if (auto pos = description.find("$OG"); pos != std::string::npos) {
description.replace(pos, 3, og.unparse(' '));
}
if (auto pos = description.find("$PO"); pos != std::string::npos) {
description.replace(pos, 3, std::to_string(parsed_offset + shift));
}
return description;
}
case 1:
{
// QPDF::JSONReactor generated description
auto j_descr = std::get<1>(*object_description);
return (
*j_descr.input + (j_descr.object.empty() ? "" : ", " + j_descr.object) +
" at offset " + std::to_string(parsed_offset));
}
case 2:
{
// Child object description
auto j_descr = std::get<2>(*object_description);
std::string result;
if (auto p = j_descr.parent.lock()) {
result = p->getDescription();
}
result += j_descr.static_descr;
if (auto pos = result.find("$VD"); pos != std::string::npos) {
result.replace(pos, 3, j_descr.var_descr);
}
return result;
}
case 3:
auto [stream_id, obj_id] = std::get<3>(*object_description);
std::string result = qpdf ? qpdf->getFilename() : "";
result += " object stream " + std::to_string(stream_id) + ", object " +
std::to_string(obj_id) + " 0 at offset " + std::to_string(parsed_offset + shift);
return result;
}
} else if (og.isIndirect()) {
return "object " + og.unparse(' ');
}
return {};
} | 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
callq *0x18(%rax)
movq %r14, (%rbx)
movl %ebp, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| /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_wanted > bits_available) {
throw std::runtime_error(
"overflow reading bit stream: wanted = " + std::to_string(bits_wanted) +
"; available = " + std::to_string(bits_available));
}
if (bits_wanted > 32) {
throw std::out_of_range("read_bits: too many bits requested");
}
unsigned long result = 0;
# ifdef BITS_TESTING
if (bits_wanted == 0) {
QTC::TC("libtests", "bits zero bits wanted");
}
# endif
while (bits_wanted > 0) {
// Grab bits from the first byte clearing anything before
// bit_offset.
unsigned char byte = static_cast<unsigned char>(*p & ((1U << (bit_offset + 1U)) - 1U));
// There are bit_offset + 1 bits available in the first byte.
size_t to_copy = std::min(bits_wanted, bit_offset + 1);
size_t leftover = (bit_offset + 1) - to_copy;
# ifdef BITS_TESTING
QTC::TC("libtests", "bits bit_offset", ((bit_offset == 0) ? 0 : (bit_offset == 7) ? 1 : 2));
QTC::TC("libtests", "bits leftover", (leftover > 0) ? 1 : 0);
# endif
// Right shift so that all the bits we want are right justified.
byte = static_cast<unsigned char>(byte >> leftover);
// Copy the bits into result
result <<= to_copy;
result |= byte;
// Update pointers
if (leftover) {
bit_offset = leftover - 1;
} else {
bit_offset = 7;
++p;
}
bits_wanted -= to_copy;
bits_available -= to_copy;
# ifdef BITS_TESTING
QTC::TC("libtests", "bits iterations", ((bits_wanted > 8) ? 0 : (bits_wanted > 0) ? 1 : 2));
# endif
}
return result;
} | 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 %r8b
andb (%r9), %r8b
incq %r10
cmpq %r15, %r10
movq %r15, %rdx
cmovbq %r10, %rdx
movzbl %r8b, %r11d
movq %r10, %r8
subq %rdx, %r8
movl %r8d, %ecx
shrl %cl, %r11d
movl %edx, %ecx
shlq %cl, %rax
cmpq %r15, %r10
jbe 0x1d384
decq %r8
jmp 0x1d390
incq %r9
movq %r9, (%rdi)
movl $0x7, %r8d
orq %r11, %rax
movq %r8, (%rsi)
subq %rdx, (%r14)
subq %rdx, %r15
jne 0x1d342
jmp 0x1d3a2
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1d795
leaq 0x13fcd9(%rip), %rsi # 0x15d0aa
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x1d725
leaq 0x13fcea(%rip), %rsi # 0x15d0d1
leaq 0x68(%rsp), %rdi
callq 0x19730
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1d444
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1d451
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x13fcba(%rip), %rsi # 0x15d0e0
movq %rax, %rdi
callq 0x192c0
movq 0x1d2adb(%rip), %rsi # 0x1eff10
movq 0x1d2b3c(%rip), %rdx # 0x1eff78
movq %rbx, %rdi
callq 0x196e0
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1d795
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1d67d
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1d2af7(%rip), %rsi # 0x1effa0
movq 0x1d2ac0(%rip), %rdx # 0x1eff70
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d4e4
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1d4e4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d507
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1d507
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d526
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1d526
movq %rax, %r14
movb $0x1, %bpl
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d541
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d55c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x1d588
jmp 0x1d590
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d588
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x1d588
jmp 0x1d585
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
| /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_available -= bits_to_skip;
}
} | 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 # 0x15d06e
movq %rax, %rdi
callq 0x19970
movq 0x1d2995(%rip), %rsi # 0x1efff0
movq 0x1d295e(%rip), %rdx # 0x1effc0
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
| /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
nop
| /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:
QIntC::range_check(this->cur_offset, offset);
this->cur_offset += offset;
break;
default:
throw std::logic_error("INTERNAL ERROR: invalid argument to BufferInputSource::seek");
break;
}
if (this->cur_offset < 0) {
throw std::runtime_error(this->description + ": seek before beginning of buffer");
}
} | 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 # 0x1efff0
movq 0x1d1bdf(%rip), %rdx # 0x1effc0
movq %r14, %rdi
callq 0x196e0
leaq 0xd8(%rbx), %r14
testq %rsi, %rsi
setg %cl
movq 0xd8(%rbx), %rax
testq %rax, %rax
setle %dl
cmpb %dl, %cl
je 0x1e41b
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e83c
movq (%r15), %rsi
movq (%r14), %rax
addq %rax, %rsi
movq %rsi, (%r14)
jmp 0x1e45f
testq %rsi, %rsi
setg %cl
movq 0xe0(%rbx), %rax
testq %rax, %rax
setle %dl
cmpb %dl, %cl
je 0x1e455
leaq 0xe0(%rbx), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1e83c
movq (%r14), %rax
movq (%r15), %rsi
addq %rax, %rsi
movq %rsi, 0xd8(%rbx)
testq %rsi, %rsi
js 0x1e46f
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
addq $0xb0, %rbx
leaq 0x13ee2c(%rip), %rdx # 0x15d2b6
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1e5ef
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1d1af0(%rip), %rsi # 0x1effa0
movq 0x1d1ab9(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x1e4e6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e4df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x1e4e9
jmp 0x1e4f1
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
movq %rbx, %rdi
callq 0x19710
nop
| /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 %rbx, %rdi
callq 0x13e0c4
movq %rax, 0xd0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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;
result = this->tell();
} else {
char* p1 = static_cast<char*>(memchr(buf, '\r', len));
char* p2 = static_cast<char*>(memchr(buf, '\n', len));
char* p = (p1 && p2) ? std::min(p1, p2) : p1 ? p1 : p2;
if (p) {
result = cur_offset + (p - buf);
// We found \r or \n. Keep reading until we get past \r and \n characters.
this->seek(result + 1, SEEK_SET);
char ch;
while (!done) {
if (this->read(&ch, 1) == 0) {
done = true;
} else if (!((ch == '\r') || (ch == '\n'))) {
this->unreadCh(ch);
done = true;
}
}
}
}
}
return result;
} | 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, %edx # imm = 0x2800
movq %rbx, %rdi
movq %r15, %rsi
callq *0x38(%rax)
testq %rax, %rax
je 0x1f7ae
movq %rax, %r14
movq %r15, %rdi
movl $0xd, %esi
movq %rax, %rdx
callq 0x19470
movq %rax, %rbp
movq %r15, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x19470
testq %rbp, %rbp
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x1f721
cmpq %rbp, %rax
cmovaeq %rbp, %rax
jmp 0x1f72d
testq %rbp, %rbp
cmovneq %rbp, %rax
testq %rax, %rax
je 0x1f7a2
movq %rax, %r14
leaq 0x20(%rsp), %r15
subq %r15, %r14
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rsi
incq %rsi
movq (%rbx), %rax
movq %rbx, %rdi
xorl %edx, %edx
callq *0x28(%rax)
testb $0x1, %r12b
jne 0x1f78b
movq (%rbx), %rax
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
testq %rax, %rax
je 0x1f78e
movzbl 0xf(%rsp), %eax
cmpl $0xa, %eax
je 0x1f74f
cmpl $0xd, %eax
je 0x1f74f
movq (%rbx), %rcx
movsbl %al, %esi
movq %rbx, %rdi
callq *0x40(%rcx)
jmp 0x1f78e
movl %r12d, %ebp
addq 0x10(%rsp), %r14
movl %ebp, %r12d
testb $0x1, %r12b
je 0x1f6b2
jmp 0x1f7ba
leaq 0x20(%rsp), %r15
movq 0x18(%rsp), %r14
jmp 0x1f796
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %r14
movq %r14, %rax
addq $0x2828, %rsp # imm = 0x2828
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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,
"",
this->last_offset,
(std::string("read ") + std::to_string(length) + " bytes"));
} else if (length > 0) {
this->seek(0, SEEK_END);
this->last_offset = this->tell();
}
}
return len;
} | 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
movq 0xd0(%r14), %rdi
callq 0x19850
testl %eax, %eax
jne 0x1ff4a
testq %r12, %r12
je 0x1ff35
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq *0x28(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq %rax, 0x8(%r14)
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x80, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x15ad7f(%rip), %rdx # 0x17ace6
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x1ef84
movq 0x8(%r14), %r15
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1608ac(%rip), %rsi # 0x180834
leaq 0x1608aa(%rip), %rdx # 0x180839
leaq 0x48(%rsp), %rdi
callq 0x1ef84
leaq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x1d795
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x1d67d
leaq 0x13ec01(%rip), %rsi # 0x15ebc5
leaq 0x88(%rsp), %rdi
callq 0x19730
addq $0xb0, %r14
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1fffd
movups (%rcx), %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2000a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r9
movq %rdx, 0x8(%r9)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %r12b
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
movq %r15, %r8
callq 0x66714
xorl %r12d, %r12d
leaq 0x1c9db5(%rip), %rsi # 0x1e9e00
leaq 0x182(%rip), %rdx # 0x201d4
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x20081
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x20081
movq %rax, %r14
movb $0x1, %r12b
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x200aa
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x200aa
movq %rax, %r14
movb $0x1, %r12b
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x200cd
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x200cd
movq %rax, %r14
movb $0x1, %r12b
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x200e4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x200fb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %r12b, %r12b
jne 0x20121
jmp 0x20129
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x20121
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x20121
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
nop
| /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(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x2022a
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
popq %rbx
jmp 0x19e20
| /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 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r15, %rcx
je 0x20fe8
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x2100b
leaq 0x30(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x21006
movq 0x30(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x21017
leaq 0x40(%rsp), %rdi
callq 0x19810
jmp 0x21025
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x191c0
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x21048
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x2104e
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x1459c8(%rip), %rsi # 0x166a3a
movq %rsp, %rdi
callq 0x19730
leaq 0x70(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x210a1
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
jmp 0x210a8
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
callq 0x30d78
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x210e3
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x210fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21119
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x21130
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x2115c
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x2115c
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2117c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x2117c
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2119c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x2119c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x211b3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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 && !(tos.isArray() || tos.isDictionary())) {
reactor->topLevelScalar();
}
return tos;
} | 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), %rbx
je 0x239b8
movq (%rax), %rcx
movl 0x8(%rcx), %ecx
decl %ecx
cmpl $0x2, %ecx
jb 0x2484c
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%r14), %rax
jmp 0x2484c
leaq 0x4048(%rbx), %r14
leaq 0x14(%rbx), %r12
leaq 0x4028(%rbx), %rax
movq %rax, 0xd0(%rsp)
leaq 0x4090(%rbx), %rax
movq %rax, 0xc0(%rsp)
movq %r14, 0xa8(%rsp)
movq $0x0, 0x4050(%rbx)
movq 0x4048(%rbx), %rax
movb $0x0, (%rax)
movq 0x4020(%rbx), %rax
movl $0x13, %ebp
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x4018(%rbx), %rcx
addq %r12, %rcx
cmpq %rcx, %rax
jne 0x23a5d
movq %r12, 0x4020(%rbx)
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x4000, %edx # imm = 0x4000
movq %r12, %rsi
callq *0x38(%rax)
movq %rax, 0x4018(%rbx)
testq %rax, %rax
je 0x23f45
movq 0x4020(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x1f, %ecx
ja 0x23a97
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0x23a76
cmpl $0xd, %ecx
jne 0x24883
movl 0x10(%rbx), %edx
testl %edx, %edx
jne 0x23fc8
incq %rax
movq %rax, 0x4020(%rbx)
movq 0x4038(%rbx), %rcx
jmp 0x23d3f
movl 0x10(%rbx), %edx
cmpl $0x5a, %ecx
jle 0x23ac8
cmpl $0x7a, %ecx
jg 0x23af1
cmpl $0x5b, %ecx
je 0x23b6b
cmpl $0x5d, %ecx
jne 0x23b2b
cmpl $0xa, %edx
jne 0x23f6c
movq %r14, %rdi
movl $0x5d, %esi
jmp 0x23d22
cmpl $0x20, %ecx
je 0x23b15
cmpl $0x2c, %ecx
je 0x23b97
cmpl $0x3a, %ecx
jne 0x23b2b
cmpl $0xa, %edx
jne 0x23fa9
movq %r14, %rdi
movl $0x3a, %esi
jmp 0x23d22
cmpl $0x7b, %ecx
je 0x23b81
cmpl $0x7d, %ecx
jne 0x23b2b
cmpl $0xa, %edx
jne 0x23f73
movq %r14, %rdi
movl $0x7d, %esi
jmp 0x23d22
cmpl $0xa, %edx
jne 0x23a79
movq %r14, %rdi
movl $0x20, %esi
jmp 0x23d22
cmpl $0xd, %edx
ja 0x24bb3
movl %edx, %edx
leaq 0x139bf7(%rip), %rsi # 0x15d734
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq 0x4038(%rbx), %rcx
movq %rcx, 0x4068(%rbx)
movb (%rax), %dl
cmpb $0x22, %dl
jne 0x23cf4
movl $0xa, 0x10(%rbx)
jmp 0x23d35
cmpl $0xa, %edx
jne 0x23f7a
movq %r14, %rdi
movl $0x5b, %esi
jmp 0x23d22
cmpl $0xa, %edx
jne 0x23f51
movq %r14, %rdi
movl $0x7b, %esi
jmp 0x23d22
cmpl $0xa, %edx
jne 0x23fae
movq %r14, %rdi
movl $0x2c, %esi
jmp 0x23d22
movl $0xa, 0x10(%rbx)
movb (%rax), %cl
movzbl %cl, %eax
cmpl $0x61, %eax
jg 0x23d5a
cmpl $0x22, %eax
je 0x23bd5
cmpl $0x2f, %eax
je 0x23bd5
cmpl $0x5c, %eax
jne 0x2512f
movsbl %cl, %esi
jmp 0x23d1f
leal -0x61(%rcx), %eax
cmpb $0x19, %al
jbe 0x23cc6
jmp 0x25136
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x23d95
cmpb $0x61, %cl
jl 0x23d80
leal -0x57(%rcx), %edx
jmp 0x23d8c
cmpl $0x5c, %ecx
je 0x23d4e
cmpl $0x22, %ecx
jne 0x23cc6
jmp 0x247de
addl $-0x30, %ecx
cmpb $0x9, %cl
jbe 0x23c8a
jmp 0x25136
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
jbe 0x23cc6
cmpl $0x65, %ecx
je 0x23d15
cmpl $0x45, %ecx
je 0x23d15
cmpl $0x2e, %ecx
je 0x23ca9
jmp 0x25136
addl $-0x30, %ecx
cmpb $0x9, %cl
ja 0x25136
movl $0x6, 0x10(%rbx)
jmp 0x23d1c
leal -0x31(%rcx), %edx
cmpb $0x8, %dl
ja 0x23ccb
movl $0x4, 0x10(%rbx)
jmp 0x23d1c
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x23cdd
movl $0x1, 0x10(%rbx)
jmp 0x23d1c
cmpl $0x65, %ecx
je 0x23d15
cmpl $0x45, %ecx
je 0x23d15
cmpl $0x2e, %ecx
jne 0x24fd6
movl $0x5, 0x10(%rbx)
jmp 0x23d1c
leal -0x30(%rcx), %eax
cmpb $0x9, %al
jbe 0x23cc6
jmp 0x25136
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x23d09
movsbl %cl, %esi
jmp 0x23d1f
cmpl $0x30, %ecx
jne 0x24ee4
movl $0x3, 0x10(%rbx)
jmp 0x23d1c
cmpl $0x2d, %ecx
je 0x23ceb
cmpl $0x2b, %ecx
jne 0x25136
movl $0x8, 0x10(%rbx)
jmp 0x23d1c
leal -0x61(%rdx), %ecx
cmpb $0x19, %cl
ja 0x23e0c
movl $0x9, 0x10(%rbx)
jmp 0x23d1c
orl $0x20, %ecx
cmpl $0x65, %ecx
jne 0x25136
movl $0x7, 0x10(%rbx)
movsbl (%rax), %esi
movq %r14, %rdi
callq 0x19d90
movq 0x4020(%rbx), %rax
movq 0x4038(%rbx), %rcx
incq %rax
movq %rax, 0x4020(%rbx)
incq %rcx
movq %rcx, 0x4038(%rbx)
jmp 0x23a1f
movl $0xc, 0x10(%rbx)
jmp 0x23a81
leal -0x6e(%rax), %ecx
cmpl $0x7, %ecx
ja 0x23ecf
leaq 0x1399ff(%rip), %rdx # 0x15d76c
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
movl $0xa, %esi
jmp 0x23d22
cmpb $0x41, %cl
jl 0x25136
leal -0x37(%rcx), %edx
cmpb $0xf, %dl
ja 0x25136
movzbl %dl, %esi
movq 0x4028(%rbx), %rdi
movq 0x4030(%rbx), %rdx
shlq $0x4, %rdx
orq %rdx, %rsi
movq %rsi, 0x4030(%rbx)
incq %rdi
movq %rdi, 0x4028(%rbx)
movq 0x4038(%rbx), %rcx
cmpq $0x4, %rdi
jne 0x23d35
movq %r15, 0x80(%rsp)
leaq -0x5(%rcx), %r15
andl $0xfc00, %edx # imm = 0xFC00
cmpl $0xdc00, %edx # imm = 0xDC00
je 0x23e21
cmpl $0xd800, %edx # imm = 0xD800
jne 0x23e87
cmpq $0x0, 0x80(%rsp)
jne 0x25053
movq %rsi, %r13
jmp 0x23ec3
cmpb $0x2d, %dl
jne 0x23eea
movl $0x2, 0x10(%rbx)
jmp 0x23d1c
addq $-0xb, %rcx
cmpq %rcx, 0x80(%rsp)
jne 0x250c2
movl %r13d, %eax
shll $0xa, %eax
andl $0xffc00, %eax # imm = 0xFFC00
andl $0x3ff, %esi # imm = 0x3FF
addq %rax, %rsi
addq $0x10000, %rsi # imm = 0x10000
movq %rsp, %rdi
callq 0x140eec
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x19810
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x23e82
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
xorl %r15d, %r15d
jmp 0x23ec3
movq %rsp, %rdi
callq 0x140eec
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x19810
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movq 0x80(%rsp), %r15
je 0x23ec3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movl $0xa, 0x10(%rbx)
jmp 0x23d27
cmpl $0x62, %eax
je 0x23f38
cmpl $0x66, %eax
jne 0x2512f
movq %r14, %rdi
movl $0xc, %esi
jmp 0x23d22
leal -0x31(%rdx), %ecx
cmpb $0x8, %cl
jbe 0x23c76
cmpb $0x30, %dl
je 0x23cd4
jmp 0x252c4
movl $0xd, 0x10(%rbx)
movq 0xd0(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
jmp 0x23d27
movq %r14, %rdi
movl $0xd, %esi
jmp 0x23d22
movq %r14, %rdi
movl $0x9, %esi
jmp 0x23d22
movq %r14, %rdi
movl $0x8, %esi
jmp 0x23d22
movb $0x1, 0x4040(%rbx)
movl 0x10(%rbx), %edx
jmp 0x23fc8
testl %edx, %edx
jne 0x23fc8
movq 0x4038(%rbx), %rcx
movq %rcx, 0x4068(%rbx)
movl $0x10, 0x10(%rbx)
jmp 0x23f93
movl $0xf, %ebp
jmp 0x23fae
movl $0x11, %ebp
jmp 0x23fae
testl %edx, %edx
jne 0x23fc8
movq 0x4038(%rbx), %rcx
movq %rcx, 0x4068(%rbx)
movl $0xe, 0x10(%rbx)
incq %rax
movq %rax, 0x4020(%rbx)
incq %rcx
movq %rcx, 0x4038(%rbx)
jmp 0x24005
movl $0x12, %ebp
testl %edx, %edx
jne 0x23fc8
movl %ebp, 0x10(%rbx)
incq %rax
movq %rax, 0x4020(%rbx)
incq 0x4038(%rbx)
jmp 0x24005
cmpq $0x0, 0x4050(%rbx)
je 0x23fee
cmpl $0x9, %edx
ja 0x25136
movl $0x58, %eax
btl %edx, %eax
jae 0x23ff7
movl $0x1, 0x10(%rbx)
jmp 0x24005
testl %edx, %edx
jne 0x24005
jmp 0x247cc
movl $0x202, %eax # imm = 0x202
btl %edx, %eax
jae 0x249c6
cmpl $0x9, 0x4070(%rbx)
je 0x248e0
movb 0x1cd0c0(%rip), %al # 0x1f10d8
testb %al, %al
je 0x247f1
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x4080(%rbx), %rax
cmpq %rax, 0x4078(%rbx)
leaq -0x10(%rax), %rax
leaq 0x1cd087(%rip), %rcx # 0x1f10c8
cmoveq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0xb0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x24076
movq 0x1cbf18(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x24072
incl 0x8(%rax)
jmp 0x24076
lock
incl 0x8(%rax)
movl 0x10(%rbx), %eax
movl $0x0, 0x10(%rbx)
decl %eax
cmpl $0x12, %eax
ja 0x24b42
leaq 0x1396fa(%rip), %rcx # 0x15d78c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsp, %rdi
movq %r14, %rsi
callq 0x21c98
jmp 0x242a6
movl 0x4070(%rbx), %ecx
movl $0x5, %eax
cmpl $0x4, %ecx
je 0x240c9
cmpl $0x7, %ecx
jne 0x24e02
movl $0x8, %eax
movl %eax, 0x4070(%rbx)
jmp 0x247a3
movl 0x4070(%rbx), %eax
andl $-0x2, %eax
cmpl $0x6, %eax
jne 0x24ad1
movq 0x4080(%rbx), %rax
movl -0x18(%rax), %eax
movl %eax, 0x4070(%rbx)
movq 0xb0(%rsp), %rcx
testq %rcx, %rcx
je 0x2410e
movq 0x4038(%rbx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2424e
movq (%rdi), %rax
leaq 0xb0(%rsp), %rsi
callq *0x20(%rax)
jmp 0x24248
movq %rsp, %rdi
callq 0x216c4
jmp 0x242a6
movl 0x4070(%rbx), %eax
orl $0x4, %eax
cmpl $0x5, %eax
jne 0x2428f
movq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x19d20
movq 0x4068(%rbx), %rax
movq %rax, 0x40b0(%rbx)
movl $0x2, 0x4070(%rbx)
jmp 0x247a3
cmpl $0x2, 0x4070(%rbx)
jne 0x24a60
movl $0x3, 0x4070(%rbx)
jmp 0x247a3
movq %rsp, %rdi
callq 0x21958
jmp 0x242a6
movq %r14, %rdi
leaq 0x153e20(%rip), %rsi # 0x177fcd
callq 0x19a80
testl %eax, %eax
je 0x24280
movq %r14, %rdi
leaq 0x1547ac(%rip), %rsi # 0x178970
callq 0x19a80
testl %eax, %eax
je 0x2429c
movq %r14, %rdi
leaq 0x157056(%rip), %rsi # 0x17b231
callq 0x19a80
testl %eax, %eax
jne 0x24f61
movq %rsp, %rdi
callq 0x218ea
jmp 0x242a6
movl 0x4070(%rbx), %eax
cmpl $0x1, %eax
je 0x24209
cmpl $0x4, %eax
jne 0x24e73
movq 0x4080(%rbx), %rax
movl -0x18(%rax), %eax
movl %eax, 0x4070(%rbx)
movq 0xb0(%rsp), %rcx
testq %rcx, %rcx
je 0x24231
movq 0x4038(%rbx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2424e
movq (%rdi), %rax
leaq 0xb0(%rsp), %rsi
callq *0x20(%rax)
movl 0x4070(%rbx), %eax
cmpl $0x9, %eax
je 0x247a3
movq 0x4080(%rbx), %rax
leaq -0x18(%rax), %rcx
movq %rcx, 0x4080(%rbx)
movq -0x8(%rax), %rdi
testq %rdi, %rdi
je 0x247a3
callq 0x1ef14
jmp 0x247a3
movq %rsp, %rdi
movl $0x1, %esi
callq 0x21d32
jmp 0x242a6
movq %rsp, %rdi
movq %r14, %rsi
callq 0x21aec
jmp 0x242a6
movq %rsp, %rdi
xorl %esi, %esi
callq 0x21d32
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x68(%rsp), %rdi
movaps %xmm0, 0x60(%rsp)
testq %rdi, %rdi
je 0x242d4
callq 0x1ef14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x242d4
callq 0x1ef14
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x242f4
movq 0x4068(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq 0x4038(%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x4070(%rbx), %r15d
cmpq $0x9, %r15
ja 0x243cd
leaq 0x1394cc(%rip), %rdx # 0x15d7d8
movslq (%rdx,%r15,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x24337
movq (%rdi), %rax
leaq 0x60(%rsp), %rsi
callq *0x38(%rax)
movl $0x7, %r15d
testb %al, %al
jne 0x243c1
leaq 0xd8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x219d2
movq 0xe0(%rsp), %rdi
movl $0x7, %r15d
jmp 0x243b7
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x24387
movq (%rdi), %rax
movq 0xc0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq *0x30(%rax)
movl $0x4, %r15d
testb %al, %al
jne 0x243c1
leaq 0xe8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movq 0xc0(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x2174c
movq 0xf0(%rsp), %rdi
movl $0x4, %r15d
testq %rdi, %rdi
je 0x243c1
callq 0x1ef14
movl %r15d, 0x4070(%rbx)
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x247a3
movq (%rax), %rcx
movl 0x8(%rcx), %ecx
decl %ecx
cmpl $0x1, %ecx
ja 0x247a3
movq 0x4080(%rbx), %r13
cmpq 0x4088(%rbx), %r13
je 0x24493
movq 0x68(%rsp), %rcx
movl %r15d, (%r13)
movq %rax, 0x8(%r13)
movq %rcx, 0x10(%r13)
testq %rcx, %rcx
je 0x24611
movq 0x1cbb64(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x24606
incl 0x8(%rcx)
jmp 0x24611
testq %rax, %rax
je 0x24449
movq (%rax), %rcx
movl 0x8(%rcx), %ecx
decl %ecx
movl $0x9, %r15d
cmpl $0x2, %ecx
jb 0x243c1
movq 0x4080(%rbx), %r13
cmpq 0x4088(%rbx), %r13
je 0x2454d
movq 0x68(%rsp), %rcx
movl $0x9, (%r13)
movq %rax, 0x8(%r13)
movq %rcx, 0x10(%r13)
testq %rcx, %rcx
je 0x24716
movq 0x1cbafe(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x2470b
incl 0x8(%rcx)
jmp 0x24716
movq 0x4078(%rbx), %rdx
movq %r13, %rbp
subq %rdx, %rbp
movabsq $0x7ffffffffffffff8, %rax # imm = 0x7FFFFFFFFFFFFFF8
cmpq %rax, %rbp
je 0x24f55
movq %rbp, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rdx, 0x80(%rsp)
cmpq %rdx, %r13
movq %rax, %rcx
movl $0x1, %edx
cmoveq %rdx, %rcx
leaq (%rcx,%rax), %r15
movabsq $0x555555555555555, %rdx # imm = 0x555555555555555
cmpq %rdx, %r15
cmovaeq %rdx, %r15
addq %rax, %rcx
cmovbq %rdx, %r15
movq %r15, %rdi
callq 0x2719a
movq %rax, %r14
movl 0x4070(%rbx), %ecx
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rax
movl %ecx, (%r14,%rbp)
movq %rdx, 0x8(%r14,%rbp)
movq %rax, 0x10(%r14,%rbp)
testq %rax, %rax
movq 0x80(%rsp), %rdi
je 0x24622
movq 0x1cba44(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x2461e
incl 0x8(%rax)
jmp 0x24622
movq 0x4078(%rbx), %rdx
movq %r13, %r14
subq %rdx, %r14
movabsq $0x7ffffffffffffff8, %rax # imm = 0x7FFFFFFFFFFFFFF8
cmpq %rax, %r14
je 0x25047
movq %r14, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
movq %rdx, 0x80(%rsp)
cmpq %rdx, %r13
movq %rax, %rcx
movl $0x1, %edx
cmoveq %rdx, %rcx
leaq (%rcx,%rax), %r15
movabsq $0x555555555555555, %rdx # imm = 0x555555555555555
cmpq %rdx, %r15
cmovaeq %rdx, %r15
addq %rax, %rcx
cmovbq %rdx, %r15
movq %r15, %rdi
callq 0x2719a
movq %rax, %rbp
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %rax
movl $0x9, (%rbp,%r14)
movq %rcx, 0x8(%rbp,%r14)
movq %rax, 0x10(%rbp,%r14)
testq %rax, %rax
movq 0x80(%rsp), %rdi
je 0x24727
movq 0x1cb98b(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x24723
incl 0x8(%rax)
jmp 0x24727
lock
incl 0x8(%rcx)
movq 0x4080(%rbx), %r13
addq $0x18, %r13
movq %r13, 0x4080(%rbx)
jmp 0x2468f
lock
incl 0x8(%rax)
movq %r14, %rbp
cmpq %rdi, %r13
movl $0x0, %edx
je 0x24657
movq %r14, %rbp
movq %rdi, %rax
movl (%rax), %ecx
movl %ecx, (%rbp)
movups 0x8(%rax), %xmm0
movq %rdx, 0x10(%rax)
movups %xmm0, 0x8(%rbp)
movq %rdx, 0x8(%rax)
addq $0x18, %rax
addq $0x18, %rbp
cmpq %r13, %rax
jne 0x24635
testq %rdi, %rdi
je 0x2466b
movq 0x4088(%rbx), %rsi
subq %rdi, %rsi
callq 0x190e0
addq $0x18, %rbp
movq %r14, 0x4078(%rbx)
movq %rbp, 0x4080(%rbx)
leaq (%r15,%r15,2), %rax
leaq (%r14,%rax,8), %rax
movq %rax, 0x4088(%rbx)
movq %rbp, %r13
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0x246e0
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl $0x2, %eax
je 0x246bf
cmpl $0x1, %eax
jne 0x246e0
movq 0x8(%rbx), %rdi
movl $0x1, %ebp
testq %rdi, %rdi
je 0x246d3
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x246d3
movq 0x8(%rbx), %rdi
movl $0x6, %ebp
testq %rdi, %rdi
je 0x246d3
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebp, 0x4070(%rbx)
movq 0x4080(%rbx), %r13
subq 0x4078(%rbx), %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
cmpq $0x1f5, %r13 # imm = 0x1F5
jb 0x247a3
jmp 0x249ef
lock
incl 0x8(%rcx)
movq 0x4080(%rbx), %r13
addq $0x18, %r13
movq %r13, 0x4080(%rbx)
jmp 0x24799
lock
incl 0x8(%rax)
movq %rbp, %r14
cmpq %rdi, %r13
movl $0x0, %edx
je 0x2475d
movq %rbp, %r14
movq %rdi, %rax
movl (%rax), %ecx
movl %ecx, (%r14)
movups 0x8(%rax), %xmm0
movq %rdx, 0x10(%rax)
movups %xmm0, 0x8(%r14)
movq %rdx, 0x8(%rax)
addq $0x18, %rax
addq $0x18, %r14
cmpq %r13, %rax
jne 0x2473a
testq %rdi, %rdi
je 0x24771
movq 0x4088(%rbx), %rsi
subq %rdi, %rsi
callq 0x190e0
addq $0x18, %r14
movq %rbp, 0x4078(%rbx)
movq %r14, 0x4080(%rbx)
leaq (%r15,%r15,2), %rax
leaq (,%rax,8), %rax
addq %rbp, %rax
movq %rax, 0x4088(%rbx)
movl $0x9, 0x4070(%rbx)
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x247b5
callq 0x1ef14
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x247c4
callq 0x1ef14
movq 0xa8(%rsp), %r14
cmpb $0x1, 0x4040(%rbx)
jne 0x239f8
jmp 0x23975
movl $0xb, %ebp
testq %r15, %r15
je 0x23fb2
jmp 0x255b8
leaq 0x1cc8e0(%rip), %rdi # 0x1f10d8
callq 0x193a0
testl %eax, %eax
je 0x24020
leaq 0x1cc8bc(%rip), %rdi # 0x1f10c8
callq 0x218ea
leaq 0x2b94(%rip), %rdi # 0x273ac
leaq 0x1cc8a9(%rip), %rsi # 0x1f10c8
leaq 0x1cbef2(%rip), %rdx # 0x1f0718
callq 0x19a30
leaq 0x1cc8a6(%rip), %rdi # 0x1f10d8
callq 0x19650
movq 0xa8(%rsp), %r14
jmp 0x24020
movq 0xc8(%rsp), %rbx
movq %rax, (%rbx)
movq -0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x24871
movq 0x1cb71d(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x2486d
incl 0x8(%rax)
jmp 0x24871
lock
incl 0x8(%rax)
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2721e
leaq 0x1391ef(%rip), %rsi # 0x15da97
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
callq 0x1d725
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cb6d4(%rip), %rsi # 0x1effa0
movq 0x1cb69d(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x257ba
movl $0x10, %edi
callq 0x193f0
movq %rax, %r15
movq 0x4038(%rbx), %rsi
leaq 0x88(%rsp), %rdi
callq 0x2721e
leaq 0x1391ba(%rip), %rsi # 0x15dac2
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x1d725
leaq 0x1394a0(%rip), %rsi # 0x15ddc1
leaq 0x20(%rsp), %rdi
callq 0x19730
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x24d9e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x24dab
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x139148(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x1394d4(%rip), %rsi # 0x15de64
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2513e
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2514a
testl %edx, %edx
jne 0x25136
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x1391a4(%rip), %rsi # 0x15db86
movq %rax, %rdi
callq 0x19970
jmp 0x24bcf
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x1390ae(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x1394c8(%rip), %rsi # 0x15def2
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2518c
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25198
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x13903d(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x139349(%rip), %rsi # 0x15dde4
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x251da
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x251e6
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138fcc(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x1392fe(%rip), %rsi # 0x15de0a
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25228
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25234
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138f5b(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138f01(%rip), %rsi # 0x15da7e
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25276
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25282
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x138f87(%rip), %rsi # 0x15db4e
movq %rax, %rdi
callq 0x19970
movq 0x1cb41a(%rip), %rsi # 0x1efff0
movq 0x1cb3e3(%rip), %rdx # 0x1effc0
jmp 0x24d96
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x1392cb(%rip), %rsi # 0x15dec1
movq %rax, %rdi
callq 0x19970
movq 0x1cb3eb(%rip), %rsi # 0x1efff0
movq 0x1cb3b4(%rip), %rdx # 0x1effc0
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138e84(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x139257(%rip), %rsi # 0x15deab
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25337
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25343
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138e13(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x1391d0(%rip), %rsi # 0x15de95
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25385
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25391
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138da2(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x139150(%rip), %rsi # 0x15de86
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x253d3
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x253df
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x138cfa(%rip), %rsi # 0x15da7a
movq %rax, %rdi
callq 0x192b0
movq 0x1cb211(%rip), %rsi # 0x1effa0
movq 0x1cb1da(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rsp, %rdi
movq 0xa8(%rsp), %rdx
callq 0x271c4
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cb1b2(%rip), %rsi # 0x1effa0
movq 0x1cb17b(%rip), %rdx # 0x1eff70
movq %r15, %rdi
callq 0x196e0
jmp 0x2556a
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138c9b(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138fba(%rip), %rsi # 0x15ddf7
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25421
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2542d
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138c2a(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138f7d(%rip), %rsi # 0x15de2b
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2546f
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2547b
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138bb9(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138bb1(%rip), %rsi # 0x15dad0
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x254bd
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x254c9
leaq 0x138fb6(%rip), %rdi # 0x15df12
callq 0x19690
movl $0x10, %edi
callq 0x193f0
movq %rax, %r15
movq 0x4038(%rbx), %rsi
leaq 0x88(%rsp), %rdi
callq 0x2721e
leaq 0x138b39(%rip), %rsi # 0x15dac2
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x1d725
leaq 0x138eaf(%rip), %rsi # 0x15de51
leaq 0x20(%rsp), %rdi
callq 0x19730
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2550b
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x25518
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2721e
leaq 0x138ac7(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138aec(%rip), %rsi # 0x15dafd
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2556a
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x25576
leaq 0x138ec4(%rip), %rdi # 0x15df12
callq 0x19690
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
callq 0x2721e
leaq 0x138a4b(%rip), %rsi # 0x15dac2
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x1d725
leaq 0x138ca8(%rip), %rsi # 0x15dd38
leaq 0x20(%rsp), %rdi
callq 0x19730
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25625
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x25632
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2721e
leaq 0x1389df(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138c86(%rip), %rsi # 0x15dd7f
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25696
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x256a2
movl $0xc, 0x10(%rbx)
movq %rbx, %rdi
callq 0x25fd8
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cae28(%rip), %rsi # 0x1effa0
movq 0x1cadf1(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cadda(%rip), %rsi # 0x1effa0
movq 0x1cada3(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cad8c(%rip), %rsi # 0x1effa0
movq 0x1cad55(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cad3e(%rip), %rsi # 0x1effa0
movq 0x1cad07(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cacf0(%rip), %rsi # 0x1effa0
movq 0x1cacb9(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
movq 0x4038(%rbx), %rsi
leaq 0x88(%rsp), %rdi
callq 0x2721e
leaq 0x1387d6(%rip), %rsi # 0x15dac2
leaq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x1d725
leaq 0x1388d9(%rip), %rsi # 0x15dbde
leaq 0x20(%rsp), %rdi
callq 0x19730
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x256df
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x256ec
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cac2f(%rip), %rsi # 0x1effa0
movq 0x1cabf8(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cabe1(%rip), %rsi # 0x1effa0
movq 0x1cabaa(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cab93(%rip), %rsi # 0x1effa0
movq 0x1cab5c(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1cab45(%rip), %rsi # 0x1effa0
movq 0x1cab0e(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1caaf7(%rip), %rsi # 0x1effa0
movq 0x1caac0(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x2556a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1caaa9(%rip), %rsi # 0x1effa0
movq 0x1caa72(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x257ba
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rsp, %rdi
movq 0xa8(%rsp), %rdx
callq 0x271c4
movb $0x1, %bpl
movq %rsp, %rsi
movq %r15, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1caa45(%rip), %rsi # 0x1effa0
movq 0x1caa0e(%rip), %rdx # 0x1eff70
movq %r15, %rdi
callq 0x196e0
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1ca9fc(%rip), %rsi # 0x1effa0
movq 0x1ca9c5(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x257ba
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2721e
leaq 0x1384e9(%rip), %rsi # 0x15dac2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1d725
leaq 0x138529(%rip), %rsi # 0x15db18
leaq 0x40(%rsp), %rdi
callq 0x19730
leaq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x25771
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x2577d
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x2721e
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x1d67d
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1ca91b(%rip), %rsi # 0x1effa0
movq 0x1ca8e4(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x256df
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1ca8d0(%rip), %rsi # 0x1effa0
movq 0x1ca899(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x4020(%rbx), %rax
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
testq %rax, %rax
jne 0x25726
leaq 0x137bb7(%rip), %rdi # 0x15d2d8
callq 0x19040
movb (%rax), %al
leaq 0x60(%rsp), %rdx
movb %al, 0x10(%rdx)
movq $0x1, 0x8(%rdx)
movb $0x0, 0x11(%rdx)
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x1d67d
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1ca840(%rip), %rsi # 0x1effa0
movq 0x1ca809(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
jmp 0x257ba
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x192d0
xorl %ebp, %ebp
movq 0x1ca7f5(%rip), %rsi # 0x1effa0
movq 0x1ca7be(%rip), %rdx # 0x1eff70
movq %r14, %rdi
callq 0x196e0
movq %rax, %rbx
leaq 0x1cb914(%rip), %rdi # 0x1f10d8
callq 0x19450
jmp 0x25d23
jmp 0x25991
jmp 0x259b1
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x257fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x257fe
movq %rax, %rbx
movb $0x1, %bpl
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
jne 0x25845
jmp 0x25861
jmp 0x25a59
jmp 0x2585b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25837
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25837
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25861
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25861
jmp 0x25d18
jmp 0x25889
movq %rax, %rbx
movb $0x1, %bpl
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x2588f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x2588f
jmp 0x2591c
jmp 0x25991
jmp 0x259b1
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x258aa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25cf1
movq 0x98(%rsp), %rsi
jmp 0x25ce9
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x258f2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x258f2
movq %rax, %rbx
movb $0x1, %bpl
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x25947
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25947
jmp 0x25d18
jmp 0x25991
jmp 0x259b1
jmp 0x25a59
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25d1b
movq 0x98(%rsp), %rsi
jmp 0x25d0e
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25962
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25983
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x25ac3
jmp 0x25c95
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x259b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x259b7
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x259d2
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25cf1
movq 0x30(%rsp), %rsi
jmp 0x25ce9
jmp 0x25ada
jmp 0x25afa
jmp 0x25ada
jmp 0x25afa
jmp 0x25a59
jmp 0x25d18
jmp 0x25d18
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25ac3
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25ac3
jmp 0x25ada
jmp 0x25afa
jmp 0x25ada
jmp 0x25afa
jmp 0x25ada
jmp 0x25afa
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25d1b
movq 0x30(%rsp), %rsi
jmp 0x25d0e
jmp 0x25ada
jmp 0x25afa
jmp 0x25ada
jmp 0x25afa
jmp 0x25ada
jmp 0x25afa
jmp 0x25b86
jmp 0x25b86
jmp 0x25ada
jmp 0x25afa
jmp 0x25d18
jmp 0x25a99
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25d23
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25d23
movq %rax, %rbx
movq %r15, %rdi
jmp 0x25bfd
jmp 0x25b86
jmp 0x25b86
jmp 0x25b86
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25b00
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25b00
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b1b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25b36
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x25bfa
jmp 0x25c95
jmp 0x25c92
jmp 0x25c92
jmp 0x25c92
jmp 0x25d18
jmp 0x25b86
jmp 0x25b86
jmp 0x25b86
jmp 0x25bf7
jmp 0x25bf7
jmp 0x25b86
jmp 0x25d18
jmp 0x25c92
jmp 0x25c92
jmp 0x25c92
jmp 0x25bf7
jmp 0x25bf7
jmp 0x25bf7
jmp 0x25bf7
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25bfa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25bfa
jmp 0x25d18
jmp 0x25d18
jmp 0x25bf7
jmp 0x25bf7
jmp 0x25bf7
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25bdc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25bdc
movq %rax, %rbx
movb $0x1, %bpl
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x25c1b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25c1b
jmp 0x25bf7
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
jmp 0x25c95
jmp 0x25c92
jmp 0x25c92
jmp 0x25c92
jmp 0x25c92
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25c36
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25c57
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x25c8a
jmp 0x25d23
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25c8a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25c8a
movq %rax, %rbx
movq %r15, %rdi
jmp 0x25d1e
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
testq %rdi, %rdi
je 0x25ca7
callq 0x1ef14
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x25d23
callq 0x1ef14
jmp 0x25d23
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x25cd6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25cf1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x25d1b
jmp 0x25d23
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25d1b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x25d1b
movq %rax, %rbx
movq %r14, %rdi
callq 0x19a40
movq %rbx, %rdi
callq 0x19710
nop
| /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
cmpq $0x10, %r14
jne 0x29f99
movl $0xa, %edi
callq 0x19d50
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
| /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 %rbx, %rdi
callq 0x29fc4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a0ed
callq 0x1ef14
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a10e
callq 0x1ef14
movq %rbx, %rdi
callq 0x19710
| /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&) {
// Ignore -- return false
}
return result;
} | 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 $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
cmpl $0x1, %edx
jne 0x2a239
callq 0x19060
callq 0x19890
xorl %ebx, %ebx
jmp 0x2a219
callq 0x19710
nop
| /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 %rsi
callq 0x190e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a985
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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 0x32446
incq %r12
cmpq %r12, %rbx
jne 0x3240d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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) {
int ch = to_i(out[i]);
if (ch < 26) {
ch += 'A';
} else if (ch < 52) {
ch -= 26;
ch += 'a';
} else if (ch < 62) {
ch -= 52;
ch += '0';
} else if (ch == 62) {
ch = '+';
} else if (ch == 63) {
ch = '/';
}
out[i] = to_uc(ch);
}
for (size_t i = 0; i < 3 - this->pos; ++i) {
out[3 - i] = '=';
}
next()->write(out, 4);
} | 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 $0x3f, %dil
movb %dil, 0xe(%rsp)
andb $0x3f, %sil
movb %sil, 0xf(%rsp)
xorl %eax, %eax
movl $0x2f, %ecx
movb 0xc(%rsp,%rax), %dl
cmpb $0x19, %dl
ja 0x32790
addb $0x41, %dl
jmp 0x327a2
cmpb $0x33, %dl
ja 0x3279a
addb $0x47, %dl
jmp 0x327a2
cmpb $0x3d, %dl
ja 0x327b4
addb $-0x4, %dl
movl %edx, %esi
movb %sil, 0xc(%rsp,%rax)
incq %rax
cmpq $0x4, %rax
jne 0x32782
jmp 0x327c7
movb $0x2b, %sil
cmpb $0x3e, %dl
je 0x327a4
cmpb $0x3f, %dl
movzbl %dl, %esi
cmovel %ecx, %esi
jmp 0x327a4
movq 0x38(%rbx), %rax
cmpq $0x3, %rax
je 0x327eb
movl $0x3, %edx
subq %rax, %rdx
leaq (%rsp,%rax), %rdi
addq $0xd, %rdi
movl $0x3d, %esi
callq 0x19330
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
nop
| /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 std::range_error(msg.str());
} | 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 0x12a7cd(%rip), %rsi # 0x15d103
leaq 0x28(%rsp), %rdi
movl $0x20, %edx
callq 0x19b40
leaq 0x28(%rsp), %rdi
movl %ebx, %esi
callq 0x19340
movq %rax, %rbx
leaq 0x12a7c9(%rip), %rsi # 0x15d124
movl $0x8, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x4, %esi
movq %rbx, %rdi
callq 0x195b0
movq %rax, %rbx
leaq 0x12a9e0(%rip), %rsi # 0x15d35f
movl $0x17, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x8, %esi
movq %rbx, %rdi
callq 0x195b0
leaq 0x12a7a7(%rip), %rsi # 0x15d147
movl $0x13, %edx
movq %rax, %rdi
callq 0x19b40
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x19410
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19e00
xorl %ebp, %ebp
movq 0x1bd606(%rip), %rsi # 0x1effe8
movq 0x1bd51f(%rip), %rdx # 0x1eff08
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32a0f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x32a19
jmp 0x32a26
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
jmp 0x32a26
movq %rax, %r14
movq 0x1bd533(%rip), %rsi # 0x1eff60
leaq 0x28(%rsp), %rdi
callq 0x197e0
leaq 0x98(%rsp), %rdi
callq 0x197a0
movq %r14, %rdi
callq 0x19710
| /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_decompress(cinfo);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic pop
#endif
if (memory_limit > 0) {
cinfo->mem->max_memory_to_use = memory_limit;
}
jpeg_buffer_src(cinfo, b);
(void)jpeg_read_header(cinfo, TRUE);
(void)jpeg_calc_output_dimensions(cinfo);
unsigned int width = cinfo->output_width * QIntC::to_uint(cinfo->output_components);
if (memory_limit > 0 &&
width > (static_cast<unsigned long>(memory_limit) / (20U * cinfo->output_height))) {
// Even if jpeglib does not run out of memory, qpdf will while buffering the data before
// writing it. Furthermore, for very large images runtime can be significant before the
// first warning is encountered causing a timeout in oss-fuzz.
throw std::runtime_error("Pl_DCT::decompress: JPEG data large - may be too slow");
}
jpeg_progress_mgr progress_mgr;
if (scan_limit > 0) {
progress_mgr.progress_monitor = &progress_monitor;
cinfo->progress = &progress_mgr;
}
JSAMPARRAY buffer =
(*cinfo->mem->alloc_sarray)(reinterpret_cast<j_common_ptr>(cinfo), JPOOL_IMAGE, width, 1);
(void)jpeg_start_decompress(cinfo);
while (cinfo->output_scanline < cinfo->output_height) {
(void)jpeg_read_scanlines(cinfo, buffer, 1);
next()->write(buffer[0], width * sizeof(buffer[0][0]));
}
(void)jpeg_finish_decompress(cinfo);
next()->finish();
} | 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)
movl $0x38, %edx
movq %r14, %rdi
xorl %esi, %esi
callq *(%rax)
movq %rax, %r12
movq %rax, 0x28(%r14)
leaq 0x293(%rip), %rax # 0x33c98
movq %rax, 0x10(%r12)
leaq 0x288(%rip), %rax # 0x33c99
movq %rax, 0x18(%r12)
leaq 0x2c5(%rip), %rax # 0x33ce2
movq %rax, 0x20(%r12)
movq 0x1bc507(%rip), %rax # 0x1eff30
movq %rax, 0x28(%r12)
leaq 0x32c(%rip), %rax # 0x33d61
movq %rax, 0x30(%r12)
movq %r15, %rdi
callq 0x1dfb4
movq %rax, 0x8(%r12)
movq %r15, %rdi
callq 0x1dfc4
movq %rax, (%r12)
movq %r14, %rdi
movl $0x1, %esi
callq 0x190a0
movq %r14, %rdi
callq 0x19170
movl 0x88(%r14), %ebp
movl 0x94(%r14), %ecx
testl %ecx, %ecx
jns 0x33a88
movl %ecx, %edi
callq 0x33e1e
movl 0x94(%r14), %ecx
imull %ebp, %ecx
movq 0x1bd65e(%rip), %rax # 0x1f10f0
movl %ecx, %r15d
testq %rax, %rax
jle 0x33ab5
movl 0x8c(%r14), %edx
shll $0x2, %edx
leal (%rdx,%rdx,4), %esi
xorl %edx, %edx
divq %rsi
cmpq %r15, %rax
jb 0x33b42
cmpl $0x0, 0x1bd63c(%rip) # 0x1f10f8
jle 0x33acf
leaq 0xc2(%rip), %rax # 0x33b87
movq %rsp, %rdx
movq %rax, (%rdx)
movq %rdx, 0x10(%r14)
movq 0x8(%r14), %rax
movq %r14, %rdi
movl $0x1, %esi
movl %ecx, %edx
movl $0x1, %ecx
callq *0x10(%rax)
movq %rax, %r12
movq %r14, %rdi
callq 0x194a0
movl 0xa8(%r14), %eax
cmpl 0x8c(%r14), %eax
jae 0x33b23
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x199f0
movq 0x28(%rbx), %rdi
movq (%r12), %rsi
movq (%rdi), %rax
movq %r15, %rdx
callq *0x10(%rax)
jmp 0x33af0
movq %r14, %rdi
callq 0x19a00
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x12afa8(%rip), %rsi # 0x15eafe
movq %rax, %rdi
callq 0x192b0
movq 0x1bc43b(%rip), %rsi # 0x1effa0
movq 0x1bc404(%rip), %rdx # 0x1eff70
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
| /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 in
// Pl_Flate.hh. This means people using shared library versions of qpdf don't have to have zlib
// development files available, which particularly helps in a Windows environment.
this->zdata = new z_stream;
if (out_bufsize > UINT_MAX) {
throw std::runtime_error(
"Pl_Flate: zlib doesn't support buffer sizes larger than unsigned int");
}
z_stream& zstream = *(static_cast<z_stream*>(this->zdata));
zstream.zalloc = nullptr;
zstream.zfree = nullptr;
zstream.opaque = nullptr;
zstream.next_in = nullptr;
zstream.avail_in = 0;
zstream.next_out = this->outbuf.get();
zstream.avail_out = QIntC::to_uint(out_bufsize);
if (action == a_deflate && Pl_Flate::zopfli_enabled()) {
zopfli_buf = std::make_unique<std::string>();
}
} | 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 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x35024
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x340d0
callq 0x1ef14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x340d0
callq 0x1ef14
movl $0x70, %edi
callq 0x19180
leaq 0x20(%rbx), %rcx
movq %rax, (%rcx)
movq %r14, %rcx
shrq $0x20, %rcx
jne 0x34116
xorl %ecx, %ecx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rax)
movq %rcx, 0x50(%rax)
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movl %r14d, 0x20(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %r15
leaq 0x12ab5f(%rip), %rsi # 0x15ec89
movq %rax, %rdi
callq 0x192b0
movq 0x1bbe67(%rip), %rsi # 0x1effa0
movq 0x1bbe30(%rip), %rdx # 0x1eff70
movq %r15, %rdi
callq 0x196e0
movq %rax, %r14
movq %r15, %rdi
callq 0x19a40
jmp 0x3415a
jmp 0x34157
movq %rax, %r14
leaq 0x50(%rbx), %rdi
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x3416b
callq 0x34ff6
movq $0x0, 0x50(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x3418a
leaq 0x30(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34198
callq 0x1ef14
movq %r14, %rdi
callq 0x19710
movq %rax, %rdi
callq 0x1d236
| /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);
return;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t const max_bytes = 1 << 30;
size_t bytes_left = len;
unsigned char const* buf = data;
while (bytes_left > 0) {
size_t bytes = (bytes_left >= max_bytes ? max_bytes : bytes_left);
handleData(buf, bytes, (m->action == a_inflate ? Z_SYNC_FLUSH : Z_NO_FLUSH));
bytes_left -= bytes;
buf += bytes;
}
} | 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
popq %r15
popq %rbp
jmp 0x19370
testq %rbx, %rbx
je 0x3442e
movl $0x40000000, %r13d # imm = 0x40000000
cmpq %r13, %rbx
movl $0x40000000, %r12d # imm = 0x40000000
cmovbq %rbx, %r12
movq 0x30(%r14), %rax
xorl %ecx, %ecx
cmpl $0x0, 0x18(%rax)
sete %cl
addl %ecx, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x344c2
addq %r12, %r15
subq %r12, %rbx
jne 0x343fc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
addq $0x8, %r14
leaq 0x12a8a9(%rip), %rdx # 0x15ecfe
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1e5ef
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19150
xorl %ebp, %ebp
movq 0x1bbb75(%rip), %rsi # 0x1efff0
movq 0x1bbb3e(%rip), %rdx # 0x1effc0
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x344a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
jne 0x344b2
jmp 0x344ba
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
| /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(%rax)
| /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 (util::is_digit(*p)) {
version.append(1, *p++);
}
} else {
valid = false;
}
}
return valid;
} | 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
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x3a237
cmpb $0x2e, %cl
jne 0x3a2cd
movb 0x1(%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3a2cd
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
addb $-0x30, %cl
movb $0x1, %bpl
cmpb $0x9, %cl
ja 0x3a2cf
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
addb $-0x30, %cl
cmpb $0xa, %cl
jb 0x3a2a0
jmp 0x3a2cf
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /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(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e1f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x122e4b(%rip), %rsi # 0x16104b
leaq 0x122e4d(%rip), %rdx # 0x161054
callq 0x1ef84
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xfbc92
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e237
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x28(%rsp), %rdi
callq 0xc25ae
testb %al, %al
je 0x3e2f1
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1219bb(%rip), %rsi # 0x15fc13
leaq 0x1219bd(%rip), %rdx # 0x15fc1c
callq 0x1ef84
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xfbb62
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e28c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bl, %bl
je 0x3e2f1
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x121974(%rip), %rsi # 0x15fc13
leaq 0x121976(%rip), %rdx # 0x15fc1c
callq 0x1ef84
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0xc5c74
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xfc1ac
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x3e2da
callq 0x1ef14
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e2f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3e300
callq 0x1ef14
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3e30f
callq 0x1ef14
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x3e332
callq 0x1ef14
jmp 0x3e332
jmp 0x3e32f
jmp 0x3e34d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e350
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x3e350
jmp 0x3e34d
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x3e384
callq 0x1ef14
jmp 0x3e384
jmp 0x3e365
jmp 0x3e381
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e384
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0x3e384
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x3e393
callq 0x1ef14
movq %rbx, %rdi
callq 0x19710
nop
| /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::TC("qpdf", "QPDFAcroFormDocumentHelper replaced DA token");
write(to_replace[name][offset]);
wrote = true;
}
}
offset += token.getRawValue().length();
if (!wrote) {
writeToken(token);
}
} | 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(%r14), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x5822a
leaq 0x20(%r14), %rcx
cmpq %rcx, %rax
je 0x56d03
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x57948
leaq 0x10(%r14), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x581e0
testq %rax, %rax
je 0x56d03
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x57948
movq %rax, %rdi
movq %r15, %rsi
callq 0x579c4
movq %r14, %rdi
movq %rax, %rsi
callq 0xbf450
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56cfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rbx), %rax
addq %rax, (%r15)
jmp 0x56d31
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56d1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rbx), %rax
addq %rax, 0x10(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf472
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x56d6f
callq 0x1ef14
jmp 0x56d6f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56d6f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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();
if ((type == tt::tt_eof) && (!allow_eof)) {
// Nothing in the qpdf library calls readToken without allowEOF anymore, so this
// case is not exercised.
type = tt::tt_bad;
error_message = "unexpected EOF";
offset = input.getLastOffset();
}
} else {
handleCharacter(ch);
if (before_token) {
++offset;
}
if (in_token) {
raw_val += ch;
}
if (max_len && (raw_val.length() >= max_len) && (state != st_token_ready)) {
// terminate this token now
QTC::TC("qpdf", "QPDFTokenizer block long token");
type = tt::tt_bad;
state = st_token_ready;
error_message = "exceeded allowable length while reading token";
}
}
}
input.fastUnread(!in_token && !before_token);
if (type != tt::tt_eof) {
input.setLastOffset(offset);
}
return error_message.empty();
} | 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 %rcx, %rax
jl 0xe2853
addq 0x90(%r14), %rcx
cmpq %rcx, %r13
jge 0xe2853
movq %r13, 0x8(%r14)
movq %rax, 0x98(%r14)
jmp 0xe2882
movq $0x0, 0x98(%r14)
leaq 0x10(%r14), %rsi
movq (%r14), %rax
movl $0x80, %edx
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, 0x90(%r14)
movq 0x8(%r14), %r13
movq %r13, 0xa0(%r14)
cmpl $0x15, (%rbx)
jne 0xe288f
movq %r13, %rsi
jmp 0xe2a57
leaq 0x10(%r14), %r12
leaq 0x50(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r12, 0x8(%rsp)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rcx
cmpq %rsi, %rcx
jge 0xe28cb
movq 0x8(%r14), %rax
jmp 0xe2965
testq %rsi, %rsi
je 0xe29d4
addq 0xa0(%r14), %rsi
movq (%r14), %rax
movq %r14, %rdi
xorl %edx, %edx
callq *0x28(%rax)
cmpq $0x0, 0x90(%r14)
je 0xe2924
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
movq 0xa0(%r14), %rdx
movq %rax, %rcx
subq %rdx, %rcx
jl 0xe2924
movq 0x90(%r14), %rsi
addq %rsi, %rdx
cmpq %rdx, %rax
jge 0xe2924
movq %rax, 0x8(%r14)
movq %rcx, 0x98(%r14)
jmp 0xe2955
movq $0x0, 0x98(%r14)
movq (%r14), %rax
movl $0x80, %edx
movq %r14, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq %rax, %rsi
movq %rax, 0x90(%r14)
movq 0x8(%r14), %rax
movq %rax, 0xa0(%r14)
movq 0x98(%r14), %rcx
cmpq %rsi, %rcx
jge 0xe28cb
movb 0x10(%r14,%rcx), %dl
incq %rcx
movq %rcx, 0x98(%r14)
incq %rax
movq %rax, 0x8(%r14)
movsbl %dl, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe151c
movzbl 0x70(%rbx), %r15d
movq %rbx, %r12
cmpb $0x1, 0x71(%rbx)
jne 0xe29a2
movq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x19d90
addq %r15, %r13
movq 0x20(%rsp), %r15
testq %r15, %r15
je 0xe29cf
movq %r12, %rbx
cmpq %r15, 0x38(%r12)
setb %cl
movl (%r12), %eax
cmpl $0x15, %eax
sete %dl
orb %cl, %dl
je 0xe2a19
movq 0x8(%rsp), %r12
jmp 0xe2a4a
movq %r12, %rbx
jmp 0xe2a43
movq %rbx, %rdi
callq 0xe2374
cmpl $0xe, 0x8(%rbx)
jne 0xe2a48
cmpb $0x0, 0x4(%rbx)
jne 0xe2a48
movl $0x0, 0x8(%rbx)
movq 0x58(%rbx), %rdx
movl $0xe, %r8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
leaq 0x97391(%rip), %rcx # 0x179d98
callq 0x19580
movq %r14, %rdi
callq 0x2033a
movq %rax, %r13
jmp 0xe2a48
movl $0x0, 0x8(%rbx)
movl $0x15, (%rbx)
movq 0x58(%rbx), %rdx
movl $0x2d, %r8d
movq 0x10(%rsp), %rdi
xorl %esi, %esi
leaq 0x9793a(%rip), %rcx # 0x17a378
callq 0x19580
movq 0x8(%rsp), %r12
movl (%rbx), %eax
cmpl $0x15, %eax
jne 0xe28af
movq 0x8(%r14), %rsi
movzbl 0x70(%rbx), %eax
xorq $0x1, %rax
xorl %ecx, %ecx
cmpb $0x0, 0x71(%rbx)
cmoveq %rax, %rcx
subq %rcx, %rsi
movq %rsi, 0x8(%r14)
movq (%r14), %rax
movq %r14, %rdi
xorl %edx, %edx
callq *0x28(%rax)
cmpl $0xe, 0x8(%rbx)
je 0xe2a8c
movq %r14, %rdi
movq %r13, %rsi
callq 0x20334
cmpq $0x0, 0x58(%rbx)
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 || tokenizer.getValue() != str) {
QTC::TC("qpdf", "QPDFTokenizer finder found wrong word");
return false;
}
qpdf_offset_t token_start = is.getLastOffset();
char next;
bool next_okay = false;
if (is.read(&next, 1) == 0) {
QTC::TC("qpdf", "QPDFTokenizer inline image at EOF");
next_okay = true;
} else {
next_okay = is_delimiter(next);
}
is.seek(pos, SEEK_SET);
if (!next_okay) {
return false;
}
if (token_start == 0) {
// Can't actually happen...we never start the search at the beginning of the input.
return false;
}
return true;
} | 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, %rcx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xe27f4
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe302c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0xd, 0x28(%rsp)
jne 0xe3062
movq 0x58(%rsp), %rdx
cmpq 0x18(%rbx), %rdx
jne 0xe3062
movq %rax, %r14
testq %rdx, %rdx
je 0xe30cb
movq 0x10(%rbx), %rsi
movq 0x50(%rsp), %rdi
callq 0x19790
testl %eax, %eax
je 0xe30cb
xorl %ebp, %ebp
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe3085
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe30a0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x190e0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe30bb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x190e0
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rdi
callq 0x2033a
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
movl $0x1, %edx
callq *0x38(%rax)
movb $0x1, %bpl
testq %rax, %rax
je 0xe3123
movzbl (%rsp), %eax
cmpq $0x3e, %rax
ja 0xe310b
movabsq $0x5000832100003e01, %rcx # imm = 0x5000832100003E01
btq %rax, %rcx
jb 0xe3123
addl $-0x5b, %eax
cmpl $0x22, %eax
ja 0xe3140
movabsq $0x500000005, %rcx # imm = 0x500000005
btq %rax, %rcx
jae 0xe3140
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
xorl %edx, %edx
callq *0x28(%rax)
testq %r15, %r15
setne %al
andb %al, %bpl
jmp 0xe3064
xorl %ebp, %ebp
jmp 0xe3123
jmp 0xe3165
jmp 0xe3165
jmp 0xe3165
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe3168
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xe3168
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3e664
movq %rbx, %rdi
callq 0x19710
| /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), %rdi
testq %rdi, %rdi
je 0xe33ce
callq 0x1ef14
jmp 0xe33ce
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe33dd
callq 0x1ef14
leaq 0x970c4(%rip), %rax # 0x17a4a8
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movb %al, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl $0x10000, 0x38(%rbx) # imm = 0x10000
movl $0x1, %ecx
movq %rcx, 0x3c(%rbx)
movabsq $0x1000100000000, %rdx # imm = 0x1000100000000
movq %rdx, 0x43(%rbx)
movb %al, 0x4b(%rbx)
movl $0x1, 0x4c(%rbx)
leaq 0x60(%rbx), %rdx
movq %rdx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
movw $0x1, 0x70(%rbx)
leaq 0x80(%rbx), %rdx
movl %eax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
movq %rdx, 0x90(%rbx)
movq %rdx, 0x98(%rbx)
leaq 0xc0(%rbx), %rdx
movups %xmm0, 0xa0(%rbx)
movq %rdx, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movb %al, 0xc0(%rbx)
leaq 0xe0(%rbx), %rdx
movq %rdx, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
movb %al, 0xe0(%rbx)
leaq 0x100(%rbx), %rdx
movq %rdx, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
movb %al, 0x100(%rbx)
movl %eax, 0x110(%rbx)
leaq 0x128(%rbx), %rdx
movq %rdx, 0x118(%rbx)
movq %rax, 0x120(%rbx)
movb %al, 0x128(%rbx)
movl %eax, 0x138(%rbx)
leaq 0x150(%rbx), %rdx
movq %rdx, 0x140(%rbx)
movq %rax, 0x148(%rbx)
movb %al, 0x150(%rbx)
movl %eax, 0x160(%rbx)
leaq 0x178(%rbx), %rdx
movq %rdx, 0x168(%rbx)
movq %rax, 0x170(%rbx)
movb %al, 0x178(%rbx)
movl %eax, 0x188(%rbx)
leaq 0x1a0(%rbx), %rdx
movq %rdx, 0x190(%rbx)
movq %rax, 0x198(%rbx)
movb %al, 0x1a0(%rbx)
leaq 0x1b0(%rbx), %rdx
movq %rdx, 0x1b8(%rbx)
movq %rdx, 0x1b0(%rbx)
leaq 0x210(%rbx), %rdx
movl %eax, 0x210(%rbx)
movq %rax, 0x218(%rbx)
movups %xmm0, 0x1c0(%rbx)
movups %xmm0, 0x1d0(%rbx)
movups %xmm0, 0x1e0(%rbx)
movups %xmm0, 0x1f0(%rbx)
movq %rax, 0x200(%rbx)
movq %rdx, 0x220(%rbx)
movq %rdx, 0x228(%rbx)
movq %rax, 0x230(%rbx)
movq $-0x1, %rdx
movq %rdx, 0x238(%rbx)
movb %al, 0x240(%rbx)
movups %xmm0, 0x248(%rbx)
movq %rax, 0x258(%rbx)
leaq 0x268(%rbx), %rsi
movl %eax, 0x268(%rbx)
movq %rax, 0x270(%rbx)
movq %rsi, 0x278(%rbx)
movq %rsi, 0x280(%rbx)
movq %rax, 0x288(%rbx)
movq %rdx, 0x290(%rbx)
movq %rcx, 0x298(%rbx)
movq %rax, 0x2a0(%rbx)
movb %al, 0x2a8(%rbx)
movq %rax, 0x2b0(%rbx)
leaq 0x2c0(%rbx), %rcx
movl %eax, 0x2c0(%rbx)
movq %rax, 0x2c8(%rbx)
movq %rcx, 0x2d0(%rbx)
movq %rcx, 0x2d8(%rbx)
movq %rax, 0x2e0(%rbx)
leaq 0x2f0(%rbx), %rcx
movl %eax, 0x2f0(%rbx)
movq %rax, 0x2f8(%rbx)
movq %rcx, 0x300(%rbx)
movq %rcx, 0x308(%rbx)
movq %rax, 0x310(%rbx)
leaq 0x320(%rbx), %rcx
movl %eax, 0x320(%rbx)
movq %rax, 0x328(%rbx)
movq %rcx, 0x330(%rbx)
movq %rcx, 0x338(%rbx)
movq %rax, 0x340(%rbx)
leaq 0x350(%rbx), %rcx
movl %eax, 0x350(%rbx)
movq %rax, 0x358(%rbx)
movq %rcx, 0x360(%rbx)
movq %rcx, 0x368(%rbx)
movups %xmm0, 0x380(%rbx)
movups %xmm0, 0x370(%rbx)
movq $0x2, 0x390(%rbx)
leaq 0x3a8(%rbx), %rcx
movq %rcx, 0x398(%rbx)
movq %rax, 0x3a0(%rbx)
movb %al, 0x3a8(%rbx)
movb %al, 0x3b8(%rbx)
movq %rax, 0x3c0(%rbx)
leaq 0x3d8(%rbx), %rcx
movq %rcx, 0x3c8(%rbx)
movq %rax, 0x3d0(%rbx)
movb %al, 0x3d8(%rbx)
movb %al, 0x3e8(%rbx)
leaq 0x400(%rbx), %rcx
movq %rcx, 0x3f0(%rbx)
movq %rax, 0x3f8(%rbx)
movb %al, 0x400(%rbx)
movups %xmm0, 0x410(%rbx)
movups %xmm0, 0x41c(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe374c
callq 0x1ef14
jmp 0xe374c
jmp 0xe3749
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xe375b
callq 0x1ef14
movq %rbx, %rdi
callq 0x19710
nop
| /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, %rdi
movq %rbx, %rsi
callq 0xe3a8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r12), %rdi
testq %rdi, %rdi
je 0xe3a83
callq 0x1ef14
jmp 0xe3a83
movq %rax, %rbx
movl $0x430, %esi # imm = 0x430
movq %r15, %rdi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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)
leaq 0x8(%rsp), %rdi
movq %r14, -0x8(%rdi)
movq %r14, %rsi
callq 0xf60a4
movl $0x20, %edi
callq 0x19180
leaq 0x1b0(%r15), %rsi
movaps (%rsp), %xmm0
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movups %xmm0, 0x10(%rax)
movq %rcx, (%rsp)
movq %rax, %rdi
callq 0x19250
incq 0x1c0(%r15)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe3dbe
callq 0x1ef14
movq (%rbx), %rax
movq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0xe3c2a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xe3dfb
callq 0x1ef14
jmp 0xe3dfb
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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
cmpq %r14, %rdi
je 0xe43a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe43c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
| /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 encrypt_metadata)
{
std::set<int> clear;
interpretR3EncryptionParameters(
clear,
user_password,
owner_password,
allow_accessibility,
allow_extract,
allow_assemble,
allow_annotate_and_form,
allow_form_filling,
allow_modify_other,
print,
qpdf_r3m_all);
m->encrypt_use_aes = true;
m->encrypt_metadata = encrypt_metadata;
setEncryptionParameters(user_password, owner_password, 5, 5, 32, clear);
} | 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 %r8, 0x10(%r8)
movq %r8, 0x18(%r8)
movq %r11, 0x20(%r8)
movzbl %dil, %edi
movzbl %sil, %r13d
movzbl %dl, %edx
movq %rsp, %r12
movq %r12, %rsi
movl %ecx, %r8d
pushq %r11
pushq %r10
pushq %rdi
pushq %r13
pushq %rdx
pushq %rax
callq 0xe4a98
addq $0x30, %rsp
movb 0x80(%rsp), %al
movq (%r15), %rcx
movb $0x1, 0x71(%rcx)
movb %al, 0x70(%rcx)
subq $0x8, %rsp
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x5, %ecx
movl $0x5, %r8d
movl $0x20, %r9d
pushq %r12
callq 0xe459e
addq $0x10, %rsp
movq %rsp, %rdi
callq 0x405e4
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x405e4
movq %rbx, %rdi
callq 0x19710
nop
| /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
addq $0x30, %rcx
testq %rdx, %rdx
cmovneq %rsi, %rcx
movq (%rcx), %r14
movslq %ebx, %rsi
movq 0x250(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rsi, %rcx
movq %r8, (%rsp)
jbe 0xe8490
shlq $0x5, %rsi
addq %rsi, %rax
jmp 0xe849c
addq $0x248, %rdi # imm = 0x248
callq 0xf66f6
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl %ebx, %ebp
negl %ebp
cmovsl %ebx, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0xe8508
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0xe84ff
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0xe8505
cmpl $0x2710, %ecx # imm = 0x2710
jb 0xe8508
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0xe84cc
addl $-0x3, %r15d
jmp 0xe8508
addl $-0x2, %r15d
jmp 0xe8508
decl %r15d
movl %ebx, %r12d
shrl $0x1f, %r12d
leal (%r15,%r12), %esi
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x19670
addq (%r13), %r12
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x202ae
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq (%rsp), %r15
movq (%r15), %rax
movq 0x1c8(%rax), %rdi
callq 0xf57a4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe8571
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq (%r15), %rax
movq 0x1c8(%rax), %rdi
leaq 0x9230e(%rip), %rsi # 0x17a890
movl $0x7, %edx
callq 0xf57a4
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0xe85b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rdi
callq 0x19710
nop
| /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 %rsp, %rsi
callq 0xfbb62
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xec9a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
testb %bpl, %bpl
je 0xeca25
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x8db38(%rip), %rsi # 0x17a4eb
leaq 0x8db34(%rip), %rdx # 0x17a4ee
callq 0x1ef84
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0xfbc92
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0xf94bc
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xc304a
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xec9fe
callq 0x1ef14
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xeca0d
callq 0x1ef14
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xeca3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xeca3e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x8e2b3(%rip), %rdx # 0x17ace6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1ef84
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xeca4d
callq 0x1ef14
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xeca70
callq 0x1ef14
jmp 0xeca70
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xeca8a
callq 0x1ef14
jmp 0xeca8a
jmp 0xeca87
jmp 0xecaa2
jmp 0xecaa2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xecaa5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xecaa5
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xecab4
callq 0x1ef14
movq %rbx, %rdi
callq 0x19710
| /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 contents = page.getKey("/Contents");
std::vector<QPDFObjGen> contents_objects;
if (contents.isArray()) {
int n = contents.getArrayNItems();
for (int i = 0; i < n; ++i) {
contents_objects.push_back(contents.getArrayItem(i).getObjGen());
}
} else if (contents.isStream()) {
contents_objects.push_back(contents.getObjGen());
}
for (auto const& c: contents_objects) {
m->contents_to_page_seq[c] = num;
m->normalized_streams.insert(c);
}
}
} | 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, %ebp
leaq 0x48(%rsp), %r12
movl $0x2b8, %r14d # imm = 0x2B8
movq (%rbx), %r15
movq %rdi, 0x38(%rsp)
callq 0xc4770
movq %rsp, %r13
addq $0x2e8, %r15 # imm = 0x2E8
movq %rax, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x89162
incl %ebp
movl %ebp, (%rax)
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x77cab(%rip), %rsi # 0x167266
leaq 0x77cad(%rip), %rdx # 0x16726f
callq 0x1ef84
leaq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r13, %rdx
callq 0xfbc92
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xef5f4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xc2564
testb %al, %al
je 0xef669
leaq 0x28(%rsp), %rdi
callq 0xf934c
movl %eax, %r13d
testl %eax, %eax
jle 0xef691
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x28(%rsp), %rsi
movl %r15d, %edx
callq 0xf94bc
movq %r12, %rdi
callq 0xc4770
movq %rax, 0x58(%rsp)
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
callq 0xf72e0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xef65f
callq 0x1ef14
incl %r15d
cmpl %r15d, %r13d
jne 0xef626
jmp 0xef691
leaq 0x28(%rsp), %rdi
callq 0xc25f8
testb %al, %al
je 0xef691
leaq 0x28(%rsp), %rdi
callq 0xc4770
movq %rax, 0x48(%rsp)
movq %rsp, %rdi
movq %r12, %rsi
callq 0xf72e0
movq (%rsp), %r13
movq 0x8(%rsp), %r15
cmpq %r15, %r13
je 0xef6cf
movq (%rbx), %rdi
movl $0x318, %eax # imm = 0x318
addq %rax, %rdi
movq %r13, %rsi
callq 0x890de
movl %ebp, (%rax)
movq (%rbx), %rdi
addq %r14, %rdi
movq %r13, %rsi
callq 0x589e0
addq $0x8, %r13
cmpq %r15, %r13
jne 0xef69f
movq (%rsp), %r13
testq %r13, %r13
je 0xef6e4
movq 0x10(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x190e0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xef6f3
callq 0x1ef14
movq 0x38(%rsp), %rdi
addq $0x10, %rdi
cmpq 0x40(%rsp), %rdi
jne 0xef57e
leaq 0x60(%rsp), %rdi
callq 0x3f01c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xef763
jmp 0xef763
jmp 0xef748
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xef78b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xef78b
jmp 0xef763
movq %rax, %rbx
jmp 0xef78b
jmp 0xef763
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xef766
callq 0x1ef14
jmp 0xef766
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xef77c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x190e0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xef78b
callq 0x1ef14
leaq 0x60(%rsp), %rdi
callq 0x3f01c
movq %rbx, %rdi
callq 0x19710
nop
| /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->linearized ? 2 : 1));
prepareFileForWrite();
if (m->linearized) {
writeLinearized();
} else {
writeStandard();
}
m->pipeline->finish();
if (m->close_file) {
fclose(m->file);
}
m->file = nullptr;
if (m->buffer_pipeline) {
m->output_buffer = m->buffer_pipeline->getBuffer();
m->buffer_pipeline = nullptr;
}
indicateProgress(false, true);
} | 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 %rbx, %rdi
callq 0xefbf0
movq (%rbx), %rax
cmpb $0x1, 0x4a(%rax)
jne 0xf054b
movq %rbx, %rdi
callq 0xf05b2
jmp 0xf0553
movq %rbx, %rdi
callq 0xf25f4
movq (%rbx), %rax
movq 0x1c8(%rax), %rdi
callq 0xf588c
movq (%rbx), %rax
cmpb $0x1, 0x20(%rax)
jne 0xf0577
movq 0x18(%rax), %rdi
callq 0x19460
movq (%rbx), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0xf059c
callq 0x32b8e
movq (%rbx), %rcx
movq %rax, 0x30(%rcx)
movq $0x0, 0x28(%rcx)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xeec30
| /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.
writeString("\n%\xbf\xf7\xa2\xfe\n");
}
writeStringQDF("%QDF-1.0\n\n");
// Note: do not write extra header text here. Linearized PDFs must include the entire
// linearization parameter dictionary within the first 1024 characters of the PDF file, so for
// linearized files, we have to write extra header text after the linearization parameter
// dictionary.
} | 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 0x87f55(%rip), %rsi # 0x17acc8
movl $0xb, %edx
jmp 0xf2d86
leaq 0x87f53(%rip), %rsi # 0x17acd4
movl $0x7, %edx
callq 0xf57a4
movq (%rbx), %rax
cmpb $0x1, 0x42(%rax)
jne 0xf2dad
movq 0x1c8(%rax), %rdi
leaq 0x87f3a(%rip), %rsi # 0x17acdc
movl $0xa, %edx
popq %rbx
jmp 0xf57a4
popq %rbx
retq
nop
| /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 trailer = getTrimmedTrailer();
enqueueObject(trailer.getKey("/Root"));
// Next place any other objects referenced from the trailer dictionary into the queue, handling
// direct objects recursively. Root is already there, so enqueuing it a second time is a no-op.
for (auto& item: trailer.as_dictionary()) {
if (!item.second.null()) {
enqueueObject(item.second);
}
}
} | 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 # 0x1eff80
movq (%r15), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0xf4aef
cmpb $0x0, (%r13)
je 0xf4aeb
incl 0x8(%rax)
jmp 0xf4aef
lock
incl 0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe875e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xf4b09
callq 0x1ef14
addq $0x10, %r15
cmpq %r12, %r15
jne 0xf4ac9
movq %rsp, %rdi
callq 0x3f01c
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xec652
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x6afc4(%rip), %rsi # 0x15fafb
leaq 0x6afc2(%rip), %rdx # 0x15fb00
movq %rsp, %rdi
callq 0x1ef84
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0xfbc92
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xe875e
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xf4b74
callq 0x1ef14
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xf4b8a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rsp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xf4bb7
movq 0xfb3d7(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xf4bb3
incl 0x8(%rax)
jmp 0xf4bb7
lock
incl 0x8(%rax)
movq %rsp, %rdi
callq 0x3f436
testq %rax, %rax
je 0xf4bca
movq 0x18(%rax), %r14
jmp 0xf4bcd
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x3f436
leaq 0x8(%rax), %r12
testq %rax, %rax
cmoveq %rax, %r12
cmpq %r12, %r14
je 0xf4c82
leaq 0x30(%rsp), %r15
movq 0xfb38b(%rip), %r13 # 0x1eff80
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0xf4c6e
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xf4c1e
cmpl $0xd, %eax
jne 0xf4c29
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12b162
jmp 0xf4c23
callq 0x3f39f
movq (%rax), %rax
movb 0x30(%rax), %al
cmpb $0x2, %al
je 0xf4c6e
movq 0x40(%r14), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%r14), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0xf4c54
cmpb $0x0, (%r13)
je 0xf4c50
incl 0x8(%rax)
jmp 0xf4c54
lock
incl 0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe875e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xf4c6e
callq 0x1ef14
movq %r14, %rdi
callq 0x19b30
movq %rax, %r14
cmpq %r12, %rax
jne 0xf4bf5
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf4c91
callq 0x1ef14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xf4ca0
callq 0x1ef14
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xf4cfa
jmp 0xf4cfa
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0xf4cc9
callq 0x1ef14
jmp 0xf4cc9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xf4d0c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x190e0
jmp 0xf4d0c
movq %rax, %rbx
jmp 0xf4d0c
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xf4cfd
callq 0x1ef14
jmp 0xf4cfd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xf4d0c
callq 0x1ef14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xf4d37
callq 0x1ef14
jmp 0xf4d37
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0xf4d2f
callq 0x1ef14
movq %rsp, %rdi
callq 0x3f01c
movq %rbx, %rdi
callq 0x19710
nop
| /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 encountered accessing ObjTable");
return element(0); // doesn't return
} | 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 0xf6786
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a837
jmp 0xf670b
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x84876(%rip), %rsi # 0x17afca
movq %rax, %rdi
callq 0x192b0
movq 0xf983d(%rip), %rsi # 0x1effa0
movq 0xf9806(%rip), %rdx # 0x1eff70
movq %rbx, %rdi
callq 0x196e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x19a40
movq %r14, %rdi
callq 0x19710
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.