name string | code string | asm string | file string |
|---|---|---|---|
flatbuffers::FlatBufferBuilder::TrackField(unsigned short, unsigned int) | void TrackField(voffset_t field, uoffset_t off) {
FieldLoc fl = { off, field };
offsetbuf_.push_back(fl);
} | pushq %rax
movl %edx, (%rsp)
movw %si, 0x4(%rsp)
movq 0x20(%rdi), %rsi
cmpq 0x28(%rdi), %rsi
je 0x2c0b
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x20(%rdi)
jmp 0x2c17
addq $0x18, %rdi
movq %rsp, %rdx
callq 0x2c1a
popq %rax
retq
nop
| /AlexStocks[P]flatbuffers/include/flatbuffers/flatbuffers.h |
void flatbuffers::FlatBufferBuilder::AddElement<short>(unsigned short, short, short) | void AddElement(voffset_t field, T e, T def) {
// We don't serialize values equal to the default.
if (e == def && !force_defaults_) return;
auto off = PushElement(e);
TrackField(field, off);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
cmpw %cx, %r14w
jne 0x2dc8
cmpb $0x1, 0x50(%rbx)
jne 0x2dfd
movl $0x2, %esi
movq %rbx, %rdi
callq 0x2ad6
movl $0x2, %esi
movq %rbx, %rdi
callq 0x2a0a
movw %r14w, (%rax)
movl (%rbx), %edx
subl 0x10(%rbx), %edx
addl 0x8(%rbx), %edx
movzwl %... | /AlexStocks[P]flatbuffers/include/flatbuffers/flatbuffers.h |
curl_mvsnprintf | int curl_mvsnprintf(char *buffer, size_t maxlength, const char *format,
va_list ap_save)
{
int retcode;
struct nsprintf info;
info.buffer = buffer;
info.length = 0;
info.max = maxlength;
retcode = dprintf_formatf(&info, addbyter, format, ap_save);
if((retcode != -1) && info.max) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
le... | /macressler[P]curl/lib/mprintf.c |
dprintf_formatf | static int dprintf_formatf(
void *data, /* untouched by format(), just sent to the stream() function in
the second argument */
/* function pointer called for each output character */
int (*stream)(int, FILE *),
const char *format, /* %-formatted string */
va_list ap_save) /* list of parame... | pushq %rbp
movq %rsp, %rbp
subq $0x1680, %rsp # imm = 0x1680
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x517e(%rip), %rax # 0x7400
movq %rax, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x15a0(%rbp), %rax
addq $0x144, %rax ... | /macressler[P]curl/lib/mprintf.c |
curl_msnprintf | int curl_msnprintf(char *buffer, size_t maxlength, const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = curl_mvsnprintf(buffer, maxlength, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x377b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)... | /macressler[P]curl/lib/mprintf.c |
alloc_addbyter | static int alloc_addbyter(int output, FILE *data)
{
struct asprintf *infop = (struct asprintf *)data;
unsigned char outc = (unsigned char)output;
if(!infop->buffer) {
infop->buffer = malloc(32);
if(!infop->buffer) {
infop->fail = 1;
return -1; /* fail */
}
infop->alloc = 32;
infop... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x39ad
movl $0x20, %edi
leaq 0x671d(%rip), %rax # 0xa080
callq *(%rax)
movq %rax, %rcx
movq... | /macressler[P]curl/lib/mprintf.c |
curl_msprintf | int curl_msprintf(char *buffer, const char *format, ...)
{
va_list ap_save; /* argument pointer */
int retcode;
va_start(ap_save, format);
retcode = dprintf_formatf(&buffer, storebuffer, format, ap_save);
va_end(ap_save);
*buffer = 0; /* we terminate this with a zero byte */
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x3b6b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)... | /macressler[P]curl/lib/mprintf.c |
curl_mprintf | int curl_mprintf(const char *format, ...)
{
int retcode;
va_list ap_save; /* argument pointer */
va_start(ap_save, format);
retcode = dprintf_formatf(stdout, fputc, format, ap_save);
va_end(ap_save);
return retcode;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3c58
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)... | /macressler[P]curl/lib/mprintf.c |
dprintf_DollarString | static long dprintf_DollarString(char *input, char **end)
{
int number = 0;
while(ISDIGIT(*input)) {
number *= 10;
number += *input-'0';
input++;
}
if(number && ('$'==*input++)) {
*end = input;
return number;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x4c1d
imull $0xa, -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x1c(%... | /macressler[P]curl/lib/mprintf.c |
curlx_strtoofft | CURLofft curlx_strtoofft(const char *str, char **endp, int base,
curl_off_t *num)
{
char *end;
curl_off_t number;
errno = 0;
*num = 0; /* clear by default */
DEBUGASSERT(str);
while(*str && ISSPACE(*str))
str++;
if('-' == *str) {
if(endp)
*endp = (char *)str; /* di... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
callq 0x2030
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
jmp 0x4d5f
jmp 0x4d61
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39... | /macressler[P]curl/lib/strtoofft.c |
curlx_ultosi | int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma war... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4e8a
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_uztoso | curl_off_t curlx_uztoso(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#elif defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable:4310) /* cast truncates constant value */
#endif
DEBUGASSERT(uznum <= (size_t) CU... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4eaa
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_uztoul | unsigned long curlx_uztoul(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_LONG < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
#endif
return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG)... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
#endif
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#i... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4f0a
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4f2a
jmp 0x4f2c
jmp 0x4f2e
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sltous | unsigned short curlx_sltous(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(slnum & (long) CURL_M... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4f6a
jmp 0x4f6c
jmp 0x4f6e
movq -0x8(%rbp), %rax
andq $0xffff, %rax # imm = 0xFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4f8a
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if (SIZEOF_INT < SIZEOF_SIZE_T)
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x4fca
jmp 0x4fcc
jmp 0x4fce
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
curlx_uitosi | int curlx_uitosi(unsigned int uinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uinum <= (unsigned int) CURL_MASK_SINT);
return (int) (uinum & (unsigned int) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warni... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x5029
movl -0x4(%rbp), %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /macressler[P]curl/lib/warnless.c |
Curl_convert_clone | CURLcode Curl_convert_clone(struct Curl_easy *data,
const char *indata,
size_t insize,
char **outbuf)
{
char *convbuf;
(void)data;
convbuf = malloc(insize);
if(!convbuf)
return CURLE_OUT_OF_MEMORY;
memcpy(convbuf, indata... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq 0x4dd1(%rip), %rax # 0xa080
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x52c9
movl $0x1b, -0x4(%rbp)
jmp 0x52ec
movq -0x30(%rbp), %r... | /macressler[P]curl/tests/server/getpart.c |
getpart | int getpart(char **outbuf, size_t *outlen,
const char *main, const char *sub, FILE *stream)
{
# define MAX_TAG_LEN 79
char couter[MAX_TAG_LEN + 1]; /* current outermost section */
char cmain[MAX_TAG_LEN + 1]; /* current main section */
char csub[MAX_TAG_LEN + 1]; /* current sub section */
char pt... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x1c8(%rbp)
movq $0x0, -0x1e8(%rbp)
movq $0x100, -0x1f0(%rbp) # imm = 0x100
movl $0x0, -0x1f4(%rbp)
movl $0x0, -0x1f8(%rbp)
... | /macressler[P]curl/tests/server/getpart.c |
decodedata | static int decodedata(char **buf, /* dest buffer */
size_t *len) /* dest buffer data length */
{
CURLcode error = CURLE_OK;
unsigned char *buf64 = NULL;
size_t src_len = 0;
if(!*len)
return GPE_OK;
/* base64 decode the given buffer */
error = Curl_base64_decode(*buf, &buf64,... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5ddd
movl $0x0, -0x4(%rbp)
jmp 0x5e62
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%... | /macressler[P]curl/tests/server/getpart.c |
Curl_base64_decode | CURLcode Curl_base64_decode(const char *src,
unsigned char **outptr, size_t *outlen)
{
size_t srclen = 0;
size_t length = 0;
size_t padding = 0;
size_t i;
size_t numQuantums;
size_t rawlen = 0;
unsigned char *pos;
unsigned char *newstr;
*outptr = NULL;
*outlen = 0;
src... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x20... | /macressler[P]curl/lib/base64.c |
decodeQuantum | static size_t decodeQuantum(unsigned char *dest, const char *src)
{
size_t padding = 0;
const char *s, *p;
unsigned long i, x = 0;
for(i = 0, s = src; i < 4; i++, s++) {
unsigned long v = 0;
if(*s == '=') {
x = (x << 6);
padding++;
}
else {
p = base64;
while(*p && (*p ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x4, -0x38(%rbp)
jae 0x6183
movq $0x0, -0x48(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %ea... | /macressler[P]curl/lib/base64.c |
base64_encode | static CURLcode base64_encode(const char *table64,
struct Curl_easy *data,
const char *inputbuff, size_t insize,
char **outptr, size_t *outlen)
{
CURLcode result;
unsigned char ibuf[3];
unsigned char obuf[4];
int i;
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x38(%rbp), %rax
movq $0... | /macressler[P]curl/lib/base64.c |
empty_suite::run() | void run()
{
test_null();
test_boolean();
test_integer();
test_real();
test_string();
test_wstring();
test_u16string();
test_u32string();
test_array();
test_map();
} | pushq %rbp
movq %rsp, %rbp
callq 0x35f0
callq 0x3660
callq 0x36e0
callq 0x3bd0
callq 0x3d40
callq 0x3e30
callq 0x3f20
callq 0x4010
callq 0x4100
callq 0x4340
popq %rbp
retq
nopl (%rax,%rax)
| /breese[P]trial/test/dynamic/variable_capacity_suite.cpp |
Pl_SHA2::Pl_SHA2(int, Pipeline*) (.cold.1) | virtual ~Pipeline() = default; | movq 0x1d96a8(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x6f42a
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x68760
retq
| /jberkenbilt[P]qpdf/include/qpdf/Pipeline.hh |
read_bits(unsigned char const*&, unsigned long&, unsigned long&, unsigned long) | static unsigned long long
read_bits(unsigned char const*& p, size_t& bit_offset, size_t& bits_available, size_t bits_wanted)
{
// View p as a stream of bits:
// 76543210 76543210 ....
// bit_offset is the bit number within the first byte that marks
// the first bit that we would read.
if (bits_wa... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %r14
cmpq %rcx, (%rdx)
jb 0x72a03
cmpq $0x20, %r15
ja 0x72a65
testq %r15, %r15
je 0x729f3
movq (%rdi), %r9
xorl %eax, %eax
movq (%rsi), %r10
leal 0x1(%r10), %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
shll %cl, %r8d
notb %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/bits_functions.hh |
BitStream::skipToNextByte() | void
BitStream::skipToNextByte()
{
if (bit_offset != 7) {
size_t bits_to_skip = bit_offset + 1;
if (bits_available < bits_to_skip) {
throw std::logic_error("INTERNAL ERROR: overflow skipping to next byte in bitstream");
}
bit_offset = 7;
++p;
bits_availabl... | pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
cmpq $0x7, %rax
je 0x72c72
incq %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
jb 0x72c7a
movq $0x7, 0x18(%rdi)
incq 0x10(%rdi)
movq %rcx, 0x20(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x142390(%rip), %rsi # ... | /jberkenbilt[P]qpdf/libqpdf/BitStream.cc |
Buffer::Buffer() | Buffer::Buffer() :
m(new Members(0, nullptr, true))
{
} | pushq %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0x68ab0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, (%rbx)
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Buffer.cc |
Buffer::Buffer(unsigned char*, unsigned long) | Buffer::Buffer(unsigned char* buf, size_t size) :
m(new Members(size, buf, false))
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x68ab0
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
movb %cl, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rax, (%r15)
popq %rbx
popq %r14
popq %r... | /jberkenbilt[P]qpdf/libqpdf/Buffer.cc |
Buffer::Buffer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Buffer::Buffer(std::string& content) :
m(new Members(content.size(), reinterpret_cast<unsigned char*>(content.data()), false))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x68ab0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
movq $0x0, 0x8(%rax)
xorl %esi, %esi
movb %sil, 0x10(%rax)
movb %sil, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rax, (%r14)
ad... | /jberkenbilt[P]qpdf/libqpdf/Buffer.cc |
QIntC::IntConverter<unsigned long, long long, false, true>::error(unsigned 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 unsigned type to a " << sizeof(To) << "-byte signed type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d780
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x688a0
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x6ac30
movq %rsp, %rdi
callq 0x6dba0
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
QIntC::IntConverter<long long, unsigned long, true, false>::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 unsigned type";
throw s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d780
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x688a0
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x6ac30
movq %rsp, %rdi
callq 0x6dba0
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
InputSource::readLine[abi:cxx11](unsigned long) | std::string
InputSource::readLine(size_t max_line_length)
{
return read_line(max_line_length);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq %rdx, %rsi
xorl %edx, %edx
callq 0x6b1f0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x6eba0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
... | /jberkenbilt[P]qpdf/libqpdf/InputSource.cc |
InputSource::findFirst(char const*, long long, unsigned long, InputSource::Finder&) | bool
InputSource::findFirst(char const* start_chars, qpdf_offset_t offset, size_t len, Finder& finder)
{
// Basic approach: search for the first character of start_chars starting from offset but not
// going past len (if len != 0). Once the first character is found, see if it is the beginning
// of a sequen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x6a120
addq $-0x401, %rax # imm = 0xFBFF
cmpq $-0x400, %rax # imm = 0xF... | /jberkenbilt[P]qpdf/libqpdf/InputSource.cc |
JSON::writeArrayItem(Pipeline*, bool&, JSON const&, unsigned long) | void
JSON::writeArrayItem(Pipeline* p, bool& first, JSON const& element, size_t depth)
{
writeNext(p, first, depth);
element.write(p, depth);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
movq %rcx, %rdx
callq 0x6de50
movq (%r15), %rax
testq %rax, %rax
je 0x764a3
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x15ccc7(%rip), %rsi # 0... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_number::JSON_number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON_value(value_type_e type_code) :
type_code(type_code)
{
} | movl $0x4, 0x8(%rdi)
leaq 0x1cbe72(%rip), %rax # 0x242958
movq %rax, (%rdi)
leaq 0x10(%rdi), %rax
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
addq %rcx, %rdx
movq %rax, %rdi
movq %rcx, %rsi
jmp 0x68320
| /jberkenbilt[P]qpdf/include/qpdf/JSON.hh |
JSON::unparse[abi:cxx11]() const | std::string
JSON::unparse() const
{
if (!m) {
return "null";
}
std::string s;
Pl_String p("unparse", nullptr, s);
write(&p, 0);
return s;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
cmpq $0x0, (%rsi)
movq %r15, (%rdi)
je 0x76ce2
movq %rsi, %r14
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x13ebd4(%rip), %rsi # 0x1b588d
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x69240
movq (%r14), %rax
t... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::makeNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | JSON
JSON::makeNumber(std::string const& encoded)
{
return {std::make_unique<JSON_number>(encoded)};
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x30, %edi
callq 0x68ab0
movq %rax, %rbx
movl $0x4, 0x8(%rax)
leaq 0x1cb5f4(%rip), %rax # 0x242958
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::forEachArrayItem(std::function<void (JSON)>) const | bool
JSON::forEachArrayItem(std::function<void(JSON value)> fn) const
{
if (auto v = m ? dynamic_cast<JSON_array const*>(m->value.get()) : nullptr) {
for (auto const& i: v->elements) {
fn(JSON(i));
}
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x777d9
movq (%rax), %rdi
testq %rdi, %rdi
je 0x777d9
leaq 0x1cb31a(%rip), %rsi # 0x242ae0
leaq 0x1cb20b(%rip), %rdx # 0x2429d8
xorl %ecx, %ecx
callq 0x6d850
movq %rax, %r14
jmp... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::parse() | JSON
JSONParser::parse()
{
while (!done) {
getToken();
handleToken();
}
if (parser_state != ps_done) {
QTC::TC("libtests", "JSON parse premature EOF");
throw std::runtime_error("JSON: premature end of input");
}
auto const& tos = stack.back().item;
if (reactor && ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, 0xd0(%rsp)
cmpb $0x0, 0x4040(%rsi)
je 0x790c6
cmpl $0x9, 0x4070(%rbx)
jne 0x7a269
movq 0x4080(%rbx), %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7908e
movq -0x10(%r14), %rax
testq %rax, %rax
je 0x79088
movq... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
(anonymous namespace)::JSONParser::~JSONParser() | JSONParser(InputSource& is, JSON::Reactor* reactor) :
is(is),
reactor(reactor),
p(buf)
{
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4090(%rdi), %rdi
leaq 0x40a0(%rbx), %rax
cmpq %rax, %rdi
je 0x7b30e
movq (%rax), %rsi
incq %rsi
callq 0x68760
movq 0x4078(%rbx), %r14
movq 0x4080(%rbx), %r15
cmpq %r15, %r14
je 0x7b335
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x7b32f
callq 0x69d60
addq $0x18, %r1... | /jberkenbilt[P]qpdf/libqpdf/JSON.cc |
JSON::JSON_string::~JSON_string() | ~JSON_string() override = default; | movq %rdi, %rax
leaq 0x1c5dc0(%rip), %rcx # 0x242930
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x7cb8b
movq (%rax), %rsi
incq %rsi
jmp 0x68760
retq
| /jberkenbilt[P]qpdf/include/qpdf/JSON.hh |
JSON::JSON_number::~JSON_number() | ~JSON_number() override = default; | movq %rdi, %rax
leaq 0x1c5d8e(%rip), %rcx # 0x242958
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x7cbe5
movq (%rax), %rsi
incq %rsi
jmp 0x68760
retq
| /jberkenbilt[P]qpdf/include/qpdf/JSON.hh |
Pipeline::~Pipeline() | virtual ~Pipeline() = default; | movq 0x1cbe11(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x7ccc1
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x68760
retq
| /jberkenbilt[P]qpdf/include/qpdf/Pipeline.hh |
JSONHandler::handle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON) | void
JSONHandler::handle(std::string const& path, JSON j)
{
if (m->h.any_handler) {
m->h.any_handler(path, j);
return;
}
bool bvalue = false;
std::string s_value;
if (m->h.null_handler && j.isNull()) {
m->h.null_handler(path);
return;
}
if (m->h.string_handle... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
cmpq $0x0, 0x10(%rdi)
je 0x7db8c
movq (%r15), %rax
movq %rax, 0x60(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x7dc51
movq 0x1cb265(%rip), %rcx ... | /jberkenbilt[P]qpdf/libqpdf/JSONHandler.cc |
MD5::encodeString(char const*) | void
MD5::encodeString(char const* str)
{
size_t len = strlen(str);
crypto->MD5_init();
encodeDataIncrementally(str, len);
crypto->MD5_finalize();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6a120
movq %rax, %r15
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%r14), %r12
movq %rbx, %rdi
callq 0x6bb40
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq *0x20(%rcx)
m... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
MD5::print() | void
MD5::print()
{
Digest digest_val;
digest(digest_val);
unsigned int i;
for (i = 0; i < 16; ++i) {
printf("%02x", digest_val[i]);
}
printf("\n");
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x30(%rax)
leaq 0x136ab0(%rip), %rbx # 0x1b60da
xorl %r14d, %r14d
movzbl (%rsp,%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x68440
incq %r14
cm... | /jberkenbilt[P]qpdf/libqpdf/MD5.cc |
warn(QPDF&, QPDFObjectHandle&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void
warn(QPDF& qpdf, QPDFObjectHandle& node, std::string const& msg)
{
qpdf.warn(qpdf_e_damaged_pdf, get_description(node), 0, msg);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x853dc
movq %r14, %rdi
movl $0x5, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x6bf00
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x80036
movq 0x10(%rsp), %rsi
incq ... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::increment(bool) | void
NNTreeIterator::increment(bool backward)
{
if (this->item_number < 0) {
QTC::TC("qpdf", "NNTree increment end()");
deepen(impl.oh, !backward, true);
return;
}
bool found_valid_key = false;
while (valid() && (!found_valid_key)) {
this->item_number += backward ? -2 : 2... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
js 0x80516
movl 0x38(%rbx), %eax
testl %eax, %eax
js 0x8057b
movl %esi, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
movq %rcx, 0xc0(%rsp)
leal -0x2(,%rcx,4), %ecx
movl %ecx, 0x4c(%rsp)
leaq 0x28(%rbx), %rcx... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::deepen(QPDFObjectHandle, bool, bool) | bool
NNTreeIterator::deepen(QPDFObjectHandle node, bool first, bool allow_empty)
{
// Starting at this node, descend through the first or last kid until we reach a node with
// items. If we succeed, return true; otherwise return false and leave path alone.
auto opath = this->path;
bool failed = false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %ecx, 0x9c(%rsp)
movl %edx, 0x54(%rsp)
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
leaq 0x10(%rdi), %rbx
leaq 0xe0(%rsp), %rdi
movq %rbx, %rsi
callq 0x8568e
leaq 0x100(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ec... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::resetLimits(QPDFObjectHandle, std::_List_iterator<NNTreeIterator::PathElement>) | void
NNTreeIterator::resetLimits(QPDFObjectHandle node, std::list<PathElement>::iterator parent)
{
bool done = false;
while (!done) {
if (parent == this->path.end()) {
QTC::TC("qpdf", "NNTree remove limits from root");
node.removeKey("/Limits");
done = true;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, 0x80(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, 0x98(%rsp)
leaq 0x10(%rsp), %r15
movq %rsi, 0x30(%rsp)
leaq 0x8(%rsi), %rax
movq %rax, 0x110(%rsp)
xorl %ebx, %ebx
leaq 0x128(%rsp), %... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeIterator::operator==(NNTreeIterator const&) const | bool
NNTreeIterator::operator==(NNTreeIterator const& other) const
{
if ((this->item_number == -1) && (other.item_number == -1)) {
return true;
}
if (this->path.size() != other.path.size()) {
return false;
}
auto tpi = this->path.begin();
auto opi = other.path.begin();
while ... | movl 0x38(%rdi), %ecx
movl 0x38(%rsi), %edx
movl %ecx, %r8d
andl %edx, %r8d
movb $0x1, %al
cmpl $-0x1, %r8d
je 0x83188
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x83186
addq $0x10, %rdi
addq $0x10, %rsi
movq %rdi, %rax
movq (%rax), %rax
cmpq %rdi, %rax
je 0x83189
movq (%rsi), %rsi
movl 0x20(%rax), %r8d
cmpl 0x20(... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::compareKeyItem(QPDFObjectHandle&, QPDFObjectHandle&, int) | int
NNTreeImpl::compareKeyItem(QPDFObjectHandle& key, QPDFObjectHandle& items, int idx)
{
if (!((items.isArray() && (items.getArrayNItems() > (2 * idx)) &&
details.keyValid(items.getArrayItem(2 * idx))))) {
QTC::TC("qpdf", "NNTree item is wrong type");
error(
qpdf,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x6c8b0
testb %al, %al
je 0x838a1
movq %r15, %rdi
callq 0x6f1d0
leal (%r14,%r14), %edx
cmpl %edx, %eax
jle 0x838a1
movq (%rbx), %r13
leaq 0x68(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::compareKeyKid(QPDFObjectHandle&, QPDFObjectHandle&, int) | int
NNTreeImpl::compareKeyKid(QPDFObjectHandle& key, QPDFObjectHandle& kids, int idx)
{
if (!(kids.isArray() && (idx < kids.getArrayNItems()) &&
kids.getArrayItem(idx).isDictionary())) {
QTC::TC("qpdf", "NNTree kid is invalid");
error(qpdf, this->oh, "invalid kid at index " + std::to_strin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x6c8b0
testb %al, %al
je 0x83b9c
movq %r15, %rdi
callq 0x6f1d0
cmpl %r14d, %eax
jle 0x83b9c
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
NNTreeImpl::insert(QPDFObjectHandle, QPDFObjectHandle) | NNTreeImpl::iterator
NNTreeImpl::insert(QPDFObjectHandle key, QPDFObjectHandle value)
{
auto iter = find(key, true);
if (!iter.valid()) {
QTC::TC("qpdf", "NNTree insert inserts first");
return insertFirst(key, value);
} else if (details.compareKeys(key, iter->first) == 0) {
QTC::TC("... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq %rax, 0x68(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x8425c
movq 0x1c4b92(%rip), %rcx # 0x248de0
cmpb $0x0, (%rcx)
je 0... | /jberkenbilt[P]qpdf/libqpdf/NNTree.cc |
PDFVersion::updateIfGreater(PDFVersion const&) | bool
PDFVersion::operator<(PDFVersion const& rhs) const
{
return (
(this->major_version < rhs.major_version) ? true
: (this->major_version > rhs.major_version) ? false
: (this->minor_version < rhs.minor_version) ? true
: (this->minor_version > rhs.minor_... | movl (%rsi), %eax
cmpl %eax, (%rdi)
jge 0x86063
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
retq
jle 0x86066
retq
movl 0x4(%rsi), %eax
cmpl %eax, 0x4(%rdi)
jl 0x86056
jg 0x86065
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jl 0x86056
jmp 0x86065
| /jberkenbilt[P]qpdf/libqpdf/PDFVersion.cc |
PDFVersion::getVersion(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&) const | void
PDFVersion::getVersion(std::string& version, int& extension_level) const
{
extension_level = this->extension_level;
version = std::to_string(this->major_version) + "." + std::to_string(this->minor_version);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
movl %eax, (%rdx)
movl (%rdi), %r13d
movl %r13d, %ebp
negl %ebp
cmovsl %r13d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x860f6
movl $0x4, %r15d
movl $0xd1b71759, %eax # imm = 0xD... | /jberkenbilt[P]qpdf/libqpdf/PDFVersion.cc |
Pipeline::getIdentifier[abi:cxx11]() const | std::string
Pipeline::getIdentifier() const
{
return this->identifier;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x68320
movq %rbx, %rax
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pipeline::operator<<(short) | Pipeline&
Pipeline::operator<<(short i)
{
this->writeString(std::to_string(i));
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %ebp
negl %ebp
cmovsl %esi, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x86589
movl $0x2, %r15d
cmpl $0x64, %ebp
jb 0x86589
movl $0x3, %r15d
cmpl $0x3e8, %ebp # imm = 0x3E8
jb 0x86589
... | /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pipeline::operator<<(long) | Pipeline&
Pipeline::operator<<(long i)
{
this->writeString(std::to_string(i));
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0x86798
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x... | /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pipeline::operator<<(long long) | Pipeline&
Pipeline::operator<<(long long i)
{
this->writeString(std::to_string(i));
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0x868a8
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x... | /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pipeline::operator<<(unsigned long) | Pipeline&
Pipeline::operator<<(unsigned long i)
{
this->writeString(std::to_string(i));
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
cmpq $0xa, %r14
jb 0x86b4b
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r14, %rcx
cmpq $0x63, %rcx
jbe 0x86b44
cmpq $0x3e7, %rcx # imm = 0x3E7
jbe 0x86b49
cmpq $0... | /jberkenbilt[P]qpdf/libqpdf/Pipeline.cc |
Pl_AES_PDF::setIV(unsigned char const*, unsigned long) | void
Pl_AES_PDF::setIV(unsigned char const* iv, size_t bytes)
{
if (bytes != this->buf_size) {
throw std::logic_error(
"Pl_AES_PDF: specified initialization vector"
" size in bytes must be " +
std::to_string(bytes));
}
this->use_specified_iv = true;
memcpy(thi... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpq $0x10, %rdx
jne 0x86e66
movb $0x1, 0xa1(%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x90(%rdi)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6c360
leaq 0x12f7a... | /jberkenbilt[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::finish() | void
Pl_AES_PDF::finish()
{
if (this->encrypt) {
if (this->offset == this->buf_size) {
flush(false);
}
if (!this->disable_padding) {
// Pad as described in section 3.5.1 of version 1.7 of the PDF specification, including
// providing an entire block of pad... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpb $0x1, 0x40(%rdi)
jne 0x87163
cmpq $0x10, %rax
jne 0x8711b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x86f8e
cmpb $0x0, 0xa2(%rbx)
jne 0x8719d
movl $0x10, %r14d
subq 0x48(%rbx), %r14
cmpq $0x100, %r14 # imm = 0x100
jb 0x8713f
movq %r14, %... | /jberkenbilt[P]qpdf/libqpdf/Pl_AES_PDF.cc |
Pl_AES_PDF::~Pl_AES_PDF() | ~Pl_AES_PDF() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x87262
callq 0x69e90
movq $0x0, 0x50(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x87278
callq 0x69d60
movq 0x1c1831(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x8729f
mov... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_AES_PDF.hh |
QIntC::IntConverter<unsigned long, unsigned char, false, false>::error(unsigned 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 unsigned type to a " << sizeof(To) << "-byte unsigned type";
throw... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d780
movq (%r14), %rax
movq -0x18(%rax), %r14
callq 0x688a0
leaq (%rsp,%r14), %rsi
addq $0x28, %rsi
movq %rsp, %rdi
movq %rax, %rdx
callq 0x6ac30
movq %rsp, %rdi
callq 0x6dba0
leaq ... | /jberkenbilt[P]qpdf/include/qpdf/QIntC.hh |
Pl_ASCII85Decoder::~Pl_ASCII85Decoder() | ~Pl_ASCII85Decoder() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x1c13d3(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x876fc
movq (%rax), %rsi
incq %rsi
callq 0x68760
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x68760
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_ASCII85Decoder.hh |
Pl_ASCIIHexDecoder::Pl_ASCIIHexDecoder(char const*, Pipeline*) | Pl_ASCIIHexDecoder::Pl_ASCIIHexDecoder(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_ASCIIHexDecoder with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6db00
leaq 0x1bb5fd(%rip), %rax # 0x242d20
movq %rax, (%rbx)
movw $0x3030, 0x30(%rbx) # imm = 0x3030
xorl %eax, %eax
movb %al, 0x32(%rbx)
movq $0x0, 0x38(%rbx)
movb %al, 0x40(%rbx)
testq %r14, %r14
je 0x87747
popq %rbx
popq %r14
popq %r15
r... | /jberkenbilt[P]qpdf/libqpdf/Pl_ASCIIHexDecoder.cc |
Pl_ASCIIHexDecoder::~Pl_ASCIIHexDecoder() | ~Pl_ASCIIHexDecoder() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x1c10bf(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x87a10
movq (%rax), %rsi
incq %rsi
callq 0x68760
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x68760
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_ASCIIHexDecoder.hh |
Pl_Base64::write(unsigned char const*, unsigned long) | void
Pl_Base64::write(unsigned char const* data, size_t len)
{
if (finished) {
throw std::logic_error("Pl_Base64 used after finished");
}
if (this->action == a_decode) {
decode(data, len);
} else {
encode(data, len);
}
} | pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x41(%rdi)
je 0x87af4
cmpl $0x1, 0x30(%rdi)
jne 0x87ae8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x87b3a
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x87ba0
movl $0x10, %edi
callq 0x6a000
movq %rax, %rbx
leaq 0x12ed54(%rip), %rsi # 0x1b685c
movq %rax, %rdi
callq 0x6c820
movq 0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::decode(unsigned char const*, unsigned long) | void
Pl_Base64::decode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
if (!util::is_space(to_c(*p))) {
this->buf[this->pos++] = *p;
if (this->pos == 4) {
flush();
}
}
++p;
--len;
}
... | testq %rdx, %rdx
je 0x87b9e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jae 0x87b6c
incq %r12
cmpq %r12, %rbx
jne 0x87b53
jmp 0x87b93
cmpl $0x20, %ecx
je 0x87b62
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::encode(unsigned char const*, unsigned long) | void
Pl_Base64::encode(unsigned char const* data, size_t len)
{
unsigned char const* p = data;
while (len > 0) {
this->buf[this->pos++] = *p;
if (this->pos == 3) {
flush();
}
++p;
--len;
}
} | testq %rdx, %rdx
je 0x87bf0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r14,%r12), %al
movq 0x38(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x38(%r15)
movb %al, 0x34(%r15,%rcx)
cmpq $0x3, 0x38(%r15)
jne 0x87bdd
movq %r15, %rdi
callq 0x... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Base64::finish() | void
Pl_Base64::finish()
{
if (this->pos > 0) {
if (finished) {
throw std::logic_error("Pl_Base64 used after finished");
}
if (this->action == a_decode) {
for (size_t i = this->pos; i < 4; ++i) {
this->buf[i] = '=';
}
}
flus... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x87ff8
cmpb $0x1, 0x41(%rbx)
je 0x8800d
cmpl $0x1, 0x30(%rbx)
setne %cl
cmpq $0x4, %rax
setae %dl
orb %cl, %dl
jne 0x87ff0
leaq (%rbx,%rax), %rdi
addq $0x34, %rdi
movl $0x4, %edx
subq %rax, %rdx
movl $0x3d, %esi
callq 0x69950
mo... | /jberkenbilt[P]qpdf/libqpdf/Pl_Base64.cc |
Pl_Buffer::Pl_Buffer(char const*, Pipeline*) | Pl_Buffer::Pl_Buffer(char const* identifier, Pipeline* next) :
Pipeline(identifier, next),
m(std::make_unique<Members>())
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6db00
movq 0x1c09a9(%rip), %rax # 0x248ba8
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x28, %edi
callq 0x68ab0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movb $0x1, (%rax)
movq %rax, %rdx
addq $0x18, %r... | /jberkenbilt[P]qpdf/libqpdf/Pl_Buffer.cc |
Pl_Buffer::write(unsigned char const*, unsigned long) | void
Pl_Buffer::write(unsigned char const* buf, size_t len)
{
if (!len) {
return;
}
m->data.append(reinterpret_cast<char const*>(buf), len);
m->ready = false;
if (next()) {
next()->write(buf, len);
}
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x88326
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rdi
addq $0x8, %rdi
callq 0x69be0
movq 0x30(%r15), %rax
movb $0x0, (%rax)
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x88326
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %r14, %rsi
movq %rbx, %r... | /jberkenbilt[P]qpdf/libqpdf/Pl_Buffer.cc |
Pl_Concatenate::Pl_Concatenate(char const*, Pipeline*) | Pl_Concatenate::Pl_Concatenate(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Concatenate with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6db00
movq 0x1c064d(%rip), %rax # 0x248c98
addq $0x10, %rax
movq %rax, (%rbx)
movq $0x0, 0x30(%rbx)
testq %r14, %r14
je 0x88665
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x6a000
movq %rax, %r15
leaq 0x12e32b(%rip), %rsi # 0x1... | /jberkenbilt[P]qpdf/libqpdf/Pl_Concatenate.cc |
Pl_Count::~Pl_Count() | Pl_Count::~Pl_Count() // NOLINT (modernize-use-equals-default)
{
// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
} | pushq %rbx
movq %rdi, %rbx
movq 0x1c063f(%rip), %rax # 0x248e90
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x8886b
movl $0x10, %esi
callq 0x68760
movq $0x0, 0x30(%rbx)
movq 0x1c0236(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cm... | /jberkenbilt[P]qpdf/libqpdf/Pl_Count.cc |
Pl_DCT::Pl_DCT(char const*, Pipeline*) | Pl_DCT::Pl_DCT(char const* identifier, Pipeline* next) :
Pipeline(identifier, next),
m(std::make_unique<Members>())
{
if (!next) {
throw std::logic_error("Attempt to create Pl_DCT with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6db00
movq 0x1c0642(%rip), %rax # 0x248f70
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x58, %edi
callq 0x68ab0
movq %rax, %r12
movl $0x1, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
leaq 0x12e247(%rip), %rsi # 0x1b6b9d
xorl %e... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::Pl_DCT(char const*, Pipeline*, unsigned int, unsigned int, int, J_COLOR_SPACE, Pl_DCT::CompressConfig*) | Pl_DCT::Pl_DCT(
char const* identifier,
Pipeline* next,
JDIMENSION image_width,
JDIMENSION image_height,
int components,
J_COLOR_SPACE color_space,
CompressConfig* compress_callback) :
Pipeline(identifier, next),
m(std::make_unique<Members>(
image_width, image_height, compone... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movq %rdi, %rbx
callq 0x6db00
movq 0x1c051e(%rip), %rax # 0x248f70
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x58, %edi
callq 0x68ab0
movq %rax, %r12
movl $0x0, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
leaq 0x12e138... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::compress(void*, Buffer*) | void
Pl_DCT::compress(void* cinfo_p, Buffer* b)
{
auto* cinfo = reinterpret_cast<jpeg_compress_struct*>(cinfo_p);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
jpeg_create_comp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r14
movl $0x248, %edx # imm = 0x248
movq %rsi, %rdi
movl $0x50, %esi
callq 0x6cda0
movl $0x10000, %ebx # imm = 0x10000
movl $0x10000, %edi # imm = 0x10000
callq 0... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::decompress(void*, Buffer*) | void
Pl_DCT::decompress(void* cinfo_p, Buffer* b)
{
auto* cinfo = reinterpret_cast<jpeg_decompress_struct*>(cinfo_p);
#if ((defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406) || defined(__clang__))
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
jpeg_create_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x290, %edx # imm = 0x290
movq %rsi, %rdi
movl $0x50, %esi
callq 0x6acc0
movq 0x1c418e(%rip), %rax # 0x24d320
testq %rax, %rax
jle 0x8919f
movq 0x8(%r14), %rcx
movq %rax, 0x58(%rcx... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_DCT::make_compress_config(std::function<void (jpeg_compress_struct*)>) | std::unique_ptr<Pl_DCT::CompressConfig>
Pl_DCT::make_compress_config(std::function<void(jpeg_compress_struct*)> f)
{
return std::make_unique<FunctionCallbackConfig>(f);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x68ab0
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x8975c
leaq 0x1b9b76(%rip), %rax # 0x242f20
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x18(%rsp), %rax
... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
skip_buffer_input_data(jpeg_decompress_struct*, long) | static void
skip_buffer_input_data(j_decompress_ptr cinfo, long num_bytes)
{
if (num_bytes < 0) {
throw std::runtime_error(
"reading jpeg: jpeg library requested skipping a negative number of bytes");
}
size_t to_skip = QIntC::to_size(num_bytes);
if ((to_skip > 0) && (to_skip <= cinf... | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x894f7
je 0x894ef
movq 0x28(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rdi
movq %rdi, %rcx
subq %rsi, %rcx
jae 0x894e5
addq %rdi, %rdx
movq %rdx, (%rax)
xorl %ecx, %ecx
jmp 0x894eb
addq %rsi, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
... | /jberkenbilt[P]qpdf/libqpdf/Pl_DCT.cc |
Pl_Discard::~Pl_Discard() | virtual ~Pipeline() = default; | movq 0x1bf2c3(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
addq $0x18, %rdi
cmpq %rdi, %rax
je 0x8980f
movq (%rdi), %rsi
incq %rsi
movq %rax, %rdi
jmp 0x68760
retq
| /jberkenbilt[P]qpdf/include/qpdf/Pipeline.hh |
Pl_Flate::zopfli_enabled() | bool
Pl_Flate::zopfli_enabled()
{
if (zopfli_supported()) {
std::string value;
static bool enabled = QUtil::get_env("QPDF_ZOPFLI", &value) && value != "disabled";
return enabled;
} else {
return false;
}
} | xorl %eax, %eax
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::Pl_Flate(char const*, Pipeline*, Pl_Flate::action_e, unsigned int) | Pl_Flate::Pl_Flate(
char const* identifier, Pipeline* next, action_e action, unsigned int out_bufsize_int) :
Pipeline(identifier, next),
m(std::make_unique<Members>(QIntC::to_size(out_bufsize_int), action))
{
if (!next) {
throw std::logic_error("Attempt to create Pl_Flate with nullptr as next");... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r15d
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6db00
movq 0x1bf1e9(%rip), %rax # 0x248c10
addq $0x10, %rax
movq %rax, (%rbx)
movl $0x58, %edi
callq 0x68ab0
movq %rax, %r12
movl %r15d, %esi
movq %rax, %rdi
movl %ebp, %edx
callq 0x8982c
l... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::~Pl_Flate() | Pl_Flate::~Pl_Flate() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x1bf119(%rip), %rax # 0x248c10
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x30, %rdi
callq 0x8a6d4
movq 0x1befa2(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x89b2e
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x687... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::handleData(unsigned char const*, unsigned long, int) | void
Pl_Flate::handleData(unsigned char const* data, size_t len, int flush)
{
if (len > UINT_MAX) {
throw std::runtime_error("Pl_Flate: zlib doesn't support data blocks larger than int");
}
z_stream& zstream = *(static_cast<z_stream*>(m->zdata));
// zlib is known not to modify the data pointed t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x8(%rsp)
movq %rdx, %rax
shrq $0x20, %rax
jne 0x89eb6
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq 0x20(%rax), %r15
movq %rsi, (%r15)
movl %edx, 0x8(%r15)
movq 0x30(%rdi), %rax
cmpb $0x0, 0x1c(%rax)
jne 0x89d3a
cmpl $0x1, 0x18(... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Flate::zopfli_check_env(QPDFLogger*) | bool
Pl_Flate::zopfli_check_env(QPDFLogger* logger)
{
if (Pl_Flate::zopfli_supported()) {
return true;
}
std::string value;
auto is_set = QUtil::get_env("QPDF_ZOPFLI", &value);
if (!is_set || value == "disabled" || value == "silent") {
return true;
}
if (!logger) {
lo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x12c89c(%rip), %rsi # 0x1b6e0d
leaq 0x12c8a0(%rip), %rdx # 0x1b6e18
movq %rsp, %rdi
callq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Flate.cc |
Pl_Function::write(unsigned char const*, unsigned long) | void
Pl_Function::write(unsigned char const* buf, size_t len)
{
m->fn(buf, len);
if (next()) {
next()->write(buf, len);
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq 0x30(%rdi), %rdi
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rdi)
je 0x8ae24
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq *0x18(%rdi)
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x8ae1a
movq (%rdi), %rax
movq ... | /jberkenbilt[P]qpdf/libqpdf/Pl_Function.cc |
Pl_LZWDecoder::Pl_LZWDecoder(char const*, Pipeline*, bool) | Pl_LZWDecoder::Pl_LZWDecoder(char const* identifier, Pipeline* next, bool early_code_change) :
Pipeline(identifier, next),
code_change_delta(early_code_change)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_LZWDecoder with nullptr as next");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x6db00
leaq 0x1b7dd1(%rip), %rax # 0x2430b8
movq %rax, (%rbx)
movw $0x0, 0x30(%rbx)
xorl %eax, %eax
movb %al, 0x32(%rbx)
movl $0x9, 0x34(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movb %bpl, 0x48(%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_OStream::~Pl_OStream() | Pl_OStream::~Pl_OStream() = default; | pushq %rbx
movq %rdi, %rbx
movq 0x1bcbbf(%rip), %rax # 0x248c20
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x8c07b
movl $0x8, %esi
callq 0x68760
movq $0x0, 0x30(%rbx)
movq 0x1bca26(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmp... | /jberkenbilt[P]qpdf/libqpdf/Pl_OStream.cc |
Pl_PNGFilter::Pl_PNGFilter(char const*, Pipeline*, Pl_PNGFilter::action_e, unsigned int, unsigned int, unsigned int) | Pl_PNGFilter::Pl_PNGFilter(
char const* identifier,
Pipeline* next,
action_e action,
unsigned int columns,
unsigned int samples_per_pixel,
unsigned int bits_per_sample) :
Pipeline(identifier, next),
action(action)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_PN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r15d
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
callq 0x6db00
leaq 0x1b708e(%rip), %rax # 0x243190
movq %rax, (%rbx)
movl %ebp, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::write(unsigned char const*, unsigned long) | void
Pl_PNGFilter::write(unsigned char const* data, size_t len)
{
size_t left = this->incoming - this->pos;
size_t offset = 0;
while (len >= left) {
// finish off current row
memcpy(this->cur_row + this->pos, data + offset, left);
offset += left;
len -= left;
process... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x78(%rdi), %r12
subq 0x70(%rdi), %r12
xorl %r13d, %r13d
cmpq %rdx, %r12
ja 0x8c415
movq 0x40(%r14), %rdi
addq 0x70(%r14), %rdi
leaq (%r15,%r13), %rsi
movq %r12, %rdx
callq 0x684e0
movq %r14, %rdi
callq 0x8c43e
m... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeRow() | void
Pl_PNGFilter::decodeRow()
{
int filter = this->cur_row[0];
if (this->prev_row) {
switch (filter) {
case 0:
break;
case 1:
this->decodeSub();
break;
case 2:
this->decodeUp();
break;
case 3:
this->... | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rcx
testq %rcx, %rcx
je 0x8c566
movq 0x40(%rbx), %rax
movzbl (%rax), %edx
decl %edx
cmpl $0x3, %edx
ja 0x8c566
leaq 0x12ad16(%rip), %rsi # 0x1b7210
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
cmpl $0x0, 0x34(%rbx)
je 0x8c566
movl 0x38(%rbx), %ecx
movl %ecx, %edx... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::PaethPredictor(int, int, int) | int
Pl_PNGFilter::PaethPredictor(int a, int b, int c)
{
int p = a + b - c;
int pa = abs_diff(p, a);
int pb = abs_diff(p, b);
int pc = abs_diff(p, c);
if (pa <= pb && pa <= pc) {
return a;
}
if (pb <= pc) {
return b;
}
return c;
} | movl %esi, %eax
leal (%rdx,%rax), %esi
subl %ecx, %esi
movl %esi, %edi
subl %eax, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl %esi, %edi
subl %edx, %edi
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
subl %ecx, %esi
movl %esi, %edi
negl %edi
cmovsl %esi, %edi
cmpl %edi, %r9d
cmoval %ecx, %edx
cmpl %edi, %r8d
cmo... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::~Pl_PNGFilter() | ~Pl_PNGFilter() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x8c75e
callq 0x69d60
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x8c76c
callq 0x69d60
movq 0x1bc33d(%rip), %rax # 0x248ab0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x8c793
movq (%rbx), %rsi
incq %r... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_PNGFilter.hh |
Pl_RC4::Pl_RC4(char const*, Pipeline*, unsigned char const*, int, unsigned long) | Pl_RC4::Pl_RC4(
char const* identifier,
Pipeline* next,
unsigned char const* key_data,
int key_len,
size_t out_bufsize) :
Pipeline(identifier, next),
out_bufsize(out_bufsize),
rc4(key_data, key_len)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_RC4 with nullptr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbx
callq 0x6db00
leaq 0x1b63e5(%rip), %rax # 0x243220
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq %r12... | /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.