name string | code string | asm string | file string |
|---|---|---|---|
QPDF::resolve(QPDFObjGen) | std::shared_ptr<QPDFObject> const&
QPDF::resolve(QPDFObjGen og)
{
if (!isUnresolved(og)) {
return m->obj_cache[og].object;
}
if (m->resolving.count(og)) {
// This can happen if an object references itself directly or indirectly in some key that
// has to be resolved during object pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
callq 0x182aac
movq (%rbx), %r14
testb %al, %al
je 0x182bc7
leaq 0x1d8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8575a
addq $0x1e0, %r14 # imm = 0x1E0
cmpq %r14, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getAllObjects() | std::vector<QPDFObjectHandle>
QPDF::getAllObjects()
{
// After fixDanglingReferences is called, all objects are in the object cache.
fixDanglingReferences();
std::vector<QPDFObjectHandle> result;
for (auto const& iter: m->obj_cache) {
result.push_back(newIndirect(iter.first, iter.second.object))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6b390
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %r13
movq 0x1c0(%r13), %r15
addq $0x1b0, %r13 # imm = 0x1B0
cmpq %r13, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::validateStreamLineEnd(QPDFObjectHandle&, QPDFObjGen, long long) | void
QPDF::validateStreamLineEnd(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
{
// The PDF specification states that the word "stream" should be followed by either a carriage
// return and a newline or by a newline alone. It specifically disallowed following it by a
// carriage return alo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
callq *0x38(%rax)
testq %rax, %rax
je 0x184334
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x7(%rsp), %rbp
leaq 0x520d9(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readObjectInStream(qpdf::is::OffsetBuffer&, int, int) | QPDFObjectHandle
QPDF::readObjectInStream(is::OffsetBuffer& input, int stream_id, int obj_id)
{
auto [object, empty] = QPDFParser::parse(input, stream_id, obj_id, m->tokenizer, *this);
if (empty) {
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
// ac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
movq (%rsi), %r8
addq $0x18, %r8
leaq 0x130(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %r12d, %ecx
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::resolveObjectsInStream(int) | void
QPDF::resolveObjectsInStream(int obj_stream_number)
{
auto damaged =
[this, obj_stream_number](int id, qpdf_offset_t offset, std::string const& msg) -> QPDFExc {
return {
qpdf_e_damaged_pdf,
m->file->getName() + " object stream " + std::to_string(obj_stream_number),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rdi, %r15
movl %esi, 0x4(%rsp)
movq %rdi, 0x170(%rsp)
movl %esi, 0x178(%rsp)
movq (%rdi), %rdi
movq 0x2e8(%rdi), %rdx
leaq 0x2e0(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x185569
movq %rax, %rcx
xor... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getObjectForJSON(int, int) | std::shared_ptr<QPDFObject>
QPDF::getObjectForJSON(int id, int gen)
{
auto og = QPDFObjGen(id, gen);
auto [it, inserted] = m->obj_cache.try_emplace(og);
auto& obj = it->second.object;
if (inserted) {
obj = (m->parsed && !m->xref_table.count(og))
? QPDFObject::create<QPDF_Null>(this, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movl %edx, (%rsi)
movl %ecx, 0x4(%rsi)
movl $0x1a8, %edi # imm = 0x1A8
addq (%r15), %rdi
callq 0x188950
movq %rax, %r14
testb $0x1, %dl
je 0x188112
movq (%r15), %r12
cmpb $0x1, 0x2d4(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::replaceObject(int, int, QPDFObjectHandle) | void
QPDF::replaceObject(int objid, int generation, QPDFObjectHandle oh)
{
replaceObject(QPDFObjGen(objid, generation), oh);
} | pushq %rbx
subq $0x10, %rsp
movq (%rcx), %rax
movq %rax, (%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x188183
movq 0xc0c6b(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x18817f
incl 0x8(%rax)
jmp 0x188183
lock
incl 0x8(%rax)
shlq $0x20, %rdx
movl %esi, %esi
orq %rdx, %rsi
movq %rsp, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::tableSize() | size_t
QPDF::tableSize()
{
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
// objects.
auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
auto m... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
xorl %r15d, %r15d
cmpq $0x0, 0x160(%r14)
movl $0x0, %r12d
je 0x188490
leaq 0x140(%r14), %rdi
callq 0x6e050
movl 0x20(%rax), %r12d
cmpq $0x0, 0x1d0(%r14)
je 0x1884ad
addq $0x1b0, %r14 # imm = 0x1B0
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
qpdf::is::OffsetBuffer::OffsetBuffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Buffer*, long long) | OffsetBuffer(std::string const& description, Buffer* buf, qpdf_offset_t global_offset) :
proxied(description, buf),
global_offset(global_offset)
{
if (global_offset < 0) {
throw std::logic_error("is::OffsetBuffer constructed with negative offset");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %r15
xorl %eax, %eax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movq %rax, 0xa0(%rdi)
leaq 0xbeeab(%rip), %rax # 0x2476b8
movq %rax, (%rdi)
leaq 0xa8(%rdi), %rbx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x6af50
movq %r14, 0x190(%r15)
tes... | /jberkenbilt[P]qpdf/libqpdf/qpdf/InputSource_private.hh |
QPDFObject::move_to(std::shared_ptr<QPDFObject>&, bool) | void
move_to(std::shared_ptr<QPDFObject>& o, bool destroy)
{
o->value = std::move(value);
o->qpdf = qpdf;
o->og = og;
o->object_description = object_description;
o->parsed_offset = parsed_offset;
if (!destroy) {
value = QPDF_Reference(o);
}
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movsbq 0x30(%rbx), %rax
leaq 0xbee5d(%rip), %rcx # 0x247718
movq %rbx, %rsi
callq *0x8(%rcx,%rax,8)
movq 0x48(%rbx), %rax
movq (%r14), %rcx
movq %rax, 0x48(%rcx)
movq... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDFObject::swapWith(std::shared_ptr<QPDFObject>) | void
swapWith(std::shared_ptr<QPDFObject> o)
{
std::swap(value, o->value);
std::swap(qpdf, o->qpdf);
std::swap(object_description, o->object_description);
std::swap(parsed_offset, o->parsed_offset);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x18a7e8
movq (%rbx), %rax
movq 0x48(%r14), %rcx
movq 0x48(%rax), %rdx
movq %rdx, 0x48(%r14)
movq %rcx, 0x48(%rax)
movq (%rbx), %rax
movq 0x38(%r14), %rcx
movq 0x38(%rax), %rdx
movq %rdx, 0x38(%r14)
movq %rcx, 0x38(%rax)
movq 0x40(... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
std::vector<bool, std::allocator<bool>> QPDF::getCompressibleObjGens<bool>() | std::vector<T>
QPDF::getCompressibleObjGens()
{
// Return a list of objects that are allowed to be in object streams. Walk through the objects
// by traversing the document from the root, including a traversal of the pages tree. This
// makes that objects that are on the same page are more likely to be in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdi, %r15
movq %rsi, 0x38(%rsp)
movq (%rsi), %rbx
leaq 0x68(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x48df6(%rip), %rsi # 0x1d2422
leaq 0x48df7(%rip), %rdx # 0x1d242a
leaq 0x58(%rsp), %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::optimize(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&, bool, std::function<int (QPDFObjectHandle&)>) | void
QPDF::optimize(
std::map<int, int> const& object_stream_data,
bool allow_changes,
std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
optimize_internal(object_stream_data, allow_changes, skip_stream_parameters);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x14d072
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0x18ead2
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x18d0e2
leaq 0x8(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::optimize(QPDFWriter::ObjTable const&, std::function<int (QPDFObjectHandle&)>) | void
QPDF::optimize(
QPDFWriter::ObjTable const& obj, std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
optimize_internal(obj, true, skip_stream_parameters);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x14d072
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movq %r15, %rcx
callq 0x18f3b6
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18d163
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %e... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::pushInheritedAttributesToPageInternal(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocato... | void
QPDF::pushInheritedAttributesToPageInternal(
QPDFObjectHandle cur_pages,
std::map<std::string, std::vector<QPDFObjectHandle>>& key_ancestors,
bool allow_changes,
bool warn_skipped_keys)
{
// Make a list of inheritable keys. Only the keys /MediaBox, /CropBox, /Resources, and /Rotate
// are i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %r8d, %r15d
movl %ecx, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
leaq 0x120(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::filterCompressedObjects(QPDFWriter::ObjTable const&) | void
QPDF::filterCompressedObjects(QPDFWriter::ObjTable const& obj)
{
if (obj.getStreamsEmpty()) {
return;
}
// Transform object_to_obj_users and obj_user_to_objects so that they refer only to uncompressed
// objects. If something is a user of a compressed object, then it is really a user of t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x0, 0x50(%rsi)
jne 0x18ea98
movq %rsi, %r14
leaq 0x30(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x60(%rsp), %rax
movl %ecx, (%rax)
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::getAllPagesInternal(QPDFObjectHandle, QPDFObjGen::set&, QPDFObjGen::set&, bool) | void
QPDF::getAllPagesInternal(
QPDFObjectHandle cur_node, QPDFObjGen::set& visited, QPDFObjGen::set& seen, bool media_box)
{
if (!visited.add(cur_node)) {
throw QPDFExc(
qpdf_e_pages,
m->file->getName(),
"object " + cur_node.getObjGen().unparse(' '),
0,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %r8d, 0x44(%rsp)
movq %rcx, 0x98(%rsp)
movq %rdx, %rbx
movq %rdi, 0x90(%rsp)
movq %rsi, 0x48(%rsp)
movq %rsi, %rdi
callq 0x6d930
movq %rbx, 0xa8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c180
testb %al... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::removePage(QPDFObjectHandle) | void
QPDF::removePage(QPDFObjectHandle page)
{
int pos = findPage(page); // also ensures flat /Pages
QTC::TC(
"qpdf",
"QPDF remove page",
(pos == 0) ? 0 : // remove at beginning
(pos == toI(m->all_pages.size() - 1)) ? 1 // end
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6ef20
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6b890
movl %eax, %ebp
testl %eax, %eax
je 0x193ba5
movq (%rbx), %rax
movq 0x220(%rax), %rdi
subq 0x218(%rax), %rdi
sarq $0x4, %rdi
decq... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::addPageAt(QPDFObjectHandle, bool, QPDFObjectHandle) | void
QPDF::addPageAt(QPDFObjectHandle newpage, bool before, QPDFObjectHandle refpage)
{
int refpos = findPage(refpage);
if (!before) {
++refpos;
}
insertPage(newpage, refpos);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x6ef20
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6b890
xorb $0x1, %bpl
movzbl %bpl, %edx
addl %eax, %edx
movq (%r14), %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
j... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::addPage(QPDFObjectHandle, bool) | void
QPDF::addPage(QPDFObjectHandle newpage, bool first)
{
if (first) {
insertPage(newpage, 0);
} else {
insertPage(newpage, getRoot().getKey("/Pages").getKey("/Count").getIntValueAsInt());
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
testl %edx, %edx
je 0x193f4e
movq %rax, 0x10(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x193f75
movq 0xb4e9c(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x193f71
incl 0x8(%rax)
jmp 0x193f75
movq %rax, (%rs... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QTC::TC_real(char const*, char const*, int) | void
QTC::TC_real(char const* const scope, char const* const ccase, int n)
{
static std::map<std::string, bool> active;
auto is_active = active.find(scope);
if (is_active == active.end()) {
active[scope] = tc_active(scope);
is_active = active.find(scope);
}
if (!is_active->second) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movb 0xb9070(%rip), %al # 0x24d688
testb %al, %al
je 0x1948d8
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %r15, %rsi
callq 0x6e7c0
leaq 0xb901f(%rip), %rdi # 0x24d658
leaq 0x1... | /jberkenbilt[P]qpdf/libqpdf/QTC.cc |
QUtil::make_shared_cstr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<char>
QUtil::make_shared_cstr(std::string const& str)
{
auto result = QUtil::make_shared_array<char>(str.length() + 1);
// Use memcpy in case string contains nulls
result.get()[str.length()] = '\0';
memcpy(result.get(), str.c_str(), str.length());
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
incq %rdi
callq 0x6a650
movq %rax, (%r14)
leaq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x6b9e0
movq (%r14), %rax
movq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%r14), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x684e0
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::make_unique_cstr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::unique_ptr<char[]>
QUtil::make_unique_cstr(std::string const& str)
{
auto result = std::make_unique<char[]>(str.length() + 1);
// Use memcpy in case string contains nulls
result.get()[str.length()] = '\0';
memcpy(result.get(), str.c_str(), str.length());
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
leaq 0x1(%r15), %r12
movq %r12, %rdi
callq 0x6a650
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x69950
movq %r13, (%r14)
movb $0x0, (%r13,%r15)
movq (%rbx), %rsi
movq %r13, %rdi
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::hex_encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::hex_encode(std::string const& input)
{
static auto constexpr hexchars = "0123456789abcdef";
std::string result;
result.reserve(2 * input.length());
for (const char c: input) {
result += hexchars[static_cast<unsigned char>(c) >> 4];
result += hexchars[c & 0x0f];
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq %rsi, %rsi
callq 0x6c790
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x196861
movq (%r1... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::hex_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::hex_decode(std::string const& input)
{
std::string result;
// We know result.size() <= 0.5 * input.size() + 1. However, reserving string space for this
// upper bound has a negative impact.
bool first = true;
char decoded;
for (auto ch: input) {
ch = util::hex_decode_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x196927
movq (%rsi), %r13
movb $0x1, %r12b
xorl %r15d, %r15d
movb (%r13,%r15), %cl
l... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::getWhoami(char*) | char*
QUtil::getWhoami(char* argv0)
{
char* whoami = nullptr;
if (((whoami = strrchr(argv0, '/')) == nullptr) &&
((whoami = strrchr(argv0, '\\')) == nullptr)) {
whoami = argv0;
} else {
++whoami;
}
if ((strlen(whoami) > 4) && (strcmp(whoami + strlen(whoami) - 4, ".exe") == 0... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x6d5e0
testq %rax, %rax
jne 0x1969ab
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x6d5e0
testq %rax, %rax
je 0x1969b1
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x6a120
cmpq $0x5, %rax
jb 0x1969e0
movq %rax, %r14
leaq (%rbx,%rax), %rdi
addq $-0x4,... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_env(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>>*) | bool
QUtil::get_env(std::string const& var, std::string* value)
{
// This was basically ripped out of wxWindows.
#ifdef _WIN32
# ifdef NO_GET_ENVIRONMENT
return false;
# else
// first get the size of the buffer
DWORD len = ::GetEnvironmentVariable(var.c_str(), NULL, 0);
if (len == 0) {
// th... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rdi
callq 0x6c120
movq %rax, %rbx
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x196a2d
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x6a120
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x6a930
t... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_current_qpdf_time() | QUtil::QPDFTime
QUtil::get_current_qpdf_time()
{
#ifdef _WIN32
SYSTEMTIME ltime;
GetLocalTime(<ime);
TIME_ZONE_INFORMATION tzinfo;
GetTimeZoneInformation(&tzinfo);
return QPDFTime(
static_cast<int>(ltime.wYear),
static_cast<int>(ltime.wMonth),
static_cast<int>(ltime.wDay),
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x6bf90
movq %rsp, %r14
movq %rax, (%r14)
callq 0x6cba0
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x68ad0
movq 0xb2203(%rip), %rax # 0x248c78
movq (%rax), %rcx
movabsq $-0x7777777777777777, %rdx # imm = 0x888888... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::qpdf_time_to_iso8601[abi:cxx11](QUtil::QPDFTime const&) | std::string
QUtil::qpdf_time_to_iso8601(QPDFTime const& qtm)
{
std::string tz_offset;
int t = qtm.tz_delta;
if (t == 0) {
tz_offset = "Z";
} else {
if (t < 0) {
t = -t;
tz_offset += "+";
} else {
tz_offset += "-";
}
tz_offset +=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x158(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movl 0x18(%rsi), %ebp
testl %ebp, %ebp
je 0x197725
js 0x197748
leaq 0x2202c(%rip), %rsi #... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_time_to_qpdf_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QUtil::QPDFTime*) | bool
QUtil::pdf_time_to_qpdf_time(std::string const& str, QPDFTime* qtm)
{
static std::regex pdf_date(
"^D:([0-9]{4})([0-9]{2})([0-9]{2})"
"([0-9]{2})([0-9]{2})([0-9]{2})"
"(?:(Z?)|([\\+\\-])([0-9]{2})'([0-9]{2})')$");
std::smatch m;
if (!std::regex_match(str, m, pdf_date)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movb 0xb5269(%rip), %al # 0x24d780
testb %al, %al
je 0x198b8c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq (%rbx), %rdi
movq 0x... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_time_to_iso8601(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>>&) | bool
QUtil::pdf_time_to_iso8601(std::string const& pdf_time, std::string& iso8601)
{
QPDFTime qtm;
if (pdf_time_to_qpdf_time(pdf_time, &qtm)) {
iso8601 = qpdf_time_to_iso8601(qtm);
return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
leaq 0x24(%rsp), %rsi
callq 0x6ea60
movl %eax, %ebx
testb %al, %al
je 0x198d8f
movq %rsp, %r15
leaq 0x24(%rsp), %rsi
movq %r15, %rdi
callq 0x6e9a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6abd0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::toUTF16[abi:cxx11](unsigned long) | std::string
QUtil::toUTF16(unsigned long uval)
{
std::string result;
if ((uval >= 0xd800) && (uval <= 0xdfff)) {
result = "\xff\xfd";
} else if (uval <= 0xffff) {
char out[2];
out[0] = static_cast<char>((uval & 0xff00) >> 8);
out[1] = static_cast<char>(uval & 0xff);
r... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rax
andq $-0x800, %rax # imm = 0xF800
cmpq $0xd800, %rax # imm = 0xD800
jne 0x198f1f
leaq 0x3f843(%rip), %rcx # 0x1d874b
movl $0x2, %r8... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_file_into_memory(char const*, std::shared_ptr<char>&, unsigned long&) | void
QUtil::read_file_into_memory(char const* filename, std::shared_ptr<char>& file_buf, size_t& size)
{
FILE* f = safe_fopen(filename, "rb");
FileCloser fc(f);
fseek(f, 0, SEEK_END);
size = QIntC::to_size(QUtil::tell(f));
fseek(f, 0, SEEK_SET);
file_buf = QUtil::make_shared_array<char>(size);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq 0x1c395(%rip), %rsi # 0x1b5484
callq 0x6c400
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6ee30
movq %rbx, %rdi
callq 0x6c490
m... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_file_into_string[abi:cxx11](char const*) | std::string
QUtil::read_file_into_string(char const* filename)
{
FILE* f = safe_fopen(filename, "rb");
FileCloser fc(f);
return read_file_into_string(f, filename);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1bdb1(%rip), %rsi # 0x1b5484
movq %r15, %rdi
callq 0x6c400
movq %rax, %r14
movq %r15, %rdi
callq 0x6a120
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x6d400
testq %r14, %r14
je 0x199704
movq %r14, %rdi
callq 0x6a2b0
mo... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_file_into_string[abi:cxx11](_IO_FILE*, std::basic_string_view<char, std::char_traits<char>>) | std::string
QUtil::read_file_into_string(FILE* f, std::string_view filename)
{
fseek(f, 0, SEEK_END);
auto o_size = QUtil::tell(f);
if (o_size >= 0) {
// Seekable file
auto size = QIntC::to_size(o_size);
fseek(f, 0, SEEK_SET);
std::string result(size, '\0');
if (auto ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, 0x70(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x6ee30
movq %r14, %rdi
callq 0x6c490
testq %rax, %rax
js 0x19986f
movq %rax, %r15
movq... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_lines_from_file[abi:cxx11](std::istream&, bool) | std::list<std::string>
QUtil::read_lines_from_file(std::istream& in, bool preserve_eol)
{
std::list<std::string> lines;
auto next_char = [&in](char& ch) { return (in.get(ch)) ? true : false; };
read_lines_from_file(next_char, lines, preserve_eol);
return lines;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movq %rsi, (%rdi)
leaq 0x3441(%rip), %rax # 0x19d5e8
movq %rax, 0x18(%rdi)
leaq 0x3450(%rip), %rax # 0x19d602
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_lines_from_file[abi:cxx11](_IO_FILE*, bool) | std::list<std::string>
QUtil::read_lines_from_file(FILE* f, bool preserve_eol)
{
std::list<std::string> lines;
auto next_char = [&f](char& ch) { return read_char_from_FILE(ch, f); };
read_lines_from_file(next_char, lines, preserve_eol);
return lines;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movq %rax, (%rdi)
leaq 0x33dc(%rip), %rax # 0x19d628
movq %rax, 0x18(%rdi)
lea... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::str_compare_nocase(char const*, char const*) | int
QUtil::str_compare_nocase(char const* s1, char const* s2)
{
#if defined(_WIN32) && defined(__BORLANDC__)
return stricmp(s1, s2);
#elif defined(_WIN32)
return _stricmp(s1, s2);
#else
return strcasecmp(s1, s2);
#endif
} | jmp 0x6c650
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_next_utf8_codepoint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&, bool&) | unsigned long
QUtil::get_next_utf8_codepoint(std::string const& utf8_val, size_t& pos, bool& error)
{
auto o_pos = pos;
size_t len = utf8_val.length();
unsigned char ch = static_cast<unsigned char>(utf8_val.at(pos++));
error = false;
if (ch < 128) {
return static_cast<unsigned long>(ch);
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rcx
movq (%rsi), %rsi
movq 0x8(%rdi), %r8
leaq 0x1(%rsi), %r9
movq %r9, (%rcx)
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
jbe 0x19b59f
movq (%rdi), %r10
movzbl (%r10,%rsi), %ebx
movb $0x0, (%rdx)
testb %bl, %bl
js 0x19b4ac
movl %ebx, %eax
jmp 0x19b58b
testb $0x40, %bl
jne 0x19b4bb... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::is_utf16(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool
QUtil::is_utf16(std::string const& val)
{
return (
(val.length() >= 2) &&
(((val.at(0) == '\xfe') && (val.at(1) == '\xff')) ||
((val.at(0) == '\xff') && (val.at(1) == '\xfe'))));
} | cmpq $0x2, 0x8(%rdi)
jb 0x19bbad
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0xff, %ecx
je 0x19bbb0
cmpl $0xfe, %ecx
jne 0x19bbad
cmpb $-0x1, 0x1(%rax)
je 0x19bbb8
cmpb $-0x1, %cl
je 0x19bbb0
xorl %eax, %eax
retq
cmpb $-0x2, 0x1(%rax)
sete %al
retq
movb $0x1, %al
retq
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::win_ansi_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::win_ansi_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 128) && (ch <= 160)) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x19be29
movq %rsi, %r14
movl $0x1, %r12d
leaq 0x18(%rsp), %rbp
xorl %esi, %esi... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_doc_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::pdf_doc_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 127) && (ch <= 160)) {
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x19c06b
movq %rsi, %r14
movl $0x1, %r12d
leaq 0x18(%rsp), %rbp
xorl %esi, %esi... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::possible_repaired_encodings(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | std::vector<std::string>
QUtil::possible_repaired_encodings(std::string supplied)
{
std::vector<std::string> result;
// Always include the original string
result.push_back(supplied);
bool has_8bit_chars = false;
bool is_valid_utf8 = false;
bool is_utf16 = false;
analyze_encoding(supplied, ha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x6a210
xorl %eax, %eax
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0xe(%rsp), %rdx
movb %al, (%rdx)
leaq 0xd(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
call_main_from_wmain(bool, int, wchar_t const* const*, std::function<int (int, char**)>) | static int
call_main_from_wmain(
bool, int argc, wchar_t const* const argv[], std::function<int(int, char*[])> realmain)
{
// argv contains UTF-16-encoded strings with a 16-bit wchar_t. Convert this to UTF-8-encoded
// strings for compatibility with other systems. That way the rest of qpdf.cc can just act l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x68(%rsp)
movq %rsi, %r14
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testl %edi, %edi
jns 0x19c6f3
movl %ebp, %edi
callq 0x8808a
movslq %ebp, %rsi
leaq 0x20(%rsp), %rdi
callq 0x69290
tes... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_max_memory_usage() | size_t
QUtil::get_max_memory_usage()
{
#if defined(HAVE_MALLOC_INFO) && defined(HAVE_OPEN_MEMSTREAM)
static std::regex tag_re("<(/?\\w+)([^>]*?)>");
static std::regex attr_re("(\\w+)=\"(.*?)\"");
char* buf;
size_t size;
FILE* f = open_memstream(&buf, &size);
if (f == nullptr) {
return 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movb 0xb0d3d(%rip), %al # 0x24d7d0
testb %al, %al
je 0x19d0c4
movb 0xb0d57(%rip), %al # 0x24d7f8
testb %al, %al
je 0x19d11e
leaq 0x58(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x6bfa0
testq %rax, %rax
je... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
read_char_from_FILE(char&, _IO_FILE*) | static bool
read_char_from_FILE(char& ch, FILE* f)
{
auto len = fread(&ch, 1, 1, f);
if (len == 0) {
if (ferror(f)) {
throw std::runtime_error("failure reading character from file");
}
return false;
}
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x1, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x6ad10
movq %rax, %r14
testq %rax, %rax
jne 0x19d594
movq %rbx, %rdi
callq 0x6c1e0
testl %eax, %eax
jne 0x19d5a2
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6a000
movq... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
ResourceFinder::ResourceFinder() | ResourceFinder::ResourceFinder() :
last_name_offset(0)
{
} | leaq 0xa6b65(%rip), %rax # 0x2478e8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq %rax, 0x28(%rdi)
leaq 0x38(%rdi), %rcx
movl %eax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
leaq ... | /jberkenbilt[P]qpdf/libqpdf/ResourceFinder.cc |
ResourceFinder::handleObject(QPDFObjectHandle, unsigned long, unsigned long) | void
ResourceFinder::handleObject(QPDFObjectHandle obj, size_t offset, size_t)
{
if (obj.isOperator() && (!this->last_name.empty())) {
static std::map<std::string, std::string> op_to_rtype = {
{"CS", "/ColorSpace"},
{"cs", "/ColorSpace"},
{"gs", "/ExtGState"},
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x69d40
testb %al, %al
je 0x1a0eda
cmpq $0x0, 0x10(%rbx)
je 0x1a0eda
movb 0xacabe(%rip), %al # 0x24d8c8
testb %al, %al
je 0x1a0f30
leaq 0x28(%rsp), %r15
movq ... | /jberkenbilt[P]qpdf/libqpdf/ResourceFinder.cc |
SecureRandomDataProvider::provideRandomData(unsigned char*, unsigned long) | void
SecureRandomDataProvider::provideRandomData(unsigned char* data, size_t len)
{
# if defined(_WIN32)
// Optimization: make the WindowsCryptProvider static as long as
// it can be done in a thread-safe fashion.
WindowsCryptProvider c;
if (!CryptGenRandom(c.crypt_prov, static_cast<DWORD>(len), reinte... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movb 0xabef2(%rip), %al # 0x24d8d8
testb %al, %al
je 0x1a1a14
movq 0xabedf(%rip), %rax # 0x24d8d0
movq (%rax), %rcx
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6ad10
cmpq %r14, %rax
jne 0x1a1a51
addq $0x68,... | /jberkenbilt[P]qpdf/libqpdf/SecureRandomDataProvider.cc |
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle) | bool
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle decode_parms)
{
if (decode_parms.isNull()) {
return true;
}
auto memory_limit = Pl_Flate::memory_limit();
std::set<std::string> keys = decode_parms.getKeys();
for (auto const& key: keys) {
QPDFObjectHandle value = decode_parms... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6db30
movb $0x1, %bpl
testb %al, %al
jne 0x1a1ee9
callq 0x6da30
movq %rax, (%rsp)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ef90
movq 0x18(%r15), %r12
leaq 0x30... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
SF_FlateLzwDecode::getDecodePipeline(Pipeline*) | Pipeline*
SF_FlateLzwDecode::getDecodePipeline(Pipeline* next)
{
std::shared_ptr<Pipeline> pipeline;
if (predictor >= 10 && predictor <= 15) {
QTC::TC("qpdf", "SF_FlateLzwDecode PNG filter");
pipeline = std::make_shared<Pl_PNGFilter>(
"png decode",
next,
Pl_PN... | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq %rsi, 0x50(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0xc(%rdi), %eax
leal -0xa(%rax), %ecx
cmpl $0x5, %ecx
ja 0x1a202e
movl $0x1, 0xc(%rsp)
movl 0x10(%rbx), %edi
testl %edi, %edi
jns 0x1a1f76
callq 0x895fa
movl 0x10(%rbx), %eax
movl %eax, 0x2c(%rsp)
movl 0x1... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
SF_FlateLzwDecode::flate_factory() | std::shared_ptr<QPDFStreamFilter>
SF_FlateLzwDecode::flate_factory()
{
return std::make_shared<SF_FlateLzwDecode>(false);
} | pushq %rbx
movq %rdi, %rbx
movl $0x48, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xa5881(%rip), %rcx # 0x247ac8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xa572b(%rip), %rdx # 0x247980
movq %rdx, 0x10(%rax)
movb $0x0, 0x18(%rax)
movaps 0x3684c(%rip), %xm... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
qpdf_init | qpdf_data
qpdf_init()
{
QTC::TC("qpdf", "qpdf-c called qpdf_init");
auto qpdf = new _qpdf_data();
qpdf->qpdf = QPDF::create();
return qpdf;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x148, %edi # imm = 0x148
callq 0x68ab0
movq %rax, %rbx
movl $0x148, %edx # imm = 0x148
movq %rax, %rdi
xorl %esi, %esi
callq 0x69950
movq %rbx, %rdi
callq 0x1b10b2
movq %rsp, %r14
movq %r14, %rdi
callq 0x6ea40
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_more_warnings | QPDF_BOOL
qpdf_more_warnings(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_more_warnings");
if (qpdf->warnings.empty()) {
std::vector<QPDFExc> w = qpdf->qpdf->getWarnings();
if (!w.empty()) {
qpdf->warnings.assign(w.begin(), w.end());
}
}
if (qpdf->warnings.e... | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x40(%rdi), %rbx
cmpq %rbx, 0x40(%rdi)
jne 0x1a28bb
movq (%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x683c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
cmpq %rdx, %rsi
je 0x1a28b3
movq %rbx, %rdi
callq 0x69880
movq %rsp, %rdi
callq 0x6f170
xorl %eax, %eax
cmpq %rbx, (%rbx)... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
trap_errors(_qpdf_data*, std::function<void (_qpdf_data*)>) | static QPDF_ERROR_CODE
trap_errors(qpdf_data qpdf, std::function<void(qpdf_data)> fn)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
try {
fn(qpdf);
} catch (QPDFExc& e) {
qpdf->error = std::make_shared<QPDFExc>(e);
status |= QPDF_ERRORS;
} catch (std::runtime_error& e) {
qpdf-... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rdi, 0x30(%rsp)
cmpq $0x0, 0x10(%rsi)
je 0x1a2b03
movq %rsi, %rax
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq *0x18(%rax)
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x69500
orl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_read_memory | QPDF_ERROR_CODE
qpdf_read_memory(
qpdf_data qpdf,
char const* description,
char const* buffer,
unsigned long long size,
char const* password)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = description;
qpdf->buffer = buffer;
qpdf->size = size;
qpdf->password = password... | pushq %rbx
subq $0x20, %rsp
movq %rsi, 0x78(%rdi)
movq %rdx, 0x80(%rdi)
movq %rcx, 0x88(%rdi)
movq %r8, 0x90(%rdi)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq 0x6b(%rip), %rax # 0x1a2fb5
movq %rax, (%rsi)
leaq 0xef6a(%rip), %rax # 0x1b1ebe
movq %rax, 0x18(%rsi)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_user_password | char const*
qpdf_get_user_password(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_get_user_password");
qpdf->tmp_string = qpdf->qpdf->getTrimmedUserPassword();
return qpdf->tmp_string.c_str();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6a780
addq $0x58, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6abd0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1a308a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
movq (%rbx), %rax
a... | /jberkenbilt[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 0x1a3750
movq %rbx, 0x78(%r14)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq 0xc6(%rip), %rax # 0x1a37a6
movq %rax, (%rsi)
leaq 0xe7d4(%rip), %rax # 0x1b1ebe
movq %rax, 0x18(%rsi)
leaq 0xe7d1... | /jberkenbilt[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 0x1a37a5
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x18(%rdi), %rdi
movups %xmm0, 0x10(%rbx)
testq %rdi, %rdi
je 0x1a3770
callq 0x69d60
cmpq $0x0, 0xa0(%rbx)
je 0x1a37a4
xorps %xmm0, %xmm0
movq 0xa8(%rbx), %rdi
movups %xmm0, 0xa0(%rbx)
testq %rdi, %rdi
je 0x1a3795
callq 0x69d60
movb $0... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
call_init_write(_qpdf_data*) | static void
call_init_write(qpdf_data qpdf)
{
qpdf->qpdf_writer = std::make_shared<QPDFWriter>(*(qpdf->qpdf), qpdf->filename);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x78(%rdi), %r8
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x1b15aa
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x18(%rbx), %rdi
movups %xmm0, 0x10(%rbx)
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r2_encryption_parameters_insecure | void
qpdf_set_r2_encryption_parameters_insecure(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_print,
QPDF_BOOL allow_modify,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_annotate)
{
QTC::TC("qpdf", "qpdf-c called qpdf_set_r2_encryption_parameters_ins... | pushq %rax
movq 0x10(%rdi), %rdi
xorl %eax, %eax
testl %ecx, %ecx
setne %al
xorl %r10d, %r10d
testl %r8d, %r8d
setne %r10b
xorl %r11d, %r11d
testl %r9d, %r9d
setne %r11b
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rsp)
setne %cl
movl %ecx, (%rsp)
movl %eax, %ecx
movl %r10d, %r8d
movl %r11d, %r9d
callq 0x6d910
popq %rax
retq
| /jberkenbilt[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... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r6_encryption_parameters2 | void
qpdf_set_r6_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... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_minimum_pdf_version_and_extension | void
qpdf_set_minimum_pdf_version_and_extension(qpdf_data qpdf, char const* version, int extension_level)
{
QTC::TC("qpdf", "qpdf-c called qpdf_set_minimum_pdf_version");
qpdf->qpdf_writer->setMinimumPDFVersion(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 0x6e7c0
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x6d2c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a3cf0
movq 0x20(%rsp), %rsi
in... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_register_progress_reporter | void
qpdf_register_progress_reporter(
qpdf_data qpdf, void (*report_progress)(int percent, void* data), void* data)
{
QTC::TC("qpdf", "qpdf-c registered progress reporter");
qpdf->qpdf_writer->registerProgressReporter(
std::shared_ptr<QPDFWriter::ProgressReporter>(new QPDFWriter::FunctionProgressRep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq 0x10(%rdi), %r14
movl $0x28, %edi
callq 0x68ab0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x10, %edi
callq 0x68ab0
movq %r12, (%rax)
movq %r15, 0x8(%rax)
leaq 0x1... | /jberkenbilt[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
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq 0x6b(%rip), %rax # 0x1a3f3f
movq %rax, (%rsi)
leaq 0xdfe0(%rip), %rax # 0x1b1ebe
movq %rax, 0x18(%rsi)
leaq 0xdfdd(%rip), %rax # 0x1b1ec6
movq %rax, 0x10(%rsi)
callq 0x1a2ac5
movl %eax, %eb... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
new_object(_qpdf_data*, QPDFObjectHandle const&) | static qpdf_oh
new_object(qpdf_data qpdf, QPDFObjectHandle const& qoh)
{
qpdf_oh oh = ++qpdf->next_oh; // never return 0
qpdf->oh_cache[oh] = std::make_shared<QPDFObjectHandle>(qoh);
return oh;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movl 0xe8(%rdi), %eax
incl %eax
movl %eax, 0xe8(%rdi)
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xb(%rsp), %rdx
callq 0x1b1700
addq $0xb8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rdi, (%rsi)
leaq 0x7e6f(%rip), %rax # 0x1abee2
movq %rax, 0x18(%rsi)
leaq 0x7e6c(%rip), %rax # 0x1abeea
movq %rax, 0x10(%rsi)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
leaq 0x8895(%rip), %rax ... | /jberkenbilt[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 0x1b22a0
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movl $0x28, %edi
callq 0... | /jberkenbilt[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 0x68e90
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a44cf
callq 0x69d60
movl %ebx, %eax
addq $0x18, %rsp
pop... | /jberkenbilt[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
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
movl %esi, 0x8(%rax)
movl %edx, 0xc(%rax)
leaq 0x84f3(%rip), %rdx # 0x1aca08
movq %rdx, 0x18(%rax)
leaq 0x8560(%rip), %rdx # 0x1aca80
movq %rdx, 0x10(%rax)
movl %ecx, %esi
movq %rax, ... | /jberkenbilt[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)
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movq %rax, 0x60(%rsp)
leaq 0x7d20(%rip), %rax # 0x1ac2c8
movq %rax, 0x78(%rsp)
leaq 0x7d1a(%rip), %... | /jberkenbilt[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 0x69f40
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x14d072
movl %ebp, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x28, %edi
callq 0x6... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x1e(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa3aa2(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa3b2f(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0xf6(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa39ca(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa3a57(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x37e(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa3742(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa37cf(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x456(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa366a(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa36f7(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_inline_image | QPDF_BOOL
qpdf_oh_is_inline_image(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_inline_image");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isInlineImage(); });
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x606(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa34ba(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa3547(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x6de(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa33e2(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa346f(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x88e(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa3232(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa32bf(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_indirect | QPDF_BOOL
qpdf_oh_is_indirect(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_indirect");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isIndirect(); });
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0x966(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa315a(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa31e7(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_scalar | QPDF_BOOL
qpdf_oh_is_scalar(qpdf_data qpdf, qpdf_oh oh)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_is_scalar");
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [](QPDFObjectHandle& o) { return o.isScalar(); });
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0xa3e(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa3082(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa310f(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_is_number | QPDF_BOOL
qpdf_oh_is_number(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_is_number");
return o.isNumber();
});
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
leaq -0xb16(%rip), %rax # 0x1a503e
movq %rax, (%rdx)
movq 0xa2faa(%rip), %rax # 0x248b08
movq %rax, 0x18(%rdx)
movq 0xa3037(%rip), %rax # 0x248ba0
movq %rax, 0x10(%rdx)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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 0x2cf24(%rip), %r8 # 0x1d2c26
cmovneq %rcx, %r8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
leaq -0xcde(%rip), %rcx # 0x1a503e
movq %rcx, (%rax)
movq 0xa2de2(%rip), %rcx # 0x248b08
movq %rcx, 0x18(%rax)
movq 0xa2e... | /jberkenbilt[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)
xorps %xmm0, %xmm0
leaq 0xf0(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rax, (%rsi)
leaq 0x740c(%rip), %rax # 0x1ad22a
movq %rax, 0x18(%rsi)
leaq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_type_name | char const*
qpdf_oh_get_type_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_type_name");
qpdf->tmp_string = o.getTypeName();
return qpdf->tmp_... | pushq %rbx
subq $0x50, %rsp
leaq 0x2c924(%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 0x730b(%rip), %rax # 0x1ad62e
movq %rax, 0x18(%rdx)
leaq 0x7308(%rip), %rax # 0x1ad636
movq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
char const* do_with_oh<char const*>(_qpdf_data*, unsigned int, std::function<char const* ()>, std::function<char const* (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 0x6dbb0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x1b258e
movl %ebp, 0x68(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x80(%rsp)
movl $0x28, %edi
callq 0x6... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
unsigned int do_with_oh<unsigned int>(_qpdf_data*, unsigned int, std::function<unsigned int ()>, std::function<unsigned 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 $0x70, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
movq %rdx, %rsi
callq 0x6b9a0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1b26c0
movl %ebp, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movl $0x28, %edi
callq 0x68... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_parse | qpdf_oh
qpdf_oh_parse(qpdf_data qpdf, char const* object_str)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_parse");
return trap_oh_errors<qpdf_oh>(qpdf, return_uninitialized(qpdf), [object_str](qpdf_data q) {
return new_object(q, QPDFObjectHandle::parse(object_str));
});
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movq %rdi, (%rax)
leaq 0x547e(%rip), %rcx # 0x1abee2
movq %rcx, 0x18(%rax)
leaq 0x547b(%rip), %rcx # 0x1abeea
movq %rcx, 0x10(%rax)
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
m... | /jberkenbilt[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
leaq 0x128(%rsp), %rax
movq $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rax, (%rsi)
leaq 0x733c(%rip), %rax # 0x1ae052
movq %rax, 0x18(%rsi)
lea... | /jberkenbilt[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)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rax, (%rdx)
leaq 0x718a(%rip), %rax # 0x1ae492
movq %rax, 0x18(%rdx)
leaq 0x7185(%rip), %rax # 0x1ae498
movq %rax, 0x10(%rdx)
leaq 0x10(%rsp), %rcx
mo... | /jberkenbilt[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
leaq 0x128(%rsp), %rax
movq $0x0, (%rax)
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rax, (%rsi)
leaq 0x703a(%rip), %rax # 0x1ae518
movq %rax, 0x18(%rsi)
lea... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_uint_value_as_uint | unsigned int
qpdf_oh_get_uint_value_as_uint(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<unsigned int>(qpdf, oh, return_T<unsigned int>(0U), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_uint_value_as_uint");
return o.getUIntValueAsUInt();
});
} | 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 0x6e88(%rip), %rax # 0x1ae958
movq %rax, 0x18(%rdx)
leaq 0x6e83(%rip), %rax # 0x1ae95e
movq %rax, 0x10(%rdx)
leaq 0x10(%rsp), %rcx
mo... | /jberkenbilt[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
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
leaq -0x3375(%rip), %rcx # 0x1a503e
movq %rcx, (%rax)
movq 0xa074b(%rip), %rcx # 0x248b08
movq %rcx, 0x18(%rax)
movq 0xa07d8(%rip), %rcx # 0x248ba0
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movaps ... | /jberkenbilt[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 0x2a394(%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 0x4d7b(%rip), %rax # 0x1ad62e
movq %rax, 0x18(%rdx)
leaq 0x4d78(%rip), %rax # 0x1ad636
movq ... | /jberkenbilt[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)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rax, (%rdx)
leaq 0x57fd(%rip), %rax # 0x1ae492
movq %rax, 0x18(%rdx)
leaq 0x57f8(%rip), %rax # 0x1ae498
movq %rax, 0x10(%rdx)
leaq 0x10(%rsp), %rcx
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_has_key | QPDF_BOOL
qpdf_oh_has_key(qpdf_data qpdf, qpdf_oh oh, char const* key)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [key](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_has_key");
return o.hasKey(key);
});
} | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
leaq -0x44cc(%rip), %rcx # 0x1a503e
movq %rcx, (%rax)
movq 0x9f5f4(%rip), %rcx # 0x248b08
movq %rcx, 0x18(%rax)
movq 0x9f681(%rip), %rcx # 0x248ba0
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movaps ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_uninitialized | qpdf_oh
qpdf_oh_new_uninitialized(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_uninitialized");
return new_object(qpdf, QPDFObjectHandle());
} | pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x1a3f7f
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9895
callq 0x69d60
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a98af
callq 0x69d60
movq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_integer | qpdf_oh
qpdf_oh_new_integer(qpdf_data qpdf, long long value)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_integer");
return new_object(qpdf, QPDFObjectHandle::newInteger(value));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6a820
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a99a1
callq 0x69d60
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%r... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_new_real_from_string | qpdf_oh
qpdf_oh_new_real_from_string(qpdf_data qpdf, char const* value)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_new_real_from_string");
return new_object(qpdf, QPDFObjectHandle::newReal(value));
} | 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 0x6a3d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a3f7f
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a9a0c
callq 0x69d60
leaq 0x2... | /jberkenbilt[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.