name string | code string | asm string | file string |
|---|---|---|---|
ImStb::stb_textedit_delete_selection(ImGuiInputTextState*, ImStb::STB_TexteditState*) | static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
{
stb_textedit_clamp(str, state);
if (STB_TEXT_HAS_SELECTION(state)) {
if (state->select_start < state->select_end) {
stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfd168
leaq 0x4(%rbx), %r12
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %ecx
leaq 0x8(%rbx), %r15
movl %edx, %eax
subl %ecx, %eax
je 0xfd108
jge 0xfd0e8
subl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfd3f4
movq %r12, %rax
jm... | /abel0b[P]shadow/external/imgui/imstb_textedit.h |
main | int main(int argc, char **argv) {
char buffer[512];
short listen_port;
SOCKET listen_sock;
int rs;
struct sockaddr_in addr;
socklen_t addrlen;
struct pollfd pfd[2];
struct conn_t server;
struct conn_t client;
struct addrinfo *ai;
struct addrinfo hints;
/* initialize Winsock */
#if defined(_WIN32)
WSADATA ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
cmpl $0x4, %edi
jne 0x169f
movq %rsi, 0x88(%rsp)
movq 0x18(%rsi), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x1120
movswl %ax, %ecx
movl %ecx, 0x38(%rsp)
rolw $0x8, %ax
movw %ax, 0xe(%rsp)
pushq $0x2
popq ... | /seanmiddleditch[P]libtelnet/util/telnet-proxy.c |
event_handler | static void _event_handler(telnet_t *telnet, telnet_event_t *ev,
void *user_data) {
struct conn_t *conn = (struct conn_t*)user_data;
(void)telnet;
switch (ev->type) {
/* data received */
case TELNET_EV_DATA:
printf("%s DATA: ", conn->name);
print_buffer(ev->data.buffer, ev->data.size);
printf(COLOR_NORMA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rsi), %eax
cmpq $0xe, %rax
ja 0x1d7f
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x27b8(%rip), %rcx # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r14), %rsi
leaq 0x2ac2(%rip), %rdi # 0x433d
xorl %eax, %eax
cal... | /seanmiddleditch[P]libtelnet/util/telnet-proxy.c |
telnet_init | telnet_t *telnet_init(const telnet_telopt_t *telopts,
telnet_event_handler_t eh, unsigned char flags, void *user_data) {
/* allocate structure */
struct telnet_t *telnet = (telnet_t*)calloc(1, sizeof(telnet_t));
if (telnet == 0)
return 0;
/* initialize data */
telnet->ud = user_data;
telnet->telopts = telopt... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
callq 0x1100
testq %rax, %rax
je 0x1eb5
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
movb %bl, 0x3c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
... | /seanmiddleditch[P]libtelnet/libtelnet.c |
telnet_free | void telnet_free(telnet_t *telnet) {
/* free sub-request buffer */
if (telnet->buffer != 0) {
free(telnet->buffer);
telnet->buffer = 0;
telnet->buffer_size = 0;
telnet->buffer_pos = 0;
}
#if defined(HAVE_ZLIB)
/* free zlib box */
if (telnet->z != 0) {
if (telnet->flags & TELNET_PFLAG_DEFLATE)
deflate... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x1ee6
leaq 0x20(%rbx), %r14
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x18(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
| /seanmiddleditch[P]libtelnet/libtelnet.c |
telnet_recv | void telnet_recv(telnet_t *telnet, const char *buffer,
size_t size) {
#if defined(HAVE_ZLIB)
/* if we have an inflate (decompression) zlib stream, use it */
if (telnet->z != 0 && !(telnet->flags & TELNET_PFLAG_DEFLATE)) {
char inflate_buffer[1024];
int rs;
/* initialize zlib state */
telnet->z->next_in = (... | jmp 0x1f00
| /seanmiddleditch[P]libtelnet/libtelnet.c |
process | static void _process(telnet_t *telnet, const char *buffer, size_t size) {
telnet_event_t ev;
unsigned char byte;
size_t i, start;
for (i = start = 0; i != size; ++i) {
byte = buffer[i];
switch (telnet->state) {
/* regular data */
case TELNET_STATE_DATA:
/* on an IAC byte, pass through all pending bytes a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdi, %rbp
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %rdi, 0x10(%rsp)
cmpq %r14, 0x48(%rsp)
je 0x263f
movq 0x40(%rsp), %rax
movb (%rax,%r14), %r15b
movb %r15b, 0xf(%rsp)
movl 0x38(%rbp), %e... | /seanmiddleditch[P]libtelnet/libtelnet.c |
telnet_negotiate | void telnet_negotiate(telnet_t *telnet, unsigned char cmd,
unsigned char telopt) {
telnet_rfc1143_t q;
/* if we're in proxy mode, just send it now */
if (telnet->flags & TELNET_FLAG_PROXY) {
unsigned char bytes[3];
bytes[0] = TELNET_IAC;
bytes[1] = cmd;
bytes[2] = telopt;
_sendu(telnet, bytes, 3);
ret... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
testb $0x1, 0x3c(%rdi)
jne 0x2740
movzbl %dl, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2850
movzbl %bpl, %esi
addl $0xffffff05, %esi # imm = 0xFFFFFF05
cmpl $0x3, %esi
ja 0x275a
movzwl %ax, %ecx
movl %ecx, %edx
shrl $0x8, %edx
l... | /seanmiddleditch[P]libtelnet/libtelnet.c |
get_rfc1143 | static INLINE telnet_rfc1143_t _get_rfc1143(telnet_t *telnet,
unsigned char telopt) {
telnet_rfc1143_t empty;
unsigned int i;
/* search for entry */
for (i = 0; i != telnet->q_cnt; ++i) {
if (telnet->q[i].telopt == telopt) {
return telnet->q[i];
}
}
/* not found, return empty value */
empty.telopt = ... | movl 0x44(%rdi), %eax
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x2873
movq 0x18(%rdi), %rdx
movl %ecx, %r8d
incl %ecx
cmpb %sil, (%rdx,%r8,2)
jne 0x2855
movzbl 0x1(%rdx,%r8,2), %eax
shll $0x8, %eax
jmp 0x2875
xorl %eax, %eax
movzbl %sil, %ecx
orl %ecx, %eax
retq
| /seanmiddleditch[P]libtelnet/libtelnet.c |
set_rfc1143 | static INLINE void _set_rfc1143(telnet_t *telnet, unsigned char telopt,
char us, char him) {
telnet_rfc1143_t *qtmp;
unsigned int i;
/* search for entry */
for (i = 0; i != telnet->q_cnt; ++i) {
if (telnet->q[i].telopt == telopt) {
telnet->q[i].state = Q_MAKE(us,him);
if (telopt != TELNET_TELOPT_BINARY)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl 0x44(%rdi), %ecx
xorl %eax, %eax
cmpl %eax, %ecx
je 0x28db
movq 0x18(%rbx), %rdx
movl %eax, %esi
incl %eax
cmpb %r15b, (%rdx,%rsi,2)
jne 0x2893
movl %ebp, %eax
shlb $0x4, %al
orb %r14b, %al
movb... | /seanmiddleditch[P]libtelnet/libtelnet.c |
error | static telnet_error_t _error(telnet_t *telnet, unsigned line,
const char* func, telnet_error_t err, int fatal, const char *fmt,
...) {
telnet_event_t ev;
char buffer[512];
va_list va;
/* format informational text */
va_start(va, fmt);
vsnprintf(buffer, sizeof(buffer), fmt, va);
va_end(va);
/* send error e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2f0, %rsp # imm = 0x2F0
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
testb %al, %al
je 0x2d60
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %... | /seanmiddleditch[P]libtelnet/libtelnet.c |
telnet_printf | int telnet_printf(telnet_t *telnet, const char *fmt, ...) {
va_list va;
int rs;
va_start(va, fmt);
rs = telnet_vprintf(telnet, fmt, va);
va_end(va);
return rs;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2e31
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%... | /seanmiddleditch[P]libtelnet/libtelnet.c |
Kandinsky::BaseExpression::differentiate(Kandinsky::Variable const&) const | Expression BaseExpression::differentiate(const Variable& variable) const
{
return Expression(derivative(variable.getVariableExpressionPtr()));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x10f04
movq (%r14), %rax
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10edc
leaq 0x8(%rsp), %rdi
callq 0x1022c
l... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/BaseExpression.cpp |
std::shared_ptr<Kandinsky::BaseExpression> Kandinsky::BaseExpression::makePtr<Kandinsky::Variable>(Kandinsky::Variable const&) | std::shared_ptr<BaseExpression> BaseExpression::makePtr<Variable>(const Variable& arg)
{
return arg.getVariableExpressionPtr();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rsi
movq %rsp, %rdi
callq 0x10f04
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1022c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /lgpasquale[P]kandinsky/src/Kandinsky/expressions/BaseExpression.cpp |
Kandinsky::VariableExpression::derivative(std::shared_ptr<Kandinsky::VariableExpression> const&) const | BaseExpressionPtr VariableExpression::derivative(const VariableExpressionPtr& variable) const
{
return makePtr(Constant(variable.get() == this));
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq %rsi, (%rdx)
je 0x111c2
xorps %xmm0, %xmm0
jmp 0x111ca
movsd 0x2e5e(%rip), %xmm0 # 0x14028
leaq 0x8617(%rip), %rax # 0x197e8
addq $0x10, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movsd %xmm0, 0x8(%rsi)
andq $0x0, 0x18(%rsi)
leaq -0x500(%rip), %rax # 0x10cec
mo... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/VariableExpression.cpp |
Kandinsky::Expression Kandinsky::operator*<std::shared_ptr<Kandinsky::BaseExpression>, std::shared_ptr<Kandinsky::BaseExpression>, (void*)0>(std::shared_ptr<Kandinsky::BaseExpression> const&, std::shared_ptr<Kandinsky::BaseExpression> const&) | Expression
operator*(const Arg1T& arg1, const Arg2T& arg2)
{
BaseExpressionPtr arg1Ptr = BaseExpression::makePtr(arg1);
BaseExpressionPtr arg2Ptr = BaseExpression::makePtr(arg2);
if (arg1Ptr->isConstant() && arg2Ptr->isConstant())
return Expression(arg1Ptr->evaluate() * arg2P... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x106c0
movq %rsp, %rdi
movq %r15, %rsi
callq 0x106c0
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x11fec
movq (%rsp), %rdi
movq (%rdi), %r... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/MultiplicationExpression.hpp |
Kandinsky::MinusExpression::derivative(std::shared_ptr<Kandinsky::VariableExpression> const&) const | BaseExpressionPtr MinusExpression::derivative(const VariableExpressionPtr& variable) const
{
return makePtr(- m_arg->derivative(variable));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x12a2b
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1261a
leaq 0x10(%rsp), %rdi
callq 0x1255a
leaq 0x8(%rsp), %rdi
callq 0x1022c
mo... | /lgpasquale[P]kandinsky/src/Kandinsky/expressions/MinusExpression.cpp |
MPXTableSet::~MPXTableSet() | bool DoExecute(lldb::SBDebugger debugger, char **command,
lldb::SBCommandReturnObject &result) override {
if (command) {
int arg_c = 0;
char *arg[3];
while (*command) {
arg[arg_c] = *command;
command++;
arg_c++;
}
if (arg_c != 3) {
re... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7c0c0
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x72950
addq $0x18, %rsp
retq
nopl (%rax)
| /intel-features/intel-mpx/cli-wrapper-mpxtable.cpp |
void* llvm::StringMapEntryBase::allocateWithKey<llvm::MallocAllocator>(unsigned long, unsigned long, llvm::StringRef, llvm::MallocAllocator&) | void *StringMapEntryBase::allocateWithKey(size_t EntrySize, size_t EntryAlign,
StringRef Key,
AllocatorTy &Allocator) {
size_t KeyLength = Key.size();
// Allocate a new item with space for the string at the end and a null
// term... | subq $0x58, %rsp
movq %rdx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x87d70
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
addq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(... | /llvm/ADT/StringMapEntry.h |
llvm::safe_realloc(void*, unsigned long) | LLVM_ATTRIBUTE_RETURNS_NONNULL inline void *safe_realloc(void *Ptr, size_t Sz) {
void *Result = std::realloc(Ptr, Sz);
if (Result == nullptr) {
// It is implementation-defined whether allocation occurs if the space
// requested is zero (ISO/IEC 9899:2018 7.22.3). Retry, requesting
// non-zero, if the sp... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x727f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9aee4
cmpq $0x0, 0x10(%rsp)
jne 0x9aed3
movl $0x1, %edi
callq 0x9ac40
movq %rax, 0x20(%rsp)
jmp 0x9aeee
leaq 0x11e71a(%rip), %rdi # 0x1b95f4
movl $0x1... | /llvm/Support/MemAlloc.h |
llvm::detail::IEEEFloat::multiply(llvm::detail::IEEEFloat const&, llvm::RoundingMode) | IEEEFloat::opStatus IEEEFloat::multiply(const IEEEFloat &rhs,
roundingMode rounding_mode) {
opStatus fs;
sign ^= rhs.sign;
fs = multiplySpecials(rhs);
if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
sign = false;
if (isFiniteNonZero()) {
... | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %ecx
movb 0x14(%rdi), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
xorl %ecx, %eax
movb %al, ... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::divide(llvm::detail::IEEEFloat const&, llvm::RoundingMode) | IEEEFloat::opStatus IEEEFloat::divide(const IEEEFloat &rhs,
roundingMode rounding_mode) {
opStatus fs;
sign ^= rhs.sign;
fs = divideSpecials(rhs);
if (isZero() && semantics->nanEncoding == fltNanEncoding::NegativeZero)
sign = false;
if (isFiniteNonZero()) {
lost... | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movb 0x14(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %ecx
movb 0x14(%rdi), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
xorl %ecx, %eax
movb %al, ... | /Support/APFloat.cpp |
llvm::detail::DoubleAPFloat::compareAbsoluteValue(llvm::detail::DoubleAPFloat const&) const | APFloat::cmpResult
DoubleAPFloat::compareAbsoluteValue(const DoubleAPFloat &RHS) const {
auto Result = Floats[0].compareAbsoluteValue(RHS.Floats[0]);
if (Result != cmpEqual)
return Result;
Result = Floats[1].compareAbsoluteValue(RHS.Floats[1]);
if (Result == cmpLessThan || Result == cmpGreaterThan) {
au... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe33c0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe33c0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xe... | /Support/APFloat.cpp |
double llvm::bit_cast<double, unsigned long, void, void, void, void>(unsigned long const&) | [[nodiscard]] inline To bit_cast(const From &from) noexcept {
#if __has_builtin(__builtin_bit_cast)
return __builtin_bit_cast(To, from);
#else
To to;
std::memcpy(&to, &from, sizeof(To));
return to;
#endif
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
retq
nop
| /llvm/ADT/bit.h |
llvm::APFloat::Storage::Storage<llvm::APFloatBase::uninitializedTag>(llvm::fltSemantics const&, llvm::APFloatBase::uninitializedTag&&) | Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
if (usesLayout<IEEEFloat>(Semantics)) {
new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
return;
}
if (usesLayout<DoubleAPFloat>(Semantics)) {
new (&Double) DoubleAPFloat(Semantics, std::forward<Arg... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xa2770
testb $0x1, %al
jne 0xe994d
jmp 0xe9965
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl (%rax), %edx
callq 0x77700
jmp 0xe998d
movq 0x18... | /llvm/ADT/APFloat.h |
llvm::APIntOps::GreatestCommonDivisor(llvm::APInt, llvm::APInt) | APInt llvm::APIntOps::GreatestCommonDivisor(APInt A, APInt B) {
// Fast-path a common case.
if (A == B) return A;
// Corner cases: if either operand is zero, the other is the gcd.
if (!A) return B;
if (!B) return A;
// Count common powers of 2 and remove all other powers of 2.
unsigned Pow2;
{
uns... | subq $0x48, %rsp
movq %rdx, (%rsp)
movq %rsi, %rax
movq (%rsp), %rsi
movq %rax, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
callq 0xf2270
testb $0x1, %al
jne 0xf3183
jmp 0xf3197
movq 0x8(%rsp... | /Support/APInt.cpp |
llvm::APInt::srem(long) const | int64_t APInt::srem(int64_t RHS) const {
if (isNegative()) {
if (RHS < 0)
return -((-(*this)).urem(-RHS));
return -((-(*this)).urem(RHS));
}
if (RHS < 0)
return this->urem(-RHS);
return this->urem(RHS);
} | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xd6250
testb $0x1, %al
jne 0xf6e36
jmp 0xf6ee5
cmpq $0x0, 0x50(%rsp)
jge 0xf6e95
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xd61f0
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd6270
xorl %eax, %e... | /Support/APInt.cpp |
llvm::APInt::tcMSB(unsigned long const*, unsigned int) | unsigned APInt::tcMSB(const WordType *parts, unsigned n) {
do {
--n;
if (parts[n] != 0) {
static_assert(sizeof(parts[n]) <= sizeof(uint64_t));
unsigned msb = llvm::Log2_64(parts[n]);
return msb + n * APINT_BITS_PER_WORD;
}
} while (n);
return UINT_MAX;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0xf966f
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0xf9690
movl %eax, (%rsp)
movl (%rsp), %eax
movl 0x... | /Support/APInt.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | subq $0x68, %rsp
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movb $0x0, 0x33(%rsp)
movq %rsi, %rdi
addq $0x98, %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax... | /llvm/Support/CommandLine.h |
char const** llvm::SmallVectorImpl<char const*>::insert<char const**, void>(char const**, char const**, char const**) | iterator insert(iterator I, ItTy From, ItTy To) {
// Convert iterator to elt# to avoid invalidating iterator when we reserve()
size_t InsertElt = I - this->begin();
if (I == this->end()) { // Important special case for empty vector.
append(From, To);
return this->begin()+InsertElt;
}
... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x101ab0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x68(%rsp... | /llvm/ADT/SmallVector.h |
llvm::cl::ExpansionContext::readConfigFile(llvm::StringRef, llvm::SmallVectorImpl<char const*>&) | Error ExpansionContext::readConfigFile(StringRef CfgFile,
SmallVectorImpl<const char *> &Argv) {
SmallString<128> AbsPath;
if (sys::path::is_relative(CfgFile)) {
AbsPath.assign(CfgFile);
if (std::error_code EC = FS->makeAbsolute(AbsPath))
return make_error<String... | subq $0x178, %rsp # imm = 0x178
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x170(%rsp)
movq %rdx, 0x160(%rsp)
movq %rcx, 0x168(%rsp)
movq %rsi, 0x158(%rsp)
movq %r8, 0x150(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0xb2070
leaq 0x90(%rsp), %rdi
leaq ... | /Support/CommandLine.cpp |
llvm::cl::generic_parser_base::getOptionWidth(llvm::cl::Option const&) const | size_t generic_parser_base::getOptionWidth(const Option &O) const {
if (O.hasArgStr()) {
size_t Size =
argPlusPrefixesSize(O.ArgStr) + EqValue.size();
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
StringRef Name = getOption(i);
if (!shouldPrintOption(Name, getDescription(i), O))... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x107a10
testb $0x1, %al
jne 0x1077ba
jmp 0x107971
movq 0xb0(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x98(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rdi
movq... | /Support/CommandLine.cpp |
llvm::cl::PrintHelpMessage(bool, bool) | void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
if (!Hidden && !Categorized)
CommonOptions->UncategorizedNormalPrinter.printHelp();
else if (!Hidden && Categorized)
CommonOptions->CategorizedNormalPrinter.printHelp();
else if (Hidden && !Categorized)
CommonOptions->UncategorizedHiddenPrinte... | pushq %rax
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, 0x7(%rsp)
andb $0x1, %al
movb %al, 0x6(%rsp)
testb $0x1, 0x7(%rsp)
jne 0x109a88
testb $0x1, 0x6(%rsp)
jne 0x109a88
leaq 0x122d3f(%rip), %rdi # 0x22c7b8
callq 0x109b00
movq %rax, %rdi
callq 0x109b10
jmp 0x109af4
testb $0x1, 0x7(%rsp)
jne 0x109ab0
testb... | /Support/CommandLine.cpp |
(anonymous namespace)::HelpPrinter::printHelp() | void printHelp() {
SubCommand *Sub = GlobalParser->getActiveSubCommand();
auto &OptionsMap = Sub->OptionsMap;
auto &PositionalOpts = Sub->PositionalOpts;
auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
StrOptionPairVector Opts;
sortOpts(OptionsMap, Opts, ShowHidden);
StrSubCommandPairVector ... | subq $0x11a8, %rsp # imm = 0x11A8
movq %rdi, 0x11a0(%rsp)
movq 0x11a0(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x122c3d(%rip), %rdi # 0x22c770
callq 0xfe900
movq %rax, %rdi
callq 0xff370
movq %rax, 0x1198(%rsp)
movq 0x1198(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x1190(%rsp)
movq 0x1198(%rsp), %rax
addq $0x2... | /Support/CommandLine.cpp |
(anonymous namespace)::VersionPrinter::print(std::vector<std::function<void (llvm::raw_ostream&)>, std::allocator<std::function<void (llvm::raw_ostream&)>>>) | void print(std::vector<VersionPrinterTy> ExtraPrinters = {}) {
raw_ostream &OS = outs();
#ifdef PACKAGE_VENDOR
OS << PACKAGE_VENDOR << " ";
#else
OS << "LLVM (http://llvm.org/):\n ";
#endif
OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n ";
#if LLVM_IS_DEBUG_BUILD
OS << "DEBUG build";
... | subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
callq 0x78810
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0xb14b9(%rip), %rsi # 0x1bb922
callq 0x985c0
movq 0x30(%rsp), %rdi
leaq 0xb14c4(%rip), %rsi # 0x1bb93e
callq 0x985c0
movq %rax, %rdi
leaq 0xb14ba(%rip), %rsi # 0x1... | /Support/CommandLine.cpp |
llvm::ConvertUTF8toWide(unsigned int, llvm::StringRef, char*&, unsigned char const*&) | bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
char *&ResultPtr, const UTF8 *&ErrorPtr) {
assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
ConversionResult result = conversionOK;
// Copy the character span over.
if (WideCharWidth == 1) {
... | subq $0xa8, %rsp
movq %rsi, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movl %edi, 0x94(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
cmpl $0x1, 0x94(%rsp)
jne 0x11ed82
leaq 0x98(%rsp), %rdi
callq 0x8ffa0
movq %rax, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x8bdc0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq... | /Support/ConvertUTFWrapper.cpp |
llvm::CrashRecoveryContext::unregisterCleanup(llvm::CrashRecoveryContextCleanup*) | void
CrashRecoveryContext::unregisterCleanup(CrashRecoveryContextCleanup *cleanup) {
if (!cleanup)
return;
if (cleanup == head) {
head = cleanup->next;
if (head)
head->prev = nullptr;
}
else {
cleanup->prev->next = cleanup->next;
if (cleanup->next)
cleanup->next->prev = cleanup->... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x123425
jmp 0x1234b6
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
jne 0x123461
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x8(%rax)
cm... | /Support/CrashRecoveryContext.cpp |
llvm::isCurrentDebugType(char const*) | bool isCurrentDebugType(const char *DebugType) {
if (CurrentDebugType->empty())
return true;
// See if DebugType is in list. Note: do not use find() as that forces us to
// unnecessarily create an std::string instance.
for (auto &d : *CurrentDebugType) {
if (d == DebugType)
return true;
}
retu... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
leaq 0x108a58(%rip), %rdi # 0x22cb98
callq 0x1241f0
movq %rax, %rdi
callq 0x124200
testb $0x1, %al
jne 0x124153
jmp 0x12415d
movb $0x1, 0x37(%rsp)
jmp 0x1241df
leaq 0x108a34(%rip), %rdi # 0x22cb98
callq 0x124250
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1242a0
movq... | /Support/Debug.cpp |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>, unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned ... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x126c40
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x126c60
callq 0x126c80
movq (%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x126c90
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x126ca0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp)... | /llvm/ADT/DenseMap.h |
int llvm::array_pod_sort_comparator<llvm::StringRef>(void const*, void const*) | inline int array_pod_sort_comparator(const void *P1, const void *P2) {
if (std::less<T>()(*reinterpret_cast<const T*>(P1),
*reinterpret_cast<const T*>(P2)))
return -1;
if (std::less<T>()(*reinterpret_cast<const T*>(P2),
*reinterpret_cast<const T*>(P1)))
return 1;
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rdi
callq 0x12ba50
testb $0x1, %al
jne 0x12ba08
jmp 0x12ba12
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x12ba3e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0xe(%rsp), %rdi
callq 0x12b... | /llvm/ADT/STLExtras.h |
llvm::errorToErrorCode(llvm::Error) | std::error_code errorToErrorCode(Error Err) {
std::error_code EC;
handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
EC = EI.convertToErrorCode();
});
if (EC == inconvertibleErrorCode())
report_fatal_error(Twine(EC.message()));
return EC;
} | subq $0x88, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
callq 0xa82c0
movq (%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x9fe60
leaq 0x78(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x12c450
leaq 0x68(%rsp), %rdi
callq 0x9f720
callq 0x12c0b0
movl %eax, 0x50(%rs... | /Support/Error.cpp |
(anonymous namespace)::GraphSession::TryFindProgram(llvm::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool TryFindProgram(StringRef Names, std::string &ProgramPath) {
raw_string_ostream Log(LogBuffer);
SmallVector<StringRef, 8> parts;
Names.split(parts, '|');
for (auto Name : parts) {
if (ErrorOr<std::string> P = sys::findProgramByName(Name)) {
ProgramPath = *P;
return true;
... | subq $0x178, %rsp # imm = 0x178
movq %rsi, 0x160(%rsp)
movq %rdx, 0x168(%rsp)
movq %rdi, 0x158(%rsp)
movq %rcx, 0x150(%rsp)
movq 0x158(%rsp), %rsi
leaq 0x118(%rsp), %rdi
callq 0xa1e70
leaq 0x88(%rsp), %rdi
callq 0xbf030
leaq 0x160(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movl $0x7c, %edx
movl $0xffffffff, %ecx ... | /Support/GraphWriter.cpp |
llvm::cl::opt<unsigned long, false, llvm::cl::parser<unsigned long>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, 0x37(%rsp)
movb %al, 0x1f(%rsp)
jne 0x13abae
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x13b390
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%r... | /llvm/Support/CommandLine.h |
llvm::initStatisticOptions() | void llvm::initStatisticOptions() {
static cl::opt<bool, true> registerEnableStats{
"stats",
cl::desc(
"Enable statistics output from program (available with Asserts)"),
cl::location(EnableStats), cl::Hidden};
static cl::opt<bool, true> registerStatsAsJson{
"stats-json", cl::desc("... | subq $0x68, %rsp
cmpb $0x0, 0xef57d(%rip) # 0x22cf98
jne 0x13dabc
leaq 0xef570(%rip), %rdi # 0x22cf98
callq 0x741f0
cmpl $0x0, %eax
je 0x13dabc
leaq 0x48(%rsp), %rdi
leaq 0x7e4d4(%rip), %rsi # 0x1bbf16
callq 0x7e720
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0xcc390
leaq 0xef53e... | /Support/Statistic.cpp |
llvm::NamedRegionTimer::NamedRegionTimer(llvm::StringRef, llvm::StringRef, llvm::StringRef, llvm::StringRef, bool) | NamedRegionTimer::NamedRegionTimer(StringRef Name, StringRef Description,
StringRef GroupName,
StringRef GroupDescription, bool Enabled)
: TimeRegion(!Enabled ? nullptr
: &NamedGroupedTimers->get(Name, Description, GroupName,
... | subq $0xb8, %rsp
movb %r9b, %al
leaq 0xd0(%rsp), %r9
movq %r9, 0x30(%rsp)
leaq 0xc0(%rsp), %r9
movq %r9, 0x38(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
andb $0x1, %al
movb %al, 0x8f(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
testb $0x1, 0x8... | /Support/Timer.cpp |
llvm::vfs::RedirectingFileSystem::status(llvm::Twine const&) | ErrorOr<Status> RedirectingFileSystem::status(const Twine &OriginalPath) {
SmallString<256> Path;
OriginalPath.toVector(Path);
if (std::error_code EC = makeAbsolute(Path))
return EC;
if (Redirection == RedirectKind::Fallback) {
// Attempt to find the original file first, only falling back to the
/... | subq $0x408, %rsp # imm = 0x408
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x400(%rsp)
movq %rsi, 0x3f8(%rsp)
movq %rdx, 0x3f0(%rsp)
movq 0x3f8(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x2d8(%rsp), %rdi
callq 0xa4b00
movq 0x3f0(%rsp), %rdi
leaq 0x2d8(%rsp), %rsi
callq 0x73970
movq 0... | /Support/VirtualFileSystem.cpp |
(anonymous namespace)::RealFileSystem::adjustPath(llvm::Twine const&, llvm::SmallVectorImpl<char>&) const | Twine adjustPath(const Twine &Path, SmallVectorImpl<char> &Storage) const {
if (!WD || !*WD)
return Path;
Path.toVector(Storage);
sys::fs::make_absolute(WD->get().Resolved, Storage);
return Storage;
} | subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x15f8c0
testb $0x1, %al
jne 0x15f825
jmp 0x15f83f
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x15f8e0
movq %rax, %rdi
callq 0x15... | /Support/VirtualFileSystem.cpp |
llvm::DenseMapIterator<llvm::StringRef, llvm::vfs::RedirectingFileSystemParser::KeyStatus, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseMapPair<llvm::StringRef, llvm::vfs::RedirectingFileSystemParser::KeyStatus>, false>::RetreatPastEmptyBuckets() | void RetreatPastEmptyBuckets() {
assert(Ptr >= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
-... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x146620
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
callq 0x146650
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x167e60
movq 0x8(%rs... | /llvm/ADT/DenseMap.h |
std::pair<llvm::StringMapIterator<llvm::vfs::RedirectingFileSystem::Entry*>, bool> llvm::StringMap<llvm::vfs::RedirectingFileSystem::Entry*, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int) | std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo]... | subq $0xc8, %rsp
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x90(%rsp)
movl 0x9c(%rsp), %ecx
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x77d80
mov... | /llvm/ADT/StringMap.h |
llvm::vfs::RedirectingFileSystem::Entry* const* llvm::SmallVectorTemplateCommon<llvm::vfs::RedirectingFileSystem::Entry*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::vfs::RedirectingFileSystem::Entry*, true>>(llvm::SmallVectorTemplateBase<llvm::vfs::RedirectingFileSystem::Entry*, true>*,... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x77b60
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x72eb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x1778d4
movq 0x30(%rs... | /llvm/ADT/SmallVector.h |
encodeUTF8(unsigned int, llvm::SmallVectorImpl<char>&) | static void encodeUTF8( uint32_t UnicodeScalarValue
, SmallVectorImpl<char> &Result) {
if (UnicodeScalarValue <= 0x7F) {
Result.push_back(UnicodeScalarValue & 0x7F);
} else if (UnicodeScalarValue <= 0x7FF) {
uint8_t FirstByte = 0xC0 | ((UnicodeScalarValue & 0x7C0) >> 6);
uint8_t Se... | subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x7f, 0x24(%rsp)
ja 0x17ed3d
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %eax
andl $0x7f, %eax
movsbl %al, %esi
callq 0xa4dc0
jmp 0x17eea4
cmpl $0x7ff, 0x24(%rsp) # imm = 0x7FF
ja 0x17ed8f
movl 0x24(%rsp), %eax
andl $0x7c0, %eax # imm = 0x7C0... | /Support/YAMLParser.cpp |
llvm::yaml::Scanner::scanDirective() | bool Scanner::scanDirective() {
// Reset the indentation level.
unrollIndent(-1);
SimpleKeys.clear();
IsSimpleKeyAllowed = false;
IsAdjacentValueAllowedInFlow = false;
StringRef::iterator Start = Current;
consume('%');
StringRef::iterator NameStart = Current;
Current = skip_while(&Scanner::skip_ns_ch... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x138(%rsp)
movq 0x138(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x1812e0
movq 0x10(%rsp), %rdi
addq $0xe0, %rdi
callq 0x1802a0
movq 0x10(%rsp), %rdi
movb $0x0, 0x49(%rdi)
movb $0x0, 0x4a(%rdi)
movq 0x28(%rdi), %rax
movq... | /Support/YAMLParser.cpp |
llvm::yaml::Document::skip() | bool Document::skip() {
if (stream.scanner->failed())
return false;
if (!Root && !getRoot())
return false;
Root->skip();
Token &T = peekNext();
if (T.Kind == Token::TK_StreamEnd)
return false;
if (T.Kind == Token::TK_DocumentEnd) {
getNext();
return skip();
}
return true;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rdi
callq 0x1847d0
movq %rax, %rdi
callq 0x1847e0
testb $0x1, %al
jne 0x184c88
jmp 0x184c92
movb $0x0, 0x57(%rsp)
jmp 0x184d18
movq (%rsp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x184cb3
movq (%rsp), %rdi
callq 0x157350
cmpq $0x0, %ra... | /Support/YAMLParser.cpp |
MakeErrMsg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | static inline bool MakeErrMsg(
std::string* ErrMsg, const std::string& prefix, int errnum = -1) {
if (!ErrMsg)
return true;
if (errnum == -1)
errnum = errno;
*ErrMsg = prefix + ": " + llvm::sys::StrError(errnum);
return true;
} | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x18f9c7
movb $0x1, 0x87(%rsp)
jmp 0x18fa46
cmpl $-0x1, 0x6c(%rsp)
jne 0x18f9d9
callq 0x789c0
movl (%rax), %eax
movl %eax, 0x6c(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x2bfff(%rip), %rdx # 0x... | /Support/Unix/Unix.h |
llvm::SourceMgr::SrcBuffer::getPointerForLineNumber(unsigned int) const | const char *
SourceMgr::SrcBuffer::getPointerForLineNumber(unsigned LineNo) const {
size_t Sz = Buffer->getBufferSize();
if (Sz <= std::numeric_limits<uint8_t>::max())
return getPointerForLineNumberSpecialized<uint8_t>(LineNo);
else if (Sz <= std::numeric_limits<uint16_t>::max())
return getPointerForLineN... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xc73b0
movq %rax, %rdi
callq 0xc8b90
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x191e00
movb %al, %cl
movq 0x20(%rsp), %rax
movzbl %cl, %ecx
cmpq %rcx, %rax
ja 0x19213c
movq 0x18... | /Support/SourceMgr.cpp |
buildFixItLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, llvm::ArrayRef<llvm::SMFixIt>, llvm::ArrayRef<char>) | static void buildFixItLine(std::string &CaretLine, std::string &FixItLine,
ArrayRef<SMFixIt> FixIts,
ArrayRef<char> SourceLine) {
if (FixIts.empty())
return;
const char *LineStart = SourceLine.begin();
const char *LineEnd = SourceLine.end();
size_t Pre... | subq $0x108, %rsp # imm = 0x108
movq %rdx, 0xf8(%rsp)
movq %rcx, 0x100(%rsp)
movq %r8, 0xe8(%rsp)
movq %r9, 0xf0(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x1957e0
testb $0x1, %al
jne 0x194eda
jmp 0x194edf
jmp 0x1951f2
leaq 0xe8(%rsp), %rdi
callq 0x11f390
movq %rax, 0xd0(%... | /Support/SourceMgr.cpp |
std::vector<unsigned int, std::allocator<unsigned int>>& GetOrCreateOffsetCache<unsigned int>(void*&, llvm::MemoryBuffer*) | static std::vector<T> &GetOrCreateOffsetCache(void *&OffsetCache,
MemoryBuffer *Buffer) {
if (OffsetCache)
return *static_cast<std::vector<T> *>(OffsetCache);
// Lazily fill in the offset cache.
auto *Offsets = new std::vector<T>();
size_t Sz = Buffer->getBuffe... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1969bb
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x196a7d
movl $0x18, %edi
callq 0x72d00
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x73e90
movq 0x8(%rsp), %... | /Support/SourceMgr.cpp |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::resolveForwardTemplateRefs(llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocat... | bool resolveForwardTemplateRefs(NameState &State) {
size_t I = State.ForwardTemplateRefsBegin;
size_t E = ForwardTemplateRefs.size();
for (; I < E; ++I) {
size_t Idx = ForwardTemplateRefs[I]->Index;
if (TemplateParams.empty() || !TemplateParams[0] ||
Idx >= TemplateParams[0]->size())
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
addq $0x2d0, %rdi # imm = 0x2D0
callq 0x1a1030
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x19eb31
movq 0x10(%r... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseSeqId(unsigned long*) | bool AbstractManglingParser<Alloc, Derived>::parseSeqId(size_t *Out) {
if (!(look() >= '0' && look() <= '9') &&
!(look() >= 'A' && look() <= 'Z'))
return true;
size_t Id = 0;
while (true) {
if (look() >= '0' && look() <= '9') {
Id *= 36;
Id += static_cast<size_t>(look() - '0');
} el... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x19cc10
movsbl %al, %eax
cmpl $0x30, %eax
jl 0x19fd99
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x19cc10
movsbl %al, %eax
cmpl $0x39, %eax
jle 0x19fdc9
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x19cc... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::FloatLiteralImpl<float>::printLeft(llvm::itanium_demangle::OutputBuffer&) const | void printLeft(OutputBuffer &OB) const override {
const size_t N = FloatData<Float>::mangled_size;
if (Contents.size() >= N) {
union {
Float value;
char buf[sizeof(Float)];
};
const char *t = Contents.data();
const char *last = t + N;
char *e = buf;
for (; t !... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x8, 0x70(%rsp)
addq $0x10, %rdi
callq 0x110370
cmpq $0x8, %rax
jb 0x1a9793
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x110360
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x58(%rs... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseBaseUnresolvedName() | Node *AbstractManglingParser<Derived, Alloc>::parseBaseUnresolvedName() {
if (std::isdigit(look()))
return getDerived().parseSimpleId();
if (consumeIf("dn"))
return getDerived().parseDestructorName();
consumeIf("on");
Node *Oper = getDerived().parseOperatorName(/*NameState=*/nullptr);
if (Oper == n... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x19cc10
movsbl %al, %edi
callq 0x7a118
cmpl $0x0, %eax
je 0x1ae311
movq (%rsp), %rdi
callq 0x19c6b0
movq %rax, %rdi
callq 0x1ae1e0
movq %rax, 0x40(%rsp)
jmp 0x1ae409
leaq 0x28(%rsp), %rdi
leaq 0x123f1(%rip), %rsi #... | /llvm/Demangle/ItaniumDemangle.h |
CircuitOramOpt::access(int) | bool access(int identifier)
{
bool res = readAndRemove(identifier);
stash->add(identifier);
update_pos(identifier);
cnt2++;
if(cnt2 == naccess) {
cnt2 = 0;
for(int i = 0; i < nevict; ++i) {
flush(reverse_order());
}
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %esi
callq 0xc440
movb %al, %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x1b(%rsp)
movq 0x13d0(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0xc4e0
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x... | /wangxiao1254[P]oram_simulator/circuit_oram_opt/circuit_oram_opt.h |
Pl_LZWDecoder::handleCode(unsigned int) | void
Pl_LZWDecoder::handleCode(unsigned int code)
{
if (this->eod) {
return;
}
if (code == 256) {
if (!this->table.empty()) {
QTC::TC("libtests", "Pl_LZWDecoder intermediate reset");
}
this->table.clear();
this->code_size = 9;
} else if (code == 257) ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x49(%rdi)
jne 0x35c42
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x101, %esi # imm = 0x101
je 0x35b2e
cmpl $0x100, %ebx # imm = 0x100
jne 0x35b38
movq 0x50(%r14), %r12
movq 0x58(%r14), %r13
cmpq %r13, %r12
je 0x35b21
mo... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::getFirstChar(unsigned int) | unsigned char
Pl_LZWDecoder::getFirstChar(unsigned int code)
{
unsigned char result = '\0';
if (code < 256) {
result = static_cast<unsigned char>(code);
} else if (code > 257) {
unsigned int idx = code - 258;
if (idx >= table.size()) {
throw std::runtime_error("Pl_LZWDeco... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
cmpl $0xff, %esi
jbe 0x35d1b
cmpl $0x102, %r14d # imm = 0x102
jb 0x35d29
addl $0xfffffefe, %r14d # imm = 0xFFFFFEFE
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x35d8b
leaq (%... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::addToTable(unsigned char) | void
Pl_LZWDecoder::addToTable(unsigned char c)
{
unsigned int last_size = 0;
unsigned char const* last_data = nullptr;
unsigned char tmp[1];
if (this->last_code < 256) {
tmp[0] = static_cast<unsigned char>(this->last_code);
last_data = tmp;
last_size = 1;
} else if (this->l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl 0x68(%rdi), %eax
cmpl $0xff, %eax
ja 0x35ecb
leaq 0x7(%rsp), %r15
movb %al, (%r15)
movl $0x1, %r12d
jmp 0x35f1b
cmpl $0x102, %eax # imm = 0x102
jb 0x35f78
addl $0xfffffefe, %eax # imm... | /jberkenbilt[P]qpdf/libqpdf/Pl_LZWDecoder.cc |
Pl_LZWDecoder::~Pl_LZWDecoder() | ~Pl_LZWDecoder() final = default; | pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0x360fc
leaq 0x1b3988(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x361f4
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_LZWDecoder.hh |
Pl_MD5::Pl_MD5(char const*, Pipeline*) | Pl_MD5::Pl_MD5(char const* identifier, Pipeline* next) :
Pipeline(identifier, next)
{
if (!next) {
throw std::logic_error("Attempt to create Pl_MD5 with nullptr as next");
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x30a50
leaq 0x1b4229(%rip), %rax # 0x1ea5f8
movq %rax, (%rbx)
movb $0x0, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
callq 0x29a4c
movw $0x1, 0x48(%rbx)
testq %r14, %r14
je 0x363f0
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x193f0
movq %rax... | /jberkenbilt[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::write(unsigned char const*, unsigned long) | void
Pl_MD5::write(unsigned char const* buf, size_t len)
{
if (this->enabled) {
if (!this->in_progress) {
this->md5.reset();
this->in_progress = true;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
cmpb $0x1, 0x48(%rdi)
jne 0x364e4
cmpb $0x0, 0x30(%r15)
jne 0x364a6
leaq 0x38(%r15), %rdi
callq 0x29adc
movb $0x1, 0x30(%r15)
cmpq $0x0, 0x8(%rsp)
je 0x364e4
leaq 0x38(%r15), %r1... | /jberkenbilt[P]qpdf/libqpdf/Pl_MD5.cc |
Pl_MD5::~Pl_MD5() | ~Pl_MD5() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x365ac
callq 0x1ed58
leaq 0x1b35ad(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x365cf
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_MD5.hh |
Pl_OStream::Pl_OStream(char const*, std::ostream&) | Pl_OStream::Pl_OStream(char const* identifier, std::ostream& os) :
Pipeline(identifier, nullptr),
m(std::make_unique<Members>(os))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x30a50
leaq 0x1b403c(%rip), %rax # 0x1ea640
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x19180
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x1b3536(%rip), %rax # 0x1e9b60
... | /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 0x30a50
leaq 0x1b3f96(%rip), %rax # 0x1ea688
movq %rax, (%rbx)
movl %ebp, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::write(unsigned char const*, unsigned long) | void
Pl_PNGFilter::write(unsigned char const* data, size_t len)
{
size_t left = this->incoming - this->pos;
size_t offset = 0;
while (len >= left) {
// finish off current row
memcpy(this->cur_row + this->pos, data + offset, left);
offset += left;
len -= left;
process... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x70(%rdi), %rdi
movq 0x78(%r14), %r13
subq %rdi, %r13
cmpq %rdx, %r13
jbe 0x369b1
xorl %ebp, %ebp
movq %rdi, %r12
jmp 0x36a10
xorl %r12d, %r12d
xorl %ebp, %ebp
addq 0x40(%r14), %rdi
leaq (%... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::encodeRow() | void
Pl_PNGFilter::encodeRow()
{
// For now, hard-code to using UP filter.
unsigned char ch = 2;
next()->write(&ch, 1);
if (this->prev_row) {
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
ch = static_cast<unsigned char>(this->cur_row[i] - this->prev_row[i]);
ne... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb $0x2, (%rsi)
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x36abf
cmpl $0x0, 0x34(%rbx)
je 0x36ad0
xorl %r15d, %r15d
leaq 0xf(%rsp), %r14
movq 0x40(%rbx), %rax
movq 0x48(%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeSub() | void
Pl_PNGFilter::decodeSub()
{
QTC::TC("libtests", "Pl_PNGFilter decodeSub");
unsigned char* buffer = this->cur_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
unsigned char left = 0;
if (i >= bpp) {
left = buffe... | cmpl $0x0, 0x34(%rdi)
je 0x36bbb
movq 0x40(%rdi), %rax
movl 0x38(%rdi), %ecx
movl %ecx, %edx
negl %edx
xorl %esi, %esi
cmpq %rcx, %rsi
jae 0x36ba1
xorl %r8d, %r8d
jmp 0x36baa
leal (%rdx,%rsi), %r8d
movb 0x1(%rax,%r8), %r8b
addb %r8b, 0x1(%rax,%rsi)
incq %rsi
movl 0x34(%rdi), %r8d
cmpq %r8, %rsi
jb 0x36b97
retq
| /jberkenbilt[P]qpdf/libqpdf/Pl_PNGFilter.cc |
Pl_PNGFilter::decodeAverage() | void
Pl_PNGFilter::decodeAverage()
{
QTC::TC("libtests", "Pl_PNGFilter decodeAverage");
unsigned char* buffer = this->cur_row + 1;
unsigned char* above_buffer = this->prev_row + 1;
unsigned int bpp = this->bytes_per_pixel;
for (unsigned int i = 0; i < this->bytes_per_row; ++i) {
int left = ... | cmpl $0x0, 0x34(%rdi)
je 0x36c2f
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movl 0x38(%rdi), %edx
movl %edx, %esi
negl %esi
xorl %r8d, %r8d
cmpq %rdx, %r8
jae 0x36c04
xorl %r9d, %r9d
jmp 0x36c0e
leal (%rsi,%r8), %r9d
movzbl 0x1(%rax,%r9), %r9d
movzbl 0x1(%rcx,%r8), %r10d
movzwl %r9w, %r9d
addl %r10d, %r9d
shrl %r9d
ad... | /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 0x36d64
callq 0x1ed58
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x36d72
callq 0x1ed58
leaq 0x1b2de7(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x36d95
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_PNGFilter.hh |
Pl_QPDFTokenizer::finish() | void
Pl_QPDFTokenizer::finish()
{
m->buf.finish();
auto input = BufferInputSource("tokenizer data", m->buf.getBuffer(), true);
std::string empty;
while (true) {
auto token = m->tokenizer.readToken(input, empty, true);
m->filter->handleToken(token);
if (token.getType() == QPDFToke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
addq $0x10, %rdi
callq 0x329ba
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1283e7(%rip), %rsi # 0x15f346
leaq 0x1283ee(%rip), %rdx # 0x15f354
leaq 0x50(%rsp), ... | /jberkenbilt[P]qpdf/libqpdf/Pl_QPDFTokenizer.cc |
QPDFTokenizer::Token::~Token() | Token() :
type(tt_bad)
{
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x3735c
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x37374
movq (%rax), %rsi
incq %rsi
callq 0x190e0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3738d
mo... | /jberkenbilt[P]qpdf/include/qpdf/QPDFTokenizer.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 0x30a50
leaq 0x1b32ed(%rip), %rax # 0x1ea718
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %r14, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq %r12... | /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RC4::write(unsigned char const*, unsigned long) | void
Pl_RC4::write(unsigned char const* data, size_t len)
{
if (this->outbuf == nullptr) {
throw std::logic_error(this->identifier + ": Pl_RC4: write() called after finish() called");
}
size_t bytes_left = len;
unsigned char const* p = data;
while (bytes_left > 0) {
size_t bytes = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0x3759a
movq %rdx, %rbx
testq %rdx, %rdx
je 0x3758b
movq %rsi, %r15
leaq 0x48(%r14), %r12
movq 0x30(%r14), %rcx
movq 0x40(%r14), %r13
cmpq %r13, %rbx
cmovbq %rbx, %r13
movq %r12, %rdi
movq %r15, %... | /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RC4::finish() | void
Pl_RC4::finish()
{
outbuf = nullptr;
next()->finish();
} | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x38(%rdi), %rdi
movups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0x37639
callq 0x1ed58
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
| /jberkenbilt[P]qpdf/libqpdf/Pl_RC4.cc |
Pl_RC4::~Pl_RC4() | ~Pl_RC4() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x37656
callq 0x1ed58
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x37664
callq 0x1ed58
leaq 0x1b24f5(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x37687
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp ... | /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_RC4.hh |
Pl_RunLength::Pl_RunLength(char const*, Pipeline*, Pl_RunLength::action_e) | Pl_RunLength::Pl_RunLength(char const* identifier, Pipeline* next, action_e action) :
Pipeline(identifier, next),
m(std::make_unique<Members>(action))
{
if (!next) {
throw std::logic_error("Attempt to create Pl_RunLength with nullptr as next");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %rbx
callq 0x30a50
leaq 0x1b30a0(%rip), %rax # 0x1ea760
movq %rax, (%rbx)
movl $0xb0, %edi
callq 0x19180
leaq 0x30(%rbx), %r14
movl %ebp, (%rax)
xorl %ecx, %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x88(%rax)
movq %rax, %rcx... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::~Pl_RunLength() | Pl_RunLength::~Pl_RunLength() // NOLINT (modernize-use-equals-default)
{
// Must be explicit and not inline -- see QPDF_DLL_CLASS in README-maintainer
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1b2fb3(%rip), %rax # 0x1ea760
movq %rax, (%rdi)
movq 0x30(%rdi), %rsi
testq %rsi, %rsi
je 0x377c2
leaq 0x30(%rbx), %rdi
callq 0x37c56
movq $0x0, 0x30(%rbx)
leaq 0x1b238f(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x377ed
movq... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::encode(unsigned char const*, unsigned long) | void
Pl_RunLength::encode(unsigned char const* data, size_t len)
{
for (size_t i = 0; i < len; ++i) {
if ((m->state == st_top) != (m->length <= 1)) {
throw std::logic_error("Pl_RunLength::encode: state/length inconsistency");
}
unsigned char ch = data[i];
if ((m->length >... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x37912
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rax
xorl %r12d, %r12d
movl 0x4(%rax), %edx
movl 0x88(%rax), %ecx
testl %edx, %edx
sete %sil
cmpl $0x2, %ecx
setae %dil
xorb %sil, %dil
je 0x3791b
movb (%r14,%r12), %bpl
te... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::decode(unsigned char const*, unsigned long) | void
Pl_RunLength::decode(unsigned char const* data, size_t len)
{
if (memory_limit && (len + m->out.size()) > memory_limit) {
throw std::runtime_error("Pl_RunLength memory limit exceeded");
}
m->out.reserve(len);
for (size_t i = 0; i < len; ++i) {
unsigned char const& ch = data[i];
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1b97b0(%rip), %rax # 0x1f1128
movq 0x30(%rdi), %rdi
testq %rax, %rax
je 0x37994
movq 0x98(%rdi), %rcx
addq %rbx, %rcx
cmpq %rax, %rcx
ja 0x37a70
addq $0x90, %rdi
movq %rbx, %rsi
callq 0x19950
testq %rbx, %rb... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_RunLength::finish() | void
Pl_RunLength::finish()
{
// When decoding, we might have read a length byte not followed by data, which means the stream
// was terminated early, but we will just ignore this case since this is the only sensible thing
// to do.
if (m->action == a_encode) {
flush_encode();
unsigned c... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
cmpl $0x0, (%rsi)
je 0x37bdf
movq 0x1b9569(%rip), %rax # 0x1f1128
testq %rax, %rax
je 0x37bcd
cmpq %rax, 0x98(%rsi)
ja 0x37c10
movq 0x28(%rbx), %rdi
addq $0x90, %rsi
callq 0x30b7c
jmp 0x37bfe
movq %rbx, %rdi
callq 0x37ab6
leaq 0x7(%rsp), %rsi
mov... | /jberkenbilt[P]qpdf/libqpdf/Pl_RunLength.cc |
Pl_SHA2::resetBits(int) | void
Pl_SHA2::resetBits(int bits)
{
if (this->in_progress) {
throw std::logic_error("bit reset requested for in-progress SHA2 Pipeline");
}
this->crypto = QPDFCryptoProvider::getImpl();
this->crypto->SHA2_init(bits);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x30(%rdi)
je 0x37d4c
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x62d9c
movaps (%r15), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r15)
movq 0x40(%r14), %rdi
movups %xmm0, 0x38(%r14)
testq %rdi, %rdi
je 0x37d36
callq 0x1ed58
movq 0x8(... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::write(unsigned char const*, unsigned long) | void
Pl_SHA2::write(unsigned char const* buf, size_t len)
{
if (!this->in_progress) {
this->in_progress = true;
}
// Write in chunks in case len is too big to fit in an int. Assume int is at least 32 bits.
static size_t const max_bytes = 1 << 30;
size_t bytes_left = len;
unsigned char c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, %r15
cmpb $0x0, 0x30(%rdi)
jne 0x37db2
movb $0x1, 0x30(%r15)
testq %r14, %r14
je 0x37de8
movl $0x40000000, %ebp # imm = 0x40000000
movq %r14, %rbx
movq (%rsp), %r12
cmpq %rbp, %rbx
movl $0x400... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::finish() | void
Pl_SHA2::finish()
{
if (next()) {
next()->finish();
}
this->crypto->SHA2_finalize();
this->in_progress = false;
} | pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x37e31
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movb $0x0, 0x30(%rbx)
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::getHexDigest[abi:cxx11]() | std::string
Pl_SHA2::getHexDigest()
{
if (this->in_progress) {
throw std::logic_error("digest requested for in-progress SHA2 Pipeline");
}
return QUtil::hex_encode(getRawDigest());
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x30(%rsi)
je 0x37ef8
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x37e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e84c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37eed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x190e0
movq %rbx, %rax
... | /jberkenbilt[P]qpdf/libqpdf/Pl_SHA2.cc |
Pl_SHA2::~Pl_SHA2() | ~Pl_SHA2() final = default; | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x37f70
callq 0x1ed58
leaq 0x1b1be9(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x37f93
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x190e0
popq %rbx
retq
nop
| /jberkenbilt[P]qpdf/libqpdf/qpdf/Pl_SHA2.hh |
Pl_StdioFile::Pl_StdioFile(char const*, _IO_FILE*) | Pl_StdioFile::Pl_StdioFile(char const* identifier, FILE* f) :
Pipeline(identifier, nullptr),
m(std::make_unique<Members>(f))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
xorl %edx, %edx
callq 0x30a50
leaq 0x1b2828(%rip), %rax # 0x1ea7f0
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x19180
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x1b1b72(%rip), %rax # 0x1e9b60
... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::~Pl_StdioFile() | Pl_StdioFile::~Pl_StdioFile() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x1b27d3(%rip), %rax # 0x1ea7f0
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x38033
movl $0x8, %esi
callq 0x190e0
movq $0x0, 0x30(%rbx)
leaq 0x1b1b1e(%rip), %rax # 0x1e9b60
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x3805e
movq (%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::~Pl_StdioFile() | void
Pl_StdioFile::write(unsigned char const* buf, size_t len)
{
size_t so_far = 0;
while (len > 0) {
so_far = fwrite(buf, 1, len, m->file);
if (so_far == 0) {
QUtil::throw_system_error(this->identifier + ": Pl_StdioFile::write");
} else {
buf += so_far;
... | pushq %rbx
movq %rdi, %rbx
callq 0x38012
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x190e0
nop
| /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::write(unsigned char const*, unsigned long) | void
Pl_StdioFile::write(unsigned char const* buf, size_t len)
{
size_t so_far = 0;
while (len > 0) {
so_far = fwrite(buf, 1, len, m->file);
if (so_far == 0) {
QUtil::throw_system_error(this->identifier + ": Pl_StdioFile::write");
} else {
buf += so_far;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x38114
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
leaq 0x127470(%rip), %r13 # 0x15f519
movq 0x30(%r15), %rax
movq (%rax), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_StdioFile::finish() | void
Pl_StdioFile::finish()
{
if ((fflush(m->file) == -1) && (errno == EBADF)) {
throw std::logic_error(this->identifier + ": Pl_StdioFile::finish: stream already closed");
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x30(%rdi), %rax
movq (%rax), %rdi
callq 0x19570
cmpl $-0x1, %eax
jne 0x3816e
callq 0x19ba0
cmpl $0x9, (%rax)
je 0x38177
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x193f0
movq %rax, %rbx
addq $0x8, %r14
leaq 0x1273a0... | /jberkenbilt[P]qpdf/libqpdf/Pl_StdioFile.cc |
Pl_String::Pl_String(char const*, Pipeline*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | Pl_String::Pl_String(char const* identifier, Pipeline* next, std::string& s) :
Pipeline(identifier, next),
m(std::make_unique<Members>(s))
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
callq 0x30a50
leaq 0x1b262a(%rip), %rax # 0x1ea838
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x19180
movq %r14, (%rax)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x1b192c(%rip), %rax # 0x1e9b60
movq %rax, (%rbx... | /jberkenbilt[P]qpdf/libqpdf/Pl_String.cc |
Pl_TIFFPredictor::write(unsigned char const*, unsigned long) | void
Pl_TIFFPredictor::write(unsigned char const* data, size_t len)
{
auto end = data + len;
auto row_end = data + (bytes_per_row - cur_row.size());
while (row_end <= end) {
// finish off current row
cur_row.insert(cur_row.end(), data, row_end);
data = row_end;
row_end += byt... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
addq %rsi, %rbx
movl 0x38(%rdi), %r13d
leaq 0x48(%rdi), %r14
movq 0x50(%rdi), %rax
movq 0x48(%rdi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
addq %rdx, %r13
addq %rcx, %r13
cmpq %rbx, %r13
jbe 0x3855a
movq %rdx, %r12
jmp 0x38596
movq %rd... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.cc |
Pl_TIFFPredictor::processRow() | void
Pl_TIFFPredictor::processRow()
{
QTC::TC("libtests", "Pl_TIFFPredictor processRow", (action == a_decode ? 0 : 1));
previous.assign(samples_per_pixel, 0);
if (bits_per_sample != 8) {
BitWriter bw(next());
BitStream in(cur_row.data(), cur_row.size());
for (unsigned int col = 0; co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x60, %rdi
movl 0x3c(%rbx), %esi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %rdi, (%rsp)
callq 0x389fc
cmpl $0x8, 0x40(%rbx)
jne 0x38692
movq 0x78(%rbx), %rdx
cmpq %rdx, 0x80(%rbx)
je 0x38601
movq %rdx, 0x80(%rbx)
... | /jberkenbilt[P]qpdf/libqpdf/Pl_TIFFPredictor.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.