name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 %rdi, -0xe0(%rbp)
callq 0x42b80
movq -0xd0(%rbp), %rdi
movq -0xe0(%rbp), %rsi
xorl %edx, %edx
callq 0x2a9aa0
jmp 0x2aa980
leaq -0x28(%rbp), %rdi
callq 0x23380
jmp 0x2aab81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x23380
jmp 0x2aab8a
movq -0xd8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x42b80
movq -0xd0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x610c0
jmp 0x2aa9ca
leaq -0x99(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1be40
movq -0xe8(%rbp), %rdx
leaq 0x6e5e6(%rip), %rsi # 0x318fd1
leaq -0x98(%rbp), %rdi
callq 0x21b70
jmp 0x2aa9f9
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x231400
jmp 0x2aaa0f
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1be40
movq -0xf0(%rbp), %rdx
leaq 0x6e5a8(%rip), %rsi # 0x318fd8
leaq -0xc0(%rbp), %rdi
callq 0x21b70
jmp 0x2aaa3e
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x231400
jmp 0x2aaa54
leaq -0x58(%rbp), %rdi
callq 0x1c0940
movl %eax, -0xf4(%rbp)
jmp 0x2aaa65
movl -0xf4(%rbp), %edx
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2a9aa0
jmp 0x2aaa7d
leaq -0x58(%rbp), %rdi
callq 0x23380
leaq -0xc0(%rbp), %rdi
callq 0x1c1e8
leaq -0xc1(%rbp), %rdi
callq 0x1c1d0
leaq -0x68(%rbp), %rdi
callq 0x23380
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
leaq -0x78(%rbp), %rdi
callq 0x23380
leaq -0x48(%rbp), %rdi
callq 0x23380
jmp 0x2aab81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aab76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aab61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aab55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aab40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2aab34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x23380
leaq -0xc0(%rbp), %rdi
callq 0x1c1e8
leaq -0xc1(%rbp), %rdi
callq 0x1c1d0
leaq -0x68(%rbp), %rdi
callq 0x23380
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x99(%rbp), %rdi
callq 0x1c1d0
leaq -0x78(%rbp), %rdi
callq 0x23380
leaq -0x48(%rbp), %rdi
callq 0x23380
jmp 0x2aab8a
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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), %rsi
callq 0x2b0430
movb %al, -0x69(%rbp)
jmp 0x2ac09a
movb -0x69(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x6a(%rbp)
jne 0x2ac0a9
jmp 0x2ac0c3
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x315c0
movb %al, -0x6b(%rbp)
jmp 0x2ac0bb
movb -0x6b(%rbp), %al
movb %al, -0x6a(%rbp)
jmp 0x2ac0c3
movb -0x6a(%rbp), %al
movb %al, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
movb -0x6c(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2ac112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
movq -0x58(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 == 8) || (base == 10) || (base == 16))) {
throw std::logic_error("int_to_string_base called with unsupported base");
}
std::string cvt;
if (base == 10) {
// Use the more efficient std::to_string when possible
cvt = std::to_string(num);
} else {
std::ostringstream buf;
buf.imbue(std::locale::classic());
buf << std::setbase(base) << std::nouppercase << num;
cvt = buf.str();
}
std::string result;
int str_length = QIntC::to_int(cvt.length());
if ((length > 0) && (str_length < length)) {
result.append(QIntC::to_size(length - str_length), '0');
}
result += cvt;
if ((length < 0) && (str_length < -length)) {
result.append(QIntC::to_size(-length - str_length), ' ');
}
return result;
}
|
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)
je 0x2ae6a8
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x240(%rbp)
leaq 0x885e8(%rip), %rsi # 0x336c52
callq 0x1bbe0
jmp 0x2ae671
movq -0x240(%rbp), %rdi
movq 0x1e2961(%rip), %rsi # 0x490fe0
movq 0x1e2932(%rip), %rdx # 0x490fb8
callq 0x1b920
movq -0x240(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x2ae96d
leaq -0x48(%rbp), %rdi
callq 0x1b510
cmpl $0xa, -0x14(%rbp)
jne 0x2ae6f2
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x242b0
jmp 0x2ae6c6
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1b790
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
jmp 0x2ae811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2ae964
leaq -0x1e0(%rbp), %rdi
callq 0x1be00
jmp 0x2ae700
movq -0x1e0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1e0(%rbp,%rax), %rax
movq %rax, -0x250(%rbp)
callq 0x1b1f0
movq %rax, -0x248(%rbp)
jmp 0x2ae728
movq -0x248(%rbp), %rdx
movq -0x250(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x1b7a0
jmp 0x2ae744
leaq -0x1e8(%rbp), %rdi
callq 0x1be70
movl -0x14(%rbp), %edi
callq 0x2bc570
movl %eax, -0x254(%rbp)
jmp 0x2ae760
movl -0x254(%rbp), %eax
movl %eax, -0x1ec(%rbp)
movl -0x1ec(%rbp), %esi
leaq -0x1e0(%rbp), %rdi
callq 0x1c160
movq %rax, -0x260(%rbp)
jmp 0x2ae787
movq -0x260(%rbp), %rdi
leaq 0xddfb(%rip), %rsi # 0x2bc590
callq 0x1c1b0
movq %rax, -0x268(%rbp)
jmp 0x2ae7a3
movq -0x268(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b870
jmp 0x2ae7b5
leaq -0x210(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x1c130
jmp 0x2ae7ca
leaq -0x48(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x1b790
leaq -0x210(%rbp), %rdi
callq 0x1c1e8
leaq -0x1e0(%rbp), %rdi
callq 0x1bd20
jmp 0x2ae811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x1bd20
jmp 0x2ae964
movq -0x238(%rbp), %rdi
movb $0x0, -0x211(%rbp)
callq 0x1b510
leaq -0x48(%rbp), %rdi
callq 0x1b850
movq %rax, -0x220(%rbp)
leaq -0x220(%rbp), %rdi
callq 0xc6150
movl %eax, -0x26c(%rbp)
jmp 0x2ae848
movl -0x26c(%rbp), %eax
movl %eax, -0x218(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x2ae8c4
movl -0x218(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2ae8c4
movl -0x18(%rbp), %eax
movl -0x218(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x224(%rbp)
leaq -0x224(%rbp), %rdi
callq 0x49400
movq %rax, -0x278(%rbp)
jmp 0x2ae88b
movq -0x278(%rbp), %rsi
movq -0x238(%rbp), %rdi
movl $0x30, %edx
callq 0x1bb10
jmp 0x2ae8a5
jmp 0x2ae8c4
movq -0x238(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c1e8
jmp 0x2ae964
movq -0x238(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1b0f0
jmp 0x2ae8d6
cmpl $0x0, -0x18(%rbp)
jge 0x2ae92f
movl -0x218(%rbp), %eax
xorl %ecx, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2ae92f
movl -0x18(%rbp), %eax
movl -0x218(%rbp), %ecx
addl %ecx, %eax
negl %eax
movl %eax, -0x228(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x49400
movq %rax, -0x280(%rbp)
jmp 0x2ae913
movq -0x280(%rbp), %rsi
movq -0x238(%rbp), %rdi
movl $0x20, %edx
callq 0x1bb10
jmp 0x2ae92d
jmp 0x2ae92f
movb $0x1, -0x211(%rbp)
testb $0x1, -0x211(%rbp)
jne 0x2ae94b
movq -0x238(%rbp), %rdi
callq 0x1c1e8
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
movq -0x230(%rbp), %rax
addq $0x280, %rsp # imm = 0x280
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
movq -0x20(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 64-bit integer");
}
return result;
}
|
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, -0x98(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1be40
movq -0x90(%rbp), %rdx
leaq 0x87a40(%rip), %rsi # 0x3369a4
leaq -0x70(%rbp), %rdi
callq 0x21b70
jmp 0x2aef6f
movq -0x8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1e9b0
jmp 0x2aef82
leaq 0x87a3a(%rip), %rdx # 0x3369c3
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1e9b0
jmp 0x2aef98
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c1c0
jmp 0x2aefaa
movq -0x98(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movq 0x1e2019(%rip), %rsi # 0x490fd8
movq 0x1e1f3a(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2af065
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af02d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af024
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af01b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c1e8
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x70(%rbp), %rdi
callq 0x1c1e8
leaq -0x71(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x85(%rbp)
jne 0x2af041
jmp 0x2af04d
movq -0x98(%rbp), %rdi
callq 0x1bcf0
jmp 0x2af05c
movq -0x10(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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_VER
unsigned long long result = _strtoui64(str, 0, 10);
#else
unsigned long long result = strtoull(str, nullptr, 10);
#endif
if (errno == ERANGE) {
throw std::runtime_error(
std::string("overflow converting ") + str + " to 64-bit unsigned integer");
}
return result;
}
|
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(%rbp), %al
testb $0x1, %al
jne 0x2af0e6
jmp 0x2af0f4
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2af0b7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2af228
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x108(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1be40
movq -0x100(%rbp), %rdx
leaq 0x87873(%rip), %rsi # 0x3369ad
leaq -0x70(%rbp), %rdi
callq 0x21b70
jmp 0x2af145
movq -0x8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1e9b0
jmp 0x2af158
leaq 0x87877(%rip), %rdx # 0x3369d6
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1e9b0
jmp 0x2af16e
movq -0x108(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1b430
jmp 0x2af180
movq -0x108(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movq 0x1e1dfb(%rip), %rsi # 0x490f90
movq 0x1e1dc4(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2af3b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af203
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af1fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af1f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c1e8
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x70(%rbp), %rdi
callq 0x1c1e8
leaq -0x71(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x85(%rbp)
jne 0x2af217
jmp 0x2af223
movq -0x108(%rbp), %rdi
callq 0x1bcf0
jmp 0x2af3ac
callq 0x1bec0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1bb30
movq %rax, -0x90(%rbp)
callq 0x1bec0
cmpl $0x22, (%rax)
jne 0x2af39c
movb $0x1, -0xf2(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x118(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1be40
movq -0x110(%rbp), %rdx
leaq 0x8775f(%rip), %rsi # 0x3369f2
leaq -0xf0(%rbp), %rdi
callq 0x21b70
jmp 0x2af2a1
movq -0x8(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1e9b0
jmp 0x2af2ba
leaq 0x87715(%rip), %rdx # 0x3369d6
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1e9b0
jmp 0x2af2d6
movq -0x118(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1b430
jmp 0x2af2eb
movq -0x118(%rbp), %rdi
movb $0x0, -0xf2(%rbp)
movq 0x1e1c90(%rip), %rsi # 0x490f90
movq 0x1e1c59(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2af3b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af377
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af36b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2af35f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
leaq -0xf0(%rbp), %rdi
callq 0x1c1e8
leaq -0xf1(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0xf2(%rbp)
jne 0x2af38e
jmp 0x2af39a
movq -0x118(%rbp), %rdi
callq 0x1bcf0
jmp 0x2af3ac
movq -0x90(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2af72c
movq -0x18(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x28(%rbp)
callq 0x1bab0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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(stream, offset, whence);
# else
return fseek(stream, QIntC::to_long(offset), whence);
# endif
#endif
}
|
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_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
HANDLE fh2 = CreateFile(
name2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
BY_HANDLE_FILE_INFORMATION fi1;
BY_HANDLE_FILE_INFORMATION fi2;
if ((fh1 != INVALID_HANDLE_VALUE) && (fh2 != INVALID_HANDLE_VALUE) &&
GetFileInformationByHandle(fh1, &fi1) && GetFileInformationByHandle(fh2, &fi2) &&
(fi1.dwVolumeSerialNumber == fi2.dwVolumeSerialNumber) &&
(fi1.nFileIndexLow == fi2.nFileIndexLow) && (fi1.nFileIndexHigh == fi2.nFileIndexHigh)) {
same = true;
}
if (fh1 != INVALID_HANDLE_VALUE) {
CloseHandle(fh1);
}
if (fh2 != INVALID_HANDLE_VALUE) {
CloseHandle(fh2);
}
# endif
return same;
#else
struct stat st1;
struct stat st2;
if ((stat(name1, &st1) == 0) && (stat(name2, &st2) == 0) && (st1.st_ino == st2.st_ino) &&
(st1.st_dev == st2.st_dev)) {
return true;
}
#endif
return false;
}
|
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
movb $0x0, -0x1(%rbp)
jmp 0x2af849
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1b130
cmpl $0x0, %eax
jne 0x2af845
movq -0x18(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x1b130
cmpl $0x0, %eax
jne 0x2af845
movq -0xa0(%rbp), %rax
cmpq -0x130(%rbp), %rax
jne 0x2af845
movq -0xa8(%rbp), %rax
cmpq -0x138(%rbp), %rax
jne 0x2af845
movb $0x1, -0x1(%rbp)
jmp 0x2af849
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopw (%rax,%rax)
|
/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
jmp 0x2af8a2
movq -0x8(%rbp), %rdi
callq 0x1b3a0
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x2af560
jmp 0x2af8b8
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2af913
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2af90a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
movq -0x58(%rbp), %rdi
callq 0x1b960
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()
|
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) {
last.pop_back();
--len;
} else if (pos == std::string::npos) {
break;
} else {
last = last.substr(pos + 1);
break;
}
}
return last;
}
|
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_char(ch);
if (ch < '\20') {
if (first) {
decoded = static_cast<char>(ch << 4);
first = false;
} else {
result.push_back(decoded | ch);
first = true;
}
}
}
if (!first) {
result.push_back(decoded);
}
return result;
}
|
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)
movq -0x20(%rbp), %rdi
callq 0x1bf80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2edf0
testb $0x1, %al
jne 0x2b0250
jmp 0x2b02d4
leaq -0x28(%rbp), %rdi
callq 0x2ee30
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %edi
callq 0x31490
movb %al, -0x59(%rbp)
jmp 0x2b026c
movb -0x59(%rbp), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x10, %eax
jge 0x2b02c4
testb $0x1, -0x12(%rbp)
je 0x2b02a8
movsbl -0x31(%rbp), %eax
shll $0x4, %eax
movb %al, -0x13(%rbp)
movb $0x0, -0x12(%rbp)
jmp 0x2b02c2
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x1c1e8
jmp 0x2b0308
movq -0x58(%rbp), %rdi
movb -0x13(%rbp), %al
movb -0x31(%rbp), %cl
orb %cl, %al
movsbl %al, %esi
callq 0x1c140
jmp 0x2b02be
movb $0x1, -0x12(%rbp)
jmp 0x2b02c4
jmp 0x2b02c6
leaq -0x28(%rbp), %rdi
callq 0x2ee50
jmp 0x2b023a
testb $0x1, -0x12(%rbp)
jne 0x2b02eb
movq -0x58(%rbp), %rdi
movsbl -0x13(%rbp), %esi
callq 0x1c140
jmp 0x2b02e9
jmp 0x2b02eb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2b02fe
movq -0x58(%rbp), %rdi
callq 0x1c1e8
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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)) {
whoami[strlen(whoami) - 4] = '\0';
}
return whoami;
}
|
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
movq %rax, -0x10(%rbp)
jmp 0x2b03ca
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b5a0
cmpq $0x4, %rax
jbe 0x2b0426
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b5a0
movq -0x18(%rbp), %rdi
addq %rax, %rdi
addq $-0x4, %rdi
leaq 0x86637(%rip), %rsi # 0x336a33
callq 0x1bbf0
cmpl $0x0, %eax
jne 0x2b0426
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b5a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x4, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
/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) {
// this means that there is no such variable
return false;
}
if (value) {
auto t = QUtil::make_shared_array<char>(len + 1);
::GetEnvironmentVariable(var.c_str(), t.get(), len);
*value = t.get();
}
return true;
# endif
#else
char* p = getenv(var.c_str());
if (p == nullptr) {
return false;
}
if (value) {
*value = p;
}
return true;
#endif
}
|
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(%rbp), %rdi
callq 0x1b5c0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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),
static_cast<int>(ltime.wHour),
static_cast<int>(ltime.wMinute),
static_cast<int>(ltime.wSecond),
// tzinfo.Bias is minutes before UTC
static_cast<int>(tzinfo.Bias));
#else
struct tm ltime;
time_t now = time(nullptr);
tzset();
# ifdef HAVE_LOCALTIME_R
localtime_r(&now, <ime);
# else
ltime = *localtime(&now);
# endif
# if HAVE_TM_GMTOFF
// tm_gmtoff is seconds after UTC
int tzoff = -static_cast<int>(ltime.tm_gmtoff / 60);
# elif HAVE_EXTERN_LONG_TIMEZONE
// timezone is seconds before UTC, not adjusted for daylight saving time
int tzoff = static_cast<int>(timezone / 60);
# else
// Don't know how to get timezone on this platform
int tzoff = 0;
# endif
return {
static_cast<int>(ltime.tm_year + 1900),
static_cast<int>(ltime.tm_mon + 1),
static_cast<int>(ltime.tm_mday),
static_cast<int>(ltime.tm_hour),
static_cast<int>(ltime.tm_min),
static_cast<int>(ltime.tm_sec),
tzoff};
#endif
}
|
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 $0x3c, %ecx
cqto
idivq %rcx
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %esi
addl $0x76c, %esi # imm = 0x76C
movl -0x28(%rbp), %edx
addl $0x1, %edx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movl -0x38(%rbp), %r10d
movl -0x44(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x2b8560
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 += QUtil::int_to_string(t / 60, 2) + "'" + QUtil::int_to_string(t % 60, 2) + "'";
}
return (
"D:" + QUtil::int_to_string(qtm.year, 4) + QUtil::int_to_string(qtm.month, 2) +
QUtil::int_to_string(qtm.day, 2) + QUtil::int_to_string(qtm.hour, 2) +
QUtil::int_to_string(qtm.minute, 2) + QUtil::int_to_string(qtm.second, 2) + 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
leaq 0x60fc5(%rip), %rsi # 0x311539
leaq -0x30(%rbp), %rdi
callq 0x1b5c0
jmp 0x2b057f
jmp 0x2b0756
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0aac
cmpl $0x0, -0x34(%rbp)
jge 0x2b05b7
movl -0x34(%rbp), %eax
negl %eax
movl %eax, -0x34(%rbp)
leaq 0x7e70c(%rip), %rsi # 0x32ecb6
leaq -0x30(%rbp), %rdi
callq 0x1b200
jmp 0x2b05b5
jmp 0x2b05cb
leaq 0x628b4(%rip), %rsi # 0x312e72
leaq -0x30(%rbp), %rdi
callq 0x1b200
jmp 0x2b05c9
jmp 0x2b05cb
movslq -0x34(%rbp), %rax
movl %eax, %ecx
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
movslq %eax, %rsi
leaq -0xc8(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b05fe
leaq 0x5de29(%rip), %rdx # 0x30e42e
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b061a
movslq -0x34(%rbp), %rcx
movl %ecx, %eax
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movslq %eax, %rsi
leaq -0xe8(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b0652
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b066e
leaq 0x5ddb9(%rip), %rdx # 0x30e42e
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b0687
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1b0f0
jmp 0x2b0696
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
leaq -0xe8(%rbp), %rdi
callq 0x1c1e8
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
leaq -0xc8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b0756
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0745
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0739
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b072d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0721
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
leaq -0xe8(%rbp), %rdi
callq 0x1c1e8
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
leaq -0xc8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b0aac
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
leaq -0x1c8(%rbp), %rdi
movl $0x4, %edx
callq 0x2ae510
jmp 0x2b0770
leaq 0x862c1(%rip), %rsi # 0x336a38
leaq -0x1a8(%rbp), %rdi
leaq -0x1c8(%rbp), %rdx
callq 0x1ea00
jmp 0x2b078c
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rsi
leaq -0x1e8(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b07a7
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
leaq -0x1e8(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b07c3
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
leaq -0x208(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b07de
leaq -0x168(%rbp), %rdi
leaq -0x188(%rbp), %rsi
leaq -0x208(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b07fa
movq -0x10(%rbp), %rax
movslq 0xc(%rax), %rsi
leaq -0x228(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b0815
leaq -0x148(%rbp), %rdi
leaq -0x168(%rbp), %rsi
leaq -0x228(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b0831
movq -0x10(%rbp), %rax
movslq 0x10(%rax), %rsi
leaq -0x248(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b084c
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rsi
leaq -0x248(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b0868
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rsi
leaq -0x268(%rbp), %rdi
movl $0x2, %edx
callq 0x2ae510
jmp 0x2b0883
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rsi
leaq -0x268(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b089f
movq -0x278(%rbp), %rdi
leaq -0x108(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x24260
jmp 0x2b08b8
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x268(%rbp), %rdi
callq 0x1c1e8
leaq -0x128(%rbp), %rdi
callq 0x1c1e8
leaq -0x248(%rbp), %rdi
callq 0x1c1e8
leaq -0x148(%rbp), %rdi
callq 0x1c1e8
leaq -0x228(%rbp), %rdi
callq 0x1c1e8
leaq -0x168(%rbp), %rdi
callq 0x1c1e8
leaq -0x208(%rbp), %rdi
callq 0x1c1e8
leaq -0x188(%rbp), %rdi
callq 0x1c1e8
leaq -0x1e8(%rbp), %rdi
callq 0x1c1e8
leaq -0x1a8(%rbp), %rdi
callq 0x1c1e8
leaq -0x1c8(%rbp), %rdi
callq 0x1c1e8
leaq -0x30(%rbp), %rdi
callq 0x1c1e8
movq -0x270(%rbp), %rax
addq $0x280, %rsp # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0aa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b0a28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x268(%rbp), %rdi
callq 0x1c1e8
leaq -0x128(%rbp), %rdi
callq 0x1c1e8
leaq -0x248(%rbp), %rdi
callq 0x1c1e8
leaq -0x148(%rbp), %rdi
callq 0x1c1e8
leaq -0x228(%rbp), %rdi
callq 0x1c1e8
leaq -0x168(%rbp), %rdi
callq 0x1c1e8
leaq -0x208(%rbp), %rdi
callq 0x1c1e8
leaq -0x188(%rbp), %rdi
callq 0x1c1e8
leaq -0x1e8(%rbp), %rdi
callq 0x1c1e8
leaq -0x1a8(%rbp), %rdi
callq 0x1c1e8
leaq -0x1c8(%rbp), %rdi
callq 0x1c1e8
leaq -0x30(%rbp), %rdi
callq 0x1c1e8
movq -0x40(%rbp), %rdi
callq 0x1b960
nop
|
/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)) {
return false;
}
int tz_delta = 0;
auto to_i = [](std::string const& s) { return QUtil::string_to_int(s.c_str()); };
if (m[8] != "") {
tz_delta = ((to_i(m[9]) * 60) + to_i(m[10]));
if (m[8] == "+") {
tz_delta = -tz_delta;
}
}
if (qtm) {
*qtm = QPDFTime(
to_i(m[1]), to_i(m[2]), to_i(m[3]), to_i(m[4]), to_i(m[5]), to_i(m[6]), tz_delta);
}
return true;
}
|
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 # 0x336a3b
movl $0x10, %edx
callq 0x64c50
jmp 0x2b1167
leaq -0x24c28e(%rip), %rdi # 0x64ee0
leaq 0x1e178b(%rip), %rsi # 0x492900
leaq 0x1e077c(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1e1798(%rip), %rdi # 0x492920
callq 0x1b840
leaq -0x48(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x64cf0
movq -0x188(%rbp), %rsi
movq -0x10(%rbp), %rdi
leaq 0x1e1751(%rip), %rdx # 0x492900
xorl %ecx, %ecx
callq 0x174620
movb %al, -0x179(%rbp)
jmp 0x2b11be
movb -0x179(%rbp), %al
testb $0x1, %al
jne 0x2b1208
jmp 0x2b11ca
movb $0x0, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x2b168d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq 0x1e1733(%rip), %rdi # 0x492920
callq 0x1b5f0
jmp 0x2b16ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b16a4
movl $0x0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x64d90
movq %rax, -0x190(%rbp)
jmp 0x2b1226
movq -0x190(%rbp), %rdi
leaq 0x7e78c(%rip), %rsi # 0x32f9c0
callq 0x2b85b0
movb %al, -0x191(%rbp)
jmp 0x2b1241
movb -0x191(%rbp), %al
testb $0x1, %al
jne 0x2b1250
jmp 0x2b1385
leaq -0x48(%rbp), %rdi
movl $0x9, %esi
callq 0x64d90
movq %rax, -0x1a0(%rbp)
jmp 0x2b1267
movq -0x1a0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b1279
leaq -0x51(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x1a4(%rbp)
jmp 0x2b128e
movl -0x1a4(%rbp), %eax
imull $0x3c, %eax, %eax
movl %eax, -0x1b4(%rbp)
leaq -0x48(%rbp), %rdi
movl $0xa, %esi
callq 0x64d90
movq %rax, -0x1b0(%rbp)
jmp 0x2b12b4
movq -0x1b0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b12c9
leaq -0x51(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x1b8(%rbp)
jmp 0x2b12e1
movl -0x1b8(%rbp), %ecx
movl -0x1b4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x50(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x64d90
movq %rax, -0x1c0(%rbp)
jmp 0x2b131e
movq -0x1c0(%rbp), %rdi
leaq 0x7d98a(%rip), %rsi # 0x32ecb6
callq 0x2b8610
movb %al, -0x1c1(%rbp)
jmp 0x2b1339
movb -0x1c1(%rbp), %al
testb $0x1, %al
jne 0x2b1345
jmp 0x2b1383
xorl %eax, %eax
subl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
jmp 0x2b1383
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1375
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b16a4
jmp 0x2b1385
cmpq $0x0, -0x18(%rbp)
je 0x2b1682
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x64d90
movq %rax, -0x1d0(%rbp)
jmp 0x2b13a7
movq -0x1d0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b13bc
leaq -0x51(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x1d4(%rbp)
jmp 0x2b13d4
leaq -0x48(%rbp), %rdi
movl $0x2, %esi
callq 0x64d90
movq %rax, -0x1e0(%rbp)
jmp 0x2b13eb
movq -0x1e0(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b1400
leaq -0x51(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x1e4(%rbp)
jmp 0x2b1418
leaq -0x48(%rbp), %rdi
movl $0x3, %esi
callq 0x64d90
movq %rax, -0x1f0(%rbp)
jmp 0x2b142f
movq -0x1f0(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b1444
leaq -0x51(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x1f4(%rbp)
jmp 0x2b145c
leaq -0x48(%rbp), %rdi
movl $0x4, %esi
callq 0x64d90
movq %rax, -0x200(%rbp)
jmp 0x2b1473
movq -0x200(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b1488
leaq -0x51(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x204(%rbp)
jmp 0x2b14a0
leaq -0x48(%rbp), %rdi
movl $0x5, %esi
callq 0x64d90
movq %rax, -0x210(%rbp)
jmp 0x2b14b7
movq -0x210(%rbp), %rsi
leaq -0x158(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b14cc
leaq -0x51(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x214(%rbp)
jmp 0x2b14e4
leaq -0x48(%rbp), %rdi
movl $0x6, %esi
callq 0x64d90
movq %rax, -0x220(%rbp)
jmp 0x2b14fb
movq -0x220(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x2b85e0
jmp 0x2b1510
leaq -0x51(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x2b16c0
movl %eax, -0x224(%rbp)
jmp 0x2b1528
movl -0x214(%rbp), %r9d
movl -0x204(%rbp), %r8d
movl -0x1f4(%rbp), %ecx
movl -0x1e4(%rbp), %edx
movl -0x1d4(%rbp), %esi
movl -0x224(%rbp), %edi
movl -0x50(%rbp), %r10d
movq %rsp, %rax
movl %r10d, 0x8(%rax)
movl %edi, (%rax)
leaq -0xb4(%rbp), %rdi
callq 0x2b8560
jmp 0x2b1569
movq -0x18(%rbp), %rax
movq -0xb4(%rbp), %rcx
movq %rcx, (%rax)
movq -0xac(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0xa4(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x9c(%rbp), %ecx
movl %ecx, 0x18(%rax)
leaq -0x178(%rbp), %rdi
callq 0x1c1e8
leaq -0x158(%rbp), %rdi
callq 0x1c1e8
leaq -0x138(%rbp), %rdi
callq 0x1c1e8
leaq -0x118(%rbp), %rdi
callq 0x1c1e8
leaq -0xf8(%rbp), %rdi
callq 0x1c1e8
leaq -0xd8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b1682
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1674
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1668
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b165c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1644
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x1c1e8
leaq -0x158(%rbp), %rdi
callq 0x1c1e8
leaq -0x138(%rbp), %rdi
callq 0x1c1e8
leaq -0x118(%rbp), %rdi
callq 0x1c1e8
leaq -0xf8(%rbp), %rdi
callq 0x1c1e8
leaq -0xd8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b16a4
movb $0x1, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x64ec0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x64ec0
movq -0x20(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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);
result = std::string(out, 2);
} else if (uval <= 0x10ffff) {
char out[4];
uval -= 0x10000;
unsigned short high = static_cast<unsigned short>(((uval & 0xffc00) >> 10) + 0xd800);
unsigned short low = static_cast<unsigned short>((uval & 0x3ff) + 0xdc00);
out[0] = static_cast<char>((high & 0xff00) >> 8);
out[1] = static_cast<char>(high & 0xff);
out[2] = static_cast<char>((low & 0xff00) >> 8);
out[3] = static_cast<char>(low & 0xff);
result = std::string(out, 4);
} else {
result = "\xff\xfd";
}
return result;
}
|
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), %rdi
leaq 0x85130(%rip), %rsi # 0x336adf
callq 0x1b5c0
jmp 0x2b19b6
jmp 0x2b1b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b1b4f
cmpq $0xffff, -0x10(%rbp) # imm = 0xFFFF
ja 0x2b1a4e
movb -0xf(%rbp), %al
movb %al, -0x26(%rbp)
movb -0x10(%rbp), %al
movb %al, -0x25(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1be40
movq -0x98(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq -0x26(%rbp), %rsi
movl $0x2, %edx
callq 0x1c100
jmp 0x2b1a0d
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1b790
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b1b27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b1b4f
cmpq $0x10ffff, -0x10(%rbp) # imm = 0x10FFFF
ja 0x2b1b0e
movq -0x10(%rbp), %rax
addq $-0x10000, %rax # imm = 0xFFFF0000
movq %rax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andl $0xffc00, %eax # imm = 0xFFC00
shrl $0xa, %eax
orl $0xd800, %eax # imm = 0xD800
movw %ax, -0x50(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x3ff, %eax # imm = 0x3FF
orl $0xdc00, %eax # imm = 0xDC00
movw %ax, -0x52(%rbp)
movb -0x4f(%rbp), %al
movb %al, -0x4d(%rbp)
movb -0x50(%rbp), %al
movb %al, -0x4c(%rbp)
movb -0x51(%rbp), %al
movb %al, -0x4b(%rbp)
movb -0x52(%rbp), %al
movb %al, -0x4a(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1be40
movq -0xa0(%rbp), %rcx
leaq -0x78(%rbp), %rdi
leaq -0x4d(%rbp), %rsi
movl $0x4, %edx
callq 0x1c100
jmp 0x2b1ad3
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1b790
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
leaq -0x79(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b1b25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b1b4f
movq -0x90(%rbp), %rdi
leaq 0x84fc3(%rip), %rsi # 0x336adf
callq 0x1b5c0
jmp 0x2b1b23
jmp 0x2b1b25
jmp 0x2b1b27
jmp 0x2b1b29
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2b1b3f
movq -0x90(%rbp), %rdi
callq 0x1c1e8
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x1c1e8
movq -0x20(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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);
char* buf_p = file_buf.get();
size_t bytes_read = 0;
size_t len = 0;
while ((len = fread(buf_p + bytes_read, 1, size - bytes_read, f)) > 0) {
bytes_read += len;
}
if (bytes_read != size) {
if (ferror(f)) {
throw std::runtime_error(
std::string("failure reading file ") + filename + " into memory: read " +
uint_to_string(bytes_read) + "; wanted " + uint_to_string(size));
} else {
throw std::runtime_error(
std::string("premature eof reading file ") + filename + " into memory: read " +
uint_to_string(bytes_read) + "; wanted " + uint_to_string(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), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1c150
jmp 0x2b1d3c
movq -0x20(%rbp), %rdi
callq 0x2af780
movq %rax, -0x290(%rbp)
jmp 0x2b1d4e
movq -0x290(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20d70
movq %rax, -0x298(%rbp)
jmp 0x2b1d6b
movq -0x298(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1c150
jmp 0x2b1d88
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2b84c0
jmp 0x2b1d9a
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x110400
leaq -0x50(%rbp), %rdi
callq 0xc6000
movq -0x10(%rbp), %rdi
callq 0x110800
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
subq %rax, %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x1b810
movq %rax, -0x2a0(%rbp)
jmp 0x2b1df9
movq -0x2a0(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jbe 0x2b1e29
movq -0x68(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x2b1dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b22e7
movq -0x60(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x2b22d5
movq -0x20(%rbp), %rdi
callq 0x1ba80
cmpl $0x0, %eax
je 0x2b2092
movb $0x1, -0x171(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x2b0(%rbp)
leaq -0x129(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
callq 0x1be40
movq -0x2a8(%rbp), %rdx
leaq 0x84b98(%rip), %rsi # 0x336a1d
leaq -0x128(%rbp), %rdi
callq 0x21b70
jmp 0x2b1e93
movq -0x8(%rbp), %rdx
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b1eac
leaq 0x84c2f(%rip), %rdx # 0x336ae2
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b1ec8
movq -0x60(%rbp), %rsi
leaq -0x150(%rbp), %rdi
xorl %edx, %edx
callq 0x2ae590
jmp 0x2b1edc
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
leaq -0x150(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b1ef8
leaq 0x84bf7(%rip), %rdx # 0x336af6
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b1f14
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x170(%rbp), %rdi
xorl %edx, %edx
callq 0x2ae590
jmp 0x2b1f2b
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x170(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b1f47
movq -0x2b0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1b430
jmp 0x2b1f5c
movq -0x2b0(%rbp), %rdi
movb $0x0, -0x171(%rbp)
movq 0x1df01f(%rip), %rsi # 0x490f90
movq 0x1defe8(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b22f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b206a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b205e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2052
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b203a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b202e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2022
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2016
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1c1e8
leaq -0x170(%rbp), %rdi
callq 0x1c1e8
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
leaq -0xc8(%rbp), %rdi
callq 0x1c1e8
leaq -0x150(%rbp), %rdi
callq 0x1c1e8
leaq -0xe8(%rbp), %rdi
callq 0x1c1e8
leaq -0x108(%rbp), %rdi
callq 0x1c1e8
leaq -0x128(%rbp), %rdi
callq 0x1c1e8
leaq -0x129(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x171(%rbp)
jne 0x2b2081
jmp 0x2b208d
movq -0x2b0(%rbp), %rdi
callq 0x1bcf0
jmp 0x2b22e7
movb $0x1, -0x281(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x2c0(%rbp)
leaq -0x239(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
callq 0x1be40
movq -0x2b8(%rbp), %rdx
leaq 0x84a35(%rip), %rsi # 0x336b00
leaq -0x238(%rbp), %rdi
callq 0x21b70
jmp 0x2b20d9
movq -0x8(%rbp), %rdx
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b20f2
leaq 0x849e9(%rip), %rdx # 0x336ae2
leaq -0x1f8(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b210e
movq -0x60(%rbp), %rsi
leaq -0x260(%rbp), %rdi
xorl %edx, %edx
callq 0x2ae590
jmp 0x2b2122
leaq -0x1d8(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b213e
leaq 0x849b1(%rip), %rdx # 0x336af6
leaq -0x1b8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b215a
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x280(%rbp), %rdi
xorl %edx, %edx
callq 0x2ae590
jmp 0x2b2171
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
leaq -0x280(%rbp), %rdx
callq 0x1e8e0
jmp 0x2b218d
movq -0x2c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1b430
jmp 0x2b21a2
movq -0x2c0(%rbp), %rdi
movb $0x0, -0x281(%rbp)
movq 0x1dedd9(%rip), %rsi # 0x490f90
movq 0x1deda2(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b22f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b22b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b22a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2298
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b228c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2274
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b2268
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b225c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1c1e8
leaq -0x280(%rbp), %rdi
callq 0x1c1e8
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
leaq -0x1d8(%rbp), %rdi
callq 0x1c1e8
leaq -0x260(%rbp), %rdi
callq 0x1c1e8
leaq -0x1f8(%rbp), %rdi
callq 0x1c1e8
leaq -0x218(%rbp), %rdi
callq 0x1c1e8
leaq -0x238(%rbp), %rdi
callq 0x1c1e8
leaq -0x239(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x281(%rbp)
jne 0x2b22c7
jmp 0x2b22d3
movq -0x2c0(%rbp), %rdi
callq 0x1bcf0
jmp 0x2b22e7
leaq -0x28(%rbp), %rdi
callq 0x12dc80
addq $0x2c0, %rsp # imm = 0x2C0
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x12dc80
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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_eol);
return lines;
}
|
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
movq %rax, -0x68(%rbp)
jmp 0x2b2da4
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x12dbb0
jmp 0x2b2dbb
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x2b2fd0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
callq 0x2b2e60
jmp 0x2b2dea
leaq -0x60(%rbp), %rdi
callq 0x2b8680
movb $0x1, -0x12(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12dc80
testb $0x1, -0x12(%rbp)
jne 0x2b2e3f
jmp 0x2b2e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2b2e4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2b8680
leaq -0x38(%rbp), %rdi
callq 0x12dc80
jmp 0x2b2e4c
movq -0x78(%rbp), %rdi
callq 0xc6200
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xc6200
movq -0x28(%rbp), %rdi
callq 0x1b960
nop
|
/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)?(z|r?\d+)(?:-(z|r?\d+))?)");
auto parse_num = [&max](std::string const& s) -> int {
if (s == "z") {
return max;
}
int num;
if (s.at(0) == 'r') {
num = max + 1 - string_to_int(s.substr(1).c_str());
} else {
num = string_to_int(s.c_str());
}
// max == 0 means we don't know the max and are just testing for valid syntax.
if ((max > 0) && ((num < 1) || (num > max))) {
throw std::runtime_error("number " + std::to_string(num) + " out of range");
}
return num;
};
auto populate = [](std::vector<int>& group, int first_num, bool is_span, int last_num) {
group.clear();
group.emplace_back(first_num);
if (is_span) {
if (first_num > last_num) {
for (auto i = first_num - 1; i >= last_num; --i) {
group.push_back(i);
}
} else {
for (auto i = first_num + 1; i <= last_num; ++i) {
group.push_back(i);
}
}
}
};
char const* p;
try {
char const* range_end = range + strlen(range);
std::vector<int> result;
std::vector<int> last_group;
// See if range ends with :even or :odd.
size_t start_idx = 0;
size_t skip = 1;
p = std::find(range, range_end, ':');
if (*p == ':') {
if (strcmp(p, ":odd") == 0) {
skip = 2;
} else if (strcmp(p, ":even") == 0) {
skip = 2;
start_idx = 1;
} else {
throw std::runtime_error("expected :even or :odd");
}
range_end = p;
}
// Divide the range into groups
p = range;
char const* group_end;
bool first = true;
while (p != range_end) {
group_end = std::find(p, range_end, ',');
std::cmatch m;
if (!std::regex_match(p, group_end, m, group_re)) {
throw std::runtime_error("invalid range syntax");
}
auto is_exclude = m[1].matched;
if (first && is_exclude) {
throw std::runtime_error("first range group may not be an exclusion");
}
first = false;
auto first_num = parse_num(m[2].str());
auto is_span = m[3].matched;
int last_num{0};
if (is_span) {
last_num = parse_num(m[3].str());
}
if (is_exclude) {
std::vector<int> work;
populate(work, first_num, is_span, last_num);
std::set<int> exclusions;
exclusions.insert(work.begin(), work.end());
work = last_group;
last_group.clear();
for (auto n: work) {
if (exclusions.count(n) == 0) {
last_group.emplace_back(n);
}
}
} else {
result.insert(result.end(), last_group.begin(), last_group.end());
populate(last_group, first_num, is_span, last_num);
}
p = group_end;
if (*p == ',') {
++p;
if (p == range_end) {
throw std::runtime_error("trailing comma");
}
}
}
result.insert(result.end(), last_group.begin(), last_group.end());
if (skip == 1) {
return result;
}
std::vector<int> filtered;
for (auto i = start_idx; i < result.size(); i += skip) {
filtered.emplace_back(result.at(i));
}
return filtered;
} catch (std::runtime_error const& e) {
std::string message;
if (p) {
message = "error at * in numeric range " +
std::string(range, QIntC::to_size(p - range)) + "*" + p + ": " + e.what();
} else {
message = "error in numeric range " + std::string(range) + ": " + e.what();
}
throw std::runtime_error(message);
}
}
|
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, %eax
je 0x2b3391
leaq 0x1df5d0(%rip), %rdi # 0x492928
leaq 0x837ca(%rip), %rsi # 0x336b29
movl $0x10, %edx
callq 0x64c50
jmp 0x2b336b
leaq -0x24e492(%rip), %rdi # 0x64ee0
leaq 0x1df5af(%rip), %rsi # 0x492928
leaq 0x1de578(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1df5bc(%rip), %rdi # 0x492948
callq 0x1b840
leaq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x388(%rbp)
callq 0x1b5a0
movq %rax, %rcx
movq -0x388(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1107b0
leaq -0x78(%rbp), %rdi
callq 0x1107b0
movq $0x0, -0x80(%rbp)
movq $0x1, -0x88(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movb $0x3a, -0x89(%rbp)
leaq -0x89(%rbp), %rdx
callq 0x2b8770
movq %rax, -0x380(%rbp)
jmp 0x2b3403
movq -0x380(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x2b3506
movq -0x40(%rbp), %rdi
leaq 0x83735(%rip), %rsi # 0x336b5e
callq 0x1bbf0
cmpl $0x0, %eax
jne 0x2b3471
movq $0x2, -0x88(%rbp)
jmp 0x2b34fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq 0x1df4f2(%rip), %rdi # 0x492948
callq 0x1b5f0
jmp 0x2b40e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3cbe
movq -0x40(%rbp), %rdi
leaq 0x836ca(%rip), %rsi # 0x336b46
callq 0x1bbf0
cmpl $0x0, %eax
jne 0x2b349b
movq $0x2, -0x88(%rbp)
movq $0x1, -0x80(%rbp)
jmp 0x2b34fc
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x390(%rbp)
leaq 0x83693(%rip), %rsi # 0x336b4c
callq 0x1b400
jmp 0x2b34c0
movq -0x390(%rbp), %rdi
movq 0x1ddac2(%rip), %rsi # 0x490f90
movq 0x1dda8b(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b40f1
movq -0x390(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x2b3cbe
jmp 0x2b34fe
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x1, -0x99(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x2b3b1a
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movb $0x2c, -0x9a(%rbp)
leaq -0x9a(%rbp), %rdx
callq 0x2b8770
movq %rax, -0x398(%rbp)
jmp 0x2b3547
movq -0x398(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2b87c0
jmp 0x2b3563
movq -0x40(%rbp), %rdi
movq -0x98(%rbp), %rsi
leaq 0x1df3b3(%rip), %rcx # 0x492928
leaq -0xc0(%rbp), %rdx
xorl %r8d, %r8d
callq 0x2b8800
movb %al, -0x399(%rbp)
jmp 0x2b358c
movb -0x399(%rbp), %al
testb $0x1, %al
jne 0x2b360a
jmp 0x2b3598
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x3a8(%rbp)
leaq 0x835ad(%rip), %rsi # 0x336b63
callq 0x1b400
jmp 0x2b35bd
movq -0x3a8(%rbp), %rdi
movq 0x1dd9c5(%rip), %rsi # 0x490f90
movq 0x1dd98e(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b40f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3b09
movq -0x3a8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x2b3b09
leaq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x2b8840
movq %rax, -0x3b0(%rbp)
jmp 0x2b3624
movq -0x3b0(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, -0xc1(%rbp)
testb $0x1, -0x99(%rbp)
je 0x2b36a9
testb $0x1, -0xc1(%rbp)
je 0x2b36a9
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x3b8(%rbp)
leaq 0x83512(%rip), %rsi # 0x336b78
callq 0x1b400
jmp 0x2b366d
movq -0x3b8(%rbp), %rdi
movq 0x1dd915(%rip), %rsi # 0x490f90
movq 0x1dd8de(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b40f1
movq -0x3b8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x2b3b09
movb $0x0, -0x99(%rbp)
leaq -0xc0(%rbp), %rdi
movl $0x2, %esi
callq 0x2b8840
movq %rax, -0x3c0(%rbp)
jmp 0x2b36ca
movq -0x3c0(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x2b88b0
jmp 0x2b36df
leaq -0x30(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x2b4100
movl %eax, -0x3c4(%rbp)
jmp 0x2b36f7
leaq -0xe8(%rbp), %rdi
callq 0x1c1e8
movl -0x3c4(%rbp), %eax
movl %eax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
movl $0x3, %esi
callq 0x2b8840
movq %rax, -0x3d0(%rbp)
jmp 0x2b3729
movq -0x3d0(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movb %al, -0xe9(%rbp)
movl $0x0, -0xf0(%rbp)
testb $0x1, -0xe9(%rbp)
je 0x2b37ed
leaq -0xc0(%rbp), %rdi
movl $0x3, %esi
callq 0x2b8840
movq %rax, -0x3d8(%rbp)
jmp 0x2b376c
movq -0x3d8(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x2b88b0
jmp 0x2b3781
leaq -0x30(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x2b4100
movl %eax, -0x3dc(%rbp)
jmp 0x2b3799
movl -0x3dc(%rbp), %eax
movl %eax, -0xf0(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b37ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b3b09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b3b09
testb $0x1, -0xc1(%rbp)
je 0x2b39b7
leaq -0x128(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
callq 0x1107b0
movq -0x3e8(%rbp), %rsi
movl -0xc8(%rbp), %edx
movl -0xf0(%rbp), %r8d
movzbl -0xe9(%rbp), %ecx
andl $0x1, %ecx
leaq -0x31(%rbp), %rdi
callq 0x2b4350
jmp 0x2b3836
leaq -0x158(%rbp), %rdi
movq %rdi, -0x3f0(%rbp)
callq 0x632d0
leaq -0x128(%rbp), %rdi
movq %rdi, -0x3f8(%rbp)
callq 0x111d70
movq -0x3f8(%rbp), %rdi
movq %rax, -0x160(%rbp)
callq 0x111da0
movq -0x3f0(%rbp), %rdi
movq %rax, -0x168(%rbp)
movq -0x160(%rbp), %rsi
movq -0x168(%rbp), %rdx
callq 0x2b8970
jmp 0x2b3892
leaq -0x128(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x12ab80
jmp 0x2b38a4
leaq -0x78(%rbp), %rdi
callq 0x2b89b0
leaq -0x128(%rbp), %rax
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rdi
callq 0x111d70
movq %rax, -0x178(%rbp)
movq -0x170(%rbp), %rdi
callq 0x111da0
movq %rax, -0x180(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x111dd0
testb $0x1, %al
jne 0x2b38fd
jmp 0x2b3989
leaq -0x178(%rbp), %rdi
callq 0x111e10
movl (%rax), %eax
movl %eax, -0x184(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x184(%rbp), %rsi
callq 0x1132a0
movq %rax, -0x400(%rbp)
jmp 0x2b392d
movq -0x400(%rbp), %rax
cmpq $0x0, %rax
jne 0x2b3976
leaq -0x78(%rbp), %rdi
leaq -0x184(%rbp), %rsi
callq 0x2b89d0
jmp 0x2b394c
jmp 0x2b3976
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b39a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x6fb70
jmp 0x2b39a6
jmp 0x2b3978
leaq -0x178(%rbp), %rdi
callq 0x112090
jmp 0x2b38e1
leaq -0x158(%rbp), %rdi
callq 0x6fb70
leaq -0x128(%rbp), %rdi
callq 0x70a30
jmp 0x2b3a6b
leaq -0x128(%rbp), %rdi
callq 0x70a30
jmp 0x2b3b09
leaq -0x60(%rbp), %rdi
movq %rdi, -0x410(%rbp)
callq 0x111da0
movq %rax, -0x198(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2b8b00
leaq -0x78(%rbp), %rdi
movq %rdi, -0x418(%rbp)
callq 0x111d70
movq -0x418(%rbp), %rdi
movq %rax, -0x1a0(%rbp)
callq 0x111da0
movq -0x410(%rbp), %rdi
movq %rax, -0x1a8(%rbp)
movq -0x190(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
movq -0x1a8(%rbp), %rcx
callq 0x2b8a50
movq %rax, -0x408(%rbp)
jmp 0x2b3a35
movq -0x408(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movl -0xc8(%rbp), %edx
movl -0xf0(%rbp), %r8d
movzbl -0xe9(%rbp), %ecx
andl $0x1, %ecx
leaq -0x31(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b4350
jmp 0x2b3a69
jmp 0x2b3a6b
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x2b3af8
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x2b3af6
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x420(%rbp)
leaq 0x7423c(%rip), %rsi # 0x327cf2
callq 0x1b400
jmp 0x2b3abd
movq -0x420(%rbp), %rdi
movq 0x1dd4c5(%rip), %rsi # 0x490f90
movq 0x1dd48e(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b40f1
movq -0x420(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
jmp 0x2b3b09
jmp 0x2b3af8
leaq -0xc0(%rbp), %rdi
callq 0x2b8b40
jmp 0x2b3515
leaq -0xc0(%rbp), %rdi
callq 0x2b8b40
jmp 0x2b3cbe
leaq -0x60(%rbp), %rdi
movq %rdi, -0x430(%rbp)
callq 0x111da0
movq %rax, -0x1c0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x2b8b00
leaq -0x78(%rbp), %rdi
movq %rdi, -0x438(%rbp)
callq 0x111d70
movq -0x438(%rbp), %rdi
movq %rax, -0x1c8(%rbp)
callq 0x111da0
movq -0x430(%rbp), %rdi
movq %rax, -0x1d0(%rbp)
movq -0x1b8(%rbp), %rsi
movq -0x1c8(%rbp), %rdx
movq -0x1d0(%rbp), %rcx
callq 0x2b8a50
movq %rax, -0x428(%rbp)
jmp 0x2b3b98
movq -0x428(%rbp), %rax
movq %rax, -0x1d8(%rbp)
cmpq $0x1, -0x88(%rbp)
jne 0x2b3bcf
movq -0x378(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x128c40
movl $0x1, -0x1dc(%rbp)
jmp 0x2b3c9c
movq -0x378(%rbp), %rdi
movb $0x0, -0x1dd(%rbp)
callq 0x1107b0
movq -0x80(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rax
movq %rax, -0x440(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x112190
movq %rax, %rcx
movq -0x440(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b3c74
movq -0x1e8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x113100
movq %rax, -0x448(%rbp)
jmp 0x2b3c2c
movq -0x448(%rbp), %rsi
movq -0x378(%rbp), %rdi
callq 0x2b89d0
jmp 0x2b3c41
jmp 0x2b3c43
movq -0x88(%rbp), %rax
addq -0x1e8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
jmp 0x2b3bed
movq -0x378(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x70a30
jmp 0x2b3cbe
movb $0x1, -0x1dd(%rbp)
movl $0x1, -0x1dc(%rbp)
testb $0x1, -0x1dd(%rbp)
jne 0x2b3c9a
movq -0x378(%rbp), %rdi
callq 0x70a30
jmp 0x2b3c9c
leaq -0x78(%rbp), %rdi
callq 0x70a30
leaq -0x60(%rbp), %rdi
callq 0x70a30
movq -0x370(%rbp), %rax
addq $0x480, %rsp # imm = 0x480
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x70a30
leaq -0x60(%rbp), %rdi
callq 0x70a30
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2b40e0
movq -0x20(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x1f0(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x1b510
cmpq $0x0, -0x40(%rbp)
je 0x2b3f1f
movq -0x10(%rbp), %rcx
movq %rcx, -0x458(%rbp)
movq -0x40(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x2d8(%rbp)
leaq -0x2d8(%rbp), %rdi
callq 0x25250
movq %rax, -0x450(%rbp)
jmp 0x2b3d35
leaq -0x2d9(%rbp), %rdi
movq %rdi, -0x460(%rbp)
callq 0x1be40
movq -0x458(%rbp), %rsi
movq -0x450(%rbp), %rdx
movq -0x460(%rbp), %rcx
leaq -0x2d0(%rbp), %rdi
callq 0x1c100
jmp 0x2b3d6b
leaq 0x82e30(%rip), %rsi # 0x336ba2
leaq -0x2b0(%rbp), %rdi
leaq -0x2d0(%rbp), %rdx
callq 0x1ea00
jmp 0x2b3d87
leaq 0x82e31(%rip), %rdx # 0x336bbf
leaq -0x290(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3da3
movq -0x40(%rbp), %rdx
leaq -0x270(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3dbc
leaq 0x7eb81(%rip), %rdx # 0x332944
leaq -0x250(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3dd8
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq -0x230(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3e00
leaq -0x210(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x1b790
leaq -0x230(%rbp), %rdi
callq 0x1c1e8
leaq -0x250(%rbp), %rdi
callq 0x1c1e8
leaq -0x270(%rbp), %rdi
callq 0x1c1e8
leaq -0x290(%rbp), %rdi
callq 0x1c1e8
leaq -0x2b0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2d0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2d9(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b4072
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b40cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3f0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3f02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3ef6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3eea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b3ede
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x1c1e8
leaq -0x270(%rbp), %rdi
callq 0x1c1e8
leaq -0x290(%rbp), %rdi
callq 0x1c1e8
leaq -0x2b0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2d0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2d9(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b40cb
movq -0x10(%rbp), %rax
movq %rax, -0x470(%rbp)
leaq -0x361(%rbp), %rdi
movq %rdi, -0x468(%rbp)
callq 0x1be40
movq -0x470(%rbp), %rsi
movq -0x468(%rbp), %rdx
leaq -0x360(%rbp), %rdi
callq 0x21b70
jmp 0x2b3f59
leaq 0x82c61(%rip), %rsi # 0x336bc1
leaq -0x340(%rbp), %rdi
leaq -0x360(%rbp), %rdx
callq 0x1ea00
jmp 0x2b3f75
leaq 0x7e9c8(%rip), %rdx # 0x332944
leaq -0x320(%rbp), %rdi
leaq -0x340(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3f91
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rdx
leaq -0x300(%rbp), %rdi
leaq -0x320(%rbp), %rsi
callq 0x1e9b0
jmp 0x2b3fb9
leaq -0x210(%rbp), %rdi
leaq -0x300(%rbp), %rsi
callq 0x1b790
leaq -0x300(%rbp), %rdi
callq 0x1c1e8
leaq -0x320(%rbp), %rdi
callq 0x1c1e8
leaq -0x340(%rbp), %rdi
callq 0x1c1e8
leaq -0x360(%rbp), %rdi
callq 0x1c1e8
leaq -0x361(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b4072
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b4064
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b4058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2b404c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x320(%rbp), %rdi
callq 0x1c1e8
leaq -0x340(%rbp), %rdi
callq 0x1c1e8
leaq -0x360(%rbp), %rdi
callq 0x1c1e8
leaq -0x361(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b40cb
movl $0x10, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x478(%rbp)
leaq -0x210(%rbp), %rsi
callq 0x1b430
jmp 0x2b4097
movq -0x478(%rbp), %rdi
movq 0x1dceeb(%rip), %rsi # 0x490f90
movq 0x1dceb4(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2b40f1
movq -0x478(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bcf0
leaq -0x210(%rbp), %rdi
callq 0x1c1e8
callq 0x1bab0
jmp 0x2b40de
jmp 0x2b40e0
movq -0x20(%rbp), %rdi
callq 0x1b960
movq %rax, %rdi
callq 0x1e220
nopw %cs:(%rax,%rax)
|
/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 avoid having the result start with something that will be interpreted as
// UTF-16 or UTF-8, meaning we can't end up with a string that starts with "fe ff",
// (UTF-16-BE) "ff fe" (UTF-16-LE, not officially part of the PDF spec, but recognized by
// most readers including qpdf), or "ef bb bf" (UTF-8). It's more efficient to check the
// input string to see if it will map to one of those sequences than to check the output
// string since all cases start with the same starting character.
if ((len >= 4) && (utf8_val[0] == '\xc3')) {
static std::string fe_ff("\xbe\xc3\xbf");
static std::string ff_fe("\xbf\xc3\xbe");
static std::string ef_bb_bf("\xaf\xc2\xbb\xc2\xbf");
// C++-20 has starts_with, but when this was written, qpdf had a minimum supported
// version of C++-17.
if ((utf8_val.compare(1, 3, fe_ff) == 0) || (utf8_val.compare(1, 3, ff_fe) == 0) ||
(utf8_val.compare(1, 5, ef_bb_bf) == 0)) {
result += unknown;
okay = false;
}
}
break;
default:
break;
}
size_t pos = 0;
while (pos < len) {
bool error = false;
unsigned long codepoint = QUtil::get_next_utf8_codepoint(utf8_val, pos, error);
if (error) {
okay = false;
if (encoding == e_utf16) {
result += "\xff\xfd";
} else {
result.append(1, unknown);
}
} else if (codepoint < 128) {
char ch = static_cast<char>(codepoint);
if (encoding == e_utf16) {
result += QUtil::toUTF16(QIntC::to_ulong(ch));
} else if ((encoding == e_pdfdoc) && (((ch >= 0x18) && (ch <= 0x1f)) || (ch == 127))) {
// PDFDocEncoding maps some low characters to Unicode, so if we encounter those
// invalid UTF-8 code points, map them to unknown so reversing the mapping doesn't
// change them into other characters.
okay = false;
result.append(1, unknown);
} else {
result.append(1, ch);
}
} else if (encoding == e_utf16) {
result += QUtil::toUTF16(codepoint);
} else if ((codepoint == 0xad) && (encoding == e_pdfdoc)) {
// PDFDocEncoding omits 0x00ad (soft hyphen).
okay = false;
result.append(1, unknown);
} else if (
(codepoint > 160) && (codepoint < 256) &&
((encoding == e_winansi) || (encoding == e_pdfdoc))) {
result.append(1, static_cast<char>(codepoint & 0xff));
} else {
unsigned char ch = '\0';
if (encoding == e_winansi) {
ch = encode_winansi(codepoint);
} else if (encoding == e_macroman) {
ch = encode_macroman(codepoint);
} else if (encoding == e_pdfdoc) {
ch = encode_pdfdoc(codepoint);
}
if (ch == '\0') {
okay = false;
ch = static_cast<unsigned char>(unknown);
}
result.append(1, static_cast<char>(ch));
}
}
return okay;
}
|
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 %eax, %eax
je 0x2b4864
jmp 0x2b4854
movl -0xa0(%rbp), %eax
subl $0x4, %eax
je 0x2b4879
jmp 0x2b4ae8
movq -0x10(%rbp), %rdi
leaq 0x823d2(%rip), %rsi # 0x336c41
callq 0x1b200
jmp 0x2b4aea
cmpq $0x4, -0x20(%rbp)
jb 0x2b4ae6
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c060
movsbl (%rax), %eax
cmpl $-0x3d, %eax
jne 0x2b4ae6
cmpb $0x0, 0x1de134(%rip) # 0x4929d8
jne 0x2b4912
leaq 0x1de12b(%rip), %rdi # 0x4929d8
callq 0x1b530
cmpl $0x0, %eax
je 0x2b4912
leaq -0x21(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1be40
movq -0xa8(%rbp), %rdx
leaq 0x1de0e3(%rip), %rdi # 0x4929b8
leaq 0x82368(%rip), %rsi # 0x336c44
callq 0x21b70
jmp 0x2b48e3
leaq -0x21(%rbp), %rdi
callq 0x1c1d0
movq 0x1dc65d(%rip), %rdi # 0x490f50
leaq 0x1de0be(%rip), %rsi # 0x4929b8
leaq 0x1dcff7(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1de0cb(%rip), %rdi # 0x4929d8
callq 0x1b840
cmpb $0x0, 0x1de0e7(%rip) # 0x492a00
jne 0x2b4987
leaq 0x1de0de(%rip), %rdi # 0x492a00
callq 0x1b530
cmpl $0x0, %eax
je 0x2b4987
leaq -0x35(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1be40
movq -0xb0(%rbp), %rdx
leaq 0x1de096(%rip), %rdi # 0x4929e0
leaq 0x822f7(%rip), %rsi # 0x336c48
callq 0x21b70
jmp 0x2b4958
leaq -0x35(%rbp), %rdi
callq 0x1c1d0
movq 0x1dc5e8(%rip), %rdi # 0x490f50
leaq 0x1de071(%rip), %rsi # 0x4929e0
leaq 0x1dcf82(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1de07e(%rip), %rdi # 0x492a00
callq 0x1b840
cmpb $0x0, 0x1de09a(%rip) # 0x492a28
jne 0x2b49fc
leaq 0x1de091(%rip), %rdi # 0x492a28
callq 0x1b530
cmpl $0x0, %eax
je 0x2b49fc
leaq -0x36(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1be40
movq -0xb8(%rbp), %rdx
leaq 0x1de049(%rip), %rdi # 0x492a08
leaq 0x82286(%rip), %rsi # 0x336c4c
callq 0x21b70
jmp 0x2b49cd
leaq -0x36(%rbp), %rdi
callq 0x1c1d0
movq 0x1dc573(%rip), %rdi # 0x490f50
leaq 0x1de024(%rip), %rsi # 0x492a08
leaq 0x1dcf0d(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1de031(%rip), %rdi # 0x492a28
callq 0x1b840
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
leaq 0x1ddfa7(%rip), %rcx # 0x4929b8
callq 0x1bfe0
cmpl $0x0, %eax
je 0x2b4a5d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
leaq 0x1ddfb0(%rip), %rcx # 0x4929e0
callq 0x1bfe0
cmpl $0x0, %eax
je 0x2b4a5d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
leaq 0x1ddfb9(%rip), %rcx # 0x492a08
callq 0x1bfe0
cmpl $0x0, %eax
jne 0x2b4ae4
movb -0x15(%rbp), %al
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x1b9d0
movb $0x0, -0x16(%rbp)
jmp 0x2b4ae4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x1c1d0
leaq 0x1ddf4a(%rip), %rdi # 0x4929d8
callq 0x1b5f0
jmp 0x2b4d6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x1c1d0
leaq 0x1ddf4c(%rip), %rdi # 0x492a00
callq 0x1b5f0
jmp 0x2b4d6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x36(%rbp), %rdi
callq 0x1c1d0
leaq 0x1ddf4e(%rip), %rdi # 0x492a28
callq 0x1b5f0
jmp 0x2b4d6e
jmp 0x2b4ae6
jmp 0x2b4aea
jmp 0x2b4aea
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2b4d60
movb $0x0, -0x41(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x41(%rbp), %rdx
callq 0x2b43f0
movq %rax, -0x50(%rbp)
testb $0x1, -0x41(%rbp)
je 0x2b4b52
movb $0x0, -0x16(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2b4b3b
movq -0x10(%rbp), %rdi
leaq 0x81fab(%rip), %rsi # 0x336adf
callq 0x1b200
jmp 0x2b4b4d
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movsbl -0x15(%rbp), %edx
callq 0x1bb10
jmp 0x2b4d5b
cmpq $0x80, -0x50(%rbp)
jae 0x2b4c12
movq -0x50(%rbp), %rax
movb %al, -0x51(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2b4bc0
leaq -0x51(%rbp), %rdi
callq 0x2b9b50
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2b1960
movq -0xc0(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x1b0f0
jmp 0x2b4b9b
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b4c0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b4d6e
cmpl $0x4, -0x14(%rbp)
jne 0x2b4bf9
movsbl -0x51(%rbp), %eax
cmpl $0x18, %eax
jl 0x2b4bd8
movsbl -0x51(%rbp), %eax
cmpl $0x1f, %eax
jle 0x2b4be1
movsbl -0x51(%rbp), %eax
cmpl $0x7f, %eax
jne 0x2b4bf9
movb $0x0, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movsbl -0x15(%rbp), %edx
callq 0x1bb10
jmp 0x2b4c0b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movsbl -0x51(%rbp), %edx
callq 0x1bb10
jmp 0x2b4c0d
jmp 0x2b4d59
cmpl $0x0, -0x14(%rbp)
jne 0x2b4c6f
movq -0x50(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x2b1960
movq -0xc8(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x1b0f0
jmp 0x2b4c41
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b4d57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b4d6e
cmpq $0xad, -0x50(%rbp)
jne 0x2b4c9a
cmpl $0x4, -0x14(%rbp)
jne 0x2b4c9a
movb $0x0, -0x16(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movsbl -0x15(%rbp), %edx
callq 0x1bb10
jmp 0x2b4d55
cmpq $0xa0, -0x50(%rbp)
jbe 0x2b4cd7
cmpq $0x100, -0x50(%rbp) # imm = 0x100
jae 0x2b4cd7
cmpl $0x2, -0x14(%rbp)
je 0x2b4cba
cmpl $0x4, -0x14(%rbp)
jne 0x2b4cd7
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rax
andq $0xff, %rax
movl $0x1, %esi
movsbl %al, %edx
callq 0x1bb10
jmp 0x2b4d53
movb $0x0, -0x99(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x2b4cf5
movq -0x50(%rbp), %rdi
callq 0x2b6e50
movb %al, -0x99(%rbp)
jmp 0x2b4d25
cmpl $0x3, -0x14(%rbp)
jne 0x2b4d0c
movq -0x50(%rbp), %rdi
callq 0x2b6ec0
movb %al, -0x99(%rbp)
jmp 0x2b4d23
cmpl $0x4, -0x14(%rbp)
jne 0x2b4d21
movq -0x50(%rbp), %rdi
callq 0x2b6f30
movb %al, -0x99(%rbp)
jmp 0x2b4d23
jmp 0x2b4d25
movzbl -0x99(%rbp), %eax
cmpl $0x0, %eax
jne 0x2b4d3e
movb $0x0, -0x16(%rbp)
movb -0x15(%rbp), %al
movb %al, -0x99(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movsbl -0x99(%rbp), %edx
callq 0x1bb10
jmp 0x2b4d55
jmp 0x2b4d57
jmp 0x2b4d59
jmp 0x2b4d5b
jmp 0x2b4af2
movb -0x16(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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)) {
ch_short = win_ansi_to_unicode[ch - 128];
}
result += QUtil::toUTF8(ch_short);
}
return result;
}
|
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 0x2b5319
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x1baf0
movq %rax, -0x70(%rbp)
jmp 0x2b5279
movq -0x70(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
movw %ax, -0x36(%rbp)
movzbl -0x25(%rbp), %eax
cmpl $0x80, %eax
jl 0x2b52cb
movzbl -0x25(%rbp), %eax
cmpl $0xa0, %eax
jg 0x2b52cb
movzbl -0x25(%rbp), %eax
subl $0x80, %eax
movslq %eax, %rcx
leaq 0x1dcfbd(%rip), %rax # 0x492270
movw (%rax,%rcx,2), %ax
movw %ax, -0x36(%rbp)
jmp 0x2b52cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b5336
movzwl -0x36(%rbp), %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0x2b1750
jmp 0x2b52dc
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b0f0
jmp 0x2b52eb
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b5258
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b5336
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2b532c
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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_roman_to_unicode[ch - 128];
}
result += QUtil::toUTF8(ch_short);
}
return result;
}
|
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 0x2b543e
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x1baf0
movq %rax, -0x70(%rbp)
jmp 0x2b53a9
movq -0x70(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
movw %ax, -0x36(%rbp)
movzbl -0x25(%rbp), %eax
cmpl $0x80, %eax
jl 0x2b53f0
movzbl -0x25(%rbp), %eax
subl $0x80, %eax
movslq %eax, %rcx
leaq 0x1dcee8(%rip), %rax # 0x4922c0
movw (%rax,%rcx,2), %ax
movw %ax, -0x36(%rbp)
jmp 0x2b53f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b545b
movzwl -0x36(%rbp), %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0x2b1750
jmp 0x2b5401
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b0f0
jmp 0x2b5410
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b5388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b545b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2b5451
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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)) {
ch_short = pdf_doc_to_unicode[ch - 127];
} else if ((ch >= 24) && (ch <= 31)) {
ch_short = pdf_doc_low_to_unicode[ch - 24];
} else if (ch == 173) {
ch_short = 0xfffd;
}
result += QUtil::toUTF8(ch_short);
}
return result;
}
|
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 0x2b55aa
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x1baf0
movq %rax, -0x70(%rbp)
jmp 0x2b54c9
movq -0x70(%rbp), %rax
movb (%rax), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
movw %ax, -0x36(%rbp)
movzbl -0x25(%rbp), %eax
cmpl $0x7f, %eax
jl 0x2b551a
movzbl -0x25(%rbp), %eax
cmpl $0xa0, %eax
jg 0x2b551a
movzbl -0x25(%rbp), %eax
subl $0x7f, %eax
movslq %eax, %rcx
leaq 0x1dcec1(%rip), %rax # 0x4923c0
movw (%rax,%rcx,2), %ax
movw %ax, -0x36(%rbp)
jmp 0x2b555c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2b55c7
movzbl -0x25(%rbp), %eax
cmpl $0x18, %eax
jl 0x2b5547
movzbl -0x25(%rbp), %eax
cmpl $0x1f, %eax
jg 0x2b5547
movzbl -0x25(%rbp), %eax
subl $0x18, %eax
movslq %eax, %rcx
leaq 0x1dced3(%rip), %rax # 0x492410
movw (%rax,%rcx,2), %ax
movw %ax, -0x36(%rbp)
jmp 0x2b555a
movzbl -0x25(%rbp), %eax
cmpl $0xad, %eax
jne 0x2b5558
movw $0xfffd, -0x36(%rbp) # imm = 0xFFFD
jmp 0x2b555a
jmp 0x2b555c
movzwl -0x36(%rbp), %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
callq 0x2b1750
jmp 0x2b556d
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b0f0
jmp 0x2b557c
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b54a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b55c7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2b55bd
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1c1e8
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 like
// arguments are UTF-8.
std::vector<std::string> utf8_argv;
utf8_argv.reserve(QIntC::to_size(argc));
for (int i = 0; i < argc; ++i) {
std::string utf16;
for (size_t j = 0; j < std::wcslen(argv[i]); ++j) {
unsigned short codepoint = static_cast<unsigned short>(argv[i][j]);
utf16.append(1, static_cast<char>(QIntC::to_uchar(codepoint >> 8)));
utf16.append(1, static_cast<char>(QIntC::to_uchar(codepoint & 0xff)));
}
utf8_argv.emplace_back(QUtil::utf16_to_utf8(utf16));
}
std::vector<char*> new_argv;
new_argv.reserve(utf8_argv.size() + 1U);
for (auto const& arg: utf8_argv) {
new_argv.emplace_back(const_cast<char*>(arg.data()));
}
argc = QIntC::to_int(utf8_argv.size());
new_argv.emplace_back(nullptr);
return realmain(argc, new_argv.data());
}
|
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
movq -0xf0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2ba120
jmp 0x2b5d62
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2b5ece
leaq -0x60(%rbp), %rdi
callq 0x1b510
movq $0x0, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1b9c0
movq %rax, %rcx
movq -0x100(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b5e61
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x68(%rbp), %rcx
movw (%rax,%rcx,4), %ax
movw %ax, -0x6a(%rbp)
movzbl -0x69(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2ba220
movb %al, -0x101(%rbp)
jmp 0x2b5de5
movb -0x101(%rbp), %al
movsbl %al, %edx
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x1bb10
jmp 0x2b5dfe
movzbl -0x6a(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x74(%rbp), %rdi
callq 0x2ba220
movb %al, -0x102(%rbp)
jmp 0x2b5e16
movb -0x102(%rbp), %al
movsbl %al, %edx
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x1bb10
jmp 0x2b5e2f
jmp 0x2b5e31
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x2b5d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b6053
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2b5ec0
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2b4f60
jmp 0x2b5e73
leaq -0x30(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xe35b0
jmp 0x2b5e85
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x60(%rbp), %rdi
callq 0x1c1e8
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2b5d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
leaq -0x60(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b6053
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x2ba240
leaq -0x30(%rbp), %rdi
callq 0x89de0
movq -0x110(%rbp), %rdi
movq %rax, %rsi
incq %rsi
callq 0x2ba260
jmp 0x2b5efe
leaq -0x30(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x906f0
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x90570
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xda8c0
testb $0x1, %al
jne 0x2b5f48
jmp 0x2b5fb0
leaq -0xc0(%rbp), %rdi
callq 0xda900
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x1b3c0
movq %rax, -0xd8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x2ba360
jmp 0x2b5f83
jmp 0x2b5f85
leaq -0xc0(%rbp), %rdi
callq 0xda920
jmp 0x2b5f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2ba4d0
jmp 0x2b6053
leaq -0x30(%rbp), %rdi
callq 0x89de0
movq %rax, -0xe0(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xc6150
movl %eax, -0x114(%rbp)
jmp 0x2b5fd4
movl -0x114(%rbp), %eax
movl %eax, -0x8(%rbp)
movq $0x0, -0xe8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x2ba3e0
jmp 0x2b5ffd
movl -0x8(%rbp), %eax
movl %eax, -0x11c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2ba4b0
movq -0xf8(%rbp), %rdi
movl -0x11c(%rbp), %esi
movq %rax, %rdx
callq 0x2ba460
movl %eax, -0x118(%rbp)
jmp 0x2b602f
leaq -0xb0(%rbp), %rdi
callq 0x2ba4d0
leaq -0x30(%rbp), %rdi
callq 0x84050
movl -0x118(%rbp), %eax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x84050
movq -0x38(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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;
}
malloc_info(0, f);
fclose(f);
if (QUtil::get_env("QPDF_DEBUG_MEM_USAGE")) {
fprintf(stderr, "%s", buf);
}
// Warning: this code uses regular expression to extract data from an XML string. This is
// generally a bad idea, but we're going to do it anyway because QUtil.hh warns against using
// this function for other than development/testing, and if this function fails to generate
// reasonable output during performance testing, it will be noticed.
// This is my best guess at how to interpret malloc_info. Anyway it seems to provide useful
// information for detecting code changes that drastically change memory usage.
size_t result = 0;
try {
std::cregex_iterator m_begin(buf, buf + size, tag_re);
std::cregex_iterator cr_end;
std::sregex_iterator sr_end;
int in_heap = 0;
for (auto m = m_begin; m != cr_end; ++m) {
std::string tag(m->str(1));
if (tag == "heap") {
++in_heap;
} else if (tag == "/heap") {
--in_heap;
} else if (in_heap == 0) {
std::string rest = m->str(2);
std::map<std::string, std::string> attrs;
std::sregex_iterator a_begin(rest.begin(), rest.end(), attr_re);
for (auto m2 = a_begin; m2 != sr_end; ++m2) {
attrs[m2->str(1)] = m2->str(2);
}
if (tag == "total") {
if (attrs.count("size") > 0) {
result += QIntC::to_size(QUtil::string_to_ull(attrs["size"].c_str()));
}
} else if (tag == "system" && attrs["type"] == "max") {
result += QIntC::to_size(QUtil::string_to_ull(attrs["size"].c_str()));
}
}
}
} catch (...) {
// ignore -- just return 0
}
free(buf);
return result;
#else
return 0;
#endif
}
|
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 0x2b623f
leaq -0x251366(%rip), %rdi # 0x64ee0
leaq 0x1dc703(%rip), %rsi # 0x492950
leaq 0x1db6a4(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1dc710(%rip), %rdi # 0x492970
callq 0x1b840
cmpb $0x0, 0x1dc72c(%rip) # 0x492998
jne 0x2b62bf
leaq 0x1dc723(%rip), %rdi # 0x492998
callq 0x1b530
cmpl $0x0, %eax
je 0x2b62bf
leaq 0x1dc6f2(%rip), %rdi # 0x492978
leaq 0x80977(%rip), %rsi # 0x336c04
movl $0x10, %edx
callq 0x64c50
jmp 0x2b6299
leaq -0x2513c0(%rip), %rdi # 0x64ee0
leaq 0x1dc6d1(%rip), %rsi # 0x492978
leaq 0x1db64a(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1dc6de(%rip), %rdi # 0x492998
callq 0x1b840
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1ba30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2b631e
movq $0x0, -0x8(%rbp)
jmp 0x2b6c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x1dc679(%rip), %rdi # 0x492970
callq 0x1b5f0
jmp 0x2b6c8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x1dc684(%rip), %rdi # 0x492998
callq 0x1b5f0
jmp 0x2b6c8f
movq -0x30(%rbp), %rsi
xorl %edi, %edi
callq 0x1bf10
movq -0x30(%rbp), %rdi
callq 0x1b610
leaq -0x51(%rbp), %rdi
movq %rdi, -0x378(%rbp)
callq 0x1be40
movq -0x378(%rbp), %rdx
leaq 0x808c2(%rip), %rsi # 0x336c12
leaq -0x50(%rbp), %rdi
callq 0x21b70
jmp 0x2b635b
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
callq 0x2b0430
movb %al, -0x379(%rbp)
jmp 0x2b6370
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
movb -0x379(%rbp), %al
testb $0x1, %al
jne 0x2b638e
jmp 0x2b63dd
movq 0x1daba3(%rip), %rax # 0x490f38
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x80884(%rip), %rsi # 0x336c27
movb $0x0, %al
callq 0x1b310
jmp 0x2b63dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b63cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c1e8
leaq -0x51(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6c8f
movq $0x0, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rsi, %rdx
addq %rax, %rdx
leaq 0x1dc556(%rip), %rcx # 0x492950
leaq -0xa0(%rbp), %rdi
xorl %r8d, %r8d
callq 0x2b8d00
jmp 0x2b640b
leaq -0xe0(%rbp), %rdi
callq 0x2b8e10
jmp 0x2b6419
leaq -0x120(%rbp), %rdi
callq 0x2b8e50
jmp 0x2b6427
movl $0x0, -0x124(%rbp)
leaq -0x168(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2b8ea0
jmp 0x2b6446
jmp 0x2b6448
leaq -0x168(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x2b8ef0
testb $0x1, %al
jne 0x2b64be
movl $0x2, -0x16c(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x2b9670
jmp 0x2b6c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6c63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6c57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6c4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6c3f
leaq -0x168(%rbp), %rdi
callq 0x2b8f20
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
movl $0x1, %edx
callq 0x2b8f40
jmp 0x2b64e0
leaq 0x80744(%rip), %rsi # 0x336c2b
leaq -0x190(%rbp), %rdi
callq 0x315c0
movb %al, -0x37a(%rbp)
jmp 0x2b64fb
movb -0x37a(%rbp), %al
testb $0x1, %al
jne 0x2b6507
jmp 0x2b653d
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x2b6be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6c0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6bff
leaq 0x806e6(%rip), %rsi # 0x336c2a
leaq -0x190(%rbp), %rdi
callq 0x315c0
movb %al, -0x37b(%rbp)
jmp 0x2b6558
movb -0x37b(%rbp), %al
testb $0x1, %al
jne 0x2b6564
jmp 0x2b6578
movl -0x124(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x2b6bde
cmpl $0x0, -0x124(%rbp)
jne 0x2b6bdc
leaq -0x168(%rbp), %rdi
callq 0x2b8f20
movq %rax, %rsi
leaq -0x1b0(%rbp), %rdi
movl $0x2, %edx
callq 0x2b8f40
jmp 0x2b65a7
leaq -0x1e0(%rbp), %rdi
callq 0xa9be0
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x388(%rbp)
callq 0x1b6e0
movq %rax, -0x230(%rbp)
leaq -0x228(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x2b8f90
movq -0x388(%rbp), %rdi
callq 0x1b7c0
movq %rax, -0x240(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2b8f90
movq -0x228(%rbp), %rsi
movq -0x238(%rbp), %rdx
leaq 0x1dc35d(%rip), %rcx # 0x492978
leaq -0x220(%rbp), %rdi
xorl %r8d, %r8d
callq 0x2b8fd0
jmp 0x2b662c
leaq -0x280(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x2b9100
jmp 0x2b6641
jmp 0x2b6643
leaq -0x280(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x2b9150
testb $0x1, %al
jne 0x2b6697
movl $0x5, -0x16c(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x2b9430
jmp 0x2b6786
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6bc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6bb6
leaq -0x280(%rbp), %rdi
callq 0x2b9180
movq %rax, %rsi
leaq -0x2a0(%rbp), %rdi
movl $0x2, %edx
callq 0x2b91a0
jmp 0x2b66b9
leaq -0x280(%rbp), %rdi
callq 0x2b9180
movq %rax, %rsi
leaq -0x2c0(%rbp), %rdi
movl $0x1, %edx
callq 0x2b91a0
jmp 0x2b66db
leaq -0x1e0(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x219520
movq %rax, -0x390(%rbp)
jmp 0x2b66f7
movq -0x390(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x1b790
leaq -0x2c0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2a0(%rbp), %rdi
callq 0x1c1e8
leaq -0x280(%rbp), %rdi
callq 0x2b91f0
jmp 0x2b6730
jmp 0x2b6643
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6775
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2a0(%rbp), %rdi
callq 0x1c1e8
leaq -0x280(%rbp), %rdi
callq 0x2b9430
jmp 0x2b6bb6
leaq 0x804a3(%rip), %rsi # 0x336c30
leaq -0x190(%rbp), %rdi
callq 0x315c0
movb %al, -0x391(%rbp)
jmp 0x2b67a1
movb -0x391(%rbp), %al
testb $0x1, %al
jne 0x2b67b0
jmp 0x2b694b
leaq -0x2e1(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1be40
movq -0x3a0(%rbp), %rdx
leaq 0x5cf16(%rip), %rsi # 0x3136e7
leaq -0x2e0(%rbp), %rdi
callq 0x21b70
jmp 0x2b67df
leaq -0x1e0(%rbp), %rdi
leaq -0x2e0(%rbp), %rsi
callq 0xa9e10
movq %rax, -0x3a8(%rbp)
jmp 0x2b67fb
leaq -0x2e0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2e1(%rbp), %rdi
callq 0x1c1d0
movq -0x3a8(%rbp), %rax
cmpq $0x0, %rax
jbe 0x2b6946
leaq -0x311(%rbp), %rdi
movq %rdi, -0x3b0(%rbp)
callq 0x1be40
movq -0x3b0(%rbp), %rdx
leaq 0x5cea2(%rip), %rsi # 0x3136e7
leaq -0x310(%rbp), %rdi
callq 0x21b70
jmp 0x2b6853
leaq -0x1e0(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x219520
movq %rax, -0x3b8(%rbp)
jmp 0x2b686f
movq -0x3b8(%rbp), %rdi
callq 0x1b180
movq %rax, %rdi
callq 0x2af0a0
movq %rax, -0x3c0(%rbp)
jmp 0x2b688c
movq -0x3c0(%rbp), %rax
movq %rax, -0x2f0(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x297720
movq %rax, -0x3c8(%rbp)
jmp 0x2b68af
movq -0x3c8(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x310(%rbp), %rdi
callq 0x1c1e8
leaq -0x311(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b68fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x2e0(%rbp), %rdi
callq 0x1c1e8
leaq -0x2e1(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6bb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6935
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x310(%rbp), %rdi
callq 0x1c1e8
leaq -0x311(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6bb6
jmp 0x2b6b90
movb $0x0, -0x33a(%rbp)
movb $0x0, -0x33b(%rbp)
leaq 0x802d6(%rip), %rsi # 0x336c36
leaq -0x190(%rbp), %rdi
callq 0x315c0
movb %al, -0x3c9(%rbp)
jmp 0x2b6974
movb -0x3c9(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3ca(%rbp)
jne 0x2b698c
jmp 0x2b6a0e
leaq -0x339(%rbp), %rdi
movq %rdi, -0x3d8(%rbp)
callq 0x1be40
movq -0x3d8(%rbp), %rdx
movb $0x1, -0x33a(%rbp)
leaq 0x56901(%rip), %rsi # 0x30d2b5
leaq -0x338(%rbp), %rdi
callq 0x21b70
jmp 0x2b69c2
movb $0x1, -0x33b(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x338(%rbp), %rsi
callq 0x219520
movq %rax, -0x3e0(%rbp)
jmp 0x2b69e5
movq -0x3e0(%rbp), %rdi
leaq 0x8024a(%rip), %rsi # 0x336c3d
callq 0x315c0
movb %al, -0x3e1(%rbp)
jmp 0x2b6a00
movb -0x3e1(%rbp), %al
movb %al, -0x3ca(%rbp)
jmp 0x2b6a0e
movb -0x3ca(%rbp), %al
movb %al, -0x3e2(%rbp)
testb $0x1, -0x33b(%rbp)
jne 0x2b6a25
jmp 0x2b6a31
leaq -0x338(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x33a(%rbp)
jne 0x2b6a3c
jmp 0x2b6a48
leaq -0x339(%rbp), %rdi
callq 0x1c1d0
movb -0x3e2(%rbp), %al
testb $0x1, %al
jne 0x2b6a57
jmp 0x2b6b8e
leaq -0x369(%rbp), %rdi
movq %rdi, -0x3f0(%rbp)
callq 0x1be40
movq -0x3f0(%rbp), %rdx
leaq 0x5cc6f(%rip), %rsi # 0x3136e7
leaq -0x368(%rbp), %rdi
callq 0x21b70
jmp 0x2b6a86
leaq -0x1e0(%rbp), %rdi
leaq -0x368(%rbp), %rsi
callq 0x219520
movq %rax, -0x3f8(%rbp)
jmp 0x2b6aa2
movq -0x3f8(%rbp), %rdi
callq 0x1b180
movq %rax, %rdi
callq 0x2af0a0
movq %rax, -0x400(%rbp)
jmp 0x2b6abf
movq -0x400(%rbp), %rax
movq %rax, -0x348(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x297720
movq %rax, -0x408(%rbp)
jmp 0x2b6ae2
movq -0x408(%rbp), %rax
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x368(%rbp), %rdi
callq 0x1c1e8
leaq -0x369(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6b8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6b41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
testb $0x1, -0x33b(%rbp)
jne 0x2b6b33
jmp 0x2b6b3f
leaq -0x338(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b6b41
testb $0x1, -0x33a(%rbp)
jne 0x2b6b4c
jmp 0x2b6b58
leaq -0x339(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6bb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x2b6b80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x368(%rbp), %rdi
callq 0x1c1e8
leaq -0x369(%rbp), %rdi
callq 0x1c1d0
jmp 0x2b6bb6
jmp 0x2b6b90
leaq -0x220(%rbp), %rdi
callq 0x2b9430
leaq -0x1e0(%rbp), %rdi
callq 0xa9fa0
leaq -0x1b0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b6bdc
leaq -0x220(%rbp), %rdi
callq 0x2b9430
leaq -0x1e0(%rbp), %rdi
callq 0xa9fa0
leaq -0x1b0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2b6bff
jmp 0x2b6bde
jmp 0x2b6be0
leaq -0x190(%rbp), %rdi
callq 0x1c1e8
leaq -0x168(%rbp), %rdi
callq 0x2b9450
jmp 0x2b6bfa
jmp 0x2b6448
leaq -0x190(%rbp), %rdi
callq 0x1c1e8
leaq -0x168(%rbp), %rdi
callq 0x2b9670
jmp 0x2b6c3f
leaq -0x120(%rbp), %rdi
callq 0x2b9430
leaq -0xe0(%rbp), %rdi
callq 0x2b9670
leaq -0xa0(%rbp), %rdi
callq 0x2b9670
jmp 0x2b6c71
leaq -0x120(%rbp), %rdi
callq 0x2b9430
leaq -0xe0(%rbp), %rdi
callq 0x2b9670
leaq -0xa0(%rbp), %rdi
callq 0x2b9670
movq -0x10(%rbp), %rdi
callq 0x1b0a0
callq 0x1bab0
movq -0x20(%rbp), %rdi
callq 0x1b2d0
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x410, %rsp # imm = 0x410
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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 == '.') {
if (found_dot) {
// only one dot
return false;
}
found_dot = true;
} else if (util::is_digit(*p)) {
found_digit = true;
} else {
return false;
}
}
return found_digit;
}
|
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), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2b6d91
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2b6d61
testb $0x1, -0x11(%rbp)
je 0x2b6d5b
movb $0x0, -0x1(%rbp)
jmp 0x2b6d99
movb $0x1, -0x11(%rbp)
jmp 0x2b6d81
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x63ce0
testb $0x1, %al
jne 0x2b6d73
jmp 0x2b6d79
movb $0x1, -0x12(%rbp)
jmp 0x2b6d7f
movb $0x0, -0x1(%rbp)
jmp 0x2b6d99
jmp 0x2b6d81
jmp 0x2b6d83
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2b6d3a
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %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&&)
|
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) {
last.pop_back();
--len;
} else if (pos == std::string::npos) {
break;
} else {
last = last.substr(pos + 1);
break;
}
}
return last;
}
|
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) {
last.pop_back();
--len;
} else if (pos == std::string::npos) {
break;
} else {
last = last.substr(pos + 1);
break;
}
}
return last;
}
|
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, %edi
callq 0x1b580
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x7f679(%rip), %rsi # 0x336c82
callq 0x1b400
jmp 0x2b7610
movq -0x38(%rbp), %rdi
movq 0x1d9975(%rip), %rsi # 0x490f90
movq 0x1d993e(%rip), %rdx # 0x490f60
callq 0x1b920
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x1bcf0
jmp 0x2b7653
movb $0x0, -0x1(%rbp)
jmp 0x2b7648
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 ((i < 0) || (ii > std::numeric_limits<To>::max())) {
error(i);
}
return static_cast<To>(i);
}
|
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 0x2ba590
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x2ba5a0
movq -0x8(%rbp), %rax
movl (%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
/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 std::range_error(msg.str());
}
|
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(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x2ba5fe
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x52ac0(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x2ba626
movq -0x1d8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1b4d0
movq %rax, -0x1e0(%rbp)
jmp 0x2ba63e
movq -0x1e0(%rbp), %rdi
leaq 0x52aa6(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x2ba65a
movq -0x1e8(%rbp), %rdi
movl $0x4, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x2ba674
movq -0x1f0(%rbp), %rdi
leaq 0x52c83(%rip), %rsi # 0x30d305
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x2ba690
movq -0x1f8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x2ba6aa
movq -0x200(%rbp), %rdi
leaq 0x52a5d(%rip), %rsi # 0x30d115
callq 0x1b860
jmp 0x2ba6bf
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x2ba6ec
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x2ba701
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x1d68c2(%rip), %rsi # 0x490fd8
movq 0x1d67e3(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2ba79b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2ba783
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2ba76a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x2ba775
jmp 0x2ba781
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x2ba783
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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::range_error(msg.str());
}
|
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(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x2bc67f
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x50a3f(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x2bc6a7
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1b870
movq %rax, -0x1e0(%rbp)
jmp 0x2bc6c0
movq -0x1e0(%rbp), %rdi
leaq 0x50a24(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x2bc6dc
movq -0x1e8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x2bc6f6
movq -0x1f0(%rbp), %rdi
leaq 0x50c01(%rip), %rsi # 0x30d305
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x2bc712
movq -0x1f8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x2bc72c
movq -0x200(%rbp), %rdi
leaq 0x50b6e(%rip), %rsi # 0x30d2a8
callq 0x1b860
jmp 0x2bc741
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x2bc76e
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x2bc783
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x1d4840(%rip), %rsi # 0x490fd8
movq 0x1d4761(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2bc81d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bc805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bc7ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x2bc7f7
jmp 0x2bc803
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x2bc805
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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::range_error(msg.str());
}
|
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(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x2bc8df
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x507df(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x2bc907
movq -0x1d8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1b570
movq %rax, -0x1e0(%rbp)
jmp 0x2bc920
movq -0x1e0(%rbp), %rdi
leaq 0x507c4(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x2bc93c
movq -0x1e8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x2bc956
movq -0x1f0(%rbp), %rdi
leaq 0x509a1(%rip), %rsi # 0x30d305
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x2bc972
movq -0x1f8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x2bc98c
movq -0x200(%rbp), %rdi
leaq 0x5090e(%rip), %rsi # 0x30d2a8
callq 0x1b860
jmp 0x2bc9a1
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x2bc9ce
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x2bc9e3
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x1d45e0(%rip), %rsi # 0x490fd8
movq 0x1d4501(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2bca7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bca65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bca4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x2bca57
jmp 0x2bca63
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x2bca65
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 std::range_error(msg.str());
}
|
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
movq -0x1d0(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x2bd571
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x4fb4d(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x2bd599
movq -0x1d8(%rbp), %rdi
movzbl -0x1(%rbp), %esi
callq 0x1bbd0
movq %rax, -0x1e0(%rbp)
jmp 0x2bd5b2
movq -0x1e0(%rbp), %rdi
leaq 0x4fb32(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x2bd5ce
movq -0x1e8(%rbp), %rdi
movl $0x1, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x2bd5e8
movq -0x1f0(%rbp), %rdi
leaq 0x4fb05(%rip), %rsi # 0x30d0fb
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x2bd604
movq -0x1f8(%rbp), %rdi
movl $0x8, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x2bd61e
movq -0x200(%rbp), %rdi
leaq 0x4fae9(%rip), %rsi # 0x30d115
callq 0x1b860
jmp 0x2bd633
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x2bd660
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x2bd675
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x1d394e(%rip), %rsi # 0x490fd8
movq 0x1d386f(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2bd70f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bd6f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2bd6de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x2bd6e9
jmp 0x2bd6f5
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x2bd6f7
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nop
|
/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 std::range_error(msg.str());
}
|
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(%rbp), %rsi
leaq -0x188(%rbp), %rdi
callq 0x1b7a0
jmp 0x2c580e
leaq -0x188(%rbp), %rdi
callq 0x1be70
leaq 0x478b0(%rip), %rsi # 0x30d0d1
leaq -0x180(%rbp), %rdi
callq 0x1b860
movq %rax, -0x1d8(%rbp)
jmp 0x2c5836
movq -0x1d8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1b4d0
movq %rax, -0x1e0(%rbp)
jmp 0x2c584e
movq -0x1e0(%rbp), %rdi
leaq 0x47896(%rip), %rsi # 0x30d0f2
callq 0x1b860
movq %rax, -0x1e8(%rbp)
jmp 0x2c586a
movq -0x1e8(%rbp), %rdi
movl $0x4, %esi
callq 0x1bf60
movq %rax, -0x1f0(%rbp)
jmp 0x2c5884
movq -0x1f0(%rbp), %rdi
leaq 0x47a73(%rip), %rsi # 0x30d305
callq 0x1b860
movq %rax, -0x1f8(%rbp)
jmp 0x2c58a0
movq -0x1f8(%rbp), %rdi
movl $0x2, %esi
callq 0x1bf60
movq %rax, -0x200(%rbp)
jmp 0x2c58ba
movq -0x200(%rbp), %rdi
leaq 0x4784d(%rip), %rsi # 0x30d115
callq 0x1b860
jmp 0x2c58cf
movb $0x1, -0x1b9(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1c130
jmp 0x2c58fc
movq -0x208(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1c1c0
jmp 0x2c5911
movq -0x208(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
movq 0x1cb6b2(%rip), %rsi # 0x490fd8
movq 0x1cb5d3(%rip), %rdx # 0x490f00
callq 0x1b920
jmp 0x2c59ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2c5993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x2c597a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x1b9(%rbp)
jne 0x2c5985
jmp 0x2c5991
movq -0x208(%rbp), %rdi
callq 0x1bcf0
jmp 0x2c5993
leaq -0x180(%rbp), %rdi
callq 0x1bd20
movq -0x190(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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"},
{"Tf", "/Font"},
{"SCN", "/Pattern"},
{"scn", "/Pattern"},
{"BDC", "/Properties"},
{"DP", "/Properties"},
{"sh", "/Shading"},
{"Do", "/XObject"},
};
std::string op = obj.getOperatorValue();
std::string resource_type;
auto iter = op_to_rtype.find(op);
if (iter != op_to_rtype.end()) {
resource_type = iter->second;
}
if (!resource_type.empty()) {
this->names.insert(this->last_name);
this->names_by_resource_type[resource_type][this->last_name].insert(
this->last_name_offset);
}
} else if (obj.isName()) {
this->last_name = obj.getName();
this->last_name_offset = offset;
}
}
|
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, %al
jne 0x2c66dc
jmp 0x2c6bd7
movq -0x360(%rbp), %rdi
addq $0x8, %rdi
callq 0x1b450
testb $0x1, %al
jne 0x2c6bd7
cmpb $0x0, 0x1cc36d(%rip) # 0x492a68
jne 0x2c6939
leaq 0x1cc360(%rip), %rdi # 0x492a68
callq 0x1b530
cmpl $0x0, %eax
je 0x2c6939
leaq -0x2b0(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x6756b(%rip), %rsi # 0x32dc96
leaq 0x50fa0(%rip), %rdx # 0x3176d2
callq 0x2c6cc0
jmp 0x2c6739
leaq -0x270(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x705c9(%rip), %rsi # 0x336d17
leaq 0x50f7d(%rip), %rdx # 0x3176d2
callq 0x2c6cc0
jmp 0x2c675c
leaq -0x230(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x4a50c(%rip), %rsi # 0x310c7d
leaq 0x705a2(%rip), %rdx # 0x336d1a
callq 0x2c6da0
jmp 0x2c677f
leaq -0x1f0(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x4d9f7(%rip), %rsi # 0x31418b
leaq 0x4d81c(%rip), %rdx # 0x313fb7
callq 0x2c6e80
jmp 0x2c67a2
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x7056e(%rip), %rsi # 0x336d25
leaq 0x7056b(%rip), %rdx # 0x336d29
callq 0x2c6f60
jmp 0x2c67c5
leaq -0x170(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x70558(%rip), %rsi # 0x336d32
leaq 0x70548(%rip), %rdx # 0x336d29
callq 0x2c6f60
jmp 0x2c67e8
leaq -0x130(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x70539(%rip), %rsi # 0x336d36
leaq 0x70536(%rip), %rdx # 0x336d3a
callq 0x2c7040
jmp 0x2c680b
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x67482(%rip), %rsi # 0x32dca2
leaq 0x70513(%rip), %rdx # 0x336d3a
callq 0x2c6cc0
jmp 0x2c682e
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x57637(%rip), %rsi # 0x31de7a
leaq 0x704fc(%rip), %rdx # 0x336d46
callq 0x2c7120
jmp 0x2c6851
leaq -0x70(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
leaq 0x704ec(%rip), %rsi # 0x336d4f
leaq 0x52826(%rip), %rdx # 0x319090
callq 0x2c7120
jmp 0x2c6871
leaq -0x2b0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0xa, -0x28(%rbp)
leaq -0x2c6(%rbp), %rdi
movq %rdi, -0x378(%rbp)
callq 0x2390b0
movq -0x378(%rbp), %r8
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq 0x1cc18b(%rip), %rdi # 0x492a38
leaq -0x2c5(%rbp), %rcx
callq 0x2390d0
jmp 0x2c68bb
leaq -0x2c6(%rbp), %rdi
callq 0x2391a0
leaq -0x2b0(%rbp), %rax
movq %rax, -0x388(%rbp)
addq $0x280, %rax # imm = 0x280
movq %rax, -0x380(%rbp)
movq -0x380(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x390(%rbp)
callq 0xac370
movq -0x388(%rbp), %rcx
movq -0x390(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x380(%rbp)
jne 0x2c68e2
leaq -0x21c97a(%rip), %rdi # 0xa9fa0
leaq 0x1cc117(%rip), %rsi # 0x492a38
leaq 0x1cafd0(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1cc134(%rip), %rdi # 0x492a68
callq 0x1b840
movq -0x368(%rbp), %rsi
leaq -0x2e8(%rbp), %rdi
movq %rdi, -0x3a0(%rbp)
callq 0x1c14b0
leaq -0x308(%rbp), %rdi
callq 0x1b510
movq -0x3a0(%rbp), %rsi
leaq 0x1cc0cb(%rip), %rdi # 0x492a38
callq 0x2c7200
movq %rax, -0x398(%rbp)
jmp 0x2c697b
movq -0x398(%rbp), %rax
movq %rax, -0x310(%rbp)
leaq 0x1cc0a8(%rip), %rdi # 0x492a38
callq 0xb4b30
movq %rax, -0x318(%rbp)
leaq -0x310(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x111270
testb $0x1, %al
jne 0x2c69b8
jmp 0x2c6ae9
leaq -0x310(%rbp), %rdi
callq 0x2c7230
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x308(%rbp), %rdi
callq 0x1c110
jmp 0x2c69d9
jmp 0x2c6ae9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
movq -0x2b8(%rbp), %rax
leaq -0x2b0(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0x3a8(%rbp)
je 0x2c6a3b
movq -0x3a8(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x3b0(%rbp)
callq 0xac370
movq -0x3b0(%rbp), %rax
leaq -0x2b0(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x3a8(%rbp)
jne 0x2c6a0a
jmp 0x2c6aa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
leaq -0x2c6(%rbp), %rdi
callq 0x2391a0
leaq -0x2b0(%rbp), %rax
movq %rax, -0x3c0(%rbp)
addq $0x280, %rax # imm = 0x280
movq %rax, -0x3b8(%rbp)
movq -0x3b8(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x3c8(%rbp)
callq 0xac370
movq -0x3c0(%rbp), %rcx
movq -0x3c8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x3b8(%rbp)
jne 0x2c6a76
jmp 0x2c6aa9
leaq 0x1cbfb8(%rip), %rdi # 0x492a68
callq 0x1b5f0
jmp 0x2c6c39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2c0(%rbp)
movl %eax, -0x2c4(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x1c1e8
leaq -0x2e8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2c6c39
leaq -0x308(%rbp), %rdi
callq 0x1b450
testb $0x1, %al
jne 0x2c6bbd
movq -0x360(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x8, %rsi
callq 0xc5f30
movb %dl, -0x3d1(%rbp)
movq %rax, -0x3d0(%rbp)
jmp 0x2c6b23
movq -0x360(%rbp), %rdi
movb -0x3d1(%rbp), %al
movq -0x3d0(%rbp), %rcx
movq %rcx, -0x328(%rbp)
movb %al, -0x320(%rbp)
addq $0x60, %rdi
leaq -0x308(%rbp), %rsi
callq 0x1f2fd0
movq %rax, -0x3e0(%rbp)
jmp 0x2c6b5d
movq -0x3e0(%rbp), %rdi
movq -0x360(%rbp), %rsi
addq $0x8, %rsi
callq 0x2c7250
movq %rax, -0x3e8(%rbp)
jmp 0x2c6b7d
movq -0x3e8(%rbp), %rdi
movq -0x360(%rbp), %rsi
addq $0x28, %rsi
callq 0x2c7330
movb %dl, -0x3f1(%rbp)
movq %rax, -0x3f0(%rbp)
jmp 0x2c6ba3
movb -0x3f1(%rbp), %al
movq -0x3f0(%rbp), %rcx
movq %rcx, -0x338(%rbp)
movb %al, -0x330(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x1c1e8
leaq -0x2e8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2c6c30
movq -0x368(%rbp), %rdi
callq 0x1c0040
testb $0x1, %al
jne 0x2c6be9
jmp 0x2c6c2e
movq -0x368(%rbp), %rsi
leaq -0x358(%rbp), %rdi
callq 0x1c02d0
movq -0x360(%rbp), %rdi
addq $0x8, %rdi
leaq -0x358(%rbp), %rsi
callq 0x1b790
leaq -0x358(%rbp), %rdi
callq 0x1c1e8
movq -0x360(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x2c6c30
addq $0x400, %rsp # imm = 0x400
popq %rbp
retq
movq -0x2c0(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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), reinterpret_cast<BYTE*>(data))) {
throw std::runtime_error("unable to generate secure random data");
}
# else
static std::unique_ptr<QUtil::FileCloser> random_device = []() {
FILE* f = fopen("/dev/urandom", "rb");
if (f == nullptr) {
f = fopen("/dev/arandom", "rb");
}
if (f == nullptr) {
f = fopen("/dev/random", "rb");
}
if (f == nullptr) {
throw std::runtime_error("unable to find device in /dev for generating random numbers");
}
return std::make_unique<QUtil::FileCloser>(f);
}();
size_t fr = fread(data, 1, len, random_device->f);
if (fr != len) {
throw std::runtime_error(
"unable to read " + std::to_string(len) + " bytes from random number device");
}
# endif
}
|
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 0x2c8740
jmp 0x2c8593
leaq 0x2e6(%rip), %rdi # 0x2c8880
leaq 0x1ca4cf(%rip), %rsi # 0x492a70
leaq 0x1c9350(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x1ca4c4(%rip), %rdi # 0x492a78
callq 0x1b840
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq 0x1ca49a(%rip), %rdi # 0x492a70
callq 0x2c88e0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1b810
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x2c8720
movb $0x1, -0x99(%rbp)
movl $0x10, %edi
callq 0x1b580
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x1ea50
jmp 0x2c8632
leaq 0x6e72a(%rip), %rsi # 0x336d63
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x1ea00
jmp 0x2c864b
leaq 0x6e721(%rip), %rdx # 0x336d73
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1e9b0
jmp 0x2c8661
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1b430
jmp 0x2c8673
movq -0xb8(%rbp), %rdi
movb $0x0, -0x99(%rbp)
movq 0x1c8908(%rip), %rsi # 0x490f90
movq 0x1c88d1(%rip), %rdx # 0x490f60
callq 0x1b920
jmp 0x2c8732
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq 0x1ca3cc(%rip), %rdi # 0x492a78
callq 0x1b5f0
jmp 0x2c8729
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c8707
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c86fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c86f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c1e8
leaq -0x78(%rbp), %rdi
callq 0x1c1e8
leaq -0x98(%rbp), %rdi
callq 0x1c1e8
testb $0x1, -0x99(%rbp)
jne 0x2c8712
jmp 0x2c871e
movq -0xb8(%rbp), %rdi
callq 0x1bcf0
jmp 0x2c8729
addq $0xc0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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.getKey(key);
if (key == "/Predictor") {
if (value.isInteger()) {
predictor = value.getIntValueAsInt();
if (!(predictor == 1 || predictor == 2 || (predictor >= 10 && predictor <= 15))) {
return false;
}
} else {
return false;
}
} else if (key == "/Columns" || key == "/Colors" || key == "/BitsPerComponent") {
if (value.isInteger()) {
int val = value.getIntValueAsInt();
if (memory_limit && static_cast<unsigned int>(val) > memory_limit) {
QPDFLogger::defaultLogger()->warn(
"SF_FlateLzwDecode parameter exceeds PL_Flate memory limit\n");
return false;
}
if (key == "/Columns") {
columns = val;
} else if (key == "/Colors") {
colors = val;
} else if (key == "/BitsPerComponent") {
bits_per_component = val;
}
} else {
return false;
}
} else if (lzw && (key == "/EarlyChange")) {
if (value.isInteger()) {
int earlychange = value.getIntValueAsInt();
early_code_change = (earlychange == 1);
if (!(earlychange == 0 || earlychange == 1)) {
return false;
}
} else {
return false;
}
}
}
if (predictor > 1 && columns == 0) {
return false;
}
return true;
}
|
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 0x4dbb0
movq -0xc0(%rbp), %rsi
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2316c0
leaq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xc6340
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xc6370
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc63a0
testb $0x1, %al
jne 0x2c8e0b
jmp 0x2c9205
leaq -0x60(%rbp), %rdi
callq 0xc63d0
movq -0xc0(%rbp), %rsi
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x231400
jmp 0x2c8e2e
movq -0x70(%rbp), %rdi
leaq 0x6dfd8(%rip), %rsi # 0x336e11
callq 0x315c0
movb %al, -0xc9(%rbp)
jmp 0x2c8e46
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x2c8e55
jmp 0x2c8f1e
leaq -0x80(%rbp), %rdi
callq 0x1bf820
movb %al, -0xca(%rbp)
jmp 0x2c8e66
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x2c8e75
jmp 0x2c8f06
leaq -0x80(%rbp), %rdi
callq 0x1c0940
movl %eax, -0xd0(%rbp)
jmp 0x2c8e86
movq -0xb8(%rbp), %rax
movl -0xd0(%rbp), %ecx
movl %ecx, 0xc(%rax)
cmpl $0x1, 0xc(%rax)
je 0x2c8f04
movq -0xb8(%rbp), %rax
cmpl $0x2, 0xc(%rax)
je 0x2c8f04
movq -0xb8(%rbp), %rax
cmpl $0xa, 0xc(%rax)
jl 0x2c8ec3
movq -0xb8(%rbp), %rax
cmpl $0xf, 0xc(%rax)
jle 0x2c8f04
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2c9248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2c91fa
jmp 0x2c8f19
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
jmp 0x2c91cb
movq -0x70(%rbp), %rdi
leaq 0x6def3(%rip), %rsi # 0x336e1c
callq 0x315c0
movb %al, -0xd1(%rbp)
jmp 0x2c8f36
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0x2c8f8d
jmp 0x2c8f42
movq -0x70(%rbp), %rdi
leaq 0x6ded8(%rip), %rsi # 0x336e25
callq 0x315c0
movb %al, -0xd2(%rbp)
jmp 0x2c8f5a
movb -0xd2(%rbp), %al
testb $0x1, %al
jne 0x2c8f8d
jmp 0x2c8f66
movq -0x70(%rbp), %rdi
leaq 0x4e77e(%rip), %rsi # 0x3176ef
callq 0x315c0
movb %al, -0xd3(%rbp)
jmp 0x2c8f7e
movb -0xd3(%rbp), %al
testb $0x1, %al
jne 0x2c8f8d
jmp 0x2c9108
leaq -0x80(%rbp), %rdi
callq 0x1bf820
movb %al, -0xd4(%rbp)
jmp 0x2c8f9e
movb -0xd4(%rbp), %al
testb $0x1, %al
jne 0x2c8fad
jmp 0x2c90f0
leaq -0x80(%rbp), %rdi
callq 0x1c0940
movl %eax, -0xd8(%rbp)
jmp 0x2c8fbe
movl -0xd8(%rbp), %eax
movl %eax, -0x94(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2c904a
movl -0x94(%rbp), %eax
cmpq -0x20(%rbp), %rax
jbe 0x2c904a
leaq -0xa8(%rbp), %rdi
callq 0x1af6e0
jmp 0x2c8feb
leaq -0xa8(%rbp), %rdi
callq 0x63af0
movq %rax, %rdi
leaq 0x6de2c(%rip), %rsi # 0x336e2d
callq 0x1af9a0
jmp 0x2c9008
leaq -0xa8(%rbp), %rdi
callq 0x4f0d0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2c91fa
movq -0x70(%rbp), %rdi
leaq 0x6ddc7(%rip), %rsi # 0x336e1c
callq 0x315c0
movb %al, -0xd9(%rbp)
jmp 0x2c9062
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x2c906e
jmp 0x2c9080
movq -0xb8(%rbp), %rax
movl -0x94(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x2c90ee
movq -0x70(%rbp), %rdi
leaq 0x6dd9a(%rip), %rsi # 0x336e25
callq 0x315c0
movb %al, -0xda(%rbp)
jmp 0x2c9098
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x2c90a4
jmp 0x2c90b6
movq -0xb8(%rbp), %rax
movl -0x94(%rbp), %ecx
movl %ecx, 0x14(%rax)
jmp 0x2c90ec
movq -0x70(%rbp), %rdi
leaq 0x4e62e(%rip), %rsi # 0x3176ef
callq 0x315c0
movb %al, -0xdb(%rbp)
jmp 0x2c90ce
movb -0xdb(%rbp), %al
testb $0x1, %al
jne 0x2c90da
jmp 0x2c90ea
movq -0xb8(%rbp), %rax
movl -0x94(%rbp), %ecx
movl %ecx, 0x18(%rax)
jmp 0x2c90ec
jmp 0x2c90ee
jmp 0x2c9103
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
jmp 0x2c91c9
movq -0xb8(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x2c91c7
movq -0x70(%rbp), %rdi
leaq 0x6dd44(%rip), %rsi # 0x336e68
callq 0x315c0
movb %al, -0xdc(%rbp)
jmp 0x2c9131
movb -0xdc(%rbp), %al
testb $0x1, %al
jne 0x2c9140
jmp 0x2c91c7
leaq -0x80(%rbp), %rdi
callq 0x1bf820
movb %al, -0xdd(%rbp)
jmp 0x2c9151
movb -0xdd(%rbp), %al
testb $0x1, %al
jne 0x2c915d
jmp 0x2c91b5
leaq -0x80(%rbp), %rdi
callq 0x1c0940
movl %eax, -0xe4(%rbp)
jmp 0x2c916e
movq -0xb8(%rbp), %rax
movl -0xe4(%rbp), %ecx
movl %ecx, -0xac(%rbp)
cmpl $0x1, -0xac(%rbp)
sete %cl
andb $0x1, %cl
movb %cl, 0x1c(%rax)
cmpl $0x0, -0xac(%rbp)
je 0x2c91b3
cmpl $0x1, -0xac(%rbp)
je 0x2c91b3
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
jmp 0x2c91c5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c91d5
jmp 0x2c91c7
jmp 0x2c91c9
jmp 0x2c91cb
movl $0x0, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x23380
movl -0x90(%rbp), %eax
testl %eax, %eax
jne 0x2c923d
jmp 0x2c91ea
jmp 0x2c91ec
leaq -0x60(%rbp), %rdi
callq 0xc63f0
jmp 0x2c8df5
leaq -0x80(%rbp), %rdi
callq 0x23380
jmp 0x2c9248
movq -0xb8(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jle 0x2c922f
movq -0xb8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x2c922f
movb $0x0, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x2c923d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xab620
jmp 0x2c9253
leaq -0x50(%rbp), %rdi
callq 0xab620
jmp 0x2c9261
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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, 0x8(%rdi)
movl $0x1, 0xc(%rdi)
movl $0x1, 0x10(%rdi)
movl $0x1, 0x14(%rdi)
movl $0x8, 0x18(%rdi)
movb $0x1, 0x1c(%rdi)
addq $0x20, %rdi
callq 0x239c80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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 handle error: " << (*qpdf)->error->what() << "\n";
}
delete *qpdf;
*qpdf = nullptr;
}
|
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
je 0x2ccc56
leaq 0x653ba(%rip), %rdi # 0x331f38
leaq 0x6c16e(%rip), %rsi # 0x338cf3
xorl %edx, %edx
movl %edx, -0x38(%rbp)
callq 0x25230
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1af6e0
movq -0x40(%rbp), %rdi
callq 0x63af0
movl -0x38(%rbp), %edx
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x1afa10
jmp 0x2ccbb6
leaq -0x18(%rbp), %rdi
callq 0x63db0
movq %rax, %rdi
leaq 0x6c156(%rip), %rsi # 0x338d1f
callq 0x46650
movq %rax, -0x48(%rbp)
jmp 0x2ccbd4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x50(%rbp)
jmp 0x2ccc02
movq -0x50(%rbp), %rdi
leaq 0x62db2(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2ccc14
leaq -0x18(%rbp), %rdi
callq 0x63e20
leaq -0x28(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ccc56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ccc4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x63e20
leaq -0x28(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ccc8f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x2ccc7e
movq -0x58(%rbp), %rdi
callq 0x2fa380
movq -0x58(%rbp), %rdi
movl $0x148, %esi # imm = 0x148
callq 0x1b190
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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.empty()) {
return QPDF_FALSE;
} else {
return QPDF_TRUE;
}
}
|
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 %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x5d4f0
leaq -0x28(%rbp), %rdi
callq 0x63c80
testb $0x1, %al
jne 0x2ccdaf
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x73d70
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x73bf0
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2fa460
jmp 0x2ccd96
jmp 0x2ccdaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x63c20
jmp 0x2ccde4
leaq -0x28(%rbp), %rdi
callq 0x63c20
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x2fa420
testb $0x1, %al
jne 0x2ccdcb
jmp 0x2ccdd4
movl $0x0, -0x4(%rbp)
jmp 0x2ccddb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x2fa4f0
leaq -0x20(%rbp), %rdi
callq 0x2fa520
leaq 0x65096(%rip), %rdi # 0x331f38
leaq 0x6bee0(%rip), %rsi # 0x338d89
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ccec6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
/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 {
return nullptr;
}
}
|
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
leaq -0x20(%rbp), %rdi
callq 0x2fa520
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x2fa5e0
leaq 0x65007(%rip), %rdi # 0x331f38
leaq 0x6be76(%rip), %rsi # 0x338dae
xorl %edx, %edx
callq 0x25230
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ccf55
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
|
/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->error = std::make_shared<QPDFExc>(qpdf_e_system, "", "", 0, e.what());
status |= QPDF_ERRORS;
} catch (std::exception& e) {
qpdf->error = std::make_shared<QPDFExc>(qpdf_e_internal, "", "", 0, e.what());
status |= QPDF_ERRORS;
}
if (qpdf_more_warnings(qpdf)) {
status |= QPDF_WARNINGS;
}
return status;
}
|
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 -0x24(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x2cd233
movq -0x20(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x2fa540
jmp 0x2cd1e5
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x90(%rbp), %rsi
callq 0x2fa4f0
leaq -0x90(%rbp), %rdi
callq 0x2fa520
movl -0x14(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x14(%rbp)
callq 0x1bab0
movq -0x8(%rbp), %rdi
callq 0x2ccd00
cmpl $0x0, %eax
je 0x2cd388
movl -0x14(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2cd388
movl -0x9c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x2cd2bc
movq -0x20(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x58(%rbp)
movl $0x2, -0x6c(%rbp)
movl $0x0, -0x70(%rbp)
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
leaq 0x6274b(%rip), %rcx # 0x32f9c0
leaq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
leaq -0x70(%rbp), %r8
leaq -0x78(%rbp), %r9
movq %rcx, %rdx
callq 0x2fb6c0
jmp 0x2cd28f
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x68(%rbp), %rsi
callq 0x2fa4f0
leaq -0x68(%rbp), %rdi
callq 0x2fa520
movl -0x14(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x14(%rbp)
callq 0x1bab0
jmp 0x2cd213
movl -0x9c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2cd394
movq -0x20(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x30(%rbp)
movl $0x1, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
leaq 0x626be(%rip), %rcx # 0x32f9c0
leaq -0x40(%rbp), %rdi
leaq -0x44(%rbp), %rsi
leaq -0x48(%rbp), %r8
leaq -0x50(%rbp), %r9
movq %rcx, %rdx
callq 0x2fb6c0
jmp 0x2cd31c
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fa4f0
leaq -0x40(%rbp), %rdi
callq 0x2fa520
movl -0x14(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x14(%rbp)
callq 0x1bab0
jmp 0x2cd213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bab0
jmp 0x2cd35c
jmp 0x2cd394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bab0
jmp 0x2cd371
jmp 0x2cd394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bab0
jmp 0x2cd386
jmp 0x2cd394
movl -0x14(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1b960
movq %rax, %rdi
callq 0x1e220
nopw %cs:(%rax,%rax)
|
/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;
status = trap_errors(qpdf, &call_read_memory);
QTC::TC("qpdf", "qpdf-c called qpdf_read_memory", status);
return status;
}
|
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 -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x82(%rip), %rax # 0x2cd890
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x2fa610
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x68(%rbp)
jmp 0x2cd835
movl -0x68(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
movl -0x2c(%rbp), %edx
leaq 0x646ea(%rip), %rdi # 0x331f38
leaq 0x6b634(%rip), %rsi # 0x338e89
callq 0x25230
movl -0x2c(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
movq -0x60(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 = QPDFObjectHandle::newString(value);
} else {
QTC::TC("qpdf", "qpdf-c set_info_key to null");
value_object = QPDFObjectHandle::newNull();
}
QPDFObjectHandle trailer = qpdf->qpdf->getTrailer();
if (!trailer.hasKey("/Info")) {
QTC::TC("qpdf", "qpdf-c add info to trailer");
trailer.replaceKey(
"/Info", qpdf->qpdf->makeIndirectObject(QPDFObjectHandle::newDictionary()));
} else {
QTC::TC("qpdf", "qpdf-c set-info-key use existing info");
}
QPDFObjectHandle info = trailer.getKey("/Info");
info.replaceKey(key, value_object);
}
|
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 0x2ce295
leaq -0x28(%rbp), %rdi
callq 0x42ac0
cmpq $0x0, -0x18(%rbp)
je 0x2cdf38
leaq 0x640bf(%rip), %rdi # 0x331f38
leaq 0x6b0cc(%rip), %rsi # 0x338f4c
xorl %edx, %edx
callq 0x25230
jmp 0x2cde89
movq -0x18(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x1be40
movq -0x170(%rbp), %rsi
movq -0x168(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x21b70
jmp 0x2cdebd
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1c70f0
jmp 0x2cdecc
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x42b50
leaq -0x48(%rbp), %rdi
callq 0x23380
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x69(%rbp), %rdi
callq 0x1c1d0
jmp 0x2cdf70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce31c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2cdf2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c1e8
leaq -0x69(%rbp), %rdi
callq 0x1c1d0
jmp 0x2ce31c
leaq 0x63ff9(%rip), %rdi # 0x331f38
leaq 0x6b023(%rip), %rsi # 0x338f69
xorl %edx, %edx
callq 0x25230
jmp 0x2cdf4f
leaq -0x80(%rbp), %rdi
callq 0x1c4c30
jmp 0x2cdf5a
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x42b50
leaq -0x80(%rbp), %rdi
callq 0x23380
movq -0x8(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x617b0
jmp 0x2cdf8a
leaq -0xb1(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0x1be40
movq -0x178(%rbp), %rdx
leaq 0x48e98(%rip), %rsi # 0x316e43
leaq -0xb0(%rbp), %rdi
callq 0x21b70
jmp 0x2cdfb9
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2312c0
movb %al, -0x179(%rbp)
jmp 0x2cdfd4
movb -0x179(%rbp), %al
xorb $-0x1, %al
movb %al, -0x17a(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
leaq -0xb1(%rbp), %rdi
callq 0x1c1d0
movb -0x17a(%rbp), %al
testb $0x1, %al
jne 0x2ce009
jmp 0x2ce18d
leaq 0x63f28(%rip), %rdi # 0x331f38
leaq 0x6af6e(%rip), %rsi # 0x338f85
xorl %edx, %edx
callq 0x25230
jmp 0x2ce020
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x1be40
movq -0x188(%rbp), %rdx
leaq 0x48e02(%rip), %rsi # 0x316e43
leaq -0xd8(%rbp), %rdi
callq 0x21b70
jmp 0x2ce04f
movq -0x8(%rbp), %rdi
callq 0x2fa440
movq %rax, -0x190(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1c7a80
jmp 0x2ce06d
movq -0x190(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rdx
callq 0x289570
jmp 0x2ce089
leaq -0x90(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x231990
jmp 0x2ce0a5
leaq -0xf0(%rbp), %rdi
callq 0x23380
leaq -0x100(%rbp), %rdi
callq 0x23380
leaq -0xd8(%rbp), %rdi
callq 0x1c1e8
leaq -0xd9(%rbp), %rdi
callq 0x1c1d0
jmp 0x2ce1a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
leaq -0xb1(%rbp), %rdi
callq 0x1c1d0
jmp 0x2ce310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce17c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce170
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce164
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x23380
leaq -0x100(%rbp), %rdi
callq 0x23380
leaq -0xd8(%rbp), %rdi
callq 0x1c1e8
leaq -0xd9(%rbp), %rdi
callq 0x1c1d0
jmp 0x2ce310
leaq 0x63da4(%rip), %rdi # 0x331f38
leaq 0x6ae05(%rip), %rsi # 0x338fa0
xorl %edx, %edx
callq 0x25230
jmp 0x2ce1a4
jmp 0x2ce1a6
leaq -0x131(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x1be40
movq -0x198(%rbp), %rdx
leaq 0x48c7c(%rip), %rsi # 0x316e43
leaq -0x130(%rbp), %rdi
callq 0x21b70
jmp 0x2ce1d5
leaq -0x110(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x130(%rbp), %rdx
callq 0x231400
jmp 0x2ce1f1
leaq -0x130(%rbp), %rdi
callq 0x1c1e8
leaq -0x131(%rbp), %rdi
callq 0x1c1d0
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x159(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x1be40
movq -0x1a8(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
leaq -0x158(%rbp), %rdi
callq 0x21b70
jmp 0x2ce243
leaq -0x110(%rbp), %rdi
leaq -0x158(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x231990
jmp 0x2ce25c
leaq -0x158(%rbp), %rdi
callq 0x1c1e8
leaq -0x159(%rbp), %rdi
callq 0x1c1d0
leaq -0x110(%rbp), %rdi
callq 0x23380
leaq -0x90(%rbp), %rdi
callq 0x23380
leaq -0x28(%rbp), %rdi
callq 0x23380
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce2c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c1e8
leaq -0x131(%rbp), %rdi
callq 0x1c1d0
jmp 0x2ce310
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2ce2f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x1c1e8
leaq -0x159(%rbp), %rdi
callq 0x1c1d0
leaq -0x110(%rbp), %rdi
callq 0x23380
leaq -0x90(%rbp), %rdi
callq 0x23380
leaq -0x28(%rbp), %rdi
callq 0x23380
movq -0x30(%rbp), %rdi
callq 0x1b960
nop
|
/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), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x2fa610
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x50(%rbp)
jmp 0x2ce6fb
leaq -0x38(%rbp), %rdi
callq 0x2fa6a0
movl -0x50(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
leaq 0x63824(%rip), %rdi # 0x331f38
leaq 0x6aa4a(%rip), %rsi # 0x339165
callq 0x25230
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2fa6a0
movq -0x48(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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
movq -0x50(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x48(%rbp)
jmp 0x2ce8ab
leaq -0x30(%rbp), %rdi
callq 0x2fa6a0
movl -0x48(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0x63677(%rip), %rdi # 0x331f38
leaq 0x6a8bb(%rip), %rsi # 0x339183
xorl %edx, %edx
callq 0x25230
movq -0x8(%rbp), %rax
movb $0x1, 0x98(%rax)
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fa6a0
movq -0x40(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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_other,
enum qpdf_r3_print_e print,
QPDF_BOOL encrypt_metadata)
{
QTC::TC("qpdf", "qpdf-c called qpdf_set_r6_encryption_parameters");
qpdf->qpdf_writer->setR6EncryptionParameters(
user_password,
owner_password,
allow_accessibility != QPDF_FALSE,
allow_extract != QPDF_FALSE,
allow_assemble != QPDF_FALSE,
allow_annotate_and_form != QPDF_FALSE,
allow_form_filling != QPDF_FALSE,
allow_modify_other != QPDF_FALSE,
print,
encrypt_metadata != QPDF_FALSE);
}
|
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(%rbp)
leaq 0x62cbe(%rip), %rdi # 0x331f38
leaq 0x6a21f(%rip), %rsi # 0x3394a0
xorl %edx, %edx
callq 0x25230
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x2fa6c0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
cmpl $0x0, -0x34(%rbp)
setne %cl
cmpl $0x0, -0x38(%rbp)
setne %r8b
cmpl $0x0, -0x3c(%rbp)
setne %al
cmpl $0x0, 0x10(%rbp)
setne %r10b
cmpl $0x0, 0x18(%rbp)
setne %r11b
cmpl $0x0, 0x20(%rbp)
setne %bl
movl 0x28(%rbp), %r15d
cmpl $0x0, 0x30(%rbp)
setne %r14b
movq %rsp, %r9
movl %r15d, 0x18(%r9)
movzbl %r14b, %r14d
andl $0x1, %r14d
movl %r14d, 0x20(%r9)
movzbl %bl, %ebx
andl $0x1, %ebx
movl %ebx, 0x10(%r9)
movzbl %r11b, %r11d
andl $0x1, %r11d
movl %r11d, 0x8(%r9)
movzbl %r10b, %r10d
andl $0x1, %r10d
movl %r10d, (%r9)
movzbl %cl, %ecx
andl $0x1, %ecx
movzbl %r8b, %r8d
andl $0x1, %r8d
movzbl %al, %r9d
andl $0x1, %r9d
callq 0x204e80
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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), %rsi
callq 0x2cd170
movl %eax, -0x48(%rbp)
jmp 0x2cf6d9
movl -0x48(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fa6a0
movl -0xc(%rbp), %ecx
movl $0x1, %edx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
leaq 0x62839(%rip), %rdi # 0x331f38
leaq 0x69e63(%rip), %rsi # 0x339569
callq 0x25230
movl -0xc(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fa6a0
movq -0x40(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
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), %rsi
leaq -0x88(%rbp), %rdi
callq 0x302810
jmp 0x2d1a0a
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2e24c0
jmp 0x2d1a22
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2e21f0
movl %eax, -0xb4(%rbp)
jmp 0x2d1a3e
leaq -0x60(%rbp), %rdi
callq 0x3028c0
leaq -0x88(%rbp), %rdi
callq 0x2e2560
leaq -0x40(%rbp), %rdi
callq 0x2faa50
movl -0xb4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d1aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d1aae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3028c0
leaq -0x88(%rbp), %rdi
callq 0x2e2560
leaq -0x40(%rbp), %rdi
callq 0x2faa50
movq -0x90(%rbp), %rdi
callq 0x1b960
nop
|
/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_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 0x5ddf3(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d1de0
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d1c21
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
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), %rsi
leaq -0x88(%rbp), %rdi
callq 0x302c80
jmp 0x2d1cca
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2e3b10
jmp 0x2d1ce2
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2e3830
movq %rax, -0xb8(%rbp)
jmp 0x2d1cff
leaq -0x60(%rbp), %rdi
callq 0x302d30
leaq -0x88(%rbp), %rdi
callq 0x2e3bb0
leaq -0x40(%rbp), %rdi
callq 0x2faa90
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d1d7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d1d70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x302d30
leaq -0x88(%rbp), %rdi
callq 0x2e3bb0
leaq -0x40(%rbp), %rdi
callq 0x2faa90
movq -0x90(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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");
return new_object(qpdf, qoh);
} else {
QTC::TC("qpdf", "qpdf-c non-array to wrap_in_array");
return new_object(
qpdf, QPDFObjectHandle::newArray(std::vector<QPDFObjectHandle>{qoh}));
}
});
}
|
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, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d20e0
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
callq 0x2d1f30
movl %eax, -0x70(%rbp)
jmp 0x2d1ee3
leaq -0x58(%rbp), %rdi
callq 0x2faab0
leaq -0x30(%rbp), %rdi
callq 0x2fa940
movl -0x70(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faab0
leaq -0x30(%rbp), %rdi
callq 0x2fa940
movq -0x68(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
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), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3037d0
jmp 0x2d2d5a
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2e9170
jmp 0x2d2d72
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2e8e90
movq %rax, -0xb8(%rbp)
jmp 0x2d2d8f
leaq -0x60(%rbp), %rdi
callq 0x303880
leaq -0x88(%rbp), %rdi
callq 0x2e9210
leaq -0x40(%rbp), %rdi
callq 0x2fab30
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d2e0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d2e00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x303880
leaq -0x88(%rbp), %rdi
callq 0x2e9210
leaq -0x40(%rbp), %rdi
callq 0x2fab30
movq -0x90(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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->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 0x5c663(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d3400
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d33b1
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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.getValueAsReal(qpdf->tmp_string);
if (result) {
*value = qpdf->tmp_string.c_str();
*length = qpdf->tmp_string.length();
}
return result;
});
}
|
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), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2d3580
jmp 0x2d34f5
movl -0x88(%rbp), %esi
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2d01f0
movl %eax, -0x94(%rbp)
jmp 0x2d3517
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2d3561
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
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), %rsi
leaq -0x88(%rbp), %rdi
callq 0x303c40
jmp 0x2d373a
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2ebd60
jmp 0x2d3752
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2eba80
movsd %xmm0, -0xb8(%rbp)
jmp 0x2d3770
leaq -0x60(%rbp), %rdi
callq 0x303cf0
leaq -0x88(%rbp), %rdi
callq 0x2ebe00
leaq -0x40(%rbp), %rdi
callq 0x2fab70
movsd -0xb8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d37ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d37e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x303cf0
leaq -0x88(%rbp), %rdi
callq 0x2ebe00
leaq -0x40(%rbp), %rdi
callq 0x2fab70
movq -0x90(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d3b00
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d3ab1
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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 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 0x5bc73(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d3df0
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d3da1
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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.getValueAsString(qpdf->tmp_string);
if (result) {
*value = qpdf->tmp_string.c_str();
*length = qpdf->tmp_string.length();
}
return result;
});
}
|
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), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2d3f70
jmp 0x2d3ee5
movl -0x88(%rbp), %esi
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2d01f0
movl %eax, -0x94(%rbp)
jmp 0x2d3f07
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2d3f51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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->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 0x5b983(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d40e0
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d4091
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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.getValueAsUTF8(qpdf->tmp_string);
if (result) {
*value = qpdf->tmp_string.c_str();
*length = qpdf->tmp_string.length();
}
return result;
});
}
|
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), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2d4260
jmp 0x2d41d5
movl -0x88(%rbp), %esi
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x2d01f0
movl %eax, -0x94(%rbp)
jmp 0x2d41f7
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2d4241
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21af70
leaq -0x40(%rbp), %rdi
callq 0x2faa10
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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.getUTF8Value();
*length = qpdf->tmp_string.length();
return qpdf->tmp_string.c_str();
});
}
|
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(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x2d4550
movq -0xa8(%rbp), %rdi
movl -0x9c(%rbp), %esi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x88(%rbp)
jmp 0x2d4506
leaq -0x60(%rbp), %rdi
callq 0x2faa70
leaq -0x38(%rbp), %rdi
callq 0x2faa90
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2faa70
leaq -0x38(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rdi
callq 0x1b960
nop
|
/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");
return o.getKeys();
});
qpdf->dict_iter = qpdf->cur_iter_dict_keys.begin();
}
|
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(%rbp), %rsi
callq 0x2d4bb0
movq -0xc8(%rbp), %rsi
movl -0xbc(%rbp), %edx
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp), %r8
leaq -0x40(%rbp), %rdi
callq 0x2d49e0
jmp 0x2d493a
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x40(%rbp), %rsi
callq 0xc7a70
leaq -0x40(%rbp), %rdi
callq 0xab620
leaq -0x88(%rbp), %rdi
callq 0x2fab90
leaq -0x60(%rbp), %rdi
callq 0x2fabb0
movq -0x8(%rbp), %rdi
addq $0xf0, %rdi
callq 0xc6340
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, 0x120(%rax)
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2fab90
leaq -0x60(%rbp), %rdi
callq 0x2fabb0
movq -0x98(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 0xc63d0
movq %rax, %rsi
movq -0x10(%rbp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x1c110
movq -0x10(%rbp), %rdi
addq $0x120, %rdi # imm = 0x120
callq 0xc63f0
movq -0x10(%rbp), %rdi
addq $0x128, %rdi # imm = 0x128
callq 0x1b180
movq %rax, -0x8(%rbp)
jmp 0x2d4d20
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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 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 0x58db3(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d6cb0
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d6c61
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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->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 0x58c53(%rip), %rax # 0x32f9c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2d1da0
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x2d6e10
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x2d1c70
movq %rax, -0x78(%rbp)
jmp 0x2d6dc1
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2faa70
leaq -0x30(%rbp), %rdi
callq 0x2faa90
movq -0x68(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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_item_internal(q, stream_oh);
Pipeline* p = nullptr;
Pl_Buffer buf("stream data");
if (bufp) {
p = &buf;
}
bool was_filtered = false;
if (stream.pipeStreamData(p, &was_filtered, 0, decode_level, false, false)) {
QTC::TC("qpdf", "qpdf-c stream data buf set", bufp ? 0 : 1);
if (p && bufp && len) {
buf.getMallocBuffer(bufp, len);
}
QTC::TC("qpdf", "qpdf-c stream data filtered set", filtered ? 0 : 1);
if (filtered) {
*filtered = was_filtered ? QPDF_TRUE : QPDF_FALSE;
}
} else {
throw std::runtime_error("unable to access stream data for stream " + stream.unparse());
}
});
}
|
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 -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x2d70a0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x78(%rbp)
jmp 0x2d7066
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
movl -0x78(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
movq -0x70(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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", "qpdf-c called qpdf_oh_replace_stream_data");
auto filter = qpdf_oh_item_internal(qpdf, filter_oh);
auto decode_parms = qpdf_oh_item_internal(qpdf, decode_parms_oh);
// XXX test with binary data with null
o.replaceStreamData(
std::string(reinterpret_cast<char const*>(buf), len), filter, decode_parms);
});
}
|
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 %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x2d7370
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdx
callq 0x2cff90
jmp 0x2d733f
leaq -0x48(%rbp), %rdi
callq 0x2fa960
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fa960
movq -0x70(%rbp), %rdi
callq 0x1b960
nop
|
/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 & QPDF_ERRORS) {
return -1;
}
return n;
}
|
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
leaq -0x24(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x63f40
movq -0x80(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
leaq -0x1c(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x2d78a0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x68(%rbp)
jmp 0x2d783f
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
movl -0x68(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2d7879
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d787f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
jmp 0x2d788b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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_errors(
qpdf, [&page, before, &ref](qpdf_data q) { q->qpdf->addPageAt(page, before, ref); });
}
|
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 -0x30(%rbp), %rdi
callq 0x2d7c60
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x2d7c60
jmp 0x2d7e14
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x80(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2d7ee0
jmp 0x2d7e4a
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x94(%rbp)
jmp 0x2d7e62
leaq -0x70(%rbp), %rdi
callq 0x2fa6a0
leaq -0x40(%rbp), %rdi
callq 0x23380
leaq -0x30(%rbp), %rdi
callq 0x23380
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d7ec6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d7ebd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2fa6a0
leaq -0x40(%rbp), %rdi
callq 0x23380
leaq -0x30(%rbp), %rdi
callq 0x23380
movq -0x48(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x50(%rbp)
jmp 0x2d810e
movl -0x50(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2fa6a0
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2fa6a0
movq -0x48(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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());
if (!result) {
QTC::TC("qpdf", "qpdf-c invalid object handle");
throw QPDFExc(
qpdf_e_internal,
q->qpdf->getFilename(),
std::string("C API object handle ") + std::to_string(oh),
0,
"attempted access to unknown object handle");
}
return fn(*(q->oh_cache[oh]));
});
}
|
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), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2fddb0
jmp 0x2d8f9a
movl -0xc(%rbp), %eax
movl %eax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2d9440
jmp 0x2d8fb2
movq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x2d9170
movb %al, -0xb1(%rbp)
jmp 0x2d8fce
leaq -0x60(%rbp), %rdi
callq 0x2fde60
leaq -0x88(%rbp), %rdi
callq 0x2d94e0
leaq -0x40(%rbp), %rdi
callq 0x2fdce0
movb -0xb1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d904c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x2d9040
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2fde60
leaq -0x88(%rbp), %rdi
callq 0x2d94e0
leaq -0x40(%rbp), %rdi
callq 0x2fdce0
movq -0x90(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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 -0x68(%rbp), %rdi
callq 0x2fde80
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2d9500
jmp 0x2d91ca
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2cd170
movl %eax, -0xe4(%rbp)
jmp 0x2d91e2
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
leaq -0x70(%rbp), %rdi
callq 0x2d95a0
movl -0xe4(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2d9418
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2d9405
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x58cfd(%rip), %rdi # 0x331f38
leaq 0x609eb(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2d932c
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xf8(%rbp)
movl $0x1, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5dd30
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rdx
movl $0x0, -0xa4(%rbp)
leaq 0x56714(%rip), %rcx # 0x32f9c0
leaq 0x60995(%rip), %r9 # 0x339c48
leaq -0x80(%rbp), %rsi
leaq -0xa4(%rbp), %r8
callq 0x2fdf30
jmp 0x2d92c5
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2d932c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2d9301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
leaq -0x70(%rbp), %rdi
callq 0x2d95a0
jmp 0x2d942e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2d942e
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1af6e0
movq -0x100(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xb8(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2d935e
leaq -0xb8(%rbp), %rdi
callq 0x63db0
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x108(%rbp)
jmp 0x2d93a2
movq -0x108(%rbp), %rdi
leaq 0x5660f(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2d93b7
leaq -0xb8(%rbp), %rdi
callq 0x63e20
leaq -0xc8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2d9405
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2d93f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x63e20
leaq -0xc8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2d942e
movq -0xd8(%rbp), %rdi
callq 0x2fdfa0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2d9420
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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)
callq 0x42ac0
movq -0xf8(%rbp), %rax
movq -0xf0(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2fed90
jmp 0x2daf02
leaq -0x58(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2db2b0
jmp 0x2daf11
movq -0xe8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x114(%rbp)
jmp 0x2daf29
leaq -0x58(%rbp), %rdi
callq 0x2fa6a0
leaq -0x80(%rbp), %rdi
callq 0x2db350
movl -0x114(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2db19e
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2db17d
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x56fb6(%rip), %rdi # 0x331f38
leaq 0x5eca4(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2db09d
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x120(%rbp)
movl $0x1, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0x5dd30
jmp 0x2dafd2
movq -0x120(%rbp), %rdi
movl $0x0, -0xb4(%rbp)
leaq 0x549d6(%rip), %rcx # 0x32f9c0
leaq 0x5ec57(%rip), %r9 # 0x339c48
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
leaq -0xb4(%rbp), %r8
callq 0x2fdf30
jmp 0x2db00d
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2db09d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2db1d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2db06c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2fa6a0
leaq -0x80(%rbp), %rdi
callq 0x2db350
jmp 0x2db1d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2db1d1
leaq -0xd8(%rbp), %rdi
callq 0x1af6e0
jmp 0x2db0ab
leaq -0xd8(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xc8(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2db0ca
leaq -0xc8(%rbp), %rdi
callq 0x63db0
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x130(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x128(%rbp)
jmp 0x2db10e
movq -0x128(%rbp), %rdi
leaq 0x548a3(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2db123
leaq -0xc8(%rbp), %rdi
callq 0x63e20
leaq -0xd8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2db17d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2db16f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x63e20
leaq -0xd8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2db1d1
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdi
callq 0x1f2c20
jmp 0x2db192
movl $0x1, -0xdc(%rbp)
jmp 0x2db1b8
movq -0x108(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x76500
movl $0x1, -0xdc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x23380
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x23380
movq -0x88(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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 -0x68(%rbp), %rdi
callq 0x3028e0
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2e2580
jmp 0x2e224a
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2cd170
movl %eax, -0xe4(%rbp)
jmp 0x2e2262
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
leaq -0x70(%rbp), %rdi
callq 0x2e2620
movl -0xe4(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e2496
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2e2485
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x4fc7d(%rip), %rdi # 0x331f38
leaq 0x5796b(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2e23ac
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xf8(%rbp)
movl $0x1, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5dd30
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rdx
movl $0x0, -0xa4(%rbp)
leaq 0x4d694(%rip), %rcx # 0x32f9c0
leaq 0x57915(%rip), %r9 # 0x339c48
leaq -0x80(%rbp), %rsi
leaq -0xa4(%rbp), %r8
callq 0x2fdf30
jmp 0x2e2345
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2e23ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2e2381
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fa6a0
leaq -0x70(%rbp), %rdi
callq 0x2e2620
jmp 0x2e24a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2e24a8
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x1af6e0
movq -0x100(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xb8(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2e23de
leaq -0xb8(%rbp), %rdi
callq 0x63db0
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x110(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x108(%rbp)
jmp 0x2e2422
movq -0x108(%rbp), %rdi
leaq 0x4d58f(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2e2437
leaq -0xb8(%rbp), %rdi
callq 0x63e20
leaq -0xc8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e2485
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x2e2477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x63e20
leaq -0xc8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e24a8
movq -0xd8(%rbp), %rdi
callq 0x302990
movl %eax, -0x4(%rbp)
jmp 0x2e249c
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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 -0x70(%rbp), %rdi
callq 0x302d50
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2e3bd0
jmp 0x2e388a
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2cd170
movl %eax, -0xec(%rbp)
jmp 0x2e38a2
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2e3c70
movl -0xec(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e3aec
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2e3ada
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x4e63d(%rip), %rdi # 0x331f38
leaq 0x5632b(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2e39fb
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x100(%rbp)
movl $0x1, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5dd30
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movl $0x0, -0xac(%rbp)
leaq 0x4c051(%rip), %rcx # 0x32f9c0
leaq 0x562d2(%rip), %r9 # 0x339c48
leaq -0x88(%rbp), %rsi
leaq -0xac(%rbp), %r8
callq 0x2fdf30
jmp 0x2e398b
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2e39fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2e39cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2e3c70
jmp 0x2e3b01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2e3b01
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1af6e0
movq -0x108(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xc0(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2e3a2d
leaq -0xc0(%rbp), %rdi
callq 0x63db0
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x110(%rbp)
jmp 0x2e3a71
movq -0x110(%rbp), %rdi
leaq 0x4bf40(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2e3a86
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e3ada
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2e3acc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e3b01
movq -0xe0(%rbp), %rdi
callq 0x302e00
movq %rax, -0x8(%rbp)
jmp 0x2e3af4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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 -0x70(%rbp), %rdi
callq 0x303430
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2e6dd0
jmp 0x2e6a8a
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2cd170
movl %eax, -0xec(%rbp)
jmp 0x2e6aa2
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2e6e70
movl -0xec(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2e6cec
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2e6cda
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x4b43d(%rip), %rdi # 0x331f38
leaq 0x5312b(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2e6bfb
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x100(%rbp)
movl $0x1, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5dd30
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movl $0x0, -0xac(%rbp)
leaq 0x48e51(%rip), %rcx # 0x32f9c0
leaq 0x530d2(%rip), %r9 # 0x339c48
leaq -0x88(%rbp), %rsi
leaq -0xac(%rbp), %r8
callq 0x2fdf30
jmp 0x2e6b8b
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2e6bfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2e6bcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2e6e70
jmp 0x2e6d01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2e6d01
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1af6e0
movq -0x108(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xc0(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2e6c2d
leaq -0xc0(%rbp), %rdi
callq 0x63db0
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x110(%rbp)
jmp 0x2e6c71
movq -0x110(%rbp), %rdi
leaq 0x48d40(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2e6c86
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e6cda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2e6ccc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2e6d01
movq -0xe0(%rbp), %rdi
callq 0x3034e0
movq %rax, -0x8(%rbp)
jmp 0x2e6cf4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1b960
nopw (%rax,%rax)
|
/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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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 -0x70(%rbp), %rdi
callq 0x303d10
leaq -0x50(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2ebe20
jmp 0x2ebada
movq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2cd170
movl %eax, -0xec(%rbp)
jmp 0x2ebaf2
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2ebec0
movl -0xec(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2ebd3d
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2ebd2a
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x463ed(%rip), %rdi # 0x331f38
leaq 0x4e0db(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2ebc4b
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x100(%rbp)
movl $0x1, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5dd30
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rdx
movl $0x0, -0xac(%rbp)
leaq 0x43e01(%rip), %rcx # 0x32f9c0
leaq 0x4e082(%rip), %r9 # 0x339c48
leaq -0x88(%rbp), %rsi
leaq -0xac(%rbp), %r8
callq 0x2fdf30
jmp 0x2ebbdb
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2ebc4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2ebc1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2fa6a0
leaq -0x78(%rbp), %rdi
callq 0x2ebec0
jmp 0x2ebd55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1c1e8
jmp 0x2ebd55
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1af6e0
movq -0x108(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xc0(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2ebc7d
leaq -0xc0(%rbp), %rdi
callq 0x63db0
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x110(%rbp)
jmp 0x2ebcc1
movq -0x110(%rbp), %rdi
leaq 0x43cf0(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2ebcd6
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ebd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x2ebd1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x63e20
leaq -0xd0(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ebd55
movq -0xe0(%rbp), %rdi
callq 0x303dc0
movsd %xmm0, -0x8(%rbp)
jmp 0x2ebd47
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1b960
nop
|
/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_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>>>>>(_qpdf_data*, std::function<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>>>> ()>, std::function<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>>>> (_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(qpdf, [&ret, fn](qpdf_data q) { ret = fn(q); });
if (status & QPDF_ERRORS) {
if (!qpdf->silence_errors) {
QTC::TC("qpdf", "qpdf-c warn about oh error", qpdf->oh_error_occurred ? 0 : 1);
if (!qpdf->oh_error_occurred) {
qpdf->warnings.emplace_back(
qpdf_e_internal,
qpdf->qpdf->getFilename(),
"",
0,
"C API function caught an exception that it isn't returning; please point the "
"application developer to ERROR HANDLING in qpdf-c.h");
qpdf->oh_error_occurred = true;
}
*QPDFLogger::defaultLogger()->getError() << qpdf->error->what() << "\n";
}
return fallback();
}
return ret;
}
|
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)
callq 0xc55d0
movq -0x118(%rbp), %rax
movq -0x110(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rcx, -0x108(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x304180
jmp 0x2ef6a8
leaq -0x78(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2efa60
jmp 0x2ef6ba
movq -0x108(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2cd170
movl %eax, -0x134(%rbp)
jmp 0x2ef6d2
leaq -0x78(%rbp), %rdi
callq 0x2fa6a0
leaq -0xa0(%rbp), %rdi
callq 0x2efb00
movl -0x134(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2ef94d
movq -0x10(%rbp), %rax
testb $0x1, 0xb0(%rax)
jne 0x2ef92c
movq -0x10(%rbp), %rax
movb 0xb1(%rax), %cl
movl $0x1, %edx
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %edx
leaq 0x4280a(%rip), %rdi # 0x331f38
leaq 0x4a4f8(%rip), %rsi # 0x339c2d
callq 0x25230
movq -0x10(%rbp), %rax
testb $0x1, 0xb1(%rax)
jne 0x2ef84c
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x140(%rbp)
movl $0x1, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2fa440
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x5dd30
jmp 0x2ef77e
movq -0x140(%rbp), %rdi
movl $0x0, -0xd4(%rbp)
leaq 0x4022a(%rip), %rcx # 0x32f9c0
leaq 0x4a4ab(%rip), %r9 # 0x339c48
leaq -0xb0(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
leaq -0xd4(%rbp), %r8
callq 0x2fdf30
jmp 0x2ef7b9
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
movq -0x10(%rbp), %rax
movb $0x1, 0xb1(%rax)
jmp 0x2ef84c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2ef980
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2ef818
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2fa6a0
leaq -0xa0(%rbp), %rdi
callq 0x2efb00
jmp 0x2ef980
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1c1e8
jmp 0x2ef980
leaq -0xf8(%rbp), %rdi
callq 0x1af6e0
jmp 0x2ef85a
leaq -0xf8(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0xe8(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x2ef879
leaq -0xe8(%rbp), %rdi
callq 0x63db0
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2fa360
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x150(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0x148(%rbp)
jmp 0x2ef8bd
movq -0x148(%rbp), %rdi
leaq 0x400f4(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x2ef8d2
leaq -0xe8(%rbp), %rdi
callq 0x63e20
leaq -0xf8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ef92c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x2ef91e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x63e20
leaq -0xf8(%rbp), %rdi
callq 0x4f0d0
jmp 0x2ef980
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdi
callq 0x304230
jmp 0x2ef941
movl $0x1, -0xfc(%rbp)
jmp 0x2ef967
movq -0x128(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x304280
movl $0x1, -0xfc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xab620
movq -0x120(%rbp), %rax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xab620
movq -0xa8(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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 & QPDF_ERRORS) {
return -1;
}
return n;
}
|
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_code_e error_code,
std::string const& filename,
std::string const& object,
qpdf_offset_t offset,
std::string const& message,
bool zero_offset_valid);
~QPDFExc() noexcept override = default;
// To get a complete error string, call what(), provided by std::exception. The accessors below
// return the original values used to create the exception. Only the error code and message are
// guaranteed to have non-zero/empty values.
// There is no lookup code that maps numeric error codes into strings. The numeric error code
// is just another way to get at the underlying issue, but it is more programmer-friendly than
// trying to parse a string that is subject to change.
QPDF_DLL
qpdf_error_code_e getErrorCode() const;
QPDF_DLL
std::string const& getFilename() const;
QPDF_DLL
std::string const& getObject() const;
QPDF_DLL
qpdf_offset_t getFilePosition() const;
QPDF_DLL
std::string const& getMessageDetail() const;
private:
QPDF_DLL_PRIVATE
static std::string createWhat(
std::string const& filename,
std::string const& object,
qpdf_offset_t offset,
std::string const& message);
// This class does not use the Members pattern to avoid needless memory allocations during
// exception handling.
qpdf_error_code_e error_code;
std::string filename;
std::string object;
qpdf_offset_t offset;
std::string message;
}
|
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
callq 0x1c110
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x1c110
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x58(%rdi)
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x1c110
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
/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 %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x305ee5
movq -0x20(%rbp), %rdi
callq 0x1b0a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xe4830
jmp 0x305daf
leaq -0x50(%rbp), %rdi
callq 0x63af0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
xorl %edx, %edx
callq 0x1afb00
jmp 0x305dc8
leaq -0x40(%rbp), %rdi
callq 0x63db0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xe47f0
jmp 0x305de7
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x46680
movq %rax, -0x90(%rbp)
jmp 0x305e00
movq -0x90(%rbp), %rdi
leaq 0x2cb36(%rip), %rsi # 0x332944
callq 0x46650
movq %rax, -0x98(%rbp)
jmp 0x305e1c
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x46650
movq %rax, -0xa0(%rbp)
jmp 0x305e41
movq -0xa0(%rbp), %rdi
leaq 0x29b70(%rip), %rsi # 0x32f9bf
callq 0x46650
jmp 0x305e56
leaq -0x70(%rbp), %rdi
callq 0x1c1e8
leaq -0x40(%rbp), %rdi
callq 0x63e20
leaq -0x50(%rbp), %rdi
callq 0x4f0d0
callq 0x1bab0
movl $0x2, -0x4(%rbp)
jmp 0x305ed9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x305ed0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x305ec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x305ebe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1c1e8
leaq -0x40(%rbp), %rdi
callq 0x63e20
leaq -0x50(%rbp), %rdi
callq 0x4f0d0
callq 0x1bab0
jmp 0x305ed7
jmp 0x305ee5
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1b960
movq %rax, %rdi
callq 0x1e220
nopw %cs:(%rax,%rax)
|
/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(%rbp), %rdi
callq 0x305b60
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
|
/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
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x10, %rax
movq %rax, -0x40(%rbp)
callq 0x1bc20
movq %rax, -0x38(%rbp)
jmp 0x30b27c
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq 0x8(%rax), %rdi
callq 0x1b700
jmp 0x30b2a9
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c1a0
jmp 0x30b2b8
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x30c380
movq -0x10(%rbp), %rdi
callq 0x1b960
nopl (%rax)
|
/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 -0x4(%rbp), %esi
leaq -0x80(%rbp), %rdi
callq 0x243e0
jmp 0x30b74d
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x1e8e0
jmp 0x30b760
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b220
jmp 0x30b772
movq -0x98(%rbp), %rdi
movb $0x0, -0x81(%rbp)
movq 0x185859(%rip), %rsi # 0x490fe0
movq 0x18582a(%rip), %rdx # 0x490fb8
callq 0x1b920
jmp 0x30b811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x30b7e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x30b7dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x30b7d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c1e8
leaq -0x80(%rbp), %rdi
callq 0x1c1e8
leaq -0x48(%rbp), %rdi
callq 0x1c1e8
leaq -0x49(%rbp), %rdi
callq 0x1c1d0
testb $0x1, -0x81(%rbp)
jne 0x30b7fa
jmp 0x30b806
movq -0x98(%rbp), %rdi
callq 0x1bcf0
jmp 0x30b808
movq -0x58(%rbp), %rdi
callq 0x1b960
nopw %cs:(%rax,%rax)
|
/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, %edi
callq 0x30b3c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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
leaq 0x186f50(%rip), %rdi # 0x492ab8
callq 0x30bfe0
jmp 0x30bb6f
leaq 0x49a(%rip), %rdi # 0x30c010
leaq 0x186f3b(%rip), %rsi # 0x492ab8
leaq 0x185d74(%rip), %rdx # 0x4918f8
callq 0x1bce0
leaq 0x186f38(%rip), %rdi # 0x492ac8
callq 0x1b840
leaq 0x186f1c(%rip), %rdi # 0x492ab8
callq 0x30c030
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
jmp 0x30bbd3
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0x18, %esi
callq 0x1b190
leaq 0x186eee(%rip), %rdi # 0x492ac8
callq 0x1b5f0
movq -0x8(%rbp), %rdi
callq 0x1b960
nopl (%rax,%rax)
|
/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;
case 24:
cipher = cbc_mode ? EVP_aes_192_cbc() : EVP_aes_192_ecb();
break;
default:
cipher = cbc_mode ? EVP_aes_128_cbc() : EVP_aes_128_ecb();
break;
}
check_openssl(EVP_CIPHER_CTX_reset(cipher_ctx));
check_openssl(
// line-break
EVP_CipherInit_ex(cipher_ctx, cipher, nullptr, key_data, cbc_block, encrypt));
check_openssl(EVP_CIPHER_CTX_set_padding(cipher_ctx, 0));
}
|
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 %rax, -0x40(%rbp)
subq $0x18, %rax
je 0x30bc68
jmp 0x30bc38
movq -0x40(%rbp), %rax
subq $0x20, %rax
jne 0x30bc8c
jmp 0x30bc44
testb $0x1, -0x21(%rbp)
je 0x30bc55
callq 0x1b940
movq %rax, -0x50(%rbp)
jmp 0x30bc5e
callq 0x1c070
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x30bcae
testb $0x1, -0x21(%rbp)
je 0x30bc79
callq 0x1b550
movq %rax, -0x58(%rbp)
jmp 0x30bc82
callq 0x1b4b0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x30bcae
testb $0x1, -0x21(%rbp)
je 0x30bc9d
callq 0x1b760
movq %rax, -0x60(%rbp)
jmp 0x30bca6
callq 0x1b440
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1c1a0
movl %eax, %edi
callq 0x30b3c0
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %r9d
xorl %eax, %eax
movl %eax, %edx
callq 0x1bdc0
movl %eax, %edi
callq 0x30b3c0
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x1b670
movl %eax, %edi
callq 0x30b3c0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/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 InKeyType = InMapKeyType;
Config() = default;
Config(const Config& in_config);
Config(Config&& in_config) = default;
Config& operator=(const Config& in_config);
Config& operator=(Config&& in_config) = default;
/**
* @brief Fetches the value of an entry.
*
* @param in_key Key of the entry to fetch
* @param in_default_value Value to return if no such entry exists
* @return Value of the entry if it exists, an empty string otherwise.
*/
std::string_view get(std::string_view in_key, std::string_view in_default_value = std::string_view{}) const;
/**
* @brief Fetches the value of an entry and interprets it as another type.
*
* @param T Type to interpret the value as
*
* @param in_key Key of the entry to fetch
* @param in_default_value Value to return if no such entry exists
* @return Value of the entry if it exists, 0 otherwise.
*/
template<typename T> T get(std::string_view in_key, T in_default_value = 0) const;
/**
* @brief Fetches a section based on its name
*
* @param in_key Name of the section to fetch
* @return Pointer to a section if it exists, nullptr otherwise
*/
Config *getSection(std::string_view in_key) const;
/**
* @brief Fetches a section based on its name
* Note: This will create new sections as necessary if they do not exist
*
* @param in_key Name of the section to fetch
* @return Reference to the section
*/
Config &getSectionReference(std::string_view in_key);
/**
* @brief Sets an entry's value in the table
*
* @param in_key Key of the entry to write to
* @param in_value Value to write to the entry
* @return True if a new entry was added, false if an entry was overwritten
*/
bool set(std::string_view in_key, std::string in_value);
/**
* @brief Removes an entry from the table
*
* @param in_key Key of the entry to remove
* @return True if an entry was removed, false otherwise
*/
bool remove(std::string_view in_key);
/**
* @brief Removes a section from the table
*
* @param in_key Key of the section to remove
* @return True if an entry was removed, false otherwise
*/
bool removeSection(std::string_view in_key);
/**
* @brief Fetches the name of this config section
* Note: This is the filename on the root node
*
* @return Name of this section
*/
const std::string& getName() const;
/**
* @brief Erases all data from this section
*/
void erase();
/**
* @brief Reads config data from a file and stores it in this config
*
* @param in_filename Name of the file to read from
* @return True on success, false otherwise
*/
bool read(const char *in_filename);
/**
* @brief Reads config data from a file and stores it in this config
*
* @param in_filename Name of the file to read from
* @return True on success, false otherwise
*/
bool read(std::string_view in_filename);
/**
* @brief Writes config data to the last read file
*
* @return True on success, false otherwise
*/
bool write();
/**
* @brief Writes config data to a file
*
* @param in_filename Name of the file to write to
* @return True on success, false otherwise
*/
bool write(const char *in_filename);
/**
* @brief Writes config data to a file
*
* @param in_filename Name of the file to write to
* @return True on success, false otherwise
*/
bool write(std::string_view in_filename);
/**
* @brief Empties config data from memory and reads from the last read file
*
* @return True on success, false otherwise
*/
bool reload();
/**
* @brief Empties config data from memory and reads from a file
*
* @param in_filename Name of the file to read from
* @return True on success, false otherwise
*/
bool reload(const char *in_filename);
/**
* @brief Empties config data from memory and reads from a file
*
* @param in_filename Name of the file to read from
* @return True on success, false otherwise
*/
bool reload(std::string_view in_filename);
/**
* @brief Fetches a reference to this config's entry table
*
* @return Reference to m_table
*/
inline const ValuesHashTable &getTable() const { return m_table; }
/**
* @brief Fetches a reference to this config's subsections
*
* @return Reference to m_sections
*/
const SectionHashTable &getSections() const;
/** Subscript operator */
Config &operator[](std::string_view in_key);
protected:
virtual bool read_internal(const char *in_filename);
virtual bool write_internal(const char *in_filename);
/** Name of this Config section. This is empty or the filename at the root level. */
std::string m_name;
/** Table of entries within this section */
ValuesHashTable m_table;
/** Table of sections within this section */
std::unique_ptr<SectionHashTable> m_sections;
}
|
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 0x167c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/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 codepoints_removed{};
while (!in_string.empty() && !in_prefix.empty()) {
decode_result string_front = decode_codepoint(in_string);
decode_result prefix_front = decode_codepoint(in_prefix);
if (string_front.units == 0
|| prefix_front.units == 0) {
// Failed to decode front codepoint; bad unicode sequence
return 0;
}
if (!equalsi(string_front.codepoint, prefix_front.codepoint)) {
// Codepoints don't fold to same value
return 0;
}
// Codepoints are equal; trim off the fronts and continue
in_string.remove_prefix(string_front.units);
in_prefix.remove_prefix(prefix_front.units);
codepoints_removed += string_front.units;
}
if (!in_prefix.empty()) {
// We reached end of in_string before end of prefix
return 0;
}
return codepoints_removed;
}
|
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)
jmp 0x1fd04
movq $0x0, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x170c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x79(%rbp)
jne 0x1fc35
leaq -0x28(%rbp), %rdi
callq 0x170c0
xorb $-0x1, %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x1fc41
jmp 0x1fce5
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x174f0
movl %eax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x174f0
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x1fc97
cmpq $0x0, -0x58(%rbp)
jne 0x1fca1
movq $0x0, -0x8(%rbp)
jmp 0x1fd04
movl -0x40(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x166f0
testb $0x1, %al
jne 0x1fcba
movq $0x0, -0x8(%rbp)
jmp 0x1fd04
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x16df0
movq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x16df0
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x1fc12
leaq -0x28(%rbp), %rdi
callq 0x170c0
testb $0x1, %al
jne 0x1fcfc
movq $0x0, -0x8(%rbp)
jmp 0x1fd04
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/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::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::basic_string_view<char, std::char_traits<char>>&&)
|
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);
}
else {
// Append over all the codepoints
decode_result decode;
std::basic_string_view<InCharT> in_view = in_string;
while ((decode = decode_codepoint(in_view)).units != 0) {
encode_codepoint(out_string, decode.codepoint);
in_view.remove_prefix(decode.units);
}
}
join_append(out_string, std::forward<ArgsT>(in_args)...);
}
|
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 %rax
retq
movq %rax, %rdi
callq 0x3f7c
nop
|
/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 $0x0, (%r15)
movq 0x18(%rbx), %rdi
movq %rax, 0x18(%rbx)
testq %rdi, %rdi
je 0x3a52
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3a52
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x4058
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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() );
string_section_accessor str_writer( string_table );
Elf_Word pos = str_writer.add_string( name );
new_section->set_name_string_offset( pos );
return new_section;
}
|
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
movq (%r15), %rax
jmp 0x3b07
xorl %ecx, %ecx
movq 0x20(%rax), %rax
movq (%rax,%rcx,8), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
callq 0x6404
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 =
static_cast<Elf_Word>( string_section->get_size() );
if ( current_position == 0 ) {
char empty_string = '\0';
string_section->append_data( &empty_string, 1 );
current_position++;
}
// Calculate string length and check for overflow
size_t str_len = std::strlen( str );
if ( str_len > std::numeric_limits<Elf_Word>::max() - 1 ) {
return 0; // String too long
}
// Check if appending would overflow section size
Elf_Word append_size = static_cast<Elf_Word>( str_len + 1 );
if ( append_size >
std::numeric_limits<Elf_Word>::max() - current_position ) {
return 0; // Would overflow section size
}
string_section->append_data( str, append_size );
}
return 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 (%rdi), %rax
pushq $0x1
popq %rdx
callq *0xe0(%rax)
pushq $0x1
popq %r12
movq %r14, %rdi
callq 0x3090
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
cmpq %rcx, %rax
ja 0x3bf8
movl %r12d, %ecx
notl %ecx
cmpl %ecx, %eax
jae 0x3bf8
incq %rax
movq (%r15), %rdi
movq (%rdi), %rcx
movq %r14, %rsi
movq %rax, %rdx
callq *0xe0(%rcx)
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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_entry( offset, info );
}
|
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 $0x20, %r14
movl %ebp, %edx
orq %r14, %rdx
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8084
nop
|
/serge1[P]ELFIO/elfio/elfio_relocation.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.