name string | code string | asm string | file string |
|---|---|---|---|
qpdfjob_initialize_from_json | int
qpdfjob_initialize_from_json(qpdfjob_handle j, char const* json)
{
return wrap_qpdfjob(j, [json](qpdfjob_handle jh) {
jh->j.setMessagePrefix("qpdfjob json");
jh->j.initializeFromJson(json);
return 0;
});
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x63d(%rip), %rcx # 0x15b55a
movq %rcx, 0x18(%rax)
leaq 0x6fe(%rip), %rcx # 0x15b626
movq %rcx, 0x10(%rax)
movq %rax, %rsi
callq 0x15ad08
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15af4d
movq %rsp, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run | int
qpdfjob_run(qpdfjob_handle j)
{
QUtil::setLineBuf(stdout);
return wrap_qpdfjob(j, [](qpdfjob_handle jh) {
jh->j.run();
return jh->j.getExitCode();
});
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x94fa8(%rip), %rax # 0x1eff38
movq (%rax), %rdi
callq 0x13e9ec
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
leaq 0x6a4(%rip), %rax # 0x15b64c
movq %rax, 0x18(%rsi)
leaq 0x6af(%rip), %rax # 0x15b662
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_create_qpdf | qpdf_data
qpdfjob_create_qpdf(qpdfjob_handle j)
{
QUtil::setLineBuf(stdout);
try {
auto qpdf = j->j.createQPDF();
return qpdf ? new _qpdf_data(std::move(qpdf)) : nullptr;
} catch (std::exception& e) {
*j->j.getLogger()->getError() << j->j.getMessagePrefix() << ": " << e.what() << "\n... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x94f17(%rip), %rax # 0x1eff38
movq (%rax), %rdi
callq 0x13e9ec
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6fb6a
cmpq $0x0, 0x8(%rsp)
je 0x15b05a
movl $0x148, %edi # imm = 0x148
callq 0x19180
movq %rax, %r15
leaq 0x8(%rsp... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_write_qpdf | int
qpdfjob_write_qpdf(qpdfjob_handle j, qpdf_data qpdf)
{
QUtil::setLineBuf(stdout);
return wrap_qpdfjob(j, [qpdf](qpdfjob_handle jh) {
jh->j.writeQPDF(*(qpdf->qpdf));
return jh->j.getExitCode();
});
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x94d54(%rip), %rax # 0x1eff38
movq (%rax), %rdi
callq 0x13e9ec
leaq 0x8(%rsp), %rsi
movq $0x0, 0x8(%rsi)
movq %rbx, (%rsi)
leaq 0x477(%rip), %rax # 0x15b67a
movq %rax, 0x18(%rsi)
leaq 0x488(%rip), %rax # 0x15b696
movq %rax, 0x1... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run_from_argv | int
qpdfjob_run_from_argv(char const* const argv[])
{
return run_with_handle(
[argv](qpdfjob_handle j) { return qpdfjob_initialize_from_argv(j, argv); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x435(%rip), %rcx # 0x15b6bc
movq %rcx, 0x18(%rax)
leaq 0x438(%rip), %rcx # 0x15b6ca
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x15b2eb
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15b2b7
movq %rsp, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
run_with_handle(std::function<int (_qpdfjob_handle*)>) | static int
run_with_handle(std::function<int(qpdfjob_handle)> fn)
{
auto j = qpdfjob_init();
int status = fn(j);
if (status == 0) {
status = qpdfjob_run(j);
}
qpdfjob_cleanup(&j);
return status;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x15ab38
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%r14)
je 0x15b33d
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *0x18(%r14)
movl %eax, %ebp
testl %eax, %eax
jne 0x15b32a
movq %rbx, %rdi
callq 0x15af81
movl %eax, %ebp
mo... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run_from_wide_argv | int
qpdfjob_run_from_wide_argv(wchar_t const* const argv[])
{
return run_with_handle(
[argv](qpdfjob_handle j) { return qpdfjob_initialize_from_wide_argv(j, argv); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x394(%rip), %rcx # 0x15b6f0
movq %rcx, 0x18(%rax)
leaq 0x397(%rip), %rcx # 0x15b6fe
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x15b2eb
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15b38c
movq %rsp, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_run_from_json | int
qpdfjob_run_from_json(char const* json)
{
return run_with_handle(
[json](qpdfjob_handle j) { return qpdfjob_initialize_from_json(j, json); });
} | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rax
movq $0x0, 0x8(%rax)
movq %rdi, (%rax)
leaq 0x34a(%rip), %rcx # 0x15b724
movq %rcx, 0x18(%rax)
leaq 0x34d(%rip), %rcx # 0x15b732
movq %rcx, 0x10(%rax)
movq %rax, %rdi
callq 0x15b2eb
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x15b40a
movq %rsp, %rdi... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdfjob_register_progress_reporter | void
qpdfjob_register_progress_reporter(
qpdfjob_handle j, void (*report_progress)(int percent, void* data), void* data)
{
j->j.registerProgressReporter(std::bind(report_progress, std::placeholders::_1, data));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq $0x0, 0x8(%r12)
movl $0x10, %edi
callq 0x19180
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r12)
leaq -0x17f6(%rip), %rax # 0x159c86
movq %rax, 0x18(%r12)
leaq -0x17f4(%rip),... | /jberkenbilt[P]qpdf/libqpdf/qpdfjob-c.cc |
qpdf_data::_qpdf_data(std::unique_ptr<QPDF, std::default_delete<QPDF>>&&) | _qpdf_data(std::unique_ptr<QPDF>&& qpdf) :
qpdf(std::move(qpdf)) {} | pushq %rbx
movq %rdi, %rbx
callq 0x15b828
leaq 0x40(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x50(%rbx)
leaq 0x68(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movb %al, 0x68... | /jberkenbilt[P]qpdf/libqpdf/qpdf/qpdf-c_impl.hh |
qpdflogger_default_logger | qpdflogger_handle
qpdflogger_default_logger()
{
return new _qpdflogger_handle(QPDFLogger::defaultLogger());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x10, %edi
callq 0x19180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb939a
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x15b9a4
movq 0x945f9(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x15b991
incl 0x8(%rdi)
jmp... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
qpdflogger_create | qpdflogger_handle
qpdflogger_create()
{
return new _qpdflogger_handle(QPDFLogger::create());
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x10, %edi
callq 0x19180
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb9348
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x15ba1f
movq 0x9457e(%rip), %rax # 0x1eff80
cmpb $0x0, (%rax)
je 0x15ba0c
incl 0x8(%rdi)
jmp... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
set_log_dest(QPDFLogger*, void (QPDFLogger::*)(std::shared_ptr<Pipeline>), qpdf_log_dest_e, char const*, int (*)(char const*, unsigned long, void*), void*) | static void
set_log_dest(
QPDFLogger* l,
void (QPDFLogger::*method)(std::shared_ptr<Pipeline>),
qpdf_log_dest_e dest,
char const* identifier,
qpdf_log_fn_t fn,
void* udata)
{
set_log_dest(
l, std::bind(std::mem_fn(method), l, std::placeholders::_1), dest, identifier, fn, udata);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbx
movq %r14, 0x8(%rbx)
movl $0x18, %edi
callq 0x19180
movq %r12, (%rax)
movq %r14, 0x8(%rax)
m... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
qpdflogger_set_save | void
qpdflogger_set_save(
qpdflogger_handle l, qpdf_log_dest_e dest, qpdf_log_fn_t fn, void* udata, int only_if_not_set)
{
auto method = std::bind(
std::mem_fn(&QPDFLogger::setSave), l->l.get(), std::placeholders::_1, only_if_not_set);
set_log_dest(l->l.get(), method, dest, "save logger", fn, udata)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movq %rcx, (%rsp)
movq %rdx, %r14
movl %esi, %r15d
movq (%rdi), %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq %rbx, 0x8(%r13)
movl $0x20, %edi
callq 0x19180
leaq -0xa220b(%rip), %rcx # 0xb99ce
movq %rcx, (%rax)
movq %... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
set_log_dest(QPDFLogger*, std::function<void (std::shared_ptr<Pipeline>)>, qpdf_log_dest_e, char const*, int (*)(char const*, unsigned long, void*), void*) | static void
set_log_dest(
QPDFLogger* l,
std::function<void(std::shared_ptr<Pipeline>)> method,
qpdf_log_dest_e dest,
char const* identifier,
qpdf_log_fn_t fn,
void* udata)
{
switch (dest) {
case qpdf_log_dest_default:
method(nullptr);
break;
case qpdf_log_dest_stdout... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rcx, 0x80(%rsp)
movq %r8, 0x78(%rsp)
movq %r9, 0x70(%rsp)
cmpl $0x4, %edx
ja 0x15bdc5
movq %rsi, %rbx
movq %rdi, %rsi
movl %edx, %eax
leaq 0x26bb7(%rip), %rcx # 0x182860
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x3... | /jberkenbilt[P]qpdf/libqpdf/qpdflogger-c.cc |
check_openssl(int) | static void
check_openssl(int status)
{
if (status != 1) {
// OpenSSL creates a "queue" of errors; copy the first (innermost) error to the exception
// message.
char buf[256] = "";
ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
std::string what = "OpenSSL error: ";
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
cmpl $0x1, %edi
jne 0x15c1dc
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r14
popq %r15
jmp 0x19bb0
leaq 0x20(%rsp), %rbx
movl $0x100, %edx # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19330
callq 0x19ad0
movl ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_init(int) | void
QPDFCrypto_openssl::SHA2_init(int bits)
{
static const EVP_MD* md = EVP_sha512();
switch (bits) {
case 256:
md = EVP_sha256();
break;
case 384:
md = EVP_sha384();
break;
case 512:
md = EVP_sha512();
break;
default:
bad_bits(bits);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movb 0x953f6(%rip), %al # 0x1f16d0
testb %al, %al
je 0x15c355
cmpl $0x100, %r14d # imm = 0x100
je 0x15c30b
cmpl $0x180, %r14d # imm = 0x180
je 0x15c304
cmpl $0x200, %r14d ... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::MD5_finalize() | void
QPDFCrypto_openssl::MD5_finalize()
{
#ifdef QPDF_OPENSSL_1
auto md = EVP_MD_CTX_md(md_ctx);
#else
auto md = EVP_MD_CTX_get0_md(md_ctx);
#endif
if (md) {
check_openssl(EVP_DigestFinal(md_ctx, md_out + 0, nullptr));
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x19720
testq %rax, %rax
je 0x15c630
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x190f0
movl %eax, %edi
popq %rbx
jmp 0x15c1ba
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_finalize() | void
QPDFCrypto_openssl::SHA2_finalize()
{
#ifdef QPDF_OPENSSL_1
auto md = EVP_MD_CTX_md(md_ctx);
#else
auto md = EVP_MD_CTX_get0_md(md_ctx);
#endif
if (md) {
check_openssl(EVP_DigestFinal(md_ctx, md_out + 0, nullptr));
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x19720
testq %rax, %rax
je 0x15c65e
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x190f0
movl %eax, %edi
popq %rbx
jmp 0x15c1ba
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
QPDFCrypto_openssl::SHA2_digest[abi:cxx11]() | std::string
QPDFCrypto_openssl::SHA2_digest()
{
return {reinterpret_cast<char*>(md_out), sha2_bits / 8};
} | pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rsi), %rax
movq 0x58(%rsi), %rcx
shrq $0x3, %rcx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
leaq (%rsi,%rcx), %rdx
addq $0x18, %rdx
movq %rax, %rsi
callq 0x1ee2c
movq %rbx, %rax
popq %rbx
retq
| /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
(anonymous namespace)::RC4Loader::getRC4() | EVP_CIPHER const*
RC4Loader::getRC4()
{
static auto loader = std::shared_ptr<RC4Loader>(new RC4Loader());
return loader->rc4;
} | pushq %r14
pushq %rbx
pushq %rax
movb 0x94f74(%rip), %al # 0x1f16f8
testb %al, %al
je 0x15c79b
movq 0x94f59(%rip), %rax # 0x1f16e8
movq 0x10(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x94f56(%rip), %rdi # 0x1f16f8
callq 0x193a0
testl %eax, %eax
je 0x15c788
movl $0x18, %edi
callq 0x19180
mov... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
(anonymous namespace)::RC4Loader::RC4Loader() | RC4Loader::RC4Loader()
{
libctx = OSSL_LIB_CTX_new();
if (libctx == nullptr) {
throw std::runtime_error("unable to create openssl library context");
return;
}
legacy = OSSL_PROVIDER_load(libctx, "legacy");
if (legacy == nullptr) {
OSSL_LIB_CTX_free(libctx);
throw std:... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x19920
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x15c9ad
leaq 0x26363(%rip), %rsi # 0x182cdd
movq %rax, %rdi
callq 0x19ab0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rax, %rax
je 0x15c9cb
leaq 0xb08f(%rip), %rsi # 0x167a24
xorl %edx, %edx
callq 0x19550... | /jberkenbilt[P]qpdf/libqpdf/QPDFCrypto_openssl.cc |
vfprintf | int vfprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, va_list arg )
{
/* TODO: This function should interpret format as multibyte characters. */
struct _PDCLIB_status_t status;
status.base = 0;
status.flags = 0;
status.n = SIZE_MAX;
status.i = 0;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
andq $0x0, 0x8(%rsp)
orq $-0x1, 0x10(%rsp)
movq %rdx, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x28(%rsp)
orl $-0x1, 0x38(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq %rdi, 0x40(%rsp)
leaq 0x48(%rdi), %rbx
movq %rbx, %rdi
callq ... | /DevSolar[P]pdclib/functions/stdio/vfprintf.c |
tmpfile | struct _PDCLIB_file_t * tmpfile( void )
{
FILE * rc;
/* This is the chosen way to get high-quality randomness. Replace as
appropriate.
*/
int randomsource = open( "/dev/urandom", O_RDONLY );
/* Working under the assumption that the tempfile location is canonical
(absolute), and does no... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x717c(%rip), %rdi # 0x1fd9e
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x3110
movl %eax, %ebp
pushq $0x2e
popq %rdi
callq 0x18d50
cmpl $-0x1, %ebp
je 0x18d04
movq %rax, %rbx
pushq $0x4
popq %r15
leaq 0x715c(%rip), %r12 ... | /DevSolar[P]pdclib/platform/example/functions/stdio/tmpfile.c |
init_mparams | static int init_mparams(void) {
#ifdef NEED_GLOBAL_LOCK_INIT
if (malloc_global_mutex_status <= 0)
init_malloc_global_mutex();
#endif
ACQUIRE_MALLOC_GLOBAL_LOCK();
if (mparams.magic == 0) {
size_t magic;
size_t psize;
size_t gsize;
#ifndef WIN32
psize = malloc_getpagesize;
gsize = ((DEFAU... | pushq %rax
pushq $0x1
popq %rax
xchgl %eax, 0xfd6f(%rip) # 0x2a0a0
testl %eax, %eax
je 0x1a341
leaq 0xfd64(%rip), %rdi # 0x2a0a0
callq 0x1a3be
cmpq $0x0, 0xf97f(%rip) # 0x29cc8
jne 0x1a3ad
pushq $0x1e
popq %rdi
callq 0x3120
leaq -0x1(%rax), %rcx
testq %rcx, %rax
jne 0x1a3b9
movq %rax, 0xf975(%rip) #... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
sys_trim | static int sys_trim(mstate m, size_t pad) {
size_t released = 0;
ensure_initialization();
if (pad < MAX_REQUEST && is_initialized(m)) {
pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
if (m->topsize > pad) {
/* Shrink top space in granularity-size units, keeping at least one */
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0xf1ab(%rip) # 0x29cc8
jne 0x1ab24
callq 0x1a327
xorl %eax, %eax
cmpq $-0x81, %rbx
ja 0x1acae
movq 0xf1e6(%rip), %rdi # 0x29d20
testq %rdi, %rdi
je 0x1acae
leaq 0x50(%rbx), %rcx
movq 0xf1ba(%rip), %rax # 0x29d08
cmpq %rcx, ... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlrealloc_in_place | void* dlrealloc_in_place(void* oldmem, size_t bytes) {
void* mem = 0;
if (oldmem != 0) {
if (bytes >= MAX_REQUEST) {
MALLOC_FAILURE_ACTION;
}
else {
size_t nb = request2size(bytes);
mchunkptr oldp = mem2chunk(oldmem);
#if ! FOOTERS
mstate m = gm;
#else /* FOOTERS */
mstate ... | testq %rdi, %rdi
je 0x1b52f
pushq %r15
pushq %r14
pushq %rbx
cmpq $-0x80, %rsi
jb 0x1b532
callq 0x1c5dc
movl $0xc, (%rax)
xorl %eax, %eax
jmp 0x1b599
xorl %eax, %eax
retq
movq %rdi, %rbx
leaq 0x17(%rsi), %rax
andq $-0x10, %rax
cmpq $0x17, %rsi
pushq $0x20
popq %r15
cmovaeq %rax, %r15
leaq -0x10(%rdi), %r14
testb $0x2, ... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmalloc_set_footprint_limit | size_t dlmalloc_set_footprint_limit(size_t bytes) {
size_t result; /* invert sense of 0 */
if (bytes == 0)
result = granularity_align(1); /* Use minimal size */
if (bytes == MAX_SIZE_T)
result = 0; /* disable */
else
result = granularity_align(bytes);
return gm->footprint_limit... | cmpq $-0x1, %rdi
je 0x1bbac
movq 0xe13b(%rip), %rax # 0x29cd8
leaq (%rdi,%rax), %rcx
decq %rcx
negq %rax
andq %rcx, %rax
jmp 0x1bbae
xorl %eax, %eax
movq %rax, 0xe4ab(%rip) # 0x2a060
retq
| /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_getstream | int _PDCLIB_getstream( struct _PDCLIB_file_t * stream )
{
struct _PDCLIB_file_t * previous;
if ( ! _PDCLIB_isstream( stream, &previous ) )
{
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
return EOF;
}
if ( previous != NULL )
{
previous->next = stream->next;
}
else
... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x1c720
testl %eax, %eax
je 0x1c676
movq 0x8(%rsp), %rcx
movq 0x78(%rbx), %rax
testq %rcx, %rcx
je 0x1c686
movq %rax, 0x78(%rcx)
jmp 0x1c690
callq 0x1c5dc
movl $0x9, (%rax)
pushq $-0x1
popq %rax
jmp 0x1c692
leaq 0xca5b(%rip), %rcx # 0x290e8
mov... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_getstream.c |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FR... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x1c7c0
cmpq $0x0, 0x38(%rbx)
jne 0x1c7c0
movl 0x44(%rbx), %eax
testw $0xe08, %ax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x1c7d4
callq 0x1c5dc
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
pushq $-0x1
popq %rax
... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %ebp
testb $0x40, %bpl
jne 0x1d8d5
movl 0x30(%rbx), %ecx
testl %ecx, %ecx
js 0x1d8da
xorl %eax, %eax
cmpq %rax, %rcx
je 0x1d9fe
cmpb $0x0, (%r14,%rax)
je 0x1d8e2
incq %rax
jmp 0x1d8c0
pushq $0x1
popq %rax
jmp 0x1d8e2
movq %r14, %rdi
callq ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
PDCLIB_flushbuffer | int _PDCLIB_flushbuffer( struct _PDCLIB_file_t * stream )
{
/* No need to handle buffers > INT_MAX, as PDCLib doesn't allow them */
_PDCLIB_size_t written = 0;
int rc;
unsigned int retries;
if ( !( stream->status & _PDCLIB_FBIN ) )
{
/* TODO: Text stream conversion here */
}
/*... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movb $0x1, %al
xorl %ebx, %ebx
testb $0x1, %al
je 0x1daa4
movl (%r14), %edi
movq 0x8(%r14), %rsi
addq %rbx, %rsi
movq 0x18(%r14), %rdx
subq %rbx, %rdx
callq 0x3060
testl %eax, %eax
js 0x1dab1
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
addq %rax, 0x28(%r14)
addq %rax... | /DevSolar[P]pdclib/platform/example/functions/_PDCLIB/_PDCLIB_flushbuffer.c |
mtx_init | int mtx_init( mtx_t * mtx, int type )
{
/* As far as I could figure out from Pthread documentation, there is
no special requirement for a Pthread mutex to support timeout (the
default "fast" mutex already supports that). So the only thing we
check for in type is whether the mutex shall be recur... | xorps %xmm0, %xmm0
testb $0x1, %sil
jne 0x1db0a
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
jmp 0x1db15
movups %xmm0, (%rdi)
movb $0x1, 0x10(%rdi)
movups %xmm0, 0x11(%rdi)
andq $0x0, 0x20(%rdi)
pushq $0x1
popq %rax
retq
nop
| /DevSolar[P]pdclib/platform/example/functions/threads/mtx_init.c |
fseek | int fseek( struct _PDCLIB_file_t * stream, long offset, int whence )
{
int rc;
_PDCLIB_LOCK( stream->mtx );
if ( stream->status & _PDCLIB_FWRITE )
{
if ( _PDCLIB_flushbuffer( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
}
stre... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x48(%rdi), %rbx
movq %rbx, %rdi
callq 0x1db20
movl 0x44(%r15), %eax
testb $0x10, %al
je 0x1db90
movq %r15, %rdi
callq 0x1da60
cmpl $-0x1, %eax
je 0x1dbe9
movl 0x44(%r15), %eax
testb $0x40, %al
movl $0xfffffbff, ... | /DevSolar[P]pdclib/functions/stdio/fseek.c |
PDCLIB_closeall | void _PDCLIB_closeall( void )
{
struct _PDCLIB_file_t * stream = _PDCLIB_filelist;
struct _PDCLIB_file_t * next;
while ( stream != NULL )
{
next = stream->next;
fclose( stream );
stream = next;
}
} | pushq %rbx
leaq 0xb184(%rip), %rax # 0x290e8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1df7a
movq 0x78(%rdi), %rbx
callq 0x187fc
movq %rbx, %rdi
jmp 0x1df67
popq %rbx
retq
| /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_closeall.c |
PDCLIB_strtox_prelim | const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base )
{
/* skipping leading whitespace */
while ( isspace( (unsigned char)*p ) )
{
++p;
}
/* determining / skipping sign */
if ( *p != '+' && *p != '-' )
{
*sign = '+';
}
else
{
*sign... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rbx), %r12b
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x1e16c
incq %rbx
testl %eax, %eax
jne 0x1e075
cmpl $0x2b, %ebp
je 0x1e09a
cmpl $0x2d, %ebp
je 0x1e09a
decq %rbx
movb $0x2b, %r12b
movb %r12b, (%r15)
cmpb $0... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_strtox_prelim.c |
mbedtls_hmac_drbg_seed_buf | int mbedtls_hmac_drbg_seed_buf( mbedtls_hmac_drbg_context *ctx,
const mbedtls_md_info_t * md_info,
const unsigned char *data, size_t data_len )
{
int ret;
if( ( ret = mbedtls_md_setup( &ctx->md_ctx, md_info, 1 ) ) != 0 )
return( ret );
/*
* Set ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl $0x1, %edx
callq 0x5d51
movl %eax, %ebp
testl %eax, %eax
jne 0x5407
leaq 0x18(%r15), %r13
movq %r12, %rdi
callq 0x6215
movzbl %al, %edx
movq %r15, %rdi
movq %r13, %rsi
callq ... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_reseed | int mbedtls_hmac_drbg_reseed( mbedtls_hmac_drbg_context *ctx,
const unsigned char *additional, size_t len )
{
unsigned char seed[MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT];
size_t seedlen;
/* III. Check input length */
if( len > MBEDTLS_HMAC_DRBG_MAX_INPUT ||
ctx->entropy_len + len... | movl $0xfffffffb, %eax # imm = 0xFFFFFFFB
cmpq $0x100, %rdx # imm = 0x100
ja 0x54cb
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rdx, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %r12
leaq (%r12,%rdx), %rcx
cmpq $0x180, %rcx # imm = 0x180
j... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_seed | int mbedtls_hmac_drbg_seed( mbedtls_hmac_drbg_context *ctx,
const mbedtls_md_info_t * md_info,
int (*f_entropy)(void *, unsigned char *, size_t),
void *p_entropy,
const unsigned char *custom,
size_t len )
{
int ret;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x1, %edx
callq 0x5d51
testl %eax, %eax
jne 0x557f
movq %rbp, %rdi
callq 0x6215
movzbl %al, %ebp
movq %r14, (%rsp)
leaq 0x18(%rbx), %r14
movq %... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_random_with_add | int mbedtls_hmac_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t out_len,
const unsigned char *additional, size_t add_len )
{
int ret;
mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_context *) p_rng;
size_t md_len = mbedtls_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6215
movl %eax, %ebp
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
cmpq $0x400, %r15 # imm = 0x400
ja 0x56ae
movl $0xff... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_random | int mbedtls_hmac_drbg_random( void *p_rng, unsigned char *output, size_t out_len )
{
int ret;
mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_context *) p_rng;
#if defined(MBEDTLS_THREADING_C)
if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
ret = mbedtls_hmac_d... | xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x559b
| /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_write_seed_file | int mbedtls_hmac_drbg_write_seed_file( mbedtls_hmac_drbg_context *ctx, const char *path )
{
int ret;
FILE *f;
unsigned char buf[ MBEDTLS_HMAC_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "wb" ) ) == NULL )
return( MBEDTLS_ERR_HMAC_DRBG_FILE_IO_ERROR );
if( ( ret = mbedtls_hmac_drbg_random( ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rax
movq %rdi, %r14
leaq 0x7491(%rip), %rsi # 0xcb93
movq %rax, %rdi
callq 0x31d0
testq %rax, %rax
je 0x575e
movq %rax, %rbx
xorl %r15d, %r15d
movq %rsp, %rsi
movl $0x100, %edx # imm = 0x100
movq %r14, %rd... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_hmac_drbg_self_test | int mbedtls_hmac_drbg_self_test( int verbose )
{
mbedtls_hmac_drbg_context ctx;
unsigned char buf[OUTPUT_LEN];
const mbedtls_md_info_t *md_info = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
mbedtls_hmac_drbg_init( &ctx );
/*
* PR = True
*/
if( verbose != 0 )
mbedtls_printf(... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
movl $0x4, %edi
callq 0x5c8b
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.c |
mbedtls_md_clone | int mbedtls_md_clone( mbedtls_md_context_t *dst,
const mbedtls_md_context_t *src )
{
if( dst == NULL || dst->md_info == NULL ||
src == NULL || src->md_info == NULL ||
dst->md_info != src->md_info )
{
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
dst->md_info->... | movl $0xffffaf00, %eax # imm = 0xFFFFAF00
testq %rdi, %rdi
je 0x5d33
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x5d33
cmpq (%rsi), %rcx
je 0x5d34
retq
pushq %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq *0x48(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
retq
| /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_md_setup | int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
{
if( md_info == NULL || ctx == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( ( ctx->md_ctx = md_info->ctx_alloc_func() ) == NULL )
return( MBEDTLS_ERR_MD_ALLOC_FAILED );
if( hmac != 0 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0xffffaf00, %ebp # imm = 0xFFFFAF00
jne 0x5db4
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq *0x38(%rsi)
movq %rax, 0x8(%r14)
movl $0xffffae80, %ebp # imm = 0xFFFFAE80
testq... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_md_hmac | int mbedtls_md_hmac( const mbedtls_md_info_t *md_info, const unsigned char *key, size_t keylen,
const unsigned char *input, size_t ilen,
unsigned char *output )
{
mbedtls_md_context_t ctx;
int ret;
if( md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x61d5
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %r8, (%rsp)
movq %r9, 0x8(%rsp)
callq *0x38(%rdi)
movq %rax, 0x18(%rsp)
movl $0xffffae80, %ebp # imm = 0xFFFFAE80
testq %rax, %rax
je 0... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_ripemd160_starts | void mbedtls_ripemd160_starts( mbedtls_ripemd160_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
} | movaps 0x68e9(%rip), %xmm0 # 0xcd30
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
retq
| /Dragonchang[P]https_client/mbedtls/library/ripemd160.c |
mbedtls_ripemd160_self_test | int mbedtls_ripemd160_self_test( int verbose )
{
int i;
unsigned char output[20];
memset( output, 0, sizeof output );
for( i = 0; i < TESTS; i++ )
{
if( verbose != 0 )
mbedtls_printf( " RIPEMD-160 test #%d: ", i + 1 );
mbedtls_ripemd160( (const unsigned char *) ripemd... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
pxor %xmm0, %xmm0
movq %rsp, %r14
movdqa %xmm0, (%r14)
movl $0x0, 0x10(%r14)
leaq 0x9180(%rip), %rbp # 0x10da0
leaq 0x5239(%rip), %r15 # 0xce60
xorl %r12d, %r12d
testl %ebx, %ebx
je 0x7c41
leal 0x1(%r12), %esi
l... | /Dragonchang[P]https_client/mbedtls/library/ripemd160.c |
mbedtls_sha1_starts | void mbedtls_sha1_starts( mbedtls_sha1_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
ctx->state[4] = 0xC3D2E1F0;
} | movaps 0x5005(%rip), %xmm0 # 0xcd30
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
retq
| /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha1_finish | void mbedtls_sha1_finish( mbedtls_sha1_context *ctx, unsigned char output[20] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_UINT3... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shldl $0x3, %eax, %ecx
movq %rsi, %r14
leal (,%rax,8), %edx
movl %ecx, %esi
shrl $0x18, %esi
leaq 0x8(%rsp), %r15
movb %sil, (%r15)
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, 0x1(%r15)
movb %ch, 0xa(%rsp)
movb %cl,... | /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha1_self_test | int mbedtls_sha1_self_test( int verbose )
{
int i, j, buflen, ret = 0;
unsigned char buf[1024];
unsigned char sha1sum[20];
mbedtls_sha1_context ctx;
mbedtls_sha1_init( &ctx );
/*
* SHA-1
*/
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %edi, %ebx
pxor %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movdqu %xmm0, 0x4c(%r14)
movdqa %xmm0, 0x40(%r14)
movdqa %xmm0, 0x30(%r14)
movdqa %xmm0, 0x20(%r14)
movdqa %xmm0, 0x10(%r14)
movdqa %xmm0, (%r14)
leaq 0x80... | /Dragonchang[P]https_client/mbedtls/library/sha1.c |
mbedtls_sha256_starts | void mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
if( is224 == 0 )
{
/* SHA-256 */
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
c... | movq $0x0, (%rdi)
testl %esi, %esi
je 0x92b1
movaps 0x3e0a(%rip), %xmm0 # 0xd0b0
jne 0x92ba
movaps 0x3e11(%rip), %xmm1 # 0xd0c0
jmp 0x92c1
movaps 0x3de8(%rip), %xmm0 # 0xd0a0
je 0x92a8
movaps 0x3e0f(%rip), %xmm1 # 0xd0d0
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%rdi)
movl %esi, 0x68(%rdi)
retq
| /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha256_finish | void mbedtls_sha256_finish( mbedtls_sha256_context *ctx, unsigned char output[32] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_U... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shldl $0x3, %eax, %ecx
movq %rsi, %r14
leal (,%rax,8), %edx
movl %ecx, %esi
shrl $0x18, %esi
leaq 0x8(%rsp), %r15
movb %sil, (%r15)
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, 0x1(%r15)
movb %ch, 0xa(%rsp)
movb %cl,... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha512_finish | void mbedtls_sha512_finish( mbedtls_sha512_context *ctx, unsigned char output[64] )
{
size_t last, padn;
uint64_t high, low;
unsigned char msglen[16];
high = ( ctx->total[0] >> 61 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT64_BE( high, msglen, 0 );
PUT_UI... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
shldq $0x3, %rax, %rdx
movq %rsi, %r14
leal (,%rax,8), %ecx
movq %rdx, %rsi
shrq $0x38, %rsi
movq %rsp, %r15
movb %sil, (%r15)
movq %rdx, %rsi
shrq $0x30, %rsi
movb %sil, 0x1(%r15)
movq %rdx, %rsi
shrq $0x28, %rsi
m... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_md5_process | void mbedtls_md5_process( mbedtls_md5_context *ctx, const unsigned char data[64] )
{
uint32_t X[16], A, B, C, D;
GET_UINT32_LE( X[ 0], data, 0 );
GET_UINT32_LE( X[ 1], data, 4 );
GET_UINT32_LE( X[ 2], data, 8 );
GET_UINT32_LE( X[ 3], data, 12 );
GET_UINT32_LE( X[ 4], data, 16 );
GET_UINT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r9
movq %rdi, -0x20(%rsp)
movl (%rsi), %r11d
movl 0x4(%rsi), %r13d
movl 0x8(%rsi), %r12d
movl 0x8(%rdi), %ebx
movq %rbx, -0x8(%rsp)
movl 0xc(%rdi), %esi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
xorl %edx, %eax
movq %rsi, %r... | /Dragonchang[P]https_client/mbedtls/library/md5.c |
disp::test() | void test()
{
TESTD("hg/x","m:hg/x:x");
TESTD("h0","-");
TESTD("h1/a1",":1");
TESTD("h2/a1/a2",":1:2");
TESTD("h3/a1/a2/a3",":1:2:3");
TESTD("h4/a1/a2/a3/a4",":1:2:3:4");
TESTD("h5/a1/a2/a3/a4/a5",":1:2:3:4:5");
TESTD("h6/a1/a2/a3/a4/a5/a6",":1:2:3:4:5:6");
TESTM("GET","/h0","-");
TESTM("GET","/r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd18, %rsp # imm = 0xD18
movq %rdi, %r14
leaq 0x988(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bba2(%rip), %rsi # 0x32e17
leaq 0x1bb9f(%rip), %rdx # 0x32e1b
leaq 0x978(%rsp), %rbx
movq %rbx, %rdi
callq 0x2b0ac
movq (%r14), %rax
... | /artyom-beilis[P]cppcms/tests/url_mapper_test.cpp |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnOpcodeF64(unsigned long) | Result BinaryReaderObjdumpDisassemble::OnOpcodeF64(uint64_t value) {
if (!in_function_body) {
return Result::Ok;
}
char buffer[WABT_MAX_DOUBLE_HEX];
WriteDoubleHex(buffer, sizeof(buffer), value);
LogOpcode(buffer);
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x118(%rax)
jne 0x348ee
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x3491a
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x28, %esi
callq 0x63610
movq -0... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnOpcodeV128(v128) | Result BinaryReaderObjdumpDisassemble::OnOpcodeV128(v128 value) {
if (!in_function_body) {
return Result::Ok;
}
// v128 is always dumped as i32x4:
LogOpcode("0x%08x 0x%08x 0x%08x 0x%08x", value.u32(0), value.u32(1),
value.u32(2), value.u32(3));
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x14(%rbp)
movq %rdx, -0xc(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34962
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x349ca
leaq -0x14(%rbp), %rdi
xorl %esi, %esi
callq 0x41af0
movl %eax... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnOpcodeBlockSig(wabt::Type) | Result BinaryReaderObjdumpDisassemble::OnOpcodeBlockSig(Type sig_type) {
if (!in_function_body) {
return Result::Ok;
}
if (sig_type != Type::Void) {
LogOpcode("%s", BlockSigToString(sig_type).c_str());
} else {
LogOpcode(nullptr);
}
indent_level++;
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34a11
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x34a9c
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0xffffffc0,... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnOpcodeType(wabt::Type) | Result BinaryReaderObjdumpDisassemble::OnOpcodeType(Type type) {
if (!in_function_body) {
return Result::Ok;
}
if (current_opcode == Opcode::SelectT) {
LogOpcode(type.GetName().c_str());
} else {
LogOpcode(type.GetRefKindName());
}
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34ade
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x34b44
movq -0x40(%rbp), %rdi
addq $0xe8, %rdi
callq 0x41ac0
cmpl $0x19, %eax
jne 0x34b22
le... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnBrTableExpr(unsigned int, unsigned int*, unsigned int) | Result BinaryReaderObjdumpDisassemble::OnBrTableExpr(
Index num_targets,
Index* target_depths,
Index default_target_depth) {
if (!in_function_body) {
return Result::Ok;
}
std::string buffer = std::string();
for (Index i = 0; i < num_targets; i++) {
buffer.append(std::to_string(target_depths... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34b8d
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x34c48
leaq -0x48(%rbp), %rdi
callq 0xd420
mo... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnDelegateExpr(unsigned int) | Result BinaryReaderObjdumpDisassemble::OnDelegateExpr(Index depth) {
if (!in_function_body) {
return Result::Ok;
}
// Because `delegate` ends the block we need to dedent here, and
// we don't need to dedent it in LogOpcode.
if (indent_level > 0) {
indent_level--;
}
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34e2d
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x34e58
movq -0x20(%rbp), %rax
cmpl $0x0, 0x108(%rax)
jle 0x34e4d
movq -0x20(%rbp), %rax
mov... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnEndExpr() | Result BinaryReaderObjdumpDisassemble::OnEndExpr() {
if (!in_function_body) {
return Result::Ok;
}
if (indent_level > 0) {
indent_level--;
}
LogOpcode(0, nullptr);
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x118(%rax)
jne 0x34e9a
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x34ed7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x108(%rax)
jle 0x34eba
movq -0x18(%rbp), %rax
movl 0x108(%rax), %ecx
add... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::LogOpcode(char const*, ...) | void BinaryReaderObjdumpDisassemble::LogOpcode(const char* fmt, ...) {
// BinaryReaderObjdumpDisassemble is only used to disassembly function bodies
// so this should never be called for instructions outside of function bodies
// (i.e. init expresions).
assert(in_function_body);
if (skip_next_opcode_) {
s... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
testb %al, %al
je 0x352d7
movaps %xmm0, -0x110(%rbp)
movaps %xmm1, -0x100(%rbp)
movaps %xmm2, -0xf0(%rbp)
movaps %xmm3, -0xe0(%rbp)
movaps %xmm4, -0xd0(%rbp)
movaps %xmm5, -0xc0(%rbp)
movaps %xmm6, -0xb0(%rbp)
movaps %xmm7, -0xa0(%rbp)
movq %r9, -0x1... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::BlockSigToString[abi:cxx11](wabt::Type) const | std::string BinaryReaderObjdumpDisassemble::BlockSigToString(Type type) const {
if (type.IsIndex()) {
return StringPrintf("type[%d]", type.GetIndex());
} else if (type == Type::Void) {
return "";
} else {
return type.GetName();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x41c40
testb $0x1, %al
jne 0x35a6e
jmp 0x35a8d
leaq -0x10(%rbp), %rdi
callq 0x41c60
movq -0x38(%rbp), %rdi
movl %eax... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnFuncType(unsigned int, unsigned int, wabt::Type*, unsigned int, wabt::Type*) | Result BinaryReaderObjdump::OnFuncType(Index index,
Index param_count,
Type* param_types,
Index result_count,
Type* result_types) {
if (!ShouldPrintDetails()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38bb0
testb $0x1, %al
jne 0x3601e
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x361af
movl -0x14... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnStructType(unsigned int, unsigned int, wabt::TypeMut*) | Result BinaryReaderObjdump::OnStructType(Index index,
Index field_count,
TypeMut* fields) {
if (!ShouldPrintDetails()) {
return Result::Ok;
}
printf(" - type[%" PRIindex "] (struct", index);
for (Index i = 0; i < field_count; ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38bb0
testb $0x1, %al
jne 0x361f3
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x362be
movl -0x14(%rbp), %esi
leaq 0x3fbe3(%rip), %rdi # 0... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnArrayType(unsigned int, wabt::TypeMut) | Result BinaryReaderObjdump::OnArrayType(Index index, TypeMut field) {
if (!ShouldPrintDetails()) {
return Result::Ok;
}
printf(" - type[%" PRIindex "] (array", index);
if (field.mutable_) {
printf(" (mut");
}
printf(" %s", field.type.GetName().c_str());
if (field.mutable_) {
printf(")");
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdx, -0x20(%rbp)
movb %al, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38bb0
testb $0x1, %al
jne 0x36313
leaq -0x4(%rbp)... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnImportTable(unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderObjdump::OnImportTable(Index import_index,
std::string_view module_name,
std::string_view field_name,
Index table_index,
Type elem_ty... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x10(%rbp), %eax
movl %... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnFunction(unsigned int, unsigned int) | Result BinaryReaderObjdump::OnFunction(Index index, Index sig_index) {
PrintDetails(" - func[%" PRIindex "] sig=%" PRIindex, index, sig_index);
auto name = GetFunctionName(index);
if (!name.empty()) {
PrintDetails(" <" PRIstringview ">", WABT_PRINTF_STRING_VIEW_ARG(name));
}
PrintDetails("\n");
objdump_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x3f4a6(%rip), %rsi # 0x75e0d
movb $0x0, %al
callq 0x38bf0
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
c... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnDataSegmentData(unsigned int, void const*, unsigned long) | Result BinaryReaderObjdump::OnDataSegmentData(Index index,
const void* src_data,
Address size) {
if (!ShouldPrintDetails()) {
return Result::Ok;
}
PrintDetails(" - segment[%" PRIindex "]", index);
auto name = GetSeg... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x38bb0
testb $0x1, %al
jne 0x3775b
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x37994
movq -0x68(%rbp), %rdi
movl -0x1... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnSectionSymbol(unsigned int, unsigned int, unsigned int) | Result BinaryReaderObjdump::OnSectionSymbol(Index index,
uint32_t flags,
Index section_index) {
auto sym_name = GetSectionName(section_index);
assert(!sym_name.empty());
PrintDetails(" - %d: S <" PRIstringview "> section=%" ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x1c(%rbp), %esi
callq 0x33bb0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x40cc0
xorb $-0x1, %al
te... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::PrintSymbolFlags(unsigned int) | Result BinaryReaderObjdump::PrintSymbolFlags(uint32_t flags) {
if (flags > WABT_SYMBOL_FLAG_MAX) {
err_stream_->Writef("Unknown symbols flags: %x\n", flags);
return Result::Error;
}
const char* binding_name = nullptr;
SymbolBinding binding =
static_cast<SymbolBinding>(flags & WABT_SYMBOL_MASK_BIN... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x3ff, -0x14(%rbp) # imm = 0x3FF
jbe 0x3a267
movq -0x40(%rbp), %rdi
addq $0xf0, %rdi
callq 0x3f970
movq %rax, %rdi
movl -0x14(%rbp), %edx
leaq 0x3bf84(%rip), %rsi # 0x761... | /WebAssembly[P]wabt/src/binary-reader-objdump.cc |
wabt::Features::EnableAll() | void EnableAll() {
#define WABT_FEATURE(variable, flag, default_, help) enable_##variable();
#include "wabt/feature.def"
#undef WABT_FEATURE
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x3ac40
movq -0x10(%rbp), %rdi
callq 0x3ac60
movq -0x10(%rbp), %rdi
callq 0x3ac80
movq -0x10(%rbp), %rdi
callq 0x3aca0
movq -0x10(%rbp), %rdi
callq 0x3acc0
movq -0x10(%rbp), %rdi
callq 0x3ace0
movq -0x10... | /WebAssembly[P]wabt/include/wabt/feature.h |
wabt::ReadS32Leb128(unsigned char const*, unsigned char const*, unsigned int*) | size_t ReadS32Leb128(const uint8_t* p,
const uint8_t* end,
uint32_t* out_value) {
if (p < end && (p[0] & 0x80) == 0) {
uint32_t result = LEB128_1(uint32_t);
*out_value = SIGN_EXTEND(int32_t, result, 6);
return 1;
} else if (p + 1 < end && (p[1] & 0x80) == 0) {
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x61e07
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x61e07
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x7f, %eax
shll $0x0, %eax
mo... | /WebAssembly[P]wabt/src/leb128.cc |
wabt::ParseHexdigit(char, unsigned int*) | Result ParseHexdigit(char c, uint32_t* out) {
if (static_cast<unsigned int>(c - '0') <= 9) {
*out = c - '0';
return Result::Ok;
} else if (static_cast<unsigned int>(c - 'a') < 6) {
*out = 10 + (c - 'a');
return Result::Ok;
} else if (static_cast<unsigned int>(c - 'A') < 6) {
*out = 10 + (c - '... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
cmpl $0x9, %eax
ja 0x627d8
movsbl -0x5(%rbp), %ecx
subl $0x30, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x2efd0
jmp 0x6283c
mov... | /WebAssembly[P]wabt/src/literal.cc |
wabt::ParseInt64(char const*, char const*, unsigned long*, wabt::ParseIntType) | Result ParseInt64(const char* s,
const char* end,
uint64_t* out,
ParseIntType parse_type) {
bool has_sign = false;
if (*s == '-' || *s == '+') {
if (parse_type == ParseIntType::UnsignedOnly) {
return Result::Error;
}
if (*s == '-') {
has_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x62ae3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x62b18
cmpl $0x0, -0x24(%... | /WebAssembly[P]wabt/src/literal.cc |
wabt::(anonymous namespace)::FloatParser<float>::ParseFloat(char const*, char const*, unsigned int*) | Result FloatParser<T>::ParseFloat(const char* s,
const char* end,
Uint* out_bits) {
// Here is the normal behavior for strtof/strtod:
//
// input | errno | output |
// ---------------------------------
// overflow | ERANGE | +-HUGE_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x63c70
jmp 0x63c8f
leaq 0x174db(%rip), %rdi # 0x7b152
leaq 0x17427(%rip), %rsi # 0x7b0a5
movl $0xa0, %edx
leaq 0x174d1(%rip), %rcx # 0x7b15b
call... | /WebAssembly[P]wabt/src/literal.cc |
main | int main()
{
try {
return run();
}
catch (int param) { cout << "int exception"; }
catch (char param) { cout << "char exception"; }
catch (...) { cout << "default exception"; }
} | pushq %rbx
callq 0x671c
xorl %eax, %eax
popq %rbx
retq
movq %rdx, %rbx
movq %rax, %rdi
cmpl $0x3, %ebx
jne 0x6994
callq 0x60b0
movq 0x964f(%rip), %rdi # 0xffd0
leaq 0x471f(%rip), %rsi # 0xb0a7
movl $0xd, %edx
callq 0x6270
jmp 0x69d0
callq 0x60b0
cmpl $0x2, %ebx
jne 0x69b8
movq 0x962b(%rip), %rdi # 0xffd0... | /haukri[P]MasterProject/Test/Nest_One_IAF_SNN_Results.cpp |
SpikingPopulation::SpikingPopulation(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Parameters*) | SpikingPopulation(int amount, std::string type) : Population(amount, type) { } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x6e18
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r... | /haukri[P]MasterProject/Network/Population/SpikingPopulation.h |
Network::Network() | Network::Network() :
param(new Network_param())
{
clock = Clock::getInstance();
logger = Logging::getInstance();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
movl $0x8, %edi
callq 0x6240
movabsq $0x3f847ae147ae147b, %rcx # imm = 0x3F847AE147AE147B
movq %rcx, (%rax)
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %r15
movq %r14, 0x30(%rbx)
xorps %xmm0, %xmm... | /haukri[P]MasterProject/Network/Network.cpp |
Izhikevich::update(double) | Event* Izhikevich::update(double n_dt) {
dt = n_dt;
dv = 0.04*v*v + 5*v + 140 - u + input_current;
du = param->a*(param->b*v - u);
v += dv * dt + input_spike;
u += du * dt;
v = ( v < -std::numeric_limits< double >::max() ? -std::numeric_limits< double >::max() : v );
logger->logValue... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm0, 0x50(%rdi)
movsd 0x28(%rdi), %xmm2
movsd 0x3163(%rip), %xmm1 # 0xb2b8
mulsd %xmm2, %xmm1
movsd 0x315f(%rip), %xmm3 # 0xb2c0
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
addsd 0x3153(%rip), %xmm1 # 0xb2c8
movsd 0x20(%rdi), %xmm3
subsd ... | /haukri[P]MasterProject/Network/Neuron/Izhikevich.cpp |
CurrentGenerator::CurrentGenerator(CurrentGenerator_param*) | CurrentGenerator::CurrentGenerator(CurrentGenerator_param* param) : param(param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(seed);
distribution = std::normal_distribution<double>(pa... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x775e(%rip), %rax # 0xfb28
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
xorps %xmm0, %xmm0
movhps 0x2c8d(%rip), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, 0x38(%rdi)
xorl %r15d, %r15d
movq %r15, 0x48(%rdi)
movb %r15b, ... | /haukri[P]MasterProject/Network/Neuron/CurrentGenerator.cpp |
iaf_psc_alpha::iaf_psc_alpha(long, int) | iaf_psc_alpha::iaf_psc_alpha(long n_populationID, int n_neuronID) : param(new iaf_psc_alpha_param) {
populationID = n_populationID;
neuronID = n_neuronID;
initialize();
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6f01(%rip), %rax # 0xfc98
movq %rax, (%rdi)
movb $0x1, 0x20(%rdi)
movl $0x50, %edi
callq 0x6240
movaps 0x2261(%rip), %xmm0 # 0xb010
movups %xmm0, (%rax)
movaps 0x2267(%rip), %xmm0 # 0xb020
movups %xmm0, 0x10(%rax)
xorps... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
iaf_psc_alpha::propagator_31(double, double, double, double) | double iaf_psc_alpha::propagator_31( double tau_syn, double tau, double C, double h )
{
const double P31_linear = 1 / ( 3. * C * tau * tau ) * h * h * h * ( tau_syn - tau ) * std::exp( -h / tau );
const double P31 =
1 / C * ( std::exp( -h / tau_syn ) * std::expm1( -h / tau + h / tau_syn ) / ( tau / tau_syn - 1 ... | subq $0x88, %rsp
movapd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x68(%rsp)
movaps %xmm0, 0x30(%rsp)
movapd 0x2516(%rip), %xmm0 # 0xb390
xorpd %xmm3, %xmm0
movapd %xmm0, (%rsp)
divsd %xmm1, %xmm0
movapd %xmm0, 0x70(%rsp)
callq 0x6350
movsd %xmm0, 0x58(%rsp)
movapd (%rsp), %xmm0
divsd 0x30(%rsp), %xmm0... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
SpikingPopulation::update() | void SpikingPopulation::update() {
while(current_time < clock->getCurrentTime()) {
resetOutput();
for(int i = 0; i < numberOfNeurons; i++) {
output[i] = neurons[i]->update(clock->getDt());
if(output[i]->type != EventType::No) {
logger->logEvent((long)this, i, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rdi), %rdi
callq 0x9c5e
ucomisd 0x8(%rsp), %xmm0
jbe 0x96d9
movq %rbx, %rdi
callq 0x739a
cmpl $0x0, 0x20(%rbx)
jle 0x96b7
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
movq 0x50(%rbx), %rdi
movq (%rax,%... | /haukri[P]MasterProject/Network/Population/SpikingPopulation.cpp |
StaticSynapse::initialize(Population*, Population*) | void StaticSynapse::initialize(Population* n_from, Population* n_to) {
inputSize = n_from->getNumberOfNeurons();
outputSize = n_to->getNumberOfNeurons();
weights = Eigen::MatrixXd::Zero(inputSize, outputSize);
from_population = n_from;
to_population = n_to;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
movl %eax, 0x38(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %eax, 0x3c(%r14)
movslq 0x38(%r14), %rcx
cltq
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq... | /haukri[P]MasterProject/Network/Synapse/StaticSynapse.cpp |
Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long) | EIGEN_DEVICE_FUNC void resize(Index size, Index rows, Index cols)
{
if(size != m_rows*m_cols)
{
internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
if (size)
m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x9bf9
movq %rsi, %r12
movq (%r15), %rdi
callq 0x6290
testq %r12, %r12
je 0x9bf4
movq %r12, %rax
shrq $0x3d, %rax
jne 0x9bc6
leaq (,%r12,8), %rdi
callq 0x... | /haukri[P]MasterProject/Eigen/src/Core/DenseStorage.h |
progressKiller | static int progressKiller(void *arg,
double dltotal,
double dlnow,
double ultotal,
double ulnow)
{
(void)arg;
(void)dltotal;
(void)dlnow;
(void)ultotal;
(void)ulnow;
printf("PROGRESSFUNCTION called\n");
... | pushq %rax
leaq 0xc7e(%rip), %rdi # 0x30ed
xorl %eax, %eax
callq 0x2080
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
| /mitls[P]mitls-curl/tests/libtest/lib1513.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
snprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0xc8, %rsi
jbe 0x24ff
xorl %ebx, %ebx
jmp 0x2549
movq %rsi, %r14
testq %rsi, %rsi
je 0x2542
movq %rdi, %r15
leaq 0x2baf(%rip), %rbx # 0x50c0
leaq 0xbee(%rip), %r12 # 0x3106
xorl %ebp, %ebp
movq %rbx, %r13
movzbl (%r15,%rbp), %... | /mitls[P]mitls-curl/tests/libtest/first.c |
tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** clock_gettime() is granted to be increased monotonically when the
** monotonic clock is queried. Time starting point is unspecified, it
** could be the system start-up time, the Epoch, or something else,
** in any case the time starting point does not change once that ... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x20a0
testl %eax, %eax
je 0x2626
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2100
movq 0x8(%rbx), %rdx
jmp 0x2643
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%rsp)
movq %rdx, %rax
shrq $0x3f, ... | /mitls[P]mitls-curl/tests/libtest/testutil.c |
curlx_ultouc | unsigned char curlx_ultouc(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_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /mitls[P]mitls-curl/lib/warnless.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... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /mitls[P]mitls-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... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /mitls[P]mitls-curl/lib/warnless.c |
curlx_uztosi | int curlx_uztosi(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_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /mitls[P]mitls-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)... | movq %rdi, %rax
retq
| /mitls[P]mitls-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... | movq %rdi, %rax
retq
| /mitls[P]mitls-curl/lib/warnless.c |
curlx_sotouz | size_t curlx_sotouz(curl_off_t sonum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sonum >= 0);
return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /mitls[P]mitls-curl/lib/warnless.c |
curlx_uitous | unsigned short curlx_uitous(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_USHORT);
return (unsigned short) (uinum & (unsigned int) CURL_MASK_USHORT);
#ifdef __INTE... | movl %edi, %eax
retq
| /mitls[P]mitls-curl/lib/warnless.c |
robin_hood::detail::Table<false, 80ul, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, robin_hood::... | explicit DataNode(M& map, Args&&... args)
: mData(map.allocate()) {
::new (static_cast<void*>(mData)) value_type(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
testq %rbx, %rbx
jne 0x108ee
movq %r12, %rdi
callq 0xdffe
movq %rax, %rbx
movq (%rbx), %rax
leaq 0x10(%rbx), %rcx
movq %rbx, %rdi
movq %rax, (%r12)
movq %rbx, (%r15)
movq (%r14), %rax
movq %rcx, (%rb... | /MW55[P]DNA-Aeon/cpp/single_include/robin_hood.h |
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.