name string | code string | asm string | file string |
|---|---|---|---|
Pl_LZWDecoder::write(unsigned char const*, unsigned long) | void
Pl_LZWDecoder::write(unsigned char const* bytes, size_t len)
{
for (size_t i = 0; i < len; ++i) {
buf[next_char_++] = bytes[i];
if (next_char_ == 3) {
next_char_ = 0;
}
this->bits_available += 8;
if (this->bits_available >= this->code_size) {
send... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x57bbd
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movb (%rcx,%r... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::getFirstChar(unsigned int) | unsigned char
Pl_LZWDecoder::getFirstChar(unsigned int code)
{
unsigned char result = '\0';
if (code < 256) {
result = static_cast<unsigned char>(code);
} else if (code > 257) {
unsigned int idx = code - 258;
if (idx >= table.size()) {
throw std::runtime_error("Pl_LZWDeco... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0xd(%rbp)
cmpl $0x100, -0xc(%rbp) # imm = 0x100
jae 0x58135
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
jmp 0x582fd
cmpl $0x101, -0xc(%rbp) # imm = 0x101
jbe 0x581fe
... | /qpdf[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_MD5::Pl_MD5(char const*, Pipeline*) | Pl_MD5::Pl_MD5(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_MD5 with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x38(%rbp), %rdi
leaq 0x437f34(%rip), %rax # 0x491438
movq %rax, (%rdi)
movb $0x0, 0x30(%rdi)
... | /qpdf[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::write(unsigned char const*, unsigned long) | void
Pl_MD5::write(unsigned char const* buf, size_t len)
{
if (this->enabled) {
if (!this->in_progress) {
this->md5.reset();
this->in_progress = true;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x48(%rax)
je 0x59675
movq -0x38(%rbp), %rax
testb $0x1, 0x30(%rax)
jne 0x59605
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x40730
movq -0x38(%rbp),... | /qpdf[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::getHexDigest[abi:cxx11]() | std::string
Pl_MD5::getHexDigest()
{
if (!this->enabled) {
throw std::logic_error("digest requested for a disabled MD5 Pipeline");
}
this->in_progress = false;
return this->md5.unparse();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x48(%rax)
jne 0x59799
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
le... | /qpdf[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_PNGFilter::Pl_PNGFilter(char const*, Pipeline*, Pl_PNGFilter::action_e, unsigned int, unsigned int, unsigned int) | Pl_PNGFilter::Pl_PNGFilter(
char const* identifier,
Pipeline* next,
action_e action,
unsigned int columns,
unsigned int samples_per_pixel,
unsigned int bits_per_sample) :
Pipeline(identifier, next),
action(action)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_PN... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x68(%... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeRow() | void
Pl_PNGFilter::decodeRow()
{
int filter = this->cur_row[0];
if (this->prev_row) {
switch (filter) {
case 0:
break;
case 1:
this->decodeSub();
break;
case 2:
this->decodeUp();
break;
case 3:
this->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40(%rax), %rcx
movzbl (%rcx), %ecx
movl %ecx, -0xc(%rbp)
cmpq $0x0, 0x48(%rax)
je 0x5a558
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x5a554
movq -0x20(%rbp), %rax
leaq 0x2bac83(%ri... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeAverage() | void
Pl_PNGFilter::decodeAverage()
{
QTC::TC("libtests", "Pl_PNGFilter decodeAverage");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
int left = ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x2b8344(%rip), %rdi # 0x312a2f
leaq 0x2babf5(%rip), %rsi # 0x3152e7
xorl %edx, %edx
callq 0x2af50
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq 0x48(%rax)... | /qpdf[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_QPDFTokenizer::Pl_QPDFTokenizer(char const*, QPDFObjectHandle::TokenFilter*, Pipeline*) | Pl_QPDFTokenizer::Pl_QPDFTokenizer(
char const* identifier, QPDFObjectHandle::TokenFilter* filter, Pipeline* next) :
Pipeline(identifier, next),
m(std::make_unique<Members>())
{
m->filter = filter;
QPDFObjectHandle::TokenFilter::PipelineAccessor::setPipeline(m->filter, next);
m->tokenizer.allowE... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c1b0
movq -0x40(%rbp), %rdi
leaq 0x436a78(%rip), %rax # 0x491510
movq %rax, (%rdi)... | /qpdf[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_RunLength::Pl_RunLength(char const*, Pipeline*, Pl_RunLength::action_e) | Pl_RunLength::Pl_RunLength(char const* identifier, Pipeline* next, action_e action) :
Pipeline(identifier, next),
m(std::make_unique<Members>(action))
{
if (!next) {
throw std::logic_error("Attempt to create Pl_RunLength with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x40(%rbp), %rdi
leaq 0x435959(%rip), %rax # 0x4915a0
movq %rax, (%rdi)... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x5c870
cmpl $0x0, (%rax)
jne 0x5c6bf
movq -0x28(%rbp), %rdi
callq 0x5c3f0
movq -0x28(%rbp), %rdi
movb $-0x80, -0x9(%rbp)
callq 0x4d5c0
movq %rax, %rdi
movq (%rdi), %rax
leaq -0x9(%rbp),... | /qpdf[P]qpdf/libqpdf/Pl_RunLength.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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x30(%rax)
je 0x5d059
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
lea... | /qpdf[P]qpdf/libqpdf/Pl_SHA2.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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x5d2c5
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0... | /qpdf[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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x30, %rdi
callq 0x5d4a0
movq (%rax), %rdi
callq 0x1b750
cmpl $-0x1, %eax
jne 0x5d3aa
callq 0x1bed0
cmpl $0x9, (%rax)
jne 0x5d3aa
movb $0x1, -0x35(%rbp)
movl $0x10, %edi
callq 0x1b580
movq -0x40(%rbp), %... | /qpdf[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_TIFFPredictor::Pl_TIFFPredictor(char const*, Pipeline*, Pl_TIFFPredictor::action_e, unsigned int, unsigned int, unsigned int) | Pl_TIFFPredictor::Pl_TIFFPredictor(
char const* identifier,
Pipeline* next,
action_e action,
unsigned int columns,
unsigned int samples_per_pixel,
unsigned int bits_per_sample) :
Pipeline(identifier, next),
action(action),
columns(columns),
samples_per_pixel(samples_per_pixel),
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x50(%... | /qpdf[P]qpdf/libqpdf/Pl_TIFFPredictor.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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x38(%rdi), %eax
movq %rax, -0x68(%rbp)
add... | /qpdf[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
QPDF::ForeignStreamData::ForeignStreamData(std::shared_ptr<QPDF::EncryptionParameters>, std::shared_ptr<InputSource>, QPDFObjGen, long long, unsigned long, QPDFObjectHandle, bool) | QPDF::ForeignStreamData::ForeignStreamData(
std::shared_ptr<EncryptionParameters> encp,
std::shared_ptr<InputSource> file,
QPDFObjGen foreign_og,
qpdf_offset_t offset,
size_t length,
QPDFObjectHandle local_dict,
bool is_root_metadata) :
encp(encp),
file(file),
foreign_og(foreign_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %r10, -0x48(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp... | /qpdf[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
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
callq 0x68a70
movq %rax, %rsi
leaq... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x691d0
movq %rax, %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x69250
movq -0x40(%rbp), %rdi
callq 0x691d0
addq $0x1a8, %rax # imm = 0x1A8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %... | /qpdf[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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x69840
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x63231
jmp 0x63170
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x69840... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x63a00
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ca0e0
jm... | /qpdf[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
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdx, -0x230(%rbp)
movq %rdi, %rax
movq -0x230(%rbp), %rdi
movq %rax, -0x228(%rbp)
movq %rax, %rcx
movq %rcx, -0x220(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x218(%rbp)
callq 0... | /qpdf[P]qpdf/libqpdf/QPDF.cc |
QPDF::getVersionAsPDFVersion() | PDFVersion
QPDF::getVersionAsPDFVersion()
{
int major = 1;
int minor = 3;
int extension_level = getExtensionLevel();
std::regex v("^[[:space:]]*([0-9]+)\\.([0-9]+)");
std::smatch match;
if (std::regex_search(m->pdf_version, match, v)) {
major = QUtil::string_to_int(match[1].str().c_str(... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x3, -0x20(%rbp)
callq 0x66600
movl %eax, -0x24(%rbp)
leaq 0x2afa1e(%rip), %rsi # 0x315e45
leaq -0x48(%rbp), %rdi
movl $0x10, %edx
callq 0x6a7b0
leaq... | /qpdf[P]qpdf/libqpdf/QPDF.cc |
QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper(QPDFObjectHandle) | QPDFFormFieldObjectHelper::QPDFFormFieldObjectHelper(QPDFObjectHandle oh) :
QPDFObjectHelper(oh),
m(new Members())
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x48940
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc5240
jmp 0xe0674
leaq -0x20(%rbp), %rdi
callq 0x290a0
movq -0x40(%rbp),... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getInheritableFieldValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFFormFieldObjectHelper::getInheritableFieldValue(std::string const& name)
{
QPDFObjectHandle node = oh();
if (!node.isDictionary()) {
return QPDFObjectHandle::newNull();
}
QPDFObjectHandle result(node.getKey(name));
if (result.isNull()) {
QPDFObjGen::set seen;
... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xc52f0
movq -0xf8(%rbp), %rdi
callq 0x1c55... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1be50
movq -0x98(%rbp), %rdx
leaq 0x234e96(%rip), %rsi # 0x31757e
leaq -0x38(%rbp), %rdi
callq 0x27890
jmp 0xe26f3
movq -0xa0(%rbp), %rsi
leaq -0x18(%rb... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isRadioButton() | bool
QPDFFormFieldObjectHelper::isRadioButton()
{
return ((getFieldType() == "/Btn") && ((getFlags() & ff_btn_radio) == ff_btn_radio));
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xe1440
movq -0x40(%rbp), %rdi
leaq 0x23489c(%rip), %rsi # 0x317538
callq 0x37320
movb %al, -0x35(%rbp)
jmp 0xe2ca6
movb -0x35(%rbp), %cl
xorl %eax, %eax
... | /qpdf[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
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x2f8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc52f0
leaq -0x51(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0x1be50
movq -0x2f0(%rbp), %rdx
leaq 0x23... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
(anonymous namespace)::TfFinder::TfFinder() | TfFinder() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x29030
movq -0x10(%rbp), %rdi
leaq 0x3ab194(%rip), %rax # 0x492578
addq $0x10, %rax
movq %rax, (%rdi)
movsd 0x231965(%rip), %xmm0 # 0x318d58
movsd %xmm0, 0x10(%rdi)
movl $0xffffffff, 0x18(%rdi) # i... | /qpdf[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFJob::PageSpec::PageSpec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::PageSpec::PageSpec(
std::string const& filename, char const* password, std::string const& range) :
filename(filename),
range(range)
{
if (password) {
this->password = QUtil::make_shared_cstr(password);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1b1c0
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
c... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::Members::Members() | QPDFJob::Members::Members() :
log(QPDFLogger::defaultLogger())
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x1b4fd0
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1be50
movq -0x30(%rbp), %rdi
movq -0x28... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::handlePageSpecs(QPDF&, std::vector<std::unique_ptr<QPDF, std::default_delete<QPDF>>, std::allocator<std::unique_ptr<QPDF, std::default_delete<QPDF>>>>&) | void
QPDFJob::handlePageSpecs(QPDF& pdf, std::vector<std::unique_ptr<QPDF>>& page_heap)
{
// Parse all page specifications and translate them into lists of actual pages.
// Handle "." as a shortcut for the input file
for (auto& page_spec: m->page_specs) {
if (page_spec.filename == ".") {
... | pushq %rbp
movq %rsp, %rbp
subq $0xde0, %rsp # imm = 0xDE0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xaa0(%rbp)
callq 0x115e80
addq $0x380, %rax # imm = 0x380
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1181d0
movq %rax, -0x28(... | /qpdf[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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xf2060
testb $0x1, %al
jne 0xf1cec
jmp 0xf1d6d
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x62e80
movq -0x98(%rbp), %rdi
callq 0x54c10
movq %rax, %... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::getExitCode() const | int
QPDFJob::getExitCode() const
{
if (m->check_is_encrypted) {
if (m->encryption_status & qpdf_es_encrypted) {
QTC::TC("qpdf", "QPDFJob check encrypted encrypted");
return 0;
} else {
QTC::TC("qpdf", "QPDFJob check encrypted not encrypted");
return EX... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x115e80
testb $0x1, 0x3ca(%rax)
je 0xf41eb
movq -0x18(%rbp), %rdi
callq 0x115e80
movq 0x38(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xf41ca
leaq 0x24312c(%rip), %rdi # 0x3372dc
leaq 0x22809e(... | /qpdf[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
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x48880
movq -0x158(%rbp), %rdi
callq 0x115e80
testb $0x1, 0x1f2(%rax)
je 0xf4e04
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
ca... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::parse_object_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&, int&, int&) | void
QPDFJob::parse_object_id(std::string const& objspec, bool& trailer, int& obj, int& gen)
{
if (objspec == "trailer") {
trailer = true;
} else {
trailer = false;
obj = QUtil::string_to_int(objspec.c_str());
size_t comma = objspec.find(',');
if ((comma != std::string::n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x243393(%rip), %rsi # 0x3397b6
callq 0x37320
testb $0x1, %al
jne 0xf642e
jmp 0xf643a
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0xf64fe
movq -0x10(%rbp)... | /qpdf[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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x48e30
movq -0x68(%rbp), %rdi
callq 0x115e80
addq $0x2c0, %rax # imm = 0x2C0
movq ... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONAcroform(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONAcroform(Pipeline* p, bool& first, QPDF& pdf)
{
JSON j_acroform = JSON::makeDictionary();
QPDFAcroFormDocumentHelper afdh(pdf);
j_acroform.addDictionaryMember("hasacroform", JSON::makeBool(afdh.hasAcroForm()));
j_acroform.addDictionaryMember("needappearances", JSON::makeBool(afdh.get... | pushq %rbp
movq %rsp, %rbp
subq $0xbb0, %rsp # imm = 0xBB0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2c6a0
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa4f40
jmp 0xfac9e
leaq... | /qpdf[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
movq %rsp, %rbp
subq $0x4a0, %rsp # imm = 0x4A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x328(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1b510
leaq -0x48(%rbp), %rdi
callq 0x116b90
movq -0x328(%rbp), %rdi
callq 0x115e80
testb $0x1, 0x318(%rax... | /qpdf[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
movq %rsp, %rbp
subq $0xc0, %rsp
movl %r9d, -0x9c(%rbp)
movl %r8d, %eax
movq %rcx, %r8
movl -0x9c(%rbp), %ecx
movq %r8, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movq %rsi, %r8
movq -0x98(%rbp), %rsi
movq %rdi, %r9
movq -0x90(%rbp), %rdi
movb %al, %dl
movb 0x10(%rbp), %al
movq %r9, -0x8(%rbp)
movq %r8, -0x10(%rbp)
... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::getUOPagenos(std::vector<QPDFJob::UnderOverlay, std::allocator<QPDFJob::UnderOverlay>>&, std::map<int, std::map<unsigned long, std::vector<int, std::allocator<int>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::vector<int, std::allocator<int>>>>>, std::less<int>, std::allocator<... | void
QPDFJob::getUOPagenos(
std::vector<QPDFJob::UnderOverlay>& uos,
std::map<int, std::map<size_t, std::vector<int>>>& pagenos)
{
size_t uo_idx = 0;
for (auto const& uo: uos) {
size_t page_idx = 0;
size_t from_size = uo.from_pagenos.size();
size_t repeat_size = uo.repeat_pagenos... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1179c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1179f0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp),... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::shouldRemoveUnreferencedResources(QPDF&) | bool
QPDFJob::shouldRemoveUnreferencedResources(QPDF& pdf)
{
if (m->remove_unreferenced_page_resources == QPDFJob::re_no) {
return false;
} else if (m->remove_unreferenced_page_resources == QPDFJob::re_yes) {
return true;
}
// Unreferenced resources are common in files where resources d... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x330(%rbp)
callq 0x115e80
cmpl $0x2, 0x150(%rax)
jne 0x1063d5
movb $0x0, -0x1(%rbp)
jmp 0x107060
movq -0x330(%rbp), %rdi
callq 0x115e80
cmpl $0x1, 0x150(%rax)
jne 0x106... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::setWriterOptions(QPDFWriter&) | void
QPDFJob::setWriterOptions(QPDFWriter& w)
{
if (m->compression_level >= 0) {
Pl_Flate::setCompressionLevel(m->compression_level);
}
if (m->qdf_mode) {
w.setQDFMode(true);
}
if (m->preserve_unreferenced_objects) {
w.setPreserveUnreferencedObjects(true);
}
if (m->ne... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x115e80
cmpl $0x0, 0x134(%rax)
jl 0x108c83
movq -0xe8(%rbp), %rdi
callq 0x115e80
movl 0x134(%rax), %edi
callq 0x544e0
movq -0xe8(%rbp), %rdi
callq 0x115e... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ImageOptimizer::evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool
ImageOptimizer::evaluate(std::string const& description)
{
// Note: passing nullptr as pipeline (first argument) just tests whether we can filter.
if (!image.pipeStreamData(nullptr, 0, decode_level, true)) {
QTC::TC("qpdf", "QPDFJob image optimize no pipeline");
o.doIfVerbose([&](Pipeline& ... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
movq %rax, %rdi
addq $0x38, %rdi
movl 0x30(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
xorl %r9d, %r9d
movl $0x1, %r8d
movl %r9d, %edx
callq 0x23b970
testb $... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::QPDFPageData::QPDFPageData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFPageData::QPDFPageData(std::string const& filename, QPDF* qpdf, std::string const& range) :
filename(filename),
qpdf(qpdf),
orig_pages(qpdf->getAllPages())
{
try {
this->selected_pages =
QUtil::parse_numrange(range.c_str(), QIntC::to_int(this->orig_pages.size()));
} catch (st... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1b1c0
movq -0xd8(%rbp), %rax
movq -0x18(%rbp... | /qpdf[P]qpdf/libqpdf/QPDFJob.cc |
QPDFObjectHandle::ParserCallbacks::ParserCallbacks() | class QPDF_DLL_CLASS ParserCallbacks
{
public:
virtual ~ParserCallbacks() = default;
// One of the handleObject methods must be overridden.
QPDF_DLL
virtual void handleObject(QPDFObjectHandle);
QPDF_DLL
virtual void handleObject(QPDFObjectHandle, size_t offset, ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x37b005(%rip), %rcx # 0x494928
addq $0x10, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| /qpdf[P]qpdf/include/qpdf/QPDFObjectHandle.hh |
(anonymous namespace)::ArgParser::argCopyright() | void
ArgParser::argCopyright()
{
// clang-format off
// Make sure the output looks right on an 80-column display.
// 1 2 3 4 5 6 7 8
// 12345678901234567890123456789012345678901234567890123456789012345678901234567890
*QPDFLog... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1b4fd0
movq -0x60(%rbp), %rdi
callq 0x69650
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
callq 0x1b50e0
jmp 0x13e0dd
le... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argShowCrypto() | void
ArgParser::argShowCrypto()
{
auto crypto = QPDFCryptoProvider::getRegisteredImpls();
std::string default_crypto = QPDFCryptoProvider::getDefaultProvider();
*QPDFLogger::defaultLogger()->getInfo() << default_crypto << "\n";
for (auto const& iter: crypto) {
if (iter != default_crypto) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd4f50
leaq -0x58(%rbp), %rdi
callq 0xd5040
jmp 0x13e423
leaq -0x88(%rbp), %rdi
callq 0x1b4fd0
jmp 0x13e431
leaq -0x88(%rbp), %rdi
callq 0x69650
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
callq 0x1b50e0
jmp 0x13e... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
(anonymous namespace)::ArgParser::argEncPositional(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
ArgParser::argEncPositional(std::string const& arg)
{
if (used_enc_password_args) {
usage("positional and dashed encryption arguments may not be mixed");
}
this->accumulated_args.push_back(arg);
if (this->accumulated_args.size() < 3) {
return;
}
user_password = this->accumu... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, 0xca(%rax)
je 0x14288b
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1be50
movq -0x78(%rbp), %rdx
leaq 0x1e01fd(%rip), %rsi # 0x322a29
leaq -0x30(%rbp), %rdi
callq... | /qpdf[P]qpdf/libqpdf/QPDFJob_argv.cc |
add_help_2(QPDFArgParser&) | static void add_help_2(QPDFArgParser& ap)
{
ap.addOptionHelp("--verbose", "general", "print additional information", R"(Output additional information about various things qpdf is
doing, including information about files created and operations
performed.
)");
ap.addOptionHelp("--progress", "general", "show progress when... | pushq %rbp
movq %rsp, %rbp
subq $0xe90, %rsp # imm = 0xE90
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xbb8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xbb0(%rbp)
callq 0x1be50
movq -0xbb0(%rbp), %rdx
leaq 0x1c06c3(%rip), %rsi # 0x32387b
leaq -0x28(%rbp), %rdi
callq 0x27890
jmp 0x1631c3
leaq -0... | /qpdf[P]qpdf/libqpdf/qpdf/auto_job_help.hh |
QPDFJob::Config::emptyInput() | QPDFJob::Config*
QPDFJob::Config::emptyInput()
{
if (o.m->infilename == nullptr) {
// Various places in QPDFJob.cc know that the empty string for infile means empty. We set it
// to something other than a null pointer as an indication that some input source has been
// specified. This approa... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq (%rax), %rdi
callq 0x115e80
movq %rax, %rdi
addq $0x3d0, %rdi # imm = 0x3D0
xorl %eax, %eax
movl %eax, %esi
callq 0x116460
testb $0x1, %al
jne 0x17443b
jmp 0x1744e3
leaq -0x39(%rbp), %rdi
movq ... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::outputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::outputFile(std::string const& filename)
{
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
o.m->outfilename = QUtil::make_shared_cstr(filename);
} else {
usage("output file has already been given");
}
return this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x115e80
movq %rax, %rdi
addq $0x3e0, %rdi # imm = 0x3E0
xorl %eax, %eax
movl %eax, %esi
callq 0x116460
testb $0x1, %al
jne 0x1745a9
jmp 0x1745f5
movq ... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::replaceInput() | QPDFJob::Config*
QPDFJob::Config::replaceInput()
{
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
o.m->replace_input = true;
} else {
usage("replace-input can't be used since output file has already been given");
}
return this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rdi
callq 0x115e80
movq %rax, %rdi
addq $0x3e0, %rdi # imm = 0x3E0
xorl %eax, %eax
movl %eax, %esi
callq 0x116460
testb $0x1, %al
jne 0x1746b5
jmp 0x1746df
movq -0x48(%rbp), %rax
movq ... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::collate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::collate(std::string const& parameter)
{
if (parameter.empty()) {
o.m->collate.push_back(1);
return this;
}
size_t pos = 0;
// Parse a,b,c
while (true) {
auto end = parameter.find(',', pos);
auto n = parameter.substr(pos, end);
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0x17493d
jmp 0x174977
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
callq 0x115e80
movq %rax, %rdi
addq $0x200, %rdi # im... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x115e80
movb $0x1, 0x189(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1ad4a8(%rip), %rsi # 0x32235a
callq 0x37320
testb $0x1, %al
jne 0x174ebd
jmp 0x174edd
movq -0x50(... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::json(std::string const& parameter)
{
if (parameter.empty() || (parameter == "latest")) {
o.m->json_version = JSON::LATEST;
} else {
o.m->json_version = QUtil::string_to_int(parameter.c_str());
}
if ((o.m->json_version < 1) || (o.m->json_version > JSON::L... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0x17521e
movq -0x10(%rbp), %rdi
leaq 0x1ad14e(%rip), %rsi # 0x322361
callq 0x37320
testb $0x1, %al
jne 0x17521e
jmp 0x175236
m... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::jsonStreamData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::jsonStreamData(std::string const& parameter)
{
o.m->json_stream_data_set = true;
if (parameter == "none") {
o.m->json_stream_data = qpdf_sj_none;
} else if (parameter == "inline") {
o.m->json_stream_data = qpdf_sj_inline;
} else if (parameter == "file") ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x115e80
movb $0x1, 0x2f4(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1a8e99(%rip), %rsi # 0x31e2bb
callq 0x37320
testb $0x1, %al
jne 0x17542d
jmp 0x175448
movq -0x50(... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::jsonOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::jsonOutput(std::string const& parameter)
{
o.m->json_output = true;
json(parameter);
if (!o.m->json_stream_data_set) {
// No need to set json_stream_data_set -- that indicates explicit use of --json-stream-data.
o.m->json_stream_data = qpdf_sj_inline;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rdi
callq 0x115e80
movq -0x60(%rbp), %rdi
movb $0x1, 0x3f1(%rax)
movq -0x10(%rbp), %rsi
callq 0x1751e0
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0x115e80
testb $0x1, 0... | /qpdf[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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x115e80
movb $0x1, 0x128(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1ae2fa(%rip), %rsi # 0x324afc
callq 0x37320
testb $0x1, %al
jne 0x17680d
jmp 0x176828
movq -0x50(... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::decodeLevel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::decodeLevel(std::string const& parameter)
{
o.m->decode_level_set = true;
if (parameter == "none") {
o.m->decode_level = qpdf_dl_none;
} else if (parameter == "generalized") {
o.m->decode_level = qpdf_dl_generalized;
} else if (parameter == "specialized"... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x115e80
movb $0x1, 0x140(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1a7979(%rip), %rsi # 0x31e2bb
callq 0x37320
testb $0x1, %al
jne 0x17694d
jmp 0x176968
movq -0x50(... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::EncConfig::modify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::EncConfig*
QPDFJob::EncConfig::modify(std::string const& parameter)
{
if (config->o.m->keylen == 40) {
config->o.m->r2_modify = (parameter == "y");
} else if (parameter == "all") {
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rax
movq (%rax), %rdi
callq 0x115e80
cmpl $0x28, 0x110(%rax)
jne 0x1792b1
movq -0x10(%rbp), %rdi
leaq 0x1a5473(%rip), %rsi # 0x31e6fa
callq 0x37320
movb %al, %cl
movq -0... | /qpdf[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::initializeFromJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void
QPDFJob::initializeFromJson(std::string const& json, bool partial)
{
std::list<std::string> errors;
JSON j = JSON::parse(json);
if (!j.checkSchema(JOB_SCHEMA, JSON::f_optional, errors)) {
std::ostringstream msg;
msg << m->message_prefix << ": job json has errors:";
for (auto con... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2d8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcbcf0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2eea0
jmp 0x17e20... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::Handlers(bool, std::shared_ptr<QPDFJob::Config>) | Handlers::Handlers(bool partial, std::shared_ptr<QPDFJob::Config> c_main) :
partial(partial),
c_main(c_main)
{
initHandlers();
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x70(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1b2fe0
movq -0x70(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, 0x18(... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addChoices(char const**, bool, std::function<void (char const*)>) | void
Handlers::addChoices(char const** choices, bool required, param_handler_t fn)
{
jh->addStringHandler(
[fn, choices, required, this](std::string const& path, std::string const& parameter) {
char const* p = parameter.c_str();
bool matches = false;
if ((!required) && (p... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rcx, -0xa8(%rbp)
movq %rsi, %rcx
movq -0xa8(%rbp), %rsi
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq ... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>) | void
Handlers::beginDict(json_handler_t start_fn, bare_handler_t end_fn)
{
jh->addDictHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); });
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1b4700
movq -0xb0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x197... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rsi, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x1b510
leaq -0x58(%rbp), %rdi
movq %rdi, -0x128(%rbp)
call... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginArray(std::function<void (JSON)>, std::function<void ()>) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0xe8(%rbp)
movq %rdx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b3190
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rsi
movq 0x... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::~$_0() | void
Handlers::addChoices(char const** choices, bool required, param_handler_t fn)
{
jh->addStringHandler(
[fn, choices, required, this](std::string const& path, std::string const& parameter) {
char const* p = parameter.c_str();
bool matches = false;
if ((!required) && (p... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::$_0($_0&&) | void
Handlers::addChoices(char const** choices, bool required, param_handler_t fn)
{
jh->addStringHandler(
[fn, choices, required, this](std::string const& path, std::string const& parameter) {
char const* p = parameter.c_str();
bool matches = false;
if ((!required) && (p... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b45a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::addParameter(std::function<void (char const*)>)::$_0::$_0($_0 const&) | void
Handlers::addChoices(char const** choices, bool required, param_handler_t fn)
{
jh->addStringHandler(
[fn, choices, required, this](std::string const& path, std::string const& parameter) {
char const* p = parameter.c_str();
bool matches = false;
if ((!required) && (p... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b44c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::setupReplaceInput()::$_0::operator()() const | 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x1737c0
movq %rax, %rdi
callq 0x174680
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::~$_1() | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcb370
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::$_1($_1&&) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b4670
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcbf80
addq $0x10, %rsp
popq %rbp
retq
nop
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginDict(std::function<void (JSON)>, std::function<void ()>)::$_1::$_1($_1 const&) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xcb750
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginUnderOverlay(JSON const&) | void
Handlers::beginUnderOverlay(JSON const& j)
{
// File has to be processed before items, so handle it here.
std::string file;
if (!j.getDictItem("file").getString(file)) {
QTC::TC("qpdf", "QPDFJob json over/under no file");
usage("file is required in underlay/overlay specification");
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1b510
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be50
movq -0xa8(%rbp), %rdx
leaq 0x181c8d(%rip),... | /qpdf[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::Members::Members() | QPDFLogger::Members::Members() :
p_discard(new Pl_Discard()),
p_real_stdout(new Pl_OStream("standard output", std::cout)),
p_stdout(new Pl_Track("track stdout", p_real_stdout.get())),
p_stderr(new Pl_OStream("standard error", std::cerr)),
p_info(p_stdout),
p_warn(nullptr),
p_error(p_stderr),... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x30, %edi
callq 0x1b250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x530c0
jmp 0x1b4b43
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1b5f70
movq -0x28(%... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
(anonymous namespace)::Pl_Track::Pl_Track(char const*, Pipeline*) | Pl_Track(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Track with nullptr as next");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4c1b0
movq -0x30(%rbp), %rax
leaq 0x2df614(%rip), %rcx # 0x494388
addq $0x10, %rcx
movq %rcx, (%rax)
movb ... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::throwIfNull(std::shared_ptr<Pipeline>, bool) | std::shared_ptr<Pipeline>
QPDFLogger::throwIfNull(std::shared_ptr<Pipeline> p, bool null_okay)
{
if (!(null_okay || p)) {
throw std::logic_error("QPDFLogger: requested a null pipeline without null_okay == true");
}
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1b526d
movq -0x48(%rbp), %rdi
callq 0x12b8... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setInfo(std::shared_ptr<Pipeline>) | void
QPDFLogger::setInfo(std::shared_ptr<Pipeline> p)
{
if (p == nullptr) {
if (m->p_save == m->p_stdout) {
p = m->p_stderr;
} else {
p = m->p_stdout;
}
}
m->p_info = p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x12aac0
testb $0x1, %al
jne 0x1b56e6
jmp 0x1b574c
movq -0x18(%... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setSave(std::shared_ptr<Pipeline>, bool) | void
QPDFLogger::setSave(std::shared_ptr<Pipeline> p, bool only_if_not_set)
{
if (only_if_not_set && (m->p_save != nullptr)) {
return;
}
if (m->p_save == p) {
return;
}
if (p == m->p_stdout) {
auto pt = dynamic_cast<Pl_Track*>(p.get());
if (pt->getUsed()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x40(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1b586d
movq -0x38(%rbp), %rdi
callq 0x1b60a0
movq %rax, %rdi
addq $0x70, %rdi
xorl ... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setOutputStreams(std::ostream*, std::ostream*) | void
QPDFLogger::setOutputStreams(std::ostream* out_stream, std::ostream* err_stream)
{
if (out_stream == &std::cout) {
out_stream = nullptr;
}
if (err_stream == &std::cerr) {
err_stream = nullptr;
}
std::shared_ptr<Pipeline> new_out;
std::shared_ptr<Pipeline> new_err;
if (o... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x2e1482(%rip), %rax # 0x496f18
cmpq %rax, -0x10(%rbp)
jne 0x1b5aa4
movq $0x0, -0x10(%rbp)
movq 0x2e14fd(%rip), %rax # 0x496fa8
cmpq %rax, -0x18(%rbp)
j... | /qpdf[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFMatrix::QPDFMatrix() | QPDFMatrix::QPDFMatrix() :
a(1.0),
b(0.0),
c(0.0),
d(1.0),
e(0.0),
f(0.0)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x16126c(%rip), %xmm0 # 0x318d70
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x161250(%rip), %xmm0 # 0x318d70
movsd %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::QPDFMatrix(QPDFObjectHandle::Matrix const&) | QPDFMatrix::QPDFMatrix(QPDFObjectHandle::Matrix const& m) :
a(m.a),
b(m.b),
c(m.c),
d(m.d),
e(m.e),
f(m.f)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rcx
... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::unparse[abi:cxx11]() const | std::string
QPDFMatrix::unparse() const
{
return (
QUtil::double_to_string(fix_rounding(a), 5) + " " +
QUtil::double_to_string(fix_rounding(b), 5) + " " +
QUtil::double_to_string(fix_rounding(c), 5) + " " +
QUtil::double_to_string(fix_rounding(d), 5) + " " +
QUtil::double_to_... | pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
movsd (%rax), %xmm0
callq 0x1b8160
leaq -0x150(%rbp), %rdi
movq %rdi, -0x208(%rbp)
movl $0x5, ... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.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.... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm2
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rcx
mulsd 0x8(%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x8(%rax), %xmm0
movq -0... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFMatrix::rotatex90(int) | void
QPDFMatrix::rotatex90(int angle)
{
switch (angle) {
case 90:
concat(QPDFMatrix(0, 1, -1, 0, 0, 0));
break;
case 180:
concat(QPDFMatrix(-1, 0, 0, -1, 0, 0));
break;
case 270:
concat(QPDFMatrix(0, -1, 1, 0, 0, 0));
break;
default:
// ignore
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa4(%rbp)
subl $0x5a, %eax
je 0x1b843e
jmp 0x1b841d
movl -0xa4(%rbp), %eax
subl $0xb4, %eax
je 0x1b8475
jmp 0x1b842c
movl -0xa4(%rbp), %eax
subl $0x10e,... | /qpdf[P]qpdf/libqpdf/QPDFMatrix.cc |
QPDFObjectHandle::Matrix::Matrix(double, double, double, double, double, double) | Matrix(double a, double b, double c, double d, double e, double f) :
a(a),
b(b),
c(c),
d(d),
e(e),
f(f)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd ... | /qpdf[P]qpdf/include/qpdf/QPDFObjectHandle.hh |
QPDFNameTreeObjectHelper::QPDFNameTreeObjectHelper(QPDFObjectHandle, QPDF&, bool) | QPDFNameTreeObjectHelper::QPDFNameTreeObjectHelper(QPDFObjectHandle oh, QPDF& q, bool auto_repair) :
QPDFObjectHelper(oh),
m(new Members(oh, q, auto_repair))
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x48940
movq -0x50(%rbp), %rdi
movq -... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::iterator::updateIValue() | void
QPDFNameTreeObjectHelper::iterator::updateIValue()
{
if (impl->valid()) {
auto p = *impl;
this->ivalue.first = p->first.getUTF8Value();
this->ivalue.second = p->second;
} else {
this->ivalue.first = "";
this->ivalue.second = QPDFObjectHandle();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x8, %rdi
callq 0x1bb090
movq %rax, %rdi
callq 0x41a20
testb $0x1, %al
jne 0x1b9c34
jmp 0x1b9d04
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bb0b0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::find(std::string const& key, bool return_prev_if_not_found)
{
auto i = m->impl->find(QPDFObjectHandle::newUnicodeString(key), return_prev_if_not_found);
return {std::make_shared<NNTreeIterator>(i)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1bb150
movq %rax, %rdi
callq 0x1bb170
movq %rax... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle) | QPDFNameTreeObjectHelper::iterator
QPDFNameTreeObjectHelper::insert(std::string const& key, QPDFObjectHandle value)
{
auto i = m->impl->insert(QPDFObjectHandle::newUnicodeString(key), value);
return {std::make_shared<NNTreeIterator>(i)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rcx, -0xe0(%rbp)
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1bb150
movq %rax, %rdi
callq 0x1bb170
movq %rax, -0x... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::findObject(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle&) | bool
QPDFNameTreeObjectHelper::findObject(std::string const& name, QPDFObjectHandle& oh)
{
auto i = find(name);
if (i == end()) {
return false;
}
oh = i->second;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rdi
xorl %ecx, %ecx
callq 0x1ba200
movq -0xc8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x1ba040
jmp 0x1ba676
leaq -0x68... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
(anonymous namespace)::NameTreeDetails::compareKeys(QPDFObjectHandle, QPDFObjectHandle) const | int
compareKeys(QPDFObjectHandle a, QPDFObjectHandle b) const override
{
if (!(keyValid(a) && keyValid(b))) {
// We don't call this without calling keyValid first
throw std::logic_error("comparing invalid keys");
}
auto as = a.getUTF8Va... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x48940
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq (%rdi)... | /qpdf[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFNameTreeObjectHelper::iterator::iterator(QPDFNameTreeObjectHelper::iterator const&) | class QPDF_DLL_PRIVATE iterator
{
friend class QPDFNameTreeObjectHelper;
public:
typedef std::pair<std::string, QPDFObjectHandle> T;
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = long;
using pointer = T... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x2d5961(%rip), %rax # 0x492430
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1bb020
movq -0x28(%rbp), %rdi
addq $0x18, ... | /qpdf[P]qpdf/include/qpdf/QPDFNameTreeObjectHelper.hh |
QPDFNumberTreeObjectHelper::QPDFNumberTreeObjectHelper(QPDFObjectHandle, QPDF&, bool) | QPDFNumberTreeObjectHelper::QPDFNumberTreeObjectHelper(
QPDFObjectHandle oh, QPDF& q, bool auto_repair) :
QPDFObjectHelper(oh),
m(new Members(oh, q, auto_repair))
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x48940
movq -0x50(%rbp), %rdi
movq -... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::iterator::updateIValue() | void
QPDFNumberTreeObjectHelper::iterator::updateIValue()
{
if (impl->valid()) {
auto p = *impl;
this->ivalue.first = p->first.getIntValue();
this->ivalue.second = p->second;
} else {
this->ivalue.first = 0;
this->ivalue.second = QPDFObjectHandle();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x8, %rdi
callq 0x1bb090
movq %rax, %rdi
callq 0x41a20
testb $0x1, %al
jne 0x1bd6b4
jmp 0x1bd766
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bb0b0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::find(long long, bool) | QPDFNumberTreeObjectHelper::iterator
QPDFNumberTreeObjectHelper::find(numtree_number key, bool return_prev_if_not_found)
{
auto i = m->impl->find(QPDFObjectHandle::newInteger(key), return_prev_if_not_found);
return {std::make_shared<NNTreeIterator>(i)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x1bed80
movq %rax, %rdi
callq 0x1bb170
movq %rax... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::getMax() | QPDFNumberTreeObjectHelper::numtree_number
QPDFNumberTreeObjectHelper::getMax()
{
auto i = last();
if (i == end()) {
return 0;
}
return i->first;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1bdb70
movq -0x88(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1bda90
jmp 0x1be0d5
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1bd870
movb %al, -0x89(%rbp)
jmp 0x1be0ea... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::findObjectAtOrBelow(long long, QPDFObjectHandle&, long long&) | bool
QPDFNumberTreeObjectHelper::findObjectAtOrBelow(
numtree_number idx, QPDFObjectHandle& oh, numtree_number& offset)
{
auto i = find(idx, true);
if (i == end()) {
return false;
}
oh = i->second;
QIntC::range_check_subtract(idx, i->first);
offset = idx - i->first;
return true;
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movl $0x1, %ecx
callq 0x1bdc50
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1bda90
... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.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.