name string | code string | asm string | file string |
|---|---|---|---|
QPDF::addPage(QPDFObjectHandle, bool) | void
QPDF::addPage(QPDFObjectHandle newpage, bool first)
{
if (first) {
insertPage(newpage, 0);
} else {
insertPage(newpage, getRoot().getKey("/Pages").getKey("/Count").getIntValueAsInt());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rsi, -0xd8(%rbp)
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)
je 0x2aa9a8
movq -0xd8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq... | /jberkenbilt[P]qpdf/libqpdf/QPDF_pages.cc |
tc_active(char const*) | static bool
tc_active(char const* const scope)
{
std::string value;
return (QUtil::get_env("TC_SCOPE", &value) && (value == scope));
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1b510
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x89bc4(%rip), %rsi # 0x335c41
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0x2ac088
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rs... | /jberkenbilt[P]qpdf/libqpdf/QTC.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> int_to_string_base_internal<long long>(long long, int, int) | static std::string
int_to_string_base_internal(T num, int base, int length)
{
// Backward compatibility -- int_to_string, which calls this function, used to use sprintf with
// %0*d, so we interpret length such that a negative value appends spaces and a positive value
// prepends zeroes.
if (!((base == ... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x238(%rbp)
movq %rdi, %rax
movq %rax, -0x230(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x8, -0x14(%rbp)
je 0x2ae6a8
cmpl $0xa, -0x14(%rbp)
je 0x2ae6a8
cmpl $0x10, -0x14(%rbp)
j... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::string_to_ll(char const*) | long long
QUtil::string_to_ll(char const* str)
{
errno = 0;
#ifdef _MSC_VER
long long result = _strtoi64(str, 0, 10);
#else
long long result = strtoll(str, nullptr, 10);
#endif
if (errno == ERANGE) {
throw std::range_error(
std::string("overflow/underflow converting ") + str + " to 6... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1bec0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1ba90
movq %rax, -0x10(%rbp)
callq 0x1bec0
cmpl $0x22, (%rax)
jne 0x2af04f
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x9... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::string_to_ull(char const*) | unsigned long long
QUtil::string_to_ull(char const* str)
{
char const* p = str;
while (*p && util::is_space(*p)) {
++p;
}
if (*p == '-') {
throw std::runtime_error(
std::string("underflow converting ") + str + " to 64-bit unsigned integer");
}
errno = 0;
#ifdef _MSC_... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0xf3(%rbp)
je 0x2af0da
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x31500
movb %al, -0xf3(%rbp)
movb -0xf3(%r... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::file_can_be_opened(char const*) | bool
QUtil::file_can_be_opened(char const* filename)
{
try {
fclose(safe_fopen(filename, "rb"));
return true;
} catch (std::runtime_error&) {
// can't open the file
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5ddcd(%rip), %rsi # 0x30d4a4
callq 0x2af590
movq %rax, -0x30(%rbp)
jmp 0x2af6e2
movq -0x30(%rbp), %rdi
callq 0x1b610
jmp 0x2af6ed
movb $0x1, -0x1(%rbp)
jmp 0x2af721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::seek(_IO_FILE*, long long, int) | int
QUtil::seek(FILE* stream, qpdf_offset_t offset, int whence)
{
#if HAVE_FSEEKO
return fseeko(stream, QIntC::IntConverter<qpdf_offset_t, off_t>::convert(offset), whence);
#elif HAVE_FSEEKO64
return fseeko64(stream, offset, whence);
#else
# if defined _MSC_VER || defined __BORLANDC__
return _fseeki64(strea... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b8440
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x1b8d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::same_file(char const*, char const*) | bool
QUtil::same_file(char const* name1, char const* name2)
{
if ((name1 == nullptr) || (strlen(name1) == 0) || (name2 == nullptr) || (strlen(name2) == 0)) {
return false;
}
#ifdef _WIN32
bool same = false;
# ifndef AVOID_WINDOWS_HANDLE
HANDLE fh1 = CreateFile(
name1, GENERIC_READ, FILE_... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2af7ef
movq -0x10(%rbp), %rdi
callq 0x1b5a0
cmpq $0x0, %rax
je 0x2af7ef
cmpq $0x0, -0x18(%rbp)
je 0x2af7ef
movq -0x18(%rbp), %rdi
callq 0x1b5a0
cmpq $0x0, %rax
jne 0x2af7f5
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::remove_file(char const*) | void
QUtil::remove_file(char const* path)
{
#ifdef _WIN32
std::shared_ptr<wchar_t> wpath = win_convert_filename(path);
os_wrapper(std::string("remove ") + path, _wunlink(wpath.get()));
#else
os_wrapper(std::string("remove ") + path, unlink(path));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1be40
movq -0x68(%rbp), %rdx
leaq 0x87189(%rip), %rsi # 0x336a0d
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0x2af88f
movq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1e9b0... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::file_provider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0::~$_0() | std::string
QUtil::path_basename(std::string const& filename)
{
#ifdef _WIN32
char const* pathsep = "/\\";
#else
char const* pathsep = "/";
#endif
std::string last = filename;
auto len = last.length();
while (len > 1) {
auto pos = last.find_last_of(pathsep);
if (pos == len - 1) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c1e8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::hex_decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::hex_decode(std::string const& input)
{
std::string result;
// We know result.size() <= 0.5 * input.size() + 1. However, reserving string space for this
// upper bound has a negative impact.
bool first = true;
char decoded;
for (auto ch: input) {
ch = util::hex_decode_c... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movb $0x1, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b380
movq %rax, -0x28(%rbp)
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::getWhoami(char*) | char*
QUtil::getWhoami(char* argv0)
{
char* whoami = nullptr;
if (((whoami = strrchr(argv0, '/')) == nullptr) &&
((whoami = strrchr(argv0, '\\')) == nullptr)) {
whoami = argv0;
} else {
++whoami;
}
if ((strlen(whoami) > 4) && (strcmp(whoami + strlen(whoami) - 4, ".exe") == 0... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x1bde0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2b03be
movq -0x8(%rbp), %rdi
movl $0x5c, %esi
callq 0x1bde0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x2b03be
movq -0x8(%rbp), %rax... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool
QUtil::get_env(std::string const& var, std::string* value)
{
// This was basically ripped out of wxWindows.
#ifdef _WIN32
# ifdef NO_GET_ENVIRONMENT
return false;
# else
// first get the size of the buffer
DWORD len = ::GetEnvironmentVariable(var.c_str(), NULL, 0);
if (len == 0) {
// th... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b180
movq %rax, %rdi
callq 0x1ba60
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2b0462
movb $0x0, -0x1(%rbp)
jmp 0x2b047a
cmpq $0x0, -0x18(%rbp)
je 0x2b0476
movq -0x20(%rbp), %rsi
movq -0x18(... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_current_qpdf_time() | QUtil::QPDFTime
QUtil::get_current_qpdf_time()
{
#ifdef _WIN32
SYSTEMTIME ltime;
GetLocalTime(<ime);
TIME_ZONE_INFORMATION tzinfo;
GetTimeZoneInformation(&tzinfo);
return QPDFTime(
static_cast<int>(ltime.wYear),
static_cast<int>(ltime.wMonth),
static_cast<int>(ltime.wDay),
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1ba20
movq %rax, -0x40(%rbp)
callq 0x1bc50
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1b260
movq -0x58(%rbp), %rdi
movq 0x1e0a66(%rip), %rax # 0x490f40
movq (%rax), %rax
movl $... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::qpdf_time_to_pdf_time[abi:cxx11](QUtil::QPDFTime const&) | std::string
QUtil::qpdf_time_to_pdf_time(QPDFTime const& qtm)
{
std::string tz_offset;
int t = qtm.tz_delta;
if (t == 0) {
tz_offset = "Z";
} else {
if (t < 0) {
t = -t;
tz_offset += "+";
} else {
tz_offset += "-";
}
tz_offset +... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1b510
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x2b0595
... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_time_to_qpdf_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, QUtil::QPDFTime*) | bool
QUtil::pdf_time_to_qpdf_time(std::string const& str, QPDFTime* qtm)
{
static std::regex pdf_date(
"^D:([0-9]{4})([0-9]{2})([0-9]{2})"
"([0-9]{2})([0-9]{2})([0-9]{2})"
"(?:(Z?)|([\\+\\-])([0-9]{2})'([0-9]{2})')$");
std::smatch m;
if (!std::regex_match(str, m, pdf_date)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0x1e17e6(%rip) # 0x492920
jne 0x2b118d
leaq 0x1e17dd(%rip), %rdi # 0x492920
callq 0x1b530
cmpl $0x0, %eax
je 0x2b118d
leaq 0x1e17ac(%rip), %rdi # 0x492900
leaq 0x858e0(%rip), %rsi ... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::toUTF16[abi:cxx11](unsigned long) | std::string
QUtil::toUTF16(unsigned long uval)
{
std::string result;
if ((uval >= 0xd800) && (uval <= 0xdfff)) {
result = "\xff\xfd";
} else if (uval <= 0xffff) {
char out[2];
out[0] = static_cast<char>((uval & 0xff00) >> 8);
out[1] = static_cast<char>(uval & 0xff);
r... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
cmpq $0xd800, -0x10(%rbp) # imm = 0xD800
jb 0x2b19cc
cmpq $0xdfff, -0x10(%rbp) # imm = 0xDFFF
ja 0x2b19cc
movq -0x90(%rbp), %r... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_file_into_memory(char const*, std::shared_ptr<char>&, unsigned long&) | void
QUtil::read_file_into_memory(char const* filename, std::shared_ptr<char>& file_buf, size_t& size)
{
FILE* f = safe_fopen(filename, "rb");
FileCloser fc(f);
fseek(f, 0, SEEK_END);
size = QIntC::to_size(QUtil::tell(f));
fseek(f, 0, SEEK_SET);
file_buf = QUtil::make_shared_array<char>(size);
... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x5b792(%rip), %rsi # 0x30d4a4
callq 0x2af590
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x12dbb0
movq -0x20(%rbp), %rd... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::read_lines_from_file[abi:cxx11](char const*, bool) | std::list<std::string>
QUtil::read_lines_from_file(char const* filename, bool preserve_eol)
{
std::list<std::string> lines;
FILE* f = safe_fopen(filename, "rb");
FileCloser fc(f);
auto next_char = [&f](char& ch) { return read_char_from_FILE(ch, f); };
read_lines_from_file(next_char, lines, preserve_... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0xc61b0
movq -0x10(%rbp), %rdi
leaq 0x5a70b(%rip), %rsi # 0x30d4a4
callq 0x2af590
mov... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::str_compare_nocase(char const*, char const*) | int
QUtil::str_compare_nocase(char const* s1, char const* s2)
{
#if defined(_WIN32) && defined(__BORLANDC__)
return stricmp(s1, s2);
#elif defined(_WIN32)
return _stricmp(s1, s2);
#else
return strcasecmp(s1, s2);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bb60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::parse_numrange(char const*, int) | std::vector<int>
QUtil::parse_numrange(char const* range, int max)
{
// Performance note: this implementation aims to be straightforward, not efficient. Numeric
// range parsing is used only during argument processing. It is not used during processing of
// PDF files.
static std::regex group_re(R"((x)?... | pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %rdi, -0x378(%rbp)
movq %rdi, %rax
movq %rax, -0x370(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpb $0x0, 0x1df60a(%rip) # 0x492948
jne 0x2b3391
leaq 0x1df601(%rip), %rdi # 0x492948
callq 0x1b530
cmpl $0x0, ... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
transcode_utf8(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>>&, encoding_e, char) | static bool
transcode_utf8(std::string const& utf8_val, std::string& result, encoding_e encoding, char unknown)
{
bool okay = true;
result.clear();
size_t len = utf8_val.length();
switch (encoding) {
case e_utf16:
result += "\xfe\xff";
break;
case e_pdfdoc:
// We need to ... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
movb $0x1, -0x16(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b7d0
movq -0x8(%rbp), %rdi
callq 0x1b850
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xa0(%rbp)
testl %... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::win_ansi_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::win_ansi_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 128) && (ch <= 160)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0x10(%rbp), %rdi
callq 0x1b850
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::mac_roman_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::mac_roman_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if (ch >= 128) {
ch_short = mac_r... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0x10(%rbp), %rdi
callq 0x1b850
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::pdf_doc_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string
QUtil::pdf_doc_to_utf8(std::string const& val)
{
std::string result;
size_t len = val.length();
for (unsigned int i = 0; i < len; ++i) {
unsigned char ch = static_cast<unsigned char>(val.at(i));
unsigned short ch_short = ch;
if ((ch >= 127) && (ch <= 160)) {
c... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b510
movq -0x10(%rbp), %rdi
callq 0x1b850
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x20(%rbp), %rax
jae... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
call_main_from_wmain(bool, int, wchar_t const* const*, std::function<int (int, char**)>) | static int
call_main_from_wmain(
bool, int argc, wchar_t const* const argv[], std::function<int(int, char*[])> realmain)
{
// argv contains UTF-16-encoded strings with a 16-bit wchar_t. Convert this to UTF-8-encoded
// strings for compatibility with other systems. That way the rest of qpdf.cc can just act l... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rcx, -0xf8(%rbp)
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x83ee0
leaq -0x8(%rbp), %rdi
callq 0x49400
movq %rax, -0xf0(%rbp)
jmp 0x2b5d50... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::get_max_memory_usage() | size_t
QUtil::get_max_memory_usage()
{
#if defined(HAVE_MALLOC_INFO) && defined(HAVE_OPEN_MEMSTREAM)
static std::regex tag_re("<(/?\\w+)([^>]*?)>");
static std::regex attr_re("(\\w+)=\"(.*?)\"");
char* buf;
size_t size;
FILE* f = open_memstream(&buf, &size);
if (f == nullptr) {
return 0... | pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp # imm = 0x410
cmpb $0x0, 0x1dc75e(%rip) # 0x492970
jne 0x2b6265
leaq 0x1dc755(%rip), %rdi # 0x492970
callq 0x1b530
cmpl $0x0, %eax
je 0x2b6265
leaq 0x1dc724(%rip), %rdi # 0x492950
leaq 0x809bf(%rip), %rsi # 0x336bf2
movl $0x10, %edx
callq 0x64c50
jmp ... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::is_number(char const*) | bool
QUtil::is_number(char const* p)
{
// No longer used by qpdf.
// ^[\+\-]?(\.\d*|\d+(\.\d*)?)$
if (!*p) {
return false;
}
if ((*p == '-') || (*p == '+')) {
++p;
}
bool found_dot = false;
bool found_digit = false;
for (; *p; ++p) {
if (*p == '.') {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2b6d0e
movb $0x0, -0x1(%rbp)
jmp 0x2b6d99
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x2b6d26
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x2b6d32
movq -0x10(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::file_provider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0::$_0($_0&&) | std::string
QUtil::path_basename(std::string const& filename)
{
#ifdef _WIN32
char const* pathsep = "/\\";
#else
char const* pathsep = "/";
#endif
std::string last = filename;
auto len = last.length();
while (len > 1) {
auto pos = last.find_last_of(pathsep);
if (pos == len - 1) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b1c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QUtil::file_provider(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::$_0::$_0($_0 const&) | std::string
QUtil::path_basename(std::string const& filename)
{
#ifdef _WIN32
char const* pathsep = "/\\";
#else
char const* pathsep = "/";
#endif
std::string last = filename;
auto len = last.length();
while (len > 1) {
auto pos = last.find_last_of(pathsep);
if (pos == len - 1) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b1c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
read_char_from_FILE(char&, _IO_FILE*) | static bool
read_char_from_FILE(char& ch, FILE* f)
{
auto len = fread(&ch, 1, 1, f);
if (len == 0) {
if (ferror(f)) {
throw std::runtime_error("failure reading character from file");
}
return false;
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1b810
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2b7644
movq -0x18(%rbp), %rdi
callq 0x1ba80
cmpl $0x0, %eax
je 0x2b763e
movl $0x10, %e... | /jberkenbilt[P]qpdf/libqpdf/QUtil.cc |
QIntC::IntConverter<int, unsigned char, true, false>::convert(int const&) | inline static To
convert(From const& i)
{
// From is signed, and To is unsigned. If i > 0, it's safe to
// convert it to the corresponding unsigned type and to
// compare with To's max.
auto ii = static_cast<typename to_u<From>::type>(i);
if ((... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x2ba585
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x47dd0
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jbe 0x2ba59... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<int, unsigned char, 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
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2ba5e2
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long long, long, true, true>::error(long long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte signed type";
throw std... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2bc663
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long, long long, true, true>::error(long) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte signed type to a " << sizeof(To) << "-byte signed type";
throw std... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2bc8c3
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<unsigned char, unsigned long, false, false>::error(unsigned char) | static void
error(From i)
{
std::ostringstream msg;
msg.imbue(std::locale::classic());
msg << "integer out of range converting " << i << " from a " << sizeof(From)
<< "-byte unsigned type to a " << sizeof(To) << "-byte unsigned type";
throw... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movb %dil, %al
movb %al, -0x1(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2bd555
movq -0x1c8(%rbp), %rdx
m... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<int, unsigned short, 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
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1be00
movq -0x180(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x180(%rbp,%rax), %rax
movq %rax, -0x1d0(%rbp)
callq 0x1b1f0
movq %rax, -0x1c8(%rbp)
jmp 0x2c57f2
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rb... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
ResourceFinder::handleObject(QPDFObjectHandle, unsigned long, unsigned long) | void
ResourceFinder::handleObject(QPDFObjectHandle obj, size_t offset, size_t)
{
if (obj.isOperator() && (!this->last_name.empty())) {
static std::map<std::string, std::string> op_to_rtype = {
{"CS", "/ColorSpace"},
{"cs", "/ColorSpace"},
{"gs", "/ExtGState"},
... | pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp # imm = 0x400
movq %rsi, -0x370(%rbp)
movq %rdi, %rax
movq -0x370(%rbp), %rdi
movq %rdi, -0x368(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x360(%rbp)
callq 0x1c00a0
testb $0x1... | /jberkenbilt[P]qpdf/libqpdf/ResourceFinder.cc |
SecureRandomDataProvider::provideRandomData(unsigned char*, unsigned long) | void
SecureRandomDataProvider::provideRandomData(unsigned char* data, size_t len)
{
# if defined(_WIN32)
// Optimization: make the WindowsCryptProvider static as long as
// it can be done in a thread-safe fashion.
WindowsCryptProvider c;
if (!CryptGenRandom(c.crypt_prov, static_cast<DWORD>(len), reinte... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpb $0x0, 0x1ca50a(%rip) # 0x492a78
jne 0x2c85b9
leaq 0x1ca501(%rip), %rdi # 0x492a78
callq 0x1b530
cmpl $0x0, %eax
je 0x2c85b9
leaq 0x1ca4e8(%rip), %rdi # 0x492a70
leaq -0x19(%rbp), %rsi
callq 0x2c... | /jberkenbilt[P]qpdf/libqpdf/SecureRandomDataProvider.cc |
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle) | bool
SF_FlateLzwDecode::setDecodeParms(QPDFObjectHandle decode_parms)
{
if (decode_parms.isNull()) {
return true;
}
auto memory_limit = Pl_Flate::memory_limit();
std::set<std::string> keys = decode_parms.getKeys();
for (auto const& key: keys) {
QPDFObjectHandle value = decode_parms... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x1bf7f0
testb $0x1, %al
jne 0x2c8db1
jmp 0x2c8dba
movb $0x1, -0x1(%rbp)
jmp 0x2c9253
callq 0... | /jberkenbilt[P]qpdf/libqpdf/SF_FlateLzwDecode.cc |
SF_FlateLzwDecode::SF_FlateLzwDecode(bool) | SF_FlateLzwDecode(bool lzw) :
lzw(lzw)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x23a760
movq -0x18(%rbp), %rdi
leaq 0x1c3544(%rip), %rax # 0x48fdb0
addq $0x10, %rax
movq %rax, (%rdi)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al,... | /jberkenbilt[P]qpdf/libqpdf/qpdf/SF_FlateLzwDecode.hh |
qpdf_cleanup | void
qpdf_cleanup(qpdf_data* qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_cleanup");
qpdf_oh_release_all(*qpdf);
if ((*qpdf)->error.get()) {
QTC::TC("qpdf", "qpdf-c cleanup warned about unhandled error");
*QPDFLogger::defaultLogger()->getWarn()
<< "WARNING: application did not han... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x653f5(%rip), %rdi # 0x331f38
leaq 0x6c18e(%rip), %rsi # 0x338cd8
xorl %edx, %edx
callq 0x25230
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2ccca0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x2fa340
cmpq $0x0, %rax
j... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_more_warnings | QPDF_BOOL
qpdf_more_warnings(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_more_warnings");
if (qpdf->warnings.empty()) {
std::vector<QPDFExc> w = qpdf->qpdf->getWarnings();
if (!w.empty()) {
qpdf->warnings.assign(w.begin(), w.end());
}
}
if (qpdf->warnings.e... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x65225(%rip), %rdi # 0x331f38
leaq 0x6c031(%rip), %rsi # 0x338d4b
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x2fa420
testb $0x1, %al
jne 0x2ccd37
jmp 0x2ccdb8
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %ra... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_get_error | qpdf_error
qpdf_get_error(qpdf_data qpdf)
{
if (qpdf->error.get()) {
qpdf->tmp_error.exc = qpdf->error;
qpdf->error = nullptr;
QTC::TC("qpdf", "qpdf-c qpdf_get_error returned error");
return &qpdf->tmp_error;
} else {
return nullptr;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa340
cmpq $0x0, %rax
je 0x2ccebe
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2fa4a0
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2fa4d0
movq ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_next_warning | qpdf_error
qpdf_next_warning(qpdf_data qpdf)
{
if (qpdf_more_warnings(qpdf)) {
qpdf->tmp_error.exc = std::make_shared<QPDFExc>(qpdf->warnings.front());
qpdf->warnings.pop_front();
QTC::TC("qpdf", "qpdf-c qpdf_next_warning returned warning");
return &qpdf->tmp_error;
} else {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ccd00
cmpl $0x0, %eax
je 0x2ccf4d
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x2fa5b0
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2fa540
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x2fa4f0
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
trap_errors(_qpdf_data*, std::function<void (_qpdf_data*)>) | static QPDF_ERROR_CODE
trap_errors(qpdf_data qpdf, std::function<void(qpdf_data)> fn)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
try {
fn(qpdf);
} catch (QPDFExc& e) {
qpdf->error = std::make_shared<QPDFExc>(e);
status |= QPDF_ERRORS;
} catch (std::runtime_error& e) {
qpdf-... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, %rax
movq -0x98(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rsi
callq 0x2fb680
jmp 0x2cd1a6
jmp 0x2cd213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_read_memory | QPDF_ERROR_CODE
qpdf_read_memory(
qpdf_data qpdf,
char const* description,
char const* buffer,
unsigned long long size,
char const* password)
{
QPDF_ERROR_CODE status = QPDF_SUCCESS;
qpdf->filename = description;
qpdf->buffer = buffer;
qpdf->size = size;
qpdf->password = password... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_info_key | void
qpdf_set_info_key(qpdf_data qpdf, char const* key, char const* value)
{
if ((key == nullptr) || (std::strlen(key) == 0) || (key[0] != '/')) {
return;
}
QPDFObjectHandle value_object;
if (value) {
QTC::TC("qpdf", "qpdf-c set_info_key to value");
value_object = QPDFObjectHandl... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2cde59
movq -0x10(%rbp), %rdi
callq 0x1b5a0
cmpq $0x0, %rax
je 0x2cde59
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2cde5e
jmp 0x2ce2... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_init_write | QPDF_ERROR_CODE
qpdf_init_write(qpdf_data qpdf, char const* filename)
{
qpdf_init_write_internal(qpdf);
qpdf->filename = filename;
QPDF_ERROR_CODE status = trap_errors(qpdf, &call_init_write);
QTC::TC("qpdf", "qpdf-c called qpdf_init_write", status);
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2ce750
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0x13c(%rip), %rax # 0x2ce810
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %... | /jberkenbilt[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 0x2ce750
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq 0x8c(%rip), %rax # 0x2ce910
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2fa610
movq -0x58(%rbp), %rdi
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_set_r6_encryption_parameters2 | void
qpdf_set_r6_encryption_parameters2(
qpdf_data qpdf,
char const* user_password,
char const* owner_password,
QPDF_BOOL allow_accessibility,
QPDF_BOOL allow_extract,
QPDF_BOOL allow_assemble,
QPDF_BOOL allow_annotate_and_form,
QPDF_BOOL allow_form_filling,
QPDF_BOOL allow_modify_ot... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl 0x30(%rbp), %eax
movl 0x28(%rbp), %eax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
movl %r8d, -0x38(%rbp)
movl %r9d, -0x3c(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
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 # 0x2cf740
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2fa610
movq -0x58(%rbp), %rdi
movq -0x50(%rbp),... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_object_type_e do_with_oh<qpdf_object_type_e>(_qpdf_data*, unsigned int, std::function<qpdf_object_type_e ()>, std::function<qpdf_object_type_e (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 0x302760
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_type_name | char const*
qpdf_oh_get_type_name(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_type_name");
qpdf->tmp_string = o.getTypeName();
return qpdf->tmp_... | 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 0x5ddf3(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
char const* do_with_oh<char const*>(_qpdf_data*, unsigned int, std::function<char const* ()>, std::function<char const* (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 0x302bd0
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_wrap_in_array | qpdf_oh
qpdf_oh_wrap_in_array(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<qpdf_oh>(
qpdf,
oh,
[qpdf]() { return qpdf_oh_new_array(qpdf); },
[qpdf](QPDFObjectHandle& qoh) {
if (qoh.isArray()) {
QTC::TC("qpdf", "qpdf-c array to wrap_in_array");
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x84(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d2050
movq -0x8(%rbp), %rax
movq %rax, -0... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
unsigned long long do_with_oh<unsigned long long>(_qpdf_data*, unsigned int, std::function<unsigned long long ()>, std::function<unsigned 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 0x303720
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_real_value | char const*
qpdf_oh_get_real_value(qpdf_data qpdf, qpdf_oh oh)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_real_value");
qpdf->tmp_string = o.getRealValue();
return qpdf->t... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq 0x5c663(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_real | QPDF_BOOL
qpdf_oh_get_value_as_real(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_real");
auto result = o.getValu... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x31b5(%rip), %rsi # 0x2d0310
leaq -0x40(%rbp), %rdi
callq 0x2fa980
movq -0x8(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
double do_with_oh<double>(_qpdf_data*, unsigned int, std::function<double ()>, std::function<double (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 0x303b90
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_name | char const*
qpdf_oh_get_name(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_name");
qpdf->tmp_string = o.getName();
return qpdf->tmp_string.c_str()... | 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 0x5bf63(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_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 0x5bc73(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_string | QPDF_BOOL
qpdf_oh_get_value_as_string(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_string");
auto result = o.get... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x3ba5(%rip), %rsi # 0x2d0310
leaq -0x40(%rbp), %rdi
callq 0x2fa980
movq -0x8(%rbp), %... | /jberkenbilt[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 0x5b983(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_value_as_utf8 | QPDF_BOOL
qpdf_oh_get_value_as_utf8(qpdf_data qpdf, qpdf_oh oh, char const** value, size_t* length)
{
return do_with_oh<QPDF_BOOL>(
qpdf, oh, return_false, [qpdf, value, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_value_as_utf8");
auto result = o.getValu... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x3e95(%rip), %rsi # 0x2d0310
leaq -0x40(%rbp), %rdi
callq 0x2fa980
movq -0x8(%rbp), %... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_binary_utf8_value | char const*
qpdf_oh_get_binary_utf8_value(qpdf_data qpdf, qpdf_oh oh, size_t* length)
{
return do_with_oh<char const*>(
qpdf, oh, return_T<char const*>(""), [qpdf, length](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_get_binary_utf8_value");
qpdf->tmp_string = o.getU... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq 0x5b51f(%rip), %rax # 0x32f9c0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x40... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_begin_dict_key_iter | void
qpdf_oh_begin_dict_key_iter(qpdf_data qpdf, qpdf_oh oh)
{
qpdf->cur_iter_dict_keys = do_with_oh<std::set<std::string>>(
qpdf,
oh,
[]() { return std::set<std::string>(); },
[](QPDFObjectHandle& o) {
QTC::TC("qpdf", "qpdf-c called qpdf_oh_begin_dict_key_iter");
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xbc(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x61(%rbp), %rsi
callq 0x2d4b20
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
leaq -0x89(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_dict_next_key | char const*
qpdf_oh_dict_next_key(qpdf_data qpdf)
{
QTC::TC("qpdf", "qpdf-c called qpdf_oh_dict_next_key");
if (qpdf_oh_dict_more_keys(qpdf)) {
qpdf->cur_dict_key = *qpdf->dict_iter;
++qpdf->dict_iter;
return qpdf->cur_dict_key.c_str();
} else {
return nullptr;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x5d285(%rip), %rdi # 0x331f38
leaq 0x64baa(%rip), %rsi # 0x339864
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rdi
callq 0x2d4c40
cmpl $0x0, %eax
je 0x2d4d18
movq -0x10(%rbp), %rdi
addq $0x120, %rdi # imm = 0x120
callq 0xc63... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_unparse_resolved | char const*
qpdf_oh_unparse_resolved(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_resolved");
qpdf->tmp_string = o.unparseResolved();
return ... | 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 0x58db3(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_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 0x58c53(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_get_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 -... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_oh_replace_stream_data | void
qpdf_oh_replace_stream_data(
qpdf_data qpdf,
qpdf_oh stream_oh,
unsigned char const* buf,
size_t len,
qpdf_oh filter_oh,
qpdf_oh decode_parms_oh)
{
do_with_oh_void(
qpdf, stream_oh, [qpdf, buf, len, filter_oh, decode_parms_oh](QPDFObjectHandle& o) {
QTC::TC("qpdf", "... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x84(%rbp)
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_find_page_by_id | int
qpdf_find_page_by_id(qpdf_data qpdf, int objid, int generation)
{
QTC::TC("qpdf", "qpdf-c called qpdf_find_page_by_id");
int n = -1;
QPDFObjGen og(objid, generation);
QPDF_ERROR_CODE code =
trap_errors(qpdf, [&n, &og](qpdf_data q) { n = QIntC::to_int(q->qpdf->findPage(og)); });
if (code ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
leaq 0x5a75c(%rip), %rdi # 0x331f38
leaq 0x62331(%rip), %rsi # 0x339b14
xorl %edx, %edx
callq 0x25230
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
le... | /jberkenbilt[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 0x5a154(%rip), %rdi # 0x331f38
leaq 0x61dc0(%rip), %rsi # 0x339bab
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -... | /jberkenbilt[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 0x2d8150
movq -0x60(%... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
bool do_with_oh<bool>(_qpdf_data*, unsigned int, std::function<bool ()>, std::function<bool (QPDFObjectHandle&)>) | static RET
do_with_oh(
qpdf_data qpdf,
qpdf_oh oh,
std::function<RET()> fallback,
std::function<RET(QPDFObjectHandle&)> fn)
{
return trap_oh_errors<RET>(qpdf, fallback, [fn, oh](qpdf_data q) {
auto i = q->oh_cache.find(oh);
bool result = ((i != q->oh_cache.end()) && (i->second).get()... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb0(%rbp)
movl %esi, %eax
movq -0xb0(%rbp), %rsi
movq %rcx, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fdd00
movq -0xa0(%rbp), ... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
bool trap_oh_errors<bool>(_qpdf_data*, std::function<bool ()>, std::function<bool (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x21(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
QPDFObjectHandle trap_oh_errors<QPDFObjectHandle>(_qpdf_data*, std::function<QPDFObjectHandle ()>, std::function<QPDFObjectHandle (_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 $0x130, %rsp # imm = 0x130
movq %rcx, -0xf0(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
ca... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_object_type_e trap_oh_errors<qpdf_object_type_e>(_qpdf_data*, std::function<qpdf_object_type_e ()>, std::function<qpdf_object_type_e (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rax, -0xd8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
char const* trap_oh_errors<char const*>(_qpdf_data*, std::function<char const* ()>, std::function<char const* (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
long long trap_oh_errors<long long>(_qpdf_data*, std::function<long long ()>, std::function<long long (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
double trap_oh_errors<double>(_qpdf_data*, std::function<double ()>, std::function<double (_qpdf_data*)>) | static RET
trap_oh_errors(qpdf_data qpdf, std::function<RET()> fallback, std::function<RET(qpdf_data)> fn)
{
// Note: fallback is a function so we don't have to evaluate it unless needed. This is important
// because sometimes the fallback creates an object.
RET ret;
QPDF_ERROR_CODE status = trap_errors... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdx, -0xe8(%rbp)
movq %rsi, %rax
movq -0xe8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
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)
... | /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
qpdf_update_all_pages_cache::$_0::operator()(_qpdf_data*) const | int
qpdf_find_page_by_id(qpdf_data qpdf, int objid, int generation)
{
QTC::TC("qpdf", "qpdf-c called qpdf_find_page_by_id");
int n = -1;
QPDFObjGen og(objid, generation);
QPDF_ERROR_CODE code =
trap_errors(qpdf, [&n, &og](qpdf_data q) { n = QIntC::to_int(q->qpdf->findPage(og)); });
if (code ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rdi
callq 0x2a96e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /jberkenbilt[P]qpdf/libqpdf/qpdf-c.cc |
QPDFExc::operator=(QPDFExc const&) | class QPDF_DLL_CLASS QPDFExc: public std::runtime_error
{
public:
QPDF_DLL
QPDFExc(
qpdf_error_code_e error_code,
std::string const& filename,
std::string const& object,
qpdf_offset_t offset,
std::string const& message);
QPDF_DLL
QPDFExc(
qpdf_error_cod... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 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... | /jberkenbilt[P]qpdf/include/qpdf/QPDFExc.hh |
wrap_qpdfjob(_qpdfjob_handle*, std::function<int (_qpdfjob_handle*)>) | static int
wrap_qpdfjob(qpdfjob_handle j, std::function<int(qpdfjob_handle j)> fn)
{
try {
return fn(j);
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n";
}
return QPDFJob::EXIT_ERROR;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x308830
movl %eax, -0x74(%rbp)
jmp 0x305d6c
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x305ed9
movq %rax, %rcx
movl %edx, %eax
movq... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
run_with_handle(std::function<int (_qpdfjob_handle*)>) | static int
run_with_handle(std::function<int(qpdfjob_handle)> fn)
{
auto j = qpdfjob_init();
int status = fn(j);
if (status == 0) {
status = qpdfjob_run(j);
}
qpdfjob_cleanup(&j);
return status;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x305b10
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x308830
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x30671b
movq -0x10(%rbp), %rdi
callq 0x3061e0
movl %eax, -0x14(%rbp)
leaq -0x10(%... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
QPDFCrypto_openssl::QPDFCrypto_openssl() | QPDFCrypto_openssl::QPDFCrypto_openssl() :
md_ctx(EVP_MD_CTX_new()),
cipher_ctx(EVP_CIPHER_CTX_new())
{
memset(md_out, 0, sizeof(md_out));
EVP_MD_CTX_init(md_ctx);
EVP_CIPHER_CTX_init(cipher_ctx);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x30c360
movq -0x30(%rbp), %rax
leaq 0x1858bc(%rip), %rcx # 0x490b00
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x28(%rbp)
callq 0x1b2f0
movq %rax, -0x20(%rbp)
jmp 0x30b25a
movq -0x30(%rbp), %rax
m... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
bad_bits(int) | static void
bad_bits(int bits)
{
throw std::logic_error(std::string("unsupported key length: ") + std::to_string(bits));
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movb $0x1, -0x81(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1be40
movq -0x90(%rbp), %rdx
leaq 0x2f6eb(%rip), %rsi # 0x33ae1f
leaq -0x48(%rbp), %rdi
callq 0x21b70
jmp 0x30b73f
movl... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::MD5_finalize() | void
QPDFCrypto_openssl::MD5_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 0x30b8e4
movq -0x18(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x18, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1b1a0
movl %eax... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
(anonymous namespace)::RC4Loader::getRC4() | EVP_CIPHER const*
RC4Loader::getRC4()
{
static auto loader = std::shared_ptr<RC4Loader>(new RC4Loader());
return loader->rc4;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpb $0x0, 0x186f99(%rip) # 0x492ac8
jne 0x30bb95
leaq 0x186f90(%rip), %rdi # 0x492ac8
callq 0x1b530
cmpl $0x0, %eax
je 0x30bb95
movl $0x18, %edi
callq 0x1b250
movq %rax, -0x18(%rbp)
jmp 0x30bb52
movq -0x18(%rbp), %rdi
callq 0x30be30
jmp 0x30bb5d
movq -0x18(%rbp), %rsi
... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::rijndael_init(bool, unsigned char const*, unsigned long, bool, unsigned char*) | void
QPDFCrypto_openssl::rijndael_init(
bool encrypt,
unsigned char const* key_data,
size_t key_len,
bool cbc_mode,
unsigned char* cbc_block)
{
const EVP_CIPHER* cipher = nullptr;
switch (key_len) {
case 32:
cipher = cbc_mode ? EVP_aes_256_cbc() : EVP_aes_256_ecb();
break... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %sil
movb %sil, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
Jupiter::Config::~Config() | class JUPITER_API Config
{
public:
/** Hash_Table type for sections */
using SectionHashTable = std::unordered_map<std::string, Config, jessilib::text_hashi, jessilib::text_equali>;
using ValuesHashTable = std::unordered_map<std::string, std::string, jessilib::text_hashi, jessilib::text_equali>;
using InKeyTy... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0xa415(%rip), %rax # 0x27fc0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x60, %rdi
callq 0x173b0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x17590
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x167... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/common/../include/Jupiter/Config.h |
unsigned long jessilib::starts_with_lengthi<char, char>(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | size_t starts_with_lengthi(std::basic_string_view<LhsCharT> in_string, std::basic_string_view<RhsCharT> in_prefix) {
// If in_string and in_prefix are the same type, skip decoding each point
if constexpr (std::is_same_v<LhsCharT, RhsCharT>) {
if (in_string.size() < in_prefix.size()) {
return 0;
}
}
size_t c... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x16620
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x16620
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x1fc0a
movq $0x0, -0x8(%rbp... | /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/unicode_compare.hpp |
void jessilib::impl_join::join_append<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::basic_string_view<char, std::char_traits<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | constexpr void join_append(OutT& out_string, InT&& in_string, ArgsT&&... in_args) {
using InCharT = typename std::remove_cvref_t<InT>::value_type;
if constexpr (std::is_same_v<typename std::remove_cvref_t<OutT>::value_type, InCharT>) {
// Join these straight together
out_string += std::forward<InT>(in_string);
}... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x17760
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /JAJames[P]Jupiter-Bot/src/Jupiter/src/jessilib/src/common/../include/jessilib/unicode.hpp |
ELFIO::elfio::elfio() | elfio() noexcept : sections( this ), segments( this )
{
create( ELFCLASS32, ELFDATA2LSB );
} | pushq %rax
movq %rdi, (%rdi)
movq %rdi, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movb $0x0, 0x50(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x39ee
popq... | /serge1[P]ELFIO/elfio/elfio.hpp |
ELFIO::elfio::create(unsigned char, unsigned char) | void create( unsigned char file_class, unsigned char encoding )
{
sections_.clear();
segments_.clear();
convertor.setup( encoding );
header = create_header( file_class, encoding );
create_mandatory_sections();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x3f88
leaq 0x38(%rbx), %rdi
callq 0x3f90
cmpl $0x1, %ebp
setne 0x50(%rbx)
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x3f98
movq (%r15), %rax
andq $... | /serge1[P]ELFIO/elfio/elfio.hpp |
ELFIO::elfio::Sections::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | section* add( const std::string& name ) const
{
section* new_section = parent->create_section();
new_section->set_name( name );
Elf_Half str_index = parent->get_section_name_str_index();
section* string_table( parent->sections_[str_index].get() );
str... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x48a6
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq (%r15), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x3b05
movq (%rdi), %rax
callq *0x100(%rax)
movzwl %ax, %ecx
mo... | /serge1[P]ELFIO/elfio/elfio.hpp |
ELFIO::string_section_accessor_template<ELFIO::section>::add_string(char const*) | Elf_Word add_string( const char* str )
{
if ( !str ) {
return 0; // Return index of empty string for null input
}
Elf_Word current_position = 0;
if ( string_section ) {
// Strings are added to the end of the current section data
current_position ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3bf8
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3bf8
movq %rsi, %r14
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, %r12
testl %r12d, %r12d
jne 0x3bc5
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq (%r15), %rdi
movq (... | /serge1[P]ELFIO/elfio/elfio_strings.hpp |
ELFIO::relocation_section_accessor_template<ELFIO::section>::add_entry(unsigned long, unsigned int, unsigned int) | void add_entry( Elf64_Addr offset, Elf_Word symbol, unsigned type )
{
Elf_Xword info;
if ( elf_file.get_class() == ELFCLASS32 ) {
info = ELF32_R_INFO( (Elf_Xword)symbol, type );
}
else {
info = ELF64_R_INFO( (Elf_Xword)symbol, type );
}
add_en... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x3c51
movq (%rdi), %rax
callq *0x20(%rax)
cmpb $0x1, %al
jne 0x3c51
movl %r14d, %r14d
shlq $0x8, %r14
movzbl %bpl, %ebp
jmp 0x3c55
shlq $0x... | /serge1[P]ELFIO/elfio/elfio_relocation.hpp |
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.