name string | code string | asm string | file string |
|---|---|---|---|
QPDFNumberTreeObjectHelper::getAsMap() const | std::map<QPDFNumberTreeObjectHelper::numtree_number, QPDFObjectHandle>
QPDFNumberTreeObjectHelper::getAsMap() const
{
std::map<numtree_number, QPDFObjectHandle> result;
result.insert(begin(), end());
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1bee10
movq -0x90(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1bd9b0
jmp 0x1be56a
movq -0x90(... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
(anonymous namespace)::NumberTreeDetails::compareKeys(QPDFObjectHandle, QPDFObjectHandle) const | int
compareKeys(QPDFObjectHandle a, QPDFObjectHandle b) const override
{
if (!(keyValid(a) && keyValid(b))) {
// We don't call this without calling keyValid first
throw std::logic_error("comparing invalid keys");
}
auto as = a.getIntVal... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x48940
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi)... | /qpdf[P]qpdf/libqpdf/QPDFNumberTreeObjectHelper.cc |
QPDFNumberTreeObjectHelper::iterator::iterator(QPDFNumberTreeObjectHelper::iterator const&) | class QPDF_DLL_PRIVATE iterator
{
friend class QPDFNumberTreeObjectHelper;
public:
typedef std::pair<numtree_number, QPDFObjectHandle> T;
using iterator_category = std::bidirectional_iterator_tag;
using value_type = T;
using difference_type = long;
using pointe... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x2d50a9(%rip), %rax # 0x494788
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1bb020
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
m... | /qpdf[P]qpdf/include/qpdf/QPDFNumberTreeObjectHelper.hh |
qpdf::Name::analyzeJSONEncoding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::pair<bool, bool>
Name::analyzeJSONEncoding(const std::string& name)
{
int tail = 0; // Number of continuation characters expected.
bool tail2 = false; // Potential overlong 3 octet utf-8.
bool tail3 = false; // potential overlong 4 octet
bool needs_escaping = false;
for (auto const& it: n... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
movb $0x0, -0x17(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b380
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bf90
movq %rax, -0x30(%... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::copy(bool) const | std::shared_ptr<QPDFObject>
BaseHandle::copy(bool shallow) const
{
switch (resolved_type_code()) {
case ::ot_uninitialized:
throw std::logic_error("QPDFObjectHandle: attempting to copy an uninitialized object");
return {}; // does not return
case ::ot_reserved:
return QPDFObject::cre... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x1d8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x1cfea0
movl %eax, %ecx
movq %rcx, -... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::unparse[abi:cxx11]() const | std::string
BaseHandle::unparse() const
{
switch (resolved_type_code()) {
case ::ot_uninitialized:
throw std::logic_error("QPDFObjectHandle: attempting to unparse an uninitialized object");
return ""; // does not return
case ::ot_reserved:
throw std::logic_error("QPDFObjectHandle: at... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x1cfea0
movl %eax, %ecx
movq %rcx, -0x218(%rbp)
subl $0xf, %eax
ja 0x1c33d9
movq -0x218... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::writeJSON(int, JSON::Writer&, bool) const | void
QPDFObjectHandle::writeJSON(int json_version, JSON::Writer& p, bool dereference_indirect) const
{
if (!dereference_indirect && isIndirect()) {
p << "\"" << getObjGen().unparse(' ') << " R\"";
} else if (!obj) {
throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHand... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1c4690
movq -0x70(%rbp), %rdi
callq 0x1c70a0
testb $0x1, %al
jne 0x1c45f1
jmp 0x1c4... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
qpdf::BaseHandle::disconnect(bool) | void
BaseHandle::disconnect(bool only_direct)
{
// QPDF::~QPDF() calls disconnect for indirect objects, so we don't do that here.
if (only_direct && indirect()) {
return;
}
switch (raw_type_code()) {
case ::ot_array:
{
auto& a = std::get<QPDF_Array>(obj->value);
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1c475f
movq -0xa0(%rbp), %rdi
callq 0x1d0510
testb $0x1, %al
jne 0x1c475a
jmp 0x1c475f
jmp 0x1c49b6
movq -0xa0(%rbp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::typeWarning(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFObjectHandle::typeWarning(char const* expected_type, std::string const& warning) const
{
QPDF* context = nullptr;
std::string description;
// Type checks above guarantee that the object has been dereferenced. Nevertheless, dereference
// throws exceptions in the test suite
if (!obj) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b510
movq -0x1d8(%rbp), %rdi
callq 0x49650
testb $0x1, %al
jne 0x1c5165
movl $0x1... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::mergeResources(QPDFObjectHandle, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<s... | void
QPDFObjectHandle::mergeResources(
QPDFObjectHandle other, std::map<std::string, std::map<std::string, std::string>>* conflicts)
{
if (!(isDictionary() && other.isDictionary())) {
QTC::TC("qpdf", "QPDFObjectHandle merge top type mismatch");
return;
}
auto make_og_to_name = [](QPDFOb... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rsi, -0x3a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1c55e0
testb $0x1, %al
jne 0x1c7104
jmp 0x1c7114
movq -0x3a8(%rbp), %rdi
callq 0x1c55e0
testb $0x1, %al
... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::getResourceNames[abi:cxx11]() const | std::set<std::string>
QPDFObjectHandle::getResourceNames() const
{
// Return second-level dictionary keys
std::set<std::string> result;
for (auto const& item: as_dictionary(strict)) {
for (auto const& [key2, val2]: item.second.as_dictionary(strict)) {
if (!val2.null()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcb130
movq -0xb8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %ed... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::warn(QPDF*, QPDFExc const&) | void
QPDFObjectHandle::warn(QPDF* qpdf, QPDFExc const& e)
{
// If parsing on behalf of a QPDF object and want to give a warning, we can warn through the
// object. If parsing for some other reason, such as an explicit creation of an object from a
// string, then just throw the exception.
if (qpdf) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c8ef6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x63510
jmp 0x1c8f43
movl $0x80, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x79080
jm... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::addPageContents(QPDFObjectHandle, bool) | void
QPDFObjectHandle::addPageContents(QPDFObjectHandle new_contents, bool first)
{
new_contents.assertStream();
std::vector<QPDFObjectHandle> content_streams;
if (first) {
QTC::TC("qpdf", "QPDFObjectHandle prepend page contents");
content_streams.push_back(new_contents);
}
for (aut... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rcx
movq -0xc0(%rbp), %rdi
movb %dl, %al
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x1c93b0
leaq -0x30(%rbp), %rdi
callq 0x68e70
testb $0x1, -0x11(%rb... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::unparseResolved[abi:cxx11]() const | std::string
QPDFObjectHandle::unparseResolved() const
{
if (!obj) {
throw std::logic_error("attempted to dereference an uninitialized QPDFObjectHandle");
}
return BaseHandle::unparse();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x49650
testb $0x1, %al
jne 0x1ca1cc
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::parseContentStream_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle::ParserCallbacks*) | void
QPDFObjectHandle::parseContentStream_internal(
std::string const& description, ParserCallbacks* callbacks)
{
Pl_Buffer buf("concatenated stream data buffer");
std::string all_description;
pipeContentStreams(&buf, description, all_description);
auto stream_data = buf.getBufferSharedPointer();
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq 0x1668bc(%rip), %rsi # 0x331b55
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4f470
leaq -0x70(%rbp), %rdi
movq %rd... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::filterAsContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFObjectHandle::filterAsContents(TokenFilter* filter, Pipeline* next)
{
auto description = "token filter for object " + getObjGen().unparse(' ');
Pl_QPDFTokenizer token_pipeline(description.c_str(), filter, next);
this->pipeStreamData(&token_pipeline, 0, qpdf_dl_specialized);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1c8320
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x60(%rbp), %rsi
movl $0x20, %edx
callq 0x69d20
movq -0xb0(%rbp), %rdx
le... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newArray(QPDFObjectHandle::Matrix const&) | QPDFObjectHandle
QPDFObjectHandle::newArray(Matrix const& matrix)
{
return newArray(
{newReal(matrix.a),
newReal(matrix.b),
newReal(matrix.c),
newReal(matrix.d),
newReal(matrix.e),
newReal(matrix.f)});
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorl %esi, %esi
movl $0x1, %edx
callq 0x1cc4b0
jmp 0x1... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::newReserved(QPDF*) | QPDFObjectHandle
QPDFObjectHandle::newReserved(QPDF* qpdf)
{
if (qpdf == nullptr) {
throw std::runtime_error("attempt to create reserved object in null qpdf object");
}
return qpdf->newReserved();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1cd232
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x164a7a(%rip), %rsi # 0x331c77
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::makeDirect(QPDFObjGen::set&, bool) | void
QPDFObjectHandle::makeDirect(QPDFObjGen::set& visited, bool stop_at_streams)
{
assertInitialized();
auto cur_og = getObjGen();
if (!visited.add(cur_og)) {
QTC::TC("qpdf", "QPDFObjectHandle makeDirect loop");
throw std::runtime_error("loop detected while converting object from indirect ... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0x1cdb20
movq -0x178(%rbp), %rdi
callq 0x1c8320
movq %rax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::objectWarning(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void
QPDFObjectHandle::objectWarning(std::string const& warning) const
{
QPDF* context = nullptr;
std::string description;
// Type checks above guarantee that the object is initialized.
obj->getDescription(context, description);
// Null context handled by warn
warn(context, QPDFExc(qpdf_e_object... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq $0x0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1b510
movq -0x100(%rbp), %rdi
callq 0x6ba50
movq -0xf8(%rbp), %rdx
movq %rax, %rdi... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isPagesObject() const | bool
QPDFObjectHandle::isPagesObject() const
{
if (getOwningQPDF() == nullptr) {
return false;
}
// getAllPages repairs /Type when traversing the page tree.
getOwningQPDF()->getAllPages();
return isDictionaryOfType("/Pages");
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1c8f60
cmpq $0x0, %rax
jne 0x1ce87b
movb $0x0, -0x1(%rbp)
jmp 0x1ce970
movq -0x78(%rbp), %rdi
callq 0x1c8f60
movq %rax, %rdi
callq 0x2ac270
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be50... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFDictItems::iterator::iterator(QPDFObjectHandle&, bool) | QPDFObjectHandle::QPDFDictItems::iterator::iterator(QPDFObjectHandle& oh, bool for_begin) :
m(new Members(oh, for_begin))
{
updateIValue();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %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, -0x40(%rbp)
leaq 0x2c2d7a(%rip), %rcx # 0x492000
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x48, %edi
callq 0x1b250
movq %r... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
JSON::Writer::writeEnd(char const&) | Writer&
writeEnd(char const& c)
{
if (indent > 1) {
indent -= 2;
}
if (!first) {
first = true;
writeNext();
}
first = false;
write(&c, 1);
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x1, 0x10(%rax)
jbe 0x1d0fbf
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x1d0fd6
movq -0x18... | /qpdf[P]qpdf/libqpdf/qpdf/JSON_writer.hh |
QPDF_Bool* qpdf::BaseHandle::as<QPDF_Bool>() 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 0x49650
testb $0x1, %al
jne 0x1d122d
movq $0x0, -0x8(%rbp)
jmp 0x1d136c
movq -0x50(%rbp), %rdi
callq 0x6ba50
movq %rax, %rdi
callq 0x1dc470
testb $0x1, %al
jne 0x1d1244
jmp 0x1d125e
movq -0x50(%rbp), %... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_Integer* qpdf::BaseHandle::as<QPDF_Integer>() 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 0x49650
testb $0x1, %al
jne 0x1d13bd
movq $0x0, -0x8(%rbp)
jmp 0x1d14fc
movq -0x50(%rbp), %rdi
callq 0x6ba50
movq %rax, %rdi
callq 0x1dc4a0
testb $0x1, %al
jne 0x1d13d4
jmp 0x1d13ee
movq -0x50(%rbp), %... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDFOutlineDocumentHelper::initializeByPage() | void
QPDFOutlineDocumentHelper::initializeByPage()
{
std::list<QPDFOutlineObjectHelper> queue;
queue.insert(queue.end(), m->outlines.begin(), m->outlines.end());
while (!queue.empty()) {
QPDFOutlineObjectHelper oh = queue.front();
queue.pop_front();
m->by_page[oh.getDestPage().getOb... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1df9f0
movq -0xf8(%rbp), %rdi
callq 0x1dfb00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dfb30... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineDocumentHelper::resolveNamedDest(QPDFObjectHandle) | QPDFObjectHandle
QPDFOutlineDocumentHelper::resolveNamedDest(QPDFObjectHandle name)
{
QPDFObjectHandle result;
if (name.isName()) {
if (!m->dest_dict) {
m->dest_dict = qpdf.getRoot().getKey("/Dests");
}
QTC::TC("qpdf", "QPDFOutlineDocumentHelper name named dest");
res... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdx, -0x198(%rbp)
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x48880
movq -0x19... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineObjectHelper::getDest() | QPDFObjectHandle
QPDFOutlineObjectHelper::getDest()
{
QPDFObjectHandle dest;
QPDFObjectHandle A;
if (oh().hasKey("/Dest")) {
QTC::TC("qpdf", "QPDFOutlineObjectHelper direct dest");
dest = oh().getKey("/Dest");
} else if (
(A = oh().getKey("/A")).isDictionary() && A.getKey("/S").i... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %rdi, -0x230(%rbp)
movq %rdi, %rax
movq %rax, -0x228(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x220(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x48880
leaq -0x30(%rbp), %rdi
callq 0x48880
movq -0x220(%rbp), %... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getDestPage() | QPDFObjectHandle
QPDFOutlineObjectHelper::getDestPage()
{
QPDFObjectHandle dest = getDest();
if ((dest.isArray()) && (dest.getArrayNItems() > 0)) {
return dest.getArrayItem(0);
}
return QPDFObjectHandle::newNull();
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1e47f0
movq -0x40(%rbp), %rdi
callq 0x1c55b0
movb %al, -0x31(%rbp)
jmp 0x1e51da
movb -0x31(%... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getCount() | int
QPDFOutlineObjectHelper::getCount()
{
int count = 0;
if (oh().hasKey("/Count")) {
count = oh().getKey("/Count").getIntValueAsInt();
}
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc52f0
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be50
movq -0xa8(%rbp), %rdx
leaq 0x139090(%rip), %rsi # 0x31e338
leaq -0x40(%rbp), %rdi
call... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFOutlineObjectHelper::getTitle[abi:cxx11]() | std::string
QPDFOutlineObjectHelper::getTitle()
{
std::string result;
if (oh().hasKey("/Title")) {
result = oh().getKey("/Title").getUTF8Value();
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0xd0(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xc52f0
... | /qpdf[P]qpdf/libqpdf/QPDFOutlineObjectHelper.cc |
QPDFPageDocumentHelper::getAllPages() | std::vector<QPDFPageObjectHelper>
QPDFPageDocumentHelper::getAllPages()
{
std::vector<QPDFPageObjectHelper> pages;
for (auto const& iter: this->qpdf.getAllPages()) {
pages.emplace_back(iter);
}
return pages;
} | 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), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1e7f30
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2ac270
movq %rax, -0x50(%rbp)
jmp... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::removeUnreferencedResources() | void
QPDFPageDocumentHelper::removeUnreferencedResources()
{
for (auto& ph: getAllPages()) {
ph.removeUnreferencedResources();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1e6310
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb0970
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb09a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq ... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::flattenAnnotations(int, int) | void
QPDFPageDocumentHelper::flattenAnnotations(int required_flags, int forbidden_flags)
{
QPDFAcroFormDocumentHelper afdh(this->qpdf);
if (afdh.getNeedAppearances()) {
this->qpdf.getRoot()
.getKey("/AcroForm")
.warnIfPossible(
"document does not have updated appe... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0xa4f40
movq -0x1b8(%rbp), %rdi
callq 0xa8e00
movb %al, -0x1aa(... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageLabelDocumentHelper::QPDFPageLabelDocumentHelper(QPDF&) | QPDFPageLabelDocumentHelper::QPDFPageLabelDocumentHelper(QPDF& qpdf) :
QPDFDocumentHelper(qpdf),
m(new Members())
{
QPDFObjectHandle root = qpdf.getRoot();
if (root.hasKey("/PageLabels")) {
m->labels =
std::make_shared<QPDFNumberTreeObjectHelper>(root.getKey("/PageLabels"), this->qpd... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0xaf630
movq -0xb8(%rbp), %rax
leaq 0x2aa043(%rip), %rcx # 0x492a88
movq %rcx, (%rax)
addq $0x10, %rax
movq %rax, -0xb0(%rbp)
movl $0x10, %edi
callq 0x1b2... | /qpdf[P]qpdf/libqpdf/QPDFPageLabelDocumentHelper.cc |
QPDFPageObjectHelper::getTrimBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getTrimBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/TrimBox",
copy_if_shared,
[this, copy_if_shared, copy_if_fallback]() {
return this->getCropBox(copy_if_shared, copy_if_fallback);
},
copy_if_fall... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, %rdx
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x39(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::shallowCopyPage() | QPDFPageObjectHelper
QPDFPageObjectHelper::shallowCopyPage()
{
QPDF& qpdf = oh().getQPDF("QPDFPageObjectHelper::shallowCopyPage called with a direct object");
QPDFObjectHandle new_page = oh().shallowCopy();
return {qpdf.makeIndirectObject(new_page)};
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc52f0
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be50
movq -0xa8(%rbp), %rdx
lea... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMatrixForTransformations(bool) | QPDFObjectHandle::Matrix
QPDFPageObjectHelper::getMatrixForTransformations(bool invert)
{
QPDFObjectHandle::Matrix matrix(1, 0, 0, 1, 0, 0);
QPDFObjectHandle bbox = getTrimBox(false);
if (!bbox.isRectangle()) {
return matrix;
}
QPDFObjectHandle rotate_obj = getAttribute("/Rotate", false);
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x1c8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1c0(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movsd 0x128f56(%rip), %xmm3 # 0x318d70
xorps %xmm5, %xmm5
movaps %... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getFormXObjectForPage(bool) | QPDFObjectHandle
QPDFPageObjectHelper::getFormXObjectForPage(bool handle_transformations)
{
auto result =
oh().getQPDF("QPDFPageObjectHelper::getFormXObjectForPage called with a direct object")
.newStream();
QPDFObjectHandle newdict = result.getDict();
newdict.replaceKey("/Type", QPDFObj... | pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp # imm = 0x470
movq %rdi, -0x3e0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x3d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x3d0(%rbp)
movb $0x0, -0x12(%rbp)
leaq -0x28(%rbp), %r... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getMatrixForFormXObjectPlacement(QPDFObjectHandle, QPDFObjectHandle::Rectangle, bool, bool, bool) | QPDFMatrix
QPDFPageObjectHelper::getMatrixForFormXObjectPlacement(
QPDFObjectHandle fo,
QPDFObjectHandle::Rectangle rect,
bool invert_transformations,
bool allow_shrink,
bool allow_expand)
{
// Calculate the transformation matrix that will place the given form XObject fully inside the
// giv... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movl %r8d, -0x3b0(%rbp)
movl %ecx, %eax
movl -0x3b0(%rbp), %ecx
movl %eax, -0x3ac(%rbp)
movq %rdx, %rax
movl -0x3ac(%rbp), %edx
movq %rax, -0x3a8(%rbp)
movq %rsi, %rax
movq -0x3a8(%rbp), %rsi
movq %rax, -0x3a0(%rbp)
movq %rdi, %r8
movq -0x3a0(%rbp), ... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFParser::parse(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFTokenizer&, bool&, QPDFObjectHandle::StringDecrypter*, QPDF*) | QPDFObjectHandle
QPDFParser::parse(
InputSource& input,
std::string const& object_description,
QPDFTokenizer& tokenizer,
bool& empty,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context)
{
return QPDFParser(
input,
make_description(input.getName(), objec... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
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 -0x10(%rbp), %rdi
movq %... | /qpdf[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::QPDFParser(InputSource&, std::shared_ptr<std::variant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, QPDFObject::JSON_Descr, QPDFObject::ChildDescr, QPDFObject::ObjStreamDescr>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, qpdf::Tok... | QPDFParser(
InputSource& input,
std::shared_ptr<QPDFObject::Description> sp_description,
std::string const& object_description,
qpdf::Tokenizer& tokenizer,
QPDFObjectHandle::StringDecrypter* decrypter,
QPDF* context,
bool parse_pdf,
int stream_id = 0,
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rcx, -0x58(%rbp)
movq %rdx, %rax
movq -0x58(%rbp), %rdx
movq %rax, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq %rdi, %r10
movq -0x48(%rbp), %rdi
movb 0x30(%rbp), %al
movl 0x28(%rbp), %ecx
movl 0x20(%rbp), %ecx
movb 0x18(%rbp), %cl
movq... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFParser.hh |
void QPDFParser::addScalar<QPDF_Bool, bool>(bool&&) | void
QPDFParser::addScalar(Args&&... args)
{
if ((bad_count || sanity_checks) &&
(frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
jne 0x201198
movq -0x38(%rbp), %rax
testb $0x1, 0x44(%rax)
je 0x2011d3
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x7bd20
cmpq $0x1388, %rax # imm... | /qpdf[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_Name, 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&) | void
QPDFParser::addScalar(Args&&... args)
{
if ((bad_count || sanity_checks) &&
(frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
jne 0x201498
movq -0x38(%rbp), %rax
testb $0x1, 0x44(%rax)
je 0x2014d3
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x7bd20
cmpq $0x1388, %rax # imm... | /qpdf[P]qpdf/libqpdf/QPDFParser.cc |
void QPDFParser::addScalar<QPDF_String, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void
QPDFParser::addScalar(Args&&... args)
{
if ((bad_count || sanity_checks) &&
(frame->olist.size() > 5'000 || frame->dict.size() > 5'000)) {
// Stop adding scalars. We are going to abort when the close token or a bad token is
// encountered.
max_bad_count = 0;
return;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, 0x68(%rax)
jne 0x201798
movq -0x38(%rbp), %rax
testb $0x1, 0x44(%rax)
je 0x2017d3
movq -0x38(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x7bd20
cmpq $0x1388, %rax # imm... | /qpdf[P]qpdf/libqpdf/QPDFParser.cc |
QPDFParser::StackFrame::StackFrame(InputSource&, QPDFParser::parser_state_e) | StackFrame(InputSource& input, parser_state_e state) :
state(state),
offset(input.tell())
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0x68e70
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x50(%rbp)
callq 0x1bb200
movq -0x40(%rbp), %rdi
movl -0x1... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFParser.hh |
QPDFSystemError::QPDFSystemError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | QPDFSystemError::QPDFSystemError(std::string const& description, int system_errno) :
std::runtime_error(createWhat(description, system_errno)),
description(description),
system_errno(system_errno)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x204900
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1b... | /qpdf[P]qpdf/libqpdf/QPDFSystemError.cc |
QPDFSystemError::createWhat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | std::string
QPDFSystemError::createWhat(std::string const& description, int system_errno)
{
std::string message;
#ifdef _MSC_VER
// "94" is mentioned in the MSVC docs, but it's still safe if the
// message is longer. strerror_s is a templated function that
// knows the size of buf and truncates.
ch... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x1b510
movq -0x10(%rbp), %rsi
leaq 0x1333b3(%rip), %rdx # 0x337ce8
leaq -0x58(%rbp), %rdi
callq 0x26e20
jmp 0x204... | /qpdf[P]qpdf/libqpdf/QPDFSystemError.cc |
qpdf::Tokenizer::inComment(char) | void
Tokenizer::inComment(char ch)
{
if ((ch == '\r') || (ch == '\n')) {
if (include_ignorable) {
type = tt::tt_comment;
in_token = false;
char_to_unread = ch;
state = st_token_ready;
} else {
state = st_before_token;
}
}
} | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0x205438
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x20546b
movq -0x18(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x20545f
movq -0x18(%rbp), %rax
movl ... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inString(char) | void
Tokenizer::inString(char ch)
{
switch (ch) {
case '\\':
state = st_string_escape;
return;
case '(':
val += ch;
++string_depth;
return;
case ')':
if (--string_depth == 0) {
type = tt::tt_string;
state = st_token_ready;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x205644
jmp 0x20557c
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x205626
jmp 0x20558a
movl -0x10(%rbp), %ea... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inName(char) | void
Tokenizer::inName(char ch)
{
if (isDelimiter(ch)) {
// A C-locale whitespace character or delimiter terminates token. It is important to unread
// the whitespace character even though it is ignored since it may be the newline after a
// stream keyword. Removing it here could make the ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x204e70
testb $0x1, %al
jne 0x2056a9
jmp 0x2056d7
movq -0x18(%rbp), %rax
movb 0x80(%rax), %sil
movl $0x8, %ecx
xorl %edx, %edx
testb $0x1, %si... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inNumber(char) | void
Tokenizer::inNumber(char ch)
{
if (util::is_digit(ch)) {
} else if (ch == '.') {
state = st_real;
} else if (isDelimiter(ch)) {
type = tt::tt_integer;
state = st_token_ready;
in_token = false;
char_to_unread = ch;
} else {
state = st_literal;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x69840
testb $0x1, %al
jne 0x205749
jmp 0x20574b
jmp 0x20579e
movsbl -0x9(%rbp), %eax
cmpl $0x2e, %eax
jne 0x205760
movq -0x18(%rbp), %rax
mov... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inReal(char) | void
Tokenizer::inReal(char ch)
{
if (util::is_digit(ch)) {
} else if (isDelimiter(ch)) {
type = tt::tt_real;
state = st_token_ready;
in_token = false;
char_to_unread = ch;
} else {
state = st_literal;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x69840
testb $0x1, %al
jne 0x2057d9
jmp 0x2057db
jmp 0x205817
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x204e70
testb $0x1, %al
jn... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inNameHex2(char) | void
Tokenizer::inNameHex2(char ch)
{
if (char hval = util::hex_decode_char(ch); hval < '\20') {
char_code |= int(hval);
} else {
QTC::TC("qpdf", "QPDFTokenizer bad name 2");
error_message = "name with stray # will not work with PDF >= 1.2";
// Use null to encode a bad # -- this ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %edi
callq 0x371f0
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x10, %eax
jge 0x205fd5
movq -0x18(%rbp), %rax
movsbl -0xa(%rbp), %ecx
orl 0x88(%rax... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::inBeforeToken(char) | void
Tokenizer::inBeforeToken(char ch)
{
// Note: we specifically do not use ctype here. It is locale-dependent.
if (isSpace(ch)) {
before_token = !include_ignorable;
in_token = include_ignorable;
if (include_ignorable) {
state = st_in_space;
}
} else if (ch == '... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movsbl -0x9(%rbp), %esi
callq 0x204e30
testb $0x1, %al
jne 0x2061a9
jmp 0x2061d4
movq -0x18(%rbp), %rax
movb 0x5(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x70(%ra... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::presentEOF() | void
Tokenizer::presentEOF()
{
switch (state) {
case st_name:
case st_name_hex1:
case st_name_hex2:
case st_number:
case st_real:
case st_sign:
case st_decimal:
case st_literal:
QTC::TC("qpdf", "QPDFTokenizer EOF reading appendable token");
// Push any delimiter to th... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x15, %rax
ja 0x20636d
movq -0x10(%rbp), %rax
leaq 0x12d809(%rip), %rcx # 0x333af8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x130fdd(%rip), %... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::expectInlineImage(InputSource&) | void
Tokenizer::expectInlineImage(InputSource& input)
{
if (state == st_token_ready) {
reset();
} else if (state != st_before_token) {
throw std::logic_error(
"QPDFTokenizer::expectInlineImage called when tokenizer is in improper state");
}
findEI(input);
before_token = f... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x15, (%rax)
jne 0x206418
movq -0x28(%rbp), %rdi
callq 0x204a90
jmp 0x206473
movq -0x28(%rbp), %rax
cmpl $0x14, (%rax)
je 0x206471
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
mo... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::findEI(InputSource&) | void
Tokenizer::findEI(InputSource& input)
{
qpdf_offset_t last_offset = input.getLastOffset();
qpdf_offset_t pos = input.tell();
// Use QPDFWordTokenFinder to find EI surrounded by delimiters. Then read the next several
// tokens or up to EOF. If we find any suspicious-looking or tokens, this is proba... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x190(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a5e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::nextToken(InputSource&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | bool
Tokenizer::nextToken(InputSource& input, std::string const& context, size_t max_len)
{
if (state != st_inline_image) {
reset();
}
qpdf_offset_t offset = input.fastTell();
while (state != st_token_ready) {
char ch;
if (!input.fastRead(ch)) {
presentEOF();
... | 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), %rax
movq %rax, -0x38(%rbp)
cmpl $0xd, (%rax)
je 0x206aae
movq -0x38(%rbp), %rdi
callq 0x204a90
movq -0x10(%rbp), %rdi
callq 0x207920
movq %rax, -0x28(%rbp)
movq -0x38(... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
qpdf::Tokenizer::getToken(QPDFTokenizer::Token&, bool&, char&) | bool
Tokenizer::getToken(Token& token, bool& unread_char, char& ch)
{
bool ready = (state == st_token_ready);
unread_char = !in_token && !before_token;
ch = char_to_unread;
if (ready) {
token = (!(type == tt::tt_name || type == tt::tt_string))
? Token(type, raw_val, raw_val, error_me... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x140(%rbp)
cmpl $0x15, (%rcx)
sete %al
andb $0x1, %al
movb %al, -0x21(%rbp)
xorl %eax, %eax
testb $0x1, 0x71(%rcx)
movb %al,... | /qpdf[P]qpdf/libqpdf/QPDFTokenizer.cc |
QPDFWriter::Members::Members(QPDF&) | QPDFWriter::Members::Members(QPDF& pdf) :
pdf(pdf),
root_og(pdf.getRoot().getObjGen().isIndirect() ? pdf.getRoot().getObjGen() : QPDFObjGen(-1, 0))
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x66c30
movq -0x60(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setOutputFilename(char const*) | void
QPDFWriter::setOutputFilename(char const* filename)
{
char const* description = filename;
FILE* f = nullptr;
bool close_file = false;
if (filename == nullptr) {
description = "standard output";
QTC::TC("qpdf", "QPDFWriter write to stdout");
f = stdout;
QUtil::binary_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2086e8
leaq 0x113f22(%rip), %rax # 0x31c5dc
movq %rax, -0x18(%... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::parseVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&, int&) const | void
QPDFWriter::parseVersion(std::string const& version, int& major, int& minor) const
{
major = QUtil::string_to_int(version.c_str());
minor = 0;
size_t p = version.find('.');
if ((p != std::string::npos) && (version.length() > p)) {
minor = QUtil::string_to_int(version.substr(p + 1).c_str());... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b180
movq %rax, %rdi
callq 0x2b4270
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setEncryptionParameters(char const*, char const*, int, int, int, std::set<int, std::less<int>, std::allocator<int>>&) | void
QPDFWriter::setEncryptionParameters(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
std::set<int>& bits_to_clear)
{
// PDF specification refers to bits with the low bit numbered 1.
// We have to convert this into a bit field.
// Specification ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x180(%rbp)
movq 0x10(%rbp), %rdi
movl $0x1,... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR4EncryptionParametersInsecure(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool, bool) | void
QPDFWriter::setR4EncryptionParametersInsecure(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
boo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %eax
movq %rdx, %r11
movq %rsi, %rbx
movq %rdi, %r14
movb %r9b, %r8b
movb %al, %r9b
movb %cl, %r10b
movb 0x38(%rbp), %al
movb 0x30(%rbp), %cl
movl 0x28(%rbp), %edx
movb 0x20(%rbp), %dl
movb 0x18(%rbp), %sil
movb 0x10(%rbp), %dil
mov... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setR5EncryptionParameters(char const*, char const*, bool, bool, bool, bool, bool, bool, qpdf_r3_print_e, bool) | void
QPDFWriter::setR5EncryptionParameters(
char const* user_password,
char const* owner_password,
bool allow_accessibility,
bool allow_extract,
bool allow_assemble,
bool allow_annotate_and_form,
bool allow_form_filling,
bool allow_modify_other,
qpdf_r3_print_e print,
bool encryp... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r10
movq %rsi, %r11
movq %rdi, %rbx
movb %r9b, %dil
movb %cl, %r9b
movb 0x30(%rbp), %al
movl 0x28(%rbp), %ecx
movb 0x20(%rbp), %cl
movb 0x18(%rbp), %dl
movb 0x10(%rbp), %sil
movq %rbx, -0x20(%rbp)
movq %r11, -0x28(%rbp)
movq %r10, ... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::generateID() | void
QPDFWriter::generateID()
{
// Generate the ID lazily so that we can handle the user's preference to use static or
// deterministic ID generation.
if (!m->id2.empty()) {
return;
}
QPDFObjectHandle trailer = m->pdf.getTrailer();
std::string result;
if (m->static_id) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x21e8d0
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x20a6c7
jmp 0x20ad4b
movq -0x1b0(%rbp), %rdi
callq 0x21e8d0
movq (%rax), %rsi
leaq -0x18(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::writeBinary(unsigned long long, unsigned int) | void
QPDFWriter::writeBinary(unsigned long long val, unsigned int bytes)
{
if (bytes > sizeof(unsigned long long)) {
throw std::logic_error("QPDFWriter::writeBinary called with too many bytes");
}
unsigned char data[sizeof(unsigned long long)];
for (unsigned int i = 0; i < bytes; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x8, %rax
jbe 0x20d9f4
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x1268a2(%rip), %rsi... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::activatePipelineStack(QPDFWriter::PipelinePopper&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::unique_ptr<qpdf::pl::Link, std::default_delete<qpdf::pl::Link>>) | void
QPDFWriter::activatePipelineStack(
PipelinePopper& pp, bool discard, std::string* str, std::unique_ptr<pl::Link> link)
{
pl::Count* c;
if (link) {
c = new pl::Count(m->next_stack_id, m->count_buffer, std::move(link));
} else if (discard) {
c = new pl::Count(m->next_stack_id, nullptr... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %r8, -0x68(%rbp)
movl %edx, %eax
movq %rdi, %rdx
movq -0x68(%rbp), %rdi
movq %rdx, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x21f1a0
testb $0x1,... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::PipelinePopper::~PipelinePopper() | QPDFWriter::PipelinePopper::~PipelinePopper()
{
if (!stack_id) {
return;
}
qpdf_assert_debug(qw->m->pipeline_stack.size() >= 2);
qw->m->pipeline->finish();
qpdf_assert_debug(dynamic_cast<pl::Count*>(qw->m->pipeline_stack.back()) == qw->m->pipeline);
// It might be possible for this asser... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x20e1e3
jmp 0x20e518
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x21e8d0
movq %rax, %rdi
addq $0x378, %rdi # imm = 0x378
callq 0x21f2d0
cmpq $0x2, %rax
jb 0x20e206
jmp ... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObject(QPDFObjectHandle) | void
QPDFWriter::enqueueObject(QPDFObjectHandle object)
{
if (object.isIndirect()) {
// This owner check can only be done for indirect objects. It is possible for a direct
// object to have an owning QPDF that is from another file if a direct QPDFObjectHandle from
// one file was insert into... | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, -0x148(%rbp)
movq %rdi, %rax
movq -0x148(%rbp), %rdi
movq %rdi, -0x140(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
callq 0x1c70a0
testb $0x1, %al
jne 0x20ee34
jmp 0x20f287
movq -0x140(%r... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::unparseObject(QPDFObjectHandle, int, int, unsigned long, bool) | void
QPDFWriter::unparseObject(
QPDFObjectHandle object, int level, int flags, size_t stream_length, bool compress)
{
QPDFObjGen old_og = object.getObjGen();
int child_flags = flags & ~f_stream;
if (level < 0) {
throw std::logic_error("invalid level in QPDFWriter::unparseObject");
}
// F... | pushq %rbp
movq %rsp, %rbp
subq $0xf60, %rsp # imm = 0xF60
movq %rsi, -0xd08(%rbp)
movq %rdi, %rsi
movq -0xd08(%rbp), %rdi
movb %r9b, %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::getTrimmedTrailer() | QPDFObjectHandle
QPDFWriter::getTrimmedTrailer()
{
// Remove keys from the trailer that necessarily have to be replaced when writing the file.
QPDFObjectHandle trailer = m->pdf.getTrailer().unsafeShallowCopy();
// Remove encryption keys
trailer.removeKey("/ID");
trailer.removeKey("/Encrypt");
... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x21e8d0
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x67320
m... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::enqueueObjectsStandard() | void
QPDFWriter::enqueueObjectsStandard()
{
if (m->preserve_unreferenced_objects) {
QTC::TC("qpdf", "QPDFWriter preserve unreferenced standard");
for (auto const& oh: m->pdf.getAllObjects()) {
enqueueObject(oh);
}
}
// Put root first on queue.
QPDFObjectHandle traile... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x21e8d0
testb $0x1, 0x43(%rax)
je 0x21d163
leaq 0x11a24c(%rip), %rdi # 0x3372dc
leaq 0x117ffc(%rip), %rsi # 0x335093
xorl %edx, %edx
callq 0x2af50
movq -0xf0(%rbp), %rdi
... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
qpdf::util::increment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int) | inline void
increment(std::string& s, int tail = 0)
{
auto end = s.rend();
for (auto it = s.rbegin() + tail; it != end; ++it) {
++*it;
if (*it != ':') {
return;
}
*it = '0';
}
s.insert(0, 1, '1');
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1be00
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1c0c0
movslq -0xc(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x222400
leaq -0x20(%rbp), %rdi
leaq -... | /qpdf[P]qpdf/libqpdf/qpdf/Util.hh |
ObjTable<QPDFWriter::Object>::large_element(unsigned long) | T&
large_element(size_t idx)
{
static const size_t max_size = std::vector<T>::max_size();
if (idx < min_sparse) {
min_sparse = idx;
}
if (idx < max_size) {
return sparse_elements[idx];
}
throw std::runtime_error("Impossibly large object id ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpb $0x0, 0x271191(%rip) # 0x498740
jne 0x2275de
leaq 0x271188(%rip), %rdi # 0x498740
callq 0x1b530
cmpl $0x0, %eax
je 0x2275de
movq -0x28(%rbp), %rdi
callq 0x227680
movq %rax, 0x... | /qpdf[P]qpdf/libqpdf/qpdf/ObjTable.hh |
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 0x22f1e9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x1060f6(%rip), %rsi # 0x3352aa
callq 0x1bbf0
jmp 0x22f1bb
movq -0x28(%rbp), %rdi
mov... | /qpdf[P]qpdf/libqpdf/QPDFXRefEntry.cc |
qpdf::Array::cend() | Array::const_iterator
Array::cend()
{
if (auto a = as<QPDF_Array>()) {
if (!a->sp) {
return a->elements.cend();
}
if (!sp_elements) {
sp_elements = std::make_unique<std::vector<QPDFObjectHandle>>(getAsVector());
}
return sp_elements->cend();
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x231d90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x22f923
movq -0x18(%rbp), %rdi
callq 0x1d0310
testb $0x1, %al
jne 0x22f89b
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x232060
movq %rax, -0... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::push_back(QPDFObjectHandle const&) | void
Array::push_back(QPDFObjectHandle const& item)
{
auto a = array();
checkOwnership(item);
if (a->sp) {
a->sp->elements[(a->sp->size)++] = item;
} else {
a->elements.emplace_back(item);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x22f380
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x232310
movq -0x18(%rbp), %rdi
callq 0x1d0310
testb $0x1, %al
jne 0x23030d
jmp 0x230359
movq -0... | /qpdf[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 0x69fc0
movq -0x68(%rbp), %rdi
callq 0x48a70
movb %al, -0x5a(%rbp)
jmp 0x231588
movb -0x5a(%rbp), %al
testb $0x1, %al
... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::Array::checkOwnership(QPDFObjectHandle const&) const | inline void
Array::checkOwnership(QPDFObjectHandle const& item) const
{
if (!item) {
throw std::logic_error("Attempting to add an uninitialized object to a QPDF_Array.");
}
if (qpdf() && item.qpdf() && qpdf() != item.qpdf()) {
throw std::logic_error(
"Attempting to add an object ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48a70
testb $0x1, %al
jne 0x232388
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x103343(%rip), %rsi # 0x3... | /qpdf[P]qpdf/libqpdf/QPDF_Array.cc |
qpdf::BaseDictionary::replaceKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QPDFObjectHandle) | void
BaseDictionary::replaceKey(std::string const& key, QPDFObjectHandle value)
{
auto d = dict();
if (value.isNull() && !value.isIndirect()) {
// The PDF spec doesn't distinguish between keys with null values and missing keys.
// Allow indirect nulls which are equivalent to a dangling reference... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2361d0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1c4ca0
testb $0x1, %al
jne 0x2365c4
jmp 0x2365e0
movq -0x28(%rbp), %rdi
callq 0x1c70a0
testb $... | /qpdf[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 0x6a0d0
movq -0x68(%rbp), %rdi
callq 0x48a70
movb %al, -0x5a(%rbp)
jmp 0x2366f8
movb -0x5a(%rbp), %al
testb $0x1, %a... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
QPDFObjectHandle::removeKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void
QPDFObjectHandle::removeKey(std::string const& key)
{
if (auto dict = as_dictionary(strict)) {
dict.removeKey(key);
return;
}
typeWarning("dictionary", "ignoring key removal request");
QTC::TC("qpdf", "QPDFObjectHandle dictionary ignoring removeKey");
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x6a0d0
movq -0x60(%rbp), %rdi
callq 0x48a70
movb %al, -0x52(%rbp)
jmp 0x237135
movb -0x52(%rbp), %al
testb $0x1, %al
... | /qpdf[P]qpdf/libqpdf/QPDF_Dictionary.cc |
ncnn::ModelBinFromDataReader::load(int, int) const | Mat ModelBinFromDataReader::load(int w, int type) const
{
if (type == 0)
{
size_t nread;
union
{
struct
{
unsigned char f0;
unsigned char f1;
unsigned char f2;
unsigned char f3;
};
... | subq $0x688, %rsp # imm = 0x688
movq %rdi, 0xf0(%rsp)
movq %rdi, %rax
movq %rax, 0xf8(%rsp)
movq %rdi, 0x680(%rsp)
movq %rsi, 0x678(%rsp)
movl %edx, 0x674(%rsp)
movl %ecx, 0x670(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x100(%rsp)
cmpl $0x0, 0x670(%rsp)
jne 0x46e7a
movq 0x100(%rsp), %rax
movq 0x8(%rax), %rdi
... | /xiangweizeng[P]ncnn/src/modelbin.cpp |
ncnn::fastFree(void*) | static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];... | pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x47195
movq (%rsp), %rdi
callq 0x1a3c0
popq %rax
retq
nopw (%rax,%rax)
| /xiangweizeng[P]ncnn/src/allocator.h |
ncnn::Mat::reshape(int, int, ncnn::Allocator*) const | inline Mat Mat::reshape(int _w, int _h, Allocator* _allocator) const
{
if (w * h * c != _w * _h)
return Mat();
if (dims == 3 && cstep != (size_t)w * h)
{
Mat m;
m.create(_w, _h, elemsize, elempack, _allocator);
// flatten
for (int i=0; i<c; i++)
{
... | subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x2c(%rcx), %eax
imull 0x30(%rcx), %eax
imull 0x34(%rcx), %eax
movl 0x54(%rsp), %ecx
imull... | /xiangweizeng[P]ncnn/src/mat.h |
ncnn::Mat::reshape(int, int, int, ncnn::Allocator*) const | inline Mat Mat::reshape(int _w, int _h, int _c, Allocator* _allocator) const
{
if (w * h * c != _w * _h * _c)
return Mat();
if (dims < 3)
{
if ((size_t)_w * _h != alignSize(_w * _h * elemsize, 16) / elemsize)
{
Mat m;
m.create(_w, _h, _c, elemsize, elempack, ... | subq $0xd8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movl %edx, 0xc4(%rsp)
movl %ecx, 0xc0(%rsp)
movl %r8d, 0xbc(%rsp)
movq %r9, 0xb0(%rsp)
movq 0xc8(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movl 0x2c(%rcx), %eax
imull 0x30(%rcx), %eax
imull 0x34(%rcx), %eax
... | /xiangweizeng[P]ncnn/src/mat.h |
ncnn::Mat::reshape(int, ncnn::Allocator*) const | inline Mat Mat::reshape(int _w, Allocator* _allocator) const
{
if (w * h * c != _w)
return Mat();
if (dims == 3 && cstep != (size_t)w * h)
{
Mat m;
m.create(_w, elemsize, elempack, _allocator);
// flatten
for (int i=0; i<c; i++)
{
const void* ptr... | subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x2c(%rcx), %eax
imull 0x30(%rcx), %eax
imull 0x34(%rcx), %eax
cmpl 0x54(%rsp), %eax
je 0x47bdc
movq (%rsp), %r... | /xiangweizeng[P]ncnn/src/mat.h |
ncnn::fastFree(void*) | static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];... | pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4a105
movq (%rsp), %rdi
callq 0x1a3c0
popq %rax
retq
nopw (%rax,%rax)
| /xiangweizeng[P]ncnn/src/allocator.h |
ncnn::BatchNorm::BatchNorm() | BatchNorm::BatchNorm()
{
one_blob_only = true;
support_inplace = true;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x38440
movq 0x20(%rsp), %rdi
leaq 0xb07fc(%rip), %rax # 0xfa9b0
movq %rax, (%rdi)
addq $0xc0, %rdi
movq %rdi, 0x28(%rsp)
callq 0x1dc70
jmp 0x4a1ca
movq 0x20(%rsp), %rdi
addq $0x100, %rdi # imm = 0x100
movq %rdi, 0x1... | /xiangweizeng[P]ncnn/src/layer/batchnorm.cpp |
ncnn::BatchNorm::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BatchNorm::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
// a = bias - slope * mean / sqrt(var)
// b = slope / sqrt(var)
// value = b * value + a
int dims = bottom_top_blob.dims;
if (dims == 1)
{
int w = bottom_top_blob.w;
float* ptr = bottom_top_blob;
... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xd8(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0xcc(%rsp)
cmpl $0x1, 0xcc(%rsp)
jne 0x4a90a
movq 0xd8(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0xc8(%rsp)
movq 0xd8(%rsp), %rdi
callq... | /xiangweizeng[P]ncnn/src/layer/batchnorm.cpp |
ncnn::fastMalloc(unsigned long) | static inline void* fastMalloc(size_t size)
{
#if _MSC_VER
return _aligned_malloc(size, MALLOC_ALIGN);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
void* ptr = 0;
if (posix_memalign(&ptr, MALLOC_ALIGN, size))
ptr = 0;
return ptr;
#elif __ANDROID__ && __ANDROID_API__... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rdi
movl $0x10, %esi
callq 0x1a130
cmpl $0x0, %eax
je 0x4ac64
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
| /xiangweizeng[P]ncnn/src/allocator.h |
ncnn::Bias::load_model(ncnn::ModelBin const&) | int Bias::load_model(const ModelBin& mb)
{
bias_data = mb.load(bias_data_size, 1);
if (bias_data.empty())
return -100;
return 0;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
movl 0xb8(%rax), %edx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %ecx
callq *%rax
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0xc0, %rdi
callq 0x... | /xiangweizeng[P]ncnn/src/layer/bias.cpp |
ncnn::Bias::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Bias::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bo... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x88(%rsp)
movq 0x98(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x84(%... | /xiangweizeng[P]ncnn/src/layer/bias.cpp |
ncnn::BNLL::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BNLL::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bo... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movl 0x30(%rax), %eax
movl %eax, 0x88(%rsp)
movq 0x98(%rsp), %rax
movl 0x34(%rax), %eax
movl %eax, 0x84(%rsp)
movl 0x8c(%rsp), %eax
imull 0x88(%rsp),... | /xiangweizeng[P]ncnn/src/layer/bnll.cpp |
ncnn::fastFree(void*) | static inline void fastFree(void* ptr)
{
if (ptr)
{
#if _MSC_VER
_aligned_free(ptr);
#elif _POSIX_C_SOURCE >= 200112L || (__ANDROID__ && __ANDROID_API__ >= 17)
free(ptr);
#elif __ANDROID__ && __ANDROID_API__ < 17
free(ptr);
#else
unsigned char* udata = ((unsigned char**)ptr)[-1];... | pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4b2a5
movq (%rsp), %rdi
callq 0x1a3c0
popq %rax
retq
nopw (%rax,%rax)
| /xiangweizeng[P]ncnn/src/allocator.h |
int ncnn::reduction_op_keepdims<ncnn::reduction_op_asum<float>, std::plus<float>>(ncnn::Mat const&, ncnn::Mat&, float, bool, bool, bool, ncnn::Option const&) | static int reduction_op_keepdims(const Mat& a, Mat& b, float v0, bool reduce_w, bool reduce_h, bool reduce_c, const Option& opt)
{
Op op;
Op2 op2;
size_t elemsize = a.elemsize;
int dims = a.dims;
if (dims == 1)
{
int w = a.w;
b.create(1, elemsize, opt.blob_allocator);
c... | subq $0x718, %rsp # imm = 0x718
movb %r8b, %al
movq %rdi, 0x708(%rsp)
movq %rsi, 0x700(%rsp)
movss %xmm0, 0x6fc(%rsp)
andb $0x1, %dl
movb %dl, 0x6fb(%rsp)
andb $0x1, %cl
movb %cl, 0x6fa(%rsp)
andb $0x1, %al
movb %al, 0x6f9(%rsp)
movq %r9, 0x6f0(%rsp)
movq 0x708(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x... | /xiangweizeng[P]ncnn/src/layer/reduction.cpp |
ncnn::BinaryOp::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
if (op_type == Operation_ADD)
return binary_op_scalar_inplace< std::plus<float> >(bottom_top_blob, b, opt);
if (op_type == Operation_SUB)
return binary_op_scalar_inplace< std::minus<float> >(bottom_top_blob, b, opt);... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0xb8(%rax)
jne 0xa4c39
movq (%rsp), %rax
movq 0x10(%rsp), %rdi
movss 0xc0(%rax), %xmm0
movq 0x8(%rsp), %rsi
callq 0xa4dd0
movl %eax, 0x24(%rsp)
jmp 0xa4dc0
movq (%rsp), %rax
cmpl $0x1, 0x... | /xiangweizeng[P]ncnn/src/layer/binaryop.cpp |
tsl::detail_robin_hash::robin_hash<std::pair<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int>, tsl::robin_map<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, unsigned int, std::hash<std::__cxx11::basic_string<wchar_t, std::ch... | robin_iterator& operator++() {
while(true) {
if(m_iterator->last_bucket()) {
++m_iterator;
return *this;
}
++m_iterator;
if(!m_iterator->empty()) {
return *this;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdi), %rdx
addq $0x30, %rdx
movq %rdx, %rcx
cmpb $0x0, -0x2a(%rdx)
jne 0x634f8
leaq 0x30(%rcx), %rdx
cmpw $-0x1, 0x4(%rcx)
je 0x634e4
movq %rcx, (%rax)
popq %rbp
retq
nop
| /imShayan[P]JamSpell/contrib/tsl/robin_hash.h |
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.