name string | code string | asm string | file string |
|---|---|---|---|
Pl_RC4::write(unsigned char const*, unsigned long) | void
Pl_RC4::write(unsigned char const* data, size_t len)
{
if (this->outbuf == nullptr) {
throw std::logic_error(this->identifier + ": Pl_RC4: write() called after finish() called");
}
size_t bytes_left = len;
unsigned char const* p = data;
while (bytes_left > 0) {
size_t bytes = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0x8cfae
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8cf9f
movq %rsi, %r15
leaq 0x48(%r14), %r12
movq 0x30(%r14), %rcx
movq 0x40(%r14), %r13
cmpq %r13, %rbx
cmovbq %rbx, %r13
movq %r12, %rdi
movq %r15, %... | /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RC4::~Pl_RC4() | ~Pl_RC4() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x8d06c
callq 0x69d60
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8d07a
callq 0x69d60
movq 0x1bba2f(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x8d0a1
movq (%rbx), %rsi
incq %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_RC4.hh |
Pl_RunLength::encode(unsigned char const*, unsigned long) | void
Pl_RunLength::encode(unsigned char const* data, size_t len)
{
for (size_t i = 0; i < len; ++i) {
if ((m->state == st_top) != (m->length <= 1)) {
throw std::logic_error("Pl_RunLength::encode: state/length inconsistency");
}
unsigned char ch = data[i];
if ((m->length >... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x8d32c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movl 0x4(%rax), %edx
movl 0x88(%rax), %ecx
testl %edx, %edx
sete %sil
cmpl $0x2, %ecx
setae %dil
xorb %sil, %dil
je 0x8d335
movb (%r14,%r12), %bpl
te... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::flush_encode() | void
Pl_RunLength::flush_encode()
{
if (m->length == 128) {
QTC::TC(
"libtests",
"Pl_RunLength flush full buffer",
(m->state == st_copying ? 0
: m->state == st_run ? 1
: -1));
}
if (m->length == 0) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
movl 0x88(%rcx), %eax
cmpl $0x2, 0x4(%rcx)
jne 0x8d524
leal -0x81(%rax), %ecx
cmpl $-0x80, %ecx
jbe 0x8d56f
movb $0x1, %cl
subb %al, %cl
leaq 0x7(%rsp), %rsi
movb %cl, (%rsi)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::finish() | void
Pl_RunLength::finish()
{
// When decoding, we might have read a length byte not followed by data, which means the stream
// was terminated early, but we will just ignore this case since this is the only sensible thing
// to do.
if (m->action == a_encode) {
flush_encode();
unsigned c... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
cmpl $0x0, (%rsi)
je 0x8d5eb
movq 0x1bfd8d(%rip), %rax # 0x24d358
testq %rax, %rax
je 0x8d5d9
cmpq %rax, 0x98(%rsi)
ja 0x8d61c
movq 0x28(%rbx), %rdi
addq $0x90, %rsi
callq 0x6c620
jmp 0x8d60a
movq %rbx, %rdi
callq 0x8d4d2
leaq 0x7(%rsp), %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_SHA2::Pl_SHA2(int, Pipeline*) | Pl_SHA2::Pl_SHA2(int bits, Pipeline* next) :
Pipeline("sha2", next),
in_progress(false)
{
if (bits) {
resetBits(bits);
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x129de2(%rip), %rsi # 0x1b748a
callq 0x6db00
leaq 0x1b5bfc(%rip), %rax # 0x2432b0
movq %rax, (%rbx)
movb $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
testl %ebp, %ebp
je 0x8d6d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8d6f6
pop... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::resetBits(int) | void
Pl_SHA2::resetBits(int bits)
{
if (this->in_progress) {
throw std::logic_error("bit reset requested for in-progress SHA2 Pipeline");
}
this->crypto = QPDFCryptoProvider::getImpl();
this->crypto->SHA2_init(bits);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x30(%rdi)
je 0x8d758
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x6c510
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x40(%r14), %rdi
movups %xmm0, 0x38(%r14)
testq %rdi, %rdi
je 0x8d733
callq 0x69d60
movq 0x8(... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::finish() | void
Pl_SHA2::finish()
{
if (next()) {
next()->finish();
}
this->crypto->SHA2_finalize();
this->in_progress = false;
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x8d83d
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movb $0x0, 0x30(%rbx)
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::getHexDigest[abi:cxx11]() | std::string
Pl_SHA2::getHexDigest()
{
if (this->in_progress) {
throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
}
return QUtil::hex_encode(getRawDigest());
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x30(%rsi)
je 0x8d904
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8d84e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b560
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8d8f9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
movq %rbx, %rax
a... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::~Pl_SHA2() | ~Pl_SHA2() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x8d97c
callq 0x69d60
movq 0x1bb12d(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x8d9a3
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x68760
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_SHA2.hh |
Pl_StdioFile::~Pl_StdioFile() | Pl_StdioFile::~Pl_StdioFile() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x1bb533(%rip), %rax # 0x248f68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x8da4f
movl $0x8, %esi
callq 0x68760
movq $0x0, 0x30(%rbx)
movq 0x1bb052(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmp... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::write(unsigned char const*, unsigned long) | void
Pl_StdioFile::write(unsigned char const* buf, size_t len)
{
size_t so_far = 0;
while (len > 0) {
so_far = fwrite(buf, 1, len, m->file);
if (so_far == 0) {
QUtil::throw_system_error(this->identifier + ": Pl_StdioFile::write");
} else {
buf += so_far;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x8db34
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
leaq 0x129a30(%rip), %r13 # 0x1b74f9
movq 0x30(%r15), %rax
movq (%rax), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::finish() | void
Pl_StdioFile::finish()
{
if ((fflush(m->file) == -1) && (errno == EBADF)) {
throw std::logic_error(this->identifier + ": Pl_StdioFile::finish: stream already closed");
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq (%rax), %rdi
callq 0x6a910
cmpl $-0x1, %eax
jne 0x8db8e
callq 0x6dd20
cmpl $0x9, (%rax)
je 0x8db97
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
addq $0x8, %r14
leaq 0x129960... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_String::Pl_String(char const*, Pipeline*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Pl_String::Pl_String(char const* identifier, Pipeline* next, std::string& s) :
Pipeline(identifier, next),
m(std::make_unique<Members>(s))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
callq 0x6db00
movq 0x1bb22e(%rip), %rax # 0x248e60
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x68ab0
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x1bae54(%rip), %rax # 0x248ab0... | /jberkenbilt[P]qpdf/libqpdf/Pl_String.cc |
Pl_String::write(unsigned char const*, unsigned long) | void
Pl_String::write(unsigned char const* buf, size_t len)
{
if (!len) {
return;
}
m->s.append(reinterpret_cast<char const*>(buf), len);
if (next()) {
next()->write(buf, len);
}
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x8dd2e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rax
movq (%rax), %rdi
callq 0x69be0
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x8dd2e
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_String.cc |
Pl_TIFFPredictor::write(unsigned char const*, unsigned long) | void
Pl_TIFFPredictor::write(unsigned char const* data, size_t len)
{
auto end = data + len;
auto row_end = data + (bytes_per_row - cur_row.size());
while (row_end <= end) {
// finish off current row
cur_row.insert(cur_row.end(), data, row_end);
data = row_end;
row_end += byt... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
addq %rsi, %rbx
movl 0x38(%rdi), %r13d
movq 0x48(%rdi), %rax
subq 0x50(%rdi), %rax
leaq 0x48(%rdi), %r15
addq %rsi, %r13
addq %rax, %r13
cmpq %rbx, %r13
jbe 0x8df8f
movq %rdx, %r12
jmp 0x8dfc6
movq %r13, %r12
movq 0x5... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
Pl_TIFFPredictor::processRow() | void
Pl_TIFFPredictor::processRow()
{
QTC::TC("libtests", "Pl_TIFFPredictor processRow", (action == a_decode ? 0 : 1));
previous.assign(samples_per_pixel, 0);
if (bits_per_sample != 8) {
BitWriter bw(next());
BitStream in(cur_row.data(), cur_row.size());
for (unsigned int col = 0; co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x60, %rdi
movl 0x3c(%rbx), %esi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %rdi, (%rsp)
callq 0x69960
cmpl $0x8, 0x40(%rbx)
jne 0x8e0bb
movq 0x78(%rbx), %rax
cmpq %rax, 0x80(%rbx)
je 0x8e02d
movq %rax, 0x80(%rbx)
... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
Pl_TIFFPredictor::finish() | void
Pl_TIFFPredictor::finish()
{
if (!cur_row.empty()) {
// write partial row
cur_row.insert(cur_row.end(), bytes_per_row - cur_row.size(), 0);
processRow();
}
cur_row.clear();
next()->finish();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
subq %rsi, %rax
je 0x8e18a
leaq 0x48(%rbx), %rdi
movl 0x38(%rbx), %edx
addq %rax, %rdx
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
callq 0x6ecb0
movq %rbx, %rdi
callq 0x8dfe2
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x8e198
movq %r... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
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 0x69e20
leaq 0x1b4a91(%rip), %rax # 0x2433d0
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 0x93bba
movq (%rax), %rcx
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x8e9c6
movq 0x1ba428(%rip), %rax # 0x248de0
cmpb $0x0, (%rax)
... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::Members::Members() | QPDF::Members::Members() :
log(QPDFLogger::defaultLogger()),
file(new InvalidInputSource()),
encp(new EncryptionParameters)
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x6a760
movq $0x0, 0x10(%rbx)
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x13821c
movl $0xa8, %edi
callq 0x68ab0
movq %rax, %r15
leaq 0xb0(%rbx), %r12
xorl %r13d, %r13d
movl $0xa8, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x69950
movq %r13,... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::QPDF() | QPDF::QPDF() :
m(std::make_unique<Members>())
{
m->tokenizer.allowEOF();
// Generate a unique ID. It just has to be unique among all QPDF objects allocated throughout
// the lifetime of this running application.
static std::atomic<unsigned long long> unique_id{0};
m->unique_id = unique_id.fetch_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x588, %edi # imm = 0x588
callq 0x68ab0
movq %rax, %r14
movq %rax, %rdi
callq 0x8ec8c
movq %r14, (%rbx)
addq $0x18, %r14
movq %r14, %rdi
callq 0x1382b6
movl $0x1, %eax
lock
xaddq %rax, 0x1be22a(%rip) # 0x24d390
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
... | /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 0x95ebc
movq (%rbx), %r12
movq 0x1c0(%r12), %r14
addq $0x1b0, %r12 # imm = 0x1B0
cmpq %r12, %r14
je 0x8f223
movq %rsp, %r15
movq 0x1b9c0a(%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 0x68ab0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x69010
leaq 0x10(%rsp), %r12
movq %r15, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x6ebd0
movq (%r14), %rdi
movq -0x8(... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::processFile(char const*, _IO_FILE*, bool, char const*) | void
QPDF::processFile(char const* description, FILE* filep, bool close_file, char const* password)
{
auto* fi = new FileInputSource(description, filep, close_file);
processInputSource(std::shared_ptr<InputSource>(fi), password);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movl $0xd8, %edi
callq 0x68ab0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x6e150
leaq 0x10(%rsp), %r12
movq %r15, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::processMemoryFile(char const*, char const*, unsigned long, char const*) | void
QPDF::processMemoryFile(
char const* description, char const* buf, size_t length, char const* password)
{
processInputSource(
std::shared_ptr<InputSource>(
// line-break
new BufferInputSource(
description, new Buffer(QUtil::unsigned_char_pointer(buf), length)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movl $0xe8, %edi
callq 0x68ab0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r13, %rsi
callq 0x6e7c0
movb $0x1, %al
movl %eax, (%rsp)
movl ... | /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 0x8f6f7
movq 0x1b96f6(%rip), %rdx # 0x248de0
cmpb $0x0, (%rdx)
je 0x8f6f3
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 0x6b570
movq (%r15), %rdi
movq (%r12), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x10(%rsp), %r12
movq %r12, %rsi
callq 0x6c300
movq (%r12), %rdi
testq %rdi, %rdi
je ... | /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 %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movb (%rax), %al
addb $-0x30, %al
cmpb $0xa, %al
setb %bl
jae 0x8f8eb
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x8f881
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movsbl (%rax), %r8d
movq 0x8(%r14), %rsi
mov... | /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 0x6a000
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x142f96(%rip), %rdx # 0x1d2c26
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x68bb0
movb $0x1, %bpl
movq %rsp, %rdx
movq %... | /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 0x68320
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newIndirectNull() | QPDFObjectHandle
QPDF::newIndirectNull()
{
return makeIndirectFromQPDFObject(QPDFObject::create<QPDF_Null>());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq $0x0, (%r15)
movl $0x70, %edi
callq 0x68ab0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1b370c(%rip), %rcx # 0x2435f8
movq %rcx, (%rax)
movb $0x2, 0x40(%rax)
xorps %xmm0, %xmm0
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newStream(std::shared_ptr<Buffer>) | QPDFObjectHandle
QPDF::newStream(std::shared_ptr<Buffer> data)
{
auto result = newStream();
result.replaceStreamData(data, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
return result;
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6d330
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x9008d
movq 0x1b8d61(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x90089
incl 0x8(%rax)
jmp 0x9008d
lock
incl 0x8(%rax)
leaq 0x28... | /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 0x6d330
leaq 0x18(%rsp), %rdi
callq 0x6b240
leaq 0x8(%rsp), %rdi
callq 0x6b240
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6c240
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9018a
callq 0x69d60
movq 0x20(%... | /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 0x6ae50
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
callq 0x6ae50
movq (%r14), %rax
cmpq $0x0, 0x2c8(%rax)
jne 0x916e4
movl $0x78, %edi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getExtensionLevel() | int
QPDF::getExtensionLevel()
{
int result = 0;
QPDFObjectHandle obj = getRoot();
if (obj.hasKey("/Extensions")) {
obj = obj.getKey("/Extensions");
if (obj.isDictionary() && obj.hasKey("/ADBE")) {
obj = obj.getKey("/ADBE");
if (obj.isDictionary() && obj.hasKey("/Exten... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x6ac80
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x125627(%rip), %rsi # 0x1b7a49
leaq 0x12562b(%rip), %rdx # 0x1b7a54
leaq 0x10(%rsp), %rdi
callq 0x68bb0
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x69f70
movl %eax, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getRoot() | QPDFObjectHandle
QPDF::getRoot()
{
QPDFObjectHandle root = m->trailer.getKey("/Root");
if (!root.isDictionary()) {
throw damagedPDF("", -1, "unable to find /Root dictionary");
} else if (
// Check_mode is an interim solution to request #810 pending a more comprehensive review of
// t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0xa8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1252e1(%rip), %rsi # 0x1b7a6b
leaq 0x1252df(%rip), %rdx # 0x1b7a70
leaq 0x98(%rsp), %rdi
callq 0x68bb0
... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getTrailer() | QPDFObjectHandle
QPDF::getTrailer()
{
return m->trailer;
} | movq %rdi, %rax
movq (%rsi), %rcx
movq 0x208(%rcx), %rdx
movq %rdx, (%rdi)
movq 0x210(%rcx), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x92c52
movq 0x1b619b(%rip), %rdx # 0x248de0
cmpb $0x0, (%rdx)
je 0x92c4e
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::pipeStreamData(std::shared_ptr<QPDF::EncryptionParameters>, std::shared_ptr<InputSource>, QPDF&, QPDFObjGen, long long, unsigned long, QPDFObjectHandle, bool, Pipeline*, bool, bool) | bool
QPDF::pipeStreamData(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDF& qpdf_for_warning,
QPDFObjGen og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle stream_dict,
bool is_root_metadata,
Pipeline* pipeline,
bool suppress_warnings,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %r9, %r12
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rcx, 0x70(%rsp)
movq $0x0, 0x68(%rsp)
movq (%rdi), %rax
cmpb $0x1, (%rax)
jne 0x92dd2
movq %rax, 0xa8(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0xb... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::damagedPDF(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&) | QPDFExc
QPDF::damagedPDF(std::string const& object, std::string const& message)
{
return damagedPDF(object, m->file->getLastOffset(), message);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
movq 0xb0(%rax), %rdi
callq 0x6cf20
movq %rax, %r13
movq (%r15), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x1, (%rsp)
movq %r12, %rdi
movl... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::damagedPDF(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFExc
QPDF::damagedPDF(std::string const& message)
{
return damagedPDF(m->last_object_description, m->file->getLastOffset(), message);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %r12
movq 0xb0(%r12), %rdi
addq $0xc0, %r12
callq 0x6cf20
movq %rax, %r13
movq (%r14), %rax
movq 0xb0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x1, (%rsp)
movq %r15, %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDFObjGen::unparse[abi:cxx11](char) const | std::string
unparse(char separator = ',') const
{
return std::to_string(obj) + separator + std::to_string(gen);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movl (%rsi), %ebx
movl %ebx, %r15d
negl %r15d
cmovsl %ebx, %r15d
movl $0x1, %r12d
cmpl $0xa, %r15d
jb 0x94094
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %r1... | /jberkenbilt[P]qpdf/include/qpdf/QPDFObjGen.hh |
qpdf::Stream::getStreamDataBuffer() const | std::shared_ptr<Buffer>
getStreamDataBuffer() const
{
return stream()->stream_data;
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x94c74
movq 0x20(%rax), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x94459
movq 0x1b4995(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0x94455
incl 0x8(%rax)
jmp 0x94459
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF::Members::~Members() | ~Members() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x558, %rdi # imm = 0x558
callq 0x95af6
leaq 0x528(%rbx), %rdi
callq 0x95bc6
leaq 0x510(%rbx), %rdi
callq 0x94700
leaq 0x4f8(%rbx), %rdi
callq 0x94700
leaq 0x4e0(%rbx), %rdi
callq 0x94700
leaq 0x4c8(%rbx), %rdi
callq 0x94700
leaq 0x4b0(%rbx), %rdi
callq 0x94700
movq 0x480(%rb... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDF_private.hh |
QPDFAcroFormDocumentHelper::traverseField(QPDFObjectHandle, QPDFObjectHandle, int, QPDFObjGen::set&) | void
QPDFAcroFormDocumentHelper::traverseField(
QPDFObjectHandle field, QPDFObjectHandle parent, int depth, QPDFObjGen::set& visited)
{
if (depth > 100) {
// Arbitrarily cut off recursion at a fixed depth to avoid specially crafted files that
// could cause stack overflow.
return;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
cmpl $0x64, %ecx
jg 0xa5243
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x6ab30
testb %al, %al
je 0xa519e
movq %r14, %rdi
callq 0x6b6a0
testb %al, %al
je ... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::addAndRenameFormFields(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>) | void
QPDFAcroFormDocumentHelper::addAndRenameFormFields(std::vector<QPDFObjectHandle> fields)
{
analyze();
std::map<std::string, std::string> renames;
QPDFObjGen::set seen;
for (std::list<QPDFObjectHandle> queue{fields.begin(), fields.end()}; !queue.empty();
queue.pop_front()) {
auto& o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %rbx
movq %rdi, 0xc8(%rsp)
callq 0xa4240
leaq 0x168(%rsp), %rcx
xorl %eax, %eax
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x198(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getAnnotationsForField(QPDFFormFieldObjectHelper) | std::vector<QPDFAnnotationObjectHelper>
QPDFAcroFormDocumentHelper::getAnnotationsForField(QPDFFormFieldObjectHelper h)
{
analyze();
std::vector<QPDFAnnotationObjectHelper> result;
QPDFObjGen og(h.getObjectHandle().getObjGen());
if (m->field_to_annotations.count(og)) {
result = m->field_to_annot... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa4240
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xa6d1e
movq 0x1a20d0(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getWidgetAnnotationsForPage(QPDFPageObjectHelper) | std::vector<QPDFAnnotationObjectHelper>
QPDFAcroFormDocumentHelper::getWidgetAnnotationsForPage(QPDFPageObjectHelper h)
{
return h.getAnnotations("/Widget");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x112060(%rip), %rsi # 0x1b8e2a
leaq 0x112060(%rip), %rdx # 0x1b8e31
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x68bb0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::getFormFieldsForPage(QPDFPageObjectHelper) | std::vector<QPDFFormFieldObjectHelper>
QPDFAcroFormDocumentHelper::getFormFieldsForPage(QPDFPageObjectHelper ph)
{
analyze();
QPDFObjGen::set todo;
std::vector<QPDFFormFieldObjectHelper> result;
for (auto& annot: getWidgetAnnotationsForPage(ph)) {
auto field = getFieldForAnnotation(annot).getTop... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, 0x28(%rsp)
movq %rsi, %rdi
callq 0xa4240
leaq 0xf8(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded() | void
QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded()
{
if (!getNeedAppearances()) {
return;
}
for (auto const& page: QPDFPageDocumentHelper(qpdf).getAllPages()) {
for (auto& aoh: getWidgetAnnotationsForPage(page)) {
QPDFFormFieldObjectHelper ffh = getFieldForAnnotation... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbx
callq 0x68b70
testb %al, %al
je 0xa7ae7
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x689e0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x68f80
leaq 0xf0... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAcroFormDocumentHelper::adjustInheritedFields(QPDFObjectHandle, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, int) | void
QPDFAcroFormDocumentHelper::adjustInheritedFields(
QPDFObjectHandle obj,
bool override_da,
std::string const& from_default_da,
bool override_q,
int from_default_q)
{
// Override /Q or /DA if needed. If this object has a field type, directly or inherited, it is a
// field and not just an... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r14d
movl %edx, %r12d
movl %r12d, %eax
orb %r14b, %al
cmpb $0x1, %al
jne 0xa80c7
movq %rcx, %r15
movq %rsi, %rbx
movq (%rsi), %rax
movq %rax, 0x60(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x68(%rsp)
testq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
(anonymous namespace)::ResourceReplacer::handleToken(QPDFTokenizer::Token const&) | void
ResourceReplacer::handleToken(QPDFTokenizer::Token const& token)
{
bool wrote = false;
if (token.getType() == QPDFTokenizer::tt_name) {
std::string name = QPDFObjectHandle::newName(token.getValue()).getName();
if (to_replace.count(name) && to_replace[name].count(offset)) {
QTC::... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x8, (%rsi)
jne 0xac622
leaq 0x8(%rbx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6da40
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x6b430
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xac585
callq 0x69d60
leaq 0x18... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
ResourceFinder::~ResourceFinder() | ~ResourceFinder() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x19ab93(%rip), %rax # 0x2478d8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x69610
leaq 0x30(%rbx), %rdi
callq 0x6cf60
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xacd77
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x68760
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/ResourceFinder.hh |
QPDFAnnotationObjectHelper::getAppearanceState[abi:cxx11]() | std::string
QPDFAnnotationObjectHelper::getAppearanceState()
{
if (oh().getKey("/AS").isName()) {
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS present");
return oh().getKey("/AS").getName();
}
QTC::TC("qpdf", "QPDFAnnotationObjectHelper AS absent");
return "";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xb1056
movq 0x197d98(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xb1052
incl 0x8(%rax)
jmp 0xb1056
lock
incl 0x8(%ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFArgParser::addChoices(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, bool, char const**) | void
QPDFArgParser::addChoices(
std::string const& arg, param_arg_handler_t handler, bool required, char const** choices)
{
OptionEntry& oe = registerArg(arg);
oe.parameter_needed = required;
oe.param_arg_handler = handler;
for (char const** i = choices; *i; ++i) {
oe.choices.insert(*i);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r15
callq 0xb301c
movq %rax, %r14
movb %bpl, (%rax)
leaq 0x78(%rax), %rdi
movq %r15, %rsi
callq 0x6f100
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xb2a8d
addq $0x28, %r14
leaq 0x18(%rsp), %r13
addq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::addInvalidChoiceHandler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) | void
QPDFArgParser::addInvalidChoiceHandler(std::string const& arg, param_arg_handler_t handler)
{
auto i = m->option_table->find(arg);
if (i == m->option_table->end()) {
QTC::TC("libtests", "QPDFArgParser invalid choice handler to unknown");
throw std::logic_error(
"QPDFArgParser: a... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x178(%rax), %rdi
callq 0xb7e0c
movq (%r14), %rcx
movq 0x178(%rcx), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xb2b90
addq $0xd8, %rax
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f100
movl $0x10, %edi
ca... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::invalidHelpArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFArgParser::invalidHelpArg(std::string const& p)
{
usage(std::string("unknown help option") + (p.empty() ? "" : (" " + p)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x106a02(%rip), %rsi # 0x1b95f9
leaq 0x106a0e(%rip), %rdx # 0x1b960c
leaq 0x48(%rsp), %rdi
callq 0x68bb0
cmpq $0x0, 0x8(%r14)
leaq 0x38(%rsp), %r12
jne 0xb2c2d
leaq 0x28(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::registerArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFArgParser::OptionEntry&
QPDFArgParser::registerArg(std::string const& arg)
{
if (0 != m->option_table->count(arg)) {
QTC::TC("libtests", "QPDFArgParser duplicate handler");
throw std::logic_error(
"QPDFArgParser: adding a duplicate handler for option " + arg + " in " +
m-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq 0x178(%rax), %rbx
movq %rbx, %rdi
callq 0xb7810
addq $0x8, %rbx
cmpq %rbx, %rax
jne 0xb306d
movq (%r14), %rax
movq 0x178(%rax), %rdi
movq %r15, %rsi
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::completionCommon(bool) | void
QPDFArgParser::completionCommon(bool zsh)
{
std::string progname = m->argv[0];
std::string executable;
std::string appdir;
std::string appimage;
if (QUtil::get_env(m->progname_env.c_str(), &executable)) {
progname = executable;
} else if (QUtil::get_env("APPDIR", &appdir) && QUtil::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x6e7c0
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %a... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::checkCompletion() | void
QPDFArgParser::checkCompletion()
{
// See if we're being invoked from bash completion.
std::string bash_point_env;
// On Windows with mingw, there have been times when there appears to be no way to distinguish
// between an empty environment variable and an unset variable. There are also conditions... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x10534a(%rip), %rsi # 0x1b960d
leaq 0x10534c(%rip), %rdx # 0x1b9616
leaq 0x8(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::parseArgs() | void
QPDFArgParser::parseArgs()
{
selectMainOptionTable();
checkCompletion();
handleArgFileArguments();
for (m->cur_arg = 1; m->cur_arg < m->argc; ++m->cur_arg) {
bool help_option = false;
bool end_option = false;
auto oep = m->option_table->end();
char const* arg = m->ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x118(%rdi), %rax
movq %rax, 0x178(%rdi)
movq 0x188(%rdi), %rdx
addq $0x180, %rdi # imm = 0x180
leaq 0x104de0(%rip), %rcx # 0x1b9448
movl $0x4, %r8d
xorl %esi... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::getProgname[abi:cxx11]() | std::string
QPDFArgParser::getProgname()
{
return m->whoami;
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x68320
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::Members::~Members() | ~Members() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x270(%rdi), %rdi
leaq 0x280(%rbx), %rax
cmpq %rax, %rdi
je 0xb70d2
movq (%rax), %rsi
incq %rsi
callq 0x68760
leaq 0x240(%rbx), %rdi
callq 0xb6d98
leaq 0x210(%rbx), %rdi
callq 0xb6d98
movq 0x208(%rbx), %rdi
testq %rdi, %rdi
je 0xb70fb
callq 0x69d60
movq 0x1f8(%rbx), %rdi
testq %rdi, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFArgParser.hh |
QPDFCryptoProvider::getImpl_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::shared_ptr<QPDFCryptoImpl>
QPDFCryptoProvider::getImpl_internal(std::string const& name) const
{
auto iter = m->providers.find(name);
if (iter == m->providers.end()) {
throw std::logic_error(
"QPDFCryptoProvider requested unknown implementation \"" + name + "\"");
}
return m->pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
addq $0x20, %rdi
movq %rdx, %rsi
callq 0x6dce0
movq (%r15), %rdi
leaq 0x28(%rdi), %rcx
cmpq %rcx, %rax
je 0xb8c1a
addq $0x20, %rdi
movq %r14, %rsi
callq 0x69f60
cmpq $0x0, 0x10(%rax)
je 0xb8c6d... | /jberkenbilt[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
QPDFCryptoProvider::registerImpl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<std::shared_ptr<QPDFCryptoImpl> ()>) | void
QPDFCryptoProvider::registerImpl(std::string const& name, provider_fn f)
{
getInstance().registerImpl_internal(name, std::move(f));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb8b52
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xb8d8d
movups (%r14), %xmm1
addq $0x10, %r14
movaps %xmm1, (%rsp)
movq %rax, 0x10(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
QPDFCryptoProvider::Members::~Members() | ~Members() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x6be20
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0xb942d
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x68760
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/include/qpdf/QPDFCryptoProvider.hh |
QPDFEFStreamObjectHelper::setParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&) | void
QPDFEFStreamObjectHelper::setParam(std::string const& pkey, QPDFObjectHandle const& pval)
{
auto params = oh().getDict().getKey("/Params");
if (!params.isDictionary()) {
params = oh().getDict().replaceKeyAndGetNew("/Params", QPDFObjectHandle::newDictionary());
}
params.replaceKey(pkey, pval... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xb9c9d
movq 0x18f151(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xb9c99
incl 0x8(%rax)
jmp 0xb9c9d
lock
... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::getSubtype[abi:cxx11]() | std::string
QPDFEFStreamObjectHelper::getSubtype()
{
auto val = oh().getDict().getKey("/Subtype");
if (val.isName()) {
auto n = val.getName();
if (n.length() > 1) {
return n.substr(1);
}
}
return "";
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0xba1ac
movq 0x18ec42(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xba1a8
incl 0x8(%rax)
jmp 0xba1ac
lock
incl 0x8(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x28(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::createEFStream(QPDF&, std::function<void (Pipeline*)>) | QPDFEFStreamObjectHelper
QPDFEFStreamObjectHelper::createEFStream(QPDF& qpdf, std::function<void(Pipeline*)> provider)
{
auto stream = qpdf.newStream();
stream.replaceStreamData(provider, QPDFObjectHandle::newNull(), QPDFObjectHandle::newNull());
return newFromStream(stream);
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6d330
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6c0b0
leaq 0x38(%rsp), %rdi
callq 0x6b240
leaq 0x28(%rsp), %rdi
callq 0x6b240
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x28(%rsp), %rcx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFEFStreamObjectHelper::setCreationDate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFEFStreamObjectHelper&
QPDFEFStreamObjectHelper::setCreationDate(std::string const& date)
{
setParam("/CreationDate", QPDFObjectHandle::newString(date));
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xff3e5(%rip), %rsi # 0x1b9f22
leaq 0xff3eb(%rip), %rdx # 0x1b9f2f
leaq 0x10(%rsp), %rdi
callq 0x68bb0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x69060
leaq 0x10(%rsp), %rsi
movq %rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFEFStreamObjectHelper.cc |
QPDFExc::createWhat(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&, long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QPDFExc::createWhat(
std::string const& filename,
std::string const& object,
qpdf_offset_t offset,
std::string const& message)
{
std::string result;
if (!filename.empty()) {
result += filename;
}
if (!(object.empty() && offset < 0)) {
if (!filename.empty()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xbc4c8
movq (%r15), %rsi
movq %rb... | /jberkenbilt[P]qpdf/libqpdf/QPDFExc.cc |
QPDFFileSpecObjectHelper::QPDFFileSpecObjectHelper(QPDFObjectHandle) | QPDFFileSpecObjectHelper::QPDFFileSpecObjectHelper(QPDFObjectHandle oh) :
QPDFObjectHelper(oh)
{
if (!oh.isDictionary()) {
oh.warnIfPossible("Embedded file object is not a dictionary");
return;
}
if (!oh.isDictionaryOfType("/Filespec")) {
oh.warnIfPossible("Embedded file object's... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xbc8de
movq 0x18c51f(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xbc8cb
incl 0x8(%rdi)
jmp 0xbc8cf
lock
incl 0x8(%rdi)
testq %rdi, %rdi
je 0xbc8de
cmpb ... | /jberkenbilt[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFileSpecObjectHelper::createFileSpec(QPDF&, 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&) | QPDFFileSpecObjectHelper
QPDFFileSpecObjectHelper::createFileSpec(
QPDF& qpdf, std::string const& filename, std::string const& fullpath)
{
return createFileSpec(
qpdf,
filename,
QPDFEFStreamObjectHelper::createEFStream(qpdf, QUtil::file_provider(fullpath)));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rcx, %rsi
callq 0x6cea0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6ead0
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6f0... | /jberkenbilt[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper() | QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper() :
QPDFObjectHelper(QPDFObjectHandle::newNull()),
m(new Members())
{
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6b240
movq (%r14), %rax
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xbdaec
movq 0x18b302(%rip), %rdx # 0x248de0
cmpb $0x0, (%rdx)
je 0xbdae8
incl 0x8(%rcx)
jmp 0xbdaec
lock
incl 0x8(%rcx)
movq %rax, 0x8(%rbx)
movq %rcx,... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getAlternativeName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getAlternativeName()
{
if (oh().getKey("/TU").isString()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TU present");
return oh().getKey("/TU").getUTF8Value();
}
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TU absent");
return getFullyQualifiedName();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xbec28
movq 0x18a1c6(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xbec24
incl 0x8(%rax)
jmp 0xbec28
lock
incl 0x8(%ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getMappingName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getMappingName()
{
if (oh().getKey("/TM").isString()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TM present");
return oh().getKey("/TM").getUTF8Value();
}
QTC::TC("qpdf", "QPDFFormFieldObjectHelper TM absent");
return getAlternativeName();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xbede8
movq 0x18a006(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xbede4
incl 0x8(%rax)
jmp 0xbede8
lock
incl 0x8(%ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getValueAsString[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getValueAsString()
{
return getInheritableFieldValueAsString("/V");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xfa04a(%rip), %rsi # 0x1b9064
leaq 0xfa045(%rip), %rdx # 0x1b9066
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x68bb0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getDefaultValueAsString[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getDefaultValueAsString()
{
return getInheritableFieldValueAsString("/DV");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xfb1fb(%rip), %rsi # 0x1ba32d
leaq 0xfb1f7(%rip), %rdx # 0x1ba330
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x68bb0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getQuadding() | int
QPDFFormFieldObjectHelper::getQuadding()
{
QPDFObjectHandle fv = getInheritableFieldValue("/Q");
bool looked_in_acroform = false;
if (!fv.isInteger()) {
fv = getFieldFromAcroForm("/Q");
looked_in_acroform = true;
}
int result = 0;
if (fv.isInteger()) {
QTC::TC("qpdf",... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xf9c87(%rip), %rsi # 0x1b9075
leaq 0xf9c82(%rip), %rdx # 0x1b9077
leaq 0x10(%rsp), %rdi
callq 0x68bb0
movq %rsp, %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
callq 0x6c200
movq 0x10(%rsp), %rdi
cmpq %r14, %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isChecked() | bool
QPDFFormFieldObjectHelper::isChecked()
{
return isCheckbox() && getValue().isName() && (getValue().getName() != "/Off");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x6ea90
movl %eax, %ebx
testb %al, %al
je 0xbf74f
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6a710
movq %r15, %rdi
callq 0x6a170
testb %al, %al
je 0xbf74f
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6a710
leaq 0x28(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isChoice() | bool
QPDFFormFieldObjectHelper::isChoice()
{
return (getFieldType() == "/Ch");
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x688e0
leaq 0xfaa38(%rip), %rsi # 0x1ba33e
movq %r14, %rdi
callq 0x6d210
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbf92a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x68760
testl %ebx, %eb... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::setCheckBoxValue(bool) | void
QPDFFormFieldObjectHelper::setCheckBoxValue(bool value)
{
QPDFObjectHandle AP = oh().getKey("/AP");
QPDFObjectHandle annot;
if (AP.null()) {
// The widget may be below. If there is more than one, just
// find the first one.
QPDFObjectHandle kids = oh().getKey("/Kids");
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %esi, %ebp
movq %rdi, %r13
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xc0135
movq 0x188cb9(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0xc0131
incl 0x8(%rax)
jmp 0xc0135... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::generateAppearance(QPDFAnnotationObjectHelper&) | void
QPDFFormFieldObjectHelper::generateAppearance(QPDFAnnotationObjectHelper& aoh)
{
std::string ft = getFieldType();
// Ignore field types we don't know how to generate appearances for. Button fields don't really
// need them -- see code in QPDFAcroFormDocumentHelper::generateAppearancesIfNeeded.
if (... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x688e0
leaq 0xf89ff(%rip), %rsi # 0x1ba335
movq %r15, %rdi
callq 0x6d210
testl %eax, %eax
je 0xc1955
leaq 0xf89f5(%rip), %rsi # 0x1ba33e
movq %rsp, %rdi
callq 0x6d210
testl %e... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper&) | void
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper& aoh)
{
QPDFObjectHandle AS = aoh.getAppearanceStream("/N");
if (AS.isNull()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper create AS from scratch");
QPDFObjectHandle::Rectangle rect = aoh.getRect();
QPDFObj... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x150(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf7a30(%rip), %rsi # 0x1b9407
leaq 0xf7a2b(%rip), %rdx # 0x1b9409
leaq 0x140(%rsp), %rdi
callq 0x68bb0
leaq 0xf0(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
(anonymous namespace)::ValueSetter::~ValueSetter() | ~ValueSetter() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x180cf5(%rip), %rax # 0x244260
movq %rax, (%rdi)
addq $0x50, %rdi
callq 0x6f2e8
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xc358f
movq (%rax), %rsi
incq %rsi
callq 0x68760
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0xc35a8
movq (%rbx), %rsi
incq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
(anonymous namespace)::ValueSetter::handleToken(QPDFTokenizer::Token const&) | void
ValueSetter::handleToken(QPDFTokenizer::Token const& token)
{
QPDFTokenizer::token_type_e ttype = token.getType();
std::string value = token.getValue();
bool do_replace = false;
switch (state) {
case st_top:
writeToken(token);
if (token.isWord("BMC")) {
state = st_bm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %ebp
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x68320
movl 0x90(%rbx), %eax
cmpq $0x3, %rax
ja 0xc370... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFTokenizer::Token::isWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
isWord(std::string const& value) const
{
return this->type == tt_word && this->value == value;
} | cmpl $0xd, (%rdi)
jne 0xc4c1f
movq 0x10(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0xc4c1f
testq %rdx, %rdx
je 0xc4c22
pushq %rax
movq (%rsi), %rsi
movq 0x8(%rdi), %rdi
callq 0x6bbe0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /jberkenbilt[P]qpdf/include/qpdf/QPDFTokenizer.hh |
QPDFJob::getMessagePrefix[abi:cxx11]() const | std::string
QPDFJob::getMessagePrefix() const
{
return m->message_prefix;
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
callq 0x68320
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::parseNumrange(char const*, int) | std::vector<int>
QPDFJob::parseNumrange(char const* range, int max)
{
try {
return QUtil::parse_numrange(range, max);
} catch (std::runtime_error& e) {
usage(e.what());
}
return {};
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rdx, %rsi
movl %ecx, %edx
callq 0x6cd40
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xc5bc0
movq %rbx, %rdi
callq 0x683f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::handleUnderOverlay(QPDF&) | void
QPDFJob::handleUnderOverlay(QPDF& pdf)
{
if (m->underlay.empty() && m->overlay.empty()) {
return;
}
for (auto& uo: m->underlay) {
validateUnderOverlay(pdf, &uo);
}
for (auto& uo: m->overlay) {
validateUnderOverlay(pdf, &uo);
}
// First map key is 1-based page nu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %rbp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x348(%rax), %r15
movq 0x350(%rax), %rbx
cmpq %rbx, %r15
jne 0xc9f6b
movq 0x360(%rax), %rcx
cmpq 0x368(%rax), %rcx
jne 0xc9f6b
jmp 0xca912
movq %r14, %rdi
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::handleTransformations(QPDF&) | void
QPDFJob::handleTransformations(QPDF& pdf)
{
QPDFPageDocumentHelper dh(pdf);
std::shared_ptr<QPDFAcroFormDocumentHelper> afdh;
auto make_afdh = [&]() {
if (!afdh.get()) {
afdh = std::make_shared<QPDFAcroFormDocumentHelper>(pdf);
}
};
if (m->remove_restrictions) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %rbp
movq %rdi, %r14
leaq 0xd8(%rsp), %rdi
callq 0x689e0
movq (%r14), %rax
cmpb $0x1, 0x5a(%rax)
jne 0xcad33
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
xorl %r12d, %r12d
movq %rsp, %rsi
leaq 0x38(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::writeQPDF(QPDF&) | void
QPDFJob::writeQPDF(QPDF& pdf)
{
if (createsOutput()) {
if (!Pl_Flate::zopfli_check_env(pdf.getLogger().get())) {
m->warnings = true;
}
}
if (!createsOutput()) {
doInspection(pdf);
} else if (m->split_pages) {
doSplitPages(pdf);
} else {
writeO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq $0x0, 0x3e0(%rax)
jne 0xcb954
cmpb $0x1, 0x3c9(%rax)
jne 0xcb989
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6ef50
movq (%r15), %rdi
callq 0x68b50
movl %eax, %ebp
movq 0x10(%rs... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
show_encryption_method[abi:cxx11](QPDF::encryption_method_e) | static std::string
show_encryption_method(QPDF::encryption_method_e method)
{
std::string result = "unknown";
switch (method) {
case QPDF::e_none:
result = "none";
break;
case QPDF::e_unknown:
result = "unknown";
break;
case QPDF::e_rc4:
result = "RC4";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xf21c0(%rip), %rsi # 0x1bf9a0
leaq 0xf21c0(%rip), %rdx # 0x1bf9a7
callq 0x68bb0
cmpl $0x5, %ebp
jae 0xcd81a
movl %ebp, %eax
leaq 0xed9da(%rip), %rdx # 0x1bb1d4
movslq (%rdx,%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doShowObj(QPDF&) | void
QPDFJob::doShowObj(QPDF& pdf)
{
QPDFObjectHandle obj;
if (m->show_trailer) {
obj = pdf.getTrailer();
} else {
obj = pdf.getObjectByID(m->show_obj, m->show_gen);
}
bool error = false;
if (obj.isStream()) {
if (m->show_raw_stream_data || m->show_filtered_stream_data) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%rdi), %rax
cmpb $0x1, 0x1f2(%rax)
jne 0xcdd83
movq %rsp, %rdi
callq 0x6e7e0
jmp 0xcdd97
movl 0x1f4(%rax), %edx
movl 0x1f8(%rax), %ecx
movq %rsp, %rdi
callq 0x68e90
movaps (%rsp), %xmm0
xorps %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::getWantedJSONObjects() | QPDFObjGen::set
QPDFJob::getWantedJSONObjects()
{
QPDFObjGen::set wanted_og;
for (auto const& iter: m->json_objects) {
bool trailer;
int obj = 0;
int gen = 0;
parse_object_id(iter, trailer, obj, gen);
wanted_og.add(QPDFObjGen(obj, gen));
}
return wanted_og;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ebp, %ebp
movq %rbp, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
movq (%rsi), %r15
movq 0x2d8(%r15), %r14
addq $0x2c8, %r15 # imm... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONPageLabels(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONPageLabels(Pipeline* p, bool& first, QPDF& pdf)
{
JSON j_labels = JSON::makeArray();
QPDFPageLabelDocumentHelper pldh(pdf);
long long npages = QIntC::to_longlong(QPDFPageDocumentHelper(pdf).getAllPages().size());
if (pldh.hasPageLabels()) {
std::vector<QPDFObjectHandle> label... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdx, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x685f0
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x6cfa0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x689e0
leaq 0x20(%rsp), %rdi... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::setEncryptionOptions(QPDFWriter&) | void
QPDFJob::setEncryptionOptions(QPDFWriter& w)
{
int R = 0;
if (m->keylen == 40) {
R = 2;
} else if (m->keylen == 128) {
if (m->force_V4 || m->cleartext_metadata || m->use_aes) {
R = 4;
} else {
R = 3;
}
} else if (m->keylen == 256) {
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x110(%rax), %ecx
cmpl $0x28, %ecx
je 0xdb7da
cmpl $0x100, %ecx # imm = 0x100
je 0xdb7c4
cmpl $0x80, %ecx
jne 0xdbad0
movl $0x4, %r15d
movb $0x1, %cl
cmpb $0x0, 0x124(%rax... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::writeJSON(QPDF&) | void
QPDFJob::writeJSON(QPDF& pdf)
{
// File pipeline must have block scope so it will be closed after write.
std::shared_ptr<QUtil::FileCloser> fc;
std::shared_ptr<Pipeline> fp;
if (m->outfilename.get()) {
QTC::TC("qpdf", "QPDFJob write json to file");
if (m->json_stream_prefix.empty())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq (%rdi), %r13
movq 0x3e0(%r13), %rbp
testq %rbp, %rbp
je 0xdc3bb
movq %rsi, 0x30(%rsp)
movq 0x300(%r13), %rbx
testq %rbx, %rbx
jne 0xdc327
addq $0x2f8, %r13 # imm = 0x2F8
movq %rbp, %rdi
callq 0x6a120
xorl ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ArgParser::initOptionTables() | void
ArgParser::initOptionTables()
{
#include <qpdf/auto_job_init.hh>
this->ap.addFinalCheck([this]() { c_main->checkConfiguration(); });
// add_help is defined in auto_job_help.hh
add_help(this->ap);
// Special case: ignore -- at the top level. This undocumented behavior is for backward
// compatib... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x14a8, %rsp # imm = 0x14A8
movq %rdi, %rbx
callq 0xb29d4
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe1880(%rip), %rsi # 0x1c5b5b
leaq 0xe1880(%rip), %rdx # 0x1c5b62
movq %rsp, %rdi
callq 0x68bb0
xorps %xmm0, %xmm0
movaps... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argPositional(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argPositional(std::string const& arg)
{
if (!this->gave_input) {
c_main->inputFile(arg);
this->gave_input = true;
} else if (!this->gave_output) {
c_main->outputFile(arg);
this->gave_output = true;
} else {
usage("unknown argument " + arg);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
cmpb $0x0, 0xcb(%rdi)
je 0xecb05
cmpb $0x0, 0xcc(%rbx)
je 0xecb1a
leaq 0xd60b7(%rip), %rsi # 0x1c2b87
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6c310
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb3958
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.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.