name string | code string | asm string | file string |
|---|---|---|---|
QPDFXRefEntry::getOffset() const | qpdf_offset_t
QPDFXRefEntry::getOffset() const
{
if (this->type != 1) {
throw std::logic_error("getOffset called for xref entry of type != 1");
}
return this->field1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, (%rax)
je 0x229cd9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x1061ed(%rip), %rsi # 0x32fe91
callq 0x1bbe0
jmp 0x229cab
movq -0x28(%rbp), %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFXRefEntry.cc |
QPDFXRefEntry::getObjStreamIndex() const | int
QPDFXRefEntry::getObjStreamIndex() const
{
if (this->type != 2) {
throw std::logic_error("getObjStreamIndex called for xref entry of type != 2");
}
return this->field2;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2, (%rax)
je 0x229de9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x106140(%rip), %rsi # 0x32fef4
callq 0x1bbe0
jmp 0x229dbb
movq -0x28(%rbp), %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFXRefEntry.cc |
qpdf::Array::begin() | Array::iterator
Array::begin()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.begin();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->begin();
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22c990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22a0e3
movq -0x18(%rbp), %rdi
callq 0x1cae60
testb $0x1, %al
jne 0x22a05b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x64060
movq %rax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::getAsVector() const | std::vector<QPDFObjectHandle>
Array::getAsVector() const
{
auto a = array();
if (a->sp) {
std::vector<QPDFObjectHandle> v;
v.reserve(size_t(size()));
for (auto const& item: a->sp->elements) {
v.resize(size_t(item.first), null_oh);
v.emplace_back(item.second);
... | 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 -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x229f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cae60
testb $0x1, %al
jne 0x22a13e
jmp 0x22a240
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::end() | Array::iterator
Array::end()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.end();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->end();
}
return {}... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22c990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22a343
movq -0x18(%rbp), %rdi
callq 0x1cae60
testb $0x1, %al
jne 0x22a2bb
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x64090
movq %rax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::at(int) const | std::pair<bool, QPDFObjectHandle>
Array::at(int n) const
{
auto a = array();
if (n < 0 || n >= size()) {
return {false, {}};
}
if (!a->sp) {
return {true, a->elements[size_t(n)]};
}
auto const& iter = a->sp->elements.find(n);
return {true, iter == a->sp->elements.end() ? null... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x229f80
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x22a832
movq -0x88(%rbp), %rdi
movl... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::setFromVector(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&) | void
Array::setFromVector(std::vector<QPDFObjectHandle> const& v)
{
auto a = array();
a->elements.resize(0);
a->elements.reserve(v.size());
for (auto const& item: v) {
checkOwnership(item);
a->elements.emplace_back(item);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x229f80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22d030
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::getArrayAsVector() const | std::vector<QPDFObjectHandle>
QPDFObjectHandle::getArrayAsVector() const
{
if (auto array = as_array(strict)) {
return array.getAsVector();
}
typeWarning("array", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle array treating as empty vector");
return {};
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x68(%rbp), %rdi
callq 0x42cb0
movb %al, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::setArrayFromVector(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&) | void
QPDFObjectHandle::setArrayFromVector(std::vector<QPDFObjectHandle> const& items)
{
if (auto array = as_array(strict)) {
array.setFromVector(items);
} else {
typeWarning("array", "ignoring attempt to replace items");
QTC::TC("qpdf", "QPDFObjectHandle array ignoring replace items");
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x68(%rbp), %rdi
callq 0x42cb0
movb %al, -0x5a(%rbp)
jmp 0x22c188
movb -0x5a(%rbp), %al
testb $0x1, %al
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::insertItem(int, QPDFObjectHandle const&) | void
QPDFObjectHandle::insertItem(int at, QPDFObjectHandle const& item)
{
if (auto array = as_array(strict)) {
if (!array.insert(at, item)) {
objectWarning("ignoring attempt to insert out of bounds array item");
QTC::TC("qpdf", "QPDFObjectHandle insert array bounds");
}
}... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x98(%rbp), %rdi
callq 0x42cb0
movb %al, -0x8a(%rbp)
jmp 0x22c2b7
movb -0x8a(%rbp)... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::appendItem(QPDFObjectHandle const&) | void
QPDFObjectHandle::appendItem(QPDFObjectHandle const& item)
{
if (auto array = as_array(strict)) {
array.push_back(item);
} else {
typeWarning("array", "ignoring attempt to append item");
QTC::TC("qpdf", "QPDFObjectHandle array ignoring append item");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x68(%rbp), %rdi
callq 0x42cb0
movb %al, -0x5a(%rbp)
jmp 0x22c4f8
movb -0x5a(%rbp), %al
testb $0x1, %al
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::eraseItem(int) | void
QPDFObjectHandle::eraseItem(int at)
{
if (auto array = as_array(strict)) {
if (!array.erase(at)) {
objectWarning("ignoring attempt to erase out of bounds array item");
QTC::TC("qpdf", "QPDFObjectHandle erase array bounds");
}
} else {
typeWarning("array", "ig... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x90(%rbp), %rdi
callq 0x42cb0
movb %al, -0x82(%rbp)
jmp 0x22c673
movb -0x82(%rbp), %al
testb $0x1, %al
j... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDFObjectHandle::eraseItemAndGetOld(int) | QPDFObjectHandle
QPDFObjectHandle::eraseItemAndGetOld(int at)
{
auto array = as_array(strict);
auto result = (array && at < array.size() && at >= 0) ? array.at(at).second : newNull();
eraseItem(at);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
xorl %edx, %edx
callq 0x64460
movq -0x70(%rbp), %rdi
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Array.cc |
QPDF_Array* qpdf::BaseHandle::as<QPDF_Array>() const | T*
BaseHandle::as() const
{
if (!obj) {
return nullptr;
}
if (std::holds_alternative<T>(obj->value)) {
return &std::get<T>(obj->value);
}
if (std::holds_alternative<QPDF_Unresolved>(obj->value)) {
return BaseHandle(QPDF::Resolver::resol... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x43890
testb $0x1, %al
jne 0x22c9bd
movq $0x0, -0x8(%rbp)
jmp 0x22cafc
movq -0x50(%rbp), %rdi
callq 0x65ef0
movq %rax, %rdi
callq 0x22e620
testb $0x1, %al
jne 0x22c9d4
jmp 0x22c9ee
movq -0x50(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_Null::create(std::shared_ptr<QPDFObject>, std::basic_string_view<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | inline std::shared_ptr<QPDFObject>
QPDF_Null::create(
std::shared_ptr<QPDFObject> parent, std::string_view const& static_descr, std::string var_descr)
{
auto n = QPDFObject::create<QPDF_Null>();
n->setChildDescription(parent->getQPDF(), parent, static_descr, var_descr);
return n;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rcx, -0x98(%rbp)
movq %rsi, -0x80(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x63e70
movq -0x88(%rbp), %rdi
callq 0x65ef0
mov... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFObject::setChildDescription(QPDF*, std::shared_ptr<QPDFObject>, std::basic_string_view<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void
setChildDescription(
QPDF* a_qpdf,
std::shared_ptr<QPDFObject> parent,
std::string_view const& static_descr,
std::string var_descr)
{
object_description =
std::make_shared<Description>(ChildDescr(parent, static_descr, var_descr));
qpdf = a_qpdf;
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xd0(%rbp)
movq %rsi, %rax
movq -0xd0(%rbp), %rsi
movq %r8, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x438... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
qpdf::BaseDictionary::getKeys[abi:cxx11]() | std::set<std::string>
BaseDictionary::getKeys()
{
std::set<std::string> result;
for (auto& iter: dict()->items) {
if (!iter.second.isNull()) {
result.insert(iter.first);
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0xc55d0
movq -0x68(%rbp), %rdi
callq 0x230dd0
movq %rax, -0x60(%rbp)
jmp 0x23105e
movq -0x60(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::checkOwnership(QPDFObjectHandle const&) const | void
QPDFObjectHandle::checkOwnership(QPDFObjectHandle const& item) const
{
auto qpdf = getOwningQPDF();
auto item_qpdf = item.getOwningQPDF();
if (qpdf && item_qpdf && qpdf != item_qpdf) {
QTC::TC("qpdf", "QPDFObjectHandle check ownership");
throw std::logic_error(
"Attempting t... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c3ab0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3ab0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2312a7
cmpq $0x0, -0x20(%rbp)
je 0x2312a7
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::hasKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool
QPDFObjectHandle::hasKey(std::string const& key) const
{
auto dict = as_dictionary(strict);
if (dict) {
return dict.hasKey(key);
} else {
typeWarning("dictionary", "returning false for a key containment request");
QTC::TC("qpdf", "QPDFObjectHandle dictionary false for hasKey");
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x64570
movq -0x68(%rbp), %rdi
callq 0x42cb0
movb %al, -0x5a(%rbp)
jmp 0x2312f8
movb -0x5a(%rbp), %al
testb $0x1, %a... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::getDictAsMap[abi:cxx11]() const | std::map<std::string, QPDFObjectHandle>
QPDFObjectHandle::getDictAsMap() const
{
if (auto dict = as_dictionary(strict)) {
return dict.getAsMap();
}
typeWarning("dictionary", "treating as empty");
QTC::TC("qpdf", "QPDFObjectHandle dictionary empty map for asMap");
return {};
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x64570
movq -0x60(%rbp), %rdi
callq 0x42cb0
movb %al, ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Dictionary.cc |
qpdf::Stream::getStreamData(qpdf_stream_decode_level_e) | std::shared_ptr<Buffer>
Stream::getStreamData(qpdf_stream_decode_level_e decode_level)
{
Pl_Buffer buf("stream data buffer");
bool filtered;
pipeStreamData(&buf, &filtered, 0, decode_level, false, false);
if (!filtered) {
throw QPDFExc(
qpdf_e_unsupported,
obj->getQPDF()-... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq 0xf7fe5(%rip), %rsi # 0x32c80e
xorl %eax, %eax
movl %eax, -0xd8(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::isRootMetadata() const | bool
Stream::isRootMetadata() const
{
if (!getDict().isDictionaryOfType("/Metadata", "/XML")) {
return false;
}
auto root_metadata = qpdf()->getRoot().getKey("/Metadata");
return root_metadata.isSameObjectAs(obj);
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x239a20
leaq -0x41(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1be40
movq -0xe0(%rbp), %rdx
leaq 0xe20b8(%rip), %rsi # 0x316e49
leaq -0x40(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
qpdf::Stream::filterable(std::vector<std::shared_ptr<QPDFStreamFilter>, std::allocator<std::shared_ptr<QPDFStreamFilter>>>&, bool&, bool&) | bool
Stream::filterable(
std::vector<std::shared_ptr<QPDFStreamFilter>>& filters,
bool& specialized_compression,
bool& lossy_compression)
{
auto s = stream();
// Check filters
QPDFObjectHandle filter_obj = s->stream_dict.getKey("/Filter");
bool filters_okay = true;
std::vector<std::str... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x6aa80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x248(%rbp)
leaq -0x61(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::string const& data, QPDFObjectHandle const& filter, QPDFObjectHandle const& decode_parms)
{
auto b = std::make_shared<Buffer>(data.length());
unsigned char* bp = b->getBuffer();
if (bp) {
memcpy(bp, data.c_str(), data.length());
}
as_stream(... | 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), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b850
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x23a... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::function<void (Pipeline*)>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::function<void(Pipeline*)> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto sdp = std::shared_ptr<StreamDataProvider>(new FunctionProvider(provider));
as_stream(error).replaceStreamData(sdp, filter, decode_parms);
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x50, %edi
callq 0x1b250
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movb $0x1, -0x5d(%rbp)
leaq -0x50(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDFObjectHandle::replaceStreamData(std::function<bool (Pipeline*, bool, bool)>, QPDFObjectHandle const&, QPDFObjectHandle const&) | void
QPDFObjectHandle::replaceStreamData(
std::function<bool(Pipeline*, bool, bool)> provider,
QPDFObjectHandle const& filter,
QPDFObjectHandle const& decode_parms)
{
auto sdp = std::shared_ptr<StreamDataProvider>(new FunctionProvider(provider));
as_stream(error).replaceStreamData(sdp, filter, decod... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x50, %edi
callq 0x1b250
movq -0x90(%rbp), %rsi
movq %rax, -0x88(%rbp)
movb $0x1, -0x5d(%rbp)
leaq -0x50(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_Stream.cc |
QPDF_Stream::QPDF_Stream(QPDFObjectHandle, unsigned long) | QPDF_Stream(QPDFObjectHandle stream_dict, size_t length) :
m(std::make_unique<Members>(stream_dict, length))
{
if (!stream_dict.isDictionary()) {
throw std::logic_error(
"stream object instantiated with non-dictionary object for dictionary");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x2426f0
movq -0x30(%rbp), %rdi
callq 0x1c0130
movb %al, -0x25(%rbp)
jmp 0x241d17
movb -0x25(%rbp), %al
testb $... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
QPDF_String::getUTF8Val[abi:cxx11]() const | std::string
QPDF_String::getUTF8Val() const
{
if (QUtil::is_utf16(this->val)) {
return QUtil::utf16_to_utf8(this->val);
} else if (QUtil::is_explicit_utf8(this->val)) {
// PDF 2.0 allows UTF-8 strings when explicitly prefixed with the three-byte representation
// of U+FEFF.
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2b4e40
testb $0x1, %al
jne 0x24707e
jmp 0x24708d
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x2b4f60
jmp 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_String.cc |
QPDF_String::useHexString() const | bool
QPDF_String::useHexString() const
{
// Heuristic: use the hexadecimal representation of a string if there are any non-printable (in
// PDF Doc encoding) characters or if too large of a proportion of the string consists of
// non-ASCII characters.
unsigned int non_ascii = 0;
for (auto const ch: ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x14(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b380
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bf80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_String.cc |
QPDF_String::unparse[abi:cxx11](bool) | std::string
QPDF_String::unparse(bool force_binary)
{
bool use_hexstring = force_binary || useHexString();
std::string result;
if (use_hexstring) {
static auto constexpr hexchars = "0123456789abcdef";
result.reserve(2 * this->val.length() + 2);
result += '<';
for (const char ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x1, %al
testb $0x1, -0x11(%rbp)
movb %al, -0x91(%rbp)
jne 0x24724... | /jberkenbilt[P]qpdf/libqpdf/QPDF_String.cc |
QPDF::compute_data_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, bool, int, int) | std::string
QPDF::compute_data_key(
std::string const& encryption_key,
int objid,
int generation,
bool use_aes,
int encryption_V,
int encryption_R)
{
// Algorithm 3.1 from the PDF 1.7 Reference Manual
std::string result = encryption_key;
if (encryption_V >= 5) {
// Algorith... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa8(%rbp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, -0xa0(%rbp)
movl 0x10(%rbp), %r8d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | std::string
QPDF::compute_encryption_key(std::string const& password, EncryptionData const& data)
{
if (data.getV() >= 5) {
// For V >= 5, the encryption key is generated and stored in the file, encrypted separately
// with both user and owner passwords.
return recover_encryption_key_with_pa... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2476b0
cmpl $0x5, %eax
jl 0x247c90
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x247... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
iterate_md5_digest(MD5&, unsigned char (&) [16], int, int) | static void
iterate_md5_digest(MD5& md5, MD5::Digest& digest, int iterations, int key_len)
{
md5.digest(digest);
for (int i = 0; i < iterations; ++i) {
MD5 m;
m.encodeDataIncrementally(reinterpret_cast<char*>(digest), QIntC::to_size(key_len));
m.digest(digest);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ad50
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2480af
leaq -0x30(%rbp), %rdi
callq 0x3a900
movq -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_Perms_value_V5_clear(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&, unsigned char*) | void
compute_Perms_value_V5_clear(
std::string const& encryption_key, QPDF::EncryptionData const& data, unsigned char k[16])
{
// From algorithm 3.10 from the PDF 1.7 extension level 3
unsigned long long extended_perms =
0xffffffff00000000LL | static_cast<unsigned long long>(data.getP());
for (i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x247700
cltq
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x24853b
movq -0x2... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
check_owner_password_V5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static bool
check_owner_password_V5(std::string const& owner_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.12 from the PDF 1.7 extension level 3
std::string user_data = data.getU().substr(0, 48);
std::string owner_data = data.getO().substr(0, 32);
std::string validation_salt = data.getO(... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x247740
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0xc8(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x30, %ecx
callq 0x1be90
movq -0x10(%rbp), %rdi
callq 0x247720
movq -0xc8(%rbp), %rdx
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::initializeEncryption() | void
QPDF::initializeEncryption()
{
if (m->encp->encryption_initialized) {
return;
}
m->encp->encryption_initialized = true;
// After we initialize encryption parameters, we must use stored key information and never look
// at /Encrypt again. Otherwise, things could go wrong if someone mut... | pushq %rbp
movq %rsp, %rbp
subq $0x1330, %rsp # imm = 0x1330
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf78(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x108, %rdi # imm = 0x108
callq 0x64f70
testb $0x1, 0x1(%rax)
je 0x249249
jmp 0x24d064
movq -0xf78(%rbp), %rdi
callq 0x63670
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::decryptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, QPDFObjGen) | void
QPDF::decryptString(std::string& str, QPDFObjGen og)
{
if (!og.isIndirect()) {
return;
}
bool use_aes = false;
if (m->encp->encryption_V >= 4) {
switch (m->encp->cf_string) {
case e_none:
return;
case e_aes:
use_aes = true;
break;... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x308(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x43a40
testb $0x1, %al
jne 0x24d474
jmp 0x24dbb8
movq -0x308(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x63... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_O_U(char const*, char const*, int, int, int, int, bool, 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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void
QPDF::compute_encryption_O_U(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
int P,
bool encrypt_metadata,
std::string const& id1,
std::string& O,
std::string& U)
{
if (V >= 5) {
throw std::logic_error("compute_encryption_O_U ca... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
andb $0x1, %al
movb %al, -... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::compute_encryption_parameters_V5(char const*, char const*, int, int, int, int, bool, 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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std:... | void
QPDF::compute_encryption_parameters_V5(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
int P,
bool encrypt_metadata,
std::string const& id1,
std::string& encryption_key,
std::string& O,
std::string& U,
std::string& OE,
std::stri... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %e... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_O_OE_value_V5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__c... | static void
compute_O_OE_value_V5(
std::string const& owner_password,
std::string const& encryption_key,
QPDF::EncryptionData const& data,
std::string const& U,
std::string& O,
std::string& OE)
{
// Algorithm 3.9 from the PDF 1.7 extension level 3
char k[16];
QUtil::initializeWithRan... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movl $0x10, %esi
callq 0x2b1c90
leaq -0x61(%rbp), %rdi
movq %rdi, -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowAccessibility() | bool
QPDF::allowAccessibility()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
if (R < 3) {
status = is_bit_set(P, 5);
} else {
status = is_bit_set(P, 10);
}
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x250990
testb $0x1, %al
jne 0x250ee5
jmp 0x250f13
cmpl $0x3, -0xc(%rbp)
jge 0x250eff
movl -0x10(%rbp), %edi
movl... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowExtractAll() | bool
QPDF::allowExtractAll()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 5);
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x250990
testb $0x1, %al
jne 0x250f85
jmp 0x250f97
movl -0x10(%rbp), %edi
movl $0x5, %esi
callq 0x250f20
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::allowModifyAnnotation() | bool
QPDF::allowModifyAnnotation()
{
int R = 0;
int P = 0;
bool status = true;
if (isEncrypted(R, P)) {
status = is_bit_set(P, 6);
}
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x250990
testb $0x1, %al
jne 0x251195
jmp 0x2511a7
movl -0x10(%rbp), %edi
movl $0x6, %esi
callq 0x250f20
andb $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
iterate_rc4(unsigned char*, unsigned long, unsigned char*, int, int, bool) | static void
iterate_rc4(
unsigned char* data,
size_t data_len,
unsigned char* okey,
int key_len,
int iterations,
bool reverse)
{
auto key_ph = std::make_unique<unsigned char[]>(QIntC::to_size(key_len));
unsigned char* key = key_ph.get();
for (int i = 0; i < iterations; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x49400
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x476d0
leaq -0x30(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
compute_U_value_R3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDF::EncryptionData const&) | static std::string
compute_U_value_R3(std::string const& user_password, QPDF::EncryptionData const& data)
{
// Algorithm 3.5 from the PDF 1.7 Reference Manual
std::string k1 = QPDF::compute_encryption_key(user_password, data);
MD5 md5;
md5.encodeDataIncrementally(pad_or_truncate_password_V4("").c_str()... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x247c50
leaq -0x48(%rbp), %rdi
callq 0x3a900... | /jberkenbilt[P]qpdf/libqpdf/QPDF_encryption.cc |
is_indirect_object(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) | static bool
is_indirect_object(std::string const& v, int& obj, int& gen)
{
char const* p = v.c_str();
std::string o_str;
std::string g_str;
if (!util::is_digit(*p)) {
return false;
}
while (util::is_digit(*p)) {
o_str.append(1, *p++);
}
if (*p != ' ') {
return fal... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b180
movq %rax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1b510
leaq -0x68(%rbp), %rdi
callq 0x1b510
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x63ce0
movb %al, -0x79(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
is_obj_key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) | static bool
is_obj_key(std::string const& v, int& obj, int& gen)
{
if (v.substr(0, 4) != "obj:") {
return false;
}
return is_indirect_object(v.substr(4), obj, gen);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x4, %ecx
callq 0x1be90
movq -0x80(%rbp), %rdi
leaq 0xc2079(%rip), %rsi # 0x3176c5
callq 0x385e0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
is_unicode_string(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>>&) | static bool
is_unicode_string(std::string const& v, std::string& str)
{
if (v.substr(0, 2) == "u:") {
str = v.substr(2);
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x2, %ecx
callq 0x1be90
movq -0x78(%rbp), %rdi
leaq 0xdbb85(%rip), %rsi # 0x3312cd
callq 0x315c0
movb %al, -0x69(%rbp)
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::error(long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDF::JSONReactor::error(qpdf_offset_t offset, std::string const& msg)
{
errors = true;
std::string object = this->cur_object;
if (is->getName() != pdf.getFilename()) {
object += " from " + is->getName();
}
pdf.warn(qpdf_e_json, object, offset, msg);
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movb $0x1, 0x38(%rsi)
addq $0x40, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b1c0
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
callq 0x45fd0
movq %rax, %rdi
movq (%rdi), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::setObjectDescription(QPDFObjectHandle&, JSON const&) | void
QPDF::JSONReactor::setObjectDescription(QPDFObjectHandle& oh, JSON const& value)
{
auto j_descr = std::get<QPDFObject::JSON_Descr>(*descr);
if (j_descr.object != cur_object) {
descr = std::make_shared<QPDFObject::Description>(
QPDFObject::JSON_Descr(j_descr.input, cur_object));
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x28, %rdi
callq 0x1bb4f0
movq %rax, %rdi
callq 0x25b110
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x1bb560
movq -0xb0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::makeObject(JSON const&) | QPDFObjectHandle
QPDF::JSONReactor::makeObject(JSON const& value)
{
QPDFObjectHandle result;
std::string str_v;
bool bool_v = false;
if (value.isDictionary()) {
result = QPDFObjectHandle::newDictionary();
next_obj = result;
next_state = st_object;
} else if (value.isArray()) ... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x42ac0
leaq -0x40(%rbp), %rdi
callq 0x1b5... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::arrayItem(JSON const&) | bool
QPDF::JSONReactor::arrayItem(JSON const& value)
{
if (stack.empty()) {
throw std::logic_error("stack is empty in arrayItem");
}
next_state = st_ignore;
auto state = stack.back().state;
if (state == st_qpdf) {
if (!this->saw_qpdf_meta) {
this->saw_qpdf_meta = true;
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
addq $0x68, %rdi
callq 0x25b060
testb $0x1, %al
jne 0x25937d
jmp 0x2593d9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
leaq 0xd93fe(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::JSONReactor::JSONReactor(QPDF&, std::shared_ptr<InputSource>, bool) | JSONReactor(QPDF& pdf, std::shared_ptr<InputSource> is, bool must_be_complete) :
pdf(pdf),
is(is),
must_be_complete(must_be_complete),
descr(
std::make_shared<QPDFObject::Description>(
QPDFObject::JSON_Descr(std::make_shared<std::string>(is->getName()), "")))
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xb0(%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), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x25b770
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq 0x23466e(%rip), %rax ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_json.cc |
QPDF::isLinearized() | bool
QPDF::isLinearized()
{
// If the first object in the file is a dictionary with a suitable /Linearized key and has an /L
// key that accurately indicates the file size, initialize m->lindict and return true.
// A linearized PDF spec's first object will be contained within the first 1024 bytes of the
... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x45fd0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movl $0x400, %edx # imm = 0x400
xorl %eax, %eax
movl %eax, %ecx
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::readHintStream(Pipeline&, long long, unsigned long) | QPDFObjectHandle
QPDF::readHintStream(Pipeline& pl, qpdf_offset_t offset, size_t length)
{
QPDFObjGen og;
QPDFObjectHandle H =
readObjectAtOffset(false, offset, "linearization hint stream", QPDFObjGen(0, 0), og, false);
ObjCache& oc = m->obj_cache[og];
qpdf_offset_t min_end_offset = oc.end_befor... | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rdi, -0x2c0(%rbp)
movq %rdi, %rax
movq %rax, -0x2b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b0(%rbp)
leaq -0x30(%rbp), %rdi
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::readHPageOffset(BitStream) | void
QPDF::readHPageOffset(BitStream h)
{
// All comments referring to the PDF spec refer to the spec for version 1.4.
HPageOffset& t = m->page_offset_hints;
t.min_nobjects = h.getBitsInt(32); // 1
t.first_page_offset = h.getBitsInt(32); // 2
t.nbits_delta_nobjects = h.getBi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x63670
movq -0x28(%rbp), %rdi
addq $0x368, %rax # imm = 0x368
movq %rax, -0x10(%rbp)
movl $0x20, %esi
callq 0x1e790
movq -0x28(%rbp), %rdi
movl %e... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void load_vector_int<QPDF::HPageOffsetEntry, int>(BitStream&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int, int QPDF::HPageOffsetEntry::*) | static void
load_vector_int(
BitStream& bit_stream, int nitems, std::vector<T>& vec, int bits_wanted, int_type T::* field)
{
bool append = vec.empty();
// nitems times, read bits_wanted from the given bit stream, storing results in the ith vector
// entry.
for (size_t i = 0; i < QIntC::to_size(nite... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x270560
andb $0x1, %al
movb %al, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0xc(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void load_vector_vector<QPDF::HPageOffsetEntry>(BitStream&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int QPDF::HPageOffsetEntry::*, int, std::vector<int, std::allocator<int>> QPDF::HPageOffsetEntry::*) | static void
load_vector_vector(
BitStream& bit_stream,
int nitems1,
std::vector<T>& vec1,
int T::* nitems2,
int bits_wanted,
std::vector<int> T::* vec2)
{
// nitems1 times, read nitems2 (from the ith element of vec1) items into the vec2 vector field
// of the ith item of vec1.
for (s... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x49400
movq %rax, %rcx
movq -0x48(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::checkHSharedObject(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>&) | void
QPDF::checkHSharedObject(std::vector<QPDFObjectHandle> const& pages, std::map<int, int>& idx_to_obj)
{
// Implementation note 125 says shared object groups always contain only one object.
// Implementation note 128 says that Acrobat always nbits_nobjects to zero. Implementation note
// 130 says that A... | pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp # imm = 0x370
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0x63670
addq $0x3c0, %rax # imm = 0x3C0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x20(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::checkHPageOffset(std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>> const&, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>&) | void
QPDF::checkHPageOffset(
std::vector<QPDFObjectHandle> const& pages, std::map<int, int>& shared_idx_to_obj)
{
// Implementation note 126 says Acrobat always sets delta_content_offset and
// delta_content_length in the page offset header dictionary to 0. It also states that
// min_content_offset in ... | pushq %rbp
movq %rsp, %rbp
subq $0x770, %rsp # imm = 0x770
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rdi
callq 0x761c0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x251ef0
movq -0x680(%rbp), %rdi
movl %eax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::getUncompressedObject(QPDFObjectHandle&, QPDFWriter::ObjTable const&) | QPDFObjectHandle
QPDF::getUncompressedObject(QPDFObjectHandle& oh, QPDFWriter::ObjTable const& obj)
{
if (obj.contains(oh)) {
if (auto id = obj[oh].object_stream; id > 0) {
return oh.isNull() ? oh : getObject(id, 0);
}
}
return oh;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::dumpHPageOffset() | void
QPDF::dumpHPageOffset()
{
HPageOffset& t = m->page_offset_hints;
*m->log->getInfo() << "min_nobjects: " << t.min_nobjects << "\n"
<< "first_page_offset: " << adjusted_offset(t.first_page_offset) << "\n"
<< "nbits_delta_nobjects: " << t.nbits_delta_nobjects << "... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x63670
movq -0x90(%rbp), %rdi
addq $0x368, %rax # imm = 0x368
movq %rax, -0x10(%rbp)
callq 0x63670
movq %rax, %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0x20(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::dumpHGeneric(QPDF::HGeneric&) | void
QPDF::dumpHGeneric(HGeneric& t)
{
*m->log->getInfo() << "first_object: " << t.first_object << "\n"
<< "first_object_offset: " << adjusted_offset(t.first_object_offset) << "\n"
<< "nobjects: " << t.nobjects << "\n"
<< "group_length: " << t.gro... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x63670
movq %rax, %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %edx, %edx
callq 0x1af7f0
movq -0x40(%rbp), %rdi
callq 0x63db0
movq %rax, %... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::getLinearizedParts(QPDFWriter::ObjTable const&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, std::vector<QPDFObjectHandle, std::allocator<QPDFObjectHandle>>&, st... | void
QPDF::getLinearizedParts(
QPDFWriter::ObjTable const& obj,
std::vector<QPDFObjectHandle>& part4,
std::vector<QPDFObjectHandle>& part6,
std::vector<QPDFObjectHandle>& part7,
std::vector<QPDFObjectHandle>& part8,
std::vector<QPDFObjectHandle>& part9)
{
calculateLinearizationData(obj);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26b620
movq -0x38(%rbp), %rdi
callq 0x63670... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::outputLengthNextN(int, int, QPDFWriter::NewObjTable const&, QPDFWriter::ObjTable const&) | int
QPDF::outputLengthNextN(
int in_object, int n, QPDFWriter::NewObjTable const& new_obj, QPDFWriter::ObjTable const& obj)
{
// Figure out the length of a series of n consecutive objects in the output file starting with
// whatever object in_object from the input file mapped to.
int first = obj[in_obj... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x26eb30
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void write_vector_int<QPDF::HPageOffsetEntry, int>(BitWriter&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int, int QPDF::HPageOffsetEntry::*) | static void
write_vector_int(BitWriter& w, int nitems, std::vector<T>& vec, int bits, int_type T::* field)
{
// nitems times, write bits bits from the given field of the ith vector to the given bit writer.
for (size_t i = 0; i < QIntC::to_size(nitems); ++i) {
w.writeBits(QIntC::to_ulonglong(vec.at(i).*... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x49400
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void write_vector_vector<QPDF::HPageOffsetEntry>(BitWriter&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int QPDF::HPageOffsetEntry::*, int, std::vector<int, std::allocator<int>> QPDF::HPageOffsetEntry::*) | static void
write_vector_vector(
BitWriter& w,
int nitems1,
std::vector<T>& vec1,
int T::* nitems2,
int bits,
std::vector<int> T::* vec2)
{
// nitems1 times, write nitems2 (from the ith element of vec1) items from the vec2 vector field
// of the ith item of vec1.
for (size_t i1 = 0; ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x49400
movq %rax, %rcx
movq -0x48(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::writeHSharedObject(BitWriter&) | void
QPDF::writeHSharedObject(BitWriter& w)
{
HSharedObject& t = m->shared_object_hints;
w.writeBitsInt(t.first_shared_obj, 32); // 1
w.writeBits(toULL(t.first_shared_offset), 32); // 2
w.writeBitsInt(t.nshared_first_page, 32); // 3
w.writeBitsInt(t.nshared_total, 32); // ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x63670
addq $0x3c0, %rax # imm = 0x3C0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x20, %edx
callq 0x1f470
movq -0x10(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void write_vector_int<QPDF::HSharedObjectEntry, int>(BitWriter&, int, std::vector<QPDF::HSharedObjectEntry, std::allocator<QPDF::HSharedObjectEntry>>&, int, int QPDF::HSharedObjectEntry::*) | static void
write_vector_int(BitWriter& w, int nitems, std::vector<T>& vec, int bits, int_type T::* field)
{
// nitems times, write bits bits from the given field of the ith vector to the given bit writer.
for (size_t i = 0; i < QIntC::to_size(nitems); ++i) {
w.writeBits(QIntC::to_ulonglong(vec.at(i).*... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x49400
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QIntC::IntConverter<double, int, true, true>::error(double) | 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 signed type";
throw std... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movsd %xmm0, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x26f034
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
ObjTable<QPDFWriter::Object>::element(unsigned long) const | inline T const&
element(size_t idx) const
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < std::vector<T>::size()) {
return std::vector<T>::operator[](idx);
}
if (idx < max_size) {
return sparse_elements.at(idx);
}
thr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpb $0x0, 0x21bfd9(%rip) # 0x4927d8
jne 0x27682e
leaq 0x21bfd0(%rip), %rdi # 0x4927d8
callq 0x1b530
cmpl $0x0, %eax
je 0x27682e
movq -0x30(%rbp), %rdi
callq 0x222020
movq %rax, ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
ObjTable<QPDFWriter::NewObject>::element(unsigned long) const | inline T const&
element(size_t idx) const
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < std::vector<T>::size()) {
return std::vector<T>::operator[](idx);
}
if (idx < max_size) {
return sparse_elements.at(idx);
}
thr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpb $0x0, 0x21b2f9(%rip) # 0x4927e8
jne 0x27751e
leaq 0x21b2f0(%rip), %rdi # 0x4927e8
callq 0x1b530
cmpl $0x0, %eax
je 0x27751e
movq -0x30(%rbp), %rdi
callq 0x21ff10
movq %rax, ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
QPDF::parse(char const*) | void
QPDF::parse(char const* password)
{
if (password) {
m->encp->provided_password = password;
}
// Find the header anywhere in the first 1024 bytes of the file.
PatternFinder hf(*this, &QPDF::findHeader);
if (!m->file->findFirst("%PDF-", 0, 1024, hf)) {
QTC::TC("qpdf", "QPDF not a... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x350(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27867e
movq -0x350(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x358(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x108, %rdi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::inParse(bool) | void
QPDF::inParse(bool v)
{
if (m->in_parse == v) {
// This happens if QPDFParser::parse tries to resolve an indirect object while it is
// parsing.
throw std::logic_error(
"QPDF: re-entrant parsing detected. This is a qpdf bug."
" Please report at https://github.com... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x63670
movb 0x2d3(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x27cc49
movl $0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readTrailer() | QPDFObjectHandle
QPDF::readTrailer()
{
qpdf_offset_t offset = m->file->tell();
auto [object, empty] = QPDFParser::parse(*m->file, "trailer", m->tokenizer, nullptr, *this);
if (empty) {
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
// actual PDF ... | pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x2d8(%rbp)
movq %rdi, %rax
movq %rax, -0x2d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x45fd0
movq %rax, %rdi
movq (%rdi), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::parse_xrefFirst(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&, int&) | bool
QPDF::parse_xrefFirst(std::string const& line, int& obj, int& num, int& bytes)
{
// is_space and is_digit both return false on '\0', so this will not overrun the null-terminated
// buffer.
char const* p = line.c_str();
char const* start = line.c_str();
// Skip zero or more spaces
while (ut... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b180
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b180
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %edi... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::read_xrefEntry(long long&, int&, char&) | bool
QPDF::read_xrefEntry(qpdf_offset_t& f1, int& f2, char& type)
{
std::array<char, 21> line;
if (m->file->read(line.data(), 20) != 20) {
// C++20: [[unlikely]]
return false;
}
line[20] = '\0';
char const* p = line.data();
int f1_len = 0;
int f2_len = 0;
// is_space an... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x45fd0
movq %rax, -0x58(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x28ae10
movq -0x58(%rbp)... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readObjectAtOffset(bool, long long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjGen, QPDFObjGen&, bool) | QPDFObjectHandle
QPDF::readObjectAtOffset(
bool try_recovery,
qpdf_offset_t offset,
std::string const& description,
QPDFObjGen exp_og,
QPDFObjGen& og,
bool skip_cache_if_in_xref)
{
bool check_og = true;
if (exp_og.getObj() == 0) {
// This method uses an expect object ID of 0 to i... | pushq %rbp
movq %rsp, %rbp
subq $0x700, %rsp # imm = 0x700
movq %rdi, -0x5b8(%rbp)
movq %rdi, %rax
movq %rax, -0x5b0(%rbp)
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %r9, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::processXRefStream(long long, QPDFObjectHandle&) | qpdf_offset_t
QPDF::processXRefStream(qpdf_offset_t xref_offset, QPDFObjectHandle& xref_obj)
{
auto damaged = [this, xref_offset](std::string_view msg) -> QPDFExc {
return damagedPDF("xref stream", xref_offset, msg.data());
};
auto dict = xref_obj.getDict();
auto [entry_size, W] = processXRefW... | pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x3e8(%... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::processXRefW(QPDFObjectHandle&, std::function<QPDFExc (std::basic_string_view<char, std::char_traits<char>>)>) | std::pair<int, std::array<int, 3>>
QPDF::processXRefW(QPDFObjectHandle& dict, std::function<QPDFExc(std::string_view)> damaged)
{
auto W_obj = dict.getKey("/W");
if (!(W_obj.isArray() && (W_obj.getArrayNItems() >= 3) && W_obj.getArrayItem(0).isInteger() &&
W_obj.getArrayItem(1).isInteger() && W_obj.ge... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdx, -0x148(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1be40
movq -0x138(%rbp), %rdx
leaq 0xab885(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::processXRefSize(QPDFObjectHandle&, int, std::function<QPDFExc (std::basic_string_view<char, std::char_traits<char>>)>) | int
QPDF::processXRefSize(
QPDFObjectHandle& dict, int entry_size, std::function<QPDFExc(std::string_view)> damaged)
{
// Number of entries is limited by the highest possible object id and stream size.
auto max_num_entries = std::numeric_limits<int>::max();
if (max_num_entries > (std::numeric_limits<qpd... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x632c0
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0xf0(%rbp)
callq 0x20df0
movslq -0x14(%rbp), %rcx
cqto
idivq %... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::resolve(QPDFObjGen) | std::shared_ptr<QPDFObject> const&
QPDF::resolve(QPDFObjGen og)
{
if (!isUnresolved(og)) {
return m->obj_cache[og].object;
}
if (m->resolving.count(og)) {
// This can happen if an object references itself directly or indirectly in some key that
// has to be resolved during object pa... | pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp # imm = 0x430
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x398(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x284130
testb $0x1, %al
jne 0x28420b
movq -0x398(%rbp), %rdi
callq 0x63670
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getObjectCount() | size_t
QPDF::getObjectCount()
{
// This method returns the next available indirect object number. makeIndirectObject uses it for
// this purpose. After fixDanglingReferences is called, all objects in the xref table will also
// be in obj_cache.
fixDanglingReferences();
QPDFObjGen og;
if (!m->obj... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
callq 0x284c70
leaq -0x10(%rbp), %rdi
callq 0x654e0
movq -0x28(%rbp), %rdi
callq 0x63670
movq %rax, %rdi
addq $0x1a8, %rdi # imm = 0x1A8
callq 0x28b510
testb $0x1, %al
jne 0x284d4c
m... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readStream(QPDFObjectHandle&, QPDFObjGen, long long) | void
QPDF::readStream(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
{
validateStreamLineEnd(object, og, offset);
// Must get offset before accessing any additional objects since resolving a previously
// unresolved indirect object will change file position.
qpdf_offset_t stream_offset ... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x200(%rbp)
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::recoverStreamLength(std::shared_ptr<InputSource>, QPDFObjGen, long long) | size_t
QPDF::recoverStreamLength(
std::shared_ptr<InputSource> input, QPDFObjGen og, qpdf_offset_t stream_offset)
{
// Try to reconstruct stream length by looking for endstream or endobj
warn(damagedPDF(*input, stream_offset, "attempting to recover stream length"));
PatternFinder ef(*this, &QPDF::findE... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movq %rsi, -0x368(%rbp)
movq %rdi, %rax
movq -0x368(%rbp), %rdi
movq %rdi, -0x360(%rbp)
movq %rdx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x358(%rbp)
callq 0x65080
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::findEndstream() | bool
QPDF::findEndstream()
{
// Find endstream or endobj. Position the input at that token.
auto t = readToken(*m->file, 20);
if (t.isWord("endobj") || t.isWord("endstream")) {
m->file->seek(m->file->getLastOffset(), SEEK_SET);
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x65080
movq -0xe8(%rbp), %rsi
movq %rax, %rdx
leaq -0x78(%rbp), %rdi
movl $0x14, %ecx
callq 0x2785a0
leaq -0x99(%rbp), %rdi
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::updateCache(QPDFObjGen, std::shared_ptr<QPDFObject> const&, long long, long long, bool) | void
QPDF::updateCache(
QPDFObjGen og,
std::shared_ptr<QPDFObject> const& object,
qpdf_offset_t end_before_space,
qpdf_offset_t end_after_space,
bool destroy)
{
object->setObjGen(this, og);
if (isCached(og)) {
auto& cache = m->obj_cache[og];
object->move_to(cache.object, dest... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %r9b, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x65ef0
movq -0x90(%rbp), %rsi
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::resolveObjectsInStream(int) | void
QPDF::resolveObjectsInStream(int obj_stream_number)
{
auto damaged =
[this, obj_stream_number](int id, qpdf_offset_t offset, std::string const& msg) -> QPDFExc {
return {
qpdf_e_damaged_pdf,
m->file->getName() + " object stream " + std::to_string(obj_stream_number),
... | pushq %rbp
movq %rsp, %rbp
subq $0xe60, %rsp # imm = 0xE60
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd20(%rbp)
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x2d8, %rdi # imm = 0x2D8
leaq -0xc(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::makeIndirectObject(QPDFObjectHandle) | QPDFObjectHandle
QPDF::makeIndirectObject(QPDFObjectHandle oh)
{
if (!oh) {
throw std::logic_error("attempted to make an uninitialized QPDFObjectHandle indirect");
}
return makeIndirectFromQPDFObject(oh.getObj());
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x42cb0
testb $0x1, %al
jne 0x28... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::replaceObject(QPDFObjGen, QPDFObjectHandle) | void
QPDF::replaceObject(QPDFObjGen og, QPDFObjectHandle oh)
{
if (!oh || (oh.isIndirect() && !(oh.isStream() && oh.getObjGen() == og))) {
QTC::TC("qpdf", "QPDF replaceObject called with indirect object");
throw std::logic_error("QPDF::replaceObject called with indirect object handle");
}
up... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x42cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x49(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0xa81cd(%rip), %rdi # 0x331f38
leaq 0xab503(%rip), %rsi # 0x335275
xorl %edx, %edx
callq 0x25230
movq -0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::tableSize() | size_t
QPDF::tableSize()
{
// If obj_cache is dense, accommodate all object in tables,else accommodate only original
// objects.
auto max_xref = m->xref_table.size() ? m->xref_table.crbegin()->first.getObj() : 0;
auto max_obj = m->obj_cache.size() ? m->obj_cache.crbegin()->first.getObj() : 0;
auto m... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x28a610
cmpq $0x0, %rax
je 0x289fe6
movq -0x80(%rbp), %rdi
callq 0x63670
movq %rax, %rsi
addq $0x138, %rsi # imm = 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
qpdf::is::OffsetBuffer::OffsetBuffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Buffer*, long long) | OffsetBuffer(std::string const& description, Buffer* buf, qpdf_offset_t global_offset) :
proxied(description, buf),
global_offset(global_offset)
{
if (global_offset < 0) {
throw std::logic_error("is::OffsetBuffer constructed with negative offset");
... | pushq %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)
callq 0x20c30
movq -0x40(%rbp), %rdi
leaq 0x204120(%rip), %rax # 0x48fae0
movq %rax, (%rdi)
addq $0xa8, %rdi
movq %rdi, -0x38(%rbp)
movq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/InputSource_private.hh |
QPDFObject::move_to(std::shared_ptr<QPDFObject>&, bool) | void
move_to(std::shared_ptr<QPDFObject>& o, bool destroy)
{
o->value = std::move(value);
o->qpdf = qpdf;
o->og = og;
o->object_description = object_description;
o->parsed_offset = parsed_offset;
if (!destroy) {
value = QPDF_Reference(o);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65ef0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x28f780
movq -0x58(%rbp), %rax
movq 0x48(%rax), %rax... | /jberkenbilt[P]qpdf/libqpdf/qpdf/QPDFObject_private.hh |
std::vector<QPDFObjGen, std::allocator<QPDFObjGen>> QPDF::getCompressibleObjGens<QPDFObjGen>() | std::vector<T>
QPDF::getCompressibleObjGens()
{
// Return a list of objects that are allowed to be in object streams. Walk through the objects
// by traversing the document from the root, including a traversal of the pages tree. This
// makes that objects that are on the same page are more likely to be in... | pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp # imm = 0x390
movq %rdi, -0x288(%rbp)
movq %rdi, %rax
movq %rax, -0x280(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x278(%rbp)
callq 0x63670
addq $0x208, %rax # imm = 0x208
movq %rax, -0x270(%rbp)
leaq -0x41(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::pushInheritedAttributesToPage(bool, bool) | void
QPDF::pushInheritedAttributesToPage(bool allow_changes, bool warn_skipped_keys)
{
// Traverse pages tree pushing all inherited resources down to the page level.
// The record of whether we've done this is cleared by updateAllPagesCache(). If we're warning
// for skipped keys, re-traverse unconditiona... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x63670
testb $0x1, 0x268(%rax)
je 0x29db53
testb $0x1, -0xa(%rbp)
jne 0x29db53
jmp 0x29ddcb
movq -0xc... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::filterCompressedObjects(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&) | void
QPDF::filterCompressedObjects(std::map<int, int> const& object_stream_data)
{
if (object_stream_data.empty()) {
return;
}
// Transform object_to_obj_users and obj_user_to_objects so that they refer only to uncompressed
// objects. If something is a user of a compressed object, then it is ... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a1ec0
testb $0x1, %al
jne 0x29f78d
jmp 0x29f792
jmp 0x29fcb6
leaq -0x40(%rbp), %rdi
callq 0x63560
leaq -0x70(%rbp), %rdi
callq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::filterCompressedObjects(QPDFWriter::ObjTable const&) | void
QPDF::filterCompressedObjects(QPDFWriter::ObjTable const& obj)
{
if (obj.getStreamsEmpty()) {
return;
}
// Transform object_to_obj_users and obj_user_to_objects so that they refer only to uncompressed
// objects. If something is a user of a compressed object, then it is really a user of t... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a20d0
testb $0x1, %al
jne 0x29fcfd
jmp 0x29fd02
jmp 0x2a021b
leaq -0x40(%rbp), %rdi
callq 0x63560
leaq -0x70(%rbp), %rdi
callq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
void QPDF::optimize_internal<std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>>(std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const&, bool, std::function<int (QPDFObjectHandle&)>) | void
QPDF::optimize_internal(
T const& object_stream_data,
bool allow_changes,
std::function<int(QPDFObjectHandle&)> skip_stream_parameters)
{
if (!m->obj_user_to_objects.empty()) {
// already optimized
return;
}
// The PDF specification indicates that /Outlines is supposed to b... | pushq %rbp
movq %rsp, %rbp
subq $0x3b0, %rsp # imm = 0x3B0
movq %rcx, -0x2f8(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0x63670
movq %rax, %rdi
addq $0x528, %rdi # ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::updateAllPagesCache() | void
QPDF::updateAllPagesCache()
{
// Force regeneration of the pages cache. We force immediate recalculation of all_pages since
// users may have references to it that they got from calls to getAllPages(). We can defer
// recalculation of pageobj_to_pages_pos until needed.
QTC::TC("qpdf", "QPDF updat... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x8883d(%rip), %rdi # 0x331f38
leaq 0x8c383(%rip), %rsi # 0x335a85
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rdi
callq 0x63670
movq %rax, %rdi
addq $0x218, %rdi # imm = 0x218
cal... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.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.