name string | code string | asm string | file string |
|---|---|---|---|
net::TcpSocket::Accept(char*, unsigned int&) | int TcpSocket::Accept(char* fromIP, UINT& fromPort)
{
assert(fromIP != NULL);
sockaddr_in from;
memset(&from, 0, sizeof(struct sockaddr_in));
from.sin_family = AF_INET;
socklen_t len = sizeof(from);
int clientSock = -1;
if ((clientSock = accept(fd_, (sockaddr*) &from, &len)) < 0 )
re... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x2eb7
movq %rdx, %rbx
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movw $0x2, (%rsi)
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
movl 0x8(%rdi), %edi
callq 0x20a0
movl %eax, %ebp
testl %eax, %eax
js 0x2eac
movl 0x14(%rsp... | /distanceNing[P]benchmarkTool/socket/tcp_socket.cpp |
net::TcpSocket::read_n(void*, unsigned long) | ssize_t TcpSocket::read_n(void* msg, size_t buf_len)
{
assert(msg != NULL);
ssize_t recv_size = 0;
ssize_t a_recv_size;
while ((a_recv_size = ::read(fd_, (char*) msg + recv_size, buf_len - recv_size)) > 0) {
recv_size += a_recv_size;
if ( recv_size == buf_len )
break;
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x30f8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
movl 0x8(%r12), %edi
leaq (%r14,%r15), %rsi
movq %rbx, %rdx
subq %r15, %rdx
callq 0x2340
testq %rax, %rax
jle 0x30e9
addq %rax, %r15
cmpq %rbx, %r15
jne 0x30c5
movq %rbx, %... | /distanceNing[P]benchmarkTool/socket/tcp_socket.cpp |
net::TcpSocket::sockConnect(int, char const*, unsigned short) | bool TcpSocket::sockConnect(int fd, const char* conn_ip, uint16_t conn_port)
{
assert(conn_ip != NULL);
sockaddr_in conAddr;
memset(&conAddr, 0, sizeof(struct sockaddr_in));
conAddr.sin_family = AF_INET;
conAddr.sin_addr.s_addr = inet_addr(conn_ip);
conAddr.sin_port = htons(static_cast<uint16_t>... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x31ac
movl %edx, %ebp
movl %edi, %ebx
movq %rsp, %r14
movq $0x0, 0x8(%r14)
movw $0x2, (%r14)
movq %rsi, %rdi
callq 0x22b0
movl %eax, 0x4(%r14)
rolw $0x8, %bp
movw %bp, 0x2(%r14)
movl %ebx, %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2210
testl %ea... | /distanceNing[P]benchmarkTool/socket/tcp_socket.cpp |
Thread::threadFun(void*) | void* Thread::threadFun(void* arg)
{
Thread* thread= static_cast<Thread*>(arg);
thread->threadFun_();
return NULL;
} | pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x3872
movq %rdi, %rax
addq $0x8, %rdi
callq *0x20(%rax)
xorl %eax, %eax
popq %rcx
retq
callq 0x20f0
nop
| /distanceNing[P]benchmarkTool/thread/Thread.cpp |
addsig(int) | void addsig(int sig)
{
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = timerHandle;
sa.sa_flags |= SA_RESTART;
sigfillset(&sa.sa_mask);
sigaction(sig, &sa, NULL);
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2170
leaq -0x34(%rip), %rax # 0x3960
movq %rax, -0x8(%r14)
movl $0x10000000, 0x80(%r14) # imm = 0x10000000
movq %r14, %rdi
callq 0x20b0
movq %rsp, %rsi
movl %ebx, %edi
xorl %edx, %e... | /distanceNing[P]benchmarkTool/benckmark.cpp |
BenchMark::run() | void BenchMark::run()
{
g_is_loop = true;
//设置测试时间
addsig(SIGALRM);
addsig(SIGTERM);
alarm(gOption.duration_);
ThreadPool threadPool(gOption.thread_num_ - 1);
for (int i = 1; i < gOption.thread_num_; ++i) {
threadPool.appendTask(std::bind(&BenchMark::benchmark, this, i));
}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, (%rsp)
movb $0x1, 0x67f4(%rip) # 0xa298
leaq 0x38(%rsp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2170
leaq -0x15f(%rip), %r14 # 0x3960
movq %r14, -0x8(%rbx)
movl $0x10000000, %ebp # imm = ... | /distanceNing[P]benchmarkTool/benckmark.cpp |
Option::printDefautOption() | void Option::printDefautOption()
{
printf("Defaut Option : \n");
printf("\thost = 127.0.0.1\n"
"\ttimeout_ms = 3000\n"
"\tserver_port = 9000\n"
"\tconcurrent_num = 1024\n"
"\tis_keep_alive = true\n"
"\tduration ... | pushq %rax
leaq 0x266d(%rip), %rdi # 0x68d9
callq 0x2390
leaq 0x2672(%rip), %rdi # 0x68ea
callq 0x2390
leaq 0x2468(%rip), %rdi # 0x66ec
leaq 0x24f6(%rip), %rsi # 0x6781
xorl %eax, %eax
popq %rcx
jmp 0x2050
nop
| /distanceNing[P]benchmarkTool/benckmark.cpp |
Option::printCurrentOption() | void Option::printCurrentOption()
{
printf("Current Option : \n");
std::cout << "\thost = " << server_ip_ << "\n" << "\tserver_port = " << server_port_ << "\n"
<< "\ttimeout_ms = " << connect_timeout_ms_ << "\n" << "\tconcurrent_num = "
<< concurrent_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2703(%rip), %rdi # 0x69a6
callq 0x2390
movq 0x5d29(%rip), %r14 # 0x9fd8
leaq 0x24d5(%rip), %rsi # 0x678b
movl $0x16, %edx
movq %r14, %rdi
callq 0x22d0
movq (%rbx), %r15
testq %r15, %r15
je 0x42e7
movq %r15, %rdi
callq 0x2120
movq 0x5cfe(%rip), %rdi ... | /distanceNing[P]benchmarkTool/benckmark.cpp |
Option::process_parameters(int, char**) | int Option::process_parameters(int argc, char** argv)
{
int c;
while ((c = getopt(argc, argv, "h:p:t:c:aw:d:")) != -1) {
switch (c) {
case 'a':gOption.is_keep_alive_ = true;
break;
case 'h':gOption.server_ip_ = optarg;
break;
case 't':gOption.thread_num_ =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x23ad(%rip), %r14 # 0x6843
leaq 0x20c7(%rip), %r15 # 0x6564
movq 0x5b24(%rip), %r12 # 0x9fc8
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2070
cmpl $0x6f, %eax
jg 0x44d4
leal -0x61(%rax), %ecx
cmpl $0x... | /distanceNing[P]benchmarkTool/benckmark.cpp |
iutest::UnitTestImpl::ValidateTestPropertyName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool ValidateTestPropertyName(const ::std::string& name)
{
const char* ban[] = {
"name", "tests", "failures", "disabled", "skip", "errors", "time", "timestamp", "random_seed"
};
#if !defined(IUTEST_NO_FUNCTION_TEMPLATE_ORDERING)
return TestProperty::ValidateName(name, ban)... | pushq %rbx
subq $0x50, %rsp
movq %rdi, %rdx
leaq 0x119a7(%rip), %rsi # 0x32540
movq %rsp, %rax
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x48(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21477
cmpq %rbx, %rax
sete %al
addq $0x50, %rsp
popq %rbx
retq
nop
| /srz-zumix[P]iutest/include/internal/iutest_core_impl.hpp |
sqstd_aux_printerror(SQVM*) | static SQInteger _sqstd_aux_printerror(HSQUIRRELVM v)
{
SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) {
const SQChar *sErr = 0;
if(sq_gettop(v)>=1) {
if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) {
pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
}
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5120
testq %rax, %rax
je 0x5d5b
movq %rax, %r14
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x5270
testq %rax, %rax
jle 0x5d5b
movq %rsp, %rdx
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5110
testq %rax, %rax
js 0x5d44
movq (%rsp), %rdx
leaq 0x5437(%rip), %rsi # 0xb... | /albertodemichelis[P]squirrel/sqstdlib/sqstdaux.cpp |
blob_resize(SQVM*) | static SQInteger _blob_resize(HSQUIRRELVM v)
{
SETUP_BLOB(v);
SQInteger size;
sq_getinteger(v,2,&size);
if(!self->Resize(size))
return sq_throwerror(v,_SC("resize failed"));
return 0;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl $0x1, %esi
movl $0x80000002, %ecx # imm = 0x80000002
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x612e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6125
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x61... | /albertodemichelis[P]squirrel/sqstdlib/sqstdblob.cpp |
blob_swap4(SQVM*) | static SQInteger _blob_swap4(HSQUIRRELVM v)
{
SETUP_BLOB(v);
SQInteger num=(self->Len()-(self->Len()%4))>>2;
unsigned int *t=(unsigned int *)self->GetBuf();
for(SQInteger i = 0; i < num; i++) {
__swap_dword(&t[i]);
}
return 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x1, %esi
movl $0x80000002, %ecx # imm = 0x80000002
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x6291
movq (%rsp), %rdi
leaq 0x5021(%rip), %r14 # 0xb250
testq %rdi, %rdi
je 0x6298
movq (%rdi), %rax
callq *0x40(%rax... | /albertodemichelis[P]squirrel/sqstdlib/sqstdblob.cpp |
blob__get(SQVM*) | static SQInteger _blob__get(HSQUIRRELVM v)
{
SETUP_BLOB(v);
SQInteger idx;
if ((sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0)
{
sq_pushnull(v);
return sq_throwobject(v);
}
sq_getinteger(v,2,&idx);
if(idx < 0 || idx >= self->Len())
return sq_throwerror(v,_SC("index out of range"));
sq_p... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movl $0x1, %esi
movl $0x80000002, %ecx # imm = 0x80000002
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x63ef
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x63e6
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x63... | /albertodemichelis[P]squirrel/sqstdlib/sqstdblob.cpp |
blob__cloned(SQVM*) | static SQInteger _blob__cloned(HSQUIRRELVM v)
{
SQBlob *other = NULL;
{
if(SQ_FAILED(sq_getinstanceup(v,2,(SQUserPointer*)&other,(SQUserPointer)SQSTD_BLOB_TYPE_TAG,SQFalse)))
return SQ_ERROR;
}
//SQBlob *thisone = new SQBlob(other->Len());
SQBlob *thisone = new (sq_malloc(sizeof(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x2, %esi
movl $0x80000002, %ecx # imm = 0x80000002
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x6621
movl $0x30, %edi
callq 0x5470
movq %rax, %r14
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%... | /albertodemichelis[P]squirrel/sqstdlib/sqstdblob.cpp |
SQBlob::Resize(long long) | bool Resize(SQInteger n) {
if(!_owns) return false;
if(n != _allocated) {
unsigned char *newbuf = (unsigned char *)sq_malloc(n);
memset(newbuf,0,n);
if(_size > n)
memcpy(newbuf,_buf,n);
else
memcpy(newbuf,_buf,_size);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb 0x28(%rdi), %bl
cmpb $0x1, %bl
jne 0x6974
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, 0x10(%rdi)
je 0x6974
movq %r14, %rdi
callq 0x5470
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5240
movq 0x8(%r15), %rdx
movq 0x20(%r15), %rsi
cmpq ... | /albertodemichelis[P]squirrel/sqstdlib/sqstdblobimpl.h |
sqstd_createfile | SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own)
{
SQInteger top = sq_gettop(v);
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) {
sq_remove(v,-2); //removes the registry
sq_pushroottable(v); // push the this
sq_pushuse... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x5270
movq %rax, %r15
movq %rbx, %rdi
callq 0x5720
leaq 0x48ef(%rip), %rsi # 0xb2f2
movq $-0x1, %r14
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5030
movq %rbx, %rdi
movq $-0x2, %rsi
callq 0x5230
testq %rax, ... | /albertodemichelis[P]squirrel/sqstdlib/sqstdio.cpp |
sqstd_dofile | SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror)
{
//at least one entry must exist in order for us to push it as the environment
if(sq_gettop(v) == 0)
return sq_throwerror(v,_SC("environment table expected"));
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,prin... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5270
testq %rax, %rax
je 0x6e26
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x5530
movq $-0x1, %r15
testq %rax, %rax
js 0x6e54
movq %rbx, %rdi
movq $-0x2, %rsi
callq 0x5190
movl $0x1,... | /albertodemichelis[P]squirrel/sqstdlib/sqstdio.cpp |
g_io_loadfile(SQVM*) | SQInteger _g_io_loadfile(HSQUIRRELVM v)
{
const SQChar *filename;
SQBool printerror = SQFalse;
sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) {
sq_getbool(v,3,&printerror);
}
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,printerror)))
return 1;
return SQ_ERROR; //propagates t... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x5110
movq %rbx, %rdi
callq 0x5270
cmpq $0x3, %rax
jl 0x6f10
leaq 0x8(%rsp), %r14
movl $0x3, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x55b0
movq (%r14), %rdx
jmp 0x6f12
xorl %edx, %edx
movq 0x10(%... | /albertodemichelis[P]squirrel/sqstdlib/sqstdio.cpp |
g_io_dofile(SQVM*) | SQInteger _g_io_dofile(HSQUIRRELVM v)
{
const SQChar *filename;
SQBool printerror = SQFalse;
sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) {
sq_getbool(v,3,&printerror);
}
sq_push(v,1); //repush the this
if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQTrue,printerror)))
return... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq 0x8(%rsp), %rdx
movl $0x2, %esi
callq 0x5110
movq %rbx, %rdi
callq 0x5270
cmpq $0x3, %rax
jl 0x6f9e
movq %rsp, %rdx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x55b0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5190
movq 0x8(%rsp), %rsi
movq (%rsp), %rcx
movl $0x... | /albertodemichelis[P]squirrel/sqstdlib/sqstdio.cpp |
sqstd_rex_compile | SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
{
SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp()
exp->_eol = exp->_bol = NULL;
exp->_p = pattern;
exp->_nallocated = (SQInteger)scstrlen(pattern) * sizeof(SQChar);
exp->_nodes = (SQRe... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x68, %edi
callq 0x5470
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r15d
movq %r15, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %r15, (%rax)
movq 0x8(%rsp), %rax
movq %r14, 0x10(%rax)
movq %r14, %rdi
callq 0x51f0
m... | /albertodemichelis[P]squirrel/sqstdlib/sqstdrex.cpp |
sqstd_rex_matchnode(SQRex*, tagSQRexNode*, char const*, tagSQRexNode*) | static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str,SQRexNode *next)
{
SQRexNodeType type = node->type;
switch(type) {
case OP_GREEDY: {
//SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
SQRexNode *greedystop = NULL;
SQ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rdi, %r14
movl (%rsi), %r15d
leal -0x100(%r15), %eax
cmpl $0xd, %eax
ja 0x80eb
movq %rsi, %rbp
leaq 0x3791(%rip), %rcx # 0xb44c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x... | /albertodemichelis[P]squirrel/sqstdlib/sqstdrex.cpp |
sqstd_rex_element(SQRex*) | static SQInteger sqstd_rex_element(SQRex *exp)
{
SQInteger ret = -1;
switch(*exp->_p)
{
case '(': {
SQInteger expr;
exp->_p++;
if(*exp->_p =='?') {
exp->_p++;
sqstd_rex_expect(exp,':');
expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
jg 0x8357
cmpl $0x24, %ecx
je 0x8395
cmpl $0x28, %ecx
jne 0x8389
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movl $0x102, %esi # imm = 0x102
cmpb $0x3f, 0x1(%... | /albertodemichelis[P]squirrel/sqstdlib/sqstdrex.cpp |
sqstd_rex_parsenumber(SQRex*) | static SQInteger sqstd_rex_parsenumber(SQRex *exp)
{
SQInteger ret = *exp->_p-'0';
SQInteger positions = 10;
exp->_p++;
while(isdigit(*exp->_p)) {
ret = ret*10+(*exp->_p++-'0');
if(positions==1000000000) sqstd_rex_error(exp,_SC("overflow in numeric constant"));
positions *= 10;
... | pushq %rax
movq 0x10(%rdi), %rcx
movsbq (%rcx), %rax
addq $-0x30, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rdi)
movsbl 0x1(%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x89b5
addq $0x2, %rcx
movl $0xa, %edx
movq %rcx, 0x10(%rdi)
cmpq $0x3b9aca00, %rdx # imm = 0x3B9ACA00
je 0x89b7
leaq (%rax,%rax,4), %rax
mo... | /albertodemichelis[P]squirrel/sqstdlib/sqstdrex.cpp |
stream_readblob(SQVM*) | SQInteger _stream_readblob(HSQUIRRELVM v)
{
SETUP_STREAM(v);
SQUserPointer data,blobp;
SQInteger size,res;
sq_getinteger(v,2,&size);
if(size > self->Len()) {
size = self->Len();
}
data = sq_getscratchpad(v,size);
res = self->Read(data,size);
if(res <= 0)
return sq_thr... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movq $0x0, (%rdx)
movl $0x1, %esi
movl $0x80000000, %ecx # imm = 0x80000000
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x8bbc
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8bb3
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0... | /albertodemichelis[P]squirrel/sqstdlib/sqstdstream.cpp |
init_streamclass(SQVM*) | void init_streamclass(HSQUIRRELVM v)
{
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_stream"),-1);
if(SQ_FAILED(sq_get(v,-2))) {
sq_pushstring(v,_SC("std_stream"),-1);
sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(SQUserPointer)((SQUnsignedInteger)SQSTD_STREAM_TYPE_TAG));
S... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5720
leaq 0x23c3(%rip), %rsi # 0xb79c
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5030
movq %rbx, %rdi
movq $-0x2, %rsi
callq 0x5230
testq %rax, %rax
jns 0x9502
leaq 0x2395(%rip), %rsi # 0xb79c
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0... | /albertodemichelis[P]squirrel/sqstdlib/sqstdstream.cpp |
regexp_search(SQVM*) | static SQInteger _regexp_search(HSQUIRRELVM v)
{
SETUP_REX(v);
const SQChar *str,*begin,*end;
SQInteger start = 0;
sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
_addrexmatch(v,str,begin,end);
r... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
movq 0x653a(%rip), %rcx # 0x10428
movl $0x1, %esi
xorl %r8d, %r8d
callq 0x5050
testq %rax, %rax
js 0x9f41
movq $0x0, 0x8(%rsp)
movq %rsp, %rdx
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5110
movq %rbx, %rdi
callq 0x5270
cmp... | /albertodemichelis[P]squirrel/sqstdlib/sqstdstring.cpp |
string_strip(SQVM*) | static SQInteger _string_strip(HSQUIRRELVM v)
{
const SQChar *str,*start,*end;
sq_getstring(v,2,&str);
SQInteger len = sq_getsize(v,2);
__strip_l(str,&start);
__strip_r(str,len,&end);
sq_pushstring(v,start,end - start);
return 1;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movl $0x2, %esi
movq %r14, %rdx
callq 0x5110
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5690
movq %rax, %r12
movq (%r14), %r14
movb (%r14), %al
movq %r14, %r15
testb %al, %al
je 0xa36c
movq %r14, %r15
movsbl %al, %edi
callq 0x5070
testl... | /albertodemichelis[P]squirrel/sqstdlib/sqstdstring.cpp |
string_startswith(SQVM*) | static SQInteger _string_startswith(HSQUIRRELVM v)
{
const SQChar *str,*cmp;
sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp);
SQInteger len = sq_getsize(v,2);
SQInteger cmplen = sq_getsize(v,3);
SQBool ret = SQFalse;
if(cmplen <= len) {
ret = memcmp(str,cmp,sq_rsl(cmplen)) == 0 ? SQTr... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x5110
leaq 0x8(%rsp), %rdx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x5110
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5690
movq %rax, %r14
movl $0x3, %esi
movq %rbx, %rdi
callq 0x5690
cmpq %r14, %rax
jle 0xa756
xorl %esi, %esi... | /albertodemichelis[P]squirrel/sqstdlib/sqstdstring.cpp |
sqstd_register_systemlib | SQInteger sqstd_register_systemlib(HSQUIRRELVM v)
{
SQInteger i=0;
while(systemlib_funcs[i].name!=0)
{
sq_pushstring(v,systemlib_funcs[i].name,-1);
sq_newclosure(v,systemlib_funcs[i].f,0);
sq_setparamscheck(v,systemlib_funcs[i].nparamscheck,systemlib_funcs[i].typemask);
sq_se... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x11e9(%rip), %r14 # 0xba04
movl $0x20, %r12d
leaq 0x5458(%rip), %r13 # 0xfc80
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0x5030
movq -0x18(%r12,%r13), %rsi
movq -0x10(%r12,%r13), %r15
movq %rbx, %rdi
xorl %edx, %edx
callq... | /albertodemichelis[P]squirrel/sqstdlib/sqstdsystem.cpp |
PrintUsage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void PrintUsage(std::string const & filename) {
std::cout << "Usage: " << filename << " [inputfile]" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2c16(%rip), %r14 # 0x4fd0
leaq 0xc53(%rip), %rsi # 0x3014
movl $0x7, %edx
movq %r14, %rdi
callq 0x21a0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21a0
movq %rax, %rbx
leaq 0xc35(%rip), %rsi # 0x301c
movl $0xc, %edx
movq %rax, %... | /AntoineJT[P]cpp-things/bf2c.cpp |
set_look_proc(Am_Object) | Am_Define_Method(Am_Object_Method, void, set_look, (Am_Object cmd))
{
Am_Value my_look = cmd.Get(Am_WIDGET_LOOK);
std::cout << "Setting look to " << my_look << std::endl << std::flush;
Am_Set_Default_Look(my_look);
} | pushq %rbx
subq $0x20, %rsp
movl $0x17f, %esi # imm = 0x17F
xorl %edx, %edx
callq 0x55e0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x54f0
movq 0x137e0(%rip), %rdi # 0x19f20
leaq 0xd86a(%rip), %rsi # 0x13fb1
movl $0x10, %edx
callq 0x5560
movq 0x137c8(%rip), %rdi # 0x19f20
leaq 0x10(%rsp), %rsi
... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
value_from_cycle_command_proc(Am_Object&) | Am_Define_No_Self_Formula(bool, on_left_form)
{
Am_Value value;
// get the value from the checkbox widget's value.
value = checkboxes.Peek(Am_VALUE);
return !find_in_list(value, ON_RIGHT);
} | pushq %rbx
subq $0x30, %rsp
movw $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x13da1(%rip), %rdi # 0x1a698
movl $0x1, %edx
movl $0x169, %esi # imm = 0x169
callq 0x55e0
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x5390
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movw $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
leaq ... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
fixed_width_form_proc(Am_Object&) | Am_Define_No_Self_Formula(bool, on_left_form)
{
Am_Value value;
// get the value from the checkbox widget's value.
value = checkboxes.Peek(Am_VALUE);
return !find_in_list(value, ON_RIGHT);
} | pushq %rbx
subq $0x20, %rsp
movw $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x13a01(%rip), %rdi # 0x1a5b8
movl $0x1, %edx
movl $0x169, %esi # imm = 0x169
callq 0x55e0
movq %rsp, %rdi
movq %rax, %rsi
callq 0x5390
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x54f0
leaq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
name_from_value_proc(Am_Object&) | Am_Define_String_Formula(name_from_value)
{
Am_Value value;
value = self.Peek(Am_VALUE);
static char outs[MAXNAMESIZE];
strcpy(outs, COLORSTR);
//concatenate current color on end
if (value.type == Am_STRING) {
strcat(outs, Am_String(value));
} else
strcat(outs, DEFAULTSTR);
std::cout << "new nam... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movw $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x1, %edx
movl $0x169, %esi # imm = 0x169
callq 0x55e0
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5390
movabsq $0x6f7420726f6c6f43, %rax # imm = 0x6F7420726F6C6F43
movq %rax, 0xfbee(%rip) # 0x1a9d0
... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
load_bitmap() | void
load_bitmap()
{
const char *filename = Am_Merge_Pathname(AMULET_BITMAP);
Am_Image_Array amulet_icon_image(filename);
delete[] filename;
if (!amulet_icon_image.Valid())
Am_Error("Amulet bitmap image not found");
Amulet_Dark_Purple = Am_Style(0.85f, 0.75f, 0.95f);
amulet_icon = Am_Bitmap.Create("Amul... | pushq %rbx
subq $0x20, %rsp
leaq 0x7a06(%rip), %rdi # 0x13408
callq 0x5840
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5150
testq %rbx, %rbx
je 0xba24
movq %rbx, %rdi
callq 0x55c0
leaq 0x10(%rsp), %rdi
callq 0x5590
testb %al, %al
je 0xbb59
movq 0xe39b(%rip), %rsi # 0x19dd8
leaq 0x18(%rsp), %... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
do_pop_up_error_proc(Am_Object) | Am_Define_Method(Am_Object_Method, void, do_pop_up_error, (Am_Object /*cmd*/))
{
AM_POP_UP_ERROR_WINDOW("This is an error message");
} | pushq %rbx
subq $0x270, %rsp # imm = 0x270
leaq 0x8(%rsp), %rbx
leaq 0x170(%rsp), %rsi
movq %rbx, %rdi
movl $0xfa, %edx
movl $0x10, %ecx
callq 0x58e0
leaq 0x960f(%rip), %rsi # 0x151e8
movl $0x18, %edx
movq %rbx, %rdi
callq 0x5560
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x5050
leaq 0x170(%rsp), %rdi
c... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
do_pop_up_string_proc(Am_Object) | Am_Define_Method(Am_Object_Method, void, do_pop_up_string, (Am_Object /*cmd*/))
{
Am_Value v = Am_Get_Input_From_Dialog(
Am_Value_List().Add("First line of message"), "Initial value");
std::cout << "Value returned is `" << v << "'\n" << std::flush;
} | pushq %rbx
subq $0x40, %rsp
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x5230
leaq 0x9521(%rip), %rsi # 0x15201
movq %rbx, %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x5620
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5060
leaq 0x9528(%rip), %rsi # 0x1522e
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
callq 0x5330
l... | /ProgrammerArchaeology[P]openamulet/test/widgets/testwidgets.cpp |
Am_Input_Char::Am_Input_Char(Am_Value const&) | Am_Input_Char(const Am_Value &value)
{
long l = value.value.long_value;
if (l) {
if (value.type != Am_Input_Char_ID) {
#ifdef DEBUG
Am_Error("** Tried to set an Am_Input_Char with a non Am_Input_Char "
"wrapper.");
#else
Am_Error();
#endif
}
}
short low_by... | movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x122a6
movzwl (%rsi), %ecx
movq 0x7ca7(%rip), %rdx # 0x19f48
cmpw (%rdx), %cx
jne 0x122c2
movw %ax, (%rdi)
shrl $0x10, %eax
movzwl 0x2(%rdi), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
andl $0xfff, %eax # imm = 0xFFF
orl %ecx, %eax
movw %ax, 0x2(%rdi)
... | /ProgrammerArchaeology[P]openamulet/include/amulet/idefs.h |
main | ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, epoll__simple);
#ifndef USE_EPOLLRDHUP_LINUX_DEFINITION
ATF_TP_ADD_TC(tp, epoll__poll_flags);
#endif
ATF_TP_ADD_TC(tp, epoll__leakcheck);
ATF_TP_ADD_TC(tp, epoll__fd_exhaustion);
ATF_TP_ADD_TC(tp, epoll__invalid_op);
ATF_TP_ADD_TC(tp, epoll__invalid_op2);
ATF_TP_ADD_TC(tp, ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xc(%rip), %rdx # 0x2560
callq 0x22c0
addq $0x10, %rsp
popq %rbp
retq
nop
| /jiixyj[P]epoll-shim/test/epoll-test.c |
microatf_tp_add_tcs | ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, epoll__simple);
#ifndef USE_EPOLLRDHUP_LINUX_DEFINITION
ATF_TP_ADD_TC(tp, epoll__poll_flags);
#endif
ATF_TP_ADD_TC(tp, epoll__leakcheck);
ATF_TP_ADD_TC(tp, epoll__fd_exhaustion);
ATF_TP_ADD_TC(tp, epoll__invalid_op);
ATF_TP_ADD_TC(tp, epoll__invalid_op2);
ATF_TP_ADD_TC(tp, ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x13a86(%rip), %rsi # 0x16000
callq 0x2110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2592
jmp 0x259f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b... | /jiixyj[P]epoll-shim/test/epoll-test.c |
create_bound_socket | static int
create_bound_socket()
{
int sock = socket(PF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
ATF_REQUIRE(sock >= 0);
int enable = 1;
ATF_REQUIRE(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, /**/
&enable, sizeof(int)) == 0);
struct sockaddr_in addr = { 0 };
addr.sin_family = AF_INET;
addr.sin_port = htons(133... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x2, %edi
movl $0x80001, %esi # imm = 0x80001
xorl %edx, %edx
callq 0x2420
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x5513
leaq 0x8b19(%rip), %rdi # 0xe012
leaq 0x8c23(%rip), %rsi # 0xe123
movl $0x6a, %edx
leaq 0xa38f(%rip), %rcx # 0xf89b
... | /jiixyj[P]epoll-shim/test/epoll-test.c |
sleep_argument_impl | static void
sleep_argument_impl(int sleep)
{
int ep = epoll_create1(EPOLL_CLOEXEC);
ATF_REQUIRE(ep >= 0);
int fds[3];
fd_pipe(fds);
struct epoll_event event;
event.events = EPOLLIN;
ATF_REQUIRE(epoll_ctl(ep, EPOLL_CTL_ADD, fds[0], &event) >= 0);
pthread_t writer_thread;
ATF_REQUIRE(pthread_create(&writer_t... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0x80000, %edi # imm = 0x80000
callq 0x23e0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x56bf
leaq 0x896d(%rip), %rdi # 0xe012
leaq 0x8a77(%rip), %rsi # 0xe123
movl $0x1d2, %edx # imm = 0x1D2
leaq 0x92a4(%rip), %rc... | /jiixyj[P]epoll-shim/test/epoll-test.c |
no_epollin_on_closed_empty_pipe_impl | static void
no_epollin_on_closed_empty_pipe_impl(bool do_write_data)
{
int ep = epoll_create1(EPOLL_CLOEXEC);
ATF_REQUIRE(ep >= 0);
int fds[3];
fd_pipe(fds);
struct epoll_event event;
event.events = EPOLLIN | EPOLLRDHUP;
event.data.fd = fds[0];
ATF_REQUIRE(epoll_ctl(ep, EPOLL_CTL_ADD, fds[0], &event) == 0);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x80000, %edi # imm = 0x80000
callq 0x23e0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x65b4
leaq 0x7a78(%rip), %rdi # 0xe012
leaq 0x7b82(%rip), %rsi # 0xe123
movl $0x2c4, %edx # imm =... | /jiixyj[P]epoll-shim/test/epoll-test.c |
socket_shutdown_impl | static void
socket_shutdown_impl(bool specify_rdhup)
{
int ep = epoll_create1(EPOLL_CLOEXEC);
ATF_REQUIRE(ep >= 0);
int fds[3];
fd_tcp_socket(fds);
uint32_t rdhup_flag = specify_rdhup ? EPOLLRDHUP : 0;
struct epoll_event event;
event.events = EPOLLOUT | EPOLLIN | (specify_rdhup ? 0 : EPOLLRDHUP);
event.data.... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x80000, %edi # imm = 0x80000
callq 0x23e0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x7de4
leaq 0x6248(%rip), %rdi # 0xe012
leaq 0x6352(%rip), %rsi # 0xe123
movl $0x40d, %edx # imm =... | /jiixyj[P]epoll-shim/test/epoll-test.c |
shutdown_behavior_impl | static void
shutdown_behavior_impl(void (*fd_fun)(int fds[3]))
{
int ep = epoll_create1(EPOLL_CLOEXEC);
ATF_REQUIRE(ep >= 0);
connector_epfd = ep;
int fds[3];
fd_fun(fds);
connector_epfd = -1;
int counter = 0;
char c = 42;
write(fds[0], &c, 1);
struct epoll_event event;
event.events = EPOLLOUT | EPOLLIN... | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x8(%rbp)
movl $0x80000, %edi # imm = 0x80000
callq 0x23e0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xa2a3
leaq 0x3d89(%rip), %rdi # 0xe012
leaq 0x3e93(%rip), %rsi # 0xe123
movl $0x601, %edx # imm = 0x... | /jiixyj[P]epoll-shim/test/epoll-test.c |
mbedtls_ecp_curve_info_from_grp_id | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_grp_id( mbedtls_ecp_group_id grp_id )
{
const mbedtls_ecp_curve_info *curve_info;
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if( curve_info->grp_id == grp_id )
... | leaq 0x30261(%rip), %rax # 0x3ecf0
movl $0x5, %ecx
cmpl %edi, %ecx
je 0xeaa5
movl 0x10(%rax), %ecx
addq $0x10, %rax
testl %ecx, %ecx
jne 0xea94
xorl %eax, %eax
retq
| /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_curve_info_from_name | const mbedtls_ecp_curve_info *mbedtls_ecp_curve_info_from_name( const char *name )
{
const mbedtls_ecp_curve_info *curve_info;
if( name == NULL )
return( NULL );
for( curve_info = mbedtls_ecp_curve_list();
curve_info->grp_id != MBEDTLS_ECP_DP_NONE;
curve_info++ )
{
if... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xeaed
movq %rdi, %r14
leaq 0x3021d(%rip), %rbx # 0x3ecf0
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x9140
testl %eax, %eax
je 0xeaef
cmpl $0x0, 0x10(%rbx)
leaq 0x10(%rbx), %rbx
jne 0xead3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_point_write_binary | int mbedtls_ecp_point_write_binary( const mbedtls_ecp_group *grp,
const mbedtls_ecp_point *P,
int format, size_t *olen,
unsigned char *buf, size_t buflen )
{
int ret = MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movl %edx, %ebx
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
addq $0x8, %rdi
callq 0xa187
movq %rax, %r15
movl $0xffffb180, %ebp # imm = 0xFFFFB180
cmpq $0x0, 0x60(%r14)
je 0xee71
cmpq $0... | /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_tls_read_point | int mbedtls_ecp_tls_read_point( const mbedtls_ecp_group *grp,
mbedtls_ecp_point *pt,
const unsigned char **buf, size_t buf_len )
{
unsigned char data_len;
const unsigned char *buf_start;
ECP_VALIDATE_RET( grp != NULL );
ECP_VALIDATE_RET( pt... | cmpq $0x2, %rcx
jb 0xf10c
movq (%rdx), %r8
leaq 0x1(%r8), %rax
movq %rax, (%rdx)
movzbl (%r8), %r8d
testq %r8, %r8
je 0xf10c
decq %rcx
cmpq %r8, %rcx
jae 0xf112
movl $0xffffb080, %eax # imm = 0xFFFFB080
retq
leaq (%rax,%r8), %rcx
movq %rcx, (%rdx)
movq %rax, %rdx
movq %r8, %rcx
jmp 0xefaa
| /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_check_pubkey | int mbedtls_ecp_check_pubkey( const mbedtls_ecp_group *grp,
const mbedtls_ecp_point *pt )
{
ECP_VALIDATE_RET( grp != NULL );
ECP_VALIDATE_RET( pt != NULL );
/* Must use affine coordinates */
if( mbedtls_mpi_cmp_int( &pt->Z, 1 ) != 0 )
return( MBEDTLS_ERR_ECP_INVAL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsi), %rdi
movl $0x1, %esi
callq 0xb0bb
movl $0xffffb380, %ebp # imm = 0xFFFFB380
testl %eax, %eax
je 0x10160
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq ... | /ARMmbed[P]mbed-crypto/library/ecp.c |
mbedtls_ecp_self_test | int mbedtls_ecp_self_test( int verbose )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
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[] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edi, %ebx
leaq 0xc0(%rsp), %r14
movq %r14, %rdi
callq 0xeb2e
leaq 0x30(%rsp), %rdi
callq 0x9c60
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x9c60
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x9c60
leaq 0x... | /ARMmbed[P]mbed-crypto/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)
movl $0x7, %esi
callq 0x9ca5
movl %eax, %ebp
testl %eax, %eax
jne 0x... | /ARMmbed[P]mbed-crypto/library/ecp_curves.c |
ecp_mod_p448 | static int ecp_mod_p448( mbedtls_mpi *N )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t i;
mbedtls_mpi M, Q;
mbedtls_mpi_uint Mp[P448_WIDTH + 1], Qp[P448_WIDTH];
if( N->n <= P448_WIDTH )
return( 0 );
/* M = A1 */
M.s = 1;
M.n = N->n - ( P448_WIDTH );
if( M.n > P... | movq 0x8(%rdi), %rdx
xorl %eax, %eax
cmpq $0x8, %rdx
jb 0x139f9
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movl $0x1, 0x8(%rsp)
addq $-0x7, %rdx
movq %rdx, 0x10(%rsp)
movl $0xffffb080, %eax # imm = 0xFFFFB080
cmpq $0x7, %rdx
ja 0x139ef
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
mov... | /ARMmbed[P]mbed-crypto/library/ecp_curves.c |
mbedtls_entropy_write_seed_file | int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
{
int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
FILE *f;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
if( ( f = fopen( path, "wb" ) ) == NULL )
return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
if( ( ret = mb... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %r14
leaq 0x1a357(%rip), %rsi # 0x2e38a
movq %rax, %rdi
callq 0x91d0
testq %rax, %rax
je 0x14093
movq %rax, %rbx
movq %rsp, %rsi
movl $0x40, %edx
movq %r14, %rdi
callq 0x13eaa
movl %eax, %ebp
testl %eax, %eax
jne 0x1407c
movq %rsp, %rdi
mo... | /ARMmbed[P]mbed-crypto/library/entropy.c |
mbedtls_pk_info_from_type | const mbedtls_pk_info_t * mbedtls_pk_info_from_type( mbedtls_pk_type_t pk_type )
{
switch( pk_type ) {
#if defined(MBEDTLS_RSA_C)
case MBEDTLS_PK_RSA:
return( &mbedtls_rsa_info );
#endif
#if defined(MBEDTLS_ECP_C)
case MBEDTLS_PK_ECKEY:
return( &mbedtls_eckey_info );
... | decl %edi
cmpl $0x3, %edi
ja 0x14457
movl %edi, %eax
leaq 0x2a98e(%rip), %rcx # 0x3ede0
movq (%rcx,%rax,8), %rax
retq
xorl %eax, %eax
retq
| /ARMmbed[P]mbed-crypto/library/pk.c |
mbedtls_rsa_free | void mbedtls_rsa_free( mbedtls_rsa_context *ctx )
{
if( ctx == NULL )
return;
mbedtls_mpi_free( &ctx->Vi );
mbedtls_mpi_free( &ctx->Vf );
mbedtls_mpi_free( &ctx->RN );
mbedtls_mpi_free( &ctx->D );
mbedtls_mpi_free( &ctx->Q );
mbedtls_mpi_free( &ctx->P );
mbedtls_mpi_free( &ct... | testq %rdi, %rdi
je 0x16519
pushq %rbx
movq %rdi, %rbx
addq $0x118, %rdi # imm = 0x118
callq 0x9c6e
leaq 0x130(%rbx), %rdi
callq 0x9c6e
leaq 0xd0(%rbx), %rdi
callq 0x9c6e
leaq 0x40(%rbx), %rdi
callq 0x9c6e
leaq 0x70(%rbx), %rdi
callq 0x9c6e
leaq 0x58(%rbx), %rdi
callq 0x9c6e
leaq 0x28(%rbx), %rdi
callq 0x9c6... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_rsaes_oaep_encrypt | int mbedtls_rsa_rsaes_oaep_encrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
const unsigned char *label, size_t label_len,
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, %r14
cmpl $0x1, %ecx
jne 0x16ca4
movl $0xffffbf80, %ebx # imm = 0xFFFFBF80
testq %r13, %r13
je 0x16d4e
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
cmpl $0x1, 0x148(%r14)
... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_rsassa_pkcs1_v15_sign | int mbedtls_rsa_rsassa_pkcs1_v15_sign( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
unsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %rdx
cmpl $0x1, %ecx
jne 0x179df
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
cmpl $0x0, 0x148(%r12)
jne 0x179f8
movq 0x8(%r12), %rcx
mo... | /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_pkcs1_sign | int mbedtls_rsa_pkcs1_sign( 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 char *hash,
... | movl 0x148(%rdi), %eax
cmpl $0x1, %eax
je 0x176cb
testl %eax, %eax
jne 0x17cc7
pushq %rax
pushq 0x18(%rsp)
pushq 0x18(%rsp)
callq 0x179a9
addq $0x10, %rsp
popq %rcx
retq
movl $0xffffbf00, %eax # imm = 0xFFFFBF00
retq
| /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_rsa_rsassa_pss_verify | int mbedtls_rsa_rsassa_pss_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,
... | pushq %rax
movl 0x14c(%rdi), %eax
testl %eax, %eax
cmovel %r8d, %eax
pushq 0x18(%rsp)
pushq $-0x1
pushq %rax
pushq 0x28(%rsp)
callq 0x17ccd
addq $0x20, %rsp
popq %rcx
retq
| /ARMmbed[P]mbed-crypto/library/rsa.c |
mbedtls_internal_sha512_process | int mbedtls_internal_sha512_process( mbedtls_sha512_context *ctx,
const unsigned char data[128] )
{
int i;
uint64_t temp1, temp2, W[80];
uint64_t A[8];
SHA512_VALIDATE_RET( ctx != NULL );
SHA512_VALIDATE_RET( (const unsigned char *)data != NULL );
#define SHR(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movups 0x10(%rdi), %xmm0
movups 0x20(%rdi), %xmm1
movups 0x30(%rdi), %xmm2
movups 0x40(%rdi), %xmm3
movaps %xmm3, -0x50(%rsp)
movaps %xmm2, -0x60(%rsp)
movaps %xmm1, -0x70(%rsp)
movaps %xmm0, -0x80(%rsp)
xorl %e... | /ARMmbed[P]mbed-crypto/library/sha512.c |
mbedtls_timing_get_timer | unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )
{
struct _hr_time *t = (struct _hr_time *) val;
if( reset )
{
gettimeofday( &t->start, NULL );
return( 0 );
}
else
{
unsigned long delta;
struct timeval now;
gettimeof... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x1b347
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x90f0
jmp 0x1b38c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x90f0
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq (%rbx), %rcx
imulq $0x3e8, %rcx, %rcx # imm = 0... | /ARMmbed[P]mbed-crypto/library/timing.c |
mbedtls_aes_xts_setkey_dec | int mbedtls_aes_xts_setkey_dec( mbedtls_aes_xts_context *ctx,
const unsigned char *key,
unsigned int keybits)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
const unsigned char *key1, *key2;
unsigned int key1bits, key2bits;
AES_VALIDAT... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
cmpl $0x200, %edx # imm = 0x200
je 0x2295b
cmpl $0x100, %edx # imm = 0x100
jne 0x22969
movl %edx, %ebp
shrl %ebp
shrl $0x4, %edx
addq %rbx, %rdx
movb $0x1, %cl
jmp 0x22970
movl $0xffffffe0, %eax # imm = 0xFFFFFF... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_aes_crypt_ecb | int mbedtls_aes_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
AES_VALIDATE_RET( ctx != NULL );
AES_VALIDATE_RET( input != NULL );
AES_VALIDATE_RET( output != NULL );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0x2000000, %edi # imm = 0x2000000
callq 0x24714
movq %r15, %rdi
testl %eax, %eax
je 0x23644
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
po... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_gf128mul_x_ble | static void mbedtls_gf128mul_x_ble( unsigned char r[16],
const unsigned char x[16] )
{
uint64_t a, b, ra, rb;
GET_UINT64_LE( a, x, 0 );
GET_UINT64_LE( b, x, 8 );
ra = ( a << 1 ) ^ 0x0087 >> ( 8 - ( ( b >> 63 ) << 3 ) );
rb = ( a >> 63 ) | ( b << 1 );
PUT_U... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzbl 0x7(%rsi), %r10d
movq %r10, %rax
shlq $0x38, %rax
movzbl 0x6(%rsi), %r8d
shlq $0x30, %r8
orq %rax, %r8
movzbl 0x5(%rsi), %r9d
shlq $0x28, %r9
movzbl 0x4(%rsi), %eax
movzbl 0x3(%rsi), %r14d
shll $0x18, %r14d
movzbl 0x2(%rsi), %edx
shll $0x10, %edx
... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_aes_self_test | int mbedtls_aes_self_test( int verbose )
{
int ret = 0, i, j, u, mode;
unsigned int keybits;
unsigned char key[32];
unsigned char buf[64];
const unsigned char *aes_tests;
#if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movl %edi, 0x14(%rsp)
pxor %xmm0, %xmm0
leaq 0x70(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0xd0(%rsp), %rdi
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0x9100
leaq 0x20... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_aesni_crypt_ecb | int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor... | movl (%rdi), %eax
movq 0x8(%rdi), %rdi
movdqu (%rdx), %xmm0
movdqu (%rdi), %xmm1
pxor %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
testl %esi, %esi
je 0x24779
movdqu (%rdi), %xmm1
aesenc %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x2475c
movdqu (%rdi), %xmm1
aesenclast %xmm1, %xmm0
jmp 0x24794
movdqu (%rdi), %x... | /ARMmbed[P]mbed-crypto/library/aesni.c |
mbedtls_asn1_write_mpi | int mbedtls_asn1_write_mpi( unsigned char **p, unsigned char *start, const mbedtls_mpi *X )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
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_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0xa187
movq %rax, %rbx
movq (%r14), %rsi
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
movq %rsi, %rax
subq %r15, %rax
jb 0x24d8e
cmpq %rbx, %rax
jb 0x24d8e
subq %rbx, %rsi
movq %rsi, (%r14)
mo... | /ARMmbed[P]mbed-crypto/library/asn1write.c |
mbedtls_asn1_write_oid | int mbedtls_asn1_write_oid( unsigned char **p, unsigned char *start,
const char *oid, size_t oid_len )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len = 0;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_raw_buffer( p, start,
(const unsigned... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
setb %cl
cmpq %r12, %rax
setb %al
orb %cl, %al
movl $0xffffff94, %ebx # imm = 0xFFFFFF94
jne 0x24e97
subq %r12, %rdi
movq %rdi, (%r14)
movq %rdx, %rsi
movq %r12,... | /ARMmbed[P]mbed-crypto/library/asn1write.c |
mbedtls_asn1_write_bool | int mbedtls_asn1_write_bool( unsigned char **p, unsigned char *start, int boolean )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len = 0;
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = (boolean) ? 255 : 0;
len++;
MBEDTLS_ASN1_CHK_ADD( len, mbedtl... | movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x24ff9
xorl %ecx, %ecx
negl %edx
sbbl %ecx, %ecx
leaq -0x1(%rax), %rdx
movq %rdx, (%rdi)
movb %cl, -0x1(%rax)
movq (%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x24fff
leaq -0x1(%rax), %rdx
movq %rdx, (%rdi)
movb $0x1, -0x1(%ra... | /ARMmbed[P]mbed-crypto/library/asn1write.c |
mbedtls_asn1_write_bitstring | int mbedtls_asn1_write_bitstring( unsigned char **p, unsigned char *start,
const unsigned char *buf, size_t bits )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len = 0;
size_t unused_bits, byte_len;
byte_len = ( bits + 7 ) / 8;
unused_bits = ( byte_len * 8 ) -... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq (%rdi), %rsi
movl $0xffffff94, %eax # imm = 0xFFFFFF94
movq %rsi, %r9
subq %r15, %r9
jb 0x252fd
movq %rdi, %rbx
leaq 0x7(%rcx), %rdi
movq %rdi, %r8
shrq $0x3, %r8
cmpq %r8, %r9
jbe 0x252fd
movq %rdi, %r12
andq $-0x8, %r12
subq %rcx, %r12
... | /ARMmbed[P]mbed-crypto/library/asn1write.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_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_hmac_drbg_context *ctx = (mbedtls_hmac_drbg_contex... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x272a4
movl $0xfffffffd, %r14d # imm = 0xFFFFFFFD
cmpq $0x400, %r15 # imm = 0x400
ja 0x264e6
movl $0xfff... | /ARMmbed[P]mbed-crypto/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 );
}
switch( src->m... | movl $0xffffaf00, %eax # imm = 0xFFFFAF00
testq %rdi, %rdi
je 0x26b2a
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x26b2a
movq (%rsi), %rdx
cmpq %rdx, %rcx
je 0x26b2b
retq
pushq %rax
movl 0x8(%rdx), %ecx
addl $-0x3, %ecx
cmpl $0x6, %ecx
ja 0x26b92
leaq 0xe10e(%rip), %r... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_md_finish | int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
{
if( ctx == NULL || ctx->md_info == NULL )
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD2_C)
case MBEDTLS_MD_MD2:
return( mbedtls_md2_finish_ret( ctx->md_c... | testq %rdi, %rdi
je 0x26dd4
movq (%rdi), %rax
testq %rax, %rax
je 0x26dd4
movl 0x8(%rax), %eax
addl $-0x3, %eax
cmpl $0x6, %eax
ja 0x26dd4
leaq 0xdefa(%rip), %rcx # 0x34cbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x2b489
movl $0xffffaf00, %eax # imm = 0xFFFFAF00
retq
mo... | /ARMmbed[P]mbed-crypto/library/md.c |
mbedtls_md5_starts_ret | int mbedtls_md5_starts_ret( mbedtls_md5_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;
return( 0 );
} | movaps 0x8ada(%rip), %xmm0 # 0x2fde0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
xorl %eax, %eax
retq
| /ARMmbed[P]mbed-crypto/library/md5.c |
mbedtls_md5_update_ret | int mbedtls_md5_update_ret( mbedtls_md5_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left = ctx->total[0] & 0x3F;
... | testq %rdx, %rdx
je 0x27bae
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x27b1d
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x27b3b
movl $0x40,... | /ARMmbed[P]mbed-crypto/library/md5.c |
mbedtls_md5_self_test | int mbedtls_md5_self_test( int verbose )
{
int i, ret = 0;
unsigned char md5sum[16];
for( i = 0; i < 7; i++ )
{
if( verbose != 0 )
mbedtls_printf( " MD5 test #%d: ", i + 1 );
ret = mbedtls_md5_ret( md5_test_buf[i], md5_test_buflen[i], md5sum );
if( ret != 0 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movl $0x1, %ebp
leaq 0xd265(%rip), %r12 # 0x34fd0
leaq 0xcfde(%rip), %r14 # 0x34d50
movq %rsp, %r15
xorl %r13d, %r13d
testl %ebx, %ebx
je 0x27d8c
leaq 0xcfbb(%rip), %rdi # 0x34d3e
movl %ebp, %esi
xorl %eax,... | /ARMmbed[P]mbed-crypto/library/md5.c |
pem_des_decrypt | static int pem_des_decrypt( unsigned char des_iv[8],
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen )
{
mbedtls_des_context des_ctx;
unsigned char des_key[8];
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_des... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x2c4e4
movq %rsp, %rdi
movl $0x8, %esi
movq %r15, %rdx
movq %r13, %rcx
movq %r12, %r8
callq 0x28ed0
testl %eax, %eax
jne 0x28c1a
l... | /ARMmbed[P]mbed-crypto/library/pem.c |
mbedtls_ripemd160_starts | int mbedtls_ripemd160_starts_ret( 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;
return( 0 );
} | movaps 0x6d6c(%rip), %xmm0 # 0x2fde0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
movl $0xc3d2e1f0, 0x18(%rdi) # imm = 0xC3D2E1F0
retq
| /ARMmbed[P]mbed-crypto/library/ripemd160.c |
mbedtls_internal_ripemd160_process | int mbedtls_internal_ripemd160_process( mbedtls_ripemd160_context *ctx,
const unsigned char data[64] )
{
uint32_t A, B, C, D, E, Ap, Bp, Cp, Dp, Ep, X[16];
GET_UINT32_LE( X[ 0], data, 0 );
GET_UINT32_LE( X[ 1], data, 4 );
GET_UINT32_LE( X[ 2], data, 8 );
G... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl (%rsi), %r11d
movq %r11, -0x48(%rsp)
movl 0x4(%rsi), %r14d
movq %r14, -0x58(%rsp)
movl 0x14(%rsi), %ebx
movq %rbx, -0x60(%rsp)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %r8d
movl 0x10(%rdi), %eax
movl 0x14(%rdi), %r9d
movl 0x... | /ARMmbed[P]mbed-crypto/library/ripemd160.c |
mbedtls_ripemd160_update_ret | int mbedtls_ripemd160_update_ret( mbedtls_ripemd160_context *ctx,
const unsigned char *input,
size_t ilen )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t fill;
uint32_t left;
if( ilen == 0 )
return( 0 );
left =... | testq %rdx, %rdx
je 0x2a68a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x2a5f9
incl 0x4(%r14)
xorl %ebp, %ebp
testl %eax, %eax
je 0x2a617
movl $0x40,... | /ARMmbed[P]mbed-crypto/library/ripemd160.c |
mbedtls_asn1_traverse_sequence_of | int mbedtls_asn1_traverse_sequence_of(
unsigned char **p,
const unsigned char *end,
unsigned char tag_must_mask, unsigned char tag_must_val,
unsigned char tag_may_mask, unsigned char tag_may_val,
int (*cb)( void *ctx, int tag,
unsigned char *start, size_t len ),
void *ctx )
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rax
movq %rsi, %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0x2bccf
movl $0xffffff9e, %ebx # imm = 0xFFFFFF9E
... | /ARMmbed[P]mbed-crypto/library/asn1parse.c |
des3_set2key | static void des3_set2key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[MBEDTLS_DES_KEY_SIZE*2] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
for( i = 0; i < 32; i += 2 )
{
dsk[i ] =... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x2c5a1
leaq 0x80(%rbx), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0x2c5a1
movl $0x41, %ecx
movl $0x3f, %eax
movl -0x84(%r14,%rax,4), %edx
movl %edx, -0x104(%rbx,%rcx,4)
movl -0x80(%r14,%rax,4), %edx
movl %edx, -0x10... | /ARMmbed[P]mbed-crypto/library/des.c |
des3_set3key | static void des3_set3key( uint32_t esk[96],
uint32_t dsk[96],
const unsigned char key[24] )
{
int i;
mbedtls_des_setkey( esk, key );
mbedtls_des_setkey( dsk + 32, key + 8 );
mbedtls_des_setkey( esk + 64, key + 16 );
for( i = 0; i < 32; i += 2 )
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x2c5a1
leaq 0x80(%rbx), %rdi
leaq 0x8(%r15), %rsi
callq 0x2c5a1
leaq 0x100(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x2c5a1
movq $-0x2, %rax
movl $0x3e, %ecx
movl 0x80(%r14,%rcx,4), %edx
movl %edx, 0x8(%rbx... | /ARMmbed[P]mbed-crypto/library/des.c |
mbedtls_des_crypt_ecb | int mbedtls_des_crypt_ecb( mbedtls_des_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 < 8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x10(%rsp)
movq %rdi, -0x8(%rsp)
movl (%rsi), %ecx
movl 0x4(%rsi), %eax
bswapl %ecx
bswapl %eax
movl %ecx, %edx
shrl $0x4, %edx
xorl %eax, %edx
andl $0xf0f0f0f, %edx # imm = 0xF0F0F0F
xorl %edx, %eax
shll $0x4, %edx
xorl %ecx, %edx
mov... | /ARMmbed[P]mbed-crypto/library/des.c |
mbedtls_des_crypt_cbc | int mbedtls_des_crypt_cbc( mbedtls_des_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl $0xffffffce, %eax # imm = 0xFFFFFFCE
testb $0x7, %r12b
jne 0x2cf48
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
cmpl $0x1, %esi
jne 0x2cf0d
testq %r12, %r12
je 0x2cf46
xorl %eax, %eax
movb (%r15,%rax... | /ARMmbed[P]mbed-crypto/library/des.c |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | reference operator*() const
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case basic_json::value_t::object:
{
assert(m_it.object_iterator != m_object->m_value.object->end());
return m_it.obj... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x7d0b
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x7cee
cmpl $0x2, %ecx
je 0x7cc1
testl %ecx, %ecx
je 0x7d2a
cmpq $0x0, 0x18(%rdi)
je 0x7d03
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq 0x144c1(%rip), %rsi # 0x1c175
movq %rax, %rdi
callq 0x40... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::type_name() const | std::string type_name() const
{
{
switch (m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
... | pushq %rbx
movq %rdi, %rbx
movzbl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x8, %rax
ja 0x9044
leaq 0x12161(%rip), %rcx # 0x1b16c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x126cb(%rip), %rsi # 0x1b6e6
leaq 0x126c8(%rip), %rdx # 0x1b6ea
jmp 0x9082
leaq 0x126c7(%rip), %rsi ... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::cend() const | const_iterator cend() const noexcept
{
const_iterator result(this);
result.set_end();
return result;
} | pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movzbl (%rsi), %eax
cmpl $0x1, %eax
je 0x9cc3
cmpl $0x2, %eax
jne 0x9cc9
leaq 0x10(%rbx), %rax
jmp 0x9ccd
leaq 0x8(%rbx), %rax
jmp 0x9ccd
leaq 0x18(%rbx), %rax
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x9ce2
mov... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | void set_end() noexcept
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case basic_json::value_t::object:
{
m_it.object_iterator = m_object->m_value.object->end();
break;
}
... | movq (%rdi), %rax
testq %rax, %rax
je 0x9d1a
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x9d04
cmpl $0x1, %ecx
jne 0x9d11
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
pushq %rax
leaq 0x11be8(%rip), %rdi # 0... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, std::less<std::__cxx11::basic... | static T* create(Args&& ... args)
{
AllocatorType<T> alloc;
auto deleter = [&](T * object)
{
alloc.deallocate(object, 1);
};
std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
alloc.construct(object.get(), std::forward<Args>(args)...... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x30, %edi
callq 0x4320
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9e26
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x30, %esi
movq %rbx, %rdi
callq 0x4330
movq %r14, %rdi
callq 0x4530
| /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
std::vector<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, std::allocator<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_trai... | static T* create(Args&& ... args)
{
AllocatorType<T> alloc;
auto deleter = [&](T * object)
{
alloc.deallocate(object, 1);
};
std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
alloc.construct(object.get(), std::forward<Args>(args)...... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x4320
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xa0c2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4330
movq %r14, %rdi
callq 0x4530
| /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>* nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::create<std::__cxx11::basic_string<char... | static T* create(Args&& ... args)
{
AllocatorType<T> alloc;
auto deleter = [&](T * object)
{
alloc.deallocate(object, 1);
};
std::unique_ptr<T, decltype(deleter)> object(alloc.allocate(1), deleter);
alloc.construct(object.get(), std::forward<Args>(args)...... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x4320
movq %rax, %rbx
addq $0x10, %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x7f78
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
void nlohmann::detail::from_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::cha... | void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (not j.is_string())
{
JSON_THROW(std::domain_error("type must be string, but is " + j.type_name()));
}
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0xa599
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41e0
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x8ff0
leaq 0x11bce(%rip), %rs... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::operator==(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_tra... | constexpr value_t type() const noexcept
{
return m_type;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
movb (%rsi), %cl
cmpb %cl, %al
jne 0xa965
cmpl $0x7, %eax
ja 0xab1b
movb $0x1, %bl
movl %eax, %eax
leaq 0x10851(%rip), %rcx # 0x1b1a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0xaad2
... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_... | basic_json(CompatibleType && val) noexcept(noexcept(JSONSerializer<U>::to_json(
std::declval<basic_json_t&>(), std::forward<CompatibleType>(val))))
{
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
assert_invariant();
} | pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movb $0x3, (%rdi)
movq %rsi, %rdi
callq 0xa1ee
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x8d80
movq %rbx, %rdi
popq %rbx
jmp 0x8d80
| /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | void set_begin() noexcept
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case basic_json::value_t::object:
{
m_it.object_iterator = m_object->m_value.object->begin();
break;
}... | movq (%rdi), %rax
testq %rax, %rax
je 0xaf92
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0xaf80
cmpl $0x2, %ecx
je 0xaf74
cmpl $0x1, %ecx
jne 0xaf89
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
movq $0x0, 0x... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | void set_end() noexcept
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case basic_json::value_t::object:
{
m_it.object_iterator = m_object->m_value.object->end();
break;
}
... | movq (%rdi), %rax
testq %rax, %rax
je 0xafea
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0xafd4
cmpl $0x1, %ecx
jne 0xafe1
movq 0x8(%rax), %rax
addq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
pushq %rax
leaq 0x10918(%rip), %rdi # 0... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::al... | bool operator==(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
if (m_object != other.m_object)
{
JSON_THROW(std::domain_error("cannot compare iterators of different containers"));
}
assert(m... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0xb04f
testq %rax, %rax
je 0xb081
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0xb032
cmpl $0x1, %eax
jne 0xb03c
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0xb044
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0xb044
movq 0x18(%rdi), %rax
cmpq 0x18(... | /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
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.