name string | code string | asm string | file string |
|---|---|---|---|
bsp_end | void bsp_end()
{
if (!s_spmd)
bsp_abort("bsp_end: called without calling bsp_begin() before\n");
if (s_spmd->closed())
bsp_abort("bsp_end: may not be called multiple times\n");
if (s_spmd->end_sync())
bsp_abort("bsp_sync/bsp_end: Some processes have called bsp_sync, "
... | pushq %rbx
movq 0x113cc(%rip), %rdi # 0x1a2d0
testq %rdi, %rdi
jne 0x8f1e
leaq 0x97d6(%rip), %rdi # 0x126e6
xorl %eax, %eax
callq 0x873d
movq 0x113b2(%rip), %rdi # 0x1a2d0
cmpb $0x1, 0x8(%rdi)
jne 0x8f39
leaq 0x97ef(%rip), %rdi # 0x1271a
xorl %eax, %eax
callq 0x873d
movq 0x11397(%rip), %rdi # 0x1a... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_sync | void bsp_sync()
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_sync: can only be called within SPMD section\n");
if (s_spmd->normal_sync())
bsp_abort("bsp_sync/bsp_end: Some processes have called bsp_sync, "
"while others have called bsp_end instead\n");
#ifdef PROFILE
{ ... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq 0x1120b(%rip), %rdi # 0x1a2d0
testq %rdi, %rdi
je 0x90d0
cmpb $0x1, 0x8(%rdi)
jne 0x90e5
leaq 0x97cd(%rip), %rdi # 0x128a4
xorl %eax, %eax
callq 0x873d
movq 0x111eb(%rip), %rdi # 0x1a2d0
callq 0xaea0
testl %eax, %eax
je 0x90fc
leaq 0x9650(%rip), %rdi # 0x127... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
lookup_usable_reg(void const*, char const*) | static bsplib::Rdma::Memslot lookup_usable_reg( const void * addr, const char * func )
{
assert( addr != NULL );
bsplib::Rdma::Memslot id =
s_rdma->lookup_reg( const_cast<void*>(addr), false, true);
if ( id == s_rdma->no_slot() ) {
id = s_rdma->lookup_reg( addr, true, false );
unsi... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9484
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10ee6(%rip), %rdi # 0x1a2d8
pushq $0x1
popq %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa774
movq %rax, %r15
cmpq $-0x1, %rax
jne 0x9475
movq 0x10ec9(%rip), %rdi # 0x1a2d8
pushq $0x1
popq %rdx
movq %rbx, %rsi
xor... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_get | void bsp_get( bsp_pid_t pid, const void * src, bsp_size_t offset,
void * dst, bsp_size_t nbytes )
{
#ifdef PROFILE
TicToc t( TicToc::GET, nbytes );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_get: can only be called within SPMD section\n");
if (nbytes == 0) // ignore any empty r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movl %edi, %ebp
movq 0x10c92(%rip), %rax # 0x1a2d0
testq %rax, %rax
je 0x9649
cmpb $0x1, 0x8(%rax)
jne 0x9657
leaq 0x9624(%rip), %rdi # 0x12c74
xorl %eax, %eax
callq 0x873d
testl %r14d, %r14... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_get_tag | void bsp_get_tag( bsp_size_t * status, void * tag )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_get_tag: can only be called within SPMD section\n");
#ifdef PROFILE
TicToc t( TicToc::BSMP, s_bsmp->recv_tag_size() );
#endif
if ( status == NULL )
bsp_abort("bsp_get_tag: first arguments m... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1086a(%rip), %rax # 0x1a2d0
testq %rax, %rax
je 0x9a71
cmpb $0x1, 0x8(%rax)
jne 0x9a7f
leaq 0x9742(%rip), %rdi # 0x131ba
xorl %eax, %eax
callq 0x873d
testq %r14, %r14
jne 0x9a92
leaq 0x9764(%rip), %rdi # 0x131ef
xorl %eax, %eax
callq ... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_put | void mcbsp_put( mcbsp_pid_t pid, const void * src,
const void * dst, mcbsp_size_t offset, mcbsp_size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::PUT, size );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_put: can only be called within SPMD section\n");
if (size == 0) // ignor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movl %edi, %ebp
movq 0x10606(%rip), %rax # 0x1a2d0
testq %rax, %rax
je 0x9cd5
cmpb $0x1, 0x8(%rax)
jne 0x9ce3
leaq 0x8cd4(%rip), %rdi # 0x129b0
xorl %eax, %eax
callq 0x873d
testq %rbx, %rbx
je ... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_hpget | void mcbsp_hpget( mcbsp_pid_t pid, const void * src,
mcbsp_size_t offset, const void * dst, mcbsp_size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET, size );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_hpget: can only be called within SPMD section\n");
if (size == 0) // ignore ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
movq 0x102ea(%rip), %rax # 0x1a2d0
testq %rax, %rax
je 0x9ff1
cmpb $0x1, 0x8(%rax)
jne 0x9fff
leaq 0x8dcc(%rip), %rdi # 0x12dc4
xorl %eax, %eax
callq 0x873... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_send | void mcbsp_send( mcbsp_pid_t pid, const void * tag,
const void * payload, mcbsp_size_t size )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_send: can only be called within SPMD section\n");
if (pid > mcbsp_pid_t(s_spmd->nprocs()))
bsp_abort("bsp_send: The source process ID doe... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq 0x1016d(%rip), %rax # 0x1a2d0
testq %rax, %rax
je 0xa16e
cmpb $0x1, 0x8(%rax)
jne 0xa183
leaq 0x8dfd(%rip), %rdi # 0x12f72
xorl %eax, %eax
callq 0x873d
movq 0x1014d(%rip), %rax # 0x1a... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bool bsplib::read_env<unsigned long>(char const*, unsigned long&) | bool read_env( const char * str, T & result ) {
#if HAS_DUPENV_S_WIN32
char * env = NULL;
if (_dupenv_s( &env, NULL , str) )
return false;
#else
const char * env = std::getenv( str );
#endif
if (env) {
std::istringstream s( env );
#if HAS_DUPENV_S_WIN32
... | pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %rbx
callq 0x8340
testq %rax, %rax
je 0xa417
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xa58c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x84a0
leaq 0x10(%rsp), %rdi
callq 0x80f0
leaq 0x30(%rsp), %rdi
mov... | /wijnand-suijlen[P]bsponmpi/src/config.h |
bsplib::Rdma::lookup_reg(void const*, bool, bool) const | Memslot lookup_reg( const void * addr, bool pushed, bool popped ) const
{
if (addr == NULL ) return null_slot();
if ( m_cached_slot != no_slot()
&& slot( m_pid, m_cached_slot).addr == addr
&& slot( m_pid, m_cached_slot).status == Memblock::NORMAL )
... | testq %rsi, %rsi
je 0xa853
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movq 0x368(%rdi), %rax
cmpq $-0x1, %rax
je 0xa7cd
movslq 0x2f4(%r14), %rcx
imulq %rax, %rcx
imulq $0x18, %rcx, %rcx
addq 0x338(%r14), %rcx
movslq 0x2f0(%r14), %rdx
imulq $0x18, %rdx, %rdx
cmpq %r... | /wijnand-suijlen[P]bsponmpi/src/rdma.h |
bsplib::Rdma::hpput(void const*, int, unsigned long, unsigned long, unsigned long) | void Rdma::hpput( const void * src,
int dst_pid, Memslot dst_slot, size_t dst_offset, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPPUT );
#endif
if ( size < m_min_n_hp_msg_size ) {
put( src, dst_pid, dst_slot, dst_offset, size );
return;
}
assert( ! (slot( m_pid, dst_slot... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r15
cmpq %r9, 0x2f8(%rdi)
jbe 0xd31e
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
movq %rbx, %r9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
j... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::PushPopCommBuf::deserialize(bsplib::A2A&) | void Rdma::PushPopCommBuf::deserialize( A2A & a2a )
{
size_t n_pushed_slots = 0;
// read pushed slots
for (int p = 0; p < a2a.nprocs(); ++p) {
size_t n;
deserial( a2a, p, n );
if ( p == 0 ) {
n_pushed_slots = n;
m_pushed_slots.resize( a2a.nprocs() * n );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %rbp
jge 0xdc5f
movq %rbx, %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0xe931
movq (%rsp), %r13
testq %rbp, %rbp... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::LinCost::get_bruck_vol() | std::size_t LinCost::get_bruck_vol()
{
if ( m_nprocs == 1 ) return m_sizes.back();
// Make sure the list m_sizes consists of unique numbers, sorted in
// increasing order, while m_counts contains the multiplicity
std::sort( m_sizes.begin(), m_sizes.end() );
unsigned k = 0;
for ( unsigned i = 0,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r13
cmpl $0x1, 0x10(%rdi)
jne 0x10558
movq 0x20(%r13), %rax
movq -0x8(%rax), %r14
jmp 0x1079f
leaq 0x18(%r13), %rax
movq %rax, (%rsp)
movq 0x18(%r13), %rdi
movq 0x20(%r13), %rsi
callq 0x1098f
leaq 0x30(%r13), %r15
xorl %r14d,... | /wijnand-suijlen[P]bsponmpi/src/lincost.cc |
secp256k1_selftest | void secp256k1_selftest(void) {
if (!secp256k1_selftest_passes()) {
secp256k1_callback_call(&default_error_callback, "self test failed");
}
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movaps 0xca0b3(%rip), %xmm0 # 0x64c040
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0xca0b4(%rip), %xmm0 # 0x64c050
movaps %xmm0, 0x10(%rbx)
andq $0x0, 0x60(%rbx)
leaq 0xcbe7d(%rip), %rsi # 0x64de29
pushq $0x3f
popq %rdx
movq %rbx, %rdi
callq 0x584abc
movq %rsp, %r1... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_preallocated_create | secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigned int flags) {
size_t prealloc_size;
secp256k1_context* ret;
secp256k1_selftest();
prealloc_size = secp256k1_context_preallocated_size(flags);
if (prealloc_size == 0) {
return NULL;
}
VERIFY_CHECK(preal... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x581f7c
movl %ebp, %edi
callq 0x581ff2
testq %rax, %rax
je 0x5820e7
movups 0x3b25ac(%rip), %xmm0 # 0x934660
movups %xmm0, 0xa8(%rbx)
movups 0x3b258e(%rip), %xmm0 # 0x934650
movups %xmm0, 0xb8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x584051... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_serialize | int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
secp256k1_ge Q;
size_t len;
int ret = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(outputlen != NULL);
ARG_CHECK(*outputlen >= ((flags & SEC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r13
testq %rdx, %rdx
je 0x5826cf
movl %r8d, %ebx
movq %rdx, %r14
movq (%rdx), %rdx
xorl %eax, %eax
movl %r8d, %r12d
andl $0x100, %r12d # imm = 0x100
sete %al
shll $0x5, %eax
addq $0x21, %rax
cmpq %rax, %rdx
jb 0x582... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_eckey_pubkey_serialize | static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed) {
if (secp256k1_ge_is_infinity(elem)) {
return 0;
}
secp256k1_fe_normalize_var(&elem->x);
secp256k1_fe_normalize_var(&elem->y);
secp256k1_fe_get_b32(&pub[1], &elem->x);
if (c... | xorl %eax, %eax
cmpl $0x0, 0x50(%rdi)
je 0x582796
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x5881b4
leaq 0x28(%r12), %r15
movq %r15, %rdi
callq 0x5881b4
leaq 0x1(%rbx), %rdi
movq %r12, %rsi
callq 0x587e17
testl %ebp, %ebp
je 0x5827... | /bitcoin[P]bitcoin/src/secp256k1/src/eckey_impl.h |
secp256k1_ecdsa_signature_serialize_compact | int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context* ctx, unsigned char *output64, const secp256k1_ecdsa_signature* sig) {
secp256k1_scalar r, s;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(output64 != NULL);
ARG_CHECK(sig != NULL);
secp256k1_ecdsa_signature_load(ctx, &r, &s, sig);
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rax
testq %rsi, %rsi
je 0x582d6c
testq %rdx, %rdx
je 0x582d7c
movq %rsi, %rbx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
leaq 0x20(%rsp), %rsi
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movups 0x20(%rdx), %xmm0
movups 0x30(%rdx), %xmm1
movq %rsp, %r14
movaps %xmm... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_scalar_is_high | static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
int yes = 0;
int no = 0;
SECP256K1_SCALAR_VERIFY(a);
no |= (a->d[3] < SECP256K1_N_H_3);
yes |= (a->d[3] > SECP256K1_N_H_3) & ~no;
no |= (a->d[2] < SECP256K1_N_H_2) & ~yes; /* No need for a > check. */
no |= (a->d[1] < SECP256K... | movq 0x18(%rdi), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
cmpq %rax, %rcx
setb %dl
shrq $0x3f, %rcx
movl %ecx, %esi
xorl $0x1, %esi
xorl %eax, %eax
cmpq $-0x1, 0x10(%rdi)
movl %esi, %r8d
cmovel %eax, %r8d
orl %edx, %r8d
movq 0x8(%rdi), %rdx
movabsq $0x5d576e7357a4501d, %r9 # imm... | /bitcoin[P]bitcoin/src/secp256k1/src/scalar_4x64_impl.h |
secp256k1_ec_seckey_verify | int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsigned char *seckey) {
secp256k1_scalar sec;
int ret;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(seckey != NULL);
ret = secp256k1_scalar_set_b32_seckey(&sec, seckey);
secp256k1_scalar_clear(&sec);
return ret;
} | pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x583828
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x583843
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movaps %xmm0, 0x10(%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rdi, %rax
movq 0xb0(%rdi), %rsi
leaq 0xca3d9(%rip), %rdi # 0x64dc12
callq *0xa8(%rax)
xorl %eax, %eax
jmp 0x5... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_negate | int secp256k1_ec_pubkey_negate(const secp256k1_context* ctx, secp256k1_pubkey *pubkey) {
int ret = 0;
secp256k1_ge p;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkey != NULL);
ret = secp256k1_pubkey_load(ctx, &p, pubkey);
memset(pubkey, 0, sizeof(*pubkey));
if (ret) {
secp256k1_ge_neg(&... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rax
testq %rsi, %rsi
je 0x583b0f
movq %rsi, %rbx
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x582728
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
testl %eax, %eax
je 0x583b23
movq %rsp, %r... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_tweak_add | int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k1_pubkey *pubkey, const unsigned char *tweak32) {
secp256k1_ge p;
int ret = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkey != NULL);
ARG_CHECK(tweak32 != NULL);
ret = secp256k1_pubkey_load(ctx, &p, pubkey);
memset(pubke... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rax
testq %rsi, %rsi
je 0x583cc5
movq %rdx, %r14
testq %rdx, %rdx
je 0x583cd5
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x582728
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups... | /bitcoin[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_sha256_finalize | static void secp256k1_sha256_finalize(secp256k1_sha256 *hash, unsigned char *out32) {
static const unsigned char pad[64] = {0x80};
unsigned char sizedesc[8];
int i;
/* The maximum message size of SHA256 is 2^64-1 bits. */
VERIFY_CHECK(hash->bytes < ((uint64_t)1 << 61));
secp256k1_write_be32(&siz... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rax
movq %rax, %rcx
movq %rax, %rsi
movq %rax, %rdi
leal (,%rax,8), %r8d
movl %eax, %r9d
movl %eax, %r10d
movl %eax, %r11d
pushq $0x37
popq %rdx
subl %eax, %edx
shrq $0x1d, %rax
leaq 0x8(%rsp), %r15
movb %al, 0x3(%r15)
s... | /bitcoin[P]bitcoin/src/secp256k1/src/hash_impl.h |
secp256k1_fe_impl_get_b32 | static void secp256k1_fe_impl_get_b32(unsigned char *r, const secp256k1_fe *a) {
r[0] = (a->n[4] >> 40) & 0xFF;
r[1] = (a->n[4] >> 32) & 0xFF;
r[2] = (a->n[4] >> 24) & 0xFF;
r[3] = (a->n[4] >> 16) & 0xFF;
r[4] = (a->n[4] >> 8) & 0xFF;
r[5] = a->n[4] & 0xFF;
r[6] = (a->n[3] >> 44) & 0xFF;
... | movb 0x25(%rsi), %al
movb %al, (%rdi)
movb 0x24(%rsi), %al
movb %al, 0x1(%rdi)
movb 0x23(%rsi), %al
movb %al, 0x2(%rdi)
movb 0x22(%rsi), %al
movb %al, 0x3(%rdi)
movb 0x21(%rsi), %al
movb %al, 0x4(%rdi)
movb 0x20(%rsi), %al
movb %al, 0x5(%rdi)
movq 0x18(%rsi), %rax
shrq $0x2c, %rax
movb %al, 0x6(%rdi)
movq 0x18(%rsi), %... | /bitcoin[P]bitcoin/src/secp256k1/src/field_5x52_impl.h |
secp256k1_keypair_sec | int secp256k1_keypair_sec(const secp256k1_context* ctx, unsigned char *seckey, const secp256k1_keypair *keypair) {
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(seckey != NULL);
memset(seckey, 0, 32);
ARG_CHECK(keypair != NULL);
memcpy(seckey, &keypair->data[0], 32);
return 1;
} | pushq %rax
movq %rdi, %rax
testq %rsi, %rsi
je 0x5883cb
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
testq %rdx, %rdx
je 0x5883db
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
pushq $0x1
popq %rax
popq %rcx
retq
movq 0xb0(%rax), %rsi
leaq 0xc5839(%rip), ... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/extrakeys/main_impl.h |
nonce_function_bip340 | static int nonce_function_bip340(unsigned char *nonce32, const unsigned char *msg, size_t msglen, const unsigned char *key32, const unsigned char *xonly_pk32, const unsigned char *algo, size_t algolen, void *data) {
secp256k1_sha256 sha;
unsigned char masked_key[32];
int i;
if (algo == NULL) {
... | testq %r9, %r9
je 0x5887be
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq 0xd8(%rsp), %rsi
movq 0xd0(%rsp), %rbx
testq %rsi, %rsi
je 0x5887c1
movaps 0xc5142(%rip), %xmm0 # 0x64d... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/schnorrsig/main_impl.h |
secp256k1_ge_set_gej_var | static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
secp256k1_fe z2, z3;
SECP256K1_GEJ_VERIFY(a);
if (secp256k1_gej_is_infinity(a)) {
secp256k1_ge_set_infinity(r);
return;
}
r->infinity = 0;
secp256k1_fe_inv_var(&a->z, &a->z);
secp256k1_fe_sqr(&z2, &a->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x78(%rsi)
je 0x589472
movl $0x1, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
jmp 0x589511
movq %rsi, %r14
andl $0... | /bitcoin[P]bitcoin/src/secp256k1/src/group_impl.h |
secp256k1_ellswift_create | int secp256k1_ellswift_create(const secp256k1_context *ctx, unsigned char *ell64, const unsigned char *seckey32, const unsigned char *auxrnd32) {
secp256k1_ge p;
secp256k1_fe t;
secp256k1_sha256 hash;
secp256k1_scalar seckey_scalar;
int ret;
static const unsigned char zero32[32] = {0};
/* S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %r14
testq %rsi, %rsi
je 0x589e4d
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
cmpl $0x0, (%r14)
je 0x589e5d
movq ... | /bitcoin[P]bitcoin/src/secp256k1/src/modules/ellswift/main_impl.h |
secp256k1_write_be64 | SECP256K1_INLINE static void secp256k1_write_be64(unsigned char* p, uint64_t x) {
p[7] = x;
p[6] = x >> 8;
p[5] = x >> 16;
p[4] = x >> 24;
p[3] = x >> 32;
p[2] = x >> 40;
p[1] = x >> 48;
p[0] = x >> 56;
} | bswapq %rsi
movq %rsi, (%rdi)
retq
| /bitcoin[P]bitcoin/src/secp256k1/src/util.h |
routine | static void routine (NN_UNUSED void *arg)
{
int s;
s = nn_socket (AF_SP, NN_SUB);
if (s < 0 && nn_errno () == EMFILE)
return;
errno_assert (s >= 0);
test_connect (s, SOCKET_ADDRESS);
test_close (s);
} | pushq %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rdi
pushq $0x21
popq %rsi
callq 0x1090
testl %eax, %eax
js 0x1750
movl %eax, %ebx
pushq $0x32
popq %rdi
movl %eax, %esi
callq 0x1983
pushq $0x33
popq %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x17a8
callq 0x1150
cmpl $0x18, %eax
jne 0x1760
popq %rbx
popq %r... | /Snaipe[P]nanomsg/tests/ipc_shutdown.c |
wabt::OptionParser::Errorf(char const*, ...) | void OptionParser::Errorf(const char* format, ...) {
WABT_SNPRINTF_ALLOCA(buffer, length, format);
std::string msg(program_name_);
msg += ": ";
msg += buffer;
msg += "\nTry '--help' for more information.";
on_error_(msg.c_str());
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x130(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2e85f
movaps %xmm0, -0x100(%rbp)
movaps %xmm... | /dcodeIO[P]wabt/src/option-parser.cc |
wabt::Stream::WriteMemoryDump(void const*, unsigned long, unsigned long, wabt::PrintChars, char const*, char const*) | void Stream::WriteMemoryDump(const void* start,
size_t size,
size_t offset,
PrintChars print_chars,
const char* prefix,
const char* desc) {
const uint8_t* p = static_cast<co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x14(%rsp)
movq %rcx, 0x18(%rsp)
testq %rdx, %rdx
jle 0x2fe1b
movq %r9, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
addq %rsi, %r15
subq %rsi, 0x18(%rsp)
movb $0x20, %bl
movq %r9, 0x20(%rsp)
testq %r14, %r14
je 0x2fcb... | /dcodeIO[P]wabt/src/stream.cc |
wabt::Stream::Truncate(unsigned long) | inline bool Failed(Result result) {
return result == Result::Error;
} | cmpl $0x1, 0x10(%rdi)
je 0x30012
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2ffed
leaq 0x99bb(%rip), %rsi # 0x3999b
movq %rbx, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2feb6
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
mov... | /dcodeIO[P]wabt/src/result.h |
wabt::MemoryStream::MemoryStream(wabt::Stream*) | MemoryStream::MemoryStream(Stream* log_stream)
: Stream(log_stream), buf_(new OutputBuffer()) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
leaq 0x13bee(%rip), %rax # 0x43cf8
movq %rax, (%rdi)
movl $0x18, %edi
callq 0x201b0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
... | /dcodeIO[P]wabt/src/stream.cc |
wabt::MemoryStream::MemoryStream(std::unique_ptr<wabt::OutputBuffer, std::default_delete<wabt::OutputBuffer>>&&, wabt::Stream*) | MemoryStream::MemoryStream(std::unique_ptr<OutputBuffer>&& buf,
Stream* log_stream)
: Stream(log_stream), buf_(std::move(buf)) {} | xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
leaq 0x13bb2(%rip), %rcx # 0x43cf8
movq %rcx, (%rdi)
movq (%rsi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, (%rsi)
retq
| /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::FileStream(wabt::string_view, wabt::Stream*) | FileStream::FileStream(string_view filename, Stream* log_stream)
: Stream(log_stream), file_(nullptr), offset_(0), should_close_(false) {
std::string filename_str = filename.to_string();
file_ = fopen(filename_str.c_str(), "wb");
// TODO(binji): this is pretty cheesy, should come up with a better API.
if (... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
leaq 0x13a74(%rip), %rcx # 0x43d38
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x8(%rsp), ... | /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::FileStream(wabt::FileStream&&) | FileStream::FileStream(FileStream&& other) {
*this = std::move(other);
} | xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x139d2(%rip), %rax # 0x43d38
movq %rax, (%rdi)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
movb 0x30(%rsi), %al
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
movb $0x... | /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::WriteDataImpl(unsigned long, void const*, unsigned long) | Result FileStream::WriteDataImpl(size_t at, const void* data, size_t size) {
if (!file_) {
return Result::Error;
}
if (size == 0) {
return Result::Ok;
}
if (at != offset_) {
if (fseek(file_, at, SEEK_SET) != 0) {
ERROR("fseek offset=%" PRIzd " failed, errno=%d\n", size, errno);
return ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq 0x20(%rdi), %rcx
movl $0x1, %ebx
testq %rcx, %rcx
je 0x30463
testq %r14, %r14
je 0x30461
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
cmpq %rsi, 0x28(%rdi)
je 0x30447
movq %rcx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x201d0
testl %eax, ... | /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::MoveDataImpl(unsigned long, unsigned long, unsigned long) | Result FileStream::MoveDataImpl(size_t dst_offset,
size_t src_offset,
size_t size) {
if (!file_) {
return Result::Error;
}
if (size == 0) {
return Result::Ok;
}
// TODO(binji): implement if needed.
ERROR0("FileStream::MoveDataImpl not i... | movl $0x1, %eax
cmpq $0x0, 0x20(%rdi)
je 0x30497
xorl %eax, %eax
testq %rcx, %rcx
jne 0x30498
retq
pushq %rax
callq 0x205cb
movl $0x1, %eax
addq $0x8, %rsp
retq
| /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::CreateStderr() | std::unique_ptr<FileStream> FileStream::CreateStderr() {
return std::unique_ptr<FileStream>(new FileStream(stderr));
} | pushq %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0x201b0
movq 0x13ac1(%rip), %rcx # 0x43fe0
movq (%rcx), %rcx
xorl %edx, %edx
movq %rdx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rdx, 0x18(%rax)
leaq 0x137fe(%rip), %rsi # 0x43d38
movq %rsi, (%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movb $0x0, 0x30(%rax)
m... | /dcodeIO[P]wabt/src/stream.cc |
wabt::string_view::find(char const*, unsigned long, unsigned long) const | string_view::size_type string_view::find(const char* s,
size_type pos,
size_type n) const {
return find(string_view(s, n), pos);
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r8
cmpq %rdx, %r8
cmovbq %r8, %rdx
movq (%rdi), %rsi
leaq (%rdx,%rsi), %rdi
addq %r8, %rsi
addq %rax, %rcx
movq %rax, %rdx
callq 0x30d8a
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
movq %rax, %rsi
subq %rcx, %rsi
cmpq %rdx, %rax
movq $-0x1, %rax
cmo... | /dcodeIO[P]wabt/src/string-view.cc |
wabt::string_view::find(char const*, unsigned long) const | string_view::size_type string_view::find(const char* s, size_type pos) const {
return find(string_view(s), pos);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x200b0
movq 0x8(%r15), %rcx
cmpq %rbx, %rcx
cmovbq %rcx, %rbx
movq (%r15), %rsi
addq %rsi, %rbx
addq %rcx, %rsi
leaq (%rax,%r14), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x30d8a
movq (%r15), %rcx
movq 0x8(%r15), %... | /dcodeIO[P]wabt/src/string-view.cc |
wabt::string_view::rfind(wabt::string_view, unsigned long) const | string_view::size_type string_view::rfind(string_view s, size_type pos) const
noexcept {
pos = std::min(std::min(pos, size_ - s.size_) + s.size_, size_);
reverse_iterator iter = std::search(reverse_iterator(begin() + pos), rend(),
s.rbegin(), s.rend());
return iter == ren... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq %rax, %rdx
subq %rbx, %rdx
cmpq %rcx, %rdx
cmovaeq %rcx, %rdx
addq %rbx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq (%rdi), %rcx
addq %rcx, %rdx
leaq (%rsi,%rbx), %rdi
leaq 0x28(%rsp), %rax
movq %rdx, (%rax)
lea... | /dcodeIO[P]wabt/src/string-view.cc |
wabt::Color::SupportsColor(_IO_FILE*) | bool Color::SupportsColor(FILE* file) {
char* force = getenv("FORCE_COLOR");
if (force) {
return atoi(force) != 0;
}
#if _WIN32
{
#if HAVE_WIN32_VT100
HANDLE handle;
if (file == stdout) {
handle = GetStdHandle(STD_OUTPUT_HANDLE);
} else if (file == stderr) {
handle = GetStdHandle(S... | pushq %rbx
movq %rdi, %rbx
leaq 0x8f89(%rip), %rdi # 0x3a208
callq 0x20240
testq %rax, %rax
je 0x31293
movq %rax, %rdi
callq 0x20290
jmp 0x312a2
movq %rbx, %rdi
callq 0x201c0
movl %eax, %edi
callq 0x202c0
testl %eax, %eax
setne %al
popq %rbx
retq
nop
| /dcodeIO[P]wabt/src/color.cc |
wabt::LexerSource::ReadRange(wabt::Range<unsigned long>, std::vector<char, std::allocator<char>>*) | Result LexerSource::ReadRange(OffsetRange range, std::vector<char>* out_data) {
OffsetRange clamped = range;
clamped.start = std::min(clamped.start, size_);
clamped.end = std::min(clamped.end, size_);
if (clamped.size()) {
out_data->resize(clamped.size());
const void* src = static_cast<const char*>(data... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
cmovbq %rax, %r14
cmpq %rdx, %rax
cmovbq %rax, %rbx
subq %r14, %rbx
je 0x313a2
movq %rcx, %r15
movq %rdi, %r12
movq %rcx, %rdi
movq %rbx, %rsi
callq 0x313b0
addq (%r12), %r14
movq (%r15), %rdi
mov... | /dcodeIO[P]wabt/src/lexer-source.cc |
main | int main( int argc, char *argv[] )
{
int ret = 0;
mbedtls_pk_context key;
char buf[1024];
int i;
char *p, *q;
/*
* Set to sane values
*/
mbedtls_pk_init( &key );
memset( buf, 0, sizeof( buf ) );
if( argc == 0 )
{
usage:
ret = 1;
mbedtls_printf( USA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4298, %rsp # imm = 0x4298
movq %rsi, %rbx
movl %edi, %ebp
movq %rsp, %rdi
callq 0x12738
leaq 0x10(%rsp), %rdi
movl $0x400, %edx # imm = 0x400
xorl %esi, %esi
callq 0xa0d0
testl %ebp, %ebp
je 0xa5b0
andl $0x0, 0x39e2e(%rip) ... | /Dragonchang[P]https_client/mbedtls/programs/pkey/key_app_writer.c |
mbedtls_mpi_grow | int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs )
{
mbedtls_mpi_uint *p;
if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
if( X->n < nblimbs )
{
if( ( p = (mbedtls_mpi_uint*)mbedtls_calloc( nblimbs, ciL ) ) == NULL )
return( MBEDTLS_ERR_MPI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x10
popq %rbp
cmpq $0x2710, %rsi # imm = 0x2710
ja 0xaa2e
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
jae 0xaa2c
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0xa0f0
testq %rax, %rax
je 0xaa2e
movq %rax... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_copy | int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y )
{
int ret;
size_t i;
if( X == Y )
return( 0 );
if( Y->p == NULL )
{
mbedtls_mpi_free( X );
return( 0 );
}
for( i = Y->n - 1; i > 0; i-- )
if( Y->p[i] != 0 )
break;
i++;
X->s =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
cmpq %rsi, %rdi
je 0xab77
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0xab6f
movq 0x8(%r14), %rdx
leaq (,%rdx,8), %rcx
negq %rcx
movq %rdx, %rsi
movq %rcx, %r15
cmpq $0x1, %rdx
je 0xab32
leaq 0x8(%r15), %rcx
leaq -0x1(%... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_safe_cond_swap | int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char swap )
{
int ret, s;
size_t i;
mbedtls_mpi_uint tmp;
if( X == Y )
return( 0 );
/* make sure swap is 0 or 1 in a time-constant manner */
swap = (swap | (unsigned char)-swap) >> 7;
MBEDTLS_MPI_CHK( mbedtls... | cmpq %rsi, %rdi
je 0xac62
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rsi
callq 0xa9bb
testl %eax, %eax
jne 0xac5c
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0xa9bb
testl %eax, %eax
je 0xac65
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
testb %bl, %bl
mov... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_set_bit | int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0 )
return( 0 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
cmpb $0x1, %bpl
jbe 0xad35
pushq $-0x4
popq %rax
jmp 0xad89
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x6, %r15
movq 0x8(%rdi), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0xad70
andl $0x3f, %ebx
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %r... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_bitlen | size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
{
size_t i, j;
if( X->n == 0 )
return( 0 );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
break;
j = biL - mbedtls_clz( X->p[i] );
return( ( i * biL ) + j );
} | movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0xae05
movq 0x10(%rdi), %rdx
movq %rsi, %rax
shlq $0x6, %rax
addq $0x40, %rax
decq %rsi
movq %rsi, %rdi
subq $0x1, %rdi
jb 0xae08
movq (%rdx,%rsi,8), %rcx
addq $-0x40, %rax
movq %rdi, %rsi
testq %rcx, %rcx
je 0xaded
jmp 0xae0e
xorl %eax, %eax
retq
movq (%rdx), %rcx
pushq $0x40
p... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_shift_l | int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count )
{
int ret;
size_t i, v0, t1;
mbedtls_mpi_uint r0 = 0, r1;
v0 = count / (biL );
t1 = count & (biL - 1);
i = mbedtls_mpi_bitlen( X ) + count;
if( X->n * biL < i )
MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, BITS_TO_LIMBS( i ) ) );... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xadcf
addq %r14, %rax
movq 0x8(%rbx), %rcx
shlq $0x6, %rcx
cmpq %rax, %rcx
jae 0xb5ea
movq %rax, %rsi
shrq $0x6, %rsi
andl $0x3f, %eax
cmpq $0x1, %rax
sbbq $-0x1, %rsi
movq %rbx, %rdi
callq 0xa9bb
testl %eax, %eax
jne 0xb673
movq %r14, %rdi
shrq $0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_cmp_mpi | int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
break;
if( i == 0 && j == 0 )
return( 0 );
if( i > j )... | movq 0x8(%rdi), %rax
movq %rax, %rcx
subq $0x1, %rax
jb 0xb7a7
movq 0x10(%rdi), %rdx
cmpq $0x0, (%rdx,%rax,8)
je 0xb793
movq 0x8(%rsi), %rax
movq %rax, %rdx
subq $0x1, %rax
jb 0xb7bf
movq 0x10(%rsi), %r8
cmpq $0x0, (%r8,%rax,8)
je 0xb7ab
xorl %eax, %eax
movq %rdx, %r8
orq %rcx, %r8
je 0xb81e
cmpq %rdx, %rcx
jbe 0xb7d1
... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_sub_mpi | int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s > 0 )
{
if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %ebp
movl (%rdx), %eax
imull %ebp, %eax
testl %eax, %eax
jle 0xbb08
movq %r15, %rdi
movq %r14, %rsi
callq 0xb726
movq %rbx, %rdi
testl %eax, %eax
js 0xbb1c
movq %r15, %rsi
movq %r14, %rdx
callq 0xb954
jmp... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_mul_hlp | __attribute__ ((noinline))
#endif
void mpi_mul_hlp( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )
{
mbedtls_mpi_uint c = 0, t = 0;
#if defined(MULADDC_HUIT)
for( ; i >= 8; i -= 8 )
{
MULADDC_INIT
MULADDC_HUIT
MULADDC_STOP
}
for( ; i > 0; i-- )
... | pushq %rbx
movq %rcx, %rbx
movq %rdi, %r9
xorl %ecx, %ecx
cmpq $0xf, %r9
jbe 0xbfa2
movq %rdx, %rdi
xorq %r8, %r8
movq (%rsi), %rax
mulq %rbx
addq $0x8, %rsi
addq %rcx, %rax
movq %r8, %rcx
adcq $0x0, %rdx
nop
addq %rax, (%rdi)
adcq %rdx, %rcx
addq $0x8, %rdi
movq (%rsi), %rax
mulq %rbx
addq $0x8, %rsi
addq %rcx, %rax
m... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_inv_mod | int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
{
int ret;
mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TU ); mbedtls_mpi_init( &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
xorl %esi, %esi
callq 0xb81f
testl %eax, %eax
jle 0xd125
pushq $0x1
popq %rax
movl %eax, 0x78(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x80(%rsp)
movl %eax, (%rsp)
movups %xmm... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_check_small_factors | static int mpi_check_small_factors( const mbedtls_mpi *X )
{
int ret = 0;
size_t i;
mbedtls_mpi_uint r;
if( ( X->p[0] & 1 ) == 0 )
return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
for( i = 0; small_prime[i] > 0; i++ )
{
if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
pushq $-0xe
popq %rbx
testb $0x1, (%rax)
je 0xd5be
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x2022c(%rip), %rbp # 0x2d7a0
movq %rsp, %r15
cmpq $0x29c, %r13 # imm = 0x29C
je 0xd5b3
movl (%r13,%rbp), %r12d
movq... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
pk_hashlen_helper | static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
{
const mbedtls_md_info_t *md_info;
if( *hash_len != 0 )
return( 0 );
if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
return( -1 );
*hash_len = mbedtls_md_get_size( md_info );
return(... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, (%rsi)
jne 0x128fb
movq %rsi, %r14
callq 0x1ee97
testq %rax, %rax
je 0x128f8
movq %rax, %rdi
callq 0x1f3d3
movzbl %al, %eax
movq %rax, (%r14)
jmp 0x128fb
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/pk.c |
mbedtls_pk_parse_subpubkey | int mbedtls_pk_parse_subpubkey( unsigned char **p, const unsigned char *end,
mbedtls_pk_context *pk )
{
int ret;
size_t len;
mbedtls_asn1_buf alg_params;
mbedtls_pk_type_t pk_alg = MBEDTLS_PK_NONE;
const mbedtls_pk_info_t *pk_info;
if( ( ret = mbedtls_asn1_get_tag( p, en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r14
andl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdx
pushq $0x30
popq %rcx
callq 0x18603
testl %eax, %eax
je 0x136fb
movl %eax, %ebp
addl $0xffffc300, %ebp # imm = 0xFFFFC300
jmp 0x13750
movq (%r14), %r15
addq... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
pk_parse_key_sec1_der | static int pk_parse_key_sec1_der( mbedtls_ecp_keypair *eck,
const unsigned char *key,
size_t keylen )
{
int ret;
int version, pubkey_done;
size_t len;
mbedtls_asn1_buf params;
unsigned char *p = (unsigned char *) key;
unsigned c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rsi, (%rdi)
addq %rdx, %rsi
leaq 0x8(%rsp), %rdx
pushq $0x30
popq %rcx
callq 0x18603
testl %eax, %eax
jne 0x13fc2
movq %rsp, %rdi
movq (%rdi), %r15
addq 0x8(%rsp), %r15
leaq 0x14(%rsp), %rdx
movq %r15, %rsi
cal... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
pk_parse_key_pkcs8_unencrypted_der | static int pk_parse_key_pkcs8_unencrypted_der(
mbedtls_pk_context *pk,
const unsigned char* key,
size_t keylen )
{
int ret, version;
size_t len;
mbedtls_asn1_buf params;
unsigned char *p = (unsign... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
addq %rdx, %rsi
andl $0x0, 0xc(%rsp)
leaq 0x18(%rsp), %rdx
pushq $0x30
popq %rcx
callq 0x18603
testl %eax, %eax
jne 0x141ee
leaq 0x10(%rsp), %rdi
movq (%rdi), %r14
addq 0x18(%rsp), %r14
leaq 0x24(%rsp), %rdx
movq %... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
pk_parse_key_pkcs8_encrypted_der | static int pk_parse_key_pkcs8_encrypted_der(
mbedtls_pk_context *pk,
const unsigned char *key, size_t keylen,
const unsigned char *pwd, size_t pwdlen )
{
int ret, decrypted = 0;
size_t len;
unsigned c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x868, %rsp # imm = 0x868
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x60(%rsp), %r12
movl $0x800, %edx # imm = 0x800
movq %r12, %rdi
xorl %esi, %esi
callq 0xa0d0
movq %r13, 0x20(%rsp)
... | /Dragonchang[P]https_client/mbedtls/library/pkparse.c |
mbedtls_pk_write_pubkey_der | int mbedtls_pk_write_pubkey_der( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char *c;
size_t len = 0, par_len = 0, oid_len;
const char *oid;
c = buf + size;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_pk_write_pubkey( &c, buf, key ) );
if( c - buf < 1 )
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movq %r15, %rdx
callq 0x144d8
movl %eax, %ebx
testl %eax, %eax
js 0x146a5
movq 0x8(%rsp), %rax
movq %rax, %rcx
subq %r14, %rcx
testq %rcx, %rcx
jle 0x14699
leaq ... | /Dragonchang[P]https_client/mbedtls/library/pkwrite.c |
mbedtls_pk_write_pubkey_pem | int mbedtls_pk_write_pubkey_pem( mbedtls_pk_context *key, unsigned char *buf, size_t size )
{
int ret;
unsigned char output_buf[PUB_DER_MAX_BYTES];
size_t olen = 0;
if( ( ret = mbedtls_pk_write_pubkey_der( key, output_buf,
sizeof(output_buf) ) ) < 0 )
{
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x840, %rsp # imm = 0x840
movq %rdx, %rbx
movq %rsi, %r14
andq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movl $0x826, %edx # imm = 0x826
movq %r15, %rsi
callq 0x14603
testl %eax, %eax
js 0x14b35
movl %eax, %ecx
subq %rcx, %r15
addq $0x826, %r15 # imm =... | /Dragonchang[P]https_client/mbedtls/library/pkwrite.c |
mbedtls_rsa_private | int mbedtls_rsa_private( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
const unsigned char *input,
unsigned char *output )
{
int ret;
size_t olen;
mbedtls_mpi T, T1, T2;
/* Make sure we have priv... | movl $0xffffbf80, %eax # imm = 0xFFFFBF80
cmpq $0x0, 0x68(%rdi)
je 0x155a7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
cmpq $0x0, 0x80(%rdi)
je 0x15599
cmpq $0x0, 0x50(%r14)
je 0x15599
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
leaq 0x10(%... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mgf_mask | static void mgf_mask( unsigned char *dst, size_t dlen, unsigned char *src,
size_t slen, mbedtls_md_context_t *md_ctx )
{
unsigned char mask[MBEDTLS_MD_MAX_SIZE];
unsigned char counter[4];
unsigned char *p;
unsigned int hlen;
size_t i, use_len;
memset( mask, 0, MBEDTLS_MD_M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
leaq 0x4(%rsp), ... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_pkcs1_decrypt | int mbedtls_rsa_pkcs1_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
const unsigned char *input,
unsigned char *output,
... | movq %r9, %r10
movq %r8, %rax
movl 0x148(%rdi), %r8d
cmpl $0x1, %r8d
je 0x160dc
testl %r8d, %r8d
jne 0x160f9
movq %rax, %r8
movq %r10, %r9
jmp 0x15f7e
pushq %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq 0x18(%rsp)
pushq 0x18(%rsp)
pushq %r10
pushq %rax
callq 0x15d26
addq $0x20, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax ... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_pkcs1_verify | int mbedtls_rsa_pkcs1_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsigned int hashlen,
const unsigned... | movl 0x148(%rdi), %eax
cmpl $0x1, %eax
je 0x168b8
testl %eax, %eax
jne 0x16b8e
pushq %rax
pushq 0x18(%rsp)
pushq 0x18(%rsp)
callq 0x168db
popq %rcx
popq %rdx
popq %rcx
retq
movl $0xffffbf00, %eax # imm = 0xFFFFBF00
retq
| /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_asn1_get_bool | int mbedtls_asn1_get_bool( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_BOOLEAN ) ) != 0 )
return( ret );
if( len != 1 )
return( MBEDTLS_ERR_ASN1_INVALID... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdx
pushq $0x1
popq %rcx
callq 0x18603
testl %eax, %eax
jne 0x18668
cmpq $0x1, (%rsp)
jne 0x18665
movq (%rbx), %rax
xorl %ecx, %ecx
cmpb $0x0, (%rax)
setne %cl
movl %ecx, (%r14)
incq %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x18668
pushq $-0... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_int | int mbedtls_asn1_get_int( unsigned char **p,
const unsigned char *end,
int *val )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len, MBEDTLS_ASN1_INTEGER ) ) != 0 )
return( ret );
if( len == 0 || len > sizeof( int ) || ( **p & 0x80 ) != 0... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %rdx
pushq $0x2
popq %rcx
callq 0x18603
testl %eax, %eax
jne 0x186c5
movq (%rsp), %rcx
leaq -0x5(%rcx), %rdx
pushq $-0x64
popq %rax
cmpq $-0x4, %rdx
jb 0x186c5
movq (%r14), %rdx
cmpb $0x0, (%rdx)
js 0x186c5
andl $0x0, (%rbx)
incq %rdx
xorl %eax... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_bitstring | int mbedtls_asn1_get_bitstring( unsigned char **p, const unsigned char *end,
mbedtls_asn1_bitstring *bs)
{
int ret;
/* Certificate type is a single byte bitstring */
if( ( ret = mbedtls_asn1_get_tag( p, end, &bs->len, MBEDTLS_ASN1_BIT_STRING ) ) != 0 )
return( ret );
/*... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3
popq %rcx
callq 0x18603
testl %eax, %eax
jne 0x18767
movq (%r15), %rax
testq %rax, %rax
je 0x18747
decq %rax
movq %rax, (%r15)
movq (%r14), %rcx
movb (%rcx), %dl
movb %dl, 0x8(%r15)
cmpb $0x7, %dl
jbe 0x1874c
pushq $-0x64
jmp 0x... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_get_alg | int mbedtls_asn1_get_alg( unsigned char **p,
const unsigned char *end,
mbedtls_asn1_buf *alg, mbedtls_asn1_buf *params )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
pushq $0x30
popq %rcx
callq 0x18603
testl %eax, %eax
je 0x188af
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %r15
subq %r15... | /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_asn1_write_mpi | int mbedtls_asn1_write_mpi( unsigned char **p, unsigned char *start, const mbedtls_mpi *X )
{
int ret;
size_t len = 0;
// Write the MPI
//
len = mbedtls_mpi_size( X );
if( *p < start || (size_t)( *p - start ) < len )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
(*p) -= len;
MBEDT... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rdi
callq 0xae34
movq %rax, %r15
movq (%r14), %rsi
pushq $-0x6c
popq %rbx
movq %rsi, %rax
subq %r12, %rax
jb 0x18c10
cmpq %r15, %rax
jb 0x18c10
subq %r15, %rsi
movq %rsi, (%r14)
movq %r13, %rdi
movq %r15, ... | /Dragonchang[P]https_client/mbedtls/library/asn1write.c |
mbedtls_ecdsa_write_signature | int mbedtls_ecdsa_write_signature( mbedtls_ecdsa_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hlen,
unsigned char *sig, size_t *slen,
int (*f_rng)(void *, unsigned char *, size_t),
vo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0xa960
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xa960
leaq 0xf8(%r13), %rcx
movl %e... | /Dragonchang[P]https_client/mbedtls/library/ecdsa.c |
mbedtls_ecp_copy | int mbedtls_ecp_copy( mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->X, &Q->X ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Y, &Q->Y ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Z, &Q->Z ) );
cleanup:
return( ret );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xaaea
testl %eax, %eax
jne 0x19dbf
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0xaaea
testl %eax, %eax
je 0x19dc7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x30, %r14
addq $0x30, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq ... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_point_read_string | int mbedtls_ecp_point_read_string( mbedtls_ecp_point *P, int radix,
const char *x, const char *y )
{
int ret;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &P->X, radix, x ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &P->Y, radix, y ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &P->Z... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xae44
testl %eax, %eax
jne 0x19ea3
leaq 0x18(%rbx), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0xae44
testl %eax, %eax
je 0x19ea8
popq %rbx
popq %r14
popq %rbp
retq
addq $0x30, %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
pop... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_tls_write_group | int mbedtls_ecp_tls_write_group( const mbedtls_ecp_group *grp, size_t *olen,
unsigned char *buf, size_t blen )
{
const mbedtls_ecp_curve_info *curve_info;
if( ( curve_info = mbedtls_ecp_curve_info_from_grp_id( grp->id ) ) == NULL )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
... | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl (%rdi), %edi
callq 0x19bd8
testq %rax, %rax
je 0x1a175
movq $0x3, (%r15)
movl $0xffffb100, %ecx # imm = 0xFFFFB100
cmpq $0x3, %r14
jb 0x1a17a
movb $0x3, (%rbx)
movb 0x5(%rax), %cl
movb %cl, 0x1(%rbx)
movb 0x4(%rax), %al
movb %al... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_ecp_self_test | int mbedtls_ecp_self_test( int verbose )
{
int ret;
size_t i;
mbedtls_ecp_group grp;
mbedtls_ecp_point R, P;
mbedtls_mpi m;
unsigned long add_c_prev, dbl_c_prev, mul_c_prev;
/* exponents especially adapted for secp192r1 */
const char *exponents[] =
{
"000000000000000000000000... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edi, %ebp
leaq 0xc0(%rsp), %r14
movl $0xf8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xa0d0
leaq 0x30(%rsp), %rdi
callq 0x19c43
leaq 0x78(%rsp), %rdi
callq 0x19c43
leaq 0x10(%rsp), %rdi
callq 0xa960
push... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
ecp_mod_p224 | static int ecp_mod_p224( mbedtls_mpi *N )
{
INIT( 224 );
SUB( 7 ); SUB( 11 ); NEXT; // A0 += -A7 - A11
SUB( 8 ); SUB( 12 ); NEXT; // A1 += -A8 - A12
SUB( 9 ); SUB( 13 ); NEXT; // A2 += -A9 - A13
SUB( 10 ); ADD( 7 ); ADD( 11 ); NEXT; // A3 += -A10 + A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movl $0x1, 0x18(%rsp)
movq $0x4, 0x20(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
pushq $0x7
popq %r14
movq %r14, %rsi
callq 0xa9bb
movl %eax, %ebp
te... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
ecp_mod_p384 | static int ecp_mod_p384( mbedtls_mpi *N )
{
INIT( 384 );
ADD( 12 ); ADD( 21 ); ADD( 20 );
SUB( 23 ); NEXT; // A0
ADD( 13 ); ADD( 22 ); ADD( 23 );
SUB( 12 ); SUB( 20 ); NEXT; // A2
ADD( 14 ); ADD( 23 );
SUB( 13 ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movl $0x1, 0x18(%rsp)
movq $0x7, 0x20(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
andq $0x0, 0x30(%rax)
pushq $0xc
popq %r14
... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.c |
ecp_mod_p521 | static int ecp_mod_p521( mbedtls_mpi *N )
{
int ret;
size_t i;
mbedtls_mpi M;
mbedtls_mpi_uint Mp[P521_WIDTH + 1];
/* Worst case for the size of M is when mbedtls_mpi_uint is 16 bits:
* we need to hold bits 513 to 1056, which is 34 limbs, that is
* P521_WIDTH + 1. Otherwise P521_WIDTH is e... | movq 0x8(%rdi), %rcx
xorl %eax, %eax
cmpq $0x9, %rcx
jb 0x1e2ab
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl $0x1, (%r15)
addq $-0x8, %rcx
cmpq $0xa, %rcx
pushq $0xa
popq %rdx
cmovbq %rcx, %rdx
movq %rdx, 0x8(%r15)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x10(%r15)
movq 0x10(%rbx... | /Dragonchang[P]https_client/mbedtls/library/ecp_curves.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 0x1f3d3
cmpq $0x400, %r15 # imm = 0x400
jbe 0x1e90f
pushq $-0x3
jmp 0x1e91a
cmpq $0x100, %r13 # imm = 0x100
jbe ... | /Dragonchang[P]https_client/mbedtls/library/hmac_drbg.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 0x1efb7
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq *0x38(%rsi)
movq %rax, 0x8(%r14)
movl $0xffffae80, %ebp # imm = 0xFFFFAE80
test... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_md_file | int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
{
int ret;
FILE *f;
size_t n;
mbedtls_md_context_t ctx;
unsigned char buf[1024];
if( md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
if( ( f = fopen( path, "rb" ) ) == NULL )... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp # imm = 0x428
testq %rdi, %rdi
je 0x1f0d9
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x123b5(%rip), %rax # 0x3141f
movq %rsi, %rdi
movq %rax, %rsi
callq 0xa160
testq %rax, %rax
je 0x1f0ff
movq %rax, %r14
xorps %xmm0, %xmm0
mova... | /Dragonchang[P]https_client/mbedtls/library/md.c |
mbedtls_pem_read_buffer | int mbedtls_pem_read_buffer( mbedtls_pem_context *ctx, const char *header, const char *footer,
const unsigned char *data, const unsigned char *pwd,
size_t pwdlen, size_t *use_len )
{
int ret, enc;
size_t len;
unsigned char *buf;
const unsigned char *s1, *s2, *en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
testq %rdi, %rdi
je 0x1fc3c
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq %rcx, %rdi
callq 0xa180
movl $0xffffef80, %ebp # imm = 0xFFFFEF80
... | /Dragonchang[P]https_client/mbedtls/library/pem.c |
mbedtls_pkcs5_self_test | int mbedtls_pkcs5_self_test( int verbose )
{
mbedtls_md_context_t sha1_ctx;
const mbedtls_md_info_t *info_sha1;
int ret, i;
unsigned char key[64];
mbedtls_md_init( &sha1_ctx );
info_sha1 = mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
if( info_sha1 == NULL )
{
ret = 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edi, %r12d
leaq 0x18(%rsp), %rdi
callq 0x1eeb0
pushq $0x4
popq %rdi
callq 0x1ee97
testq %rax, %rax
je 0x2116d
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rbx
movq %rax, %rsi
movl %ebx, %edx
callq 0x1ef56
testl %eax, %eax
jne 0x21170
lea... | /Dragonchang[P]https_client/mbedtls/library/pkcs5.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_sha512_self_test | int mbedtls_sha512_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char *buf;
unsigned char sha512sum[64];
mbedtls_sha512_context ctx;
buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
if( NULL == buf )
{
if( verbose != 0 )
mbedtls_printf( "Buffer al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %edi, %r12d
pushq $0x1
popq %rsi
movl $0x400, %edi # imm = 0x400
callq 0xa0f0
testq %rax, %rax
je 0x24526
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movl $0xd8, %edx
movq %r14, %rdi
xorl %esi, %esi
ca... | /Dragonchang[P]https_client/mbedtls/library/sha512.c |
mbedtls_aes_setkey_dec | int mbedtls_aes_setkey_dec( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
int i, j, ret;
mbedtls_aes_context cty;
uint32_t *RK;
uint32_t *SK;
mbedtls_aes_init( &cty );
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_PADLOCK_ALIGN16)
if( aes_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movl $0x120, %edx # imm = 0x120
movq %r12, %rdi
xorl %esi, %esi
callq 0xa0d0
leaq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r12, ... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_decrypt | void mbedtls_aes_decrypt( mbedtls_aes_context *ctx,
const unsigned char input[16],
unsigned char output[16] )
{
int i;
uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
RK = ctx->rk;
GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++;
GET_UINT32_LE( X1, inp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
movl 0x4(%rax), %r8d
xorl (%rsi), %ecx
xorl 0x4(%rsi), %r8d
movq %rdx, -0x8(%rsp)
movl 0x8(%rax), %r11d
xorl 0x8(%rsi), %r11d
movl 0xc(%rax), %r15d
xorl 0xc(%rsi), %r15d
movl (%rdi), %edx
sarl %edx
addq $0x2c, %rax
... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_arc4_self_test | int mbedtls_arc4_self_test( int verbose )
{
int i, ret = 0;
unsigned char ibuf[8];
unsigned char obuf[8];
mbedtls_arc4_context ctx;
mbedtls_arc4_init( &ctx );
for( i = 0; i < 3; i++ )
{
if( verbose != 0 )
mbedtls_printf( " ARC4 test #%d: ", i + 1 );
memcpy( ib... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edi, %ebx
leaq 0x10(%rsp), %r14
movl $0x108, %edx # imm = 0x108
movq %r14, %rdi
xorl %esi, %esi
callq 0xa0d0
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r15
leaq 0xe251(%rip), %r12 # 0x346f0
xorl... | /Dragonchang[P]https_client/mbedtls/library/arc4.c |
mbedtls_cipher_info_from_values | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_d... | leaq 0x1cd63(%rip), %rcx # 0x43780
addq $0x8, %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x26a42
movq 0x28(%rax), %r8
cmpl %edi, (%r8)
jne 0x26a3c
cmpl %esi, 0x8(%rax)
jne 0x26a3c
cmpl %edx, 0x4(%rax)
je 0x26a42
addq $0x10, %rcx
jmp 0x26a21
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_update_ad | int mbedtls_cipher_update_ad( mbedtls_cipher_context_t *ctx,
const unsigned char *ad, size_t ad_len )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_MODE_GCM == ctx->cipher_info->mode )
{
return mbedtls_gcm_star... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x26c50
movq %rdx, %r9
movq %rdi, %rdx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x26c50
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x26c50
movq %rsi, %r8
movq 0x50(%rdx), %rdi
movl 0xc(%rdx), %esi
movq 0x48(%rdx), %rcx
addq $0x38, %rdx
jmp 0x28c8d
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x27289
movq (%rdi), %rcx
testq %rcx, %rcx
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x27289
cmpl $0x1, 0xc(%rdi)
jne 0x27289
xorl %eax, %eax
cmpl $0x6, 0x4(%rcx)
jne 0x27289
movq 0x50(%rdi), %rdi
jmp 0x290dd
retq
| /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_des3_crypt_ecb | int mbedtls_des3_crypt_ecb( mbedtls_des3_context *ctx,
const unsigned char input[8],
unsigned char output[8] )
{
int i;
uint32_t X, Y, T, *SK;
SK = ctx->sk;
GET_UINT32_BE( X, input, 0 );
GET_UINT32_BE( Y, input, 4 );
DES_IP( X, Y );
for( i = 0; i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %esi
shrl $0x4, %esi
xorl %eax, %esi
andl $0xf0f0f0f, %esi # imm = 0xF0F0F0F
xorl %esi, %eax
shll $0x4, %esi
xorl %ecx, %esi
movl %esi, %ecx
shrl $0x10... | /Dragonchang[P]https_client/mbedtls/library/des.c |
mbedtls_ccm_self_test | int mbedtls_ccm_self_test( int verbose )
{
mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
mbedtls_ccm_init( &ctx );
if( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( " CCM: setup f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edi, %r15d
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0xbf3a(%rip), %rdx # 0x37f... | /Dragonchang[P]https_client/mbedtls/library/ccm.c |
mbedtls_ecp_copy | int mbedtls_ecp_copy( mbedtls_ecp_point *P, const mbedtls_ecp_point *Q )
{
int ret;
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->X, &Q->X ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Y, &Q->Y ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &P->Z, &Q->Z ) );
cleanup:
return( ret );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e9a6
testl %eax, %eax
jne 0x256c7
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x1e9a6
testl %eax, %eax
je 0x256cf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x30, %r14
addq $0x30, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
pop... | /project-everest[P]mbedtls/library/ecp.c |
mbedtls_pk_setup | int mbedtls_pk_setup( mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info )
{
if( ctx == NULL || info == NULL || ctx->pk_info != NULL )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
if( ( ctx->pk_ctx = info->ctx_alloc_func() ) == NULL )
return( MBEDTLS_ERR_PK_ALLOC_FAILED );
ctx->pk_info = i... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffc180, %eax # imm = 0xFFFFC180
jne 0x337ab
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0x337a4
movq %rsi, %rbx
callq *0x48(%rsi)
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x3379f
movq %rbx, (%r14)
xorl %eax, %eax... | /project-everest[P]mbedtls/library/pk.c |
mbedtls_pk_verify | int mbedtls_pk_verify( mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
if( ctx == NULL || ctx->pk_info == NULL ||
pk_hashlen_helper( md_alg, &hash_len ) != 0 )
return( MBEDTLS_ER... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl $0xffffc180, %r12d # imm = 0xFFFFC180
testq %rdi, %rdi
je 0x33865
movq %rdi, %r13
cmpq $0x0, (%rdi)
je 0x33865
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rsp, %rsi
movl %ebp, %edi
callq 0x33... | /project-everest[P]mbedtls/library/pk.c |
pk_hashlen_helper | static inline int pk_hashlen_helper( mbedtls_md_type_t md_alg, size_t *hash_len )
{
const mbedtls_md_info_t *md_info;
if( *hash_len != 0 )
return( 0 );
if( ( md_info = mbedtls_md_info_from_type( md_alg ) ) == NULL )
return( -1 );
*hash_len = mbedtls_md_get_size( md_info );
return(... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, (%rsi)
jne 0x338db
movq %rsi, %r14
callq 0x31557
testq %rax, %rax
je 0x338d8
movq %rax, %rdi
callq 0x31ad6
movzbl %al, %eax
movq %rax, (%r14)
jmp 0x338db
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /project-everest[P]mbedtls/library/pk.c |
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.