name string | code string | asm string | file string |
|---|---|---|---|
npf_vpprintf | int npf_vpprintf(npf_putc pc, void *pc_ctx, char const *format, va_list args) {
npf_format_spec_t fs;
char const *cur = format;
npf_cnt_putc_ctx_t pc_cnt;
pc_cnt.pc = pc;
pc_cnt.ctx = pc_ctx;
pc_cnt.n = 0;
while (*cur) {
int const fs_len = (*cur != '%') ? 0 : npf_parse_format_spec(cur, &fs);
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x40(%rbp)... | /charlesnicholson[P]nanoprintf/tests/../nanoprintf.h |
doctest::(anonymous namespace)::color_to_stream(std::ostream&, doctest::Color::Enum) | void color_to_stream(std::ostream& s, Color::Enum code) {
static_cast<void>(s); // for DOCTEST_CONFIG_COLORS_NONE or DOCTEST_CONFIG_COLORS_WINDOWS
static_cast<void>(code); // for DOCTEST_CONFIG_COLORS_NONE
#ifdef DOCTEST_CONFIG_COLORS_ANSI
if(g_no_colors ||
(isatty(STDOUT_FILE... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %fs:0x0, %rax
leaq -0x38(%rax), %rax
testb $0x1, (%rax)
jne 0xb8e5
movl $0x1, %edi
callq 0x57b0
cmpl $0x0, %eax
jne 0xb8ea
callq 0xc0c0
movb 0x78(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xb8ea
jmp 0xb9c8
... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::TestCase::operator=(doctest::detail::TestCase const&) | TestCase& TestCase::operator=(const TestCase& other) {
TestCaseData::operator=(other);
m_test = other.m_test;
m_type = other.m_type;
m_template_id = other.m_template_id;
m_full_name = other.m_full_name;
if(m_template_id != -1)
m_name =... | 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 0x22bf0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x50(%rdi)
movq -0x10(%rbp), %rsi
addq $0x58, %rsi
addq $0x58, %rdi
ca... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::isDebuggerActive() | bool isDebuggerActive() {
ErrnoGuard guard;
std::ifstream in("/proc/self/status");
for(std::string line; std::getline(in, line);) {
static const int PREFIX_LEN = 11;
if(line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0) {
return line.length() > PREFIX... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
leaq -0x8(%rbp), %rdi
callq 0x22cd0
leaq 0x26b9c(%rip), %rsi # 0x34a77
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x5840
jmp 0xdeee
leaq -0x240(%rbp), %rdi
callq 0x5640
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x50a0
movq %rax, -0... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
doctest::detail::ContextScopeBase::ContextScopeBase(doctest::detail::ContextScopeBase&&) | ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) noexcept {
if (other.need_to_destroy) {
other.destroy();
}
other.need_to_destroy = false;
g_infoContexts.push_back(this);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x22f10
movq -0x20(%rbp), %rax
leaq 0x3b708(%rip), %rcx # 0x49910
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0xe22a... | /charlesnicholson[P]nanoprintf/tests/doctest.h |
PDCLIB_fillbuffer | int _PDCLIB_fillbuffer( struct _PDCLIB_file_t * stream )
{
/* No need to handle buffers > INT_MAX, as PDCLib doesn't allow them */
ssize_t rc = read( stream->handle, stream->buffer, stream->bufsize );
if ( rc > 0 )
{
/* Reading successful. */
if ( !( stream->status & _PDCLIB_FBIN ) )
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x30c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x10006
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0... | /DevSolar[P]pdclib/platform/example/functions/_PDCLIB/_PDCLIB_fillbuffer.c |
raise | int raise( int sig )
{
void ( *sighandler )( int );
const char * message;
switch ( sig )
{
case SIGABRT:
sighandler = _PDCLIB_sigabrt;
message = "Abnormal termination (SIGABRT)";
break;
case SIGFPE:
sighandler = _PDCLIB_sigfpe;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xd, %eax
ja 0x1109c
movq -0x20(%rbp), %rax
leaq 0x1f79(%rip), %rcx # 0x12f64
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12595(%rip), %rax # 0x... | /DevSolar[P]pdclib/platform/example/functions/signal/raise.c |
(anonymous namespace)::JSONParser::parse() | JSON
JSONParser::parse()
{
while (!done) {
getToken();
handleToken();
}
if (parser_state != ps_done) {
QTC::TC("libtests", "JSON parse premature EOF");
throw std::runtime_error("JSON: premature end of input");
}
auto const& tos = stack.back().item;
if (reactor && ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, 0xc8(%rsp)
cmpb $0x0, 0x4040(%rsi)
je 0x2386f
cmpl $0x9, 0x4070(%rbx)
jne 0x24c14
movq 0x4080(%rbx), %r14
movq 0x8(%rbx), %rdi
movq -0x10(%r14), %rax
testq %rdi, %rdi
je 0x246ec
testq %rax, %rax
movq 0xc8(%rsp)... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::~JSONParser() | JSONParser(InputSource& is, JSON::Reactor* reactor) :
is(is),
reactor(reactor),
p(buf)
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4090(%rdi), %rdi
leaq 0x40a0(%rbx), %rax
cmpq %rax, %rdi
je 0x25bfa
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x4078(%rbx), %r14
movq 0x4080(%rbx), %r15
cmpq %r15, %r14
je 0x25c2b
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x25c1b
callq 0x1d0e8
addq $0x18, %r1... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::tokenError() | void
JSONParser::tokenError()
{
if (done) {
QTC::TC("libtests", "JSON parse ls premature end of input");
throw std::runtime_error("JSON: premature end of input");
}
if (lex_state == ls_u4) {
QTC::TC("libtests", "JSON parse bad hex after u");
throw std::runtime_error(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpb $0x1, 0x4040(%rdi)
jne 0x25ecc
movl $0x10, %edi
callq 0x193f0
movq %rax, %r14
leaq 0x137b9c(%rip), %rsi # 0x15da4a
movq %rax, %rdi
callq 0x192b0
movq 0x1ca0e3(%rip), %rsi # 0x1effa0
movq 0x1ca0ac(%rip), %rdx # 0x1eff70
movq... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
MD5::encodeString(char const*) | void
MD5::encodeString(char const* str)
{
size_t len = strlen(str);
crypto->MD5_init();
encodeDataIncrementally(str, len);
crypto->MD5_finalize();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x19420
movq %rax, %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%r14), %r12
movq %rbx, %rdi
callq 0x13dec7
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq *0x20(%rcx)
... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
error(QPDF&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
error(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
{
throw QPDFExc(qpdf_e_damaged_pdf, qpdf.getFilename(), get_description(node), 0, msg);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x80, %edi
callq 0x193f0
movq %rax, %rbx
movq %rsp, %rdi
movq %r12, %rsi
callq 0x3a61e
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x2fb1a
movb $0x1, %bpl
movq %rsp, %rdx
leaq 0x20(%rsp), %rcx
m... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::getNextKid(NNTreeIterator::PathElement&, bool) | QPDFObjectHandle
NNTreeIterator::getNextKid(PathElement& pe, bool backward)
{
QPDFObjectHandle result;
bool found = false;
while (!found) {
pe.kid_number += backward ? -1 : 1;
auto kids = pe.node.getKey("/Kids");
if ((pe.kid_number >= 0) && (pe.kid_number < kids.getArrayNItems())) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
negl %r13d
orl $0x1, %r13d
leaq 0x10(%rsp), %r12
movq %rsp, %r15
movq %rdi, 0x20(%rsp)
movl %r13d, 0x2c(%rsp)
addl %r13d, 0x10... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
warn(QPDF&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
warn(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
{
qpdf.warn(qpdf_e_damaged_pdf, get_description(node), 0, msg);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2fb1a
movq %r14, %rdi
movl $0x5, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x3a53c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a805
movq 0x10(%rsp), %rsi
incq ... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::split(QPDFObjectHandle, std::_List_iterator<NNTreeIterator::PathElement>) | void
NNTreeIterator::split(QPDFObjectHandle to_split, std::list<PathElement>::iterator parent)
{
// Split some node along the path to the item pointed to by this iterator, and adjust the
// iterator so it points to the same item.
// In examples, for simplicity, /Nums is shown to just contain numbers instea... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, 0x98(%rsp)
cmpl $0x0, 0x38(%rdi)
js 0x2ca60
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x13206b(%rip), %rsi # 0x15e3ec
leaq 0x132069(%rip), %rdx # 0x15e3f1... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::last() | NNTreeImpl::iterator
NNTreeImpl::last()
{
iterator result(*this);
result.deepen(this->oh, false, true);
return result;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1bc6d5(%rip), %rax # 0x1ea0e8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movups... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::compareKeyKid(QPDFObjectHandle&, QPDFObjectHandle&, int) | int
NNTreeImpl::compareKeyKid(QPDFObjectHandle& key, QPDFObjectHandle& kids, int idx)
{
if (!(kids.isArray() && (idx < kids.getArrayNItems()) &&
kids.getArrayItem(idx).isDictionary())) {
QTC::TC("qpdf", "NNTree kid is invalid");
error(qpdf, this->oh, "invalid kid at index " + std::to_strin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xc23c8
testb %al, %al
je 0x2e32a
movq %r15, %rdi
callq 0xf91b0
cmpl %r14d, %eax
jle 0x2e32a
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::insert(QPDFObjectHandle, QPDFObjectHandle) | NNTreeImpl::iterator
NNTreeImpl::insert(QPDFObjectHandle key, QPDFObjectHandle value)
{
auto iter = find(key, true);
if (!iter.valid()) {
QTC::TC("qpdf", "NNTree insert inserts first");
return insertFirst(key, value);
} else if (details.compareKeys(key, iter->first) == 0) {
QTC::TC("... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x68(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x2e956
movq 0x1c1638(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
Pl_DCT::compress(void*, Buffer*) | void
Pl_DCT::compress(void* cinfo_p, Buffer* b)
{
auto* cinfo = reinterpret_cast<jpeg_compress_struct*>(cinfo_p);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
jpeg_create_comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r13
movl $0x248, %edx # imm = 0x248
movq %rsi, %rdi
movl $0x50, %esi
callq 0x199e0
movl $0x10000, %ebx # imm = 0x10000
movl $0x10000, %edi # imm = 0x10000
callq 0... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::make_compress_config(std::function<void (jpeg_compress_struct*)>) | std::unique_ptr<Pl_DCT::CompressConfig>
Pl_DCT::make_compress_config(std::function<void(jpeg_compress_struct*)> f)
{
return std::make_unique<FunctionCallbackConfig>(f);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x19180
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x33e24
leaq 0x1b697a(%rip), %rax # 0x1ea418
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x18(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
empty_pipeline_output_buffer(jpeg_compress_struct*) | static boolean
empty_pipeline_output_buffer(j_compress_ptr cinfo)
{
QTC::TC("libtests", "Pl_DCT empty_pipeline_output_buffer");
auto* dest = reinterpret_cast<dct_pipeline_dest*>(cinfo->dest);
dest->next->write(dest->buffer, dest->size);
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_bu... | pushq %rbx
movq 0x28(%rdi), %rbx
movq 0x38(%rbx), %rdi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movups 0x28(%rbx), %xmm0
movups %xmm0, (%rbx)
movl $0x1, %eax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
QIntC::IntConverter<int, unsigned int, true, false>::error(int) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %edi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x19b00
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x19130
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x195d0
movq %rsp, %rdi
callq 0x19b50
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
Pl_Function::Pl_Function(char const*, Pipeline*, std::function<void (unsigned char const*, unsigned long)>) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_t fn) :
Pipeline(identifier, next),
m(std::make_unique<Members>(fn))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b5535(%rip), %rax # 0x1ea548
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x19180
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
callq 0x35886
movq %rsp, %rsi
movq %r14, %rdi
callq 0x35886
movq %r14, 0x30(%rbx)
movq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_Function::Pl_Function(char const*, Pipeline*, int (*)(char const*, unsigned long, void*), void*) | Pl_Function::Pl_Function(char const* identifier, Pipeline* next, writer_c_char_t fn, void* udata) :
Pipeline(identifier, next),
m(new Members(nullptr))
{
m->fn = [identifier, fn, udata](unsigned char const* data, size_t len) {
int code = fn(reinterpret_cast<char const*>(data), len, udata);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b52f0(%rip), %rax # 0x1ea548
movq %rax, (%rbx)
movl $0x20, %edi
callq 0x19180
movq %rax, %r14
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_Function::~Pl_Function() | Pl_Function::~Pl_Function() // NOLINT (modernize-use-equals-default)
{
// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b5197(%rip), %rax # 0x1ea548
movq %rax, (%rdi)
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x353c6
leaq 0x30(%rbx), %rdi
callq 0x358e4
movq $0x0, 0x30(%rbx)
leaq 0x1b478b(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x353f1
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_Function::write(unsigned char const*, unsigned long) | void
Pl_Function::write(unsigned char const* buf, size_t len)
{
m->fn(buf, len);
if (next()) {
next()->write(buf, len);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x3545c
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq *0x18(%rdi)
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x35452
movq (%rdi), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_LZWDecoder::Pl_LZWDecoder(char const*, Pipeline*, bool) | Pl_LZWDecoder::Pl_LZWDecoder(char const* identifier, Pipeline* next, bool early_code_change) :
Pipeline(identifier, next),
code_change_delta(early_code_change)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_LZWDecoder with nullptr as next");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b4c79(%rip), %rax # 0x1ea5b0
movq %rax, (%rbx)
movw $0x0, 0x30(%rbx)
xorl %eax, %eax
movb %al, 0x32(%rbx)
movl $0x9, 0x34(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movb %bpl, 0x48(%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::write(unsigned char const*, unsigned long) | void
Pl_LZWDecoder::write(unsigned char const* bytes, size_t len)
{
for (size_t i = 0; i < len; ++i) {
buf[next_char_++] = bytes[i];
if (next_char_ == 3) {
next_char_ = 0;
}
this->bits_available += 8;
if (this->bits_available >= this->code_size) {
send... | testq %rdx, %rdx
je 0x35a5a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movl 0x38(%r15), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x38(%r15)
movb %al, 0x30(%r15,%rcx)
cmpl $0x3, 0x38(%r15)
jne 0x35a2e
movl $0x0, 0x38(%r15)
mo... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::sendNextCode() | void
Pl_LZWDecoder::sendNextCode()
{
unsigned int high = this->byte_pos;
unsigned int med = (this->byte_pos + 1) % 3;
unsigned int low = (this->byte_pos + 2) % 3;
unsigned int bits_from_high = 8 - this->bit_pos;
unsigned int bits_from_med = this->code_size - bits_from_high;
unsigned int bits_fr... | pushq %rbp
pushq %rbx
movl 0x34(%rdi), %r8d
movl 0x3c(%rdi), %r11d
leal 0x1(%r11), %eax
movl $0xaaaaaaab, %r10d # imm = 0xAAAAAAAB
imulq %r10, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %edx
negl %edx
movl $0x8, %eax
movl $0x8, %ecx
subl 0x40(%rdi), %ecx
movl %r8d, %ebx
subl %ecx, %ebx
cmpl $0x8, %ebx
cmovbl %ebx, ... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::handleCode(unsigned int) | void
Pl_LZWDecoder::handleCode(unsigned int code)
{
if (this->eod) {
return;
}
if (code == 256) {
if (!this->table.empty()) {
QTC::TC("libtests", "Pl_LZWDecoder intermediate reset");
}
this->table.clear();
this->code_size = 9;
} else if (code == 257) ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x49(%rdi)
jne 0x35ca6
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x101, %esi # imm = 0x101
je 0x35b92
cmpl $0x100, %ebx # imm = 0x100
jne 0x35b9c
movq 0x50(%r14), %r12
movq 0x58(%r14), %r13
cmpq %r13, %r12
je 0x35b85
mo... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_MD5::Pl_MD5(char const*, Pipeline*) | Pl_MD5::Pl_MD5(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_MD5 with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b41c5(%rip), %rax # 0x1ea5f8
movq %rax, (%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
callq 0x29ab0
movw $0x1, 0x48(%rbx)
testq %r14, %r14
je 0x36454
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x193f0
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::write(unsigned char const*, unsigned long) | void
Pl_MD5::write(unsigned char const* buf, size_t len)
{
if (this->enabled) {
if (!this->in_progress) {
this->md5.reset();
this->in_progress = true;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
cmpb $0x1, 0x48(%rdi)
jne 0x36548
cmpb $0x0, 0x30(%r15)
jne 0x3650a
leaq 0x38(%r15), %rdi
callq 0x29b40
movb $0x1, 0x30(%r15)
cmpq $0x0, 0x8(%rsp)
je 0x36548
leaq 0x38(%r15), %r1... | /jberkenbilt[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::~Pl_MD5() | ~Pl_MD5() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x36610
callq 0x1d0e8
leaq 0x1b3549(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x36633
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_MD5.hh |
Pl_OStream::Pl_OStream(char const*, std::ostream&) | Pl_OStream::Pl_OStream(char const* identifier, std::ostream& os) :
Pipeline(identifier, nullptr),
m(std::make_unique<Members>(os))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x30ab4
leaq 0x1b3fd8(%rip), %rax # 0x1ea640
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x19180
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x1b34d2(%rip), %rax # 0x1e9b60
... | /jberkenbilt[P]qpdf/libqpdf/Pl_OStream.cc |
Pl_OStream::~Pl_OStream() | Pl_OStream::~Pl_OStream() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b3f83(%rip), %rax # 0x1ea640
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x366d3
movl $0x8, %esi
callq 0x190e0
movq $0x0, 0x30(%rbx)
leaq 0x1b347e(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x366fe
movq (%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_OStream.cc |
Pl_PNGFilter::Pl_PNGFilter(char const*, Pipeline*, Pl_PNGFilter::action_e, unsigned int, unsigned int, unsigned int) | Pl_PNGFilter::Pl_PNGFilter(
char const* identifier,
Pipeline* next,
action_e action,
unsigned int columns,
unsigned int samples_per_pixel,
unsigned int bits_per_sample) :
Pipeline(identifier, next),
action(action)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_PN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r15d
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b3f32(%rip), %rax # 0x1ea688
movq %rax, (%rbx)
movl %ebp, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::write(unsigned char const*, unsigned long) | void
Pl_PNGFilter::write(unsigned char const* data, size_t len)
{
size_t left = this->incoming - this->pos;
size_t offset = 0;
while (len >= left) {
// finish off current row
memcpy(this->cur_row + this->pos, data + offset, left);
offset += left;
len -= left;
process... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x70(%rdi), %rdi
movq 0x78(%r14), %r13
subq %rdi, %r13
cmpq %rdx, %r13
jbe 0x36a15
xorl %ebp, %ebp
movq %rdi, %r12
jmp 0x36a74
xorl %r12d, %r12d
xorl %ebp, %ebp
addq 0x40(%r14), %rdi
leaq (%... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::encodeRow() | void
Pl_PNGFilter::encodeRow()
{
// For now, hard-code to using UP filter.
unsigned char ch = 2;
next()->write(&ch, 1);
if (this->prev_row) {
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
ch = static_cast<unsigned char>(this->cur_row[i] - this->prev_row[i]);
ne... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb $0x2, (%rsi)
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x36b23
cmpl $0x0, 0x34(%rbx)
je 0x36b34
xorl %r15d, %r15d
leaq 0xf(%rsp), %r14
movq 0x40(%rbx), %rax
movq 0x48(%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeRow() | void
Pl_PNGFilter::decodeRow()
{
int filter = this->cur_row[0];
if (this->prev_row) {
switch (filter) {
case 0:
break;
case 1:
this->decodeSub();
break;
case 2:
this->decodeUp();
break;
case 3:
this->... | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x36bd0
movq 0x40(%rbx), %rax
movzbl (%rax), %edx
decl %edx
cmpl $0x3, %edx
ja 0x36bd0
leaq 0x1286dc(%rip), %rsi # 0x15f240
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
cmpl $0x0, 0x34(%rbx)
je 0x36bd0
movl 0x38(%rbx), %ecx
movl %ecx, %edx... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeUp() | void
Pl_PNGFilter::decodeUp()
{
QTC::TC("libtests", "Pl_PNGFilter decodeUp");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
unsigned char up = above_buffer[i];
buffer[i] = static_cast... | cmpl $0x0, 0x34(%rdi)
je 0x36c45
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
xorl %edx, %edx
movb 0x1(%rcx,%rdx), %sil
addb %sil, 0x1(%rax,%rdx)
incq %rdx
movl 0x34(%rdi), %esi
cmpq %rsi, %rdx
jb 0x36c30
retq
| /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodePaeth() | void
Pl_PNGFilter::decodePaeth()
{
QTC::TC("libtests", "Pl_PNGFilter decodePaeth");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
int left = 0;
... | cmpl $0x0, 0x34(%rdi)
je 0x36d39
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movl 0x38(%rdi), %edx
movl %edx, %esi
negl %esi
xorl %r8d, %r8d
movl $0x0, %r9d
movl $0x0, %r10d
cmpq %rdx, %r8
jb 0x36cd7
leal (%rsi,%r8), %r10d
movzbl 0x1(%rax,%r10), %r9d
movzbl 0x1(%rcx,%r10), %r... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::PaethPredictor(int, int, int) | int
Pl_PNGFilter::PaethPredictor(int a, int b, int c)
{
int p = a + b - c;
int pa = abs_diff(p, a);
int pb = abs_diff(p, b);
int pc = abs_diff(p, c);
if (pa <= pb && pa <= pc) {
return a;
}
if (pb <= pc) {
return b;
}
return c;
} | movl %esi, %eax
leal (%rdx,%rax), %esi
subl %ecx, %esi
movl %esi, %edi
subl %eax, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl %esi, %edi
subl %edx, %edi
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
subl %ecx, %esi
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
cmpl %edi, %r9d
cmoval %ecx, %edx
cmpl %edi, %r8d
cmo... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::finish() | void
Pl_PNGFilter::finish()
{
if (this->pos) {
// write partial row
processRow();
}
this->prev_row = nullptr;
this->cur_row = buf1.get();
this->pos = 0;
memset(this->cur_row, 0, this->bytes_per_row + 1);
next()->finish();
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x70(%rdi)
je 0x36d8d
movq %rbx, %rdi
callq 0x36aa8
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movq 0x50(%rbx), %rdi
movq %rdi, 0x40(%rbx)
movq %rax, 0x70(%rbx)
movl 0x34(%rbx), %edx
incl %edx
xorl %esi, %esi
callq 0x19330
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%ra... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_QPDFTokenizer::Pl_QPDFTokenizer(char const*, QPDFObjectHandle::TokenFilter*, Pipeline*) | Pl_QPDFTokenizer::Pl_QPDFTokenizer(
char const* identifier, QPDFObjectHandle::TokenFilter* filter, Pipeline* next) :
Pipeline(identifier, next),
m(std::make_unique<Members>())
{
m->filter = filter;
QPDFObjectHandle::TokenFilter::PipelineAccessor::setPipeline(m->filter, next);
m->tokenizer.allowE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq %rcx, %rdx
callq 0x30ab4
leaq 0x1b38df(%rip), %rax # 0x1ea6d0
movq %rax, (%rbx)
movl $0x48, %edi
callq 0x19180
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0,... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_QPDFTokenizer::~Pl_QPDFTokenizer() | Pl_QPDFTokenizer::~Pl_QPDFTokenizer() = default; | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b380c(%rip), %rax # 0x1ea6d0
movq %rax, (%rdi)
movq 0x30(%rdi), %r14
testq %r14, %r14
je 0x36eef
leaq 0x10(%r14), %rdi
callq 0x3296e
leaq 0x8(%r14), %rdi
callq 0xe122a
movl $0x48, %esi
movq %r14, %rdi
callq 0x190e0
movq $0x0, 0x30(%rbx)
leaq 0x1b2c62(%rip), %r... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_QPDFTokenizer::finish() | void
Pl_QPDFTokenizer::finish()
{
m->buf.finish();
auto input = BufferInputSource("tokenizer data", m->buf.getBuffer(), true);
std::string empty;
while (true) {
auto token = m->tokenizer.readToken(input, empty, true);
m->filter->handleToken(token);
if (token.getType() == QPDFToke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $0x10, %rdi
callq 0x32a1e
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1283d7(%rip), %rsi # 0x15f356
leaq 0x1283de(%rip), %rdx # 0x15f364
leaq 0x50(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
Pl_RC4::Pl_RC4(char const*, Pipeline*, unsigned char const*, int, unsigned long) | Pl_RC4::Pl_RC4(
char const* identifier,
Pipeline* next,
unsigned char const* key_data,
int key_len,
size_t out_bufsize) :
Pipeline(identifier, next),
out_bufsize(out_bufsize),
rc4(key_data, key_len)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_RC4 with nullptr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbx
callq 0x30ab4
leaq 0x1b32cd(%rip), %rax # 0x1ea718
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq %r12... | /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RC4::finish() | void
Pl_RC4::finish()
{
outbuf = nullptr;
next()->finish();
} | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x38(%rdi), %rdi
movups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0x37659
callq 0x1d0e8
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
| /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RunLength::encode(unsigned char const*, unsigned long) | void
Pl_RunLength::encode(unsigned char const* data, size_t len)
{
for (size_t i = 0; i < len; ++i) {
if ((m->state == st_top) != (m->length <= 1)) {
throw std::logic_error("Pl_RunLength::encode: state/length inconsistency");
}
unsigned char ch = data[i];
if ((m->length >... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x37932
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rax
xorl %r12d, %r12d
movl 0x4(%rax), %edx
movl 0x88(%rax), %ecx
testl %edx, %edx
sete %sil
cmpl $0x2, %ecx
setae %dil
xorb %sil, %dil
je 0x3793b
movb (%r14,%r12), %bpl
te... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::decode(unsigned char const*, unsigned long) | void
Pl_RunLength::decode(unsigned char const* data, size_t len)
{
if (memory_limit && (len + m->out.size()) > memory_limit) {
throw std::runtime_error("Pl_RunLength memory limit exceeded");
}
m->out.reserve(len);
for (size_t i = 0; i < len; ++i) {
unsigned char const& ch = data[i];
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1b9790(%rip), %rax # 0x1f1128
movq 0x30(%rdi), %rdi
testq %rax, %rax
je 0x379b4
movq 0x98(%rdi), %rcx
addq %rbx, %rcx
cmpq %rax, %rcx
ja 0x37a90
addq $0x90, %rdi
movq %rbx, %rsi
callq 0x19950
testq %rbx, %rb... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_StdioFile::finish() | void
Pl_StdioFile::finish()
{
if ((fflush(m->file) == -1) && (errno == EBADF)) {
throw std::logic_error(this->identifier + ": Pl_StdioFile::finish: stream already closed");
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq (%rax), %rdi
callq 0x19570
cmpl $-0x1, %eax
jne 0x3818e
callq 0x19ba0
cmpl $0x9, (%rax)
je 0x38197
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
addq $0x8, %r14
leaq 0x127390... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_String::write(unsigned char const*, unsigned long) | void
Pl_String::write(unsigned char const* buf, size_t len)
{
if (!len) {
return;
}
m->s.append(reinterpret_cast<char const*>(buf), len);
if (next()) {
next()->write(buf, len);
}
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x3831a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rax
movq (%rax), %rdi
callq 0x19370
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x3831a
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_String.cc |
QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(QPDF&) | QPDF::CopiedStreamDataProvider::CopiedStreamDataProvider(QPDF& destination_qpdf) :
QPDFObjectHandle::StreamDataProvider(true),
destination_qpdf(destination_qpdf)
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0xbf1b0
leaq 0x1b1709(%rip), %rax # 0x1ea8c8
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
leaq 0x20(%r14), %rax
xorl %ecx, %ecx
movl %ecx, 0x20(%r14)
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %rax, 0x38(%r14)
movq %rcx, 0x40(%r1... | /jberkenbilt[P]qpdf/libqpdf/QPDF.cc |
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper&) | void
QPDFFormFieldObjectHelper::generateTextAppearance(QPDFAnnotationObjectHelper& aoh)
{
QPDFObjectHandle AS = aoh.getAppearanceStream("/N");
if (AS.isNull()) {
QTC::TC("qpdf", "QPDFFormFieldObjectHelper create AS from scratch");
QPDFObjectHandle::Rectangle rect = aoh.getRect();
QPDFObj... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x150(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf59cc(%rip), %rsi # 0x161467
leaq 0xf59c7(%rip), %rdx # 0x161469
leaq 0x140(%rsp), %rdi
callq 0x1ee2c
leaq 0xf0(%rsp),... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFFormFieldObjectHelper::getFontFromResource(QPDFObjectHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFObjectHandle
QPDFFormFieldObjectHelper::getFontFromResource(QPDFObjectHandle resources, std::string const& name)
{
QPDFObjectHandle result;
if (resources.isDictionary() && resources.getKey("/Font").isDictionary() &&
resources.getKey("/Font").hasKey(name)) {
result = resources.getKey("/Font")... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdx, %rdi
callq 0xc2412
testb %al, %al
je 0x6d2a5
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf541b(%rip), %rsi # 0x16258b
leaq 0xf... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
(anonymous namespace)::TfFinder::~TfFinder() | ~TfFinder() override = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x17e3d3(%rip), %rax # 0x1eb708
movq %rax, (%rdi)
addq $0x70, %rdi
callq 0x462aa
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x6d359
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x6d372
movq (%rbx), %rsi
incq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFFormFieldObjectHelper.cc |
QPDFJob::writeOutfile(QPDF&) | void
QPDFJob::writeOutfile(QPDF& pdf)
{
std::shared_ptr<char> temp_out;
if (m->replace_input) {
// Append but don't prepend to the path to generate a temporary name. This saves us from
// having to split the path by directory and non-directory.
temp_out = QUtil::make_shared_cstr(std::str... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq (%rdi), %rax
cmpb $0x1, 0x3c9(%rax)
jne 0x77099
movq 0x3d0(%rax), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1edee
leaq 0xf08b8(%rip), %rsi # 0x167920
leaq 0x30(... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::setQPDFOptions(QPDF&) | void
QPDFJob::setQPDFOptions(QPDF& pdf)
{
pdf.setLogger(m->log);
if (m->ignore_xref_streams) {
pdf.setIgnoreXRefStreams(true);
}
if (m->suppress_recovery) {
pdf.setAttemptRecovery(false);
}
if (m->password_is_hex_key) {
pdf.setPasswordIsHexKey(true);
}
if (m->supp... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x776f1
movq 0x17889d(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0x776ed
incl 0x8(%rax)
jmp 0x776f1
lock
incl 0x8(%rax)
leaq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
show_encryption_method[abi:cxx11](QPDF::encryption_method_e) | static std::string
show_encryption_method(QPDF::encryption_method_e method)
{
std::string result = "unknown";
switch (method) {
case QPDF::e_none:
result = "none";
break;
case QPDF::e_unknown:
result = "unknown";
break;
case QPDF::e_rc4:
result = "RC4";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0xf0266(%rip), %rsi # 0x167a10
leaq 0xf0266(%rip), %rdx # 0x167a17
callq 0x1ee2c
cmpl $0x5, %ebp
jae 0x777e4
movl %ebp, %eax
leaq 0xeba80(%rip), %rdx # 0x163244
movslq (%rdx,%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doCheck(QPDF&) | void
QPDFJob::doCheck(QPDF& pdf)
{
// Code below may set okay to false but not to true. We assume okay until we prove otherwise but
// may continue to perform additional checks after finding errors.
bool okay = true;
auto& cout = *m->log->getInfo();
cout << "checking " << m->infilename.get() << "\n"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0xb9494
movq (%r12), %r15
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x7784d
callq 0x1d0e8
leaq 0xedea5(%rip), ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doShowObj(QPDF&) | void
QPDFJob::doShowObj(QPDF& pdf)
{
QPDFObjectHandle obj;
if (m->show_trailer) {
obj = pdf.getTrailer();
} else {
obj = pdf.getObjectByID(m->show_obj, m->show_gen);
}
bool error = false;
if (obj.isStream()) {
if (m->show_raw_stream_data || m->show_filtered_stream_data) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%rdi), %rax
cmpb $0x1, 0x1f2(%rax)
jne 0x77d4b
movq %rsp, %rdi
callq 0x3d384
jmp 0x77d5f
movl 0x1f4(%rax), %edx
movl 0x1f8(%rax), %ecx
movq %rsp, %rdi
callq 0x3aa32
movaps (%rsp), %xmm0
xorps %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doShowPages(QPDF&) | void
QPDFJob::doShowPages(QPDF& pdf)
{
int pageno = 0;
auto& cout = *m->log->getInfo();
for (auto& ph: QPDFPageDocumentHelper(pdf).getAllPages()) {
QPDFObjectHandle page = ph.getObjectHandle();
++pageno;
cout << "page " << pageno << ": " << page.getObjectID() << " " << page.getGener... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq (%rdi), %rax
movq (%rax), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0xb9494
movq (%r15), %r14
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x78165
callq 0x1d0e8
leaq 0x50(%rsp), %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doListAttachments(QPDF&) | void
QPDFJob::doListAttachments(QPDF& pdf)
{
QPDFEmbeddedFileDocumentHelper efdh(pdf);
if (efdh.hasEmbeddedFiles()) {
for (auto const& i: efdh.getEmbeddedFiles()) {
std::string const& key = i.first;
auto efoh = i.second;
*m->log->getInfo() << key << " -> "
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
callq 0x65188
movq %r14, %rdi
callq 0x653b6
testb %al, %al
je 0x788bd
movq %rbx, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x6582a
leaq 0xb0(%rsp), %rax
movq 0x10(%r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doShowAttachment(QPDF&) | void
QPDFJob::doShowAttachment(QPDF& pdf)
{
QPDFEmbeddedFileDocumentHelper efdh(pdf);
auto fs = efdh.getEmbeddedFile(m->attachment_to_show);
if (!fs) {
throw std::runtime_error("attachment " + m->attachment_to_show + " not found");
}
auto efs = fs->getEmbeddedFileStream();
// saveToStand... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x65188
movl $0x220, %edx # imm = 0x220
addq (%rbx), %rdx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x65756
movq 0x48(%rsp), %r14
testq %r14, %r14
je 0x78b2f
leaq 0x18(%rsp), %r15
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::getWantedJSONObjects() | QPDFObjGen::set
QPDFJob::getWantedJSONObjects()
{
QPDFObjGen::set wanted_og;
for (auto const& iter: m->json_objects) {
bool trailer;
int obj = 0;
int gen = 0;
parse_object_id(iter, trailer, obj, gen);
wanted_og.add(QPDFObjGen(obj, gen));
}
return wanted_og;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ebp, %ebp
movq %rbp, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
movq (%rsi), %r15
movq 0x2d8(%r15), %r14
addq $0x2c8, %r15 # imm... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::doJSONObjects(Pipeline*, bool&, QPDF&) | void
QPDFJob::doJSONObjects(Pipeline* p, bool& first, QPDF& pdf)
{
if (m->json_version == 1) {
JSON::writeDictionaryKey(p, first, "objects", 1);
bool first_object = true;
JSON::writeDictionaryOpen(p, first_object, 1);
bool all_objects = m->json_objects.empty();
auto wanted_og... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %r12
movq (%rdi), %r15
cmpl $0x1, 0x288(%r15)
movq %rcx, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
jne 0x790ff
movq %rcx, %rbx
leaq 0xb8(%rsp), %r14
movq %r14, -0x10(%r14)
lea... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob.cc |
QPDFJob::Config::replaceInput() | QPDFJob::Config*
QPDFJob::Config::replaceInput()
{
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
o.m->replace_input = true;
} else {
usage("replace-input can't be used since output file has already been given");
}
return this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
cmpq $0x0, 0x3e0(%rax)
jne 0xa3a7d
cmpb $0x0, 0x3c9(%rax)
je 0xa3abf
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd1680(%rip), %rsi # 0x17510d
leaq 0xd16bd(%rip), %rdx # 0x175151
movq %rsp, %r14
movq %r1... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::objectStreams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::objectStreams(std::string const& parameter)
{
o.m->object_stream_set = true;
if (parameter == "disable") {
o.m->object_stream_mode = qpdf_o_disable;
} else if (parameter == "preserve") {
o.m->object_stream_mode = qpdf_o_preserve;
} else if (parameter == ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movb $0x1, 0x144(%rax)
leaq 0xc5702(%rip), %rsi # 0x16a559
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0xa4ecb
leaq 0xc56e6(%rip), %rsi # 0x16a550
movq %r14, %rdi
callq 0x19a80
testl %eax,... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::removeUnreferencedResources(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::removeUnreferencedResources(std::string const& parameter)
{
if (parameter == "auto") {
o.m->remove_unreferenced_page_resources = QPDFJob::re_auto;
} else if (parameter == "yes") {
o.m->remove_unreferenced_page_resources = QPDFJob::re_yes;
} else if (paramete... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc5607(%rip), %rsi # 0x16a54b
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0xa4fb8
leaq 0xc5613(%rip), %rsi # 0x16a56a
movq %r14, %rdi
callq 0x19a80
testl %eax, %eax
je 0xa4fca
leaq 0xc89cc(%rip), %rsi # 0x16d936
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::showObject(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::Config*
QPDFJob::Config::showObject(std::string const& parameter)
{
QPDFJob::parse_object_id(parameter, o.m->show_trailer, o.m->show_obj, o.m->show_gen);
o.m->require_outfile = false;
return this;
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq (%rcx), %rcx
leaq 0x1f2(%rcx), %rsi
leaq 0x1f4(%rcx), %rdx
addq $0x1f8, %rcx # imm = 0x1F8
movq %rax, %rdi
callq 0x78cac
movq (%rbx), %rax
movq (%rax), %rax
movb $0x0, 0x3c8(%rax)
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::copyAttachmentsFrom() | std::shared_ptr<QPDFJob::CopyAttConfig>
QPDFJob::Config::copyAttachmentsFrom()
{
return std::shared_ptr<CopyAttConfig>(new CopyAttConfig(this));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x68, %edi
callq 0x19180
movq %r14, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), ... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::CopyAttConfig::CopyAttConfig(QPDFJob::Config*) | QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
config(c)
{
} | movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::CopyAttConfig::endCopyAttachmentsFrom() | QPDFJob::Config*
QPDFJob::CopyAttConfig::endCopyAttachmentsFrom()
{
if (this->caf.path.empty()) {
usage("copy attachments: no file specified");
}
this->config->o.m->attachments_to_copy.push_back(this->caf);
return this->config;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0xa5569
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcfda5(%rip), %rsi # 0x1752de
leaq 0xcfdc1(%rip), %rdx # 0x175301
movq %rsp, %r14
movq %r14, %rdi
callq 0x1ee2c
movq %r14, %rdi
callq 0x6f4c8
movq (%rsp), %rdi
c... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::AttConfig(QPDFJob::Config*) | QPDFJob::AttConfig::AttConfig(Config* c) :
config(c)
{
} | movq %rsi, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x78(%rdi), %rcx
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::creationdate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::creationdate(std::string const& parameter)
{
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
usage(std::string(parameter) + " is not a valid PDF timestamp");
}
this->att.creationdate = parameter;
return this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x14055e
testb %al, %al
jne 0xa57a4
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1e55e
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::moddate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::moddate(std::string const& parameter)
{
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
usage(std::string(parameter) + " is not a valid PDF timestamp");
}
this->att.moddate = parameter;
return this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x14055e
testb %al, %al
jne 0xa58ce
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x1e55e
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::mimetype(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::AttConfig*
QPDFJob::AttConfig::mimetype(std::string const& parameter)
{
if (parameter.find('/') == std::string::npos) {
usage("mime type should be specified as type/subtype");
}
this->att.mimetype = parameter;
return this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x19c90
cmpq $-0x1, %rax
jne 0xa5994
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xcf9bf(%rip), %rsi # 0x175320
leaq 0xcf9e5(%rip), %rdx # 0x17534d
leaq 0x8(%... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::AttConfig::endAddAttachment() | QPDFJob::Config*
QPDFJob::AttConfig::endAddAttachment()
{
static std::string now = QUtil::qpdf_time_to_pdf_time(QUtil::get_current_qpdf_time());
if (this->att.path.empty()) {
usage("add attachment: no file specified");
}
std::string last_element = QUtil::path_basename(this->att.path);
if (la... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movb 0x14b83e(%rip), %al # 0x1f1248
testb %al, %al
je 0xa5b72
cmpq $0x0, 0x10(%rbx)
jne 0xa5a5b
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xcf925(%rip), %rsi # 0x17534e
leaq 0xcf93f(%rip), %rdx # 0x17536f
leaq 0x8(%rsp), %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::pages() | std::shared_ptr<QPDFJob::PagesConfig>
QPDFJob::Config::pages()
{
if (!o.m->page_specs.empty()) {
usage("--pages may only be specified one time");
}
return std::shared_ptr<PagesConfig>(new PagesConfig(this));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rax
movq 0x380(%rax), %rcx
cmpq 0x388(%rax), %rcx
je 0xa5ca5
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xcf729(%rip), %rsi # 0x17539b
leaq 0xcf748(%rip), %rdx # 0x1753c1
leaq 0x8(... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::PagesConfig::endPages() | QPDFJob::Config*
QPDFJob::PagesConfig::endPages()
{
auto n_specs = config->o.m->page_specs.size();
if (n_specs == 0) {
usage("--pages: no page specifications given");
}
return this->config;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
movq 0x388(%rcx), %rdx
cmpq 0x380(%rcx), %rdx
jne 0xa5d5e
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf697(%rip), %rsi # 0x1753c2
leaq 0xcf6b5(%rip), %rdx # 0x1753e7
movq %rsp, %r14
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::PagesConfig::range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::PagesConfig*
QPDFJob::PagesConfig::range(std::string const& arg)
{
if (config->o.m->page_specs.empty()) {
QTC::TC("qpdf", "QPDFJob misplaced page range");
usage("in --range must follow a file name");
}
auto& last = config->o.m->page_specs.back();
if (!last.range.empty()) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x388(%rax), %r15
cmpq %r15, 0x380(%rax)
jne 0xa5e70
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf5ba(%rip), %rsi # 0x1753e8
leaq 0xcf5d5(%rip), %rdx #... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::PagesConfig::password(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | QPDFJob::PagesConfig*
QPDFJob::PagesConfig::password(std::string const& arg)
{
if (config->o.m->page_specs.empty()) {
QTC::TC("qpdf", "QPDFJob misplaced pages password");
usage("in --pages, --password must follow a file name");
}
auto& last = config->o.m->page_specs.back();
if (last.pass... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x388(%rax), %r12
cmpq %r12, 0x380(%rax)
jne 0xa5f87
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcf4e9(%rip), %rsi # 0x175433
leaq 0xcf510(%rip), %rdx #... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
QPDFJob::Config::overlay() | std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::overlay()
{
o.m->overlay.emplace_back("overlay");
o.m->under_overlay = &o.m->overlay.back();
return std::shared_ptr<UOConfig>(new UOConfig(this));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movl $0x360, %edi # imm = 0x360
addq (%rax), %rdi
leaq 0xc8819(%rip), %rsi # 0x16e877
callq 0xa7070
movq (%r14), %rax
movq (%rax), %rax
movq $-0x100, %rcx
addq 0x368(%rax), %rcx
movq %rcx, 0x378(%rax)
movl $0x8, %edi
callq... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_config.cc |
(anonymous namespace)::Handlers::beginArray(std::function<void (JSON)>, std::function<void ()>) | void
Handlers::beginArray(json_handler_t start_fn, bare_handler_t end_fn)
{
auto item_jh = std::make_shared<JSONHandler>();
jh->addArrayHandlers(
[start_fn](std::string const&, JSON j) { start_fn(j); },
[end_fn](std::string const&) { end_fn(); },
item_jh);
jh->addFallbackHandler(item... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %rsp, %rsi
leaq 0x78(%rsp), %rdx
callq 0xb8e42
movq 0x20(%rbx), %r14
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0xb8f6c
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::endAddAttachment() | void
Handlers::endAddAttachment()
{
this->c_att->endAddAttachment();
this->c_att = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0xa59f6
xorps %xmm0, %xmm0
movq 0x50(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
testq %rdi, %rdi
je 0xb3deb
popq %rbx
jmp 0x1d0e8
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginCopyAttachmentsFrom(JSON) | void
Handlers::beginCopyAttachmentsFrom(JSON)
{
this->c_copy_att = c_main->copyAttachmentsFrom();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa5448
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0xb3e3b
callq 0x1d0e8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb3e3... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::endCopyAttachmentsFrom() | void
Handlers::endCopyAttachmentsFrom()
{
this->c_copy_att->endCopyAttachmentsFrom();
this->c_copy_att = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0xa5516
xorps %xmm0, %xmm0
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0xb3e67
popq %rbx
jmp 0x1d0e8
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginPagesArray(JSON) | void
Handlers::beginPagesArray(JSON)
{
this->c_pages = c_main->pages();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0xa5c3a
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0xb3eaf
callq 0x1d0e8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xb3ea... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::endPagesArray() | void
Handlers::endPagesArray()
{
c_pages->endPages();
c_pages = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
callq 0xa5cf6
xorps %xmm0, %xmm0
movq 0x60(%rbx), %rdi
movups %xmm0, 0x58(%rbx)
testq %rdi, %rdi
je 0xb3edb
popq %rbx
jmp 0x1d0e8
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
(anonymous namespace)::Handlers::beginPages(JSON) | void
Handlers::beginPages(JSON j)
{
std::string file;
if (!j.getDictItem("file").getString(file)) {
QTC::TC("qpdf", "QPDFJob json pages no file");
usage("file is required in page specification");
}
c_pages->file(file);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc4d4c(%rip), %rsi # 0x178c62
leaq 0xc4d49(%rip), %rdx # 0x178c66
movq %... | /jberkenbilt[P]qpdf/libqpdf/QPDFJob_json.cc |
QPDFLogger::getError(bool) | std::shared_ptr<Pipeline>
QPDFLogger::getError(bool null_okay)
{
return throwIfNull(m->p_error, null_okay);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x60(%rax), %rcx
movq %rcx, (%rsp)
movq 0x68(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xb9714
movq 0x13687a(%rip), %rcx # 0x1eff80
cmpb $0x0, (%rcx)
je 0xb9710
incl 0x8(%rax)
jmp 0xb9714
lock
incl 0x8(%rax)
movzbl %dl, %ecx
movq %rsp, %rd... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setError(std::shared_ptr<Pipeline>) | void
QPDFLogger::setError(std::shared_ptr<Pipeline> p)
{
if (p == nullptr) {
p = m->p_stderr;
}
m->p_error = p;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
testq %rax, %rax
jne 0xb99b0
movq (%r14), %rsi
movq 0x30(%rsi), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
addq $0x38, %rsi
callq 0x27552
movq (%rbx), %rax
movq (%r14), %rdi
movq %rax, 0x60(%rdi)
addq $0x68, %rdi
addq $0x8, %rbx
movq %r... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDFLogger::setSave(std::shared_ptr<Pipeline>, bool) | void
QPDFLogger::setSave(std::shared_ptr<Pipeline> p, bool only_if_not_set)
{
if (only_if_not_set && (m->p_save != nullptr)) {
return;
}
if (m->p_save == p) {
return;
}
if (p == m->p_stdout) {
auto pt = dynamic_cast<Pl_Track*>(p.get());
if (pt->getUsed()) {
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x70(%r14), %rax
testl %edx, %edx
je 0xb99ee
testq %rax, %rax
jne 0xb9a65
xorl %eax, %eax
movq (%rbx), %r12
cmpq %r12, %rax
je 0xb9a65
cmpq 0x20(%r14), %r12
jne 0xb9a43
leaq 0x13017d(%rip), %rsi # 0x1e9b80
l... | /jberkenbilt[P]qpdf/libqpdf/QPDFLogger.cc |
QPDF::readHintStream(Pipeline&, long long, unsigned long) | QPDFObjectHandle
QPDF::readHintStream(Pipeline& pl, qpdf_offset_t offset, size_t length)
{
QPDFObjGen og;
QPDFObjectHandle H =
readObjectAtOffset(false, offset, "linearization hint stream", QPDFObjGen(0, 0), og, false);
ObjCache& oc = m->obj_cache[og];
qpdf_offset_t min_end_offset = oc.end_befor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x6998c(%rip), %rsi # 0x17d3df
leaq 0x6999e(%rip),... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void load_vector_vector<QPDF::HPageOffsetEntry>(BitStream&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int QPDF::HPageOffsetEntry::*, int, std::vector<int, std::allocator<int>> QPDF::HPageOffsetEntry::*) | static void
load_vector_vector(
BitStream& bit_stream,
int nitems1,
std::vector<T>& vec1,
int T::* nitems2,
int bits_wanted,
std::vector<int> T::* vec2)
{
// nitems1 times, read nitems2 (from the ith element of vec1) items into the vec2 vector field
// of the ith item of vec1.
for (s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movl %esi, (%rsp)
movslq %esi, %rax
movq %rax, 0x10(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
cmpl $0x0, (%rsp)
jns 0x114958
movl (%rsp), %edi
... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void write_vector_int<QPDF::HPageOffsetEntry, long long>(BitWriter&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int, long long QPDF::HPageOffsetEntry::*) | static void
write_vector_int(BitWriter& w, int nitems, std::vector<T>& vec, int bits, int_type T::* field)
{
// nitems times, write bits bits from the given field of the ith vector to the given bit writer.
for (size_t i = 0; i < QIntC::to_size(nitems); ++i) {
w.writeBits(QIntC::to_ulonglong(vec.at(i).*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, 0x10(%rsp)
movslq %esi, %rax
movq %rax, 0x20(%rsp)
movl %ecx, 0xc(%rsp)
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
testl %r13d, %r13d
jns 0x11ae76
movl %r13d, %edi... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
void write_vector_vector<QPDF::HPageOffsetEntry>(BitWriter&, int, std::vector<QPDF::HPageOffsetEntry, std::allocator<QPDF::HPageOffsetEntry>>&, int QPDF::HPageOffsetEntry::*, int, std::vector<int, std::allocator<int>> QPDF::HPageOffsetEntry::*) | static void
write_vector_vector(
BitWriter& w,
int nitems1,
std::vector<T>& vec1,
int T::* nitems2,
int bits,
std::vector<int> T::* vec2)
{
// nitems1 times, write nitems2 (from the ith element of vec1) items from the vec2 vector field
// of the ith item of vec1.
for (size_t i1 = 0; ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x30(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x8(%rsp)
movslq %esi, %rax
movq %rax, 0x20(%rsp)
movl %ecx, 0xc(%rsp)
movslq %ecx, %rax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
movabsq $0x2e8ba2e8ba2e8ba3, %r13 ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::writeHSharedObject(BitWriter&) | void
QPDF::writeHSharedObject(BitWriter& w)
{
HSharedObject& t = m->shared_object_hints;
w.writeBitsInt(t.first_shared_obj, 32); // 1
w.writeBits(toULL(t.first_shared_offset), 32); // 2
w.writeBitsInt(t.nshared_first_page, 32); // 3
w.writeBitsInt(t.nshared_total, 32); // ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq (%rdi), %r15
movl 0x3c0(%r15), %esi
movl $0x20, %edx
movq %r14, %rdi
callq 0x1dbaa
movq 0x3c8(%r15), %rsi
testq %rsi, %rsi
jns 0x11b0e0
movq %rsi, %rdi
callq 0xf7b02
movq 0x3c8(%r15), %rsi
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QPDF::writeHGeneric(BitWriter&, QPDF::HGeneric&) | void
QPDF::writeHGeneric(BitWriter& w, HGeneric& t)
{
w.writeBitsInt(t.first_object, 32); // 1
w.writeBits(toULL(t.first_object_offset), 32); // 2
w.writeBitsInt(t.nobjects, 32); // 3
w.writeBitsInt(t.group_length, 32); // 4
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rdx), %esi
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1dbaa
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jns 0x11b3b4
movq %rsi, %rdi
callq 0xf7b02
movq 0x8(%r14), %rsi
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1da88
movl 0x10(%r14), %esi
movl $0x20, %edx
mo... | /jberkenbilt[P]qpdf/libqpdf/QPDF_linearization.cc |
QIntC::IntConverter<double, int, true, true>::error(double) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte signed type";
throw std... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movsd %xmm0, 0x8(%rsp)
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x19b00
movq (%rbx), %rax
movq -0x18(%rax), %rbx
callq 0x19130
leaq (%rsp,%rbx), %rsi
addq $0x38, %rsi
leaq 0x10(%rsp), %rdi
movq %rax, %rdx
callq 0x195d0
leaq 0x10(%rsp), %rdi
... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
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.