name string | code string | asm string | file string |
|---|---|---|---|
NNTreeIterator::NNTreeIterator(NNTreeImpl&) | NNTreeIterator::NNTreeIterator(NNTreeImpl& impl) :
impl(impl),
item_number(-1)
{
} | leaq 0x1c01b1(%rip), %rax # 0x1eb0e8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::getNextKid(NNTreeIterator::PathElement&, bool) | QPDFObjectHandle
NNTreeIterator::getNextKid(PathElement& pe, bool backward)
{
QPDFObjectHandle result;
bool found = false;
while (!found) {
pe.kid_number += backward ? -1 : 1;
auto kids = pe.node.getKey("/Kids");
if ((pe.kid_number >= 0) && (pe.kid_number < kids.getArrayNItems())) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
negl %r13d
orl $0x1, %r13d
leaq 0x10(%rsp), %r12
movq %rsp, %r15
movq %rdi, 0x20(%rsp)
movl %r13d, 0x2c(%rsp)
addl %r13d, 0x10... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::insertAfter(QPDFObjectHandle, QPDFObjectHandle) | void
NNTreeIterator::insertAfter(QPDFObjectHandle key, QPDFObjectHandle value)
{
if (!valid()) {
QTC::TC("qpdf", "NNTree insertAfter inserts first");
impl.insertFirst(key, value);
deepen(impl.oh, true, false);
return;
}
auto items = this->node.getKey(impl.details.itemsKey())... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
js 0x2db8e
leaq 0x28(%rbx), %r15
movq 0x8(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xfc... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::withinLimits(QPDFObjectHandle, QPDFObjectHandle) | int
NNTreeImpl::withinLimits(QPDFObjectHandle key, QPDFObjectHandle node)
{
int result = 0;
auto limits = node.getKey("/Limits");
if (limits.isArray() && (limits.getArrayNItems() >= 2) &&
details.keyValid(limits.getArrayItem(0)) && details.keyValid(limits.getArrayItem(1))) {
if (details.comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x130ce8(%rip), %rsi # 0x15f61a
leaq 0x130ce8(%rip), %rdx # 0x15f621
leaq 0x18(%rsp), %rdi
callq 0x1df30
leaq 0x8(%rsp), %rdi
leaq 0x... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::find(QPDFObjectHandle, bool) | NNTreeImpl::iterator
NNTreeImpl::find(QPDFObjectHandle key, bool return_prev_if_not_found)
{
try {
return findInternal(key, return_prev_if_not_found);
} catch (QPDFExc& e) {
if (this->auto_repair) {
QTC::TC("qpdf", "NNTree repair");
warn(qpdf, this->oh, std::string("attem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x2fb52
movq 0x1c143c(%rip), %rdx # 0x1f0f80
cmpb $0x0, (%rdx)
je 0x2fb4e
incl 0x8(... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::findInternal(QPDFObjectHandle, bool) | NNTreeImpl::iterator
NNTreeImpl::findInternal(QPDFObjectHandle key, bool return_prev_if_not_found)
{
auto first_item = begin();
auto last_item = end();
if (first_item == end()) {
// Empty
return end();
} else if (
first_item.valid() && details.keyValid(first_item->first) &&
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %ecx, 0x1c(%rsp)
movq %rdx, 0x68(%rsp)
movq %rsi, %r13
movq %rdi, %r12
leaq 0x1a8(%rsp), %r14
movq %r14, %rdi
callq 0x2e74c
leaq 0x1bb35f(%rip), %r15 # 0x1eb0e8
leaq 0x158(%rsp), %rbx
movq %r15, -0x10(%r... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
Pipeline::getIdentifier[abi:cxx11]() const | std::string
Pipeline::getIdentifier() const
{
return this->identifier;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x1f3a6
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pl_AES_PDF::initializeVector() | void
Pl_AES_PDF::initializeVector()
{
if (use_zero_iv) {
for (unsigned int i = 0; i < this->buf_size; ++i) {
this->cbc_block[i] = 0;
}
} else if (use_specified_iv) {
std::memcpy(this->cbc_block, this->specified_iv, this->buf_size);
} else if (use_static_iv) {
for ... | cmpb $0x1, 0xa0(%rdi)
jne 0x32764
xorps %xmm0, %xmm0
jmp 0x32774
cmpb $0x1, 0xa1(%rdi)
jne 0x3277c
movups 0x90(%rdi), %xmm0
movups %xmm0, 0x80(%rdi)
retq
subq $-0x80, %rdi
cmpb $0x1, 0x1bf95c(%rip) # 0x1f20e3
jne 0x32794
movaps 0x12d090(%rip), %xmm0 # 0x15f820
movups %xmm0, (%rdi)
retq
movl $0x10, %esi
jmp 0x141ea... | /jberkenbilt[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::~Pl_AES_PDF() | ~Pl_AES_PDF() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x327b0
callq 0x193d0
movq $0x0, 0x50(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x327c6
callq 0x1fc74
leaq 0x1b8853(%rip), %rax # 0x1eb020
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x327e9
movq (%rbx), %rsi
in... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_AES_PDF.hh |
Pl_ASCII85Decoder::Pl_ASCII85Decoder(char const*, Pipeline*) | Pl_ASCII85Decoder::Pl_ASCII85Decoder(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_ASCII85Decoder with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x318fc
leaq 0x1b8855(%rip), %rax # 0x1eb1d0
movq %rax, (%rbx)
movl $0x75757575, 0x30(%rbx) # imm = 0x75757575
movb $0x75, 0x34(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movb $0x0, 0x48(%rbx)
testq %r14, %r14
je 0x3299f
popq %rbx
popq %r1... | /jberkenbilt[P]qpdf/libqpdf/Pl_ASCII85Decoder.cc |
Pl_ASCIIHexDecoder::flush() | void
Pl_ASCIIHexDecoder::flush()
{
if (this->pos == 0) {
QTC::TC("libtests", "Pl_ASCIIHexDecoder no-op flush");
return;
}
int b[2];
for (int i = 0; i < 2; ++i) {
if (this->inbuf[i] >= 'A') {
b[i] = this->inbuf[i] - 'A' + 10;
} else {
b[i] = this->i... | cmpq $0x0, 0x38(%rdi)
je 0x32f1e
pushq %rax
movb 0x30(%rdi), %al
movb 0x31(%rdi), %cl
cmpb $0x41, %al
movl $0x9, %edx
movl $0x40, %r8d
cmovgel %edx, %r8d
addb %al, %r8b
cmpb $0x41, %cl
movl $0xc9, %eax
movl $0xd0, %edx
cmovgel %eax, %edx
addb %cl, %dl
shlb $0x4, %r8b
addb %dl, %r8b
leaq 0x7(%rsp), %rsi
movb %r8b, (%rsi... | /jberkenbilt[P]qpdf/libqpdf/Pl_ASCIIHexDecoder.cc |
Pl_Base64::write(unsigned char const*, unsigned long) | void
Pl_Base64::write(unsigned char const* data, size_t len)
{
if (finished) {
throw std::logic_error("Pl_Base64 used after finished");
}
if (this->action == a_decode) {
decode(data, len);
} else {
encode(data, len);
}
} | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x41(%rdi)
je 0x33038
cmpl $0x1, 0x30(%rdi)
jne 0x3302c
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3307e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x330e4
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x12ca55(%rip), %rsi # 0x15faa1
movq %rax, %rdi
callq 0x19970
movq 0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::decode(unsigned char const*, unsigned long) | void
Pl_Base64::decode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
if (!util::is_space(to_c(*p))) {
this->buf[this->pos++] = *p;
if (this->pos == 4) {
flush();
}
}
++p;
--len;
}
... | testq %rdx, %rdx
je 0x330e2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x330b0
incq %r12
cmpq %r12, %rbx
jne 0x33097
jmp 0x330d7
cmpl $0x20, %ecx
je 0x330a6
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::encode(unsigned char const*, unsigned long) | void
Pl_Base64::encode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
this->buf[this->pos++] = *p;
if (this->pos == 3) {
flush();
}
++p;
--len;
}
} | testq %rdx, %rdx
je 0x33134
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movq 0x38(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%r15)
movb %al, 0x34(%r15,%rcx)
cmpq $0x3, 0x38(%r15)
jne 0x33121
movq %r15, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::flush_encode() | void
Pl_Base64::flush_encode()
{
int outval = ((this->buf[0] << 16) | (this->buf[1] << 8) | (this->buf[2]));
unsigned char out[4] = {
to_uc(outval >> 18),
to_uc(0x3f & (outval >> 12)),
to_uc(0x3f & (outval >> 6)),
to_uc(0x3f & outval),
};
for (size_t i = 0; i < 4; ++i) {
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x34(%rdi), %eax
movl %eax, %ecx
shll $0x10, %ecx
movzbl 0x35(%rdi), %edx
shll $0x8, %edx
movzbl 0x36(%rdi), %esi
movl %esi, %edi
orl %edx, %edi
orl %ecx, %edx
shrb $0x2, %al
movb %al, 0xc(%rsp)
shrl $0xc, %edx
andb $0x3f, %dl
movb %dl, 0xd(%rsp)
shrl $0x6, %edi
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::~Pl_Base64() | ~Pl_Base64() final = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b7a6b(%rip), %rax # 0x1eb020
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x335d0
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_Base64.hh |
Pl_Buffer::~Pl_Buffer() | Pl_Buffer::~Pl_Buffer() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b7ae7(%rip), %rax # 0x1eb2a8
movq %rax, (%rdi)
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x337d6
leaq 0x30(%rbx), %rdi
callq 0x33a90
movq $0x0, 0x30(%rbx)
leaq 0x1b783b(%rip), %rax # 0x1eb020
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x33801
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_Buffer.cc |
Pl_Count::Pl_Count(char const*, Pipeline*) | Pl_Count::Pl_Count(char const* identifier, Pipeline* next) :
Pipeline(identifier, next),
m(std::make_unique<Members>())
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Count with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x318fc
leaq 0x1b76c1(%rip), %rax # 0x1eb388
movq %rax, (%rbx)
movl $0x10, %edi
callq 0x19180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x30(%rbx)
testq %r14, %r14
je 0x33ce9
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x19... | /jberkenbilt[P]qpdf/libqpdf/Pl_Count.cc |
QIntC::IntConverter<int, unsigned int, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19b00
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b50
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
Pl_Function::Pl_Function(char const*, Pipeline*, std::function<void (unsigned char const*, unsigned long)>) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_t fn) :
Pipeline(identifier, next),
m(std::make_unique<Members>(fn))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdi, %rbx
callq 0x318fc
leaq 0x1b56ed(%rip), %rax # 0x1eb548
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x19180
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
callq 0x366ce
movq %rsp, %rsi
movq %r14, %rdi
callq 0x366ce
movq %r14, 0x30(%rbx)
movq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_Function::Pl_Function(char const*, Pipeline*, int (*)(char const*, unsigned long, void*), void*) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_c_char_t fn, void* udata) :
Pipeline(identifier, next),
m(new Members(nullptr))
{
m->fn = [identifier, fn, udata](unsigned char const* data, size_t len) {
int code = fn(reinterpret_cast<char const*>(data), len, udata);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x318fc
leaq 0x1b54a8(%rip), %rax # 0x1eb548
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x19180
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_MD5::~Pl_MD5() | ~Pl_MD5() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x37458
callq 0x1fc74
leaq 0x1b3bc1(%rip), %rax # 0x1eb020
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3747b
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_MD5.hh |
Pl_OStream::~Pl_OStream() | Pl_OStream::~Pl_OStream() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b413b(%rip), %rax # 0x1eb640
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x3751b
movl $0x8, %esi
callq 0x190e0
movq $0x0, 0x30(%rbx)
leaq 0x1b3af6(%rip), %rax # 0x1eb020
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x37546
movq (%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_OStream.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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x37a18
movq 0x40(%rbx), %rax
movzbl (%rax), %edx
decl %edx
cmpl $0x3, %edx
ja 0x37a18
leaq 0x128aa4(%rip), %rsi # 0x160450
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
cmpl $0x0, 0x34(%rbx)
je 0x37a18
movl 0x38(%rbx), %ecx
movl %ecx, %edx... | /jberkenbilt[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 = ... | cmpl $0x0, 0x34(%rdi)
je 0x37adb
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movl 0x38(%rdi), %edx
movl %edx, %esi
negl %esi
xorl %r8d, %r8d
cmpq %rdx, %r8
jae 0x37ab0
xorl %r9d, %r9d
jmp 0x37aba
leal (%rsi,%r8), %r9d
movzbl 0x1(%rax,%r9), %r9d
movzbl 0x1(%rcx,%r8), %r10d
movzwl %r9w, %r9d
addl %r10d, %r9d
shrl %r9d
ad... | /jberkenbilt[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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq %rcx, %rdx
callq 0x318fc
leaq 0x1b3a53(%rip), %rax # 0x1eb6d0
movq %rax, (%rbx)
movl $0x48, %edi
callq 0x19180
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0,... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_QPDFTokenizer::finish() | void
Pl_QPDFTokenizer::finish()
{
m->buf.finish();
auto input = BufferInputSource("tokenizer data", m->buf.getBuffer(), true);
std::string empty;
while (true) {
auto token = m->tokenizer.readToken(input, empty, true);
m->filter->handleToken(token);
if (token.getType() == QPDFToke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $0x10, %rdi
callq 0x33866
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12875b(%rip), %rsi # 0x160566
leaq 0x128762(%rip), %rdx # 0x160574
leaq 0x50(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.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 0x38a8b
movq 0x1b96bd(%rip), %rax # 0x1f2128
testq %rax, %rax
je 0x38a79
cmpq %rax, 0x98(%rsi)
ja 0x38abc
movq 0x28(%rbx), %rdi
addq $0x90, %rsi
callq 0x31a28
jmp 0x38aaa
movq %rbx, %rdi
callq 0x38962
leaq 0x7(%rsp), %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_StdioFile::Pl_StdioFile(char const*, _IO_FILE*) | Pl_StdioFile::Pl_StdioFile(char const* identifier, FILE* f) :
Pipeline(identifier, nullptr),
m(std::make_unique<Members>(f))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x318fc
leaq 0x1b297c(%rip), %rax # 0x1eb7f0
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x19180
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x1b2186(%rip), %rax # 0x1eb020
... | /jberkenbilt[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdx, %r12
movq %rdi, %rbx
movl 0x40(%rsp), %r13d
callq 0x318fc
leaq 0x1b2699(%rip), %rax # 0x1eb880
movq %rax, (%rbx)
movl %r15d, 0x30(%rbx)
movl %r14d, 0x34(%rbx)
movl %ebp, 0x3c(%rbx... | /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 0x398a8
cmpl $0x8, 0x40(%rbx)
jne 0x3953e
movq 0x78(%rbx), %rdx
cmpq %rdx, 0x80(%rbx)
je 0x394ad
movq %rdx, 0x80(%rbx)
... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.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 0x3f1b8
movq (%rax), %rcx
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x3a0ce
movq 0x1b6ebc(%rip), %rax # 0x1f0f80
cmpb $0x0, (%rax)
... | /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 0x19180
movq %rax, %r14
movq %rax, %rdi
callq 0x3a3aa
movq %r14, (%rbx)
addq $0x18, %r14
movq %r14, %rdi
callq 0xe216e
movl $0x1, %eax
lock
xaddq %rax, 0x1b78f4(%rip) # 0x1f2160
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
p... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::registerStreamFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<std::shared_ptr<QPDFStreamFilter> ()>) | void
QPDF::registerStreamFilter(
std::string const& filter_name, std::function<std::shared_ptr<QPDFStreamFilter>()> factory)
{
qpdf::Stream::registerStreamFilter(filter_name, factory);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3f406
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfda22
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3ad67
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x3ad95... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::getWarnings() | std::vector<QPDFExc>
QPDF::getWarnings()
{
std::vector<QPDFExc> result = m->warnings;
m->warnings.clear();
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x270, %esi # imm = 0x270
addq (%r14), %rsi
callq 0x3f464
movq (%r14), %r15
movq 0x270(%r15), %r12
movq 0x278(%r15), %r13
cmpq %r12, %r13
je 0x3aed3
movq %r12, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
sub... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::newReserved() | QPDFObjectHandle
QPDF::newReserved()
{
return makeIndirectFromQPDFObject(QPDFObject::create<QPDF_Reserved>());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x70, %edi
callq 0x19180
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x1b05e8(%rip), %rcx # 0x1ebaf0
movq %rcx, (%rax)
movb $0x1, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%r... | /jberkenbilt[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
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
callq 0x3daac
movl %eax, %ebx
leaq 0x1233fc(%rip), %rsi # 0x160c99
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movl $0x10, %edx
callq 0x3fa88
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq (%r14), %rax... | /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 0x3e244
movq 0x1b2d49(%rip), %rdx # 0x1f0f80
cmpb $0x0, (%rdx)
je 0x3e240
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDF::EncryptionParameters::EncryptionParameters() | EncryptionParameters() = default; | xorl %eax, %eax
movw %ax, (%rdi)
movq %rax, 0x4(%rdi)
movb $0x1, 0xc(%rdi)
leaq 0x18(%rdi), %rcx
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movl %eax, 0x48(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
mov... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDF_private.hh |
qpdf::Stream::getStreamDataProvider() const | std::shared_ptr<QPDFObjectHandle::StreamDataProvider>
getStreamDataProvider() const
{
return stream()->stream_provider;
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4026c
movq 0x30(%rax), %rcx
movq %rcx, (%rbx)
movq 0x38(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3fa83
movq 0x1b150b(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x3fa7f
incl 0x8(%rax)
jmp 0x3fa83
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFAcroFormDocumentHelper::getFormFields() | std::vector<QPDFFormFieldObjectHelper>
QPDFAcroFormDocumentHelper::getFormFields()
{
analyze();
std::vector<QPDFFormFieldObjectHelper> result;
for (auto const& iter: m->field_to_annotations) {
result.emplace_back(qpdf.getObject(iter.first));
}
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4f844
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x10(%r14), %r13
movq 0x20(%r13), %r15
addq $0x10, %r13
cmpq %r13, %r15
je 0x52207
movq %rsp, %r12
movq 0x8(%r14), %rsi... | /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 $0x98, %rsp
movl %r8d, %r14d
movl %edx, %r12d
movl %r12d, %eax
orb %r14b, %al
cmpb $0x1, %al
jne 0x535ae
movl %r9d, %ebp
movq %rcx, %r15
movq %rsi, %rbx
movq (%rsi), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %... | /jberkenbilt[P]qpdf/libqpdf/QPDFAcroFormDocumentHelper.cc |
QPDFAnnotationObjectHelper::getSubtype[abi:cxx11]() | std::string
QPDFAnnotationObjectHelper::getSubtype()
{
return oh().getKey("/Subtype").getName();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5c0ac
movq 0x194ee2(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5c0a8
incl 0x8(%rax)
jmp 0x5c0ac
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %r14
movq %r14, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
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 0x5c386
movq 0x194c08(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x5c382
incl 0x8(%rax)
jmp 0x5c386
lock
incl 0x8(%ra... | /jberkenbilt[P]qpdf/libqpdf/QPDFAnnotationObjectHelper.cc |
QPDFArgParser::registerOptionTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<void ()>) | void
QPDFArgParser::registerOptionTable(std::string const& name, bare_arg_handler_t end_handler)
{
if (0 != m->option_tables.count(name)) {
QTC::TC("libtests", "QPDFArgParser register registered table");
throw std::logic_error(
"QPDFArgParser: registering already registered option table ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0xe8(%r12), %rdi
callq 0x6267e
addq $0xf0, %r12
cmpq %r12, %rax
jne 0x5e227
movl $0xe8, %edi
addq (%rbx), %rdi
movq %r15, %rsi
callq 0x61c58
movq %rbx, %rdi
movq %r15, %rsi
call... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::getAllHelp(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFArgParser::getAllHelp(std::ostringstream& msg)
{
getTopHelp(msg);
auto show = [this, &msg](std::map<std::string, HelpTopic>& topics) {
for (auto const& i: topics) {
auto const& topic = i.first;
msg << std::endl
<< "== " << topic << " (" << i.second.short_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x61628
movq %rsp, %r15
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
movl $0x210, %esi # imm = 0x210
addq (%r14), %rsi
movq %r15, %rdi
callq 0x61934
movl $0x240, %esi # imm = 0x240
addq (%r14), %rsi
movq %r15, %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFArgParser.cc |
QPDFArgParser::HelpTopic::~HelpTopic() | HelpTopic() = default; | pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x590fc
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x61f43
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x61f5b
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFArgParser.hh |
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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x63cc2
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x63f15
movups (%r14), %xmm1
addq $0x10, %r14
movaps %xmm1, (%rsp)
movq %r15... | /jberkenbilt[P]qpdf/libqpdf/QPDFCryptoProvider.cc |
QPDFFileSpecObjectHelper::createFileSpec(QPDF&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFEFStreamObjectHelper) | QPDFFileSpecObjectHelper
QPDFFileSpecObjectHelper::createFileSpec(
QPDF& qpdf, std::string const& filename, QPDFEFStreamObjectHelper efsoh)
{
auto oh = qpdf.makeIndirectObject(QPDFObjectHandle::newDictionary());
oh.replaceKey("/Type", QPDFObjectHandle::newName("/Filespec"));
QPDFFileSpecObjectHelper res... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x70(%rsp), %r13
movq %r13, %rdi
callq 0xc90e6
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x131040
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x682be
callq 0x1fc74... | /jberkenbilt[P]qpdf/libqpdf/QPDFFileSpecObjectHelper.cc |
QPDFFormFieldObjectHelper::getFullyQualifiedName[abi:cxx11]() | std::string
QPDFFormFieldObjectHelper::getDefaultAppearance()
{
auto value = getInheritableFieldValue("/DA");
bool looked_in_acroform = false;
if (!value.isString()) {
value = getFieldFromAcroForm("/DA");
looked_in_acroform = true;
}
std::string result;
if (value.isString()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, (%rsp)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x69682
movq 0x18790c(%rip), ... | /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 0xf93fb(%rip), %rsi # 0x16359d
leaq 0xf93f7(%rip), %rdx # 0x1635a0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1df30
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isChecked() | bool
QPDFFormFieldObjectHelper::isChecked()
{
return isCheckbox() && getValue().isName() && (getValue().getName() != "/Off");
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x6a6d0
testb %al, %al
je 0x6a7eb
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x69fdc
movq %r14, %rdi
callq 0xc312c
testb %al, %al
je 0x6a7ef
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x69fdc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::isPushbutton() | bool
QPDFFormFieldObjectHelper::isPushbutton()
{
return ((getFieldType() == "/Btn") && ((getFlags() & ff_btn_pushbutton) == ff_btn_pushbutton));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x695a2
leaq 0xf79e1(%rip), %rsi # 0x1622c6
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0x6a8f5
xorl %ebx, %ebx
jmp 0x6a905
movq %rbx, %rdi
callq 0x6a5bc
movl %eax, %ebx
shrl $0x10, %ebx
andl $0x1... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFJob::doSplitPages(QPDF&) | void
QPDFJob::doSplitPages(QPDF& pdf)
{
// Generate output file pattern
std::string before;
std::string after;
size_t len = strlen(m->outfilename.get());
char* num_spot = strstr(const_cast<char*>(m->outfilename.get()), "%d");
if (num_spot != nullptr) {
QTC::TC("qpdf", "QPDFJob split-page... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, 0x100(%rsp)
leaq 0x150(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x130(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONOutlines(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONOutlines(Pipeline* p, bool& first, QPDF& pdf)
{
std::map<QPDFObjGen, int> page_numbers;
int n = 0;
for (auto const& ph: QPDFPageDocumentHelper(pdf).getAllPages()) {
QPDFObjectHandle oh = ph.getObjectHandle();
page_numbers[oh.getObjGen()] = ++n;
}
JSON j_outlines ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
leaq 0x90(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x10(%rsp), %rdi
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
(anonymous namespace)::ArgParser::argEndCopyAttachment() | void
ArgParser::argEndCopyAttachment()
{
c_copy_att->endCopyAttachmentsFrom();
c_copy_att = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xa63a2
xorps %xmm0, %xmm0
movq 0x28(%rbx), %rdi
movups %xmm0, 0x20(%rbx)
testq %rdi, %rdi
je 0x97e27
popq %rbx
jmp 0x1fc74
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_argv.cc |
QPDFJob::Config::jobJsonFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::jobJsonFile(std::string const& parameter)
{
try {
o.initializeFromJson(QUtil::read_file_into_string(parameter.c_str()), true);
} catch (std::exception& e) {
throw std::runtime_error(
"error with job-json file " + std::string(parameter) + ": " + e.wha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq (%rdi), %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x142517
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0xa9828
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
(anonymous namespace)::Handlers::endPagesArray() | void
Handlers::endPagesArray()
{
c_pages->endPages();
c_pages = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0xa6b82
xorps %xmm0, %xmm0
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0xb4d67
popq %rbx
jmp 0x1fc74
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::endOverlay() | void
Handlers::endOverlay()
{
c_uo->endUnderlayOverlay();
c_uo = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0xa6f9e
xorps %xmm0, %xmm0
movq 0x70(%rbx), %rdi
movups %xmm0, 0x68(%rbx)
testq %rdi, %rdi
je 0xb4f65
popq %rbx
jmp 0x1fc74
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFNameTreeObjectHelper::Members::Members(QPDFObjectHandle&, QPDF&, bool) | QPDFNameTreeObjectHelper::Members::Members(QPDFObjectHandle& oh, QPDF& q, bool auto_repair) :
impl(std::make_shared<NNTreeImpl>(name_tree_details, q, oh, auto_repair))
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq $0x0, (%rdi)
movl $0x40, %edi
callq 0x19180
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x132753(%rip), %rax # 0x1ee790
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xbc0be
movq 0x134ecc(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0xbc0e1
incl 0x8(%rdi)
jmp 0xbc0ea
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFNameTreeObjectHelper.cc |
QPDFObjectHandle::getValueAsInlineImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | bool
QPDFObjectHandle::getValueAsInlineImage(std::string& value) const
{
if (!isInlineImage()) {
return false;
}
value = obj->getStringValue();
return true;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0xc320a
movl %eax, %ebx
testb %al, %al
je 0xc41a5
movq (%r15), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0xc260a
movq %r14, %rdi
movq %r15, %rsi
callq 0x195c0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xc41a5
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFObjectHandle.cc |
(anonymous namespace)::InlineImageTracker::~InlineImageTracker() | ~InlineImageTracker() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x11880f(%rip), %rax # 0x1eef08
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xd6714
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xd672c
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x28... | /jberkenbilt[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFWriter::unparseObject(QPDFObjectHandle, int, int, unsigned long, bool) | void
QPDFWriter::unparseObject(
QPDFObjectHandle object, int level, int flags, size_t stream_length, bool compress)
{
QPDFObjGen old_og = object.getObjGen();
int child_flags = flags & ~f_stream;
if (level < 0) {
throw std::logic_error("invalid level in QPDFWriter::unparseObject");
}
// F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movl %r9d, 0x1c4(%rsp)
movq %r8, 0x1b8(%rsp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rsi, %rdi
callq 0xc5460
movq %r12, 0x138(%rsp)
testl %r12d, %r12d
js 0xebda5
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFXRefEntry::getObjStreamNumber() const | int
QPDFXRefEntry::getObjStreamNumber() const
{
if (this->type != 2) {
throw std::logic_error("getObjStreamNumber called for xref entry of type != 2");
}
return QIntC::to_int(this->field1);
} | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, (%rdi)
jne 0xf9040
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq %eax, %rcx
cmpq %rax, %rcx
je 0xf9038
movq %rax, %rdi
callq 0x6fb00
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
leaq 0x832d9(%rip), %rsi # 0x17c... | /jberkenbilt[P]qpdf/libqpdf/QPDFXRefEntry.cc |
qpdf::Array::crbegin() | Array::const_reverse_iterator
Array::crbegin()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.crbegin();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->crbe... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfb56e
testq %rax, %rax
je 0xf969a
cmpq $0x0, (%rax)
je 0xf969e
movq 0x10(%r14), %rax
testq %rax, %rax
jne 0xf9694
movq %rsp, %rdi
movq %r14, %rsi
callq 0xf92f2
movl $0x18, %edi
callq 0x19180
addq $0x10, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::size() const | int
Array::size() const
{
auto a = array();
return a->sp ? a->sp->size : int(a->elements.size());
} | pushq %rax
callq 0xf91e8
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
je 0xf97cf
movl (%rax), %eax
jmp 0xf97db
movq 0x10(%rcx), %rax
subq 0x8(%rcx), %rax
shrq $0x4, %rax
popq %rcx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::setFilterOnWrite(bool) | void
QPDFObjectHandle::setFilterOnWrite(bool val)
{
as_stream(error).setFilterOnWrite(val);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10030f
movzbl 0x30(%rdi), %eax
cmpl $0xf, %eax
je 0x1002da
cmpl $0xd, %eax
jne 0x1002e5
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
movq %rax, %rdi
callq 0x12be52
jmp 0x1002df
callq 0x4008f
movq (%rax), %rax
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
check_user_password_V5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_user_password_V5(std::string const& user_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.11 from the PDF 1.7 extension level 3
std::string user_data = data.getU().substr(0, 32);
std::string validation_salt = data.getU().substr(32, 8);
std::string password = truncate_passw... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %r15
leaq 0x20(%rsp), %rdi
movl $0x20, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x19b70
leaq 0x80(%rsp), %rdi
movl $0x20, %edx
movl $0x8, %ecx
movq %r15, %rsi
callq 0x19b70
movq 0x8(%r14), %rax
cmpq $0x7f, %rax
movl $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::lengthNextN(int, int) | int
QPDF::lengthNextN(int first_object, int n)
{
int length = 0;
for (int i = 0; i < n; ++i) {
QPDFObjGen og(first_object + i, 0);
if (m->xref_table.count(og) == 0) {
linearizationWarning(
"no xref table entry for " + std::to_string(first_object + i) + " 0");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x80(%rsp)
movl %edx, 0x34(%rsp)
testl %edx, %edx
jle 0x119e7d
movq %rdi, %r15
leaq 0x20(%rsp), %r14
movq $0x0, (%rsp)
leaq 0x8(%rsp), %rbp
xorl %r13d, %r13d
movq %rdi, 0x38(%rsp)
movq 0x80(%rsp), %rax
leal (%rax,%r13), %r12d
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::replaceReserved(QPDFObjectHandle, QPDFObjectHandle) | void
QPDF::replaceReserved(QPDFObjectHandle reserved, QPDFObjectHandle replacement)
{
QTC::TC("qpdf", "QPDF replaceReserved");
auto tc = reserved.getTypeCode();
if (!(tc == ::ot_reserved || tc == ::ot_null)) {
throw std::logic_error("replaceReserved called with non-reserved object");
}
repla... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xc2710
decl %eax
cmpl $0x2, %eax
jae 0x131618
movq %r15, %rdi
callq 0xc5460
movq (%r14), %rcx
movq %rcx, (%rsp)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x1315f1
movq 0xbf99d(%ri... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::pushInheritedAttributesToPageInternal(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocato... | void
QPDF::pushInheritedAttributesToPageInternal(
QPDFObjectHandle cur_pages,
std::map<std::string, std::vector<QPDFObjectHandle>>& key_ancestors,
bool allow_changes,
bool warn_skipped_keys)
{
// Make a list of inheritable keys. Only the keys /MediaBox, /CropBox, /Resources, and /Rotate
// are i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %r8d, %r15d
movl %ecx, 0xc(%rsp)
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, 0x40(%rsp)
leaq 0x100(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::addPage(QPDFObjectHandle, bool) | void
QPDF::addPage(QPDFObjectHandle newpage, bool first)
{
if (first) {
insertPage(newpage, 0);
} else {
insertPage(newpage, getRoot().getKey("/Pages").getKey("/Count").getIntValueAsInt());
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
testl %edx, %edx
je 0x13ce58
movq %rax, 0x10(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x13ce7f
movq 0xb4132(%rip), %rcx # 0x1f0f80
cmpb $0x0, (%rcx)
je 0x13ce7b
incl 0x8(%rax)
jmp 0x13ce7f
movq %rax, (%rs... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QUtil::getWhoami(char*) | char*
QUtil::getWhoami(char* argv0)
{
char* whoami = nullptr;
if (((whoami = strrchr(argv0, '/')) == nullptr) &&
((whoami = strrchr(argv0, '\\')) == nullptr)) {
whoami = argv0;
} else {
++whoami;
}
if ((strlen(whoami) > 4) && (strcmp(whoami + strlen(whoami) - 4, ".exe") == 0... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x19ae0
testq %rax, %rax
jne 0x13f8ae
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x19ae0
testq %rax, %rax
je 0x13f8b4
movq %rax, %rbx
incq %rbx
movq %rbx, %rdi
callq 0x19420
cmpq $0x5, %rax
jb 0x13f8e3
movq %rax, %r14
leaq (%rbx,%rax), %rdi
addq $-0x4,... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_time_to_iso8601(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool
QUtil::pdf_time_to_iso8601(std::string const& pdf_time, std::string& iso8601)
{
QPDFTime qtm;
if (pdf_time_to_qpdf_time(pdf_time, &qtm)) {
iso8601 = qpdf_time_to_iso8601(qtm);
return true;
}
return false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
leaq 0x24(%rsp), %rsi
callq 0x1413ea
movl %eax, %ebx
testb %al, %al
je 0x141bd0
movq %rsp, %r15
leaq 0x24(%rsp), %rsi
movq %r15, %rdi
callq 0x1405cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x195c0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je ... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
qpdf_check_pdf | QPDF_ERROR_CODE
qpdf_check_pdf(qpdf_data qpdf)
{
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_check);
QTC::TC("qpdf", "qpdf-c called qpdf_check_pdf");
return status;
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rsi
movq $0x0, 0x8(%rsi)
leaq 0x282(%rip), %rax # 0x14badd
movq %rax, (%rsi)
leaq 0xf283(%rip), %rax # 0x15aae8
movq %rax, 0x18(%rsi)
leaq 0xf280(%rip), %rax # 0x15aaf0
movq %rax, 0x10(%rsi)
callq 0x14b8c6
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_longlong | QPDF_BOOL
qpdf_oh_get_value_as_longlong(qpdf_data qpdf, qpdf_oh oh, long long* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_longlong");
return o.getValueAsInt(*value);
});
} | pushq %rbx
subq $0x40, %rsp
xorl %r8d, %r8d
leaq 0x20(%rsp), %rax
movq %r8, 0x8(%rax)
leaq -0x21be(%rip), %rcx # 0x14ddfa
movq %rcx, (%rax)
leaq 0xb020(%rip), %rcx # 0x15afe2
movq %rcx, 0x18(%rax)
leaq 0xb017(%rip), %rcx # 0x15afe4
movq %rcx, 0x10(%rax)
movq %rsp, %rcx
movq %r8, 0x8(%rcx)
movq %rdx, (%rcx... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_uint_value | unsigned long long
qpdf_oh_get_uint_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<unsigned long long>(
qpdf, oh, return_T<unsigned long long>(0ULL), [](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_uint_value");
return o.getUIntValue();
});
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x128(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x108(%rsp), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, (%rsi)
leaq 0x6f56(%rip), %rax # 0x1571c4
movq %rax, 0x18(%rsi)
leaq 0x6f53(%rip), %rax # ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_data::~_qpdf_data() | ~_qpdf_data() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
leaq 0x138(%rbx), %rax
cmpq %rax, %rdi
je 0x159e04
movq (%rax), %rsi
incq %rsi
callq 0x190e0
leaq 0xf0(%rbx), %rdi
callq 0x590fc
leaq 0xb8(%rbx), %rdi
callq 0x159f18
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x159e2d
callq 0x1fc74
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
init_array_internal | void init_array_internal(double *a, int ndim, int dims[])
{
int idx[GA_MAX_DIM];
int i,dim, elems;
elems = 1;
for(i=0;i<ndim;i++)elems *= dims[i];
for(i=0; i<elems; i++){
int Index = i;
double field, val;
for(dim = 0; dim < ndim; dim++){
idx[di... | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x1, -0x44(%rsp)
movl $0x0, -0x3c(%rsp)
movl -0x3c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x3f7b
movq -0x18(%rsp), %rax
movslq -0x3c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
imull -0x44(%rsp), %eax
movl %eax, -0x44(%rsp)
movl -0x3c(%rsp), %eax
addl $0x... | /GlobalArrays[P]ga/global/testing/util.c |
compare_patches_internal | int compare_patches_internal(int me, double eps, int ndim, double *array1,
int lo1[], int hi1[], int dims1[],
double *array2, int lo2[], int hi2[],
int dims2[])
{
int i,j, elems=1;
int subscr1[GA_MAX_DIM], subscr2[GA_MAX_DIM];
double diff,max;
... | subq $0x188, %rsp # imm = 0x188
movq 0x1a8(%rsp), %rax
movq 0x1a0(%rsp), %rax
movq 0x198(%rsp), %rax
movq 0x190(%rsp), %rax
movl %edi, 0x180(%rsp)
movsd %xmm0, 0x178(%rsp)
movl %esi, 0x174(%rsp)
movq %rdx, 0x168(%rsp)
movq %rcx, 0x160(%rsp)
movq %r8, 0x158(%rsp)
movq %r9, 0x150(%rsp)
movl $0x1, 0x144(%rsp)
m... | /GlobalArrays[P]ga/global/testing/util.c |
MAi_inform_base | public Boolean MAi_inform_base(datatype, address1, address2)
Integer datatype; /* to set size of */
Pointer address1; /* of datatype element base */
Pointer address2; /* of an adjacent datatype element */
{
/* verify uninitialization */
if (ma_initialized)
{
(void)sprin... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18c025(%rip) # 0x1915d0
je 0x55ea
leaq 0x18c2cc(%rip), %rdi # 0x191880
leaq 0x16a0dd(%rip), %rsi # 0x16f698
movb $0x0, %al
callq 0x3080
movl $0x1, %esi
leaq 0x16a0e1(%rip), %rdx # 0x16f6af
leaq 0x18c2ab(%rip), %rc... | /GlobalArrays[P]ga/ma/ma.c |
ad_big_enough | private Boolean ad_big_enough(ad, ar)
AD *ad; /* the AD to test */
Pointer ar; /* allocation request */
{
Pointer client_space; /* location of client_space */
ulongi nbytes; /* length of block for ar */
/* perform trial allocation to determine size */
bal... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
callq 0x5ec0
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
ja 0x5ea0
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movl $0x1, %edx
callq 0x6c90
movq 0x8(%rsp), %rcx
mov... | /GlobalArrays[P]ga/ma/ma.c |
mh_free | private void mh_free(ad)
AD *ad; /* the AD whose memhandle to free */
{
Integer memhandle; /* memhandle for AD */
/* convert AD to memhandle */
if ((memhandle = ma_table_lookup_assoc((TableData)ad)) == TABLE_HANDLE_NONE)
{
(void)sprintf(ma_ebuf,
"cannot find ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9400
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
jne 0x6874
movq 0x10(%rsp), %rdx
leaq 0x18b036(%rip), %rdi # 0x191880
leaq 0x16969a(%rip), %rsi # 0x16feeb
movb $0x0, %al
callq 0x3080
movl $0x1, %esi
leaq 0x1696b5(%rip), %rdx # 0x16ff19
leaq 0x18b0... | /GlobalArrays[P]ga/ma/ma.c |
MA_inquire_avail | public Integer MA_inquire_avail(Integer datatype)
{
size_t gap_length; /* # of bytes between heap and stack */
Integer nelem_gap; /* max elements containable in gap */
#ifdef STATS
ma_stats.calls[(int)FID_MA_inquire_avail]++;
#endif /* STATS */
#ifdef VERIFY
if (ma_auto_verify && !MA_verif... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18a3a0(%rip), %rax # 0x191680
addq $0x1, %rax
movq %rax, 0x18a395(%rip) # 0x191680
cmpq $0x0, 0x18a2dd(%rip) # 0x1915d0
jne 0x7332
leaq 0x18a584(%rip), %rdi # 0x191880
leaq 0x16849d(%rip), %rsi # 0x16f7a0
movb $0x0, %al
callq 0x3080
movl $0x1, %edi
xorl %esi,... | /GlobalArrays[P]ga/ma/ma.c |
MA_inquire_heap_check_stack | public Integer MA_inquire_heap_check_stack(Integer datatype)
{
size_t gap_length; /* # of bytes between heap and partition */
Integer nelem_gap; /* max elements containable in gap */
Integer nelem_frag; /* max elements containable in any frag */
#ifdef STATS
ma_stats.calls[(int)FID_MA... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x189f60(%rip), %rax # 0x191690
addq $0x1, %rax
movq %rax, 0x189f55(%rip) # 0x191690
cmpq $0x0, 0x189e8d(%rip) # 0x1915d0
jne 0x7782
leaq 0x18a134(%rip), %rdi # 0x191880
leaq 0x16804d(%rip), %rsi # 0x16f7a0
movb $0x0, %al
callq 0x3080
movl $0x1, %edi
xorl %esi,... | /GlobalArrays[P]ga/ma/ma.c |
MA_inquire_stack | public Integer MA_inquire_stack(Integer datatype)
{
size_t gap_length; /* # of bytes between partition and stack */
Integer nelem_gap; /* max elements containable in gap */
#ifdef STATS
ma_stats.calls[(int)FID_MA_inquire_stack]++;
#endif /* STATS */
#ifdef VERIFY
if (ma_auto_verify && !MA_... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x189c70(%rip), %rax # 0x1916a0
addq $0x1, %rax
movq %rax, 0x189c65(%rip) # 0x1916a0
cmpq $0x0, 0x189b8d(%rip) # 0x1915d0
jne 0x7a82
leaq 0x189e34(%rip), %rdi # 0x191880
leaq 0x167d4d(%rip), %rsi # 0x16f7a0
movb $0x0, %al
callq 0x3080
movl $0x1, %edi
xorl %esi,... | /GlobalArrays[P]ga/ma/ma.c |
MA_push_stack | public Boolean MA_push_stack(
Integer datatype, /* of elements in this block */
Integer nelem, /* # of elements in this block */
const char *name, /* assigned to this block by client */
Integer *memhandle /* RETURN: handle for this block */)
{
AR ar; /*... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x189581(%rip), %rax # 0x1916d0
addq $0x1, %rax
movq %rax, 0x189576(%rip) # 0x1916d0
cmpq $0x0, 0x1895ce(%rip) # 0x191730
je 0x817e
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rax
movl %eax, %edx
leaq 0x16... | /GlobalArrays[P]ga/ma/ma.c |
MA_sizeof_overhead | public Integer MA_sizeof_overhead(Integer datatype)
{
int overhead_bytes; /* max bytes of overhead for any block */
int ceiling; /* 1 iff ceiling alters result */
int max_sizeof; /* max over i of ma_sizeof[i] */
int biggest_datatype=0; /* corresponds to max_sizeof *... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x188d98(%rip), %rax # 0x191700
addq $0x1, %rax
movq %rax, 0x188d8d(%rip) # 0x191700
leaq 0x16729d(%rip), %rdi # 0x16fc17
callq 0x6e00
cmpq $0x3e8, 0x18(%rsp) # imm = 0x3E8
jl 0x8995
cmpq $0x3f8, 0x18(%rsp) # imm = 0x3F8
jle 0x89d4
movq... | /GlobalArrays[P]ga/ma/ma.c |
guard_check | private Boolean guard_check(ad)
AD *ad; /* the AD to check guards for */
{
Guard signature; /* value to be read */
Pointer guard; /* address to read from */
guard = guard1(ad);
guard_read(guard, &signature);
if (signature != GUARD1)
return MA_FALSE;
gu... | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rsp)
cmpl $0xaaaaaaaa, -0x14(%rsp) # imm = 0xAAAAAAAA
je 0x8be7
movq $0x0, -0x8(%rsp)
jmp 0x8c41
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(... | /GlobalArrays[P]ga/ma/ma.c |
armci_msg_sel_scope | void armci_msg_sel_scope(int scope, void *x, int n, char* op, int type, int contribute)
{
static int initialized = 0;
MPI_Op mpi_op = MPI_OP_NULL;
MPI_Comm comm = get_default_comm();
if (SCOPE_NODE == scope) {
if (_number_of_procs_per_node == 1) {
comm = MPI_COMM_SELF;
} else {
... | subq $0xe8, %rsp
movl %edi, 0xe4(%rsp)
movq %rsi, 0xd8(%rsp)
movl %edx, 0xd4(%rsp)
movq %rcx, 0xc8(%rsp)
movl %r8d, 0xc4(%rsp)
movl %r9d, 0xc0(%rsp)
movq 0x185a34(%rip), %rax # 0x18ffd0
movq %rax, 0xb8(%rsp)
callq 0xbeb0
movq %rax, 0xb0(%rsp)
movl $0x151, %eax # imm = 0x151
cmpl 0xe4(%rsp), %eax
jne 0xa5f... | /GlobalArrays[P]ga/comex/src-armci/message.c |
swap_request_handler | static void _swap_request_handler(header_t *header, char *payload, int proc)
{
char *message = NULL;
void *tmp = NULL;
#if DEBUG
printf("[%d] _swap_request rem=%p loc=%p len=%d not=%p\n",
l_state.rank,
header->remote_address,
header->local_address,
header->le... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x20(%rsp), %rcx
movl $0xf, %eax
cmpl (%rcx), %eax
jne 0xd173
jmp 0xd192
leaq 0x164055(%rip), %rdi # 0x1711cf
leaq 0x163631(%rip), %rsi # 0x1707b2
movl $0x72a, %edx # imm = 0x7... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
comex_lock | int comex_lock(int mutex, int proc)
{
header_t *header = NULL;
char *notify = NULL;
#if DEBUG
printf("[%d] comex_lock id=%d proc=%d\n", l_state.rank, mutex, proc);
#endif
notify = _my_malloc(sizeof(char));
*notify = 1;
header = _my_malloc(sizeof(header_t));
header->operation = OP_LOCK_REQ... | subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x1, %edi
callq 0xcb00
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x1, (%rax)
movl $0x28, %edi
callq 0xcb00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x11, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
NGA_Create64 | int NGA_Create64(int type, int ndim, int64_t dims[], char *name, int64_t *chunk)
{
Integer *ptr, g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_wo... | subq $0xc8, %rsp
movl %edi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
cmpl $0x7, 0xbc(%rsp)
jle 0x12207
movl $0x0, 0xc4(%rsp)
jmp 0x1231e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0xbc(%rsp), %eax
jge 0x1224f
movq 0xb0(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq ... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Set_chunk64 | void GA_Set_chunk64(int g_a, int64_t chunk[])
{
Integer aa, *ptr, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_work, ndim);
ptr = _ga_work;
}
wnga_set_chunk(aa, ptr);
} | subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movslq 0x74(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0xcb800
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x14239
movq $0x0, 0x58(%rsp)
jmp 0x14288
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x50(%rsp), %rax
jge 0x1427e
movq 0x68... | /GlobalArrays[P]ga/global/src/capi.c |
pnga_scale_patch | void pnga_scale_patch(Integer g_a, Integer *lo, Integer *hi, void *alpha)
{
Integer ndim, dims[MAXDIM], type;
Integer loA[MAXDIM], hiA[MAXDIM];
Integer ld[MAXDIM];
char *src_data_ptr;
Integer num_blocks, nproc;
Integer me= pnga_nodeid();
int local_sync_begin,local_sync_end;
_iterator_hdl hdl;
local_s... | subq $0x4b8, %rsp # imm = 0x4B8
movq %rdi, 0x4b0(%rsp)
movq %rsi, 0x4a8(%rsp)
movq %rdx, 0x4a0(%rsp)
movq %rcx, 0x498(%rsp)
movb $0x0, %al
callq 0xdf860
movq %rax, 0x370(%rsp)
leaq 0x150173(%rip), %rax # 0x190570
movl (%rax), %eax
movl %eax, 0x36c(%rsp)
leaq 0x150167(%rip), %rax # 0x190574
movl (%rax),... | /GlobalArrays[P]ga/global/src/global.npatch.c |
pnga_shift_diagonal | void pnga_shift_diagonal(Integer g_a, void *c)
{
Integer loA[2], hiA[2]/*, dim1, dim2*/, ld;
Integer andim, adims[2], type, atype;
Integer me = pnga_nodeid (), i, nproc = pnga_nnodes();
char *ptr;
Integer num_blocks_a;
int local_sync_begin,local_sync_end;
_iterator_hdl hdl;
local_sync_begin = _ga_sync_... | subq $0x3a8, %rsp # imm = 0x3A8
movq %rdi, 0x3a0(%rsp)
movq %rsi, 0x398(%rsp)
movb $0x0, %al
callq 0xdf860
movq %rax, 0x338(%rsp)
movb $0x0, %al
callq 0xdf8c0
movq %rax, 0x328(%rsp)
leaq 0x1269c4(%rip), %rax # 0x190570
movl (%rax), %eax
movl %eax, 0x314(%rsp)
leaq 0x1269b8(%rip), %rax # 0x190574
movl (... | /GlobalArrays[P]ga/global/src/matrix.c |
sgai_scale_row_values | static void sgai_scale_row_values(Integer type, Integer *lo,
Integer *hi, Integer ld, void *ptr, Integer g_v)
{
Integer vlo, vhi, size;
int *ia;
float *fa;
double *da;
long *la;
DoubleComplex *dca;
SingleComplex *fca;
void *buf;
/* determine subset of my patch to access */
... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movq 0x98(%rsp), %rax
cmpq $0x0, (%rax)
jle 0x6b15c
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0x98(%rsp), %rcx
cmpq (%rcx), %rax
jl 0x6b15a
movq 0x90(%rsp), %rax
movq (%r... | /GlobalArrays[P]ga/global/src/matrix.c |
sgai_scale_col_values | static void sgai_scale_col_values(Integer type, Integer *lo,
Integer *hi, Integer ld, void *ptr, Integer g_v)
{
Integer vlo, vhi, size;
void *buf;
int *ia;
float *fa;
double *da;
long *la;
DoubleComplex *dca;
SingleComplex *fca;
/* determine subset of my patch to access */
... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movq 0x98(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x6ba0d
movq 0x90(%rsp), %rax
movq (%rax), %rax
movq 0x98(%rsp), %rcx
cmpq (%rcx), %rax
jl 0x6ba0b
movq 0x90(%rsp), %rax
movq ... | /GlobalArrays[P]ga/global/src/matrix.c |
pnga_pgroup_create | Integer pnga_pgroup_create(Integer *list, Integer count)
{
Integer pgrp_handle, i, j, nprocs, itmp;
Integer parent;
int tmp_count;
Integer *tmp_list;
int *tmp2_list;
#ifdef MSG_COMMS_MPI
ARMCI_Group *tmpgrp;
#endif
/* Allocate temporary arrays */
tmp_list = (Integer*)malloc(GAnproc*si... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0xd1c4b(%rip), %rax # 0x195d90
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x3340
movq %rax, 0x18(%rsp)
leaq 0xd1c33(%rip), %rax # 0x195d90
movq (%rax), %rdi
shlq $0x2, %rdi
callq 0x3340
movq %rax, 0x10(%rsp)
movq $-0x1, 0x50(%rsp)
movq $0x0, 0x48(%r... | /GlobalArrays[P]ga/global/src/base.c |
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.