name string | code string | asm string | file string |
|---|---|---|---|
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 0x80370
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x25be70
movq -0x680(%rbp), %rdi
movl %eax, -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::maxEnd(QPDF::ObjUser const&) | qpdf_offset_t
QPDF::maxEnd(ObjUser const& ou)
{
if (m->obj_user_to_objects.count(ou) == 0) {
stopOnError("no entry in object user table for requested object user");
}
qpdf_offset_t end = 0;
for (auto const& og: m->obj_user_to_objects[ou]) {
if (!m->obj_cache.count(og)) {
stop... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6d820
movq %rax, %rdi
addq $0x528, %rdi # imm = 0x528
movq -0x10(%rbp), %rsi
callq 0x275130
cmpq $0x0, %rax
jne 0x26de20
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
... | /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::dumpHSharedObject() | void
QPDF::dumpHSharedObject()
{
HSharedObject& t = m->shared_object_hints;
*m->log->getInfo() << "first_shared_obj: " << t.first_shared_obj << "\n"
<< "first_shared_offset: " << adjusted_offset(t.first_shared_offset) << "\n"
<< "nshared_first_page: " << t.nshared_f... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6d820
movq -0x88(%rbp), %rdi
addq $0x3c0, %rax # imm = 0x3C0
movq %rax, -0x10(%rbp)
callq 0x6d820
movq %rax, %rdi
callq 0x6dca0
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 0x6d820
movq %rax, %rdi
callq 0x6dca0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
xorl %edx, %edx
callq 0x1b9770
movq -0x40(%rbp), %rdi
callq 0x6df60
movq %rax, %... | /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 0x278ab0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::calculateHSharedObject(QPDFWriter::NewObjTable const&, QPDFWriter::ObjTable const&) | void
QPDF::calculateHSharedObject(
QPDFWriter::NewObjTable const& new_obj, QPDFWriter::ObjTable const& obj)
{
CHSharedObject& cso = m->c_shared_object_data;
std::vector<CHSharedObjectEntry>& csoe = cso.entries;
HSharedObject& so = m->shared_object_hints;
std::vector<HSharedObjectEntry>& soe = so.ent... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6d820
movq -0xc0(%rbp), %rdi
addq $0x470, %rax # imm = 0x470
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x10,... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::writeHPageOffset(BitWriter&) | void
QPDF::writeHPageOffset(BitWriter& w)
{
HPageOffset& t = m->page_offset_hints;
w.writeBitsInt(t.min_nobjects, 32); // 1
w.writeBits(toULL(t.first_page_offset), 32); // 2
w.writeBitsInt(t.nbits_delta_nobjects, 16); // 3
w.writeBitsInt(t.min_page_length, 32); /... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6d820
addq $0x368, %rax # imm = 0x368
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x20, %edx
callq 0x29f10
movq -0x10(... | /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 0x535b0
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 0x535b0
movq %rax, %rcx
movq -0x48(%rbp), %r... | /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 0x535b0
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 0x1ce00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1c1f0
movq %rax, -0x1c8(%rbp)
jmp 0x278fb4
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, 0x221069(%rip) # 0x4a17e8
jne 0x2807ae
leaq 0x221060(%rip), %rdi # 0x4a17e8
callq 0x1c530
cmpl $0x0, %eax
je 0x2807ae
movq -0x30(%rbp), %rdi
callq 0x22bfa0
movq %rax, ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/ObjTable.hh |
QPDF::findStartxref() | bool
QPDF::findStartxref()
{
if (readToken(*m->file).isWord("startxref") && readToken(*m->file).isInteger()) {
// Position in front of offset token
m->file->seek(m->file->getLastOffset(), SEEK_SET);
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x6d820
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x6f230
movq -0x130(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x78(%rbp), %rdi
callq 0x282520
leaq -0x9... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::read_xref(long long) | void
QPDF::read_xref(qpdf_offset_t xref_offset)
{
std::map<int, int> free_table;
std::set<qpdf_offset_t> visited;
while (xref_offset) {
visited.insert(xref_offset);
char buf[7];
memset(buf, 0, sizeof(buf));
m->file->seek(xref_offset, SEEK_SET);
// Some files miss the ... | pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp # imm = 0x4F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x400(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x224e50
leaq -0x70(%rbp), %rdi
callq 0x294b90
cmpq $0x0, -0x10(%rbp)
je 0x2838a8
leaq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
ca... | /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 0x6d820
movb 0x2d3(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x286bc9
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 0x6d820
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x50160
movq %rax, %rdi
movq (%rdi), %rax... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::read_xrefStream(long long) | qpdf_offset_t
QPDF::read_xrefStream(qpdf_offset_t xref_offset)
{
if (!m->ignore_xref_streams) {
QPDFObjGen x_og;
QPDFObjectHandle xref_obj;
try {
xref_obj =
readObjectAtOffset(false, xref_offset, "xref stream", QPDFObjGen(0, 0), x_og, true);
} catch (QPDFE... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x6d820
testb $0x1, 0xf1(%rax)
jne 0x28947e
leaq -0x20(%rbp), %rdi
callq 0x6f690
leaq -0x30(%rbp), %rdi
callq 0x4cc50
movq -0x18(%rbp), %rax
movq %rax,... | /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::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 0x1ce40
movq -0x138(%rbp), %rdx
leaq 0xac3c5(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::processXRefIndex(QPDFObjectHandle&, int, std::function<QPDFExc (std::basic_string_view<char, std::char_traits<char>>)>) | std::pair<int, std::vector<std::pair<int, int>>>
QPDF::processXRefIndex(
QPDFObjectHandle& dict, int max_num_entries, std::function<QPDFExc(std::string_view)> damaged)
{
auto size = dict.getKey("/Size").getIntValueAsInt();
auto Index_obj = dict.getKey("/Index");
if (Index_obj.isArray()) {
std::... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %r8, -0x3d0(%rbp)
movq %rdi, -0x3c8(%rbp)
movq %rdi, %rax
movq %rax, -0x3c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x3b8(%rbp)
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::getAllObjects() | std::vector<QPDFObjectHandle>
QPDF::getAllObjects()
{
// After fixDanglingReferences is called, all objects are in the object cache.
fixDanglingReferences();
std::vector<QPDFObjectHandle> result;
for (auto const& iter: m->obj_cache) {
result.push_back(newIndirect(iter.first, iter.second.object))... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %esi, %esi
callq 0x28ebf0
movq -0x70(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x6d4c0
movq -0x68(%rbp), %rdi
callq 0x6... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::validateStreamLineEnd(QPDFObjectHandle&, QPDFObjGen, long long) | void
QPDF::validateStreamLineEnd(QPDFObjectHandle& object, QPDFObjGen og, qpdf_offset_t offset)
{
// The PDF specification states that the word "stream" should be followed by either a carriage
// return and a newline or by a newline alone. It specifically disallowed following it by a
// carriage return alo... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
callq 0x6d820
movq %rax, %rdi
addq $0xb0, %rdi
callq 0x50160
movq %rax, %rdi
movq (%rdi)... | /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 0x6f230
movq %rax,... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::readObjectInStream(qpdf::is::OffsetBuffer&, int, int) | QPDFObjectHandle
QPDF::readObjectInStream(is::OffsetBuffer& input, int stream_id, int obj_id)
{
auto [object, empty] = QPDFParser::parse(input, stream_id, obj_id, m->tokenizer, *this);
if (empty) {
// Nothing in the PDF spec appears to allow empty objects, but they have been encountered in
// ac... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x208(%rbp)
movq -0x18(%rbp), %rax
mo... | /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 0x700a0
movq -0x90(%rbp), %rsi
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::nextObjGen() | QPDFObjGen
QPDF::nextObjGen()
{
int max_objid = toI(getObjectCount());
if (max_objid == std::numeric_limits<int>::max()) {
throw std::range_error("max object id is too high to create new objects");
}
return QPDFObjGen(max_objid + 1, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28ec60
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x25be70
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x6d470
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x293399
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QPDF::makeIndirectFromQPDFObject(std::shared_ptr<QPDFObject> const&) | QPDFObjectHandle
QPDF::makeIndirectFromQPDFObject(std::shared_ptr<QPDFObject> const& obj)
{
QPDFObjGen next{nextObjGen()};
m->obj_cache[next] = ObjCache(obj, -1, -1);
return newIndirect(next, m->obj_cache[next].object);
} | 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)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x293310
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70... | /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 0xa8d0d(%rip), %rdi # 0x33c9f8
leaq 0xac043(%rip), %rsi # 0x33fd35
xorl %edx, %edx
callq 0x2f540
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 0x6d820
movq %rax, %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x294590
cmpq $0x0, %rax
je 0x293f66
movq -0x80(%rbp), %rdi
callq 0x6d820
movq %rax, %rsi
addq $0x138, %rsi # imm = 0... | /jberkenbilt[P]qpdf/libqpdf/QPDF_objects.cc |
QIntC::IntConverter<long, int, true, true>::error(long) | 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
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1ce00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1c1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2a05f3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QPDF::ObjUser::operator<(QPDF::ObjUser const&) const | bool
QPDF::ObjUser::operator<(ObjUser const& rhs) const
{
if (ou_type < rhs.ou_type) {
return true;
}
if (ou_type == rhs.ou_type) {
if (pageno < rhs.pageno) {
return true;
}
if (pageno == rhs.pageno) {
return key < rhs.key;
}
}
return f... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2a7868
movb $0x1, -0x1(%rbp)
jmp 0x2a78be
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), ... | /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 0x2ac050
testb $0x1, %al
jne 0x2a9c7d
jmp 0x2a9c82
jmp 0x2aa19b
leaq -0x40(%rbp), %rdi
callq 0x6d710
leaq -0x70(%rbp), %rdi
callq ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_optimization.cc |
QPDF::getAllPages() | std::vector<QPDFObjectHandle> const&
QPDF::getAllPages()
{
// Note that pushInheritedAttributesToPage may also be used to initialize m->all_pages.
if (m->all_pages.empty() && !m->invalid_page_found) {
m->ever_called_get_all_pages = true;
QPDFObjGen::set visited;
QPDFObjGen::set seen;
... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x6d820
movq %rax, %rdi
addq $0x218, %rdi # imm = 0x218
callq 0x1ecad0
testb $0x1, %al
jne 0x2b1027
jmp 0x2b1912
movq -0x228(%rbp), %rdi
callq 0x6d820
testb $0x1, 0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
QPDF::removePage(QPDFObjectHandle) | void
QPDF::removePage(QPDFObjectHandle page)
{
int pos = findPage(page); // also ensures flat /Pages
QTC::TC(
"qpdf",
"QPDF remove page",
(pos == 0) ? 0 : // remove at beginning
(pos == toI(m->all_pages.size() - 1)) ? 1 // end
... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rsi, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x2b47c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2b434d
xorl %eax, %eax
movl %eax, -0x12c(%rbp)
jmp 0x2b439f
movq -0x... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> int_to_string_base_internal<unsigned long long>(unsigned long long, int, int) | static std::string
int_to_string_base_internal(T num, int base, int length)
{
// Backward compatibility -- int_to_string, which calls this function, used to use sprintf with
// %0*d, so we interpret length such that a negative value appends spaces and a positive value
// prepends zeroes.
if (!((base == ... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x8, -0x14(%rbp)
je 0x2b8998
cmpl $0xa, -0x14(%rbp)
je 0x2b8998
cmpl $0x10, -0x14(%rbp)
j... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::string_to_ll(char const*) | long long
QUtil::string_to_ll(char const* str)
{
errno = 0;
#ifdef _MSC_VER
long long result = _strtoi64(str, 0, 10);
#else
long long result = strtoll(str, nullptr, 10);
#endif
if (errno == ERANGE) {
throw std::range_error(
std::string("overflow/underflow converting ") + str + " to 6... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1cec0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1ca90
movq %rax, -0x10(%rbp)
callq 0x1cec0
cmpl $0x22, (%rax)
jne 0x2b8fcf
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0x1c580
movq %rax, -0x9... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::file_provider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0::~$_0() | std::string
QUtil::path_basename(std::string const& filename)
{
#ifdef _WIN32
char const* pathsep = "/\\";
#else
char const* pathsep = "/";
#endif
std::string last = filename;
auto len = last.length();
while (len > 1) {
auto pos = last.find_last_of(pathsep);
if (pos == len - 1) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d1e8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::hex_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::hex_decode(std::string const& input)
{
std::string result;
// We know result.size() <= 0.5 * input.size() + 1. However, reserving string space for this
// upper bound has a negative impact.
bool first = true;
char decoded;
for (auto ch: input) {
ch = util::hex_decode_c... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1c510
movb $0x1, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c380
movq %rax, -0x28(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_env(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::get_env(std::string const& var, std::string* value)
{
// This was basically ripped out of wxWindows.
#ifdef _WIN32
# ifdef NO_GET_ENVIRONMENT
return false;
# else
// first get the size of the buffer
DWORD len = ::GetEnvironmentVariable(var.c_str(), NULL, 0);
if (len == 0) {
// th... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c180
movq %rax, %rdi
callq 0x1ca60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2ba3e2
movb $0x0, -0x1(%rbp)
jmp 0x2ba3fa
cmpq $0x0, -0x18(%rbp)
je 0x2ba3f6
movq -0x20(%rbp), %rsi
movq -0x18(... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::qpdf_time_to_pdf_time[abi:cxx11](QUtil::QPDFTime const&) | std::string
QUtil::qpdf_time_to_pdf_time(QPDFTime const& qtm)
{
std::string tz_offset;
int t = qtm.tz_delta;
if (t == 0) {
tz_offset = "Z";
} else {
if (t < 0) {
t = -t;
tz_offset += "+";
} else {
tz_offset += "-";
}
tz_offset +... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c510
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x2ba515
... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::qpdf_time_to_iso8601[abi:cxx11](QUtil::QPDFTime const&) | std::string
QUtil::qpdf_time_to_iso8601(QPDFTime const& qtm)
{
std::string tz_offset;
int t = qtm.tz_delta;
if (t == 0) {
tz_offset = "Z";
} else {
if (t < 0) {
t = -t;
tz_offset += "+";
} else {
tz_offset += "-";
}
tz_offset +=... | pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp # imm = 0x2E0
movq %rdi, -0x2d8(%rbp)
movq %rdi, %rax
movq %rax, -0x2d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c510
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x2baaa5
... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::toUTF8[abi:cxx11](unsigned long) | std::string
QUtil::toUTF8(unsigned long uval)
{
std::string result;
// A UTF-8 encoding of a Unicode value is a single byte for Unicode values <= 127. For larger
// values, the first byte of the UTF-8 encoding has '1' as each of its n highest bits and '0'
// for its (n+1)th highest bit where n is the ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1c510
cmpq $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
jbe 0x2bb76a
movl $0x10, %edi
callq 0x1c580
movq %rax, %rdi
movq %rdi, %rax
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_lines_from_file[abi:cxx11](char const*, bool) | std::list<std::string>
QUtil::read_lines_from_file(char const* filename, bool preserve_eol)
{
std::list<std::string> lines;
FILE* f = safe_fopen(filename, "rb");
FileCloser fc(f);
auto next_char = [&f](char& ch) { return read_char_from_FILE(ch, f); };
read_lines_from_file(next_char, lines, preserve_... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0xd02e0
movq -0x10(%rbp), %rdi
leaq 0x5b313(%rip), %rsi # 0x31802c
callq 0x2b9510
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::utf16_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::utf16_to_utf8(std::string const& val)
{
std::string result;
// This code uses unsigned long and unsigned short to hold codepoint values. It requires
// unsigned long to be at least 32 bits and unsigned short to be at least 16 bits, but it will
// work fine if they are larger.
unsi... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1c510
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c850
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::mac_roman_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::mac_roman_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if (ch >= 128) {
ch_short = mac_r... | 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)
movb $0x0, -0x11(%rbp)
callq 0x1c510
movq -0x10(%rbp), %rdi
callq 0x1c850
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_max_memory_usage() | size_t
QUtil::get_max_memory_usage()
{
#if defined(HAVE_MALLOC_INFO) && defined(HAVE_OPEN_MEMSTREAM)
static std::regex tag_re("<(/?\\w+)([^>]*?)>");
static std::regex attr_re("(\\w+)=\"(.*?)\"");
char* buf;
size_t size;
FILE* f = open_memstream(&buf, &size);
if (f == nullptr) {
return 0... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
cmpb $0x0, 0x1e17ee(%rip) # 0x4a1980
jne 0x2c01e5
leaq 0x1e17e5(%rip), %rdi # 0x4a1980
callq 0x1c530
cmpl $0x0, %eax
je 0x2c01e5
leaq 0x1e17b4(%rip), %rdi # 0x4a1960
leaq 0x814ff(%rip), %rsi # 0x3416b2
movl $0x10, %edx
callq 0x6ee00
jmp ... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QIntC::IntConverter<char, unsigned long, true, false>::error(char) | 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
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movb %dil, %al
movb %al, -0x1(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1ce00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1c1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2c3b95
movq -0x1c8(%rbp), %rdx
m... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<int, unsigned char, true, false>::convert(int const&) | inline static To
convert(From const& i)
{
// From is signed, and To is unsigned. If i > 0, it's safe to
// convert it to the corresponding unsigned type and to
// compare with To's max.
auto ii = static_cast<typename to_u<From>::type>(i);
if ((... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x2c4505
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x51f60
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jbe 0x2c451... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
SecureRandomDataProvider::provideRandomData(unsigned char*, unsigned long) | void
SecureRandomDataProvider::provideRandomData(unsigned char* data, size_t len)
{
# if defined(_WIN32)
// Optimization: make the WindowsCryptProvider static as long as
// it can be done in a thread-safe fashion.
WindowsCryptProvider c;
if (!CryptGenRandom(c.crypt_prov, static_cast<DWORD>(len), reinte... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpb $0x0, 0x1cf59a(%rip) # 0x4a1a88
jne 0x2d2539
leaq 0x1cf591(%rip), %rdi # 0x4a1a88
callq 0x1c530
cmpl $0x0, %eax
je 0x2d2539
leaq 0x1cf578(%rip), %rdi # 0x4a1a80
leaq -0x19(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/SecureRandomDataProvider.cc |
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle) | bool
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle decode_parms)
{
if (decode_parms.isNull()) {
return true;
}
auto memory_limit = Pl_Flate::memory_limit();
std::set<std::string> keys = decode_parms.getKeys();
for (auto const& key: keys) {
QPDFObjectHandle value = decode_parms... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x1c9770
testb $0x1, %al
jne 0x2d2d31
jmp 0x2d2d3a
movb $0x1, -0x1(%rbp)
jmp 0x2d31d3
callq 0... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
qpdf_next_warning | qpdf_error
qpdf_next_warning(qpdf_data qpdf)
{
if (qpdf_more_warnings(qpdf)) {
qpdf->tmp_error.exc = std::make_shared<QPDFExc>(qpdf->warnings.front());
qpdf->warnings.pop_front();
QTC::TC("qpdf", "qpdf-c qpdf_next_warning returned warning");
return &qpdf->tmp_error;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d6c80
cmpl $0x0, %eax
je 0x2d6ecd
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x304530
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x3044c0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x304470
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_info_key | void
qpdf_set_info_key(qpdf_data qpdf, char const* key, char const* value)
{
if ((key == nullptr) || (std::strlen(key) == 0) || (key[0] != '/')) {
return;
}
QPDFObjectHandle value_object;
if (value) {
QTC::TC("qpdf", "qpdf-c set_info_key to value");
value_object = QPDFObjectHandl... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d7dd9
movq -0x10(%rbp), %rdi
callq 0x1c5a0
cmpq $0x0, %rax
je 0x2d7dd9
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2d7dde
jmp 0x2d82... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r3_encryption_parameters_insecure | void
qpdf_set_r3_encryption_parameters_insecure(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_accessibility,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_assemble,
QPDF_BOOL allow_annotate_and_form,
QPDF_BOOL allow_form_filling,
QPDF_BOOL allow_m... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
leaq 0x63af3(%rip), %rdi ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r5_encryption_parameters2 | void
qpdf_set_r5_encryption_parameters2(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_accessibility,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_assemble,
QPDF_BOOL allow_annotate_and_form,
QPDF_BOOL allow_form_filling,
QPDF_BOOL allow_modify_ot... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movl %r8d, -0x38(%rbp)
movl %r9d, -0x3c(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
int do_with_oh<int>(_qpdf_data*, unsigned int, std::function<int ()>, std::function<int (QPDFObjectHandle&)>) | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb0(%rbp)
movl %esi, %eax
movq -0xb0(%rbp), %rsi
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x30c060
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_wrap_in_array | qpdf_oh
qpdf_oh_wrap_in_array(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<qpdf_oh>(
qpdf,
oh,
[qpdf]() { return qpdf_oh_new_array(qpdf); },
[qpdf](QPDFObjectHandle& qoh) {
if (qoh.isArray()) {
QTC::TC("qpdf", "qpdf-c array to wrap_in_array");
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x84(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2dbfd0
movq -0x8(%rbp), %rax
movq %rax, -0... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_real_value | char const*
qpdf_oh_get_real_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_real_value");
qpdf->tmp_string = o.getRealValue();
return qpdf->t... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq 0x5d1a3(%rip), %rax # 0x33a480
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_real | QPDF_BOOL
qpdf_oh_get_value_as_real(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_real");
auto result = o.getValu... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x31b5(%rip), %rsi # 0x2da290
leaq -0x40(%rbp), %rdi
callq 0x304900
movq -0x8(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_string | QPDF_BOOL
qpdf_oh_get_value_as_string(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_string");
auto result = o.get... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x3ba5(%rip), %rsi # 0x2da290
leaq -0x40(%rbp), %rdi
callq 0x304900
movq -0x8(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_binary_utf8_value | char const*
qpdf_oh_get_binary_utf8_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_utf8_value");
qpdf->tmp_string = o.getU... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq 0x5c05f(%rip), %rax # 0x33a480
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x40... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> do_with_oh<std::set<std::__cxx11::basic_stri... | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %r8, -0xa8(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rsi, %rax
movq -0xc8(%rbp), %rsi
movq %rdi, -0xc0(%rbp)
movq %rdi, %rcx
movq %rcx, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_dict_next_key | char const*
qpdf_oh_dict_next_key(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_dict_next_key");
if (qpdf_oh_dict_more_keys(qpdf)) {
qpdf->cur_dict_key = *qpdf->dict_iter;
++qpdf->dict_iter;
return qpdf->cur_dict_key.c_str();
} else {
return nullptr;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5ddc5(%rip), %rdi # 0x33c9f8
leaq 0x656ea(%rip), %rsi # 0x344324
xorl %edx, %edx
callq 0x2f540
movq -0x10(%rbp), %rdi
callq 0x2debc0
cmpl $0x0, %eax
je 0x2dec98
movq -0x10(%rbp), %rdi
addq $0x120, %rdi # imm = 0x120
callq 0xd05... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_unparse_binary | char const*
qpdf_oh_unparse_binary(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_unparse_binary");
qpdf->tmp_string = o.unparseBinary();
return qpdf->... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq 0x59793(%rip), %rax # 0x33a480
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_page_content_data | QPDF_ERROR_CODE
qpdf_oh_get_page_content_data(qpdf_data qpdf, qpdf_oh page_oh, unsigned char** bufp, size_t* len)
{
return trap_errors(qpdf, [page_oh, bufp, len](qpdf_data q) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_page_content_data");
auto o = qpdf_oh_item_internal(q, page_oh);
Pl_Buff... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_num_pages | int
qpdf_get_num_pages(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_num_pages");
int n = -1;
QPDF_ERROR_CODE code =
trap_errors(qpdf, [&n](qpdf_data q) { n = QIntC::to_int(q->qpdf->getAllPages().size()); });
if (code & QPDF_ERRORS) {
return -1;
}
return n;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5b655(%rip), %rdi # 0x33c9f8
leaq 0x631c5(%rip), %rsi # 0x34456f
xorl %edx, %edx
callq 0x2f540
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
le... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_find_page_by_id | int
qpdf_find_page_by_id(qpdf_data qpdf, int objid, int generation)
{
QTC::TC("qpdf", "qpdf-c called qpdf_find_page_by_id");
int n = -1;
QPDFObjGen og(objid, generation);
QPDF_ERROR_CODE code =
trap_errors(qpdf, [&n, &og](qpdf_data q) { n = QIntC::to_int(q->qpdf->findPage(og)); });
if (code ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq 0x5b29c(%rip), %rdi # 0x33c9f8
leaq 0x62e71(%rip), %rsi # 0x3445d4
xorl %edx, %edx
callq 0x2f540
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
le... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_item_internal(_qpdf_data*, unsigned int) | static QPDFObjectHandle
qpdf_oh_item_internal(qpdf_data qpdf, qpdf_oh item)
{
return do_with_oh<QPDFObjectHandle>(
qpdf,
item,
[]() { return QPDFObjectHandle::newNull(); },
[](QPDFObjectHandle& o) { return o; });
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_write_json | QPDF_ERROR_CODE
qpdf_write_json(
qpdf_data qpdf,
int version,
qpdf_write_fn_t fn,
void* udata,
enum qpdf_stream_decode_level_e decode_level,
enum qpdf_json_stream_data_e json_stream_data,
char const* file_prefix,
char const* const* wanted_objects)
{
QPDF_ERROR_CODE status = QPDF_SUCC... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
l... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
bool do_with_oh<bool>(_qpdf_data*, unsigned int, std::function<bool ()>, std::function<bool (QPDFObjectHandle&)>) | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb0(%rbp)
movl %esi, %eax
movq -0xb0(%rbp), %rsi
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x307c80
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
bool trap_oh_errors<bool>(_qpdf_data*, std::function<bool ()>, std::function<bool (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x21(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_object_type_e trap_oh_errors<qpdf_object_type_e>(_qpdf_data*, std::function<qpdf_object_type_e ()>, std::function<qpdf_object_type_e (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
long long trap_oh_errors<long long>(_qpdf_data*, std::function<long long ()>, std::function<long long (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_update_all_pages_cache::$_0::operator()(_qpdf_data*) const | int
qpdf_find_page_by_id(qpdf_data qpdf, int objid, int generation)
{
QTC::TC("qpdf", "qpdf-c called qpdf_find_page_by_id");
int n = -1;
QPDFObjGen og(objid, generation);
QPDF_ERROR_CODE code =
trap_errors(qpdf, [&n, &og](qpdf_data q) { n = QIntC::to_int(q->qpdf->findPage(og)); });
if (code ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3043c0
movq %rax, %rdi
callq 0x2b3660
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
QPDFExc::operator=(QPDFExc const&) | class QPDF_DLL_CLASS QPDFExc: public std::runtime_error
{
public:
QPDF_DLL
QPDFExc(
qpdf_error_code_e error_code,
std::string const& filename,
std::string const& object,
qpdf_offset_t offset,
std::string const& message);
QPDF_DLL
QPDFExc(
qpdf_error_cod... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c5d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
ca... | /jberkenbilt[P]qpdf/include/qpdf/QPDFExc.hh |
qpdfjob_create_qpdf | qpdf_data
qpdfjob_create_qpdf(qpdfjob_handle j)
{
QUtil::setLineBuf(stdout);
try {
auto qpdf = j->j.createQPDF();
return qpdf ? new _qpdf_data(std::move(qpdf)) : nullptr;
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq 0x18fcaa(%rip), %rax # 0x49ff30
movq (%rax), %rdi
callq 0x2ba2c0
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xef0b0
jmp 0x31029d
leaq -0x18(%rbp), %rdi
callq 0x11a800
movb $0x0, -0x31(%rbp)
testb $0x1, %al
jne 0x3102b0
jmp 0x3102ed
movl... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
run_with_handle(std::function<int (_qpdfjob_handle*)>) | static int
run_with_handle(std::function<int(qpdfjob_handle)> fn)
{
auto j = qpdfjob_init();
int status = fn(j);
if (status == 0) {
status = qpdfjob_run(j);
}
qpdfjob_cleanup(&j);
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x30fa90
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3127b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x31069b
movq -0x10(%rbp), %rdi
callq 0x310160
movl %eax, -0x14(%rbp)
leaq -0x10(%... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdf_data::_qpdf_data(std::unique_ptr<QPDF, std::default_delete<QPDF>>&&) | _qpdf_data(std::unique_ptr<QPDF>&& qpdf) :
qpdf(std::move(qpdf)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3127f0
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x304d20
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x304d40
movq -0x18(%rbp), %rdi
addq $0x30, %rd... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
set_log_dest(QPDFLogger*, std::function<void (std::shared_ptr<Pipeline>)>, qpdf_log_dest_e, char const*, int (*)(char const*, unsigned long, void*), void*) | static void
set_log_dest(
QPDFLogger* l,
std::function<void(std::shared_ptr<Pipeline>)> method,
qpdf_log_dest_e dest,
char const* identifier,
qpdf_log_fn_t fn,
void* udata)
{
switch (dest) {
case qpdf_log_dest_default:
method(nullptr);
break;
case qpdf_log_dest_stdout... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0xb0(%rbp)
subq $0x4, %rax
ja 0x3135c8
movq -0xb0(%rbp), %rax
leaq 0x320c9(%rip), %... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
QPDFCrypto_openssl::SHA2_finalize() | void
QPDFCrypto_openssl::SHA2_finalize()
{
#ifdef QPDF_OPENSSL_1
auto md = EVP_MD_CTX_md(md_ctx);
#else
auto md = EVP_MD_CTX_get0_md(md_ctx);
#endif
if (md) {
check_openssl(EVP_DigestFinal(md_ctx, md_out + 0, nullptr));
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x1c970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3158b4
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x18, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1c1a0
movl %eax... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
p_crypto_hash_gost3411_finish | void
p_crypto_hash_gost3411_finish (PHashGOST3411 *ctx)
{
puint32 left;
puint32 last;
left = ctx->len[0] & 0xFF;
last = 32 - (left >> 3);
if (last % 32 != 0) {
memset ((pchar *) ctx->buf + (left >> 3), 0, last);
pp_crypto_hash_gost3411_swap_bytes (ctx->buf, 8);
pp_crypto_hash_gost3411_process (ctx, ctx->bu... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
shrl $0x3, %ecx
movl $0x20, %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0x1f, %eax
cmpl $0x0, %eax
je 0x132dd
movq -0x8(... | /saprykin[P]plibsys/src/pcryptohash-gost3411.c |
p_socket_address_is_loopback | P_LIB_API pboolean
p_socket_address_is_loopback (const PSocketAddress *addr)
{
puint32 addr4;
if (P_UNLIKELY (addr == NULL || addr->family == P_SOCKET_FAMILY_UNKNOWN))
return FALSE;
if (addr->family == P_SOCKET_FAMILY_INET) {
addr4 = p_ntohl (* ((puint32 *) &addr->addr.sin_addr));
/* 127.0.0.0/8 */
return... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x25(%rbp)
je 0x20e15
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je ... | /saprykin[P]plibsys/src/psocketaddress.c |
p_strdup | P_LIB_API pchar *
p_strdup (const pchar *str)
{
pchar *ret;
psize len;
if (P_UNLIKELY (str == NULL))
return NULL;
len = strlen (str) + 1;
if (P_UNLIKELY ((ret = p_malloc (len)) == NULL))
return NULL;
memcpy (ret, str, len);
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x20f7f
movq $0x0, -0x8(%rbp)
jmp 0x20fd8
movq -0x10(%rbp), %rdi
callq 0x6220
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp)... | /saprykin[P]plibsys/src/pstring.c |
p_strchomp | P_LIB_API pchar *
p_strchomp (const pchar *str)
{
pssize pos_start;
pssize pos_end;
psize str_len;
pchar *ret;
const pchar *ptr;
if (P_UNLIKELY (str == NULL))
return NULL;
ptr = str;
pos_start = 0;
pos_end = ((pssize) strlen (str)) - 1;
while (pos_start < pos_end && isspace (* ((const puchar ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x21022
movq $0x0, -0x8(%rbp)
jmp 0x211c3
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi... | /saprykin[P]plibsys/src/pstring.c |
p_strtok | P_LIB_API pchar *
p_strtok (pchar *str, const pchar *delim, pchar **buf)
{
if (P_UNLIKELY (delim == NULL))
return str;
#ifdef P_OS_WIN
# ifdef P_CC_MSVC
if (P_UNLIKELY (buf == NULL))
return str;
# if _MSC_VER < 1400
P_UNUSED (buf);
return strtok (str, delim);
# else
return strtok_s (str, delim, buf);
#... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x21207
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2123f
cmpq $0x0, -0x20(%rbp)... | /saprykin[P]plibsys/src/pstring.c |
p_strtod | P_LIB_API double
p_strtod (const pchar *str)
{
double sign;
double value;
double scale;
double pow10;
puint expon;
pint frac;
pchar *orig_str;
const pchar *strp;
orig_str = p_strchomp (str);
if (P_UNLIKELY (orig_str == NULL))
return 0.0;
strp = orig_str;
sign = 1.0;
if (*strp == '-') {
sign ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63a0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2128f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x21565
movq -0x40(... | /saprykin[P]plibsys/src/pstring.c |
p_time_profiler_new | P_LIB_API PTimeProfiler *
p_time_profiler_new ()
{
PTimeProfiler *ret;
if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PTimeProfiler))) == NULL)) {
P_ERROR ("PTimeProfiler: failed to allocate memory");
return NULL;
}
ret->counter = p_time_profiler_get_ticks_internal ();
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x8, %edi
callq 0x6700
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x215bd
leaq 0x6a87(%rip), %rdi # 0x2802c
leaq 0x8156(%rip), %rsi # 0x29702
movb $0x0, %al
callq 0x62... | /saprykin[P]plibsys/src/ptimeprofiler.c |
p_tree_insert | P_LIB_API void
p_tree_insert (PTree *tree,
ppointer key,
ppointer value)
{
pboolean result;
if (P_UNLIKELY (tree == NULL))
return;
result = tree->insert_node_func (&tree->root,
tree->compare_func,
tree->data,
tree->key_destroy_func,
tree->value_destroy_func,
key,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x218ef
jmp 0x2193f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq... | /saprykin[P]plibsys/src/ptree.c |
p_tree_remove | P_LIB_API pboolean
p_tree_remove (PTree *tree,
pconstpointer key)
{
pboolean result;
if (P_UNLIKELY (tree == NULL || tree->root == NULL))
return FALSE;
result = tree->remove_node_func (&tree->root,
tree->compare_func,
tree->data,
tree->key_destroy_func,
tree->value_destroy_func,
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1d(%rbp)
je 0x2197a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
c... | /saprykin[P]plibsys/src/ptree.c |
p_tree_avl_insert | pboolean
p_tree_avl_insert (PTreeBaseNode **root_node,
PCompareDataFunc compare_func,
ppointer data,
PDestroyFunc key_destroy_func,
PDestroyFunc value_destroy_func,
ppointer key,
ppointer value)
{
PTreeBaseNode **cur_node;
PTreeBaseNode *parent_node;
pint cmp_result;
cur_node ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x... | /saprykin[P]plibsys/src/ptree-avl.c |
pp_tree_avl_balance_insert | static void
pp_tree_avl_balance_insert (PTreeAVLNode *node, PTreeBaseNode **root)
{
PTreeAVLNode *parent;
while (TRUE) {
parent = node->parent;
if (P_UNLIKELY (parent == NULL))
break;
if (parent->base.left == (PTreeBaseNode *) node) {
if (parent->balance_factor == 1) {
if (node->balance_factor == -... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2200a
jmp 0x220db
movq -0x18(%rbp), %rax
m... | /saprykin[P]plibsys/src/ptree-avl.c |
pp_tree_avl_balance_remove | static void
pp_tree_avl_balance_remove (PTreeAVLNode *node, PTreeBaseNode **root)
{
PTreeAVLNode *parent;
PTreeAVLNode *sibling;
pint sibling_balance;
while (TRUE) {
parent = node->parent;
if (P_UNLIKELY (parent == NULL))
break;
if (parent->base.left == (PTreeBaseNode *) node) {
if (parent->balance_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2233a
jmp 0x2245d
movq -0x18(%rbp), %rax
m... | /saprykin[P]plibsys/src/ptree-avl.c |
pp_tree_avl_rotate_left_right | static void
pp_tree_avl_rotate_left_right (PTreeAVLNode *node, PTreeBaseNode **root)
{
PTreeAVLNode *tmp_node;
tmp_node = (PTreeAVLNode *) node->base.right;
node->base.right = tmp_node->base.left;
if (node->base.right != NULL)
((PTreeAVLNode *) node->base.right)->parent = node;
tmp_node->parent = node->parent... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x224d2
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
... | /saprykin[P]plibsys/src/ptree-avl.c |
pp_tree_avl_rotate_right | static void
pp_tree_avl_rotate_right (PTreeAVLNode *node, PTreeBaseNode **root)
{
node->parent->base.left = node->base.right;
if (node->base.right != NULL)
((PTreeAVLNode *) node->base.right)->parent = (PTreeAVLNode *) node->parent;
node->base.right = (PTreeBaseNode *) node->parent;
node->parent = ((PTreeAVLNod... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2267e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
mo... | /saprykin[P]plibsys/src/ptree-avl.c |
pp_tree_avl_rotate_right_left | static void
pp_tree_avl_rotate_right_left (PTreeAVLNode *node, PTreeBaseNode **root)
{
PTreeAVLNode *tmp_node;
tmp_node = (PTreeAVLNode *) node->base.left;
node->base.left = tmp_node->base.right;
if (node->base.left != NULL)
((PTreeAVLNode *) node->base.left)->parent = node;
tmp_node->parent = node->parent->p... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2277f
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (... | /saprykin[P]plibsys/src/ptree-avl.c |
p_tree_bst_remove | pboolean
p_tree_bst_remove (PTreeBaseNode **root_node,
PCompareDataFunc compare_func,
ppointer data,
PDestroyFunc key_destroy_func,
PDestroyFunc value_destroy_func,
pconstpointer key)
{
PTreeBaseNode *cur_node;
PTreeBaseNode *prev_node;
PTreeBaseNode **node_pointer;
pint cmp_result;
c... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x22... | /saprykin[P]plibsys/src/ptree-bst.c |
pp_tree_rb_balance_insert | static void
pp_tree_rb_balance_insert (PTreeRBNode *node, PTreeBaseNode **root)
{
PTreeRBNode *uncle;
PTreeRBNode *gparent;
while (TRUE) {
/* Case 1: We are at the root */
if (P_UNLIKELY (node->parent == NULL)) {
node->color = P_TREE_RB_COLOR_BLACK;
break;
}
/* Case 2: We have a black parent */
if... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x22ecd
movq -0x8(%rbp), %rax
movl $0x2, 0x28(%rax)
jmp 0x23002
movq -0x8(%rbp), %rax
movq... | /saprykin[P]plibsys/src/ptree-rb.c |
p_uthread_shutdown | void
p_uthread_shutdown (void)
{
PUThread *cur_thread;
if (P_LIKELY (pp_uthread_specific_data != NULL)) {
cur_thread = p_uthread_get_local (pp_uthread_specific_data);
if (P_UNLIKELY (cur_thread != NULL)) {
p_uthread_unref (cur_thread);
p_uthread_set_local (pp_uthread_specific_data, NULL);
}
p_uthread... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xcdb0(%rip) # 0x305e0
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2389d
movq 0xcd95(%rip), %rdi # 0x305e0
callq 0x6280
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x... | /saprykin[P]plibsys/src/puthread.c |
p_uthread_ideal_count | P_LIB_API pint
p_uthread_ideal_count (void)
{
#if defined (P_OS_WIN)
SYSTEM_INFO sys_info;
SystemInfoFunc sys_info_func;
sys_info_func = (SystemInfoFunc) GetProcAddress (GetModuleHandleA ("kernel32.dll"),
"GetNativeSystemInfo");
if (P_UNLIKELY (sys_info_func == NULL))
sys_info_func = (SystemInfoFunc) Ge... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x54, %edi
callq 0x68d0
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x23cdb
leaq 0x4e12(%rip), %rdi # 0x28ad6
leaq 0x5b1c(%rip), %rsi # 0x297e7
movb $0x0, %al
cal... | /saprykin[P]plibsys/src/puthread.c |
p_atomic_int_set | P_LIB_API void
p_atomic_int_set (volatile pint *atomic,
pint val)
{
*atomic = val;
#ifdef P_CC_CRAY
__builtin_ia32_mfence ();
#else
__sync_synchronize ();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
mfence
popq %rbp
retq
nopl (%rax)
| /saprykin[P]plibsys/src/patomic-sync.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.