name string | code string | asm string | file string |
|---|---|---|---|
QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(QPDF&) | QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(QPDF& destination_qpdf) :
QPDFObjectHandle::StreamDataProvider(true),
destination_qpdf(destination_qpdf)
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0xbf190
leaq 0x1b1729(%rip), %rax # 0x1ea8c8
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
leaq 0x20(%r14), %rax
xorl %ecx, %ecx
movl %ecx, 0x20(%r14)
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x40(%r1... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::CopiedStreamDataProvider::provideStreamData(QPDFObjGen const&, Pipeline*, bool, bool) | bool
QPDF::CopiedStreamDataProvider::provideStreamData(
QPDFObjGen const& og, Pipeline* pipeline, bool suppress_warnings, bool will_retry)
{
std::shared_ptr<ForeignStreamData> foreign_data = foreign_stream_data[og];
bool result = false;
if (foreign_data.get()) {
result = destination_qpdf.pipeFor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
addq $0x48, %rdi
callq 0x3e30c
movq (%rax), %rcx
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x39222
movq 0x1b6d68(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::pipeForeignStreamData(std::shared_ptr<QPDF::ForeignStreamData>, Pipeline*, bool, bool) | bool
QPDF::pipeForeignStreamData(
std::shared_ptr<ForeignStreamData> foreign,
Pipeline* pipeline,
bool suppress_warnings,
bool will_retry)
{
if (foreign->encp->encrypted) {
QTC::TC("qpdf", "QPDF pipe foreign encrypted stream");
}
return pipeStreamData(
foreign->encp,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rax
movq %rdi, %rdx
movq (%rsi), %rdi
movq (%rdi), %r9
movq %r9, 0x28(%rsp)
movq 0x8(%rdi), %r9
movq %r9, 0x30(%rsp)
testq %r9, %r9
je 0x39386
movq 0x1b6c0e(%rip), %r10 # 0x1eff80
cmpb $0x0, (%r10)
je 0x3937e
incl 0x8(%r9)... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::~QPDF() | QPDF::~QPDF()
{
// If two objects are mutually referential (through each object having an array or dictionary
// that contains an indirect reference to the other), the circular references in the
// std::shared_ptr objects will prevent the objects from being deleted. Walk through all objects
// in the ob... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x138, %edi # imm = 0x138
addq (%rbx), %rdi
callq 0x405d2
movq (%rbx), %r12
movq 0x1c0(%r12), %r14
addq $0x1b0, %r12 # imm = 0x1B0
cmpq %r12, %r14
je 0x39a7d
movq %rsp, %r15
movq 0x1b6550(%rip), %r13 #... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::processFile(char const*, char const*) | void
QPDF::processFile(char const* filename, char const* password)
{
auto* fi = new FileInputSource(filename);
processInputSource(std::shared_ptr<InputSource>(fi), password);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0xd8, %edi
callq 0x19180
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x1f2d8
leaq 0x10(%rsp), %r12
movq %r15, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x406cc
movq (%r14), %rdi
movq -0x8(... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::closeInputSource() | void
QPDF::closeInputSource()
{
m->file = std::shared_ptr<InputSource>(new InvalidInputSource());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x19180
movq %rax, %r14
movl $0xa8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x19330
leaq 0x1b0b07(%rip), %rax # 0x1ea920
movq %rax, (%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3990c
movq (%rbx), %rax
movq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::registerStreamFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<std::shared_ptr<QPDFStreamFilter> ()>) | void
QPDF::registerStreamFilter(
std::string const& filter_name, std::function<std::shared_ptr<QPDFStreamFilter>()> factory)
{
qpdf::Stream::registerStreamFilter(filter_name, factory);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3e55a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfcb76
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x39ebb
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x39ee9... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getLogger() | std::shared_ptr<QPDFLogger>
QPDF::getLogger()
{
return m->log;
} | movq %rdi, %rax
movq (%rsi), %rcx
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x39f2b
movq 0x1b6062(%rip), %rdx # 0x1eff80
cmpb $0x0, (%rdx)
je 0x39f27
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::setOutputStreams(std::ostream*, std::ostream*) | void
QPDF::setOutputStreams(std::ostream* out, std::ostream* err)
{
setLogger(QPDFLogger::create());
m->log->setOutputStreams(out, err);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xb9328
movq (%r15), %rdi
movq (%r12), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x274ee
movq (%r12), %rdi
testq %rdi, %rdi
je ... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getWarnings() | std::vector<QPDFExc>
QPDF::getWarnings()
{
std::vector<QPDFExc> result = m->warnings;
m->warnings.clear();
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x270, %esi # imm = 0x270
addq (%r14), %rsi
callq 0x3e5b8
movq (%r14), %r15
movq 0x270(%r15), %r12
movq 0x278(%r15), %r13
cmpq %r12, %r13
je 0x3a027
movq %r12, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
sub... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::validatePDFVersion(char const*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
QPDF::validatePDFVersion(char const*& p, std::string& version)
{
bool valid = util::is_digit(*p);
if (valid) {
while (util::is_digit(*p)) {
version.append(1, *p++);
}
if ((*p == '.') && util::is_digit(*(p + 1))) {
version.append(1, *p++);
while (u... | pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x3a111
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movsbl (%rax), %r8d
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x19640
movq (%r14), %rax
movb (%rax), %cl
... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::findHeader() | bool
QPDF::findHeader()
{
qpdf_offset_t global_offset = m->file->tell();
std::string line = m->file->readLine(1024);
char const* p = line.c_str();
if (strncmp(p, "%PDF-", 5) != 0) {
throw std::logic_error("findHeader is not looking at %PDF-");
}
p += 5;
std::string version;
// No... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r15
movq (%r14), %rax
movq 0xb0(%rax), %rsi
leaq 0x40(%rsp), %rbx
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::warn(QPDFExc const&) | void
QPDF::warn(QPDFExc const& e)
{
if (m->max_warnings > 0 && m->warnings.size() >= m->max_warnings) {
stopOnError("Too many warnings - file is too badly damaged");
}
m->warnings.push_back(e);
if (!m->suppress_warnings) {
*m->log->getWarn() << "WARNING: " << m->warnings.back().what() <<... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0xf8(%rdi), %rax
testq %rax, %rax
je 0x3a396
movq 0x278(%rdi), %rcx
subq 0x270(%rdi), %rcx
sarq $0x7, %rcx
cmpq %rax, %rcx
jae 0x3a418
addq $0x270, %rdi # imm = 0x270
callq 0x3e68a
movq (%rbx), %rax
cmpb $0x0, 0xf2(%rax)
jne 0x3a41... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::stopOnError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDF::stopOnError(std::string const& message)
{
throw damagedPDF("", message);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x80, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1407f4(%rip), %rdx # 0x17aca6
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1edc8
movb $0x1, %bpl
movq %rsp, %rdx
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::warn(qpdf_error_code_e, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDF::warn(
qpdf_error_code_e error_code,
std::string const& object,
qpdf_offset_t offset,
std::string const& message)
{
warn(QPDFExc(error_code, getFilename(), object, offset, message));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rsi
movq 0x8(%rax), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getFilename[abi:cxx11]() const | std::string
QPDF::getFilename() const
{
return m->file->getName();
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e48a
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newIndirectNull() | QPDFObjectHandle
QPDF::newIndirectNull()
{
return makeIndirectFromQPDFObject(QPDFObject::create<QPDF_Null>());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x70, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1b03fe(%rip), %rcx # 0x1eaaf0
movq %rcx, (%rax)
movb $0x2, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newStream() | QPDFObjectHandle
QPDF::newStream()
{
return makeIndirectObject(
qpdf::Stream(*this, nextObjGen(), QPDFObjectHandle::newDictionary(), 0, 0));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x130034
movq %rax, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xc823a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xfc67c
movq 0x8(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDF::newStream(std::string const& data)
{
auto result = newStream();
result.replaceStreamData(data, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
return result;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x3a75c
leaq 0x18(%rsp), %rdi
callq 0xc6058
leaq 0x8(%rsp), %rdi
callq 0xc6058
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xffc94
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3a990
callq 0x1ed58
movq 0x20(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::copyForeignObject(QPDFObjectHandle) | QPDFObjectHandle
QPDF::copyForeignObject(QPDFObjectHandle foreign)
{
// Here's an explanation of what's going on here.
//
// A QPDFObjectHandle that is an indirect object has an owning QPDF. The object ID and
// generation refers to an object in the owning QPDF. When we copy the QPDFObjectHandle from a
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xc362e
testb %al, %al
je 0x3afb1
leaq 0x118(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x14023f(%rip), %rdx # 0x17aca6
leaq 0x108(%rsp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::reserveObjects(QPDFObjectHandle, QPDF::ObjCopier&, bool) | void
QPDF::reserveObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
{
auto foreign_tc = foreign.getTypeCode();
if (foreign_tc == ::ot_reserved) {
throw std::logic_error("QPDF: attempting to copy a foreign reserved object");
}
if (foreign.isPagesObject()) {
QTC::TC("qpdf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r13d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xc1864
cmpl $0x1, %eax
je 0x3b503
movl %eax, %ebp
movq %r14, %rdi
callq 0xc94d2
testb %al, %al
jne 0x3b4f4
movq %r14, %rdi
callq 0xc362e
testb %al, %... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::replaceForeignIndirectObjects(QPDFObjectHandle, QPDF::ObjCopier&, bool) | QPDFObjectHandle
QPDF::replaceForeignIndirectObjects(QPDFObjectHandle foreign, ObjCopier& obj_copier, bool top)
{
auto foreign_tc = foreign.getTypeCode();
QPDFObjectHandle result;
if ((!top) && foreign.isIndirect()) {
QTC::TC("qpdf", "QPDF replace indirect");
auto mapping = obj_copier.object... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x38(%rsp)
movq %rdi, %r14
movq %rdx, %rdi
callq 0xc1864
movl %eax, %ebx
xorps %xmm0, %xmm0
movq %r14, 0x8(%rsp)
movups %xmm0, (%r14)
testl %ebp, %ebp
jne 0x3b632
movq %r12, %rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::copyStreamData(QPDFObjectHandle, QPDFObjectHandle) | void
QPDF::copyStreamData(QPDFObjectHandle result, QPDFObjectHandle foreign)
{
// This method was originally written for copying foreign streams, but it is used by
// QPDFObjectHandle to copy streams from the same QPDF object as well.
QPDFObjectHandle dict = result.getDict();
QPDFObjectHandle old_dict ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsp), %rdi
callq 0xff332
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
callq 0xff332
movq (%r14), %rax
cmpq $0x0, 0x2c8(%rax)
je 0x3bec7
movq %rbx, %rdi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDFJob::json_out_schema_v1[abi:cxx11]() | std::string
QPDFJob::json_out_schema_v1()
{
return json_schema(1).unparse();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x7fd2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21442
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x80c22
callq 0x1ed58
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSON(QPDF&, Pipeline*) | void
QPDFJob::doJSON(QPDF& pdf, Pipeline* p)
{
// qpdf guarantees that no new top-level keys whose names start with "x-" will be added. These
// are reserved for users.
std::string captured_json;
std::shared_ptr<Pl_String> pl_str;
if (m->test_json_schema) {
pl_str = std::make_shared<Pl_Stri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, 0x28(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rax
cmpb $0x1, 0x318(%rax)
jne 0x80ccd
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doProcessOnce(std::unique_ptr<QPDF, std::default_delete<QPDF>>&, std::function<void (QPDF*, char const*)>, char const*, bool, bool, bool) | void
QPDFJob::doProcessOnce(
std::unique_ptr<QPDF>& pdf,
std::function<void(QPDF*, char const*)> fn,
char const* password,
bool empty,
bool used_for_input,
bool main_input)
{
pdf = std::make_unique<QPDF>();
setQPDFOptions(*pdf);
if (empty) {
pdf->emptyPDF();
} else if (ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r13d
movq %rcx, 0x30(%rsp)
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x19180
movq %rax, %rbp
movq %rax, %rdi
callq 0x39986
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doProcess(std::unique_ptr<QPDF, std::default_delete<QPDF>>&, std::function<void (QPDF*, char const*)>, char const*, bool, bool, bool) | void
QPDFJob::doProcess(
std::unique_ptr<QPDF>& pdf,
std::function<void(QPDF*, char const*)> fn,
char const* password,
bool empty,
bool used_for_input,
bool main_input)
{
// If a password has been specified but doesn't work, try other passwords that are equivalent in
// different charact... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %r9d, %ebp
movl %r8d, %r12d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %rcx, 0x38(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
testq %rcx, %rcx
je 0x8... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
get_afdh_for_qpdf(std::map<unsigned long long, std::shared_ptr<QPDFAcroFormDocumentHelper>, std::less<unsigned long long>, std::allocator<std::pair<unsigned long long const, std::shared_ptr<QPDFAcroFormDocumentHelper>>>>&, QPDF*) | static QPDFAcroFormDocumentHelper*
get_afdh_for_qpdf(
std::map<unsigned long long, std::shared_ptr<QPDFAcroFormDocumentHelper>>& afdh_map, QPDF* q)
{
auto uid = q->getUniqueId();
if (!afdh_map.count(uid)) {
afdh_map[uid] = std::make_shared<QPDFAcroFormDocumentHelper>(*q);
}
return afdh_map[u... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3c9ce
movq %rax, 0x20(%rsp)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x84df3
leaq 0x8(%rbx), %rsi
movq %rsi, %rdx
xorl %edi, %edi
cmpq %rax, 0x20(%rcx)
setb %dil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rdi,8), %rcx
testq %rcx, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::maybeFixWritePassword(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFJob::maybeFixWritePassword(int R, std::string& password)
{
switch (m->password_mode) {
case QPDFJob::pm_bytes:
QTC::TC("qpdf", "QPDFJob password mode bytes");
break;
case QPDFJob::pm_hex_bytes:
QTC::TC("qpdf", "QPDFJob password mode hex-bytes");
password = QUtil::he... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq (%rdi), %rax
movl 0xc4(%rax), %eax
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x84f2e
movl %esi, %ebp
movq %rdi, %r14
leaq 0xf(%rsp), %r15
leaq 0xd(%rsp), %rdx
leaq 0xe(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x144111
cmpb $0x1, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ImageOptimizer::provideStreamData(QPDFObjGen const&, Pipeline*) | void
ImageOptimizer::provideStreamData(QPDFObjGen const&, Pipeline* pipeline)
{
std::shared_ptr<Pipeline> p = makePipeline("", pipeline);
if (p == nullptr) {
// Should not be possible
image.warnIfPossible(
"unable to create pipeline after previous success; image data will be lost");
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf37a3(%rip), %rdx # 0x17aca6
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1edc8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x87646
movq (%rsp), %rdi
cmpq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ImageOptimizer::makePipeline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Pipeline*) | std::shared_ptr<Pipeline>
ImageOptimizer::makePipeline(std::string const& description, Pipeline* next)
{
std::shared_ptr<Pipeline> result;
QPDFObjectHandle dict = image.getDict();
QPDFObjectHandle w_obj = dict.getKey("/Width");
QPDFObjectHandle h_obj = dict.getKey("/Height");
QPDFObjectHandle colors... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x88(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
addq $0x38, %rsi
leaq 0x58(%rsp), %rdi
callq 0xff332
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xde1a1(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ArgParser::argAddAttachment() | void
ArgParser::argAddAttachment()
{
this->c_att = c_main->addAttachment();
this->ap.selectOptionTable(O_ATTACHMENT);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa5640
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x38(%rbx), %rdi
movups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0x962c1
callq 0x1ed58
movq 0x8(%rsp), %rdi
testq %rdi, %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argEndPages() | void
ArgParser::argEndPages()
{
c_pages->endPages();
c_pages = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0xa5cd6
xorps %xmm0, %xmm0
movq 0x48(%rbx), %rdi
movups %xmm0, 0x40(%rbx)
testq %rdi, %rdi
je 0x96843
popq %rbx
jmp 0x1ed58
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argEndEncryption() | void
ArgParser::argEndEncryption()
{
c_enc->endEncrypt();
c_enc = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0xa6a80
xorps %xmm0, %xmm0
movq 0x68(%rbx), %rdi
movups %xmm0, 0x60(%rbx)
testq %rdi, %rdi
je 0x969c7
popq %rbx
jmp 0x1ed58
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argEndAttachment() | void
ArgParser::argEndAttachment()
{
c_att->endAddAttachment();
c_att = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xa59d6
xorps %xmm0, %xmm0
movq 0x38(%rbx), %rdi
movups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0x96f4b
popq %rbx
jmp 0x1ed58
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
QPDFJob::Config::compressStreams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::compressStreams(std::string const& parameter)
{
o.m->compress_streams_set = true;
o.m->compress_streams = (parameter == "y");
return this;
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rcx
movb $0x1, 0x131(%rcx)
leaq 0xcab7e(%rip), %rsi # 0x16e90d
movq %rax, %rdi
callq 0x19a80
testl %eax, %eax
movq (%rbx), %rax
movq (%rax), %rax
sete 0x130(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::decrypt() | QPDFJob::Config*
QPDFJob::Config::decrypt()
{
o.m->decrypt = true;
o.m->encrypt = false;
o.m->copy_encryption = false;
return this;
} | movq %rdi, %rax
movq (%rdi), %rcx
movq (%rcx), %rcx
movb $0x1, 0x59(%rcx)
xorl %edx, %edx
movb %dl, 0xc0(%rcx)
movb %dl, 0x8a(%rcx)
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::flattenAnnotations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::flattenAnnotations(std::string const& parameter)
{
o.m->flatten_annotations = true;
if (parameter == "screen") {
o.m->flatten_annotations_forbidden |= an_no_view;
} else if (parameter == "print") {
o.m->flatten_annotations_required |= an_print;
} else if... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x189(%rax)
leaq 0xc6677(%rip), %rsi # 0x16a55e
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0xa3f5b
leaq 0xcd106(%rip), %rsi # 0x171000
movq %r14, %rdi
callq 0x19a80
testl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::splitPages(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::splitPages(std::string const& parameter)
{
int n = (parameter.empty() ? 1 : QUtil::string_to_int(parameter.c_str()));
o.m->split_pages = n;
return this;
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0xa48d9
movq (%rsi), %rdi
callq 0x13dafa
jmp 0xa48de
movl $0x1, %eax
movq (%rbx), %rcx
movq (%rcx), %rcx
movl %eax, 0x5c(%rcx)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::streamData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::streamData(std::string const& parameter)
{
o.m->stream_data_set = true;
if (parameter == "compress") {
o.m->stream_data_mode = qpdf_s_compress;
} else if (parameter == "preserve") {
o.m->stream_data_mode = qpdf_s_preserve;
} else if (parameter == "uncomp... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x128(%rax)
leaq 0xc80a4(%rip), %rsi # 0x16ccc3
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0xa4c93
leaq 0xc590e(%rip), %rsi # 0x16a540
movq %r14, %rdi
callq 0x19a80
testl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::CopyAttConfig::CopyAttConfig(QPDFJob::Config*) | QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
config(c)
{
} | movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::pages() | std::shared_ptr<QPDFJob::PagesConfig>
QPDFJob::Config::pages()
{
if (!o.m->page_specs.empty()) {
usage("--pages may only be specified one time");
}
return std::shared_ptr<PagesConfig>(new PagesConfig(this));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rax
movq 0x380(%rax), %rcx
cmpq 0x388(%rax), %rcx
je 0xa5c85
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xcf739(%rip), %rsi # 0x17538b
leaq 0xcf758(%rip), %rdx # 0x1753b1
leaq 0x8(... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::encrypt(int, 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::shared_ptr<QPDFJob::EncConfig>
QPDFJob::Config::encrypt(
int keylen, std::string const& user_password, std::string const& owner_password)
{
o.m->keylen = keylen;
if (keylen == 256) {
o.m->use_aes = true;
}
o.m->user_password = user_password;
o.m->owner_password = owner_password;
... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rdi
movl %edx, 0x110(%rdi)
cmpl $0x100, %edx # imm = 0x100
jne 0xa6411
movb $0x1, 0x127(%rdi)
addq $0xd0, %rdi
movq %rcx, %rsi
callq 0x19d20
movq (%r14), %rax
movl $0xf0, %edi
addq (%rax), %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::endEncrypt() | QPDFJob::Config*
QPDFJob::EncConfig::endEncrypt()
{
if (config->o.m->keylen == 0) {
usage("encryption key length is required");
}
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
return this->config;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
cmpl $0x0, 0x110(%rcx)
jne 0xa6ae7
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcea82(%rip), %rsi # 0x175530
leaq 0xcea9c(%rip), %rdx # 0x175551
movq %rsp, %r14
movq %r14, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::EncConfig*
QPDFJob::EncConfig::print(std::string const& parameter)
{
if (config->o.m->keylen == 40) {
config->o.m->r2_print = (parameter == "y");
} else if (parameter == "full") {
config->o.m->r3_print = qpdf_r3p_full;
} else if (parameter == "low") {
config->o.m->r3_print =... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x28, 0x110(%rax)
jne 0xa6bff
leaq 0xc7d2d(%rip), %rsi # 0x16e90d
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax), %rax
sete 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
(anonymous namespace)::Handlers::beginEncrypt(JSON) | void
Handlers::beginEncrypt(JSON j)
{
// This method is only called if the overall JSON structure matches the schema, so we already
// know that keys that are present have the right types.
int key_len = 0;
std::string user_password;
std::string owner_password;
bool user_password_seen = false;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
leaq 0x88(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x68(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movb %al, 0xb(%rsp)
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::error(char const*) | void
QPDFLogger::error(char const* s)
{
getError(false)->writeCStr(s);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xb96be
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x30b46
movq 0x10(%rsp), %rdi
addq $0x18, %rsp
testq %rdi, %rdi
je 0xb9771
popq %rbx
popq %r14
jmp 0x1ed58
popq %rbx
popq %r14
retq
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFMatrix::concat(QPDFMatrix const&) | void
QPDFMatrix::concat(QPDFMatrix const& other)
{
double ap = (this->a * other.a) + (this->c * other.b);
double bp = (this->b * other.a) + (this->d * other.b);
double cp = (this->a * other.c) + (this->c * other.d);
double dp = (this->b * other.c) + (this->d * other.d);
double ep = (this->a * other.... | movupd (%rsi), %xmm3
movupd 0x8(%rsi), %xmm4
movupd 0x10(%rsi), %xmm0
movupd 0x18(%rsi), %xmm2
movupd 0x20(%rsi), %xmm1
movsd 0x28(%rsi), %xmm5
unpcklpd %xmm5, %xmm5 # xmm5 = xmm5[0,0]
movupd (%rdi), %xmm6
movupd 0x10(%rdi), %xmm7
movupd 0x20(%rdi), %xmm8
mulpd %xmm7, %xmm5
unpcklpd %xmm1, %xmm1 #... | /jberkenbilt[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFNameTreeObjectHelper::last() const | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::last() const
{
return {std::make_shared<NNTreeIterator>(m->impl->last())};
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2d99e
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rcx
callq 0xbc344
leaq 0x12fd16(%rip), %rax # 0x1eb5b0
movq %rax, (%rbx)... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFObjectHandle::writeJSON(int, JSON::Writer&, bool) const | void
QPDFObjectHandle::writeJSON(int json_version, JSON::Writer& p, bool dereference_indirect) const
{
if (!dereference_indirect && isIndirect()) {
p << "\"" << getObjGen().unparse(' ') << " R\"";
} else if (!obj) {
throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHand... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testl %ecx, %ecx
je 0xc1526
testq %rax, %rax
jne 0xc1558
jmp 0xc15cc
testq %rax, %rax
je 0xc15cc
cmpl $0x0, 0x50(%rax)
je 0xc1558
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0xa54b8(%rip), %rsi # 0x1669fa
movl $0x1, %edx
callq *0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getResourceNames[abi:cxx11]() const | std::set<std::string>
QPDFObjectHandle::getResourceNames() const
{
// Return second-level dictionary keys
std::set<std::string> result;
for (auto const& item: as_dictionary(strict)) {
for (auto const& [key2, val2]: item.second.as_dictionary(strict)) {
if (!val2.null()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xc43ea
movq %rsi, %r14
movzbl 0x30(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::coalesceContentStreams() | void
QPDFObjectHandle::coalesceContentStreams()
{
QPDFObjectHandle contents = this->getKey("/Contents");
if (contents.isStream()) {
QTC::TC("qpdf", "QPDFObjectHandle coalesce called on stream");
return;
} else if (!contents.isArray()) {
// /Contents is optional for pages, and some ve... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa16f0(%rip), %rsi # 0x167226
leaq 0xa16f2(%rip), %rdx # 0x16722f
movq %rsp, %rdi
callq 0x1edc8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0xfbad6
movq (%rs... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::pipePageContents(Pipeline*) | void
QPDFObjectHandle::pipePageContents(Pipeline* p)
{
std::string description = "page object " + getObjGen().unparse(' ');
std::string all_description;
this->getKey("/Contents").pipeContentStreams(p, description, all_description);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0xc663b
movq 0x50(%rax), %rax
jmp 0xc663d
xorl %eax, %eax
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %r15
movq %r15, %rdi
movl $0x20, %edx
callq 0x3e75e
leaq 0xb32e5(%rip... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parseContentStream(QPDFObjectHandle, QPDFObjectHandle::ParserCallbacks*) | void
QPDFObjectHandle::parseContentStream(QPDFObjectHandle stream_or_array, ParserCallbacks* callbacks)
{
stream_or_array.parseContentStream_internal("content stream objects", callbacks);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xb1a43(%rip), %rsi # 0x178d65
leaq 0xb1a52(%rip), %rdx # 0x178d7b
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1edc8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::addContentTokenFilter(std::shared_ptr<QPDFObjectHandle::TokenFilter>) | void
QPDFObjectHandle::addContentTokenFilter(std::shared_ptr<TokenFilter> filter)
{
coalesceContentStreams();
this->getKey("/Contents").addTokenFilter(filter);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc5b16
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x9f7eb(%rip), %rsi # 0x167226
leaq 0x9f7ed(%rip), %rdx # 0x16722f
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1edc8
leaq 0x18(%rsp), %rdi
movq %r14, %rs... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newBool(bool) | QPDFObjectHandle
QPDFObjectHandle::newBool(bool value)
{
return {QPDFObject::create<QPDF_Bool>(value)};
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x70, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x122e50(%rip), %rcx # 0x1eaaf0
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movb %bl, 0x10(%rax)
movb $0x3, 0x40(%rax)
xorps %xmm0, %xmm0
movups %x... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::makeDirect(QPDFObjGen::set&, bool) | void
QPDFObjectHandle::makeDirect(QPDFObjGen::set& visited, bool stop_at_streams)
{
assertInitialized();
auto cur_og = getObjGen();
if (!visited.add(cur_og)) {
QTC::TC("qpdf", "QPDFObjectHandle makeDirect loop");
throw std::runtime_error("loop detected while converting object from indirect ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
callq 0xc8aca
movq (%r15), %rax
testq %rax, %rax
je 0xc8642
movq 0x50(%rax), %r14
jmp 0xc8645
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fd9a
testb %al, %al
je 0xc89c1
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isFormXObject() const | bool
QPDFObjectHandle::isFormXObject() const
{
return isStreamOfType("", "/Form");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb16c6(%rip), %rdx # 0x17aca6
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x1edc8
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x97e63(%rip), %rsi # 0x161460
leaq 0x97e61(%rip), %rdx # 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFArrayItems::iterator::updateIValue() | void
QPDFObjectHandle::QPDFArrayItems::iterator::updateIValue()
{
m->is_end = (m->item_number >= m->oh.getArrayNItems());
if (m->is_end) {
this->ivalue = QPDFObjectHandle();
} else {
this->ivalue = m->oh.getArrayItem(m->item_number);
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0x8(%rax), %ebp
movq (%rax), %rdi
callq 0xf9190
movq 0x8(%rbx), %rcx
cmpl %eax, %ebp
setge 0xc(%rcx)
jl 0xc9ce3
xorps %xmm0, %xmm0
movq 0x20(%rbx), %rdi
movups %xmm0, 0x18(%rbx)
testq %rdi, %rdi
je 0xc9d20
addq $0x10, %rsp
popq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
std::shared_ptr<QPDFObject> QPDFObject::create<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline std::shared_ptr<QPDFObject>
QPDFObject::create(Args&&... args)
{
return std::make_shared<QPDFObject>(std::forward<T>(T(std::forward<Args>(args)...)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x1e48a
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rax
cmpq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
JSON::Writer::writeNext() | Writer&
writeNext()
{
auto n = indent;
if (first) {
first = false;
write(&spaces[1], n % n_spaces + 1);
} else {
write(&spaces[0], n % n_spaces + 2);
}
while (n >= n_spaces) {
write(&spaces[2], n_spaces);
n -= n_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
cmpb $0x1, 0x8(%rdi)
jne 0xcaa4c
movb $0x0, 0x8(%rbx)
leaq 0xae5ea(%rip), %rsi # 0x17902f
movl $0x1, %ecx
jmp 0xcaa58
leaq 0xae5db(%rip), %rsi # 0x17902e
movl $0x2, %ecx
movq %r15, %rax
shrq %rax
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0x... | /jberkenbilt[P]qpdf/libqpdf/qpdf/JSON_writer.hh |
QPDFObjectHandle::as_dictionary(qpdf::typed) const | inline qpdf::Dictionary
QPDFObjectHandle::as_dictionary(qpdf::typed options) const
{
if (options & qpdf::any_flag || type_code() == ::ot_dictionary ||
(options & qpdf::optional && type_code() == ::ot_null)) {
return qpdf::Dictionary(obj);
}
if (options & qpdf::error) {
assertType("di... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %bpl
jne 0xcae36
movq (%r14), %rdi
testq %rdi, %rdi
je 0xcadf9
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0xcadea
cmpl $0xd, %eax
jne 0xcadf5
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12afa6
jmp 0xcade... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFPageDocumentHelper::removePage(QPDFPageObjectHelper) | void
QPDFPageDocumentHelper::removePage(QPDFPageObjectHelper page)
{
this->qpdf.removePage(page.getObjectHandle());
} | pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rax
movq %rax, (%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xd0de8
movq 0x11f1a6(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xd0de4
incl 0x8(%rax)
jmp 0xd0de8
lock
incl 0x8(%rax)
movq %rsp, %rsi
callq 0x13bbb0
movq 0x8(%rsp)... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageObjectHelper::getMediaBox(bool) | QPDFObjectHandle
QPDFPageObjectHelper::getMediaBox(bool copy_if_shared)
{
return getAttribute("/MediaBox", copy_if_shared);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa5333(%rip), %rsi # 0x179520
leaq 0xa5335(%rip), %rdx # 0x179529
movq %rsp, %r15
movq %r15, %rdi
callq 0x1edc8
movq %rbx, %rdi
movq %r14, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::removeUnreferencedResourcesHelper(QPDFPageObjectHelper, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_trai... | bool
QPDFPageObjectHelper::removeUnreferencedResourcesHelper(
QPDFPageObjectHelper ph, std::set<std::string>& unresolved)
{
bool is_page = (!ph.oh().isFormXObject());
if (!is_page) {
QTC::TC("qpdf", "QPDFPageObjectHelper filter form xobject");
}
ResourceFinder rf;
try {
auto q =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, 0x58(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, 0x138(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x140(%rsp)
testq %rax, %rax
je 0xd608b
movq 0x119f03(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::placeFormXObject(QPDFObjectHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::Rectangle, QPDFMatrix&, bool, bool, bool) | std::string
QPDFPageObjectHelper::placeFormXObject(
QPDFObjectHandle fo,
std::string const& name,
QPDFObjectHandle::Rectangle rect,
QPDFMatrix& cm,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
cm = getMatrixForFormXObjectPlacement(
fo, rect, invert_transfo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movb 0x138(%rsp), %al
movb 0x130(%rsp), %dil
leaq 0x110(%rsp), %rcx
movq (%rdx), %r8
movq %r8, 0x20(%rsp)
movq 0x8(%rdx), %rdx
movq %rdx, 0x28(%rsp)
testq %rdx, %rdx
je 0xd81d4
movq 0x117dbb(%rip), %r8... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::copyAnnotations(QPDFPageObjectHelper, QPDFMatrix const&, QPDFAcroFormDocumentHelper*, QPDFAcroFormDocumentHelper*) | void
QPDFPageObjectHelper::copyAnnotations(
QPDFPageObjectHelper from_page,
QPDFMatrix const& cm,
QPDFAcroFormDocumentHelper* afdh,
QPDFAcroFormDocumentHelper* from_afdh)
{
auto old_annots = from_page.getObjectHandle().getKey("/Annots");
if (!old_annots.isArray()) {
return;
}
QP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r8, 0x28(%rsp)
movq %rcx, %r12
movq %rdx, 0xe8(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xd978d
movq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFParser::parse(bool&, bool) | QPDFObjectHandle
QPDFParser::parse(bool& empty, bool content_stream)
{
// This method must take care not to resolve any objects. Don't check the type of any object
// without first ensuring that it is a direct object. Otherwise, doing so may have the side
// effect of reading the object and changing the fil... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0xdc7e5
movl $0x1, %esi
callq 0x125d08
movb $0x0, (%r15)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
QPDFObjectHandle QPDFParser::withDescription<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | QPDFObjectHandle
QPDFParser::withDescription(Args&&... args)
{
auto obj = QPDFObject::create<T>(std::forward<Args>(args)...);
obj->setDescription(context, description, start);
return {obj};
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xca246
movq (%r15), %r15
movq 0x20(%r14), %rax
movq 0x78(%r14), %r12
movq %rax, 0x48(%r15)
movq 0x28(%r14), %rax
movq %rax, 0x38(%r15)
leaq 0x40(%r15), %rdi
addq $0x30... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFParser::addScalar(Args&&... args)
{
if (bad_count && (frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
}
auto obj = QPDFObject... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
je 0xdffc9
movq 0x60(%rbx), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq $0x13880, %rcx # imm = 0x13880
ja 0xdffc0
cmpq $0x1389, 0x40(%rax) # imm = 0x1389
jb 0xdffc9
movl $0x0, 0x6c(%rbx)
jmp 0xe0028
leaq... | /jberkenbilt[P]qpdf/libqpdf/QPDFParser.cc |
qpdf::Tokenizer::inName(char) | void
Tokenizer::inName(char ch)
{
if (isDelimiter(ch)) {
// A C-locale whitespace character or delimiter terminates token. It is important to unread
// the whitespace character even though it is ignored since it may be the newline after a
// stream keyword. Removing it here could make the ... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0xe12ee
testb %al, %al
je 0xe18a1
movzbl 0x80(%rbx), %eax
xorl $0x1, %eax
shll $0x3, %eax
movl %eax, 0x8(%rbx)
movb $0x0, 0x71(%rbx)
movb %bpl, 0x72(%rbx)
movl $0x15, (%rbx)
jmp 0xe18b7
cmpb $0x23, %bpl
jne 0xe18be
movl $0x0, 0x88(%rbx)
movl $0x12, ... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::findEI(InputSource&) | void
Tokenizer::findEI(InputSource& input)
{
qpdf_offset_t last_offset = input.getLastOffset();
qpdf_offset_t pos = input.tell();
// Use QPDFWordTokenFinder to find EI surrounded by delimiters. Then read the next several
// tokens or up to EOF. If we find any suspicious-looking or tokens, this is proba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq %rdi, 0x48(%rsp)
movq %rsi, %rdi
callq 0x2017e
movq %rax, 0x40(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %r15
movq $0x0, (%rsp)
leaq 0x7... | /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
(anonymous namespace)::QPDFWordTokenFinder::~QPDFWordTokenFinder() | ~QPDFWordTokenFinder() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x10b381(%rip), %rax # 0x1ee160
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0xe2dfa
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
| /jberkenbilt[P]qpdf/libqpdf/QPDFTokenizer.cc |
QPDFWriter::setOutputMemory() | void
QPDFWriter::setOutputMemory()
{
m->filename = "memory buffer";
m->buffer_pipeline = new Pl_Buffer("qpdf output");
m->to_delete.push_back(std::shared_ptr<Pipeline>(m->buffer_pipeline));
initializePipelineStack(m->buffer_pipeline);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x968fe(%rip), %rcx # 0x17a484
movq %rcx, 0x10(%rax)
movl $0x38, %edi
callq 0x19180
movq %rax, %r14
leaq 0x968da(%rip), %rsi # 0x17a478
movq %rax, %rdi
xorl %edx, %edx
callq 0x32890
movq (%rbx), %r15
movq %r14, 0x28(%r15)
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setExtraHeaderText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFWriter::setExtraHeaderText(std::string const& text)
{
m->extra_header_text = text;
if ((m->extra_header_text.length() > 0) && (*(m->extra_header_text.rbegin()) != '\n')) {
QTC::TC("qpdf", "QPDFWriter extra header text add newline");
m->extra_header_text += "\n";
} else {
QTC... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x168, %r14d # imm = 0x168
movq (%rdi), %rdi
addq %r14, %rdi
callq 0x19d20
movq (%rbx), %rdi
movq 0x170(%rdi), %rax
testq %rax, %rax
je 0xe426a
addq %r14, %rdi
movq (%rdi), %rcx
cmpb $0xa, -0x1(%rcx,%rax)
jne 0xe4272
addq $0x8, %rsp
popq %rbx
popq %r14
re... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::bytesNeeded(long long) | unsigned int
QPDFWriter::bytesNeeded(long long n)
{
unsigned int bytes = 0;
while (n) {
++bytes;
n >>= 8;
}
return bytes;
} | xorl %eax, %eax
testq %rsi, %rsi
je 0xe7850
movq %rsi, %rcx
incl %eax
sarq $0x8, %rcx
cmpq $0xff, %rsi
movq %rcx, %rsi
ja 0xe783e
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getTrimmedTrailer() | QPDFObjectHandle
QPDFWriter::getTrimmedTrailer()
{
// Remove keys from the trailer that necessarily have to be replaced when writing the file.
QPDFObjectHandle trailer = m->pdf.getTrailer().unsafeShallowCopy();
// Remove encryption keys
trailer.removeKey("/ID");
trailer.removeKey("/Encrypt");
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3d364
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc859e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xec4cd
callq 0x1ed58
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8dfce(%rip)... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::initializeTables(unsigned long) | void
QPDFWriter::initializeTables(size_t extra)
{
auto size = QIntC::to_size(QPDF::Writer::tableSize(m->pdf) + 100) + extra;
m->obj.resize(size);
m->new_obj.resize(size);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x13088c
addq %rax, %rbx
addq $0x64, %rbx
movl $0x1f0, %edi # imm = 0x1F0
addq (%r14), %rdi
movq %rbx, %rsi
callq 0xf5902
movl $0x248, %edi # imm = 0x248
addq (%r14), %rdi
movq %rbx, %rsi
add... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeXRefTable(QPDFWriter::trailer_e, int, int, int, long long, bool, int, long long, long long, int) | qpdf_offset_t
QPDFWriter::writeXRefTable(
trailer_e which,
int first,
int last,
int size,
qpdf_offset_t prev,
bool suppress_offsets,
int hint_id,
qpdf_offset_t hint_offset,
qpdf_offset_t hint_length,
int linearization_pass)
{
writeString("xref\n");
writeString(std::to_str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x40(%rsp)
movl %r8d, 0x34(%rsp)
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, 0x30(%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movq 0x1c8(%rax), %rdi
leaq 0x87dfa(%rip), %rsi # 0x17aefb
movl $0x5, %edx
callq 0xf55e8
movl %ebp, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFXRefEntry::QPDFXRefEntry(int, long long, int) | QPDFXRefEntry::QPDFXRefEntry(int type, qpdf_offset_t field1, int field2) :
type(type),
field1(field1),
field2(field2)
{
if ((type < 1) || (type > 2)) {
throw std::logic_error("invalid xref type " + std::to_string(type));
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %r14d
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
movl %ecx, 0x10(%rdi)
leal -0x3(%r14), %eax
cmpl $-0x3, %eax
jbe 0xf8042
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
movq %rsp, %rdi
movl %r14d, %esi
callq 0x3... | /jberkenbilt[P]qpdf/libqpdf/QPDFXRefEntry.cc |
QPDFObject::setChildDescription(QPDF*, std::shared_ptr<QPDFObject>, std::basic_string_view<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void
setChildDescription(
QPDF* a_qpdf,
std::shared_ptr<QPDFObject> parent,
std::string_view const& static_descr,
std::string var_descr)
{
object_description =
std::make_shared<Description>(ChildDescr(parent, static_descr, var_descr));
qpdf = a_qpdf;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq %rax, (%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xfaace
movq 0xf54c0(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xfaaca
incl 0x8(%rax)
jmp 0xfaace
lock
incl... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
qpdf::BaseDictionary::hasKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
BaseDictionary::hasKey(std::string const& key) const
{
auto d = dict();
return d->items.count(key) > 0 && !d->items[key].isNull();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xfb62c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe072c
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0xfb6c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xca762
movq %rax, %rdi
callq 0xc1978
xorb $0x1, %al
jmp 0xfb6c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
po... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.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 0x27116
movb $0x1, %bpl
movq %r12, %rdi
xorl %esi, %esi
callq 0xbf190
leaq 0xee53e... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
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 0xed9d7(%rip), %rcx # 0x1ee878
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xeda19(%rip), %rdx # 0x1ee8c8
movq %rdx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
mov... | /jberkenbilt[P]qpdf/libqpdf/qpdf/SF_ASCIIHexDecode.hh |
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 0x19b70
leaq 0x80(%rsp), %rdi
movl $0x20, %edx
movl $0x8, %ecx
movq %r15, %rsi
callq 0x19b70
movq 0x8(%r14), %rax
cmpq $0x7f, %rax
movl $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
check_user_password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_user_password(std::string const& user_password, QPDF::EncryptionData const& data)
{
if (data.getV() < 5) {
return check_user_password_V4(user_password, data);
} else {
return check_user_password_V5(user_password, data);
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
cmpl $0x4, (%rbx)
jg 0x10787c
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x10974f
xorl %edx, %edx
cmpl $0x3, 0x4(%rbx)
setl %dl
shll $0x4, %edx
addq $0x10, %rdx
movq 0x30(%rbx), %rdi
movq (%r14), %rbx
movq %rbx, %rsi
callq 0x19... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
iterate_rc4(unsigned char*, unsigned long, unsigned char*, int, int, bool) | static void
iterate_rc4(
unsigned char* data,
size_t data_len,
unsigned char* okey,
int key_len,
int iterations,
bool reverse)
{
auto key_ph = std::make_unique<unsigned char[]>(QIntC::to_size(key_len));
unsigned char* key = key_ph.get();
for (int i = 0; i < iterations; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, %r14d
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
testl %ecx, %ecx
jns 0x10afee
movl %ebx, %edi
callq 0x32732
movl %ebx, 0xc(%rsp)
movslq %ebx, %r15
movq %r15, %rdi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::JSONReactor::containerStart() | void
QPDF::JSONReactor::containerStart()
{
if (next_obj) {
stack.emplace_back(next_state, std::move(next_obj));
next_obj = QPDFObjectHandle();
} else {
stack.emplace_back(next_state);
}
} | pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
leaq 0x90(%rbx), %rsi
cmpq $0x0, 0x80(%rbx)
je 0x10cef1
leaq 0x80(%rbx), %rdx
callq 0x1106c6
xorps %xmm0, %xmm0
movq 0x88(%rbx), %rdi
movups %xmm0, 0x80(%rbx)
testq %rdi, %rdi
je 0x10cef7
popq %rbx
jmp 0x1ed58
popq %rbx
jmp 0x11072a
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::makeObject(JSON const&) | QPDFObjectHandle
QPDF::JSONReactor::makeObject(JSON const& value)
{
QPDFObjectHandle result;
std::string str_v;
bool bool_v = false;
if (value.isDictionary()) {
result = QPDFObjectHandle::newDictionary();
next_obj = result;
next_state = st_object;
} else if (value.isArray()) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x68(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
xorl %eax, %eax
movb %al, (%r13)
movb %al, 0xf(%rsp)
movq %rdx, %rdi
callq 0x21cdc... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
is_pdf_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool
is_pdf_name(std::string const& v)
{
return ((v.length() > 3) && (v.substr(0, 3) == "n:/"));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x4, 0x8(%rdi)
jb 0x10f1b0
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movl $0x3, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x19b70
leaq 0x6df71(%rip), %rsi # 0x17d0f8
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
sete %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::writeJSON(int, Pipeline*, bool, bool&, qpdf_stream_decode_level_e, qpdf_json_stream_data_e, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std... | void
QPDF::writeJSON(
int version,
Pipeline* p,
bool complete,
bool& first_key,
qpdf_stream_decode_level_e decode_level,
qpdf_json_stream_data_e json_stream_data,
std::string const& file_prefix,
std::set<std::string> wanted_objects)
{
if (version != 2) {
throw std::runtime_er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, 0x6c(%rsp)
cmpl $0x2, %esi
jne 0x11038f
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r13
movq %rdx, 0x28(%rsp)
movb $0x1, 0x30(%rsp)
movq $0x8, 0x38(%rsp)
testb %bpl, %bpl
je 0x10fc25
leaq 0x6d453(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
void load_vector_int<QPDF::HPageOffsetEntry, int>(BitStream&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int, int QPDF::HPageOffsetEntry::*) | static void
load_vector_int(
BitStream& bit_stream, int nitems, std::vector<T>& vec, int bits_wanted, int_type T::* field)
{
bool append = vec.empty();
// nitems times, read bits_wanted from the given bit stream, storing results in the ith vector
// entry.
for (size_t i = 0; i < QIntC::to_size(nite... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, (%rsp)
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rsp)
movslq %esi, %rbx
movslq %ecx, %rax
movq %rax, 0x8(%rsp)
xorl %r13d, %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::getUncompressedObject(QPDFObjectHandle&, QPDFWriter::ObjTable const&) | QPDFObjectHandle
QPDF::getUncompressedObject(QPDFObjectHandle& oh, QPDFWriter::ObjTable const& obj)
{
if (obj.contains(oh)) {
if (auto id = obj[oh].object_stream; id > 0) {
return oh.isNull() ? oh : getObject(id, 0);
}
}
return oh;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x118b9d
movq 0xd73f1(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x118b99
in... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::calculateHSharedObject(QPDFWriter::NewObjTable const&, QPDFWriter::ObjTable const&) | void
QPDF::calculateHSharedObject(
QPDFWriter::NewObjTable const& new_obj, QPDFWriter::ObjTable const& obj)
{
CHSharedObject& cso = m->c_shared_object_data;
std::vector<CHSharedObjectEntry>& csoe = cso.entries;
HSharedObject& so = m->shared_object_hints;
std::vector<HSharedObjectEntry>& soe = so.ent... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %r15
movq 0x3e8(%r15), %rax
cmpq %rax, 0x3f0(%r15)
je 0x11a6f5
movq %rax, 0x3f0(%r15)
movq 0x480(%r15), %rax
cmpq %rax, 0x488(%r15)
je 0x11aa3b
leaq 0x3e8(%r15... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::writeHSharedObject(BitWriter&) | void
QPDF::writeHSharedObject(BitWriter& w)
{
HSharedObject& t = m->shared_object_hints;
w.writeBitsInt(t.first_shared_obj, 32); // 1
w.writeBits(toULL(t.first_shared_offset), 32); // 2
w.writeBitsInt(t.nshared_first_page, 32); // 3
w.writeBitsInt(t.nshared_total, 32); // ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq (%rdi), %r15
movl 0x3c0(%r15), %esi
movl $0x20, %edx
movq %r14, %rdi
callq 0x1dad6
movq 0x3c8(%r15), %rsi
testq %rsi, %rsi
jns 0x11b0c0
movq %rsi, %rdi
callq 0xf7ae2
movq 0x3c8(%r15), %rsi
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
ObjTable<QPDFWriter::NewObject>::element(unsigned long) const | inline T const&
element(size_t idx) const
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < std::vector<T>::size()) {
return std::vector<T>::operator[](idx);
}
if (idx < max_size) {
return sparse_elements.at(idx);
}
thr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
movb 0xceefb(%rip), %al # 0x1f1418
testb %al, %al
je 0x122561
movq (%rsp), %rcx
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rcx
jae 0x122541
shlq $0x5, %rcx
addq %rcx, %rax
jmp 0x122559
cmpq 0xceec8(%rip), %rc... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.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 0x125dc7
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 ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::read_xrefStream(long long) | qpdf_offset_t
QPDF::read_xrefStream(qpdf_offset_t xref_offset)
{
if (!m->ignore_xref_streams) {
QPDFObjGen x_og;
QPDFObjectHandle xref_obj;
try {
xref_obj =
readObjectAtOffset(false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og, true);
} catch (QPDFE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x0, 0xf1(%rax)
jne 0x127796
movq $0x0, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x536a5(%rip), %rsi # 0x17ad02
l... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::insertFreeXrefEntry(QPDFObjGen) | void
QPDF::insertFreeXrefEntry(QPDFObjGen og)
{
if (!m->xref_table.count(og)) {
m->deleted_objects.insert(og.getObj());
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq (%rdi), %r14
leaq 0x138(%r14), %rdi
movq %rax, %rsi
callq 0x122224
addq $0x140, %r14 # imm = 0x140
cmpq %r14, %rax
jne 0x128160
movl $0x178, %edi # imm = 0x178
addq (%rbx), %rdi
movl 0x8(%rsp), %eax
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getObjectCount() | size_t
QPDF::getObjectCount()
{
// This method returns the next available indirect object number. makeIndirectObject uses it for
// this purpose. After fixDanglingReferences is called, all objects in the xref table will also
// be in obj_cache.
fixDanglingReferences();
QPDFObjGen og;
if (!m->obj... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x12b8fc
movq (%r14), %rdi
cmpq $0x0, 0x1d0(%rdi)
je 0x12b962
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x19520
movq 0x20(%rax), %rbx
testl %ebx, %ebx
jns 0x12b962
movl %ebx, %edi
callq 0x32732
movslq %ebx, %rax
addq $0x8, %rs... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.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.