name string | code string | asm string | file string |
|---|---|---|---|
qpdf::BaseDictionary::getKeys[abi:cxx11]() | std::set<std::string>
BaseDictionary::getKeys()
{
std::set<std::string> result;
for (auto& iter: dict()->items) {
if (!iter.second.isNull()) {
result.insert(iter.first);
}
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
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)
movq %rsi, %rdi
callq 0xfc348
movq %rax, %r14
movq 0x18(%rax), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0xfc592
leaq 0x40(%r15... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
qpdf::BaseDictionary::replaceKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle) | void
BaseDictionary::replaceKey(std::string const& key, QPDFObjectHandle value)
{
auto d = dict();
if (value.isNull() && !value.isIndirect()) {
// The PDF spec doesn't distinguish between keys with null values and missing keys.
// Allow indirect nulls which are equivalent to a dangling reference... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
callq 0xfc348
movq %rax, %r15
movq %rbx, %rdi
callq 0xc25b4
testb %al, %al
je 0xfc60d
movq %rbx, %rdi
callq 0xc426a
testb %al, %al
je 0xfc633
movq %r15, %rdi
movq %r14, %rsi
callq 0xcb39e
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x8(%rax), %rdi
addq $0x8,... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::getKeys[abi:cxx11]() const | std::set<std::string>
QPDFObjectHandle::getKeys() const
{
if (auto dict = as_dictionary(strict)) {
return dict.getKeys();
}
typeWarning("dictionary", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle dictionary empty set for getKeys");
return {};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xfcab4
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfca74
cmpl $0xd, %eax
jne 0xfca7f
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfca79
callq 0x3fe7f
m... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::getDictAsMap[abi:cxx11]() const | std::map<std::string, QPDFObjectHandle>
QPDFObjectHandle::getDictAsMap() const
{
if (auto dict = as_dictionary(strict)) {
return dict.getAsMap();
}
typeWarning("dictionary", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle dictionary empty map for asMap");
return {};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xfcc18
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfcbd8
cmpl $0xd, %eax
jne 0xfcbe3
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfcbdd
callq 0x3fe7f
m... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::replaceKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceKey(std::string const& key, QPDFObjectHandle const& value)
{
if (auto dict = as_dictionary(strict)) {
checkOwnership(value);
dict.replaceKey(key, value);
return;
}
typeWarning("dictionary", "ignoring key replacement request");
QTC::TC("qpdf", "QPDFOb... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfcd80
movq %rdx, %r15
movq %rsi, %r14
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfcd47
cmpl $0xd, %eax
jne 0xfcd52
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfcd4c... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::replaceKeyAndGetNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&) | QPDFObjectHandle
QPDFObjectHandle::replaceKeyAndGetNew(std::string const& key, QPDFObjectHandle const& value)
{
replaceKey(key, value);
return value;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xfcd0c
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xfceec
movq 0xf40a2(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xfcee8
incl 0x8(%rax)
jmp... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::removeKeyAndGetOld(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFObjectHandle::removeKeyAndGetOld(std::string const& key)
{
auto result = QPDFObjectHandle::newNull();
if (auto dict = as_dictionary(strict)) {
result = dict.getKey(key);
}
removeKey(key);
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xc6c94
movq (%r15), %rdi
testq %rdi, %rdi
je 0xfcfbc
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfcf87
cmpl $0xd, %eax
jne 0xfcf92
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfc... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::removeKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFObjectHandle::removeKey(std::string const& key)
{
if (auto dict = as_dictionary(strict)) {
dict.removeKey(key);
return;
}
typeWarning("dictionary", "ignoring key removal request");
QTC::TC("qpdf", "QPDFObjectHandle dictionary ignoring removeKey");
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xfd0bd
movq %rsi, %r14
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xfd084
cmpl $0xd, %eax
jne 0xfd08f
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0xfd089
callq 0x3fe7f
movq (%rax),... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
qpdf::Stream::getStreamJSON(int, qpdf_json_stream_data_e, qpdf_stream_decode_level_e, Pipeline*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON
Stream::getStreamJSON(
int json_version,
qpdf_json_stream_data_e json_data,
qpdf_stream_decode_level_e decode_level,
Pipeline* p,
std::string const& data_filename)
{
Pl_Buffer pb{"streamjson"};
JSON::Writer jw{&pb, 0};
decode_level =
writeStreamJSON(json_version, jw, json_da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r12
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x7f05a(%rip), %rsi # 0x17c938
leaq 0x78(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3352c
leaq 0xb0(%rsp), %rdx
movq ... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::getRawStreamData() | std::shared_ptr<Buffer>
Stream::getRawStreamData()
{
Pl_Buffer buf("stream data buffer");
if (!pipeStreamData(&buf, nullptr, 0, qpdf_dl_none, false, false)) {
throw QPDFExc(
qpdf_e_unsupported,
obj->getQPDF()->getFilename(),
"",
obj->getParsedOffset(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7afa7(%rip), %rsi # 0x17a131
leaq 0x68(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x3352c
movl $0x0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d,... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::replaceStreamData(std::shared_ptr<Buffer>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
Stream::replaceStreamData(
std::shared_ptr<Buffer> data,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto s = stream();
s->stream_data = data;
s->stream_provider = nullptr;
replaceFilterData(filter, decode_parms, data->getSize());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x4005c
movq %rax, %r13
movq (%r12), %rax
movq %rax, 0x20(%r13)
leaq 0x28(%r13), %rdi
leaq 0x8(%r12), %rsi
callq 0x28170
xorps %xmm0, %xmm0
movq 0x38(%r13), %rdi
movups %xmm0, 0x30(%r13)
testq %r... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::replaceStreamData(std::shared_ptr<QPDFObjectHandle::StreamDataProvider>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
Stream::replaceStreamData(
std::shared_ptr<QPDFObjectHandle::StreamDataProvider> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto s = stream();
s->stream_provider = provider;
s->stream_data = nullptr;
replaceFilterData(filter, decode_parms, 0);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x4005c
movq %rax, %r13
movq (%r12), %rax
movq %rax, 0x30(%r13)
leaq 0x38(%r13), %rdi
addq $0x8, %r12
movq %r12, %rsi
callq 0x28170
xorps %xmm0, %xmm0
movq 0x28(%r13), %rdi
movups %xmm0, 0x20(%r1... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::setFilterOnWrite(bool) | void
QPDFObjectHandle::setFilterOnWrite(bool val)
{
as_stream(error).setFilterOnWrite(val);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10017f
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x10014a
cmpl $0xd, %eax
jne 0x100155
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0x10014f
callq 0x3fe7f
movq (%rax), %rax
m... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::isRootMetadata() const | bool
QPDFObjectHandle::isRootMetadata() const
{
return as_stream(error).isRootMetadata();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10048b
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x100456
cmpl $0xd, %eax
jne 0x100461
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0x10045b
callq 0x3fe7f
movq (%rax), %rax
movb 0x30(%rax), %al
cmpb $0... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::getRawStreamData() | std::shared_ptr<Buffer>
QPDFObjectHandle::getRawStreamData()
{
return as_stream(error).getRawStreamData();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x10061c
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x1005e7
cmpl $0xd, %eax
jne 0x1005f2
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12bcf4
jmp 0x1005ec
callq 0x3fe7f
movq (%rax), %rax
m... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::pipeStreamData(Pipeline*, bool*, int, qpdf_stream_decode_level_e, bool, bool) | bool
QPDFObjectHandle::pipeStreamData(
Pipeline* p,
bool* filtering_attempted,
int encode_flags,
qpdf_stream_decode_level_e decode_level,
bool suppress_warnings,
bool will_retry)
{
return as_stream(error).pipeStreamData(
p, filtering_attempted, encode_flags, decode_level, suppress_wa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r15d
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1006f8
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x1006c1
cmpl $0xd, %eax
jne 0x1006cc
movq 0x48(%r... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::pipeStreamData(Pipeline*, int, qpdf_stream_decode_level_e, bool, bool) | bool
QPDFObjectHandle::pipeStreamData(
Pipeline* p,
int encode_flags,
qpdf_stream_decode_level_e decode_level,
bool suppress_warnings,
bool will_retry)
{
bool filtering_attempted;
as_stream(error).pipeStreamData(
p, &filtering_attempted, encode_flags, decode_level, suppress_warnings,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r12d
movl %r8d, %r15d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1007f1
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x1007ba
cmpl $0xd, %eax
jne 0x1007c5
movq 0x48(%... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::pipeStreamData(Pipeline*, bool, bool, bool) | bool
QPDFObjectHandle::pipeStreamData(Pipeline* p, bool filter, bool normalize, bool compress)
{
int encode_flags = 0;
qpdf_stream_decode_level_e decode_level = qpdf_dl_none;
if (filter) {
decode_level = qpdf_dl_generalized;
if (normalize) {
encode_flags |= qpdf_ef_normalize;
... | movl %edx, %eax
leal (%r8,%rcx,2), %edx
testl %eax, %eax
cmovel %eax, %edx
movl %eax, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0x100774
| /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::shared_ptr<Buffer>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::shared_ptr<Buffer> data,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
as_stream(error).replaceStreamData(data, filter, decode_parms);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x100900
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x1008c5
cmpl $0xd, %eax
jne 0x1008d0
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::string const& data, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms)
{
auto b = std::make_shared<Buffer>(data.length());
unsigned char* bp = b->getBuffer();
if (bp) {
memcpy(bp, data.c_str(), data.length());
}
as_stream(... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rsi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x20(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
callq 0x103694
movq ... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::shared_ptr<QPDFObjectHandle::StreamDataProvider>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::shared_ptr<StreamDataProvider> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
as_stream(error).replaceStreamData(provider, filter, decode_parms);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x100bce
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x100b93
cmpl $0xd, %eax
jne 0x100b9e
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::function<void (Pipeline*)>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::function<void(Pipeline*)> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto sdp = std::shared_ptr<StreamDataProvider>(new FunctionProvider(provider));
as_stream(error).replaceStreamData(sdp, filter, decode_parms);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movl $0x50, %edi
callq 0x19180
movq %rax, %r12
leaq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x27d72
movb $0x1, %bpl
movq %r12, %rdi
xorl %esi, %esi
callq 0xbfdcc
leaq 0xee822... | /qpdf[P]qpdf/libqpdf/QPDF_Stream.cc |
SF_DCTDecode::factory() | static std::shared_ptr<QPDFStreamFilter>
factory()
{
return std::make_shared<SF_DCTDecode>();
} | pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xedbab(%rip), %rcx # 0x1ef6d8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xedbed(%rip), %rdx # 0x1ef728
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
mov... | /qpdf[P]qpdf/libqpdf/qpdf/SF_DCTDecode.hh |
SF_ASCII85Decode::factory() | static std::shared_ptr<QPDFStreamFilter>
factory()
{
return std::make_shared<SF_ASCII85Decode>();
} | pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xedc0b(%rip), %rcx # 0x1ef780
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xedc4d(%rip), %rdx # 0x1ef7d0
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
mov... | /qpdf[P]qpdf/libqpdf/qpdf/SF_ASCII85Decode.hh |
SF_ASCIIHexDecode::factory() | static std::shared_ptr<QPDFStreamFilter>
factory()
{
return std::make_shared<SF_ASCIIHexDecode>();
} | pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xedcbb(%rip), %rcx # 0x1ef878
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xedcfd(%rip), %rdx # 0x1ef8c8
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
mov... | /qpdf[P]qpdf/libqpdf/qpdf/SF_ASCIIHexDecode.hh |
JSON::Writer::writeBase64(std::basic_string_view<char, std::char_traits<char>>) | Writer&
writeBase64(std::string_view sv)
{
Pl_Concatenate cat{"writer concat", p};
Pl_Base64 base{"writer base64", &cat, Pl_Base64::a_encode};
base.write(reinterpret_cast<unsigned char const*>(sv.data()), sv.size());
base.finish();
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0x7b07f(%rip), %rsi # 0x17ce2a
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x3396c
leaq 0x7b079(%rip), %rsi # 0x17ce38
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x... | /qpdf[P]qpdf/libqpdf/qpdf/JSON_writer.hh |
qpdf::Stream::getDict() const | QPDFObjectHandle
getDict() const
{
return stream()->stream_dict;
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4005c
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x101e9f
movq 0xef0ef(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x101e9b
incl 0x8(%rax)
jmp 0x101e9f
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF::Pipe::pipeStreamData(QPDF*, QPDFObjGen, long long, unsigned long, QPDFObjectHandle, bool, Pipeline*, bool, bool) | static bool
pipeStreamData(
QPDF* qpdf,
QPDFObjGen og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle dict,
bool is_root_metadata,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
return qpdf->pipeStreamData(
... | pushq %rbx
subq $0x10, %rsp
movb 0x30(%rsp), %r11b
movb 0x28(%rsp), %r10b
movq 0x20(%rsp), %rax
movq (%r8), %rbx
movq %rbx, (%rsp)
movq 0x8(%r8), %r8
movq %r8, 0x8(%rsp)
testq %r8, %r8
je 0x101f2a
movq 0xef066(%rip), %rbx # 0x1f0f80
cmpb $0x0, (%rbx)
je 0x101f25
incl 0x8(%r8)
jmp 0x101f2a
lock
incl 0x8(%r8)
subq $0... | /qpdf[P]qpdf/libqpdf/qpdf/QPDF_private.hh |
SF_ASCII85Decode::getDecodePipeline(Pipeline*) | Pipeline*
getDecodePipeline(Pipeline* next) override
{
this->pipeline = std::make_shared<Pl_ASCII85Decoder>("ascii85 decode", next);
return this->pipeline.get();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r8
movq %rsi, (%r8)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x7a8bd(%rip), %rcx # 0x17ce0b
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x102598
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x1... | /qpdf[P]qpdf/libqpdf/qpdf/SF_ASCII85Decode.hh |
QPDF_Stream::QPDF_Stream(QPDFObjectHandle, unsigned long) | QPDF_Stream(QPDFObjectHandle stream_dict, size_t length) :
m(std::make_unique<Members>(stream_dict, length))
{
if (!stream_dict.isDictionary()) {
throw std::logic_error(
"stream object instantiated with non-dictionary object for dictionary");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x58, %edi
callq 0x19180
movq (%r14), %rcx
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x102d65
movq 0xee229(%rip), %rsi # 0x1f0f80
cmpb $0x0, (%rsi)
je 0x102d61
incl 0x8(%rdx)
jmp 0x102d65
lock
incl 0x8(%rdx)
movb $0x1, (%rax)
movq... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDF_String::getUTF8Val[abi:cxx11]() const | std::string
QPDF_String::getUTF8Val() const
{
if (QUtil::is_utf16(this->val)) {
return QUtil::utf16_to_utf8(this->val);
} else if (QUtil::is_explicit_utf8(this->val)) {
// PDF 2.0 allows UTF-8 strings when explicitly prefixed with the three-byte representation
// of U+FEFF.
retur... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x144938
testb %al, %al
je 0x103ac9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144985
jmp 0x103af9
movq %r14, %rdi
callq 0x144965
testb %al, %al
je 0x103aee
movl $0x3, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x19b60
... | /qpdf[P]qpdf/libqpdf/QPDF_String.cc |
QPDF_String::unparse[abi:cxx11](bool) | std::string
QPDF_String::unparse(bool force_binary)
{
bool use_hexstring = force_binary || useHexString();
std::string result;
if (use_hexstring) {
static auto constexpr hexchars = "0123456789abcdef";
result.reserve(2 * this->val.length() + 2);
result += '<';
for (const char ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0x103b8d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x103bac
movq %r14, %rdi
callq 0x103b04
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq $0x0... | /qpdf[P]qpdf/libqpdf/QPDF_String.cc |
QPDF::EncryptionData::setV5EncryptionParameters(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx1... | void
QPDF::EncryptionData::setV5EncryptionParameters(
std::string const& O,
std::string const& OE,
std::string const& U,
std::string const& UE,
std::string const& Perms)
{
this->O = O;
this->OE = OE;
this->U = U;
this->UE = UE;
this->Perms = Perms;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
addq $0x10, %rdi
callq 0x19d00
leaq 0x50(%r13), %rdi
movq %r12, %rsi
callq 0x19d00
leaq 0x30(%r13), %rdi
movq %r15, %rsi
callq 0x19d00
leaq 0x70(%r13), %rdi
movq %r14, %rsi
callq 0x19d00
... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | std::string
QPDF::compute_encryption_key(std::string const& password, EncryptionData const& data)
{
if (data.getV() >= 5) {
// For V >= 5, the encryption key is generated and stored in the file, encrypted separately
// with both user and owner passwords.
return recover_encryption_key_with_pa... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x5, (%rdx)
jl 0x1041ca
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
callq 0x10449a
jmp 0x1041d2
movq %rbx, %rdi
callq 0x1041f8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_key_from_password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | std::string
QPDF::compute_encryption_key_from_password(std::string const& password, EncryptionData const& data)
{
// Algorithm 3.2 from the PDF 1.7 Reference Manual
// This code does not properly handle Unicode passwords. Passwords are supposed to be converted
// from OS codepage characters to PDFDocEncodi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2a6cc
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x10(%rsp), %rdi
callq 0x104378
movq 0x10(%rsp), %rsi
movq %rsp, %rdi
movl $0x20, %edx
callq 0x2a7b4
leaq 0x20(%rsp), %rax
movq -0x10(%ra... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
pad_or_truncate_password_V4(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string
pad_or_truncate_password_V4(std::string const& password)
{
char k1[key_bytes];
pad_or_truncate_password_V4(password, k1);
return {k1, key_bytes};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movl $0x20, %r12d
cmpq %r12, %rdx
cmovaeq %r12, %r15
subq %r15, %r12
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x19080
leaq (%rsp,%r15), %rdi
addq $0x10, %rdi
leaq 0x79078(%rip), %rsi # 0x17d430
movq %r12,... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
iterate_md5_digest(MD5&, unsigned char (&) [16], int, int) | static void
iterate_md5_digest(MD5& md5, MD5::Digest& digest, int iterations, int key_len)
{
md5.digest(digest);
for (int i = 0; i < iterations; ++i) {
MD5 m;
m.encodeDataIncrementally(reinterpret_cast<char*>(digest), QIntC::to_size(key_len));
m.digest(digest);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
callq 0x2aa0a
testl %ebp, %ebp
jle 0x104472
movslq %ebx, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x2a6cc
testl %ebx, %ebx
jns 0x104446
movl %ebx, %edi
callq 0x333ce
movq %r12, %rdi
movq %r14, %rsi
... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::recover_encryption_key_with_password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&, bool&) | std::string
QPDF::recover_encryption_key_with_password(
std::string const& password, EncryptionData const& data, bool& perms_valid)
{
// Algorithm 3.2a from the PDF 1.7 extension level 3
// This code does not handle Unicode passwords correctly. Empirical evidence suggests that most
// viewers don't. W... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, (%rcx)
movq 0x8(%rsi), %rax
cmpq $0x7f, %rax
movl $0x7f, %ecx
cmovbq %rax, %rcx
leaq 0x90(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x19b60
leaq 0x40(%rsp... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
check_owner_password_V5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_owner_password_V5(std::string const& owner_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.12 from the PDF 1.7 extension level 3
std::string user_data = data.getU().substr(0, 48);
std::string owner_data = data.getO().substr(0, 32);
std::string validation_salt = data.getO(... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %rsi
leaq 0x80(%rsp), %rdi
movl $0x30, %ecx
xorl %edx, %edx
callq 0x19b60
leaq 0x10(%rbx), %r15
movq %rsp, %rdi
movl $0x20, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x19b60
leaq 0x60(%rsp), %rdi
movl $0x20, %edx
movl $0x8, %... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
check_user_password_V5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_user_password_V5(std::string const& user_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.11 from the PDF 1.7 extension level 3
std::string user_data = data.getU().substr(0, 32);
std::string validation_salt = data.getU().substr(32, 8);
std::string password = truncate_passw... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %r15
leaq 0x20(%rsp), %rdi
movl $0x20, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x19b60
leaq 0x80(%rsp), %rdi
movl $0x20, %edx
movl $0x8, %ecx
movq %r15, %rsi
callq 0x19b60
movq 0x8(%r14), %rax
cmpq $0x7f, %rax
movl $0x... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
hash_V5(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static std::string
hash_V5(
std::string const& password,
std::string const& salt,
std::string const& udata,
QPDF::EncryptionData const& data)
{
Pl_SHA2 hash(256);
hash.writeString(password);
hash.writeString(salt);
hash.writeString(udata);
hash.finish();
std::string K = hash.getR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r8, %rbx
movq %rcx, 0x38(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0xf0(%rsp), %r13
movq %r13, %rdi
movl $0x100, %esi # imm = 0x100
xorl %edx, %edx
callq 0x38928
movq %r13, %rdi... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
process_with_aes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned int, unsigned char const*, unsigned long) | static std::string
process_with_aes(
std::string const& key,
bool encrypt,
std::string const& data,
size_t outlength = 0,
unsigned int repetitions = 1,
unsigned char const* iv = nullptr,
size_t iv_length = 0)
{
Pl_Buffer buffer("buffer");
Pl_AES_PDF aes(
"aes", &buffer, encry... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x74efb(%rip), %rsi # 0x17a13d
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x3352c
movq %r14, %rdi
callq... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::decryptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, QPDFObjGen) | void
QPDF::decryptString(std::string& str, QPDFObjGen og)
{
if (!og.isIndirect()) {
return;
}
bool use_aes = false;
if (m->encp->encryption_V >= 4) {
switch (m->encp->cf_string) {
case e_none:
return;
case e_aes:
use_aes = true;
break;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x58(%rsp)
testl %edx, %edx
je 0x108977
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x108(%rax), %rcx
cmpl $0x4, 0x4(%rcx)
jl 0x108701
movl 0x44(%rcx), %edx
cmpq $0x4, %rdx
ja 0x108705
leaq... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::decryptStream(std::shared_ptr<QPDF::EncryptionParameters>, std::shared_ptr<InputSource>, QPDF&, Pipeline*&, QPDFObjGen, QPDFObjectHandle&, bool, std::unique_ptr<Pipeline, std::default_delete<Pipeline>>&) | void
QPDF::decryptStream(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDF& qpdf_for_warning,
Pipeline*& pipeline,
QPDFObjGen og,
QPDFObjectHandle& stream_dict,
bool is_root_metadata,
std::unique_ptr<Pipeline>& decrypt_pipeline)
{
std::string type;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %rbp
movq %r8, 0x168(%rsp)
movq %rcx, 0x170(%rsp)
movq %rdx, 0x158(%rsp)
movq %rsi, 0x160(%rsp)
movq %rdi, %r15
leaq 0x148(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
lea... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_O_U(char const*, char const*, int, int, int, int, bool, 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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void
QPDF::compute_encryption_O_U(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
int P,
bool encrypt_metadata,
std::string const& id1,
std::string& O,
std::string& U)
{
if (V >= 5) {
throw std::logic_error("compute_encryption_O_U ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, 0xc8(%rsp)
movq %rdi, 0xc0(%rsp)
cmpl $0x5, %edx
jge 0x10a267
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r13d
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x72368(%rip), %rdx ... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::isEncrypted(int&, int&, int&, QPDF::encryption_method_e&, QPDF::encryption_method_e&, QPDF::encryption_method_e&) | static void
iterate_md5_digest(MD5& md5, MD5::Digest& digest, int iterations, int key_len)
{
md5.digest(digest);
for (int i = 0; i < iterations; ++i) {
MD5 m;
m.encodeDataIncrementally(reinterpret_cast<char*>(digest), QIntC::to_size(key_len));
m.digest(digest);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %rax
movq 0x108(%rax), %rax
movb (%rax), %bl
cmpb $0x1, %bl
jne 0x10b738
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r13
movq %r8, 0x38(%rsp)
movq %r9, 0x40(%rsp)
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowAccessibility() | bool
QPDF::allowAccessibility()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
if (R < 3) {
status = is_bit_set(P, 5);
} else {
status = is_bit_set(P, 10);
}
}
return status;
} | subq $0x28, %rsp
xorl %eax, %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x18(%rsp), %rax
movq %rax, (%rsp)
leaq 0x24(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x1c(%rsp), %r9
callq 0x10b52e
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x10b8a4
cmpl $0x2, 0x14(%rsp)
movl 0x1... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowExtractAll() | bool
QPDF::allowExtractAll()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 5);
}
return status;
} | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0xc(%rsp), %rsi
leaq 0x1c(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x14(%rsp), %r9
movq %rbx, %rdx
callq 0x10b52e
movl (%rbx), %ecx
andl $0x10, %ecx
shrl $0x4, %ecx
xorb $0x1, %al
orb %cl, %al
addq $0x20, %rsp
p... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowPrintLowRes() | bool
QPDF::allowPrintLowRes()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 3);
}
return status;
} | pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0xc(%rsp), %rsi
leaq 0x1c(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x14(%rsp), %r9
movq %rbx, %rdx
callq 0x10b52e
movl (%rbx), %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
xorb $0x1, %al
orb %cl, %al
addq $0x20, %rsp
po... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::getLinearizedParts(QPDFWriter::ObjTable const&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, st... | void
QPDF::getLinearizedParts(
QPDFWriter::ObjTable const& obj,
std::vector<QPDFObjectHandle>& part4,
std::vector<QPDFObjectHandle>& part6,
std::vector<QPDFObjectHandle>& part7,
std::vector<QPDFObjectHandle>& part8,
std::vector<QPDFObjectHandle>& part9)
{
calculateLinearizationData(obj);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %rbx
movq 0x40(%rsp), %r14
callq 0x11ee28
movl $0x4b0, %esi # imm = 0x4B0
addq (%rbx), %rsi
movq %rbp, %rdi
callq 0x8db7c
movl $0x4c8, %esi # imm = ... | /qpdf[P]qpdf/libqpdf/QPDF_linearization.cc |
QIntC::IntConverter<double, int, true, true>::error(double) | 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 signed type";
throw std... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x19af0
movq (%rbx), %rax
movq -0x18(%rax), %rbx
callq 0x19130
leaq (%rsp,%rbx), %rsi
addq $0x38, %rsi
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
callq 0x195d0
leaq 0x10(%rsp), %rdi
... | /qpdf[P]qpdf/include/qpdf/QIntC.hh |
QPDF::reconstruct_xref(QPDFExc&, bool)::$_0::operator()() const | void
QPDF::setTrailer(QPDFObjectHandle obj)
{
if (m->trailer) {
return;
}
m->trailer = obj;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rax
movq 0x278(%rax), %rcx
subq 0x270(%rax), %rcx
sarq $0x7, %rcx
cmpq %rsi, %rcx
ja 0x126af1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movl $0x80, %edi
callq 0x193f0
movq %rax, %rbx
leaq ... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getObject(QPDFObjGen) | QPDFObjectHandle
QPDF::getObject(QPDFObjGen og)
{
if (auto it = m->obj_cache.find(og); it != m->obj_cache.end()) {
return {it->second.object};
} else if (m->parsed && !m->xref_table.count(og)) {
return QPDFObject::create<QPDF_Null>();
} else {
auto result =
m->obj_cache.t... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
movq %rdx, (%rsi)
movl $0x1a8, %edi # imm = 0x1A8
addq (%r14), %rdi
callq 0x1351c4
movq (%r14), %r15
leaq 0x1b0(%r15), %rcx
cmpq %rcx, %rax
je 0x12747f
movq 0x28(%rax), %rcx
movq %rcx, (%rb... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::read_xrefTable(long long) | qpdf_offset_t
QPDF::read_xrefTable(qpdf_offset_t xref_offset)
{
m->file->seek(xref_offset, SEEK_SET);
std::string line;
while (true) {
line.assign(50, '\0');
m->file->read(line.data(), line.size());
int obj = 0;
int num = 0;
int bytes = 0;
if (!parse_xrefFirst... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
movq %rsi, 0xf0(%rsp)
xorl %edx, %edx
callq *0x28(%rax)
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%r... | /qpdf[P]qpdf/libqpdf/QPDF_objects.cc |
SF_FlateLzwDecode::lzw_factory() | std::shared_ptr<QPDFStreamFilter>
SF_FlateLzwDecode::lzw_factory()
{
return std::make_shared<SF_FlateLzwDecode>(true);
} | pushq %rbx
movq %rdi, %rbx
movl $0x48, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xa505f(%rip), %rcx # 0x1effb8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xa4f09(%rip), %rdx # 0x1efe70
movq %rdx, 0x10(%rax)
movb $0x1, %dl
movb %dl, 0x18(%rax)
movaps 0x36... | /qpdf[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
qpdf_get_error | qpdf_error
qpdf_get_error(qpdf_data qpdf)
{
if (qpdf->error.get()) {
qpdf->tmp_error.exc = qpdf->error;
qpdf->error = nullptr;
QTC::TC("qpdf", "qpdf-c qpdf_get_error returned error");
return &qpdf->tmp_error;
} else {
return nullptr;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x14b5dd
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
leaq 0x28(%r14), %rsi
callq 0x28170
xorps %xmm0, %xmm0
movq 0x28(%r14), %rdi
movups %xmm0, 0x20(%r14)
testq %rdi, %rdi
je 0x14b5df
callq 0x1dba8
jmp 0x14b5df
x... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_next_warning | qpdf_error
qpdf_next_warning(qpdf_data qpdf)
{
if (qpdf_more_warnings(qpdf)) {
qpdf->tmp_error.exc = std::make_shared<QPDFExc>(qpdf->warnings.front());
qpdf->warnings.pop_front();
QTC::TC("qpdf", "qpdf-c qpdf_next_warning returned warning");
return &qpdf->tmp_error;
} else {
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x14b531
testl %eax, %eax
je 0x14b664
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %rcx
addq $0x10, %rcx
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x15a702
movaps (%r15), %xmm0
xorps %xmm... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_check_pdf | QPDF_ERROR_CODE
qpdf_check_pdf(qpdf_data qpdf)
{
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_check);
QTC::TC("qpdf", "qpdf-c called qpdf_check_pdf");
return status;
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
leaq 0x282(%rip), %rax # 0x14b995
movq %rax, (%rsi)
leaq 0xf283(%rip), %rax # 0x15a9a0
movq %rax, 0x18(%rsi)
leaq 0xf280(%rip), %rax # 0x15a9a8
movq %rax, 0x10(%rsi)
callq 0x14b77e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_info_key | char const*
qpdf_get_info_key(qpdf_data qpdf, char const* key)
{
char const* result = nullptr;
QPDFObjectHandle trailer = qpdf->qpdf->getTrailer();
if (trailer.hasKey("/Info")) {
QPDFObjectHandle info = trailer.getKey("/Info");
if (info.hasKey(key)) {
QPDFObjectHandle value = inf... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x48(%rsp), %rdi
callq 0x3e000
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a750(%rip), %rsi # 0x1664c7
leaq 0x1a74e(%rip), %rdx # 0x1664cc
leaq 0x8(%rsp), %rdi
callq 0x1fa24
leaq 0x48(%rs... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_init_write | QPDF_ERROR_CODE
qpdf_init_write(qpdf_data qpdf, char const* filename)
{
qpdf_init_write_internal(qpdf);
qpdf->filename = filename;
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_init_write);
QTC::TC("qpdf", "qpdf-c called qpdf_init_write", status);
return status;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x14c3cb
movq %rbx, 0x78(%r14)
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0xca(%rip), %rax # 0x14c421
movq %rax, (%rsi)
leaq 0xe63f(%rip), %rax # 0x15a9a0
movq %rax, 0x18(%rsi)
leaq 0xe63c(%rip), %rax # 0x15a9a8
movq %rax,... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_init_write_internal(_qpdf_data*) | static void
qpdf_init_write_internal(qpdf_data qpdf)
{
if (qpdf->qpdf_writer.get()) {
QTC::TC("qpdf", "qpdf-c called qpdf_init_write multiple times");
qpdf->qpdf_writer = nullptr;
if (qpdf->output_buffer.get()) {
qpdf->output_buffer = nullptr;
qpdf->write_memory = fal... | cmpq $0x0, 0x10(%rdi)
je 0x14c420
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x18(%rdi), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0x14c3eb
callq 0x1dba8
cmpq $0x0, 0xa0(%rbx)
je 0x14c41f
xorps %xmm0, %xmm0
movq 0xa8(%rbx), %rdi
movups %xmm0, 0xa0(%rbx)
testq %rdi, %rdi
je 0x14c410
callq 0x1dba8
movb $0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_init_write_memory | QPDF_ERROR_CODE
qpdf_init_write_memory(qpdf_data qpdf)
{
qpdf_init_write_internal(qpdf);
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_init_write_memory);
QTC::TC("qpdf", "qpdf-c called qpdf_init_write_memory");
qpdf->write_memory = true;
return status;
} | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x14c3cb
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x7a(%rip), %rax # 0x14c521
movq %rax, (%rsi)
leaq 0xe4ef(%rip), %rax # 0x15a9a0
movq %rax, 0x18(%rsi)
leaq 0xe4ec(%rip), %rax # 0x15a9a8
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x14... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
call_init_write_memory(_qpdf_data*) | static void
call_init_write_memory(qpdf_data qpdf)
{
qpdf->qpdf_writer = std::make_shared<QPDFWriter>(*(qpdf->qpdf));
qpdf->qpdf_writer->setOutputMemory();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x15a1ac
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r5_encryption_parameters2 | void
qpdf_set_r5_encryption_parameters2(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_accessibility,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_assemble,
QPDF_BOOL allow_annotate_and_form,
QPDF_BOOL allow_form_filling,
QPDF_BOOL allow_modify_ot... | pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %eax
movl %r8d, %r9d
movl %ecx, %r8d
movl 0x38(%rsp), %r10d
movq 0x10(%rdi), %rdi
xorl %ecx, %ecx
testl %r8d, %r8d
setne %cl
xorl %r8d, %r8d
testl %r9d, %r9d
setne %r8b
xorl %r9d, %r9d
testl %eax, %eax
setne %r9b
xorl %eax, %eax
cmpl $0x0, 0x20(%rsp)
setne %al
xorl %r11d, %r1... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_force_pdf_version_and_extension | void
qpdf_force_pdf_version_and_extension(qpdf_data qpdf, char const* version, int extension_level)
{
QTC::TC("qpdf", "qpdf-c called qpdf_force_pdf_version");
qpdf->qpdf_writer->forcePDFVersion(version, extension_level);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq 0x10(%rdi), %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1f9e6
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xe4f2a
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14c9f1
movq 0x20(%rsp), %rsi
in... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_write | QPDF_ERROR_CODE
qpdf_write(qpdf_data qpdf)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
status = trap_errors(qpdf, &call_write);
QTC::TC("qpdf", "qpdf-c called qpdf_write", (status == 0) ? 0 : 1);
return status;
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
leaq 0x6b(%rip), %rax # 0x14cbbb
movq %rax, (%rsi)
leaq 0xde46(%rip), %rax # 0x15a9a0
movq %rax, 0x18(%rsi)
leaq 0xde43(%rip), %rax # 0x15a9a8
movq %rax, 0x10(%rsi)
callq 0x14b77e
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_trailer | qpdf_oh
qpdf_get_trailer(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_get_trailer");
return trap_oh_errors<qpdf_oh>(qpdf, return_uninitialized(qpdf), [](qpdf_data q) {
return new_object(q, q->qpdf->getTrailer());
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0x7d67(%rip), %rax # 0x154a54
movq %rax, 0x18(%rsi)
leaq 0x7d64(%rip), %rax # 0x154a5c
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
leaq 0x8786(%rip), %rax # 0x155492
movq %rax, ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
unsigned int trap_oh_errors<unsigned int>(_qpdf_data*, std::function<unsigned int ()>, std::function<unsigned int (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rax
leaq 0x18(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rdx, %rsi
callq 0x15ad80
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x28, %edi
callq 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_root | qpdf_oh
qpdf_get_root(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_get_root");
return trap_oh_errors<qpdf_oh>(qpdf, return_uninitialized(qpdf), [](qpdf_data q) {
return new_object(q, q->qpdf->getRoot());
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rdi, (%rsi)
leaq 0x79f7(%rip), %rax # 0x154a54
movq %rax, 0x18(%rsi)
leaq 0x79f4(%rip), %rax # 0x154a5c
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
leaq 0x8488(%rip), %rax # 0x155504
movq %rax, ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_object_by_id | qpdf_oh
qpdf_get_object_by_id(qpdf_data qpdf, int objid, int generation)
{
QTC::TC("qpdf", "qpdf-c called qpdf_get_object_by_id");
return new_object(qpdf, qpdf->qpdf->getObjectByID(objid, generation));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3b6ae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14cbfb
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14d14d
callq 0x1dba8
movl %ebx, %eax
addq $0x18, %rsp
pop... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_replace_object | void
qpdf_replace_object(qpdf_data qpdf, int objid, int generation, qpdf_oh oh)
{
do_with_oh_void(qpdf, oh, [qpdf, objid, generation](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_replace_object");
qpdf->qpdf->replaceObject(objid, generation, o);
});
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
leaq 0x83ed(%rip), %rdx # 0x155576
movq %rdx, 0x18(%rax)
leaq 0x8458(%rip), %rdx # 0x1555ec
movq %rdx, 0x10(%rax)
movl %ecx, %esi
movq %rax, %rdx
callq 0x14d1eb
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
do_with_oh_void(_qpdf_data*, unsigned int, std::function<void (QPDFObjectHandle&)>) | static void
do_with_oh_void(qpdf_data qpdf, qpdf_oh oh, std::function<void(QPDFObjectHandle&)> fn)
{
do_with_oh<bool>(qpdf, oh, return_T<bool>(false), [fn](QPDFObjectHandle& o) {
fn(o);
return true; // unused
});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x6(%rsp), %rax
movb $0x0, (%rax)
movq $0x0, 0x68(%rsp)
movq %rax, 0x60(%rsp)
leaq 0x7c20(%rip), %rax # 0x154e38
movq %rax, 0x78(%rsp)
leaq 0x7c1a(%rip), %rax # 0x154e3e
movq %rax, 0x70(%rsp)
leaq ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_initialized | QPDF_BOOL
qpdf_oh_is_initialized(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_initialized");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return static_cast<bool>(o); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq 0x4e0(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xd6be(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xd6b5(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x81cf... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
int do_with_oh<int>(_qpdf_data*, unsigned int, std::function<int ()>, std::function<int (QPDFObjectHandle&)>) | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xb0(%rsp), %rdi
movq %rdx, %rsi
callq 0x15adde
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0xf6a62
movl %ebp, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x28, %edi
callq 0x1... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_bool | QPDF_BOOL
qpdf_oh_is_bool(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_bool");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isBool(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x1c(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xd1c2(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xd1b9(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7cf5... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_null | QPDF_BOOL
qpdf_oh_is_null(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_null");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isNull(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0xf5(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xd0e9(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xd0e0(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7c42... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_integer | QPDF_BOOL
qpdf_oh_is_integer(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_integer");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isInteger(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x1ce(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xd010(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xd007(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7b8f... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_real | QPDF_BOOL
qpdf_oh_is_real(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_real");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isReal(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x2a7(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xcf37(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xcf2e(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7adc... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_name | QPDF_BOOL
qpdf_oh_is_name(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_name");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isName(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x380(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xce5e(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xce55(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7a29... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_string | QPDF_BOOL
qpdf_oh_is_string(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_string");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isString(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x459(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xcd85(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xcd7c(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x7976... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_operator | QPDF_BOOL
qpdf_oh_is_operator(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_operator");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isOperator(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x532(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xccac(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xcca3(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x78c3... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_array | QPDF_BOOL
qpdf_oh_is_array(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_array");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isArray(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x6e4(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xcafa(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xcaf1(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x775d... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_dictionary | QPDF_BOOL
qpdf_oh_is_dictionary(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_dictionary");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isDictionary(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x7bd(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xca21(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xca18(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x76aa... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_stream | QPDF_BOOL
qpdf_oh_is_stream(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_stream");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isStream(); });
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x896(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xc948(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xc93f(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x75f7... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_dictionary_of_type | QPDF_BOOL
qpdf_oh_is_dictionary_of_type(qpdf_data qpdf, qpdf_oh oh, char const* type, char const* subtype)
{
auto stype = (subtype == nullptr) ? "" : subtype;
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [type, stype](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_dictionary_of... | pushq %rbx
subq $0x40, %rsp
testq %rcx, %rcx
leaq 0x2d72a(%rip), %r8 # 0x17c0a8
cmovneq %rcx, %r8
leaq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
leaq -0xce4(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0xc4fa(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0xc4f1(%rip), %rcx # 0x15ae9c
movq %rcx, 0x1... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_type_code | qpdf_object_type_e
qpdf_oh_get_type_code(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<qpdf_object_type_e>(
qpdf, oh, return_T<qpdf_object_type_e>(ot_uninitialized), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_type_code");
return o.getTypeCode();
})... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x60(%rsp), %rax
movl $0x0, (%rax)
leaq 0xf0(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rax, (%rsi)
leaq 0x7305(%rip), %rax # 0x155d94
movq %rax, 0x18(%rsi)
leaq 0x7300(%rip), %rax # 0x155d9a
movq %rax... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_bool_value | QPDF_BOOL
qpdf_oh_get_bool_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_bool_value");
return o.getBoolValue();
});
} | pushq %rbx
subq $0x40, %rsp
leaq 0x20(%rsp), %rdx
movq $0x0, 0x8(%rdx)
leaq -0x1aed(%rip), %rax # 0x14dcb2
movq %rax, (%rdx)
leaq 0xb6f1(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rdx)
leaq 0xb6e8(%rip), %rax # 0x15ae9c
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x736c... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_bool | QPDF_BOOL
qpdf_oh_get_value_as_bool(qpdf_data qpdf, qpdf_oh oh, QPDF_BOOL* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_bool");
bool v = *value;
QPDF_BOOL result = o.getValueAsBool(v);
... | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x1bc5(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0xb619(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0xb610(%rip), %rcx # 0x15ae9c
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_int_value | long long
qpdf_oh_get_int_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<long long>(qpdf, oh, return_T<long long>(0LL), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_int_value");
return o.getIntValue();
});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x128(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x108(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x724a(%rip), %rax # 0x156bb8
movq %rax, 0x18(%rsi)
leaq 0x7247(%rip), %rax # ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_longlong | QPDF_BOOL
qpdf_oh_get_value_as_longlong(qpdf_data qpdf, qpdf_oh oh, long long* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_longlong");
return o.getValueAsInt(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x21be(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0xb020(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0xb017(%rip), %rcx # 0x15ae9c
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_int_value_as_int | int
qpdf_oh_get_int_value_as_int(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_int_value_as_int");
return o.getIntValueAsInt();
});
} | pushq %rbx
subq $0x50, %rsp
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
leaq 0x30(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movq %rax, (%rdx)
leaq 0x709b(%rip), %rax # 0x156ff6
movq %rax, 0x18(%rdx)
leaq 0x7096(%rip), %rax # 0x156ffc
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_uint_value | unsigned long long
qpdf_oh_get_uint_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<unsigned long long>(
qpdf, oh, return_T<unsigned long long>(0ULL), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_uint_value");
return o.getUIntValue();
});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x128(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x108(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x6f56(%rip), %rax # 0x15707c
movq %rax, 0x18(%rsi)
leaq 0x6f53(%rip), %rax # ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_numeric_value | double
qpdf_oh_get_numeric_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<double>(qpdf, oh, return_T<double>(0.0), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_numeric_value");
return o.getNumericValue();
});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x128(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x108(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x6b6e(%rip), %rax # 0x157656
movq %rax, 0x18(%rsi)
leaq 0x6b6b(%rip), %rax # ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_number | QPDF_BOOL
qpdf_oh_get_value_as_number(qpdf_data qpdf, qpdf_oh oh, double* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_number");
return o.getValueAsNumber(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x333d(%rip), %rcx # 0x14dcb2
movq %rcx, (%rax)
leaq 0x9ea1(%rip), %rcx # 0x15ae9a
movq %rcx, 0x18(%rax)
leaq 0x9e98(%rip), %rcx # 0x15ae9c
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_name | char const*
qpdf_oh_get_name(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_get_name");
qpdf->tmp_string = o.getName();
return qpdf->tmp_string.c_str()... | pushq %rbx
subq $0x50, %rsp
leaq 0x2afe9(%rip), %rax # 0x17c0a8
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
leaq 0x28(%rsp), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rdx)
leaq 0x50ba(%rip), %rcx # 0x156196
movq %rcx, 0x18(%rdx)
leaq 0x50b7(%rip), %rcx # 0x15619e
movq %rcx, 0x10(%rdx)
leaq 0x8(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_name | QPDF_BOOL
qpdf_oh_get_value_as_name(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_name");
auto result = o.getValu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, 0x8(%rsp)
leaq -0x3511(%rip), %rax # 0x14dcb2
movq %rax, (%rsp)
leaq 0x9ccc(%rip), %rax # 0x15ae9a
movq %rax, 0x18(%rsp)
leaq 0x9cc2(%rip), %r13 # 0x15ae9c
mov... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_utf8_value | char const*
qpdf_oh_get_utf8_value(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_get_utf8_value");
qpdf->tmp_string = o.getUTF8Value();
return qpdf->t... | pushq %rbx
subq $0x50, %rsp
leaq 0x2abd5(%rip), %rax # 0x17c0a8
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
leaq 0x28(%rsp), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rdx)
leaq 0x4ca6(%rip), %rcx # 0x156196
movq %rcx, 0x18(%rdx)
leaq 0x4ca3(%rip), %rcx # 0x15619e
movq %rcx, 0x10(%rdx)
leaq 0x8(%r... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_binary_string_value | char const*
qpdf_oh_get_binary_string_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_string_value");
qpdf->tmp_string = o.... | pushq %rbx
subq $0x50, %rsp
leaq 0x2a9cb(%rip), %rax # 0x17c0a8
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x4a9a(%rip), %rcx # 0x156196
movq %rcx, 0x18(%rax)
leaq 0x4a97(%rip), %rcx # 0x15619e
movq %rcx, 0x10(%rax)
leaq 0x8(%rsp), %rcx
movq %... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_binary_utf8_value | char const*
qpdf_oh_get_binary_utf8_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_utf8_value");
qpdf->tmp_string = o.getU... | pushq %rbx
subq $0x50, %rsp
leaq 0x2a8de(%rip), %rax # 0x17c0a8
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rcx, (%rax)
leaq 0x49ad(%rip), %rcx # 0x156196
movq %rcx, 0x18(%rax)
leaq 0x49aa(%rip), %rcx # 0x15619e
movq %rcx, 0x10(%rax)
leaq 0x8(%rsp), %rcx
movq %... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_array_n_items | int
qpdf_oh_get_array_n_items(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_array_n_items");
return o.getArrayNItems();
});
} | pushq %rbx
subq $0x50, %rsp
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
leaq 0x30(%rsp), %rdx
movq $0x0, 0x8(%rdx)
movq %rax, (%rdx)
leaq 0x5724(%rip), %rax # 0x156ff6
movq %rax, 0x18(%rdx)
leaq 0x571f(%rip), %rax # 0x156ffc
movq %rax, 0x10(%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.