name string | code string | asm string | file string |
|---|---|---|---|
QPDFObjectHandle::assertType(char const*, bool) const | void
QPDFObjectHandle::assertType(char const* type_name, bool istype) const
{
if (!istype) {
throw std::runtime_error(
std::string("operation for ") + type_name + " attempted on object of type " +
QPDFObjectHandle(*this).getTypeName());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %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, -0xd0(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1c945c
movb $0x1, -0xc1(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0xe0(%rbp)
leaq -0x99(%rbp), %rd... | /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 0x1c4090
cmpq $0x0, %rax
jne 0x1c99ab
movb $0x0, -0x1(%rbp)
jmp 0x1c9aa0
movq -0x78(%rbp), %rdi
callq 0x1c4090
movq %rax, %rdi
callq 0x2a78a0
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1be40... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::isImage(bool) const | bool
QPDFObjectHandle::isImage(bool exclude_imagemask) const
{
return (
isStreamOfType("", "/Image") &&
((!exclude_imagemask) ||
(!(getDict().getKey("/ImageMask").isBool() &&
getDict().getKey("/ImageMask").getBoolValue()))));
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x1be40
movq -0x120(%rbp), %rdx
movb $0x0, -0x99(%rbp)
movb $0x0, -0xc2(%rb... | /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 0x2c1c4a(%rip), %rcx # 0x48c000
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x48, %edi
callq 0x1b250
movq %r... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
QPDFObjectHandle::QPDFArrayItems::iterator::iterator(QPDFObjectHandle&, bool) | QPDFObjectHandle::QPDFArrayItems::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 0x2c16f2(%rip), %rcx # 0x48be58
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x1b250
movq %r... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
(anonymous namespace)::CoalesceProvider::provideStreamData(QPDFObjGen const&, Pipeline*) | void
CoalesceProvider::provideStreamData(QPDFObjGen const&, Pipeline* p)
{
QTC::TC("qpdf", "QPDFObjectHandle coalesce provide stream data");
std::string description = "page object " + containing_page.getObjGen().unparse(' ');
std::string all_description;
old_contents.pipeContentStreams(p, description, a... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq 0x167583(%rip), %rdi # 0x33205c
leaq 0x1621bf(%rip), %rsi # 0x32cc9f
xorl %edx, %edx
callq 0x25a90
movq -0xa0(%rbp), %rdi
addq $0x10, %rdi
callq 0x1c345... | /qpdf[P]qpdf/libqpdf/QPDFObjectHandle.cc |
JSON::Writer::writeNext() | Writer&
writeNext()
{
auto n = indent;
if (first) {
first = false;
write(&spaces[1], n % n_spaces + 1);
} else {
write(&spaces[0], n % n_spaces + 2);
}
while (n >= n_spaces) {
write(&spaces[2], n_spaces);
n -= n_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
testb $0x1, 0x8(%rax)
je 0x1cc01b
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
leaq 0x2c2a7f(%rip), %rdi # 0x48ea70
movl $0x1, %esi
callq 0x1cdb30
movq -0x18(%rbp... | /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 0x440f0
testb $0x1, %al
jne 0x1cc35d
movq $0x0, -0x8(%rbp)
jmp 0x1cc49c
movq -0x50(%rbp), %rdi
callq 0x66760
movq %rax, %rdi
callq 0x1d75a0
testb $0x1, %al
jne 0x1cc374
jmp 0x1cc38e
movq -0x50(%rbp), %... | /qpdf[P]qpdf/libqpdf/qpdf/QPDFObjectHandle_private.hh |
QPDF_String* qpdf::BaseHandle::as<QPDF_String>() 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 0x440f0
testb $0x1, %al
jne 0x1cc67d
movq $0x0, -0x8(%rbp)
jmp 0x1cc7bc
movq -0x50(%rbp), %rdi
callq 0x66760
movq %rax, %rdi
callq 0x1d7600
testb $0x1, %al
jne 0x1cc694
jmp 0x1cc6ae
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 0x1dab20
movq -0xf8(%rbp), %rdi
callq 0x1dac30
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1dac60... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.cc |
QPDFOutlineDocumentHelper::getOutlinesForPage(QPDFObjGen) | std::vector<QPDFOutlineObjectHelper>
QPDFOutlineDocumentHelper::getOutlinesForPage(QPDFObjGen og)
{
if (m->by_page.empty()) {
initializeByPage();
}
std::vector<QPDFOutlineObjectHelper> result;
if (m->by_page.count(og)) {
result = m->by_page[og];
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
callq 0x1da8a0
movq %rax, %rdi
addq $0x68, %rdi
callq 0x1daec0
testb $0x1, %al
jne ... | /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 0x43320
movq -0x19... | /qpdf[P]qpdf/libqpdf/QPDFOutlineDocumentHelper.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 0xc0000
... | /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 0x1e3060
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2a78a0
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 0x1e1440
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab680
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xab6b0
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 0x9fc50
movq -0x1b8(%rbp), %rdi
callq 0xa3b10
movb %al, -0x1aa(... | /qpdf[P]qpdf/libqpdf/QPDFPageDocumentHelper.cc |
QPDFPageDocumentHelper::flattenAnnotationsForPage(QPDFPageObjectHelper&, QPDFObjectHandle&, QPDFAcroFormDocumentHelper&, int, int) | void
QPDFPageDocumentHelper::flattenAnnotationsForPage(
QPDFPageObjectHelper& page,
QPDFObjectHandle& resources,
QPDFAcroFormDocumentHelper& afdh,
int required_flags,
int forbidden_flags)
{
bool need_appearances = afdh.getNeedAppearances();
std::vector<QPDFAnnotationObjectHelper> annots = pa... | pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp # imm = 0x630
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x520(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa3b10
movb %al, -0x29(%rbp)
movq -0x... | /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 0xaa340
movq -0xb8(%rbp), %rax
leaq 0x2a8f13(%rip), %rcx # 0x48ca88
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::getArtBox(bool, bool) | QPDFObjectHandle
QPDFPageObjectHelper::getArtBox(bool copy_if_shared, bool copy_if_fallback)
{
return getAttribute(
"/ArtBox",
copy_if_shared,
[this, copy_if_shared, copy_if_fallback]() {
return this->getCropBox(copy_if_shared, copy_if_fallback);
},
copy_if_fallba... | 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::forEachXObject(bool, std::function<void (QPDFObjectHandle&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>, std::function<bool (QPDFObjectHandle)>) | void
QPDFPageObjectHelper::forEachXObject(
bool recursive,
std::function<void(QPDFObjectHandle& obj, QPDFObjectHandle& xobj_dict, std::string const& key)>
action,
std::function<bool(QPDFObjectHandle)> selector)
{
QTC::TC(
"qpdf",
"QPDFPageObjectHelper::forEachXObject",
re... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rcx, -0x1a8(%rbp)
movq %rdx, -0x1a0(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movb -0x9(%rbp), %al
movb $0x0, -0x31... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getImages[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getImages()
{
std::map<std::string, QPDFObjectHandle> result;
forEachImage(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b5ef0
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::getFormXObjects[abi:cxx11]() | std::map<std::string, QPDFObjectHandle>
QPDFPageObjectHelper::getFormXObjects()
{
std::map<std::string, QPDFObjectHandle> result;
forEachFormXObject(
false, [&result](QPDFObjectHandle& obj, QPDFObjectHandle&, std::string const& key) {
result[key] = obj;
});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b5ef0
movq -0x68(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::externalizeInlineImages(unsigned long, bool) | void
QPDFPageObjectHelper::externalizeInlineImages(size_t min_size, bool shallow)
{
if (shallow) {
QPDFObjectHandle resources = getAttribute("/Resources", true);
// Calling mergeResources also ensures that /XObject becomes direct and is not shared with
// other pages.
resources.merge... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2e0(%rbp)
testb $0x1, -0x11(%rbp)
je 0x1e9037
leaq -0x49(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x1be40
movq -0x2e8... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter*, Pipeline*) | void
QPDFPageObjectHelper::filterContents(QPDFObjectHandle::TokenFilter* filter, Pipeline* next)
{
if (oh().isFormXObject()) {
oh().filterAsContents(filter, next);
} else {
oh().filterPageContents(filter, next);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc0000
movq -0x68(%rbp), %rdi
callq 0x1c9ac0
movb %al, -0x59(%rbp)
jmp 0x1e91aa
leaq -0x28(%rbp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::pipeContents(Pipeline*) | void
QPDFPageObjectHelper::pipeContents(Pipeline* p)
{
if (oh().isFormXObject()) {
oh().pipeStreamData(p, 0, qpdf_dl_specialized);
} else {
oh().pipePageContents(p);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %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)
callq 0xc0000
movq -0x60(%rbp), %rdi
callq 0x1c9ac0
movb %al, -0x51(%rbp)
jmp 0x1e99c6
leaq -0x20(%rbp), %rdi
callq 0x23be0
movb -0x51(%rbp)... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::addContentTokenFilter(std::shared_ptr<QPDFObjectHandle::TokenFilter>) | void
QPDFPageObjectHelper::addContentTokenFilter(
std::shared_ptr<QPDFObjectHandle::TokenFilter> token_filter)
{
if (oh().isFormXObject()) {
oh().addTokenFilter(token_filter);
} else {
oh().addContentTokenFilter(token_filter);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xc0000
movq -0x80(%rbp), %rdi
callq 0x1c9ac0
movb %al, -0x71(%rbp)
jmp 0x1e9ae0
leaq -0x20(%rbp), %rdi
callq 0... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::removeUnreferencedResourcesHelper(QPDFPageObjectHelper, 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_trai... | bool
QPDFPageObjectHelper::removeUnreferencedResourcesHelper(
QPDFPageObjectHelper ph, std::set<std::string>& unresolved)
{
bool is_page = (!ph.oh().isFormXObject());
if (!is_page) {
QTC::TC("qpdf", "QPDFPageObjectHelper filter form xobject");
}
ResourceFinder rf;
try {
auto q =... | pushq %rbp
movq %rsp, %rbp
subq $0x5b0, %rsp # imm = 0x5B0
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x488(%rbp)
movq %rsi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x480(%rbp)
callq 0xc0000
movq -0x480(%rbp), %rdi
callq 0x1c9ac0
movb %al, -0x471(%rbp)
jmp 0x1e9c64
movb -0x471(... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.cc |
QPDFPageObjectHelper::removeUnreferencedResources() | void
QPDFPageObjectHelper::removeUnreferencedResources()
{
// Accumulate a list of unresolved names across all nested form XObjects.
std::set<std::string> unresolved;
bool any_failures = false;
forEachFormXObject(
true,
[&any_failures, &unresolved](QPDFObjectHandle& obj, QPDFObjectHandle... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xc5e40
movq -0xe0(%rbp), %rax
movb $0x0, -0x39(%rbp)
leaq -0x39(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, ... | /qpdf[P]qpdf/libqpdf/QPDFPageObjectHelper.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 0x20149d
movq -0x10(%rbp), %rax
leaq 0x12d459(%rip), %rcx # 0x32e878
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x130c2d(%rip), %... | /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 0x25120
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 |
QPDFWriter::Members::~Members() | QPDFWriter::Members::~Members()
{
if (file && close_file) {
fclose(file);
}
delete output_buffer;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x203506
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x203506
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1b610
jmp 0x203504
jmp 0x203506
movq -0x10(%rbp), %rax
movq 0x30... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::setOutputMemory() | void
QPDFWriter::setOutputMemory()
{
m->filename = "memory buffer";
m->buffer_pipeline = new Pl_Buffer("qpdf output");
m->to_delete.push_back(std::shared_ptr<Pipeline>(m->buffer_pipeline));
initializePipelineStack(m->buffer_pipeline);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x219a00
leaq 0x12b298(%rip), %rcx # 0x32ee08
movq %rcx, 0x10(%rax)
movl $0x38, %edi
callq 0x1b250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x12b26d(%rip), %rsi # 0x32edfc
xorl %... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::compareVersions(int, int, int, int) const | int
QPDFWriter::compareVersions(int major1, int minor1, int major2, int minor2) const
{
if (major1 < major2) {
return -1;
} else if (major1 > major2) {
return 1;
} else if (minor1 < minor2) {
return -1;
} else if (minor1 > minor2) {
return 1;
} else {
return 0... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2043a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2043e0
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x2043b7... | /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 0x219a00
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x2057f7
jmp 0x205e7b
movq -0x1b0(%rbp), %rdi
callq 0x219a00
movq (%rax), %rsi
leaq -0x18(%rbp), %rd... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::copyEncryptionParameters(QPDF&) | void
QPDFWriter::copyEncryptionParameters(QPDF& qpdf)
{
m->preserve_encryption = false;
QPDFObjectHandle trailer = qpdf.getTrailer();
if (trailer.hasKey("/Encrypt")) {
generateID();
m->id1 = trailer.getKey("/ID").getArrayItem(0).getStringValue();
QPDFObjectHandle encrypt = trailer.ge... | pushq %rbp
movq %rsp, %rbp
subq $0x600, %rsp # imm = 0x600
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x4d8(%rbp)
callq 0x219a00
movb $0x0, 0x49(%rax)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x62020
leaq -0x41(%rbp), %rdi
movq %rdi, -0x4d0(%rbp)
callq 0x1be40
m... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::disableIncompatibleEncryption(int, int, int) | void
QPDFWriter::disableIncompatibleEncryption(int major, int minor, int extension_level)
{
if (!m->encrypted) {
return;
}
bool disable = false;
if (compareVersions(major, minor, 1, 3) < 0) {
disable = true;
} else {
int V = QUtil::string_to_int(m->encryption_dictionary["/V"... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x219a00
testb $0x1, 0x48(%rax)
jne 0x2086c3
jmp 0x2089ad
movq -0x88(%rbp), %rdi
movb $0x0, -0x15(%rbp)
movl -0xc(%rbp), %esi
movl -0x1... | /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 0x208b24
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x1264f2(%rip), %rsi... | /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 0x209313
jmp 0x209648
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x219a00
movq %rax, %rdi
addq $0x378, %rdi # imm = 0x378
callq 0x21a400
cmpq $0x2, %rax
jb 0x209336
jmp ... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::pushMD5Pipeline(QPDFWriter::PipelinePopper&) | void
QPDFWriter::pushMD5Pipeline(PipelinePopper& pp)
{
if (!m->id2.empty()) {
// Can't happen in the code
throw std::logic_error(
"Deterministic ID computation enabled after ID generation has already occurred.");
}
qpdf_assert_debug(m->deterministic_id);
qpdf_assert_debug(m->... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x219a00
movq %rax, %rdi
addq $0xd0, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x2099b3
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x12... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::openObject(int) | int
QPDFWriter::openObject(int objid)
{
if (objid == 0) {
objid = m->next_objid++;
}
m->new_obj[objid].xref = QPDFXRefEntry(m->pipeline->getCount());
writeString(std::to_string(objid));
writeString(" 0 obj\n");
return objid;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x209c80
movq -0x80(%rbp), %rdi
callq 0x219a00
movq %rax, %rcx
movl 0x298(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x298(%rcx)
movl %eax, -0xc(%rbp... | /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 0x1c21d0
testb $0x1, %al
jne 0x209f64
jmp 0x20a3b7
movq -0x140(%r... | /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 0x219a00
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x62020
m... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDFWriter::write() | void
QPDFWriter::write()
{
doWriteSetup();
// Set up progress reporting. For linearized files, we write two passes. events_expected is an
// approximation, but it's good enough for progress reporting, which is mostly a guess anyway.
m->events_expected = QIntC::to_int(m->pdf.getObjectCount() * (m->linea... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x212d50
movq -0x18(%rbp), %rdi
callq 0x219a00
movq (%rax), %rdi
callq 0x2854e0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x219a00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movb 0x4a(%rcx), %sil
m... | /qpdf[P]qpdf/libqpdf/QPDFWriter.cc |
QPDF::compute_encryption_parameters_V5(char const*, char const*, int, int, int, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std:... | void
QPDF::compute_encryption_parameters_V5(
char const* user_password,
char const* owner_password,
int V,
int R,
int key_len,
int P,
bool encrypt_metadata,
std::string const& id1,
std::string& encryption_key,
std::string& O,
std::string& U,
std::string& OE,
std::stri... | pushq %rbp
movq %rsp, %rbp
subq $0x340, %rsp # imm = 0x340
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %e... | /qpdf[P]qpdf/libqpdf/QPDF_encryption.cc |
QPDF::test_json_validators() | bool
QPDF::test_json_validators()
{
bool passed = true;
auto check_fn = [&passed](char const* msg, bool expr) {
if (!expr) {
passed = false;
std::cerr << msg << std::endl;
}
};
#define check(expr) check_fn(#expr, expr)
int obj = 0;
int gen = 0;
check(!is_... | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movb $0x1, -0x1(%rbp)
leaq -0x1(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x4d8(%rbp)
callq 0x1be40
movq -0x4d8(%rbp), %rdx
leaq 0xdb603(%rip), %rsi # 0x32faf6
leaq -0x38(%... | /qpdf[P]qpdf/libqpdf/QPDF_json.cc |
qpdf_get_info_key | char const*
qpdf_get_info_key(qpdf_data qpdf, char const* key)
{
char const* result = nullptr;
QPDFObjectHandle trailer = qpdf->qpdf->getTrailer();
if (trailer.hasKey("/Info")) {
QPDFObjectHandle info = trailer.getKey("/Info");
if (info.hasKey(key)) {
QPDFObjectHandle value = inf... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2fac70
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x62020
leaq -0x49(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x1be40
movq -0x120(%rbp), %rdx
leaq 0x... | /qpdf[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 0x2ce689
movq -0x10(%rbp), %rdi
callq 0x1b5a0
cmpq $0x0, %rax
je 0x2ce689
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2ce68e
jmp 0x2cea... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_init_write_memory | QPDF_ERROR_CODE
qpdf_init_write_memory(qpdf_data qpdf)
{
qpdf_init_write_internal(qpdf);
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_init_write_memory);
QTC::TC("qpdf", "qpdf-c called qpdf_init_write_memory");
qpdf->write_memory = true;
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cef80
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x8c(%rip), %rax # 0x2cf140
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2fae40
movq -0x58(%rbp), %rdi
mo... | /qpdf[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 0x628a7(%rip), %rdi ... | /qpdf[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(%... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_register_progress_reporter | void
qpdf_register_progress_reporter(
qpdf_data qpdf, void (*report_progress)(int percent, void* data), void* data)
{
QTC::TC("qpdf", "qpdf-c registered progress reporter");
qpdf->qpdf_writer->registerProgressReporter(
std::shared_ptr<QPDFWriter::ProgressReporter>(new QPDFWriter::FunctionProgressRep... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x6229e(%rip), %rdi # 0x33205c
leaq 0x69890(%rip), %rsi # 0x339655
xorl %edx, %edx
callq 0x25a90
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2faef0
movq %rax, -0x78(%rbp)
movl $0x28, %edi
call... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_write | QPDF_ERROR_CODE
qpdf_write(qpdf_data qpdf)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
status = trap_errors(qpdf, &call_write);
QTC::TC("qpdf", "qpdf-c called qpdf_write", (status == 0) ? 0 : 1);
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x8e(%rip), %rax # 0x2cff70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2fae40
movq -0x58(%rbp), %rdi
movq -0x50(%rbp),... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
unsigned int trap_oh_errors<unsigned int>(_qpdf_data*, std::function<unsigned int ()>, std::function<unsigned int (_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... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_bool | QPDF_BOOL
qpdf_oh_get_value_as_bool(qpdf_data qpdf, qpdf_oh oh, QPDF_BOOL* value)
{
return do_with_oh<QPDF_BOOL>(qpdf, oh, return_false, [value](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_bool");
bool v = *value;
QPDF_BOOL result = o.getValueAsBool(v);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x2121(%rip), %rsi # 0x2d0b40
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2fb1b0
movq -0x18(%rbp), ... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
long long do_with_oh<long long>(_qpdf_data*, unsigned int, std::function<long long ()>, std::function<long long (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 0x303ae0
movq -0xa0(%rbp), ... | /qpdf[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 0x5bf69(%rip), %rax # 0x32faf6
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_string_value | char const*
qpdf_oh_get_string_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_string_value");
qpdf->tmp_string = o.getStringValue();
return q... | 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 0x5b579(%rip), %rax # 0x32faf6
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_utf8_value | char const*
qpdf_oh_get_utf8_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_utf8_value");
qpdf->tmp_string = o.getUTF8Value();
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 0x5b289(%rip), %rax # 0x32faf6
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /qpdf[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 0x58559(%rip), %rax # 0x32faf6
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_stream_data | QPDF_ERROR_CODE
qpdf_oh_get_stream_data(
qpdf_data qpdf,
qpdf_oh stream_oh,
qpdf_stream_decode_level_e decode_level,
QPDF_BOOL* filtered,
unsigned char** bufp,
size_t* len)
{
return trap_errors(qpdf, [stream_oh, decode_level, filtered, bufp, len](qpdf_data q) {
auto stream = qpdf_oh_... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -... | /qpdf[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 0x5a409(%rip), %rdi # 0x33205c
leaq 0x61f65(%rip), %rsi # 0x339bbf
xorl %edx, %edx
callq 0x25a90
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
le... | /qpdf[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 0x5a050(%rip), %rdi # 0x33205c
leaq 0x61c11(%rip), %rsi # 0x339c24
xorl %edx, %edx
callq 0x25a90
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
le... | /qpdf[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... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_add_page_at | QPDF_ERROR_CODE
qpdf_add_page_at(
qpdf_data qpdf, qpdf_data newpage_qpdf, qpdf_oh newpage, QPDF_BOOL before, qpdf_oh refpage)
{
QTC::TC("qpdf", "qpdf-c called qpdf_add_page_at");
auto page = qpdf_oh_item_internal(newpage_qpdf, newpage);
auto ref = qpdf_oh_item_internal(qpdf, refpage);
return trap_er... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
leaq 0x59a48(%rip), %rdi # 0x33205c
leaq 0x616a0(%rip), %rsi # 0x339cbb
xorl %edx, %edx
callq 0x25a90
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -... | /qpdf[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_create_from_json_file | QPDF_ERROR_CODE
qpdf_create_from_json_file(qpdf_data qpdf, char const* filename)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = filename;
status = trap_errors(qpdf, [](qpdf_data q) { q->qpdf->createFromJSON(q->filename); });
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x39(%rbp), %rsi
callq 0x2d8980
movq -0x60(%... | /qpdf[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... | /qpdf[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>>>> trap_oh_errors<std::set<std::__cxx11::basic_... | 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 $0x150, %rsp # imm = 0x150
movq %rcx, -0x110(%rbp)
movq %rdx, -0x130(%rbp)
movq %rdi, -0x128(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x118(%rbp)
... | /qpdf[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 0x1b5d0
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... | /qpdf[P]qpdf/include/qpdf/QPDFExc.hh |
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 0x1b970
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x30c164
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x18, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1b1a0
movl %eax... | /qpdf[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
IF97::Region3::tau2_d2phi_dtau2(double, double) const | double tau2_d2phi_dtau2(double T, double rho) const{
const double delta = rho/Rhocrit, tau = Tcrit/T;
double summer = 0;
for (std::size_t i = 1; i < 40; ++i){
summer += nr[i]*Jr[i]*(Jr[i]-1)*powi(delta, Ir[i])*powi(tau, Jr[i]);
}
return summer;... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x70ed(%rip), %xmm1 # 0x2d278
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x70cc(%rip), %xmm0 # 0x2d268
divsd -0x1... | /CoolProp[P]IF97/IF97.h |
andres::View<int, true, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1462c
cmpq $0x0, (%r14)
je 0x148cb
cmpq %rbx, 0x28(%r14)
jbe 0x148e9
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xd080
movq %rax, %rbx
leaq 0x138da(%rip), %rsi # 0x281b9
movq ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<int, true, std::allocator<unsigned long>>::indexToCoordinates<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(unsigned long, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | inline void
View<T, isConst, A>::indexToCoordinates
(
std::size_t index, // copy to work on
CoordinateIterator outit
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || this->dimension() > 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || index < this->size());
if(coordinateOrder()... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1462c
cmpq $0x0, (%r14)
je 0x14aa6
cmpq $0x0, 0x28(%r14)
je 0x14ac4
cmpq %r15, 0x30(%r14)
jbe 0x14ae2
movq %r14, %rdi
callq 0x1462c
cmpl $0x0, 0x38(%r14)
movq (%r14), %rax
je 0x14a10
testq %rax, %rax
je 0x14b00
movq 0x28(%r14), %rc... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>::shape(unsigned long) cons... | const std::size_t shape(const std::size_t j) const
{ return e1_.dimension() < e2_.dimension() ? e2_.shape(j) : e1_.shape(j); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1eb7e
movq 0x8(%r14), %rdi
cmpq $0x0, (%rdi)
je 0x1edb9
cmpq 0x28(%rdi), %rax
jb 0x1edaa
movq (%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x134f8
movl $0x10, %edi
callq 0xd080
movq %rax,... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<int, std::allocator<unsigned long>>::Marray<andres::BinaryViewExpression<andres::BinaryViewExpression<andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>, int,... | inline
Marray<T, A>::Marray
(
const ViewExpression<E, Te>& expression,
const allocator_type& allocator
)
: dataAllocator_(allocator)
{
this->data_ = dataAllocator_.allocate(expression.size());
if(expression.dimension() == 0) {
this->geometry_ = geometry_type(0,
static_cast<const ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
movb $0x1, 0x3c(%rdi)
callq 0x12f64
leaq 0x40(%rbx), %r15
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::marray_detail::operate<andres::marray_detail::Assign<int, int>, int, std::allocator<unsigned long>, andres::BinaryViewExpression<andres::BinaryViewExpression<andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<int, false, std::allocator<unsigned long>>, i... | inline void operate
(
View<T1, false, A>& v,
const ViewExpression<E, T2>& expression,
Functor f
)
{
const E& e = expression; // cast
if(!MARRAY_NO_DEBUG) {
Assert(v.size() != 0 && e.size() != 0);
Assert(e.dimension() == v.dimension());
if(v.dimension() == 0) {
A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x1f696
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1fa24
testq %rax, %rax
je 0x1f696
movq %r14, %rdi
callq 0x1f9e4
cmpq $0x0, (%rbx)
je 0x1f6b4
cmpq 0x28(%rbx), %rax
jne 0x1f6d5
testq %rax, %rax
je 0... | /bjoern-andres[P]marray/include/andres/marray.hxx |
bool andres::BinaryViewExpression<andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>::overlaps<int, false,... | bool overlaps(const View<Tv, isConst, A>& v) const
{ return e1_.overlaps(v) || e2_.overlaps(v); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1f8ea
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1f8de
movq 0x8(%r14), %r14
movq %r14, %rdi
callq 0x12f64
movq %rbx, %rdi
callq 0x12f64
movq (%r14), %r15
testq %r15, %r15
je 0x1f8dc
movq (%rbx), %r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>::shapeBegin() const | const std::size_t* shapeBegin() const
{ return e_.shapeBegin(); } | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x12f64
cmpq $0x0, (%rbx)
je 0x1fbd9
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xd080
movq %rax, %rbx
leaq 0x85cc(%rip), %rsi # 0x281b9
movq %rax, %rdi
callq 0xd060
movq 0x123f4(%rip), %rsi # 0x... | /bjoern-andres[P]marray/include/andres/marray.hxx |
int const andres::BinaryViewExpression<andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>::operator()<int>... | const value_type operator()(Accessor it) const
{ return binaryFunctor_(e1_(it), e2_(it)); } | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
movq (%r15), %rdi
movq %rsp, %rsi
movl %ebx, (%rsi)
callq 0x139c2
movl (%rax), %ebp
imull 0x8(%r15), %ebp
movq 0x8(%r14), %rdi
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
callq 0x139c2
imull (%rax), %ebp
movl %ebp, %eax
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::BinaryViewExpression<andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>, int, andres::BinaryViewExpression<andres::BinaryViewExpressionS... | const value_type operator[](const std::size_t offset) const
{ return binaryFunctor_(e1_[offset], e2_[offset]); } | movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movq (%rdx), %rdx
movq (%rcx), %rcx
movl (%rcx,%rsi,4), %ecx
imull (%rdx,%rsi,4), %ecx
movq (%rax), %rdx
movq (%rdx), %r8
movq (%r8), %r8
movl (%r8,%rsi,4), %r8d
imull 0x8(%rdx), %r8d
movq 0x8(%rax), %rax
movq (%rax), %rax
i... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::BinaryViewExpression<andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>, int, andres::BinaryViewExpression<andres::BinaryViewExpressionS... | const bool isSimple() const
{ return e1_.isSimple() && e2_.isSimple()
&& e1_.coordinateOrder() == e2_.coordinateOrder(); } | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1ff6e
testb %al, %al
je 0x1feb2
movq 0x8(%rbx), %rdi
callq 0x1da9e
testb %al, %al
je 0x1feb2
movq (%rbx), %rax
movq (%rax), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x12f64
movl 0x38(%r14), %ebp
movq 0x8(%rbx), %rax
movq (%rax), %rbx
movq %r... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::BinaryViewExpression<andres::BinaryViewExpressionScalarFirst<andres::View<int, false, std::allocator<unsigned long>>, int, int, andres::marray_detail::Times<int, int, int>>, int, andres::View<int, false, std::allocator<unsigned long>>, int, andres::marray_detail::Times<int, int, int>>::isSimple() const | const bool isSimple() const
{ return e1_.isSimple() && e2_.isSimple()
&& e1_.coordinateOrder() == e2_.coordinateOrder(); } | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x12f64
cmpb $0x1, 0x3c(%r14)
jne 0x20017
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x12f64
cmpb $0x1, 0x3c(%r14)
jne 0x20017
movq (%rbx), %rax
movq (%rax), %r14
movq %r14, %rdi
callq 0x12f64
movl 0x38(%r14), %eb... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::View<float, false, std::allocator<unsigned long>>::assign<unsigned long*>(unsigned long*, unsigned long*, float*, andres::CoordinateOrder const&, andres::CoordinateOrder const&, std::allocator<float> const&) | inline void
View<T, isConst, A>::assign
(
ShapeIterator begin,
ShapeIterator end,
pointer data,
const CoordinateOrder& externalCoordinateOrder,
const CoordinateOrder& internalCoordinateOrder,
const allocator_type& allocator
)
{
// the invariant is not tested as a pre-condition of this
//... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rax
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %r9
movq %r12, %rdi
movq %r8, %rcx
movq %rax, %r8
callq 0x13122
leaq 0x8(%r14), %r15
cmpq %r15, %r12
je 0x201ae
movq 0x30(%rsp), %rax
movq 0x10(%r14), %rdi
movq 0x28(%r14), %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<float, false, std::allocator<unsigned long>>::shape(unsigned long) const | inline const std::size_t
View<T, isConst, A>::shape
(
const std::size_t dimension
) const
{
testInvariant();
marray_detail::Assert(MARRAY_NO_DEBUG || data_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || dimension < this->dimension());
return geometry_.shape(dimension);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2021a
cmpq $0x0, (%r14)
je 0x205c9
cmpq %rbx, 0x28(%r14)
jbe 0x205e7
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xd080
movq %rax, %rbx
leaq 0x7bdc(%rip), %rsi # 0x281b9
movq ... | /bjoern-andres[P]marray/include/andres/marray.hxx |
float const andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<float, false, std::allocator<unsigned long>>, float, andres::marray_detail::Plus<int, float, float>>::operator()<int>(int) const | const value_type operator()(Accessor it) const
{ return binaryFunctor_(e1_(it), e2_(it)); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
movl %ebx, (%rsi)
callq 0x139c2
movq %rax, %r15
movq 0x8(%r14), %rdi
leaq 0xc(%rsp), %rsi
movl %ebx, (%rsi)
callq 0x20eb2
cvtsi2ssl (%r15), %xmm0
addss (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::marray_detail::operate<andres::marray_detail::Assign<float, float>, float, std::allocator<unsigned long>, andres::BinaryViewExpression<andres::View<int, false, std::allocator<unsigned long>>, int, andres::View<float, false, std::allocator<unsigned long>>, float, andres::marray_detail::Plus<int, float, floa... | inline void operate
(
View<T1, false, A>& v,
const ViewExpression<E, T2>& expression,
Functor f
)
{
const E& e = expression; // cast
if(!MARRAY_NO_DEBUG) {
Assert(v.size() != 0 && e.size() != 0);
Assert(e.dimension() == v.dimension());
if(v.dimension() == 0) {
A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x20d55
movq %rsi, %r12
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x30(%rcx), %rcx
orq 0x30(%rax), %rcx
je 0x20d55
movq %rdi, %r13
movq %r12, %rdi
callq 0x2081a
cmpq $0x0, (%r13)
je 0x20d73
cmpq 0x28(%r13), %ra... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::View<float, false, std::allocator<unsigned long>>::operator()(unsigned long) const | inline typename View<T, isConst, A>::reference
View<T, isConst, A>::operator()
(
const std::size_t value
) const
{
testInvariant();
if(dimension() == 0) {
marray_detail::Assert(MARRAY_NO_ARG_TEST || value == 0);
return data_[0];
}
else {
std::size_t offset;
indexT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2021a
movq (%rbx), %rax
testq %rax, %rax
je 0x21fb3
cmpq $0x0, 0x28(%rbx)
je 0x21fa4
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20f64
movq (%r15), %rax
shlq $0x2, %rax
addq (%rbx), %rax
jmp 0x21fa... | /bjoern-andres[P]marray/include/andres/marray.hxx |
GameData::IsGameOver() | bool GameData::IsGameOver() {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (num[i][j] == 0)return false;
if (i - 1 >= 0 && num[i - 1][j] == num[i][j])return false;
if (i + 1 < 4 && num[i + 1][j] == num[i][j])return false;
if (j - 1 >= 0 && nu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
leaq 0x4(%rdi), %rax
xorl %r14d, %r14d
pushq $0x1
popq %rcx
pushq $0x4
popq %rdx
cmpq $0x4, %r14
je 0x2d93
leaq -0x1(%r14), %rdi
leaq 0x1(%r14), %rsi
xorl %ebp, %ebp
movq %r14, %r8
shlq $0x4, %r8
addq %rax, %r8
movq %... | /ZxfBugProgrammer[P]2048game/GameData.cpp |
GameData::InitNewGame() | void GameData::InitNewGame() {
local_best = std::max(local_best, score);
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
num[i][j] = 0;
MakeNewNumber();
MakeNewNumber();
std::ifstream TempFile("2048GAME.data",std::ios::in | std::ios::binary);
if(TempFile.is_open())
... | pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdi, %rbx
movl 0x44(%rdi), %eax
movl 0x70(%rdi), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, 0x70(%rdi)
leaq 0x4(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x2f91
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x2f88
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0x2f79... | /ZxfBugProgrammer[P]2048game/GameData.cpp |
int obs::signal<int ()>::operator()<>() | typename std::enable_if<!std::is_void<R>::value, R>::type
operator()(Args2&&...args) {
R result = R();
for (auto slot : m_slots)
if (slot)
result = (*slot)(std::forward<Args2>(args)...);
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x8(%rdi), %rbx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3ef8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3f40
xorl %ebx, %ebx
leaq 0x28(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f88
testb %al, %al
je 0x2795
movq %r14, %rdi
callq 0x3fd4
... | /dacap[P]observable/./obs/signal.h |
obs::safe_list<obs::slot<int (int)>>::iterator::operator++() | iterator& operator++() {
std::lock_guard<std::mutex> l(m_list.m_mutex_nodes);
assert(m_node);
if (m_node) {
unlock();
// Go to the next node.
m_node = m_node->next;
// Lock the new node that we're pointing to now.
if (m_node)
lock();
}
re... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x2dd6
cmpq $0x0, 0x8(%r14)
je 0x484d
movq %r14, %rdi
callq 0x4a4e
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x483a
movq %r14, %rdi
callq 0x49ae
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rax... | /dacap[P]observable/./obs/safe_list.h |
obs::safe_list<obs::slot<int (int)>>::iterator::~iterator() | ~iterator() {
if (m_node) {
std::lock_guard<std::mutex> l(m_list.m_mutex_nodes);
unlock();
}
assert(!m_locked);
m_list.unref();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x48a9
movq (%rbx), %r14
movq %r14, %rdi
callq 0x2dd6
movq %rbx, %rdi
callq 0x4a4e
movq %r14, %rdi
callq 0x20b0
cmpb $0x1, 0x18(%rbx)
je 0x48bf
movq (%rbx), %rdi
callq 0x45ce
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xc65(%rip), %rdi # ... | /dacap[P]observable/./obs/safe_list.h |
obs::safe_list<obs::slot<int (int)>>::iterator::unlock() | void unlock() {
if (!m_locked)
return;
assert(m_node);
m_node->unlock(this);
m_value = nullptr;
m_locked = false;
// node's locks count is zero
if (m_node->locks == 0)
m_list.m_delete_cv.notify_all();
} | pushq %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x4a7c
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4a8b
movq %rbx, %rsi
callq 0x4aaa
andq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movq 0x8(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x4a7e
popq %rbx
retq
movq (%rbx), %rdi
addq $0x40, %rdi
popq %rbx
jmp 0x2140
leaq 0x866(%rip)... | /dacap[P]observable/./obs/safe_list.h |
Commander::clearCommands() | void Commander::clearCommands()
{
std::map<std::string, Command*>::iterator itr;
for (itr = cmds.begin(); itr != cmds.end(); ++itr) {
Command* cmd = itr->second;
delete cmd;
}
this->cmds.clear();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x16a29
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x16a1c
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x15540
movq %rax, %r14
jmp 0x16a08
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq ... | /hasherezade[P]bearparser/commander/Commander.cpp |
Commander::printHelp() | void Commander::printHelp()
{
std::cout << "Available commands: " << cmds.size() << endl;
std::map<std::string, Command*>::iterator itr;
for (itr = cmds.begin(); itr != cmds.end(); ++itr) {
Command *cmd = itr->second;
if (cmd == NULL) continue;
std::cout << itr->first << " \t- " << c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x3b56e(%rip), %rdi # 0x51fc0
leaq 0x1b6e3(%rip), %rsi # 0x3213c
callq 0x15310
movq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0x152e0
movq %rax, %rdi
callq 0x155a0
movq 0x20(%rbx), %r12
addq $0x10, %rbx
leaq 0x1... | /hasherezade[P]bearparser/commander/Commander.cpp |
cmd_util::addrTypeToChar(Executable::addr_type) | char cmd_util::addrTypeToChar(Executable::addr_type type)
{
switch (type) {
case Executable::RAW: return 'r';
case Executable::RVA: return 'v';
case Executable::VA: return 'V';
default:
return '_';
}
return '_';
} | leal (,%rdi,8), %ecx
movl $0x5676725f, %edx # imm = 0x5676725F
shrl %cl, %edx
cmpl $0x4, %edi
pushq $0x5f
popq %rax
cmovbl %edx, %eax
retq
| /hasherezade[P]bearparser/commander/ExeCommander.cpp |
WrapperCommand::execute(CmdParams*, CmdContext*) | virtual void execute(CmdParams *params, CmdContext *context)
{
MappedExe *mappedExe = cmd_util::getMappedExeFromContext(context);
if (mappedExe == NULL) return;
size_t wrId = wrapperId;
if (wrId == INVALID_WRAPPER) {
cmd_util::printWrapperNames(mappedExe);
w... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x18d5f
testq %rax, %rax
je 0x18ef5
movq %rax, %r14
movq 0x28(%rbx), %r15
cmpq $-0x1, %r15
jne 0x18eb6
movq %r14, %rdi
callq 0x1791f
leaq 0x195a6(%rip), %rsi # 0x32433
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
c... | /hasherezade[P]bearparser/commander/ExeCommander.h |
DumpWrapperToFileCommand::wrapperAction(ExeElementWrapper*) | virtual void wrapperAction(ExeElementWrapper *wrapper)
{
if (!wrapper) {
return;
}
QString fileName = makeFileName(wrapper->getOffset());
bufsize_t dSize = FileBuffer::dump(fileName, *wrapper, true);
std::cout << "Dumped size: " << std::hex << "0x" << dSize
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
testq %rsi, %rsi
je 0x1907a
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x88(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x190aa
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1daaa
movq %ra... | /hasherezade[P]bearparser/commander/ExeCommander.h |
DumpWrapperToFileCommand::makeFileName(unsigned long) | QString makeFileName(const offset_t wrapperOffset)
{
std::stringstream sstr;
sstr << "wrapper";
if (wrapperOffset != INVALID_ADDR) {
sstr << "_at_" << std::hex << wrapperOffset;
}
sstr << ".bin";
return QString(sstr.str().c_str());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x151e0
leaq 0x38(%rsp), %r14
leaq 0x192b6(%rip), %rsi # 0x32388
movq %r14, %rdi
callq 0x15310
cmpq $-0x1, %r15
je 0x1910f
leaq 0x19398(%rip), %rsi # 0x3247f
movq %r14, %rdi
ca... | /hasherezade[P]bearparser/commander/ExeCommander.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.