name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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 )
return clientSock;
strcpy(fromIP, inet_ntoa(from.sin_addr));
fromPort = htons(from.sin_port);
return clientSock;
} | 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), %edi
callq 0x2130
movq %r14, %rdi
movq %rax, %rsi
callq 0x2270
movzwl 0x12(%rsp), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3257(%rip), %rdi # 0x6115
leaq 0x31b6(%rip), %rsi # 0x607b
leaq 0x3258(%rip), %rcx # 0x6124
movl $0x2d, %edx
callq 0x2190
| /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;
}
return recv_size;
} | 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, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3118(%rip), %rdi # 0x6217
leaq 0x2f75(%rip), %rsi # 0x607b
leaq 0x314c(%rip), %rcx # 0x6259
movl $0x74, %edx
callq 0x2190
nop
| /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>(conn_port));
socklen_t len = sizeof(conAddr);
int flag = ::connect(fd, (sockaddr*) &conAddr, len);
return flag >= 0;
} | 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 %eax, %eax
setns %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30e0(%rip), %rdi # 0x6293
leaq 0x2ec1(%rip), %rsi # 0x607b
leaq 0x30e2(%rip), %rcx # 0x62a3
movl $0x8e, %edx
callq 0x2190
nop
| /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, %edx
callq 0x2300
addq $0x98, %rsp
popq %rbx
popq %r14
retq
| /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));
}
threadPool.run();
benchmark(0);
//threadPool.join();
//sleep(1);
//统计测试结果
/*
* QPS = req/sec = 请求数/秒
* QPS = 总请求数 / ( 进程总数 * 请求时间 )
* QPS: 单个进程每秒请求服务器的成功次数
*
*/
uint64_t total_request_num = 0;
uint64_t total_response_num = 0;
uint64_t total_time = 0;
for (int i = 0; i < gOption.thread_num_; ++i) {
total_request_num += testResult_[i].request_num_;
total_response_num += testResult_[i].response_num_;
total_time += testResult_[i].use_timer_;
}
for(int i = 0;i < gOption.thread_num_;++i)
{
std::cout << "this is thread " << i << " :\n";
std::cout << "\tconnect time : " << gOption.concurrent_num_ << " use : " << testResult_[i].connect_time_ << " us\n";
std::cout << "\tuse time : " << testResult_[i].use_timer_ << " \n";
std::cout << "\trequest num : " << testResult_[i].request_num_ << " \n";
std::cout << "\tresponse num : " << testResult_[i].response_num_ << " \n";
}
std::cout<<"total result : \n";
std::cout << "\ttotal request num is : " << total_request_num << "\n";
std::cout << "\ttotal response num is : " << total_response_num << "\n";
std::cout << "\ttotal use time is : " << total_time << "\n";
std::cout << "\tQPS is : " << (total_response_num*(1000 * 1000) /total_time)*gOption.thread_num_ << "\n";
} | 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 = 0x10000000
movl %ebp, 0x80(%rbx)
movq %rbx, %rdi
callq 0x20b0
leaq 0x30(%rsp), %rsi
movl $0xe, %edi
xorl %edx, %edx
callq 0x2300
leaq 0x38(%rsp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2170
movq %r14, -0x8(%rbx)
movl %ebp, 0x80(%rbx)
movq %rbx, %rdi
callq 0x20b0
leaq 0x30(%rsp), %rsi
movl $0xf, %edi
xorl %edx, %edx
callq 0x2300
movl 0x6770(%rip), %edi # 0xa294
callq 0x2450
movq 0x6748(%rip), %rsi # 0xa278
decq %rsi
leaq 0x30(%rsp), %rdi
callq 0x45c2
cmpq $0x2, 0x6733(%rip) # 0xa278
jb 0x3bd5
movl $0x1, %ebx
leaq 0x3eb(%rip), %r12 # 0x3f42
leaq 0x1856(%rip), %r13 # 0x53b4
leaq 0x186f(%rip), %rbp # 0x53d4
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
movq $0x0, 0x18(%rsp)
movl $0x20, %edi
callq 0x22a0
movq %r12, (%rax)
movq $0x0, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rsp)
movq %r13, 0x28(%rsp)
movq %rbp, 0x20(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x471a
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x3bc9
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
incq %rbx
cmpq %rbx, 0x66a5(%rip) # 0xa278
ja 0x3b6f
movb $0x1, 0x30(%rsp)
movq 0x38(%rsp), %r14
movq 0x40(%rsp), %r15
cmpq %r15, %r14
je 0x3c09
leaq -0x394(%rip), %rbx # 0x385c
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2440
addq $0x28, %r14
cmpq %r15, %r14
jne 0x3bf0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3f42
movq 0x665d(%rip), %rax # 0xa278
testq %rax, %rax
je 0x3dc3
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
addq $0x18, %rcx
xorl %edx, %edx
xorl %r15d, %r15d
xorl %r12d, %r12d
addq -0x10(%rcx), %r12
addq -0x8(%rcx), %r15
addq (%rcx), %rdx
addq $0x20, %rcx
decq %rax
jne 0x3c38
movq %rdx, 0x8(%rsp)
xorl %r14d, %r14d
movq 0x637d(%rip), %r13 # 0x9fd8
xorl %ebp, %ebp
movl $0xf, %edx
movq %r13, %rdi
leaq 0x2974(%rip), %rsi # 0x65e0
callq 0x22d0
movq %r13, %rdi
movl %ebp, %esi
callq 0x2400
movl $0x3, %edx
movq %rax, %rdi
leaq 0x2966(%rip), %rsi # 0x65f0
callq 0x22d0
movl $0x11, %edx
movq %r13, %rdi
leaq 0x2956(%rip), %rsi # 0x65f4
callq 0x22d0
movq 0x65d6(%rip), %rsi # 0xa280
movq %r13, %rdi
callq 0x21a0
movq %rax, %rbx
movl $0x7, %edx
movq %rax, %rdi
leaq 0x2942(%rip), %rsi # 0x6606
callq 0x22d0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x21a0
movl $0x4, %edx
movq %rax, %rdi
leaq 0x2922(%rip), %rsi # 0x660e
callq 0x22d0
movl $0x11, %edx
movq %r13, %rdi
leaq 0x2913(%rip), %rsi # 0x6613
callq 0x22d0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax,%r14), %rsi
movq %r13, %rdi
callq 0x21a0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x2326(%rip), %rsi # 0x604f
callq 0x22d0
movl $0x11, %edx
movq %r13, %rdi
leaq 0x28e8(%rip), %rsi # 0x6625
callq 0x22d0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax,%r14), %rsi
movq %r13, %rdi
callq 0x21a0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x22e9(%rip), %rsi # 0x604f
callq 0x22d0
movl $0x11, %edx
movq %r13, %rdi
leaq 0x28bd(%rip), %rsi # 0x6637
callq 0x22d0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax,%r14), %rsi
movq %r13, %rdi
callq 0x21a0
movl $0x2, %edx
movq %rax, %rdi
leaq 0x22ac(%rip), %rsi # 0x604f
callq 0x22d0
incq %rbp
addq $0x20, %r14
cmpq %rbp, 0x64c2(%rip) # 0xa278
ja 0x3c5d
movq 0x8(%rsp), %rbx
jmp 0x3dcb
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x6206(%rip), %rdi # 0x9fd8
leaq 0x2870(%rip), %rsi # 0x6649
movl $0x10, %edx
callq 0x22d0
movq 0x61ee(%rip), %rdi # 0x9fd8
leaq 0x2869(%rip), %rsi # 0x665a
movl $0x1a, %edx
callq 0x22d0
movq 0x61d6(%rip), %rdi # 0x9fd8
movq %r12, %rsi
callq 0x21a0
leaq 0x2ab9(%rip), %rsi # 0x68ca
movl $0x1, %edx
movq %rax, %rdi
callq 0x22d0
movq 0x61b3(%rip), %rdi # 0x9fd8
leaq 0x2849(%rip), %rsi # 0x6675
movl $0x1a, %edx
callq 0x22d0
movq 0x619b(%rip), %rdi # 0x9fd8
movq %r15, %rsi
callq 0x21a0
leaq 0x2a7e(%rip), %rsi # 0x68ca
movl $0x1, %edx
movq %rax, %rdi
callq 0x22d0
movq 0x6178(%rip), %rdi # 0x9fd8
leaq 0x2829(%rip), %rsi # 0x6690
movl $0x1a, %edx
callq 0x22d0
movq 0x6160(%rip), %rdi # 0x9fd8
movq %rbx, %rsi
callq 0x21a0
leaq 0x2a43(%rip), %rsi # 0x68ca
movl $0x1, %edx
movq %rax, %rdi
callq 0x22d0
movq 0x613d(%rip), %rdi # 0x9fd8
leaq 0x2809(%rip), %rsi # 0x66ab
movl $0x1a, %edx
callq 0x22d0
imulq $0xf4240, %r15, %rax # imm = 0xF4240
xorl %edx, %edx
divq %rbx
imulq 0x63b8(%rip), %rax # 0xa278
movq 0x6111(%rip), %rdi # 0x9fd8
movq %rax, %rsi
callq 0x21a0
leaq 0x29f4(%rip), %rsi # 0x68ca
movl $0x1, %edx
movq %rax, %rdi
callq 0x22d0
leaq 0x30(%rsp), %rdi
callq 0x476c
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f2d
jmp 0x3f25
jmp 0x3f2d
jmp 0x3f2d
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x3f30
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3f30
movq %rax, %rdi
callq 0x2b0e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x476c
movq %rbx, %rdi
callq 0x2410
| /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 = 0\n"
"\tthread_num = 1\n");
printf("Usage: %s \n"
"\t [-h host] \n"
"\t [-p source_port] \n"
"\t [-c concurrent_num] \n"
"\t [-t thread_num] \n"
"\t [-a is_keep_alive] \n"
//测试持续时间
"\t [-d duration] \n"
"\t [-w timeout] \n", "benchmark");
} | 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_num_ << "\n" << "\tis_keep_alive = " << is_keep_alive_ << "\n"
<< "\tthread_num = " << thread_num_ << "\n" << "\tduration = " << duration_ << "\n"
<< "\tinterval_time_s = " << interval_time_s_ << "\n";
} | 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 # 0x9fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x22d0
jmp 0x42ff
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x23f0
movq 0x5cd2(%rip), %r15 # 0x9fd8
leaq 0x25bd(%rip), %r14 # 0x68ca
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x247e(%rip), %rsi # 0x67a2
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movzwl 0x8(%rbx), %esi
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x2462(%rip), %rsi # 0x67b9
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movq 0x20(%rbx), %rsi
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x2446(%rip), %rsi # 0x67d0
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x242a(%rip), %rsi # 0x67e7
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movzbl 0xa(%rbx), %esi
movq %r15, %rdi
callq 0x23e0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x240e(%rip), %rsi # 0x67fe
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x23f2(%rip), %rsi # 0x6815
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movl 0x2c(%rbx), %esi
movq %r15, %rdi
callq 0x21a0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x23d7(%rip), %rsi # 0x682c
movl $0x16, %edx
movq %r15, %rdi
callq 0x22d0
movl 0x28(%rbx), %esi
movq %r15, %rdi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x22d0
| /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_ = (size_t) atoi(optarg);
break;
case 'p':gOption.server_port_ = (uint16_t) atoi(optarg);
break;
case 'c':gOption.concurrent_num_ = (uint16_t) atoi(optarg);
break;
case 'd':gOption.duration_ = (uint32_t) atoi(optarg);
break;
case 'w':gOption.connect_timeout_ms_ = (uint32_t) atoi(optarg);
break;
default:Option::printDefautOption();
return 0;
}
}
return 0;
} | 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 $0x7, %ecx
ja 0x4559
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
jmpq *%rax
movb $0x1, 0x5da0(%rip) # 0xa272
jmp 0x44a4
cmpl $0x70, %eax
je 0x452d
cmpl $0x74, %eax
je 0x4542
cmpl $0x77, %eax
jne 0x455e
movq (%r12), %rdi
callq 0x23a0
movl %eax, %eax
movq %rax, 0x5d93(%rip) # 0xa288
jmp 0x44a4
movq (%r12), %rdi
callq 0x23a0
movl %eax, 0x5d8e(%rip) # 0xa294
jmp 0x44a4
movq (%r12), %rdi
callq 0x23a0
movzwl %ax, %eax
movq %rax, 0x5d65(%rip) # 0xa280
jmp 0x44a4
movq (%r12), %rax
movq %rax, 0x5d40(%rip) # 0xa268
jmp 0x44a4
movq (%r12), %rdi
callq 0x23a0
movw %ax, 0x5d33(%rip) # 0xa270
jmp 0x44a4
movq (%r12), %rdi
callq 0x23a0
cltq
movq %rax, 0x5d24(%rip) # 0xa278
jmp 0x44a4
cmpl $-0x1, %eax
je 0x4563
callq 0x4264
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /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);
#else
return TestProperty::ValidateName(name, ban, ban+IUTEST_PP_COUNTOF(ban));
#endif
} | 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);
}
else{
pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n"));
}
sqstd_printcallstack(v);
}
}
return 0;
} | 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 # 0xb171
movq %rbx, %rdi
xorl %eax, %eax
callq *%r14
jmp 0x5d53
leaq 0x5443(%rip), %rsi # 0xb18e
movq %rbx, %rdi
xorl %eax, %eax
callq *%r14
movq %rbx, %rdi
callq 0x5500
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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 0x6125
leaq 0x10(%rsp), %r14
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5380
movq 0x8(%rsp), %rdi
movq (%r14), %rsi
callq 0x5670
testb %al, %al
je 0x6137
xorl %eax, %eax
jmp 0x6146
leaq 0x5124(%rip), %rsi # 0xb250
jmp 0x613e
leaq 0x510a(%rip), %rsi # 0xb23f
jmp 0x613e
leaq 0x5126(%rip), %rsi # 0xb264
movq %rbx, %rdi
callq 0x5310
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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)
testb %al, %al
je 0x6298
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %rbx
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x3(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
andq $-0x4, %rcx
subq %rax, %rcx
addq %rbx, %rcx
sarq $0x2, %rcx
testq %rcx, %rcx
jle 0x62ab
movq (%rsp), %rax
movq 0x20(%rax), %rdx
xorl %eax, %eax
xorl %esi, %esi
movl (%rdx,%rsi,4), %edi
bswapl %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x627f
jmp 0x62a3
leaq 0x4fa7(%rip), %r14 # 0xb23f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5310
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x62a3
| /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_pushinteger(v,((unsigned char *)self->GetBuf())[idx]);
return 1;
} | 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 0x63e6
movl $0x2, %esi
movq %rbx, %rdi
callq 0x5320
btl $0x1a, %eax
jb 0x6406
movq %rbx, %rdi
callq 0x5580
movq %rbx, %rdi
callq 0x5730
jmp 0x63fe
leaq 0x4e63(%rip), %rsi # 0xb250
jmp 0x63f6
leaq 0x4e49(%rip), %rsi # 0xb23f
movq %rbx, %rdi
callq 0x5310
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x10(%rsp), %r14
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5380
movq (%r14), %r14
testq %r14, %r14
js 0x6454
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpq %rax, %r14
jge 0x6454
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x53c0
movl $0x1, %eax
jmp 0x63fe
leaq 0x4e17(%rip), %rsi # 0xb272
jmp 0x63f6
| /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(SQBlob)))SQBlob(other->Len());
memcpy(thisone->GetBuf(),other->GetBuf(),thisone->Len());
if(SQ_FAILED(sq_setinstanceup(v,1,thisone))) {
thisone->~SQBlob();
sq_free(thisone,sizeof(SQBlob));
return sq_throwerror(v, _SC("cannot clone blob"));
}
sq_setreleasehook(v,1,_blob_releasehook);
return 0;
} | 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(%rax)
movq 0x9a05(%rip), %rcx # 0xffa0
addq $0x10, %rcx
movq %rcx, (%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
movq %rax, %rdi
callq 0x5470
movq %rax, 0x20(%r14)
movq 0x8(%r14), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x5240
movq $0x0, 0x18(%r14)
movb $0x1, 0x28(%r14)
movq (%r14), %rax
movq 0x20(%r14), %r15
movq (%rsp), %rcx
movq 0x20(%rcx), %r12
movq %r14, %rdi
callq *0x30(%rax)
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x53b0
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x56f0
testq %rax, %rax
js 0x662a
leaq 0x4a(%rip), %rdx # 0x665a
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5250
xorl %eax, %eax
jmp 0x664e
movq $-0x1, %rax
jmp 0x664e
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movl $0x30, %esi
movq %r14, %rdi
callq 0x5400
leaq 0x4c6b(%rip), %rsi # 0xb2b1
movq %rbx, %rdi
callq 0x5310
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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);
sq_free(_buf,_allocated);
_buf=newbuf;
_allocated = n;
if(_size > _allocated)
_size = _allocated;
if(_ptr > _allocated)
_ptr = _allocated;
}
return true;
} | 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 %r14, %rdx
cmovgeq %r14, %rdx
movq %r12, %rdi
callq 0x53b0
movq 0x10(%r15), %rsi
movq 0x20(%r15), %rdi
callq 0x5400
movq %r12, 0x20(%r15)
movq %r14, 0x10(%r15)
cmpq %r14, 0x8(%r15)
jle 0x696a
movq %r14, 0x8(%r15)
cmpq %r14, 0x18(%r15)
jle 0x6974
movq %r14, 0x18(%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /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_pushuserpointer(v,file); //file
if(own){
sq_pushinteger(v,1); //true
}
else{
sq_pushnull(v); //false
}
if(SQ_SUCCEEDED( sq_call(v,3,SQTrue,SQFalse) )) {
sq_remove(v,-2);
return SQ_OK;
}
}
sq_settop(v,top);
return SQ_ERROR;
} | 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, %rax
js 0x6a98
movq %rbx, %rdi
movq $-0x2, %rsi
callq 0x54e0
movq %rbx, %rdi
callq 0x51e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5510
testq %r12, %r12
je 0x6a63
movl $0x1, %esi
movq %rbx, %rdi
callq 0x53c0
jmp 0x6a6b
movq %rbx, %rdi
callq 0x5580
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x51a0
testq %rax, %rax
js 0x6a98
movq %rbx, %rdi
movq $-0x2, %rsi
callq 0x54e0
xorl %r14d, %r14d
jmp 0x6aa3
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5780
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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,printerror))) {
sq_push(v,-2);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue))) {
sq_remove(v,retval?-2:-1); //removes the closure
return 1;
}
sq_pop(v,1); //removes the closure
}
return SQ_ERROR;
} | 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, %r15d
movl $0x1, %esi
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x51a0
testq %rax, %rax
js 0x6e40
xorl %esi, %esi
testq %r14, %r14
sete %sil
orq $-0x2, %rsi
movq %rbx, %rdi
callq 0x54e0
jmp 0x6e54
leaq 0x4510(%rip), %rsi # 0xb33d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5310
movl $0x1, %esi
movq %rbx, %rdi
callq 0x50e0
movq $-0x1, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 the error
} | 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(%rsp), %rsi
movq %rbx, %rdi
callq 0x5530
sarq $0x3f, %rax
orq $0x1, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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 1;
return SQ_ERROR; //propagates the error
} | 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 $0x1, %edx
movq %rbx, %rdi
callq 0x53a0
sarq $0x3f, %rax
orq $0x1, %rax
addq $0x10, %rsp
popq %rbx
retq
| /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 = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
exp->_nsize = 0;
exp->_matches = 0;
exp->_nsubexpr = 0;
exp->_first = sqstd_rex_newnode(exp,OP_EXPR);
exp->_error = error;
exp->_jmpbuf = sq_malloc(sizeof(jmp_buf));
if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
SQInteger res = sqstd_rex_list(exp);
exp->_nodes[exp->_first].left = res;
if(*exp->_p!='\0')
sqstd_rex_error(exp,_SC("unexpected character"));
#ifdef _DEBUG
{
SQInteger nsize,i;
SQRexNode *t;
nsize = exp->_nsize;
t = &exp->_nodes[0];
scprintf(_SC("\n"));
for(i = 0;i < nsize; i++) {
if(exp->_nodes[i].type>MAX_CHAR)
scprintf(_SC("[%02d] %10s "), (SQInt32)i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
else
scprintf(_SC("[%02d] %10c "), (SQInt32)i,exp->_nodes[i].type);
scprintf(_SC("left %02d right %02d next %02d\n"), (SQInt32)exp->_nodes[i].left, (SQInt32)exp->_nodes[i].right, (SQInt32)exp->_nodes[i].next);
}
scprintf(_SC("\n"));
}
#endif
exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch));
}
else{
sqstd_rex_free(exp);
return NULL;
}
return exp;
} | 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
movq 0x8(%rsp), %rcx
movq %rax, 0x30(%rcx)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
shlq $0x5, %rdi
callq 0x5470
movq 0x8(%rsp), %rcx
movq %rax, 0x28(%rcx)
movq 0x8(%rsp), %rax
movq %r15, 0x38(%rax)
movq 0x8(%rsp), %rax
movq %r15, 0x48(%rax)
movq 0x8(%rsp), %rax
movq %r15, 0x40(%rax)
movq 0x8(%rsp), %rdi
movl $0x102, %esi # imm = 0x102
callq 0x7aa2
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq 0x8(%rsp), %rax
movq %rbx, 0x60(%rax)
movl $0xc8, %edi
callq 0x5470
movq 0x8(%rsp), %rcx
movq %rax, 0x58(%rcx)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x5620
movq 0x8(%rsp), %rdi
testl %eax, %eax
je 0x7a0c
callq 0x57a0
xorl %eax, %eax
jmp 0x7a77
callq 0x7b2e
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq 0x18(%rdx), %rdx
shlq $0x5, %rdx
movq %rax, 0x8(%rcx,%rdx)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
cmpb $0x0, (%rax)
movq 0x8(%rsp), %rax
jne 0x7a81
movq 0x40(%rax), %rdi
shlq $0x4, %rdi
callq 0x5470
movq 0x8(%rsp), %rcx
movq %rax, 0x48(%rcx)
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x5240
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x60(%rax), %rcx
testq %rcx, %rcx
je 0x7a94
leaq 0x3b34(%rip), %rdx # 0xb5c5
movq %rdx, (%rcx)
movq 0x58(%rax), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x51b0
| /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;
SQInteger p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
const SQChar *s=str, *good = str;
if(node->next != -1) {
greedystop = &exp->_nodes[node->next];
}
else {
greedystop = next;
}
while((nmaches == 0xFFFF || nmaches < p1)) {
const SQChar *stop;
if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
break;
nmaches++;
good=s;
if(greedystop) {
//checks that 0 matches satisfy the expression(if so skips)
//if not would always stop(for instance if is a '?')
if(greedystop->type != OP_GREEDY ||
(greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))
{
SQRexNode *gnext = NULL;
if(greedystop->next != -1) {
gnext = &exp->_nodes[greedystop->next];
}else if(next && next->next != -1){
gnext = &exp->_nodes[next->next];
}
stop = sqstd_rex_matchnode(exp,greedystop,s,gnext);
if(stop) {
//if satisfied stop it
if(p0 == p1 && p0 == nmaches) break;
else if(nmaches >= p0 && p1 == 0xFFFF) break;
else if(nmaches >= p0 && nmaches <= p1) break;
}
}
}
if(s >= exp->_eol)
break;
}
if(p0 == p1 && p0 == nmaches) return good;
else if(nmaches >= p0 && p1 == 0xFFFF) return good;
else if(nmaches >= p0 && nmaches <= p1) return good;
return NULL;
}
case OP_OR: {
const SQChar *asd = str;
SQRexNode *temp=&exp->_nodes[node->left];
while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
if(temp->next != -1)
temp = &exp->_nodes[temp->next];
else
return asd;
}
asd = str;
temp = &exp->_nodes[node->right];
while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
if(temp->next != -1)
temp = &exp->_nodes[temp->next];
else
return asd;
}
return NULL;
break;
}
case OP_EXPR:
case OP_NOCAPEXPR:{
SQRexNode *n = &exp->_nodes[node->left];
const SQChar *cur = str;
SQInteger capture = -1;
if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
capture = exp->_currsubexp;
exp->_matches[capture].begin = cur;
exp->_currsubexp++;
}
SQInteger tempcap = exp->_currsubexp;
do {
SQRexNode *subnext = NULL;
if(n->next != -1) {
subnext = &exp->_nodes[n->next];
}else {
subnext = next;
}
if(!(cur = sqstd_rex_matchnode(exp,n,cur,subnext))) {
if(capture != -1){
exp->_matches[capture].begin = 0;
exp->_matches[capture].len = 0;
}
return NULL;
}
} while((n->next != -1) && (n = &exp->_nodes[n->next]));
exp->_currsubexp = tempcap;
if(capture != -1)
exp->_matches[capture].len = cur - exp->_matches[capture].begin;
return cur;
}
case OP_WB:
if((str == exp->_bol && !isspace(*str))
|| (str == exp->_eol && !isspace(*(str-1)))
|| (!isspace(*str) && isspace(*(str+1)))
|| (isspace(*str) && !isspace(*(str+1))) ) {
return (node->left == 'b')?str:NULL;
}
return (node->left == 'b')?NULL:str;
case OP_BOL:
if(str == exp->_bol) return str;
return NULL;
case OP_EOL:
if(str == exp->_eol) return str;
return NULL;
case OP_DOT:{
if (str == exp->_eol) return NULL;
str++;
}
return str;
case OP_NCLASS:
case OP_CLASS:
if (str == exp->_eol) return NULL;
if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) {
str++;
return str;
}
return NULL;
case OP_CCLASS:
if (str == exp->_eol) return NULL;
if(sqstd_rex_matchcclass(node->left,*str)) {
str++;
return str;
}
return NULL;
case OP_MB:
{
SQInteger cb = node->left; //char that opens a balanced expression
if(*str != cb) return NULL; // string doesnt start with open char
SQInteger ce = node->right; //char that closes a balanced expression
SQInteger cont = 1;
const SQChar *streol = exp->_eol;
while (++str < streol) {
if (*str == ce) {
if (--cont == 0) {
return ++str;
}
}
else if (*str == cb) cont++;
}
}
return NULL; // string ends out of balance
default: /* char */
if (str == exp->_eol) return NULL;
if(*str != node->type) return NULL;
str++;
return str;
}
return NULL;
} | 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 0x28(%r14), %rax
movq 0x8(%rbp), %r13
shlq $0x5, %r13
cmpl $0x103, %r15d # imm = 0x103
jne 0x7e23
movq 0x50(%r14), %r12
movq $-0x1, %r15
movq 0x8(%rsp), %rbp
jmp 0x7e56
cmpq %rbx, (%r14)
je 0x810b
movq 0x28(%r14), %r12
movq 0x8(%rbp), %rcx
movsbq (%rbx), %r14
shlq $0x5, %rcx
leaq (%r12,%rcx), %r13
movl (%r12,%rcx), %eax
cmpl $0x106, %eax # imm = 0x106
je 0x7d32
cmpl $0x108, %eax # imm = 0x108
jne 0x7d48
cmpq %r14, 0x8(%r13)
jg 0x7d51
cmpq %r14, 0x10(%r13)
jl 0x7d51
jmp 0x8110
movq 0x8(%r13), %rdi
movl %r14d, %esi
callq 0x89d8
testq %rax, %rax
je 0x7d51
jmp 0x8110
cmpl %r14d, %eax
je 0x8110
movl $0x107, %eax # imm = 0x107
testq %r12, %r12
je 0x8115
movq 0x18(%r13), %rcx
cmpq $-0x1, %rcx
jne 0x7d07
jmp 0x8115
cmpq %rbx, 0x8(%r14)
jne 0x7d80
movsbl (%rbx), %edi
callq 0x5070
testl %eax, %eax
je 0x7dbd
cmpq %rbx, (%r14)
jne 0x7d92
movsbl -0x1(%rbx), %edi
callq 0x5070
testl %eax, %eax
je 0x7dbd
movsbl (%rbx), %edi
callq 0x5070
testl %eax, %eax
movq %rbp, %r14
sete %bpl
movsbl 0x1(%rbx), %edi
callq 0x5070
testl %eax, %eax
sete %al
cmpb %al, %bpl
movq %r14, %rbp
je 0x8124
xorl %r12d, %r12d
cmpq $0x62, 0x8(%rbp)
jmp 0x811e
movq 0x8(%rbp), %rax
movsbq (%rbx), %rcx
cmpq %rcx, %rax
jne 0x810b
movq (%r14), %rcx
incq %rbx
cmpq %rcx, %rbx
jae 0x810b
movq 0x10(%rbp), %rdx
movl $0x1, %esi
xorl %r12d, %r12d
movsbq (%rbx), %rdi
cmpq %rdi, %rdx
jne 0x7e09
decq %rsi
jne 0x7e16
jmp 0x814a
xorl %r8d, %r8d
cmpq %rdi, %rax
sete %r8b
addq %r8, %rsi
incq %rbx
cmpq %rcx, %rbx
jne 0x7df6
jmp 0x818f
movq 0x10(%rbp), %rcx
movq 0x50(%r14), %r12
movq $-0x1, %r15
cmpq %r12, %rcx
movq 0x8(%rsp), %rbp
jne 0x7e56
movq 0x48(%r14), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rbx, (%rdx,%rsi)
leaq 0x1(%rcx), %r12
movq %r12, 0x50(%r14)
movq %rcx, %r15
addq %rax, %r13
movq 0x18(%r13), %rdx
movq %rdx, %rcx
shlq $0x5, %rcx
addq %rax, %rcx
cmpq $-0x1, %rdx
cmoveq %rbp, %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x7c85
testq %rax, %rax
je 0x80f5
movq %rax, %rbx
movq 0x18(%r13), %r13
cmpq $-0x1, %r13
je 0x7ea3
movq 0x28(%r14), %rax
shlq $0x5, %r13
addq %rax, %r13
testq %rax, %rax
jne 0x7e59
movq %r12, 0x50(%r14)
cmpq $-0x1, %r15
je 0x818c
movq 0x48(%r14), %rax
shlq $0x4, %r15
movq %rbx, %rcx
subq (%rax,%r15), %rcx
movq %rcx, 0x8(%rax,%r15)
jmp 0x818c
movq 0x10(%rbp), %rcx
movq %rbp, 0x20(%rsp)
movq 0x18(%rbp), %rax
movzwl %cx, %esi
shrl $0x10, %ecx
movq %rcx, 0x10(%rsp)
movq 0x8(%rsp), %r12
cmpq $-0x1, %rax
je 0x7ef8
shlq $0x5, %rax
addq 0x28(%r14), %rax
movq %rax, %r12
movl $0x1, %ebp
xorl %edi, %edi
leaq -0x1(%rbp), %r15
cmpq $0x10000, %rbp # imm = 0x10000
sete %al
cmpq %rsi, %r15
setb %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x8131
movq %rdi, 0x18(%rsp)
movq %rsi, %r13
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
shlq $0x5, %rsi
addq 0x28(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x7c85
testq %rax, %rax
je 0x8136
movq %rax, %rbx
testq %r12, %r12
movq %r13, %rsi
je 0x7fe8
cmpl $0x100, (%r12) # imm = 0x100
jne 0x7f70
cmpw $0x0, 0x12(%r12)
je 0x7fe8
movq 0x18(%r12), %rcx
cmpq $-0x1, %rcx
je 0x7f85
shlq $0x5, %rcx
addq 0x28(%r14), %rcx
jmp 0x7f9b
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x7f99
movq 0x18(%rax), %rcx
cmpq $-0x1, %rcx
jne 0x7f7b
xorl %ecx, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7c85
testq %rax, %rax
movq %r13, %rsi
je 0x7fe8
movq 0x10(%rsp), %rdx
movq %rdx, %rax
xorq %rsi, %rax
movq %rdx, %rcx
xorq %rbp, %rcx
orq %rax, %rcx
je 0x8145
cmpq %rsi, %r15
setb %al
cmpq $0xffff, %rsi # imm = 0xFFFF
sete %cl
cmpq %rdx, %rbp
jb 0x7fe8
orb %al, %cl
jne 0x814f
incq %rbp
movq 0x18(%rsp), %rdi
incq %rdi
cmpq (%r14), %rbx
jb 0x7eff
jmp 0x8152
movq 0x8(%rbp), %r13
shlq $0x5, %r13
addq 0x28(%r14), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x7c85
testq %rax, %rax
je 0x8053
movq %rax, %r12
movq 0x18(%r13), %r13
cmpq $-0x1, %r13
je 0x818f
shlq $0x5, %r13
addq 0x28(%r14), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7c85
movq %rax, %r12
testq %rax, %rax
jne 0x8025
movq 0x10(%rbp), %r15
shlq $0x5, %r15
addq 0x28(%r14), %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x7c85
testq %rax, %rax
je 0x818f
xorl %r12d, %r12d
movq 0x18(%r15), %r15
cmpq $-0x1, %r15
je 0x8140
shlq $0x5, %r15
addq 0x28(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7c85
testq %rax, %rax
jne 0x807e
jmp 0x818f
cmpq %rbx, (%r14)
je 0x810b
movq 0x8(%rbp), %rdi
movsbl (%rbx), %esi
callq 0x89d8
incq %rbx
testq %rax, %rax
jmp 0x812b
leaq 0x1(%rbx), %rax
xorl %r12d, %r12d
cmpq %rbx, (%r14)
cmovneq %rax, %r12
jmp 0x818f
xorl %r12d, %r12d
cmpq %rbx, 0x8(%r14)
jmp 0x811e
xorl %r12d, %r12d
cmpq %rbx, (%r14)
jmp 0x811e
cmpq %rbx, (%r14)
je 0x810b
movsbl (%rbx), %eax
jmp 0x8115
cmpq $-0x1, %r15
je 0x810b
movq 0x48(%r14), %rax
shlq $0x4, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r15)
xorl %r12d, %r12d
jmp 0x818f
movl $0x105, %eax # imm = 0x105
incq %rbx
xorl %r12d, %r12d
cmpl %eax, %r15d
cmoveq %rbx, %r12
jmp 0x818f
xorl %eax, %eax
cmpq $0x62, 0x8(%rbp)
cmoveq %rax, %rbx
jmp 0x818c
movq %r15, %rdi
jmp 0x8152
movq %r13, %rsi
movq 0x18(%rsp), %rdi
jmp 0x8152
movq %rax, %r12
jmp 0x818f
movq %rdx, %rdi
jmp 0x8152
incq %rbx
jmp 0x818c
movq %rbp, %rdi
movq 0x10(%rsp), %rdx
movq %rdx, %rax
xorq %rsi, %rax
movq %rdx, %rcx
xorq %rdi, %rcx
orq %rax, %rcx
je 0x818c
cmpq $0xffff, %rsi # imm = 0xFFFF
sete %al
cmpq %rdx, %rdi
setge %cl
testb %al, %cl
jne 0x818c
xorl %eax, %eax
cmpq %rsi, %rdi
cmovgq %rax, %rbx
cmpq %rdx, %rdi
cmovlq %rax, %rbx
movq %rbx, %r12
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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);
}
else
expr = sqstd_rex_newnode(exp,OP_EXPR);
SQInteger newn = sqstd_rex_list(exp);
exp->_nodes[expr].left = newn;
ret = expr;
sqstd_rex_expect(exp,')');
}
break;
case '[':
exp->_p++;
ret = sqstd_rex_class(exp);
sqstd_rex_expect(exp,']');
break;
case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = sqstd_rex_newnode(exp,OP_EOL);break;
case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = sqstd_rex_newnode(exp,OP_DOT);break;
default:
ret = sqstd_rex_charnode(exp,SQFalse);
break;
}
SQBool isgreedy = SQFalse;
unsigned short p0 = 0, p1 = 0;
switch(*exp->_p){
case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break;
case '{':
exp->_p++;
if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected"));
p0 = (unsigned short)sqstd_rex_parsenumber(exp);
/*******************************/
switch(*exp->_p) {
case '}':
p1 = p0; exp->_p++;
break;
case ',':
exp->_p++;
p1 = 0xFFFF;
if(isdigit(*exp->_p)){
p1 = (unsigned short)sqstd_rex_parsenumber(exp);
}
sqstd_rex_expect(exp,'}');
break;
default:
sqstd_rex_error(exp,_SC(", or } expected"));
}
/*******************************/
isgreedy = SQTrue;
break;
}
if(isgreedy) {
SQInteger nnode = sqstd_rex_newnode(exp,OP_GREEDY);
exp->_nodes[nnode].left = ret;
exp->_nodes[nnode].right = ((p0)<<16)|p1;
ret = nnode;
}
if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {
SQInteger nnode = sqstd_rex_element(exp);
exp->_nodes[ret].next = nnode;
}
return ret;
} | 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(%rax)
jne 0x832a
addq $0x2, %rax
movq %rax, 0x10(%rbx)
movl $0x3a, %esi
movq %rbx, %rdi
callq 0x8725
movl $0x103, %esi # imm = 0x103
movq %rbx, %rdi
callq 0x7aa2
movq %rax, %r14
movq %rbx, %rdi
callq 0x7b2e
movq 0x28(%rbx), %rcx
movq %r14, %rdx
shlq $0x5, %rdx
movq %rax, 0x8(%rcx,%rdx)
movl $0x29, %esi
jmp 0x854d
cmpl $0x2e, %ecx
je 0x83a6
cmpl $0x5b, %ecx
jne 0x8389
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
cmpb $0x5e, 0x1(%rax)
jne 0x83c2
movq %rbx, %rdi
movl $0x107, %esi # imm = 0x107
callq 0x7aa2
movq 0x10(%rbx), %rcx
incq %rcx
movq %rcx, 0x10(%rbx)
jmp 0x83d3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x875c
jmp 0x83ba
incq %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x10a, %esi # imm = 0x10A
jmp 0x83b5
incq %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movl $0x104, %esi # imm = 0x104
callq 0x7aa2
movq %rax, %r14
jmp 0x8555
movq %rbx, %rdi
movl $0x105, %esi # imm = 0x105
callq 0x7aa2
movq 0x10(%rbx), %rcx
movb (%rcx), %dl
cmpb $0x5d, %dl
je 0x86e0
movq $-0x1, %r13
movq %rax, (%rsp)
movq %rax, %r14
cmpq (%rbx), %rcx
je 0x8514
cmpb $0x2d, %dl
setne %al
cmpq $-0x1, %r13
sete %dl
orb %al, %dl
jne 0x8497
leaq 0x1(%rcx), %rax
movq %rax, 0x10(%rbx)
cmpb $0x5d, (%rcx)
je 0x86bc
movq %rbx, %rdi
movl $0x108, %esi # imm = 0x108
callq 0x7aa2
movq %rax, %r15
movq 0x10(%rbx), %rbp
movq 0x28(%rbx), %r12
shlq $0x5, %r13
movslq (%r12,%r13), %rax
movsbl (%rbp), %ecx
cmpl %ecx, %eax
jg 0x86aa
movq %r15, %r13
shlq $0x5, %r13
movq %rax, 0x8(%r12,%r13)
movsbl (%rbp), %edi
cmpl $0x5c, %edi
jne 0x84b9
leaq 0x1(%rbp), %rax
movq %rax, 0x10(%rbx)
movsbl 0x1(%rbp), %ecx
addl $-0x66, %ecx
rorl %ecx
addq $0x2, %rbp
movq %rbp, 0x10(%rbx)
cmpl $0x9, %ecx
jae 0x8492
movl %ecx, %edx
leaq 0x3139(%rip), %rsi # 0xb5bc
addq %rsi, %rdx
movl $0x1d1, %esi # imm = 0x1D1
btl %ecx, %esi
cmovbq %rdx, %rax
movq %rax, %rbp
jmp 0x84ce
cmpq $-0x1, %r13
je 0x84ed
movq 0x28(%rbx), %rax
shlq $0x5, %r14
movq %r13, 0x18(%rax,%r14)
movl $0x1, %esi
movq %rbx, %rdi
callq 0x875c
jmp 0x84fd
callq 0x5750
testl %eax, %eax
je 0x86ce
leaq 0x1(%rbp), %rax
movq %rax, 0x10(%rbx)
movsbq (%rbp), %rax
movq %rax, 0x10(%r12,%r13)
shlq $0x5, %r14
movq %r15, 0x18(%r12,%r14)
movq $-0x1, %rax
movq %r15, %r13
jmp 0x84fd
movl $0x1, %esi
movq %rbx, %rdi
callq 0x875c
movq %r14, %r13
movq %r13, %r14
movq 0x10(%rbx), %rcx
movb (%rcx), %dl
movq %rax, %r13
cmpb $0x5d, %dl
jne 0x83ec
jmp 0x8517
movq %r13, %rax
movq 0x28(%rbx), %rcx
cmpq $-0x1, %rax
je 0x852a
shlq $0x5, %r14
movq %rax, 0x18(%rcx,%r14)
movq (%rsp), %r14
movq %r14, %rax
shlq $0x5, %rax
movq 0x18(%rcx,%rax), %rdx
movq %rdx, 0x8(%rcx,%rax)
movq $-0x1, 0x18(%rcx,%rax)
movl $0x5d, %esi
movq %rbx, %rdi
callq 0x8725
movq 0x10(%rbx), %rax
movb (%rax), %cl
movzbl %cl, %edx
cmpl $0x3e, %edx
jg 0x8588
cmpl $0x2a, %edx
je 0x85da
cmpl $0x2b, %edx
jne 0x8664
incq %rax
movq %rax, 0x10(%rbx)
movl $0xffff, %eax # imm = 0xFFFF
movl $0x10000, %r15d # imm = 0x10000
jmp 0x8633
cmpl $0x3f, %edx
je 0x85e8
cmpl $0x7b, %edx
jne 0x8664
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x86f2
movq %rbx, %rdi
callq 0x8958
movq %rax, %r15
movq 0x10(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x2c, %ecx
je 0x85f9
cmpl $0x7d, %ecx
jne 0x8704
incq %rax
movq %rax, 0x10(%rbx)
movl %r15d, %r12d
jmp 0x862b
incq %rax
movq %rax, 0x10(%rbx)
movl $0xffff, %eax # imm = 0xFFFF
jmp 0x85f4
incq %rax
movq %rax, 0x10(%rbx)
movl $0x1, %eax
xorl %r15d, %r15d
jmp 0x8633
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
movl $0xffff, %r12d # imm = 0xFFFF
cmpl $0x9, %eax
ja 0x861e
movq %rbx, %rdi
callq 0x8958
movq %rax, %r12
movl $0x7d, %esi
movq %rbx, %rdi
callq 0x8725
shll $0x10, %r15d
movzwl %r12w, %eax
orl %eax, %r15d
movq %rbx, %rdi
movl $0x100, %esi # imm = 0x100
callq 0x7aa2
movq 0x28(%rbx), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
movq %r14, 0x8(%rcx,%rdx)
movslq %r15d, %rsi
movq %rsi, 0x10(%rcx,%rdx)
movq 0x10(%rbx), %rcx
movb (%rcx), %cl
movq %rax, %r14
movzbl %cl, %eax
cmpb $0x2b, %al
ja 0x867b
movabsq $0xe0000000001, %rcx # imm = 0xE0000000001
btq %rax, %rcx
jb 0x8698
cmpl $0x7c, %eax
je 0x8698
movq %rbx, %rdi
callq 0x82d1
movq 0x28(%rbx), %rcx
movq %r14, %rdx
shlq $0x5, %rdx
movq %rax, 0x18(%rcx,%rdx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2f6c(%rip), %rcx # 0xb626
jmp 0x8714
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2f49(%rip), %rcx # 0xb615
jmp 0x8714
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2f56(%rip), %rcx # 0xb634
jmp 0x8714
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2f19(%rip), %rcx # 0xb609
jmp 0x8714
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2ed8(%rip), %rcx # 0xb5da
jmp 0x8714
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x8717
leaq 0x2ed6(%rip), %rcx # 0xb5ea
movq %rcx, (%rax)
movq 0x58(%rbx), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x51b0
| /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;
};
return ret;
} | 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
movsbq -0x1(%rcx), %rsi
leaq (%rsi,%rax,2), %rax
addq $-0x30, %rax
addq %rdx, %rdx
leaq (%rdx,%rdx,4), %rdx
movsbl (%rcx), %esi
addl $-0x30, %esi
incq %rcx
cmpl $0xa, %esi
jb 0x8982
popq %rcx
retq
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0x89ca
leaq 0x2ce7(%rip), %rcx # 0xb6ae
movq %rcx, (%rax)
movq 0x58(%rdi), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x51b0
| /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_throwerror(v,_SC("no data left to read"));
blobp = sqstd_createblob(v,res);
memcpy(blobp,data,res);
return 1;
} | 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 0x8bb3
leaq 0x8(%rsp), %r14
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5380
movq (%r14), %r14
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpq %rax, %r14
jle 0x8bd5
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %rsi
movq %rax, 0x8(%rsp)
jmp 0x8bda
leaq 0x2b6a(%rip), %rsi # 0xb724
jmp 0x8bc3
leaq 0x267c(%rip), %rsi # 0xb23f
movq %rbx, %rdi
callq 0x5310
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5100
movq %rax, %r14
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
testq %rax, %rax
jle 0x8c1f
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5680
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x53b0
movl $0x1, %eax
jmp 0x8bcb
leaq 0x2b14(%rip), %rsi # 0xb73a
jmp 0x8bc3
| /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));
SQInteger i = 0;
while(_stream_methods[i].name != 0) {
const SQRegFunction &f = _stream_methods[i];
sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask);
sq_newslot(v,-3,SQFalse);
i++;
}
sq_newslot(v,-3,SQFalse);
sq_pushroottable(v);
sq_pushstring(v,_SC("stream"),-1);
sq_pushstring(v,_SC("std_stream"),-1);
sq_get(v,-4);
sq_newslot(v,-3,SQFalse);
sq_pop(v,1);
}
else {
sq_pop(v,1); //result
}
sq_pop(v,1);
} | 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 0x5030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5330
movl $0x80000000, %edx # imm = 0x80000000
movq %rbx, %rdi
movq $-0x1, %rsi
callq 0x50b0
leaq 0x236c(%rip), %rsi # 0xb7a7
movl $0x20, %r15d
leaq 0x64b8(%rip), %r12 # 0xf900
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5030
movq -0x18(%r15,%r12), %rsi
movq -0x10(%r15,%r12), %r14
movq %rbx, %rdi
xorl %edx, %edx
callq 0x52a0
movq -0x8(%r15,%r12), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x57e0
movq %rbx, %rdi
movq $-0x3, %rsi
xorl %edx, %edx
callq 0x55c0
movq (%r15,%r12), %rsi
addq $0x20, %r15
cmpq $0x160, %r15 # imm = 0x160
jne 0x9448
movq %rbx, %rdi
movq $-0x3, %rsi
xorl %edx, %edx
callq 0x55c0
movq %rbx, %rdi
callq 0x51e0
leaq 0x22e3(%rip), %rsi # 0xb7a0
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5030
leaq 0x22c9(%rip), %rsi # 0xb79c
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x5030
movq %rbx, %rdi
movq $-0x4, %rsi
callq 0x5230
movq %rbx, %rdi
movq $-0x3, %rsi
xorl %edx, %edx
callq 0x55c0
movl $0x1, %esi
movq %rbx, %rdi
callq 0x50e0
movl $0x1, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x50e0
| /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);
return 1;
}
return 0;
} | 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
cmpq $0x3, %rax
jl 0x9f52
leaq 0x8(%rsp), %r14
movl $0x3, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5380
movq (%r14), %rsi
jmp 0x9f54
leaq 0x12f7(%rip), %rsi # 0xb23f
movq %rbx, %rdi
callq 0x5310
jmp 0x9f91
xorl %esi, %esi
movq 0x20(%rsp), %rdi
addq (%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x5600
cmpq $0x1, %rax
jne 0x9f8f
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rbx, %rdi
callq 0xa1db
movl $0x1, %eax
jmp 0x9f91
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /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 %eax, %eax
je 0xa36c
movb 0x1(%r15), %al
incq %r15
testb %al, %al
jne 0xa355
testq %r12, %r12
je 0xa399
leaq (%r12,%r14), %rcx
decq %rcx
movq %rcx, %r12
cmpq %r14, %rcx
jb 0xa393
movsbl (%r12), %edi
callq 0x5070
leaq -0x1(%r12), %rcx
testl %eax, %eax
jne 0xa378
incq %r12
movq %r12, %r14
subq %r15, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x5030
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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 ? SQTrue : SQFalse;
}
sq_pushbool(v,ret);
return 1;
} | 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
jmp 0xa770
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x54c0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x5740
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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_setnativeclosurename(v,-1,systemlib_funcs[i].name);
sq_newslot(v,-3,SQFalse);
i++;
}
return 1;
} | 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 0x52a0
movq -0x8(%r12,%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x57e0
movq %rbx, %rdi
movq $-0x1, %rsi
movq %r14, %rdx
callq 0x55f0
movq %rbx, %rdi
movq $-0x3, %rsi
xorl %edx, %edx
callq 0x55c0
movq (%r12,%r13), %r14
addq $0x20, %r12
cmpq $0x100, %r12 # imm = 0x100
jne 0xa828
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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, %rdi
callq 0x21a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
| /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
callq 0x5490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x54a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x53b0
movl $0x0, 0xc(%rsp)
movzwl 0x10(%rsp), %eax
cmpw $0x1, %ax
je 0x67c2
movq 0x136fa(%rip), %rcx # 0x19ea8
cmpw (%rcx), %ax
je 0x67c2
leaq 0xc(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5170
movl 0x18(%rsp), %edi
movl %edi, 0xc(%rsp)
callq 0x5250
leaq 0x10(%rsp), %rdi
callq 0x5810
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5810
movq %rbx, %rdi
callq 0x5820
| /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 0x13d6b(%rip), %rdi # 0x1a698
movl $0x1, %edx
movl $0x150, %esi # imm = 0x150
callq 0x55e0
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5390
movq 0x135d0(%rip), %rdi # 0x19f20
leaq 0xd66b(%rip), %rsi # 0x13fc2
movl $0x16, %edx
callq 0x5560
movq 0x135b8(%rip), %rdi # 0x19f20
leaq 0x13d29(%rip), %rsi # 0x1a698
callq 0x5760
movq %rax, %rbx
leaq 0xd661(%rip), %rsi # 0x13fdf
movl $0x4, %edx
movq %rax, %rdi
callq 0x5560
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
movq %rax, %rbx
leaq 0xd637(%rip), %rsi # 0x13fd9
movl $0xa, %edx
movq %rax, %rdi
callq 0x5560
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x54a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
callq 0x53b0
cmpw $0x8008, 0x10(%rsp) # imm = 0x8008
jne 0x6a08
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57c0
jmp 0x6a19
leaq 0xd5d5(%rip), %rsi # 0x13fe4
leaq 0x8(%rsp), %rdi
callq 0x5070
leaq 0x8(%rsp), %rdi
callq 0x54d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5810
leaq 0x8(%rsp), %rdi
callq 0x5540
leaq 0x20(%rsp), %rdi
callq 0x5810
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x6a69
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5810
leaq 0x8(%rsp), %rdi
callq 0x5540
leaq 0x20(%rsp), %rdi
callq 0x5810
movq %rbx, %rdi
callq 0x5820
| /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 0x6877
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x5810
movq %rsp, %rdi
callq 0x5810
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5810
jmp 0x6c1b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5810
movq %rbx, %rdi
callq 0x5820
| /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 name for " << self << " is `" << outs << "'\n"
<< std::flush;
return Am_String(outs);
} | 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
movw $0x20, 0xfbed(%rip) # 0x1a9d8
cmpw $0x8008, 0x8(%rsp) # imm = 0x8008
jne 0xae22
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x50a0
movq %rsp, %rdi
callq 0x5700
leaq 0xfbc0(%rip), %rdi # 0x1a9d0
movq %rax, %rsi
callq 0x5830
movq %rsp, %rdi
callq 0x5540
jmp 0xae41
leaq 0xfba7(%rip), %r14 # 0x1a9d0
movq %r14, %rdi
callq 0x51b0
movl $0x74696857, (%rax,%r14) # imm = 0x74696857
movw $0x65, 0x4(%rax,%r14)
movq 0xf0d8(%rip), %rdi # 0x19f20
leaq 0xa2d6(%rip), %rsi # 0x15125
movl $0xd, %edx
callq 0x5560
movq 0xf0c0(%rip), %rdi # 0x19f20
movq %rbx, %rsi
callq 0x5760
movq %rax, %rbx
leaq 0xa3d8(%rip), %rsi # 0x1524a
movl $0x5, %edx
movq %rax, %rdi
callq 0x5560
leaq 0xfb4a(%rip), %r14 # 0x1a9d0
movq %r14, %rdi
callq 0x51b0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5560
leaq 0xa290(%rip), %rsi # 0x15133
movl $0x2, %edx
movq %rbx, %rdi
callq 0x5560
movq %rbx, %rdi
callq 0x53b0
leaq 0xfb11(%rip), %rsi # 0x1a9d0
movq %rsp, %rdi
movl $0x1, %edx
callq 0x5330
movq %rsp, %rdi
callq 0x54d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5540
leaq 0x8(%rsp), %rdi
callq 0x5810
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0xaef8
jmp 0xaf07
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5540
jmp 0xaf0a
jmp 0xaf07
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5810
movq %rbx, %rdi
callq 0x5820
| /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("Amulet_Icon")
.Set(Am_IMAGE, amulet_icon_image)
.Set(Am_LINE_STYLE, Am_Black)
.Set(Am_FILL_STYLE, Am_No_Style);
} | 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), %rbx
movq %rbx, %rdi
callq 0x5360
xorl %eax, %eax
movq 0xe425(%rip), %r9 # 0x19e78
leaq 0x8(%rsp), %rdi
movss 0x77f0(%rip), %xmm0 # 0x13250
movss 0x77ec(%rip), %xmm1 # 0x13254
movss 0x77e8(%rip), %xmm2 # 0x13258
movl $0x0, %esi
movl $0x1, %edx
movl $0x0, %ecx
movl $0x0, %r8d
pushq %rbx
pushq %rax
pushq %rax
pushq $0x2
callq 0x5580
addq $0x20, %rsp
leaq 0xebde(%rip), %rdi # 0x1a678
leaq 0x8(%rsp), %rsi
callq 0x5510
leaq 0x8(%rsp), %rdi
callq 0x5920
leaq 0x18(%rsp), %rdi
callq 0x5310
movq 0xe451(%rip), %rsi # 0x19f10
leaq 0x7976(%rip), %rdx # 0x1343c
leaq 0x8(%rsp), %rdi
callq 0x5080
leaq 0x10(%rsp), %rdi
callq 0x5450
leaq 0x8(%rsp), %rdi
movl $0xb0, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x5740
movq %rax, %rbx
movq 0xe358(%rip), %rdi # 0x19e50
callq 0x5410
movq %rbx, %rdi
movl $0x6b, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x5740
movq %rax, %rbx
movq 0xe4bf(%rip), %rdi # 0x19fd8
callq 0x5410
movq %rbx, %rdi
movl $0x6a, %esi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x5740
leaq 0xeb49(%rip), %rdi # 0x1a680
movq %rax, %rsi
callq 0x58a0
leaq 0x8(%rsp), %rdi
callq 0x5918
leaq 0x10(%rsp), %rdi
callq 0x5310
addq $0x20, %rsp
popq %rbx
retq
leaq 0x78be(%rip), %rdi # 0x1341e
callq 0x5690
jmp 0xbb87
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5920
jmp 0xbb79
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5310
jmp 0xbb99
jmp 0xbb87
movq %rax, %rbx
jmp 0xbb99
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5918
leaq 0x10(%rsp), %rdi
callq 0x5310
movq %rbx, %rdi
callq 0x5820
| /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
callq 0x52b0
leaq 0x8(%rsp), %rdi
callq 0x54e0
addq $0x270, %rsp # imm = 0x270
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x54e0
movq %rbx, %rdi
callq 0x5820
| /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
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl $0xffffd8f0, %ecx # imm = 0xFFFFD8F0
movl $0xffffd8f0, %r8d # imm = 0xFFFFD8F0
movl $0x1, %r9d
callq 0x54c0
leaq 0x8(%rsp), %rdi
callq 0x5540
leaq 0x10(%rsp), %rdi
callq 0x54b0
leaq 0x30(%rsp), %rdi
callq 0x54b0
movq 0xe1c1(%rip), %rdi # 0x19f20
leaq 0x94d6(%rip), %rsi # 0x1523c
movl $0x13, %edx
callq 0x5560
movq 0xe1a9(%rip), %rdi # 0x19f20
leaq 0x20(%rsp), %rsi
callq 0x5490
movq %rax, %rbx
leaq 0x93a8(%rip), %rsi # 0x15133
movl $0x2, %edx
movq %rax, %rdi
callq 0x5560
movq %rbx, %rdi
callq 0x53b0
leaq 0x20(%rsp), %rdi
callq 0x5810
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5540
jmp 0xbdc2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x54b0
jmp 0xbdd1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x54b0
jmp 0xbdea
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5810
movq %rbx, %rdi
callq 0x5820
| /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_bytes = (short)l;
short high_bytes = (short)(l >> 16);
code = low_bytes;
shift = (high_bytes & AmShiftMask);
control = (high_bytes & AmControlMask) >> 1;
meta = (high_bytes & AmMetaMask) >> 2;
any_modifier = (high_bytes & AmAnyModMask) >> 3;
button_down = (Am_Button_Down)((high_bytes & AmBDownMask) >> 4);
click_count = (Am_Click_Count)((high_bytes & AmCCountMask) >> 8);
} | 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)
retq
pushq %rax
callq 0x5270
| /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, epoll__rdhup_linux);
ATF_TP_ADD_TC(tp, epoll__simple_wait);
ATF_TP_ADD_TC(tp, epoll__event_size);
ATF_TP_ADD_TC(tp, epoll__recursive_register);
ATF_TP_ADD_TC(tp, epoll__simple_epollin);
ATF_TP_ADD_TC(tp, epoll__sleep_argument);
ATF_TP_ADD_TC(tp, epoll__remove_nonexistent);
ATF_TP_ADD_TC(tp, epoll__add_remove);
ATF_TP_ADD_TC(tp, epoll__add_existing);
ATF_TP_ADD_TC(tp, epoll__modify_existing);
ATF_TP_ADD_TC(tp, epoll__modify_nonexisting);
ATF_TP_ADD_TC(tp, epoll__poll_only_fd);
ATF_TP_ADD_TC(tp, epoll__no_epollin_on_closed_empty_pipe);
ATF_TP_ADD_TC(tp, epoll__write_to_pipe_until_full);
ATF_TP_ADD_TC(tp, epoll__realtime_timer);
ATF_TP_ADD_TC(tp, epoll__simple_signalfd);
ATF_TP_ADD_TC(tp, epoll__signalfd_poll_sigusr1);
ATF_TP_ADD_TC(tp, epoll__signalfd_in_thread);
ATF_TP_ADD_TC(tp, epoll__socket_shutdown);
ATF_TP_ADD_TC(tp, epoll__epollhup_on_fresh_socket);
ATF_TP_ADD_TC(tp, epoll__epollout_on_connecting_socket);
ATF_TP_ADD_TC(tp, epoll__epollpri);
ATF_TP_ADD_TC(tp, epoll__epollpri_oobinline);
ATF_TP_ADD_TC(tp, epoll__epollpri_oobinline_lt);
ATF_TP_ADD_TC(tp, epoll__timeout_on_listening_socket);
ATF_TP_ADD_TC(tp, epoll__epollerr_on_closed_pipe);
ATF_TP_ADD_TC(tp, epoll__shutdown_behavior);
ATF_TP_ADD_TC(tp, epoll__datagram_connection);
ATF_TP_ADD_TC(tp, epoll__epollout_on_own_shutdown);
ATF_TP_ADD_TC(tp, epoll__remove_closed);
ATF_TP_ADD_TC(tp, epoll__remove_closed_when_same_fd_open);
ATF_TP_ADD_TC(tp, epoll__add_different_file_with_same_fd_value);
ATF_TP_ADD_TC(tp, epoll__invalid_writes);
ATF_TP_ADD_TC(tp, epoll__using_real_close);
ATF_TP_ADD_TC(tp, epoll__epoll_pwait);
ATF_TP_ADD_TC(tp, epoll__cloexec);
ATF_TP_ADD_TC(tp, epoll__fcntl_fl);
ATF_TP_ADD_TC(tp, epoll__fcntl_issue49);
return atf_no_error();
} | 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, epoll__rdhup_linux);
ATF_TP_ADD_TC(tp, epoll__simple_wait);
ATF_TP_ADD_TC(tp, epoll__event_size);
ATF_TP_ADD_TC(tp, epoll__recursive_register);
ATF_TP_ADD_TC(tp, epoll__simple_epollin);
ATF_TP_ADD_TC(tp, epoll__sleep_argument);
ATF_TP_ADD_TC(tp, epoll__remove_nonexistent);
ATF_TP_ADD_TC(tp, epoll__add_remove);
ATF_TP_ADD_TC(tp, epoll__add_existing);
ATF_TP_ADD_TC(tp, epoll__modify_existing);
ATF_TP_ADD_TC(tp, epoll__modify_nonexisting);
ATF_TP_ADD_TC(tp, epoll__poll_only_fd);
ATF_TP_ADD_TC(tp, epoll__no_epollin_on_closed_empty_pipe);
ATF_TP_ADD_TC(tp, epoll__write_to_pipe_until_full);
ATF_TP_ADD_TC(tp, epoll__realtime_timer);
ATF_TP_ADD_TC(tp, epoll__simple_signalfd);
ATF_TP_ADD_TC(tp, epoll__signalfd_poll_sigusr1);
ATF_TP_ADD_TC(tp, epoll__signalfd_in_thread);
ATF_TP_ADD_TC(tp, epoll__socket_shutdown);
ATF_TP_ADD_TC(tp, epoll__epollhup_on_fresh_socket);
ATF_TP_ADD_TC(tp, epoll__epollout_on_connecting_socket);
ATF_TP_ADD_TC(tp, epoll__epollpri);
ATF_TP_ADD_TC(tp, epoll__epollpri_oobinline);
ATF_TP_ADD_TC(tp, epoll__epollpri_oobinline_lt);
ATF_TP_ADD_TC(tp, epoll__timeout_on_listening_socket);
ATF_TP_ADD_TC(tp, epoll__epollerr_on_closed_pipe);
ATF_TP_ADD_TC(tp, epoll__shutdown_behavior);
ATF_TP_ADD_TC(tp, epoll__datagram_connection);
ATF_TP_ADD_TC(tp, epoll__epollout_on_own_shutdown);
ATF_TP_ADD_TC(tp, epoll__remove_closed);
ATF_TP_ADD_TC(tp, epoll__remove_closed_when_same_fd_open);
ATF_TP_ADD_TC(tp, epoll__add_different_file_with_same_fd_value);
ATF_TP_ADD_TC(tp, epoll__invalid_writes);
ATF_TP_ADD_TC(tp, epoll__using_real_close);
ATF_TP_ADD_TC(tp, epoll__epoll_pwait);
ATF_TP_ADD_TC(tp, epoll__cloexec);
ATF_TP_ADD_TC(tp, epoll__fcntl_fl);
ATF_TP_ADD_TC(tp, epoll__fcntl_issue49);
return atf_no_error();
} | 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
jmp 0x25a1
jmp 0x25a3
movq -0x10(%rbp), %rdi
leaq 0x15a52(%rip), %rsi # 0x18000
callq 0x2110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x25c6
jmp 0x25d3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x25d5
jmp 0x25d7
movq -0x10(%rbp), %rdi
leaq 0x17a1e(%rip), %rsi # 0x1a000
callq 0x2110
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x25fa
jmp 0x2607
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2609
jmp 0x260b
movq -0x10(%rbp), %rdi
leaq 0x199ea(%rip), %rsi # 0x1c000
callq 0x2110
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x262e
jmp 0x263b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x263d
jmp 0x263f
movq -0x10(%rbp), %rdi
leaq 0x1b9b6(%rip), %rsi # 0x1e000
callq 0x2110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2662
jmp 0x266f
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2671
jmp 0x2673
movq -0x10(%rbp), %rdi
leaq 0x1d982(%rip), %rsi # 0x20000
callq 0x2110
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2696
jmp 0x26a3
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x26a5
jmp 0x26a7
movq -0x10(%rbp), %rdi
leaq 0x1f94e(%rip), %rsi # 0x22000
callq 0x2110
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x26ca
jmp 0x26d7
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x26d9
jmp 0x26db
movq -0x10(%rbp), %rdi
leaq 0x2191a(%rip), %rsi # 0x24000
callq 0x2110
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x26fe
jmp 0x270b
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x270d
jmp 0x270f
movq -0x10(%rbp), %rdi
leaq 0x238e6(%rip), %rsi # 0x26000
callq 0x2110
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2732
jmp 0x273f
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2741
jmp 0x2743
movq -0x10(%rbp), %rdi
leaq 0x258b2(%rip), %rsi # 0x28000
callq 0x2110
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2766
jmp 0x2773
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2775
jmp 0x2777
movq -0x10(%rbp), %rdi
leaq 0x2787e(%rip), %rsi # 0x2a000
callq 0x2110
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x279a
jmp 0x27a7
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x27a9
jmp 0x27ab
movq -0x10(%rbp), %rdi
leaq 0x2984a(%rip), %rsi # 0x2c000
callq 0x2110
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x27ce
jmp 0x27db
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x27dd
jmp 0x27df
movq -0x10(%rbp), %rdi
leaq 0x2b816(%rip), %rsi # 0x2e000
callq 0x2110
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2802
jmp 0x280f
movq -0x78(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2811
jmp 0x2813
movq -0x10(%rbp), %rdi
leaq 0x2d7e2(%rip), %rsi # 0x30000
callq 0x2110
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2836
jmp 0x2843
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2845
jmp 0x2847
movq -0x10(%rbp), %rdi
leaq 0x2f7ae(%rip), %rsi # 0x32000
callq 0x2110
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2870
jmp 0x2880
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2882
jmp 0x2884
movq -0x10(%rbp), %rdi
leaq 0x31771(%rip), %rsi # 0x34000
callq 0x2110
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x28ad
jmp 0x28bd
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x28bf
jmp 0x28c1
movq -0x10(%rbp), %rdi
leaq 0x33734(%rip), %rsi # 0x36000
callq 0x2110
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x28ea
jmp 0x28fa
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x28fc
jmp 0x28fe
movq -0x10(%rbp), %rdi
leaq 0x356f7(%rip), %rsi # 0x38000
callq 0x2110
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2927
jmp 0x2937
movq -0xa0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2939
jmp 0x293b
movq -0x10(%rbp), %rdi
leaq 0x376ba(%rip), %rsi # 0x3a000
callq 0x2110
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2964
jmp 0x2974
movq -0xa8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2976
jmp 0x2978
movq -0x10(%rbp), %rdi
leaq 0x3967d(%rip), %rsi # 0x3c000
callq 0x2110
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x29a1
jmp 0x29b1
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x29b3
jmp 0x29b5
movq -0x10(%rbp), %rdi
leaq 0x3b640(%rip), %rsi # 0x3e000
callq 0x2110
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x29de
jmp 0x29ee
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x29f0
jmp 0x29f2
movq -0x10(%rbp), %rdi
leaq 0x3d603(%rip), %rsi # 0x40000
callq 0x2110
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2a1b
jmp 0x2a2b
movq -0xc0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2a2d
jmp 0x2a2f
movq -0x10(%rbp), %rdi
leaq 0x3f5c6(%rip), %rsi # 0x42000
callq 0x2110
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2a58
jmp 0x2a68
movq -0xc8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2a6a
jmp 0x2a6c
movq -0x10(%rbp), %rdi
leaq 0x41589(%rip), %rsi # 0x44000
callq 0x2110
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2a95
jmp 0x2aa5
movq -0xd0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2aa7
jmp 0x2aa9
movq -0x10(%rbp), %rdi
leaq 0x4354c(%rip), %rsi # 0x46000
callq 0x2110
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2ad2
jmp 0x2ae2
movq -0xd8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2ae4
jmp 0x2ae6
movq -0x10(%rbp), %rdi
leaq 0x4550f(%rip), %rsi # 0x48000
callq 0x2110
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2b0f
jmp 0x2b1f
movq -0xe0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2b21
jmp 0x2b23
movq -0x10(%rbp), %rdi
leaq 0x474d2(%rip), %rsi # 0x4a000
callq 0x2110
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2b4c
jmp 0x2b5c
movq -0xe8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2b5e
jmp 0x2b60
movq -0x10(%rbp), %rdi
leaq 0x49495(%rip), %rsi # 0x4c000
callq 0x2110
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2b89
jmp 0x2b99
movq -0xf0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2b9b
jmp 0x2b9d
movq -0x10(%rbp), %rdi
leaq 0x4b458(%rip), %rsi # 0x4e000
callq 0x2110
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2bc6
jmp 0x2bd6
movq -0xf8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2bd8
jmp 0x2bda
movq -0x10(%rbp), %rdi
leaq 0x4d41b(%rip), %rsi # 0x50000
callq 0x2110
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2c03
jmp 0x2c13
movq -0x100(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2c15
jmp 0x2c17
movq -0x10(%rbp), %rdi
leaq 0x4f3de(%rip), %rsi # 0x52000
callq 0x2110
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2c40
jmp 0x2c50
movq -0x108(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2c52
jmp 0x2c54
movq -0x10(%rbp), %rdi
leaq 0x513a1(%rip), %rsi # 0x54000
callq 0x2110
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2c7d
jmp 0x2c8d
movq -0x110(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2c8f
jmp 0x2c91
movq -0x10(%rbp), %rdi
leaq 0x53364(%rip), %rsi # 0x56000
callq 0x2110
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2cba
jmp 0x2cca
movq -0x118(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2ccc
jmp 0x2cce
movq -0x10(%rbp), %rdi
leaq 0x55327(%rip), %rsi # 0x58000
callq 0x2110
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2cf7
jmp 0x2d07
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2d09
jmp 0x2d0b
movq -0x10(%rbp), %rdi
leaq 0x572ea(%rip), %rsi # 0x5a000
callq 0x2110
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2d34
jmp 0x2d44
movq -0x128(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2d46
jmp 0x2d48
movq -0x10(%rbp), %rdi
leaq 0x592ad(%rip), %rsi # 0x5c000
callq 0x2110
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2d71
jmp 0x2d81
movq -0x130(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2d83
jmp 0x2d85
movq -0x10(%rbp), %rdi
leaq 0x5b270(%rip), %rsi # 0x5e000
callq 0x2110
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2dae
jmp 0x2dbe
movq -0x138(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2dc0
jmp 0x2dc2
movq -0x10(%rbp), %rdi
leaq 0x5d233(%rip), %rsi # 0x60000
callq 0x2110
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2deb
jmp 0x2dfb
movq -0x140(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2dfd
jmp 0x2dff
movq -0x10(%rbp), %rdi
leaq 0x5f1f6(%rip), %rsi # 0x62000
callq 0x2110
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2e28
jmp 0x2e38
movq -0x148(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2e3a
jmp 0x2e3c
movq -0x10(%rbp), %rdi
leaq 0x611b9(%rip), %rsi # 0x64000
callq 0x2110
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2e65
jmp 0x2e75
movq -0x150(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2e77
jmp 0x2e79
movq -0x10(%rbp), %rdi
leaq 0x6317c(%rip), %rsi # 0x66000
callq 0x2110
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2ea2
jmp 0x2eb2
movq -0x158(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2eb4
jmp 0x2eb6
movq -0x10(%rbp), %rdi
leaq 0x6513f(%rip), %rsi # 0x68000
callq 0x2110
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2edf
jmp 0x2eec
movq -0x160(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2eee
jmp 0x2ef0
movq -0x10(%rbp), %rdi
leaq 0x67105(%rip), %rsi # 0x6a000
callq 0x2110
movq %rax, -0x168(%rbp)
movq -0x168(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2f19
jmp 0x2f26
movq -0x168(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2f28
jmp 0x2f2a
movq -0x10(%rbp), %rdi
leaq 0x690cb(%rip), %rsi # 0x6c000
callq 0x2110
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rdi
callq 0x2180
testb $0x1, %al
jne 0x2f53
jmp 0x2f60
movq -0x170(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2f6b
jmp 0x2f62
callq 0x2350
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopl (%rax,%rax)
| /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(1337);
ATF_REQUIRE(inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr) == 1);
ATF_REQUIRE(bind(sock, /**/
(struct sockaddr const *)&addr, sizeof(addr)) == 0);
return sock;
} | 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
movb $0x0, %al
callq 0x21b0
jmp 0x5515
movl $0x1, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x8(%rbp), %rcx
movl $0x4, %r8d
callq 0x20b0
cmpl $0x0, %eax
je 0x555e
leaq 0x8ace(%rip), %rdi # 0xe012
leaq 0x8bd8(%rip), %rsi # 0xe123
movl $0x6e, %edx
leaq 0x9753(%rip), %rcx # 0xecaa
movb $0x0, %al
callq 0x21b0
jmp 0x5560
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2190
movw $0x2, -0x18(%rbp)
movl $0x539, %edi # imm = 0x539
callq 0x2140
movw %ax, -0x16(%rbp)
leaq -0x18(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
leaq 0x9758(%rip), %rsi # 0xecf0
callq 0x2280
cmpl $0x1, %eax
je 0x55c3
leaq 0x8a69(%rip), %rdi # 0xe012
leaq 0x8b73(%rip), %rsi # 0xe123
movl $0x73, %edx
leaq 0x973e(%rip), %rcx # 0xecfa
movb $0x0, %al
callq 0x21b0
jmp 0x55c5
jmp 0x55c7
movl -0x4(%rbp), %edi
leaq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x2320
cmpl $0x0, %eax
je 0x5606
leaq 0x8a26(%rip), %rdi # 0xe012
leaq 0x8b30(%rip), %rsi # 0xe123
movl $0x76, %edx
leaq 0x9730(%rip), %rcx # 0xed2f
movb $0x0, %al
callq 0x21b0
jmp 0x5608
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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_thread, NULL, sleep_then_write,
(void *)(intptr_t)(fds[1])) == 0);
ATF_REQUIRE(epoll_wait(ep, &event, 1, sleep) == 1);
ATF_REQUIRE(pthread_join(writer_thread, NULL) == 0);
ATF_REQUIRE(close(fds[0]) == 0);
ATF_REQUIRE(close(fds[1]) == 0);
ATF_REQUIRE(fds[2] == -1 || close(fds[2]) == 0);
ATF_REQUIRE(close(ep) == 0);
} | 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), %rcx # 0xe95c
movb $0x0, %al
callq 0x21b0
jmp 0x56c1
leaq -0x14(%rbp), %rdi
callq 0x50d0
movl $0x1, -0x20(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
callq 0x21d0
cmpl $0x0, %eax
jge 0x570b
leaq 0x8921(%rip), %rdi # 0xe012
leaq 0x8a2b(%rip), %rsi # 0xe123
movl $0x1da, %edx # imm = 0x1DA
leaq 0x9406(%rip), %rcx # 0xeb0a
movb $0x0, %al
callq 0x21b0
jmp 0x570d
jmp 0x570f
movslq -0x10(%rbp), %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x17e(%rip), %rdx # 0x58a0
callq 0x2330
cmpl $0x0, %eax
je 0x574d
leaq 0x88df(%rip), %rdi # 0xe012
leaq 0x89e9(%rip), %rsi # 0xe123
movl $0x1de, %edx # imm = 0x1DE
leaq 0x96dd(%rip), %rcx # 0xee23
movb $0x0, %al
callq 0x21b0
jmp 0x574f
jmp 0x5751
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %ecx
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x2300
cmpl $0x1, %eax
je 0x578b
leaq 0x88a1(%rip), %rdi # 0xe012
leaq 0x89ab(%rip), %rsi # 0xe123
movl $0x1e0, %edx # imm = 0x1E0
leaq 0x96f7(%rip), %rcx # 0xee7b
movb $0x0, %al
callq 0x21b0
jmp 0x578d
jmp 0x578f
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23c0
cmpl $0x0, %eax
je 0x57c2
leaq 0x886a(%rip), %rdi # 0xe012
leaq 0x8974(%rip), %rsi # 0xe123
movl $0x1e2, %edx # imm = 0x1E2
leaq 0x96e6(%rip), %rcx # 0xeea1
movb $0x0, %al
callq 0x21b0
jmp 0x57c4
jmp 0x57c6
movl -0x14(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x57f4
leaq 0x8838(%rip), %rdi # 0xe012
leaq 0x8942(%rip), %rsi # 0xe123
movl $0x1e4, %edx # imm = 0x1E4
leaq 0x9398(%rip), %rcx # 0xeb85
movb $0x0, %al
callq 0x21b0
jmp 0x57f6
jmp 0x57f8
movl -0x10(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x5826
leaq 0x8806(%rip), %rdi # 0xe012
leaq 0x8910(%rip), %rsi # 0xe123
movl $0x1e5, %edx # imm = 0x1E5
leaq 0x9379(%rip), %rcx # 0xeb98
movb $0x0, %al
callq 0x21b0
jmp 0x5828
jmp 0x582a
cmpl $-0x1, -0xc(%rbp)
je 0x585e
movl -0xc(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x585e
leaq 0x87ce(%rip), %rdi # 0xe012
leaq 0x88d8(%rip), %rsi # 0xe123
movl $0x1e6, %edx # imm = 0x1E6
leaq 0x9354(%rip), %rcx # 0xebab
movb $0x0, %al
callq 0x21b0
jmp 0x5860
jmp 0x5862
movl -0x8(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x5890
leaq 0x879c(%rip), %rdi # 0xe012
leaq 0x88a6(%rip), %rsi # 0xe123
movl $0x1e7, %edx # imm = 0x1E7
leaq 0x911f(%rip), %rcx # 0xe9a8
movb $0x0, %al
callq 0x21b0
jmp 0x5892
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /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);
uint8_t data = '\0';
if (do_write_data) {
write(fds[1], &data, 1);
}
close(fds[1]);
struct epoll_event event_result;
ATF_REQUIRE(epoll_wait(ep, &event_result, 1, -1) == 1);
ATF_REQUIRE_MSG(event_result.events ==
(EPOLLHUP | (do_write_data ? EPOLLIN : 0)),
"%x", event_result.events);
ATF_REQUIRE(read(fds[0], &data, 1) >= 0);
ATF_REQUIRE(event_result.data.fd == fds[0]);
ATF_REQUIRE(close(fds[0]) == 0);
ATF_REQUIRE(close(ep) == 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 = 0x2C4
leaq 0x83af(%rip), %rcx # 0xe95c
movb $0x0, %al
callq 0x21b0
jmp 0x65b6
leaq -0x14(%rbp), %rdi
callq 0x50d0
movl $0x2001, -0x20(%rbp) # imm = 0x2001
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x20(%rbp), %rcx
callq 0x21d0
cmpl $0x0, %eax
je 0x6606
leaq 0x7a26(%rip), %rdi # 0xe012
leaq 0x7b30(%rip), %rsi # 0xe123
movl $0x2cd, %edx # imm = 0x2CD
leaq 0x8924(%rip), %rcx # 0xef23
movb $0x0, %al
callq 0x21b0
jmp 0x6608
movb $0x0, -0x21(%rbp)
testb $0x1, -0x1(%rbp)
je 0x6623
movl -0x10(%rbp), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x20e0
movl -0x10(%rbp), %edi
callq 0x21c0
movl -0x8(%rbp), %edi
leaq -0x2d(%rbp), %rsi
movl $0x1, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x2300
cmpl $0x1, %eax
je 0x6667
leaq 0x79c5(%rip), %rdi # 0xe012
leaq 0x7acf(%rip), %rsi # 0xe123
movl $0x2d6, %edx # imm = 0x2D6
leaq 0x84dc(%rip), %rcx # 0xeb3c
movb $0x0, %al
callq 0x21b0
jmp 0x6669
jmp 0x666b
movl -0x2d(%rbp), %eax
movb -0x1(%rbp), %sil
xorl %ecx, %ecx
movl $0x1, %edx
testb $0x1, %sil
cmovnel %edx, %ecx
orl $0x10, %ecx
cmpl %ecx, %eax
je 0x66a4
movl -0x2d(%rbp), %ecx
leaq 0x8a7d(%rip), %rdi # 0xf10e
leaq 0x7a8b(%rip), %rsi # 0xe123
movl $0x2da, %edx # imm = 0x2DA
movb $0x0, %al
callq 0x21b0
jmp 0x66a6
jmp 0x66a8
movl -0x14(%rbp), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x21e0
cmpq $0x0, %rax
jge 0x66e0
leaq 0x794c(%rip), %rdi # 0xe012
leaq 0x7a56(%rip), %rsi # 0xe123
movl $0x2dc, %edx # imm = 0x2DC
leaq 0x8a3f(%rip), %rcx # 0xf118
movb $0x0, %al
callq 0x21b0
jmp 0x66e2
jmp 0x66e4
movl -0x29(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x670d
leaq 0x791f(%rip), %rdi # 0xe012
leaq 0x7a29(%rip), %rsi # 0xe123
movl $0x2de, %edx # imm = 0x2DE
leaq 0x8460(%rip), %rcx # 0xeb66
movb $0x0, %al
callq 0x21b0
jmp 0x670f
jmp 0x6711
movl -0x14(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x673f
leaq 0x78ed(%rip), %rdi # 0xe012
leaq 0x79f7(%rip), %rsi # 0xe123
movl $0x2e0, %edx # imm = 0x2E0
leaq 0x844d(%rip), %rcx # 0xeb85
movb $0x0, %al
callq 0x21b0
jmp 0x6741
jmp 0x6743
movl -0x8(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x6771
leaq 0x78bb(%rip), %rdi # 0xe012
leaq 0x79c5(%rip), %rsi # 0xe123
movl $0x2e1, %edx # imm = 0x2E1
leaq 0x823e(%rip), %rcx # 0xe9a8
movb $0x0, %al
callq 0x21b0
jmp 0x6773
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /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.fd = fds[0];
ATF_REQUIRE(epoll_ctl(ep, EPOLL_CTL_ADD, fds[0], &event) == 0);
event.events = EPOLLOUT | EPOLLIN | rdhup_flag;
ATF_REQUIRE(epoll_ctl(ep, EPOLL_CTL_MOD, fds[0], &event) == 0);
ATF_REQUIRE(shutdown(fds[1], SHUT_WR) == 0);
for (;;) {
ATF_REQUIRE(epoll_wait(ep, &event, 1, -1) == 1);
fprintf(stderr, "got event: %x\n", (int)event.events);
if (event.events == EPOLLOUT) {
/* skip spurious event generated by EVFILT_WRITE */
/* TODO(jan): find a better solution */
continue;
}
if (event.events == (EPOLLOUT | EPOLLIN | rdhup_flag)) {
uint8_t buf;
ssize_t ret = read(fds[0], &buf, 1);
ATF_REQUIRE(ret == 0);
ATF_REQUIRE(shutdown(fds[0], SHUT_WR) == 0);
shutdown(fds[0], SHUT_RDWR);
} else if (event.events ==
(EPOLLOUT | EPOLLIN | rdhup_flag | EPOLLHUP)) {
/* close() may fail here! Don't check return code. */
close(fds[0]);
break;
#ifdef __NetBSD__
} else if (event.events == (EPOLLIN | rdhup_flag)) {
continue;
#endif
} else {
ATF_REQUIRE(false);
}
}
ATF_REQUIRE(epoll_wait(ep, &event, 1, 300) == 0);
ATF_REQUIRE(close(fds[1]) == 0);
ATF_REQUIRE(fds[2] == -1 || close(fds[2]) == 0);
ATF_REQUIRE(close(ep) == 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 0x7de4
leaq 0x6248(%rip), %rdi # 0xe012
leaq 0x6352(%rip), %rsi # 0xe123
movl $0x40d, %edx # imm = 0x40D
leaq 0x6b7f(%rip), %rcx # 0xe95c
movb $0x0, %al
callq 0x21b0
jmp 0x7de6
leaq -0x14(%rbp), %rdi
callq 0x5190
movb -0x1(%rbp), %dl
xorl %eax, %eax
movl $0x2000, %ecx # imm = 0x2000
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movb -0x1(%rbp), %dl
movl $0x2000, %eax # imm = 0x2000
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
orl $0x5, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x24(%rbp), %rcx
callq 0x21d0
cmpl $0x0, %eax
je 0x7e58
leaq 0x61d4(%rip), %rdi # 0xe012
leaq 0x62de(%rip), %rsi # 0xe123
movl $0x418, %edx # imm = 0x418
leaq 0x70d2(%rip), %rcx # 0xef23
movb $0x0, %al
callq 0x21b0
jmp 0x7e5a
movl -0x18(%rbp), %eax
orl $0x5, %eax
movl %eax, -0x24(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x3, %esi
leaq -0x24(%rbp), %rcx
callq 0x21d0
cmpl $0x0, %eax
je 0x7e9d
leaq 0x618f(%rip), %rdi # 0xe012
leaq 0x6299(%rip), %rsi # 0xe123
movl $0x41b, %edx # imm = 0x41B
leaq 0x7167(%rip), %rcx # 0xeffd
movb $0x0, %al
callq 0x21b0
jmp 0x7e9f
jmp 0x7ea1
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x2120
cmpl $0x0, %eax
je 0x7ed4
leaq 0x6158(%rip), %rdi # 0xe012
leaq 0x6262(%rip), %rsi # 0xe123
movl $0x41d, %edx # imm = 0x41D
leaq 0x7896(%rip), %rcx # 0xf763
movb $0x0, %al
callq 0x21b0
jmp 0x7ed6
jmp 0x7ed8
jmp 0x7eda
movl -0x8(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x1, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x2300
cmpl $0x1, %eax
je 0x7f16
leaq 0x6116(%rip), %rdi # 0xe012
leaq 0x6220(%rip), %rsi # 0xe123
movl $0x420, %edx # imm = 0x420
leaq 0x7873(%rip), %rcx # 0xf782
movb $0x0, %al
callq 0x21b0
jmp 0x7f18
movq 0xb0d9(%rip), %rax # 0x12ff8
movq (%rax), %rdi
movl -0x24(%rbp), %edx
leaq 0x7879(%rip), %rsi # 0xf7a5
movb $0x0, %al
callq 0x2230
cmpl $0x4, -0x24(%rbp)
jne 0x7f3b
jmp 0x7ed8
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
orl $0x5, %ecx
cmpl %ecx, %eax
jne 0x7fd1
movl -0x14(%rbp), %edi
leaq -0x25(%rbp), %rsi
movl $0x1, %edx
callq 0x21e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7f89
leaq 0x60a3(%rip), %rdi # 0xe012
leaq 0x61ad(%rip), %rsi # 0xe123
movl $0x42d, %edx # imm = 0x42D
leaq 0x7832(%rip), %rcx # 0xf7b4
movb $0x0, %al
callq 0x21b0
jmp 0x7f8b
jmp 0x7f8d
movl -0x14(%rbp), %edi
movl $0x1, %esi
callq 0x2120
cmpl $0x0, %eax
je 0x7fc0
leaq 0x606c(%rip), %rdi # 0xe012
leaq 0x6176(%rip), %rsi # 0xe123
movl $0x42f, %edx # imm = 0x42F
leaq 0x7804(%rip), %rcx # 0xf7bd
movb $0x0, %al
callq 0x21b0
jmp 0x7fc2
movl -0x14(%rbp), %edi
movl $0x2, %esi
callq 0x2120
jmp 0x800e
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
orl $0x5, %ecx
orl $0x10, %ecx
cmpl %ecx, %eax
jne 0x7feb
movl -0x14(%rbp), %edi
callq 0x21c0
jmp 0x8013
jmp 0x7fed
leaq 0x601e(%rip), %rdi # 0xe012
leaq 0x6128(%rip), %rsi # 0xe123
movl $0x43b, %edx # imm = 0x43B
leaq 0x77d5(%rip), %rcx # 0xf7dc
movb $0x0, %al
callq 0x21b0
jmp 0x7ed8
jmp 0x8015
movl -0x8(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x1, %edx
movl $0x12c, %ecx # imm = 0x12C
callq 0x2300
cmpl $0x0, %eax
je 0x8051
leaq 0x5fdb(%rip), %rdi # 0xe012
leaq 0x60e5(%rip), %rsi # 0xe123
movl $0x43f, %edx # imm = 0x43F
leaq 0x7798(%rip), %rcx # 0xf7e2
movb $0x0, %al
callq 0x21b0
jmp 0x8053
jmp 0x8055
movl -0x10(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x8083
leaq 0x5fa9(%rip), %rdi # 0xe012
leaq 0x60b3(%rip), %rsi # 0xe123
movl $0x441, %edx # imm = 0x441
leaq 0x6b1c(%rip), %rcx # 0xeb98
movb $0x0, %al
callq 0x21b0
jmp 0x8085
jmp 0x8087
cmpl $-0x1, -0xc(%rbp)
je 0x80bb
movl -0xc(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x80bb
leaq 0x5f71(%rip), %rdi # 0xe012
leaq 0x607b(%rip), %rsi # 0xe123
movl $0x442, %edx # imm = 0x442
leaq 0x6af7(%rip), %rcx # 0xebab
movb $0x0, %al
callq 0x21b0
jmp 0x80bd
jmp 0x80bf
movl -0x8(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x80ed
leaq 0x5f3f(%rip), %rdi # 0xe012
leaq 0x6049(%rip), %rsi # 0xe123
movl $0x443, %edx # imm = 0x443
leaq 0x68c2(%rip), %rcx # 0xe9a8
movb $0x0, %al
callq 0x21b0
jmp 0x80ef
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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;
event.data.fd = fds[1];
epoll_ctl(ep, EPOLL_CTL_ADD, fds[1], &event);
errno = 0;
for (;;) {
struct epoll_event event_result;
int n;
ATF_REQUIRE((n = epoll_wait(ep, &event_result, 1, -1)) == 1);
ATF_REQUIRE(event_result.data.fd == fds[1]);
// fprintf(stderr, "got event: %x %d\n",
// (int)event_result.events,
// (int)event_result.events);
if (event_result.events & EPOLLIN) {
ATF_REQUIRE((n = (int)read(fds[1], &c, 1)) == 1);
++counter;
if (counter <= 5) {
send(fds[0], &c, 1, MSG_NOSIGNAL);
} else if (counter == 6) {
send(fds[0], &c, 1, MSG_NOSIGNAL);
shutdown(fds[0], SHUT_WR);
usleep(100000);
} else {
uint8_t data[512] = { 0 };
send(fds[1], &data, sizeof(data), MSG_NOSIGNAL);
close(fds[0]);
event.events = EPOLLOUT;
event.data.fd = fds[1];
ATF_REQUIRE(epoll_ctl(ep, EPOLL_CTL_MOD, /**/
fds[1], &event) == 0);
usleep(100000);
}
} else if (event_result.events == EPOLLOUT) {
send(event.data.fd, &c, 1, MSG_NOSIGNAL);
// continue
} else if (fd_fun == fd_domain_socket &&
(event_result.events & (EPOLLOUT | EPOLLHUP)) ==
(EPOLLOUT | EPOLLHUP)) {
// TODO(jan): Linux sets EPOLLERR in addition
{
int error = 0;
socklen_t errlen = sizeof(error);
getsockopt(fds[1], SOL_SOCKET, SO_ERROR,
(void *)&error, &errlen);
fprintf(stderr, "socket error: %d (%s)\n",
error, strerror(error));
}
break;
} else if (fd_fun == fd_tcp_socket &&
event_result.events == (EPOLLOUT | EPOLLERR | EPOLLHUP)) {
{
int error = 0;
socklen_t errlen = sizeof(error);
getsockopt(fds[1], SOL_SOCKET, SO_ERROR,
(void *)&error, &errlen);
fprintf(stderr, "socket error: %d (%s)\n",
error, strerror(error));
}
break;
} else if (fd_fun == fd_tcp_socket &&
event_result.events == (EPOLLOUT | EPOLLHUP)) {
/*
* Rarely, we get here (no EPOLLERR). But don't fail
* the test. There is some non-determinism involved...
*/
fprintf(stderr, "no socket error\n");
break;
} else {
ATF_REQUIRE_MSG(false, "%p(%p/%p): events %x",
(void *)fd_fun, (void *)fd_domain_socket,
(void *)fd_tcp_socket, event_result.events);
}
}
ATF_REQUIRE(close(fds[1]) == 0);
ATF_REQUIRE(fds[2] == -1 || close(fds[2]) == 0);
ATF_REQUIRE(close(ep) == 0);
} | 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 = 0x601
leaq 0x46c0(%rip), %rcx # 0xe95c
movb $0x0, %al
callq 0x21b0
jmp 0xa2a5
movl -0xc(%rbp), %eax
movl %eax, 0x63d52(%rip) # 0x6e000
movq -0x8(%rbp), %rax
leaq -0x18(%rbp), %rdi
callq *%rax
movl $0xffffffff, 0x63d3e(%rip) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movb $0x2a, -0x1d(%rbp)
movl -0x18(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x20e0
movl $0x5, -0x29(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x25(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x1, %esi
leaq -0x29(%rbp), %rcx
callq 0x21d0
callq 0x2080
movl $0x0, (%rax)
jmp 0xa30c
movl -0xc(%rbp), %edi
leaq -0x35(%rbp), %rsi
movl $0x1, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x2300
movl %eax, -0x3c(%rbp)
cmpl $0x1, %eax
je 0xa34b
leaq 0x3ce1(%rip), %rdi # 0xe012
leaq 0x3deb(%rip), %rsi # 0xe123
movl $0x618, %edx # imm = 0x618
leaq 0x58c0(%rip), %rcx # 0xfc04
movb $0x0, %al
callq 0x21b0
jmp 0xa34d
jmp 0xa34f
movl -0x31(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xa378
leaq 0x3cb4(%rip), %rdi # 0xe012
leaq 0x3dbe(%rip), %rsi # 0xe123
movl $0x61a, %edx # imm = 0x61A
leaq 0x4e3d(%rip), %rcx # 0xf1ae
movb $0x0, %al
callq 0x21b0
jmp 0xa37a
movl -0x35(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa4b7
jmp 0xa38b
movl -0x14(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x21e0
movl %eax, -0x3c(%rbp)
cmpl $0x1, %eax
je 0xa3c5
leaq 0x3c67(%rip), %rdi # 0xe012
leaq 0x3d71(%rip), %rsi # 0xe123
movl $0x621, %edx # imm = 0x621
leaq 0x5876(%rip), %rcx # 0xfc34
movb $0x0, %al
callq 0x21b0
jmp 0xa3c7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jg 0xa3f1
movl -0x18(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
movl $0x4000, %ecx # imm = 0x4000
callq 0x2150
jmp 0xa4b2
cmpl $0x6, -0x1c(%rbp)
jne 0xa429
movl -0x18(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
movl $0x4000, %ecx # imm = 0x4000
callq 0x2150
movl -0x18(%rbp), %edi
movl $0x1, %esi
callq 0x2120
movl $0x186a0, %edi # imm = 0x186A0
callq 0x2410
jmp 0xa4b0
leaq -0x240(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx # imm = 0x200
callq 0x2190
movl -0x14(%rbp), %edi
leaq -0x240(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
movl $0x4000, %ecx # imm = 0x4000
callq 0x2150
movl -0x18(%rbp), %edi
callq 0x21c0
movl $0x4, -0x29(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x25(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x3, %esi
leaq -0x29(%rbp), %rcx
callq 0x21d0
cmpl $0x0, %eax
je 0xa4a4
leaq 0x3b88(%rip), %rdi # 0xe012
leaq 0x3c92(%rip), %rsi # 0xe123
movl $0x635, %edx # imm = 0x635
leaq 0x57bb(%rip), %rcx # 0xfc58
movb $0x0, %al
callq 0x21b0
jmp 0xa4a6
movl $0x186a0, %edi # imm = 0x186A0
callq 0x2410
jmp 0xa4b2
jmp 0xa669
cmpl $0x4, -0x35(%rbp)
jne 0xa4d8
movl -0x25(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
movl $0x4000, %ecx # imm = 0x4000
callq 0x2150
jmp 0xa667
leaq -0x53af(%rip), %rax # 0x5130
cmpq %rax, -0x8(%rbp)
jne 0xa573
movl -0x35(%rbp), %eax
andl $0x14, %eax
cmpl $0x14, %eax
jne 0xa573
movl $0x0, -0x244(%rbp)
movl $0x4, -0x248(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x244(%rbp), %rcx
leaq -0x248(%rbp), %r8
callq 0x21f0
movq 0x8ac9(%rip), %rax # 0x12ff8
movq (%rax), %rax
movq %rax, -0x260(%rbp)
movl -0x244(%rbp), %eax
movl %eax, -0x254(%rbp)
movl -0x244(%rbp), %edi
callq 0x23d0
movq -0x260(%rbp), %rdi
movl -0x254(%rbp), %edx
movq %rax, %rcx
leaq 0x5723(%rip), %rsi # 0xfc8a
movb $0x0, %al
callq 0x2230
jmp 0xa66e
leaq -0x53ea(%rip), %rax # 0x5190
cmpq %rax, -0x8(%rbp)
jne 0xa606
cmpl $0x1c, -0x35(%rbp)
jne 0xa606
movl $0x0, -0x24c(%rbp)
movl $0x4, -0x250(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x24c(%rbp), %rcx
leaq -0x250(%rbp), %r8
callq 0x21f0
movq 0x8a33(%rip), %rax # 0x12ff8
movq (%rax), %rax
movq %rax, -0x270(%rbp)
movl -0x24c(%rbp), %eax
movl %eax, -0x264(%rbp)
movl -0x24c(%rbp), %edi
callq 0x23d0
movq -0x270(%rbp), %rdi
movl -0x264(%rbp), %edx
movq %rax, %rcx
leaq 0x568d(%rip), %rsi # 0xfc8a
movb $0x0, %al
callq 0x2230
jmp 0xa66e
leaq -0x547d(%rip), %rax # 0x5190
cmpq %rax, -0x8(%rbp)
jne 0xa633
cmpl $0x14, -0x35(%rbp)
jne 0xa633
movq 0x89d8(%rip), %rax # 0x12ff8
movq (%rax), %rdi
leaq 0x5677(%rip), %rsi # 0xfca1
movb $0x0, %al
callq 0x2230
jmp 0xa66e
jmp 0xa635
movq -0x8(%rbp), %rcx
movl -0x35(%rbp), %eax
leaq 0x566f(%rip), %rdi # 0xfcb2
leaq 0x3ad9(%rip), %rsi # 0xe123
movl $0x660, %edx # imm = 0x660
leaq -0x5526(%rip), %r8 # 0x5130
leaq -0x54cd(%rip), %r9 # 0x5190
movl %eax, (%rsp)
movb $0x0, %al
callq 0x21b0
jmp 0xa669
jmp 0xa30a
jmp 0xa670
movl -0x14(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0xa69e
leaq 0x398e(%rip), %rdi # 0xe012
leaq 0x3a98(%rip), %rsi # 0xe123
movl $0x664, %edx # imm = 0x664
leaq 0x4501(%rip), %rcx # 0xeb98
movb $0x0, %al
callq 0x21b0
jmp 0xa6a0
jmp 0xa6a2
cmpl $-0x1, -0x10(%rbp)
je 0xa6d6
movl -0x10(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0xa6d6
leaq 0x3956(%rip), %rdi # 0xe012
leaq 0x3a60(%rip), %rsi # 0xe123
movl $0x665, %edx # imm = 0x665
leaq 0x44dc(%rip), %rcx # 0xebab
movb $0x0, %al
callq 0x21b0
jmp 0xa6d8
jmp 0xa6da
movl -0xc(%rbp), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0xa708
leaq 0x3924(%rip), %rdi # 0xe012
leaq 0x3a2e(%rip), %rsi # 0xe123
movl $0x666, %edx # imm = 0x666
leaq 0x42a7(%rip), %rcx # 0xe9a8
movb $0x0, %al
callq 0x21b0
jmp 0xa70a
addq $0x280, %rsp # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /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 )
return( curve_info );
}
return( NULL );
} | 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( strcmp( curve_info->name, name ) == 0 )
return( curve_info );
}
return( NULL );
} | 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;
size_t plen;
ECP_VALIDATE_RET( grp != NULL );
ECP_VALIDATE_RET( P != NULL );
ECP_VALIDATE_RET( olen != NULL );
ECP_VALIDATE_RET( buf != NULL );
ECP_VALIDATE_RET( format == MBEDTLS_ECP_PF_UNCOMPRESSED ||
format == MBEDTLS_ECP_PF_COMPRESSED );
plen = mbedtls_mpi_size( &grp->P );
#if defined(ECP_MONTGOMERY)
if( mbedtls_ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
{
*olen = plen;
if( buflen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary_le( &P->X, buf, plen ) );
}
#endif
#if defined(ECP_SHORTWEIERSTRASS)
if( mbedtls_ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
{
/*
* Common case: P == 0
*/
if( mbedtls_mpi_cmp_int( &P->Z, 0 ) == 0 )
{
if( buflen < 1 )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x00;
*olen = 1;
return( 0 );
}
if( format == MBEDTLS_ECP_PF_UNCOMPRESSED )
{
*olen = 2 * plen + 1;
if( buflen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x04;
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->Y, buf + 1 + plen, plen ) );
}
else if( format == MBEDTLS_ECP_PF_COMPRESSED )
{
*olen = plen + 1;
if( buflen < *olen )
return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
buf[0] = 0x02 + mbedtls_mpi_get_bit( &P->Y, 0 );
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( &P->X, buf + 1, plen ) );
}
}
#endif
cleanup:
return( ret );
} | 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 $0x0, 0x78(%r14)
je 0xeeff
cmpq $0x0, 0x60(%r14)
je 0xef92
cmpq $0x0, 0x78(%r14)
je 0xef92
movq 0x10(%rsp), %rax
leaq 0x30(%rax), %rdi
xorl %esi, %esi
callq 0xb0bb
testl %eax, %eax
je 0xef2b
cmpl $0x1, %ebx
je 0xef44
testl %ebx, %ebx
jne 0xef92
leaq (%r15,%r15), %rax
leaq 0x1(,%r15,2), %rcx
movq %rcx, (%r13)
movl $0xffffb100, %ebp # imm = 0xFFFFB100
cmpq %r12, %rax
jae 0xef92
movq 0x8(%rsp), %rbx
movb $0x4, (%rbx)
incq %rbx
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xac52
testl %eax, %eax
jne 0xef27
addq $0x18, %r14
addq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rsi
jmp 0xef77
movq %r15, (%r13)
movl $0xffffb100, %ebp # imm = 0xFFFFB100
cmpq %r12, %r15
ja 0xef92
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0xabb1
testl %eax, %eax
je 0xefa3
movl %eax, %ebp
jmp 0xef92
testq %r12, %r12
je 0xef8d
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq $0x1, (%r13)
xorl %ebp, %ebp
jmp 0xef92
movq %r15, %rax
incq %rax
movq %rax, (%r13)
movl $0xffffb100, %ebp # imm = 0xFFFFB100
cmpq %r12, %rax
ja 0xef92
movq 0x10(%rsp), %rbx
leaq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xa03f
addb $0x2, %al
movq 0x8(%rsp), %rsi
movb %al, (%rsi)
incq %rsi
movq %rbx, %rdi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xac52
movl $0xffffb100, %ebp # imm = 0xFFFFB100
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xee71
| /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 != NULL );
ECP_VALIDATE_RET( buf != NULL );
ECP_VALIDATE_RET( *buf != NULL );
/*
* We must have at least two bytes (1 for length, at least one for data)
*/
if( buf_len < 2 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
data_len = *(*buf)++;
if( data_len < 1 || data_len > buf_len - 1 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
/*
* Save buffer start for read_binary and update buf
*/
buf_start = *buf;
*buf += data_len;
return( mbedtls_ecp_point_read_binary( grp, pt, buf_start, data_len ) );
} | 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_INVALID_KEY );
#if defined(ECP_MONTGOMERY)
if( mbedtls_ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_MONTGOMERY )
return( ecp_check_pubkey_mx( grp, pt ) );
#endif
#if defined(ECP_SHORTWEIERSTRASS)
if( mbedtls_ecp_get_type( grp ) == MBEDTLS_ECP_TYPE_SHORT_WEIERSTRASS )
return( ecp_check_pubkey_sw( grp, pt ) );
#endif
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
} | 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 %r15
popq %rbp
retq
movq 0x60(%rbx), %rax
movl $0xffffb080, %ebp # imm = 0xFFFFB080
testq %rax, %rax
je 0x1014f
cmpq $0x0, 0x78(%rbx)
je 0x102bc
testq %rax, %rax
je 0x1014f
cmpq $0x0, 0x78(%rbx)
je 0x1014f
movq %r14, %rdi
xorl %esi, %esi
callq 0xb0bb
movl $0xffffb380, %ebp # imm = 0xFFFFB380
testl %eax, %eax
js 0x1014f
leaq 0x18(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xb0bb
testl %eax, %eax
js 0x1014f
leaq 0x8(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xaf5c
testl %eax, %eax
jns 0x1014f
movq %r12, %rdi
movq %r15, %rsi
callq 0xaf5c
testl %eax, %eax
jns 0x1014f
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x9c60
leaq 0x8(%rsp), %rdi
callq 0x9c60
movq %r13, %rdi
movq %r12, %rsi
movq %r12, %rdx
callq 0xb3fd
testl %eax, %eax
jne 0x1020a
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x11605
testl %eax, %eax
je 0x102e5
movl %eax, %ebp
testl %ebp, %ebp
jne 0x10319
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0xb3fd
testl %eax, %eax
jne 0x1023d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x11605
testl %eax, %eax
je 0x102f3
movl %eax, %ebp
testl %ebp, %ebp
jne 0x10319
cmpq $0x0, 0x30(%rbx)
je 0x10301
leaq 0x20(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x116e6
testl %eax, %eax
jne 0x10317
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
callq 0x115c9
testl %eax, %eax
jne 0x10317
leaq 0x38(%rbx), %rcx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x116e6
testl %eax, %eax
jne 0x10317
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaf5c
testl %eax, %eax
movl $0xffffb380, %ebp # imm = 0xFFFFB380
cmovel %eax, %ebp
jmp 0x10319
movq %r14, %rdi
callq 0xa187
movq 0xb8(%rbx), %rcx
addq $0x7, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
cmpq %rcx, %rax
movl $0xffffb380, %ebp # imm = 0xFFFFB380
cmovbel %edx, %ebp
jmp 0x1014f
incq 0x2fee4(%rip) # 0x401d0
xorl %ebp, %ebp
jmp 0x1020c
incq 0x2fed6(%rip) # 0x401d0
xorl %ebp, %ebp
jmp 0x1023f
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
movq %rdi, %rsi
callq 0xa4fb
testl %eax, %eax
je 0x10332
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x9c6e
leaq 0x8(%rsp), %rdi
callq 0x9c6e
jmp 0x1014f
leaq 0x8(%rsp), %r12
cmpl $0x0, 0x8(%rsp)
jns 0x1026e
movq %r12, %rdi
xorl %esi, %esi
callq 0xb0bb
testl %eax, %eax
je 0x1026e
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xb321
movl %eax, %ebp
testl %eax, %eax
je 0x10337
jmp 0x10319
| /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[] =
{
"000000000000000000000000000000000000000000000001", /* one */
"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22830", /* N - 1 */
"5EA6F389A38B8BC81E767753B15AA5569E1782E30ABE7D25", /* random */
"400000000000000000000000000000000000000000000000", /* one and zeros */
"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", /* all ones */
"555555555555555555555555555555555555555555555555", /* 101010... */
};
mbedtls_ecp_group_init( &grp );
mbedtls_ecp_point_init( &R );
mbedtls_ecp_point_init( &P );
mbedtls_mpi_init( &m );
/* Use secp192r1 if available, or any available curve */
#if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &grp, MBEDTLS_ECP_DP_SECP192R1 ) );
#else
MBEDTLS_MPI_CHK( mbedtls_ecp_group_load( &grp, mbedtls_ecp_curve_list()->grp_id ) );
#endif
if( verbose != 0 )
mbedtls_printf( " ECP test #1 (constant op_count, base point G): " );
/* Do a dummy multiplication first to trigger precomputation */
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &m, 2 ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &P, &m, &grp.G, NULL, NULL ) );
add_count = 0;
dbl_count = 0;
mul_count = 0;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ )
{
add_c_prev = add_count;
dbl_c_prev = dbl_count;
mul_c_prev = mul_count;
add_count = 0;
dbl_count = 0;
mul_count = 0;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &grp.G, NULL, NULL ) );
if( add_count != add_c_prev ||
dbl_count != dbl_c_prev ||
mul_count != mul_c_prev )
{
if( verbose != 0 )
mbedtls_printf( "failed (%u)\n", (unsigned int) i );
ret = 1;
goto cleanup;
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
if( verbose != 0 )
mbedtls_printf( " ECP test #2 (constant op_count, other point): " );
/* We computed P = 2G last time, use it */
add_count = 0;
dbl_count = 0;
mul_count = 0;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[0] ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
for( i = 1; i < sizeof( exponents ) / sizeof( exponents[0] ); i++ )
{
add_c_prev = add_count;
dbl_c_prev = dbl_count;
mul_c_prev = mul_count;
add_count = 0;
dbl_count = 0;
mul_count = 0;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &m, 16, exponents[i] ) );
MBEDTLS_MPI_CHK( mbedtls_ecp_mul( &grp, &R, &m, &P, NULL, NULL ) );
if( add_count != add_c_prev ||
dbl_count != dbl_c_prev ||
mul_count != mul_c_prev )
{
if( verbose != 0 )
mbedtls_printf( "failed (%u)\n", (unsigned int) i );
ret = 1;
goto cleanup;
}
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
cleanup:
if( ret < 0 && verbose != 0 )
mbedtls_printf( "Unexpected error, return code = %08X\n", ret );
mbedtls_ecp_group_free( &grp );
mbedtls_ecp_point_free( &R );
mbedtls_ecp_point_free( &P );
mbedtls_mpi_free( &m );
if( verbose != 0 )
mbedtls_printf( "\n" );
return( ret );
} | 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 0x78(%rsp), %rdi
callq 0x9c60
leaq 0x90(%rsp), %r13
movq %r13, %rdi
callq 0x9c60
leaq 0xa8(%rsp), %rdi
callq 0x9c60
leaq 0x18(%rsp), %rdi
callq 0x9c60
movq %r14, %rdi
movl $0x1, %esi
callq 0x12324
testl %eax, %eax
jne 0x11103
testl %ebx, %ebx
je 0x11067
leaq 0x1dd66(%rip), %rdi # 0x2edc6
xorl %eax, %eax
callq 0x90c0
leaq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x9ff0
testl %eax, %eax
jne 0x11103
leaq 0x110(%rsp), %r14
leaq 0xc0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf239
testl %eax, %eax
jne 0x11103
xorl %eax, %eax
movq %rax, 0x2f10d(%rip) # 0x401c0
movq %rax, 0x2f10e(%rip) # 0x401c8
movq %rax, 0x2f10f(%rip) # 0x401d0
leaq 0x1dbd8(%rip), %rdx # 0x2eca0
leaq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0xa197
testl %eax, %eax
jne 0x11103
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf239
testl %eax, %eax
je 0x1118f
movl %eax, %ebp
testl %ebx, %ebx
je 0x1111d
testl %ebp, %ebp
jns 0x1111d
leaq 0x1d74c(%rip), %rdi # 0x2e860
movl %ebp, %esi
xorl %eax, %eax
callq 0x90c0
leaq 0xc0(%rsp), %rdi
callq 0xec0b
leaq 0x30(%rsp), %rdi
callq 0x9c6e
movq %r15, %rdi
callq 0x9c6e
movq %r12, %rdi
callq 0x9c6e
leaq 0x78(%rsp), %rdi
callq 0x9c6e
movq %r13, %rdi
callq 0x9c6e
leaq 0xa8(%rsp), %rdi
callq 0x9c6e
leaq 0x18(%rsp), %rdi
callq 0x9c6e
testl %ebx, %ebx
je 0x1117b
movl $0xa, %edi
callq 0x9040
movl %ebp, %eax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r14d
leaq 0x18(%rsp), %r15
movq 0x2f01f(%rip), %r13 # 0x401c0
movq 0x2f020(%rip), %rax # 0x401c8
movq %rax, 0x10(%rsp)
movq 0x2f01c(%rip), %rax # 0x401d0
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x2effe(%rip) # 0x401c0
movq %rax, 0x2efff(%rip) # 0x401c8
movq %rax, 0x2f000(%rip) # 0x401d0
leaq 0x2dbd9(%rip), %rax # 0x3edb0
movq (%rax,%r14,8), %rdx
movq %r15, %rdi
movl $0x10, %esi
callq 0xa197
testl %eax, %eax
jne 0x113c3
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %r12
movq %r15, %rdx
leaq 0x110(%rsp), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf239
testl %eax, %eax
jne 0x113c3
cmpq %r13, 0x2ef9b(%rip) # 0x401c0
jne 0x113dc
movq 0x10(%rsp), %rax
cmpq %rax, 0x2ef91(%rip) # 0x401c8
jne 0x113dc
movq 0x8(%rsp), %rax
cmpq %rax, 0x2ef87(%rip) # 0x401d0
jne 0x113dc
incq %r14
cmpq $0x6, %r14
movq %r12, %r15
jne 0x1119a
testl %ebx, %ebx
je 0x1127d
leaq 0x1d61c(%rip), %rdi # 0x2e886
callq 0x9060
leaq 0x1db8f(%rip), %rdi # 0x2ee05
xorl %eax, %eax
callq 0x90c0
xorl %eax, %eax
movq %rax, 0x2ef3a(%rip) # 0x401c0
movq %rax, 0x2ef3b(%rip) # 0x401c8
movq %rax, 0x2ef3c(%rip) # 0x401d0
leaq 0x1da05(%rip), %rdx # 0x2eca0
leaq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0xa197
testl %eax, %eax
leaq 0x48(%rsp), %r15
leaq 0x60(%rsp), %r12
leaq 0x90(%rsp), %r13
jne 0x11103
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x78(%rsp), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf239
testl %eax, %eax
jne 0x11103
movl $0x1, %r14d
leaq 0x18(%rsp), %r15
movq 0x2eec0(%rip), %r13 # 0x401c0
movq 0x2eec1(%rip), %rax # 0x401c8
movq %rax, 0x10(%rsp)
movq 0x2eebd(%rip), %rax # 0x401d0
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x2ee9f(%rip) # 0x401c0
movq %rax, 0x2eea0(%rip) # 0x401c8
movq %rax, 0x2eea1(%rip) # 0x401d0
leaq 0x2da7a(%rip), %rax # 0x3edb0
movq (%rax,%r14,8), %rdx
movq %r15, %rdi
movl $0x10, %esi
callq 0xa197
testl %eax, %eax
jne 0x113c3
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %r12
movq %r15, %rdx
leaq 0x78(%rsp), %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xf239
testl %eax, %eax
jne 0x113c3
cmpq %r13, 0x2ee47(%rip) # 0x401c0
jne 0x11411
movq 0x10(%rsp), %rax
cmpq %rax, 0x2ee3d(%rip) # 0x401c8
jne 0x11411
movq 0x8(%rsp), %rax
cmpq %rax, 0x2ee33(%rip) # 0x401d0
jne 0x11411
incq %r14
cmpq $0x6, %r14
movq %r12, %r15
jne 0x112f9
xorl %ebp, %ebp
testl %ebx, %ebx
je 0x113c5
leaq 0x1d4ca(%rip), %rdi # 0x2e886
callq 0x9060
jmp 0x113c5
movl %eax, %ebp
leaq 0x48(%rsp), %r15
leaq 0x60(%rsp), %r12
leaq 0x90(%rsp), %r13
jmp 0x11105
movl $0x1, %ebp
testl %ebx, %ebx
leaq 0x48(%rsp), %r15
leaq 0x60(%rsp), %r12
leaq 0x90(%rsp), %r13
je 0x11105
leaq 0x1d9f6(%rip), %rdi # 0x2edf8
movl %r14d, %esi
xorl %eax, %eax
callq 0x90c0
jmp 0x11105
movl $0x1, %ebp
testl %ebx, %ebx
je 0x113c5
leaq 0x1d9d7(%rip), %rdi # 0x2edf8
movl %r14d, %esi
xorl %eax, %eax
callq 0x90c0
jmp 0x113c5
| /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 + A7 + A11
SUB( 11 ); ADD( 8 ); ADD( 12 ); NEXT; // A4 += -A11 + A8 + A12
SUB( 12 ); ADD( 9 ); ADD( 13 ); NEXT; // A5 += -A12 + A9 + A13
SUB( 13 ); ADD( 10 ); LAST; // A6 += -A13 + A10
cleanup:
return( ret );
} | 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 0x12da6
movq 0x10(%rbx), %rax
movq (%rax), %r8
movq 0x18(%rax), %r10
movq %r10, 0x8(%rsp)
shrq $0x20, %r10
xorl %r9d, %r9d
movl %r8d, %r11d
subl %r10d, %r11d
movl $0x0, %r15d
sbbl %r15d, %r15d
movq 0x28(%rax), %rdx
movq %rdx, %rdi
shrq $0x20, %rdi
xorl %esi, %esi
subl %edi, %r11d
setb %sil
subl %esi, %r15d
movq %r8, %rcx
shrq $0x20, %rcx
movl %r11d, (%rax)
cmpl %r10d, %r8d
movq %rdx, 0x10(%rsp)
jb 0x12b8b
testb %sil, %sil
jne 0x12b8b
addl %ecx, %r15d
setb %r9b
jmp 0x12b98
movl %r15d, %esi
negl %esi
cmpl %esi, %ecx
sbbl %r9d, %r9d
addl %ecx, %r15d
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq 0x8(%rax), %r12
movq 0x20(%rax), %r14
subl %r14d, %r15d
setb %sil
movq 0x30(%rax), %r8
subl %r8d, %r15d
sbbb %sil, %r9b
shlq $0x20, %r15
orq %r11, %r15
movq %r15, (%rax)
movsbl %r9b, %r15d
testb %r15b, %r15b
js 0x12bd7
addl %r12d, %r15d
setb %r13b
jmp 0x12be8
movl %r15d, %esi
negl %esi
xorl %r13d, %r13d
cmpl %esi, %r12d
sbbl %r13d, %r13d
addl %r12d, %r15d
movq %r14, %r11
shrq $0x20, %r11
subl %r11d, %r15d
setb %sil
movq %r8, %r9
shrq $0x20, %r9
subl %r9d, %r15d
sbbb %sil, %r13b
movq %r12, %rsi
andq %rcx, %rsi
orq %r15, %rsi
movq %rsi, 0x8(%rax)
shrq $0x20, %r12
movsbl %r13b, %r13d
testb %r13b, %r13b
js 0x12c26
addl %r12d, %r13d
setb %sil
jmp 0x12c35
movl %r13d, %edx
negl %edx
xorl %esi, %esi
cmpl %edx, %r12d
sbbl %esi, %esi
addl %r12d, %r13d
movq 0x10(%rsp), %r12
subl %r12d, %r13d
sbbb $0x0, %sil
addl %r10d, %r13d
setb %dl
addl %edi, %r13d
adcb %sil, %dl
shlq $0x20, %r13
orq %r15, %r13
movq %r13, 0x8(%rax)
movq 0x10(%rax), %r15
movsbl %dl, %r10d
testb %r10b, %r10b
js 0x12c6e
addl %r15d, %r10d
setb %sil
jmp 0x12c7d
movl %r10d, %edx
negl %edx
xorl %esi, %esi
cmpl %edx, %r15d
sbbl %esi, %esi
addl %r15d, %r10d
subl %edi, %r10d
sbbb $0x0, %sil
addl %r14d, %r10d
setb %dl
addl %r8d, %r10d
adcb %sil, %dl
movq %r15, %rsi
andq %rcx, %rsi
orq %r10, %rsi
movq %rsi, 0x10(%rax)
shrq $0x20, %r15
movsbl %dl, %edi
testb %dil, %dil
js 0x12cb2
addl %r15d, %edi
setb %sil
jmp 0x12cc0
movl %edi, %edx
negl %edx
xorl %esi, %esi
cmpl %edx, %r15d
sbbl %esi, %esi
addl %r15d, %edi
subl %r8d, %edi
sbbb $0x0, %sil
addl %r11d, %edi
setb %dl
addl %r9d, %edi
adcb %sil, %dl
shlq $0x20, %rdi
orq %r10, %rdi
movq %rdi, 0x10(%rax)
movsbl %dl, %edi
testb %dil, %dil
js 0x12cf0
addl 0x8(%rsp), %edi
setb %r8b
jmp 0x12d03
movl %edi, %edx
negl %edx
xorl %r8d, %r8d
movq 0x8(%rsp), %rsi
cmpl %edx, %esi
sbbl %r8d, %r8d
addl %esi, %edi
xorl %edx, %edx
subl %r9d, %edi
movl $0x0, %esi
sbbl %esi, %esi
addl %r12d, %edi
adcb %r8b, %sil
movzbl %sil, %r8d
testb %r8b, %r8b
cmovgl %r8d, %edx
movzbl %dl, %edx
shlq $0x20, %rdx
orq %rdi, %rdx
movq %rdx, 0x18(%rax)
movq 0x8(%rbx), %rdx
addq %rdx, %rdx
cmpq $0x9, %rdx
jb 0x12d72
movl $0x7, %edi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
leaq 0x1(%rdi), %r8
movq %r8, %r9
andq $-0x2, %r9
testb $0x1, %dil
movq %rcx, %r10
cmoveq %rdx, %r10
andq %r10, (%rax,%r9,4)
movq 0x8(%rbx), %r9
addq %r9, %r9
addq $0x2, %rdi
cmpq %r9, %rdi
movq %r8, %rdi
jb 0x12d45
testb %sil, %sil
jns 0x12da6
movsbq %sil, %rax
imulq %rcx, %rax
leaq 0x18(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdx
movq %rax, -0x8(%rdx,%rcx,8)
movq %rbx, %rdi
movq %rbx, %rdx
callq 0xb1fa
testl %eax, %eax
jne 0x12da6
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 > P448_WIDTH )
/* Shouldn't be called with N larger than 2^896! */
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
M.p = Mp;
memset( Mp, 0, sizeof( Mp ) );
memcpy( Mp, N->p + P448_WIDTH, M.n * sizeof( mbedtls_mpi_uint ) );
/* N = A0 */
for( i = P448_WIDTH; i < N->n; i++ )
N->p[i] = 0;
/* N += A1 */
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( N, N, &M ) );
/* Q = B1, N += B1 */
Q = M;
Q.p = Qp;
memcpy( Qp, Mp, sizeof( Qp ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Q, 224 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( N, N, &Q ) );
/* M = (B0 + B1) * 2^224, N += M */
if( sizeof( mbedtls_mpi_uint ) > 4 )
Mp[P224_WIDTH_MIN] &= ( (mbedtls_mpi_uint)-1 ) >> ( P224_UNUSED_BITS );
for( i = P224_WIDTH_MAX; i < M.n; ++i )
Mp[i] = 0;
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &M, &M, &Q ) );
M.n = P448_WIDTH + 1; /* Make room for shifted carry bit from the addition */
MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &M, 224 ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( N, N, &M ) );
cleanup:
return( ret );
} | 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
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x30(%rdi)
movq 0x10(%rbx), %r14
leaq 0x38(%r14), %rsi
shlq $0x3, %rdx
callq 0x9180
cmpq $0x8, 0x8(%rbx)
jb 0x13911
movl $0x7, %eax
movq $0x0, (%r14,%rax,8)
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x13900
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xb321
testl %eax, %eax
jne 0x139ef
movups 0x8(%rsp), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0x80(%rsp), %rax
movq %rax, 0x10(%rdi)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movaps %xmm0, (%rax)
movaps %xmm1, 0x10(%rax)
movaps %xmm2, 0x20(%rax)
movq 0x70(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl $0xe0, %esi
callq 0xade1
testl %eax, %eax
jne 0x139ef
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xb321
testl %eax, %eax
jne 0x139ef
movl $0x0, 0x5c(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x5, %rax
jb 0x139ae
leaq 0x60(%rsp), %rdi
leaq -0x20(,%rax,8), %rdx
xorl %esi, %esi
callq 0x9100
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rdi, %rsi
callq 0xb321
testl %eax, %eax
jne 0x139ef
leaq 0x8(%rsp), %rdi
movq $0x8, 0x8(%rdi)
movl $0xe0, %esi
callq 0xacf7
testl %eax, %eax
jne 0x139ef
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xb321
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
| /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 = mbedtls_entropy_func( ctx, buf, MBEDTLS_ENTROPY_BLOCK_SIZE ) ) != 0 )
goto exit;
if( fwrite( buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f ) != MBEDTLS_ENTROPY_BLOCK_SIZE )
{
ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
goto exit;
}
ret = 0;
exit:
mbedtls_platform_zeroize( buf, sizeof( buf ) );
fclose( f );
return( ret );
} | 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
movl $0x1, %esi
movl $0x40, %edx
movq %rbx, %rcx
callq 0x91f0
xorl %ecx, %ecx
cmpq $0x40, %rax
movl $0xffffffc1, %ebp # imm = 0xFFFFFFC1
cmovel %ecx, %ebp
movq %rsp, %rdi
movl $0x40, %esi
callq 0x15804
movq %rbx, %rdi
callq 0x9090
jmp 0x14098
movl $0xffffffc1, %ebp # imm = 0xFFFFFFC1
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /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 );
case MBEDTLS_PK_ECKEY_DH:
return( &mbedtls_eckeydh_info );
#endif
#if defined(MBEDTLS_ECDSA_C)
case MBEDTLS_PK_ECDSA:
return( &mbedtls_ecdsa_info );
#endif
/* MBEDTLS_PK_RSA_ALT omitted on purpose */
default:
return( NULL );
}
} | 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( &ctx->E );
mbedtls_mpi_free( &ctx->N );
#if !defined(MBEDTLS_RSA_NO_CRT)
mbedtls_mpi_free( &ctx->RQ );
mbedtls_mpi_free( &ctx->RP );
mbedtls_mpi_free( &ctx->QP );
mbedtls_mpi_free( &ctx->DQ );
mbedtls_mpi_free( &ctx->DP );
#endif /* MBEDTLS_RSA_NO_CRT */
#if defined(MBEDTLS_THREADING_C)
mbedtls_mutex_free( &ctx->mutex );
#endif
} | 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 0x9c6e
leaq 0x10(%rbx), %rdi
callq 0x9c6e
leaq 0x100(%rbx), %rdi
callq 0x9c6e
leaq 0xe8(%rbx), %rdi
callq 0x9c6e
leaq 0xb8(%rbx), %rdi
callq 0x9c6e
leaq 0xa0(%rbx), %rdi
callq 0x9c6e
addq $0x88, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x9c6e
retq
| /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,
size_t ilen,
const unsigned char *input,
unsigned char *output )
{
size_t olen;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
unsigned char *p = output;
unsigned int hlen;
const mbedtls_md_info_t *md_info;
mbedtls_md_context_t md_ctx;
RSA_VALIDATE_RET( ctx != NULL );
RSA_VALIDATE_RET( mode == MBEDTLS_RSA_PRIVATE ||
mode == MBEDTLS_RSA_PUBLIC );
RSA_VALIDATE_RET( output != NULL );
RSA_VALIDATE_RET( ilen == 0 || input != NULL );
RSA_VALIDATE_RET( label_len == 0 || label != NULL );
if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
if( f_rng == NULL )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
olen = ctx->len;
hlen = mbedtls_md_get_size( md_info );
/* first comparison checks for overflow */
if( ilen + 2 * hlen + 2 < ilen || olen < ilen + 2 * hlen + 2 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
memset( output, 0, olen );
*p++ = 0;
/* Generate a random octet string seed */
if( ( ret = f_rng( p_rng, p, hlen ) ) != 0 )
return( MBEDTLS_ERR_RSA_RNG_FAILED + ret );
p += hlen;
/* Construct DB */
if( ( ret = mbedtls_md( md_info, label, label_len, p ) ) != 0 )
return( ret );
p += hlen;
p += olen - 2 * hlen - 2 - ilen;
*p++ = 1;
if( ilen != 0 )
memcpy( p, input, ilen );
mbedtls_md_init( &md_ctx );
if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
goto exit;
/* maskedDB: Apply dbMask to DB */
if( ( ret = mgf_mask( output + hlen + 1, olen - hlen - 1, output + 1, hlen,
&md_ctx ) ) != 0 )
goto exit;
/* maskedSeed: Apply seedMask to seed */
if( ( ret = mgf_mask( output + 1, hlen, output + hlen + 1, olen - hlen - 1,
&md_ctx ) ) != 0 )
goto exit;
exit:
mbedtls_md_free( &md_ctx );
if( ret != 0 )
return( ret );
return( ( mode == MBEDTLS_RSA_PUBLIC )
? mbedtls_rsa_public( ctx, output, output )
: mbedtls_rsa_private( ctx, f_rng, p_rng, output, output ) );
} | 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)
je 0x16cbe
jmp 0x16d4e
movq %r8, 0x8(%rsp)
movq %r9, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
movq %rdx, %r12
testq %r13, %r13
je 0x16d49
movl 0x14c(%r14), %edi
callq 0x26a4c
movl $0xffffbf80, %ebx # imm = 0xFFFFBF80
testq %rax, %rax
je 0x16d4e
movq 0x80(%rsp), %r15
movq 0x8(%r14), %rbp
movq %rax, %rdi
movq %rax, 0x18(%rsp)
callq 0x272a4
movq %rbp, %rdx
movzbl %al, %ebp
leaq (%r15,%rbp,2), %rax
addq $0x2, %rax
cmpq %r15, %rax
setb %cl
cmpq %rax, %rdx
setb %al
orb %cl, %al
jne 0x16d4e
movq %r14, 0x28(%rsp)
movq 0x90(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %rdx, %r14
callq 0x9100
leaq 0x1(%rbx), %rsi
movb $0x0, (%rbx)
movq %r12, %rdi
movq %r13, %r15
movq %rsi, %r13
movq %rbp, %rdx
callq *%r15
testl %eax, %eax
je 0x16d5f
movl %eax, %ebx
addl $0xffffbb80, %ebx # imm = 0xFFFFBB80
jmp 0x16d4e
movl $0xffffbf80, %ebx # imm = 0xFFFFBF80
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, 0x20(%rsp)
movq %r13, %r12
addq %rbp, %r12
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rcx
callq 0x26dfe
movl %eax, %ebx
testl %eax, %eax
movq %r14, %rax
movq 0x28(%rsp), %r14
jne 0x16d4e
movq %r13, 0x10(%rsp)
movq 0x80(%rsp), %rdx
leaq (%rdx,%rbp,2), %rcx
movq %r12, %rsi
movq %rbp, %r12
addq %rbp, %rsi
movq %rax, %r13
subq %rcx, %rax
movb $0x1, -0x2(%rax,%rsi)
testq %rdx, %rdx
je 0x16dd4
movq %rsi, %rcx
movq 0x88(%rsp), %rsi
leaq (%rax,%rcx), %rdi
addq $-0x2, %rdi
incq %rdi
callq 0x9180
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x26a65
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x26ba1
movl %eax, %ebx
testl %eax, %eax
movq 0x90(%rsp), %rax
jne 0x16e4c
movq %r12, %rbp
leaq (%rax,%r12), %rdi
incq %rdi
movq %r12, %rax
notq %rax
addq %rax, %r13
leaq 0x30(%rsp), %r8
movq %rdi, 0x8(%rsp)
movq %r13, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdx
movq %rbp, %rcx
callq 0x16e9c
testl %eax, %eax
jne 0x16e4a
leaq 0x30(%rsp), %r8
movq %r12, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
callq 0x16e9c
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0x26a74
testl %ebx, %ebx
jne 0x16d4e
cmpl $0x0, 0x4(%rsp)
je 0x16e82
movq %r14, %rdi
movq %r15, %rsi
movq 0x20(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq %rcx, %r8
callq 0x166a4
jmp 0x16e95
movq %r14, %rdi
movq 0x90(%rsp), %rdx
movq %rdx, %rsi
callq 0x165de
movl %eax, %ebx
jmp 0x16d4e
| /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,
unsigned int hashlen,
const unsigned char *hash,
unsigned char *sig )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
unsigned char *sig_try = NULL, *verif = NULL;
RSA_VALIDATE_RET( ctx != NULL );
RSA_VALIDATE_RET( mode == MBEDTLS_RSA_PRIVATE ||
mode == MBEDTLS_RSA_PUBLIC );
RSA_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE &&
hashlen == 0 ) ||
hash != NULL );
RSA_VALIDATE_RET( sig != NULL );
if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
/*
* Prepare PKCS1-v1.5 encoding (padding and hash identifier)
*/
if( ( ret = rsa_rsassa_pkcs1_v15_encode( md_alg, hashlen, hash,
ctx->len, sig ) ) != 0 )
return( ret );
/*
* Call respective RSA primitive
*/
if( mode == MBEDTLS_RSA_PUBLIC )
{
/* Skip verification on a public key operation */
return( mbedtls_rsa_public( ctx, sig, sig ) );
}
/* Private key operation
*
* In order to prevent Lenstra's attack, make the signature in a
* temporary buffer and check it before returning it.
*/
sig_try = mbedtls_calloc( 1, ctx->len );
if( sig_try == NULL )
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
verif = mbedtls_calloc( 1, ctx->len );
if( verif == NULL )
{
mbedtls_free( sig_try );
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
}
MBEDTLS_MPI_CHK( mbedtls_rsa_private( ctx, f_rng, p_rng, sig, sig_try ) );
MBEDTLS_MPI_CHK( mbedtls_rsa_public( ctx, sig_try, verif ) );
if( mbedtls_safer_memcmp( verif, sig, ctx->len ) != 0 )
{
ret = MBEDTLS_ERR_RSA_PRIVATE_FAILED;
goto cleanup;
}
memcpy( sig, sig_try, ctx->len );
cleanup:
mbedtls_free( sig_try );
mbedtls_free( verif );
return( ret );
} | 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
movl %r8d, %edi
movl %r9d, %esi
movq %rbx, %r8
callq 0x17ae3
movl %eax, %ebp
testl %eax, %eax
je 0x17a09
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r14d, %r14d
je 0x17a80
movq 0x8(%r12), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x9130
movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0
movq %rax, (%rsp)
testq %rax, %rax
je 0x179f8
movl $0x1, %edi
movq %r14, %rsi
callq 0x9130
testq %rax, %rax
je 0x17a9c
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq (%rsp), %r13
movq %r13, %r8
callq 0x166a4
testl %eax, %eax
jne 0x17a71
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x165de
testl %eax, %eax
je 0x17aaa
movl %eax, %ebp
movq %r13, %rdi
callq 0x9030
movq %r14, %rdi
jmp 0x17aa0
movq %r12, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x165de
movq (%rsp), %rdi
callq 0x9030
jmp 0x179f8
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x17ad4
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rbx,%rcx), %sil
xorb (%r14,%rcx), %sil
orb %sil, %al
incq %rcx
cmpq %rcx, %rdx
jne 0x17ab8
movl $0xffffbd00, %ebp # imm = 0xFFFFBD00
testb %al, %al
jne 0x17a73
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9180
xorl %ebp, %ebp
jmp 0x17a73
| /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,
unsigned char *sig )
{
RSA_VALIDATE_RET( ctx != NULL );
RSA_VALIDATE_RET( mode == MBEDTLS_RSA_PRIVATE ||
mode == MBEDTLS_RSA_PUBLIC );
RSA_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE &&
hashlen == 0 ) ||
hash != NULL );
RSA_VALIDATE_RET( sig != NULL );
switch( ctx->padding )
{
#if defined(MBEDTLS_PKCS1_V15)
case MBEDTLS_RSA_PKCS_V15:
return mbedtls_rsa_rsassa_pkcs1_v15_sign( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
#if defined(MBEDTLS_PKCS1_V21)
case MBEDTLS_RSA_PKCS_V21:
return mbedtls_rsa_rsassa_pss_sign( ctx, f_rng, p_rng, mode, md_alg,
hashlen, hash, sig );
#endif
default:
return( MBEDTLS_ERR_RSA_INVALID_PADDING );
}
} | 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,
const unsigned char *hash,
const unsigned char *sig )
{
mbedtls_md_type_t mgf1_hash_id;
RSA_VALIDATE_RET( ctx != NULL );
RSA_VALIDATE_RET( mode == MBEDTLS_RSA_PRIVATE ||
mode == MBEDTLS_RSA_PUBLIC );
RSA_VALIDATE_RET( sig != NULL );
RSA_VALIDATE_RET( ( md_alg == MBEDTLS_MD_NONE &&
hashlen == 0 ) ||
hash != NULL );
mgf1_hash_id = ( ctx->hash_id != MBEDTLS_MD_NONE )
? (mbedtls_md_type_t) ctx->hash_id
: md_alg;
return( mbedtls_rsa_rsassa_pss_verify_ext( ctx, f_rng, p_rng, mode,
md_alg, hashlen, hash,
mgf1_hash_id, MBEDTLS_RSA_SALT_LEN_ANY,
sig ) );
} | 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(x,n) ((x) >> (n))
#define ROTR(x,n) (SHR((x),(n)) | ((x) << (64 - (n))))
#define S0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
#define S1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x, 6))
#define S2(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
#define S3(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
#define F0(x,y,z) (((x) & (y)) | ((z) & ((x) | (y))))
#define F1(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
#define P(a,b,c,d,e,f,g,h,x,K) \
do \
{ \
temp1 = (h) + S3(e) + F1((e),(f),(g)) + (K) + (x); \
temp2 = S2(a) + F0((a),(b),(c)); \
(d) += temp1; (h) = temp1 + temp2; \
} while( 0 )
for( i = 0; i < 8; i++ )
A[i] = ctx->state[i];
#if defined(MBEDTLS_SHA512_SMALLER)
for( i = 0; i < 80; i++ )
{
if( i < 16 )
{
GET_UINT64_BE( W[i], data, i << 3 );
}
else
{
W[i] = S1(W[i - 2]) + W[i - 7] +
S0(W[i - 15]) + W[i - 16];
}
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] );
temp1 = A[7]; A[7] = A[6]; A[6] = A[5]; A[5] = A[4]; A[4] = A[3];
A[3] = A[2]; A[2] = A[1]; A[1] = A[0]; A[0] = temp1;
}
#else /* MBEDTLS_SHA512_SMALLER */
for( i = 0; i < 16; i++ )
{
GET_UINT64_BE( W[i], data, i << 3 );
}
for( ; i < 80; i++ )
{
W[i] = S1(W[i - 2]) + W[i - 7] +
S0(W[i - 15]) + W[i - 16];
}
i = 0;
do
{
P( A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i] ); i++;
P( A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i], K[i] ); i++;
P( A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i], K[i] ); i++;
P( A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i], K[i] ); i++;
P( A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i], K[i] ); i++;
P( A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i], K[i] ); i++;
P( A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i], K[i] ); i++;
P( A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i], K[i] ); i++;
}
while( i < 80 );
#endif /* MBEDTLS_SHA512_SMALLER */
for( i = 0; i < 8; i++ )
ctx->state[i] += A[i];
return( 0 );
} | 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 %eax, %eax
movq (%rsi,%rax,8), %rcx
bswapq %rcx
movq %rcx, -0x30(%rsp,%rax,8)
incq %rax
cmpq $0x10, %rax
jne 0x1a6a9
movq %rdi, -0x38(%rsp)
movl $0x10, %eax
movq -0x40(%rsp,%rax,8), %rcx
movq %rcx, %rdx
rolq $0x2d, %rdx
movq %rcx, %rsi
rolq $0x3, %rsi
xorq %rdx, %rsi
shrq $0x6, %rcx
xorq %rsi, %rcx
addq -0x68(%rsp,%rax,8), %rcx
movq -0xa8(%rsp,%rax,8), %rdx
movq %rdx, %rsi
rorq %rsi
movq %rdx, %r8
rolq $0x38, %r8
xorq %rsi, %r8
shrq $0x7, %rdx
xorq %r8, %rdx
addq -0xb0(%rsp,%rax,8), %rcx
addq %rdx, %rcx
movq %rcx, -0x30(%rsp,%rax,8)
incq %rax
cmpq $0x50, %rax
jne 0x1a6c8
movq -0x48(%rsp), %rdi
movq -0x60(%rsp), %rcx
movq -0x50(%rsp), %rdx
movq -0x58(%rsp), %rax
movq -0x80(%rsp), %rbx
movq -0x78(%rsp), %r10
movq -0x70(%rsp), %r11
movq $-0x8, %rsi
movq -0x68(%rsp), %r9
movq %rcx, %rbp
rolq $0x32, %rbp
movq %rcx, %r13
rolq $0x2e, %r13
movq %rcx, %r15
movq %rax, %r12
rolq $0x17, %r15
xorq %rdx, %r12
andq %rcx, %r12
movq %rbx, %r8
xorq %rbp, %r13
rolq $0x24, %r8
movq %rbx, %rbp
xorq %rdx, %r12
rolq $0x1e, %rbp
xorq %r8, %rbp
xorq %r13, %r15
movq %rbx, %r8
rolq $0x19, %r8
addq %rdi, %r15
xorq %rbp, %r8
movq %r10, %r13
leaq 0x15790(%rip), %rdi # 0x2ff30
addq 0x40(%rdi,%rsi,8), %r15
movq %rdi, %r14
andq %rbx, %r13
movq %r10, %rdi
addq 0x10(%rsp,%rsi,8), %r15
orq %rbx, %rdi
andq %r11, %rdi
orq %r13, %rdi
addq %r12, %r15
addq %r15, %r9
movq %r9, %rbp
rolq $0x32, %rbp
addq %r8, %rdi
movq %r9, %r13
rolq $0x2e, %r13
addq %r15, %rdi
movq %r9, %r12
rolq $0x17, %r12
movq %rax, %r15
xorq %rcx, %r15
andq %r9, %r15
xorq %rax, %r15
addq %rdx, %r15
movq %rdi, %r8
addq 0x48(%r14,%rsi,8), %r15
rolq $0x24, %r8
movq %rdi, %r14
xorq %rbp, %r13
rolq $0x1e, %r14
xorq %r8, %r14
xorq %r13, %r12
movq %rdi, %r8
rolq $0x19, %r8
xorq %r14, %r8
movq %rdi, %r13
andq %rbx, %r13
movq %rdi, %rdx
addq %r12, %r15
orq %rbx, %rdx
andq %r10, %rdx
addq 0x18(%rsp,%rsi,8), %r15
orq %r13, %rdx
addq %r8, %rdx
addq %r15, %r11
addq %r15, %rdx
movq %r11, %r13
movq %r11, %r15
movq %r9, %r8
movq %r11, %r12
xorq %rcx, %r8
andq %r11, %r8
rolq $0x32, %r13
leaq 0x156de(%rip), %r14 # 0x2ff30
addq 0x50(%r14,%rsi,8), %rax
rolq $0x2e, %r15
addq 0x20(%rsp,%rsi,8), %rax
rolq $0x17, %r12
xorq %rcx, %r8
movq %rdx, %rbp
rolq $0x24, %rbp
movq %rdx, %r14
rolq $0x1e, %r14
xorq %r13, %r15
addq %r8, %rax
xorq %rbp, %r14
movq %rdx, %r8
xorq %r15, %r12
rolq $0x19, %r8
movq %rdx, %r15
xorq %r14, %r8
andq %rdi, %r15
movq %rdx, %r14
orq %rdi, %r14
addq %r12, %rax
andq %rbx, %r14
orq %r15, %r14
addq %r8, %r14
addq %rax, %r10
addq %r14, %rax
movq %r10, %r13
rolq $0x32, %r13
movq %r10, %r12
movq %r10, %r15
rolq $0x2e, %r12
movq %r11, %r8
xorq %r9, %r8
rolq $0x17, %r15
andq %r10, %r8
leaq 0x15662(%rip), %rbp # 0x2ff30
addq 0x58(%rbp,%rsi,8), %rcx
xorq %r9, %r8
addq 0x28(%rsp,%rsi,8), %rcx
movq %rax, %r14
addq %r8, %rcx
rolq $0x24, %r14
movq %rax, %r8
xorq %r13, %r12
rolq $0x1e, %r8
xorq %r14, %r8
xorq %r12, %r15
movq %rax, %r14
rolq $0x19, %r14
xorq %r8, %r14
movq %rax, %r8
andq %rdx, %r8
movq %rax, %r12
addq %r15, %rcx
orq %rdx, %r12
andq %rdi, %r12
orq %r8, %r12
addq %r14, %r12
addq %rcx, %rbx
addq %r12, %rcx
movq %rbx, %r8
movq %rbx, %r12
movq %rbx, %r15
movq %r10, %r14
rolq $0x32, %r8
xorq %r11, %r14
andq %rbx, %r14
rolq $0x2e, %r12
addq 0x60(%rbp,%rsi,8), %r9
rolq $0x17, %r15
xorq %r11, %r14
addq 0x30(%rsp,%rsi,8), %r9
addq %r14, %r9
movq %rcx, %r14
rolq $0x24, %r14
xorq %r8, %r12
movq %rcx, %r8
rolq $0x1e, %r8
movq %r9, %r13
movq %rcx, %rbp
rolq $0x19, %rbp
xorq %r12, %r15
xorq %r14, %r8
xorq %r8, %rbp
movq %rcx, %r8
addq %r15, %r13
andq %rax, %r8
movq %rcx, %r9
orq %rax, %r9
andq %rdx, %r9
orq %r8, %r9
addq %rbp, %r9
addq %r13, %rdi
addq %r13, %r9
movq %rdi, %r8
movq %rdi, %r14
rolq $0x32, %r8
movq %rdi, %r15
movq %rbx, %r12
rolq $0x2e, %r14
xorq %r10, %r12
andq %rdi, %r12
rolq $0x17, %r15
xorq %r10, %r12
leaq 0x1557b(%rip), %r13 # 0x2ff30
addq 0x68(%r13,%rsi,8), %r11
xorq %r8, %r14
addq 0x38(%rsp,%rsi,8), %r11
addq %r12, %r11
movq %r11, %r12
movq %r9, %r8
rolq $0x24, %r8
xorq %r14, %r15
movq %r9, %r14
rolq $0x1e, %r14
addq %r15, %r12
movq %r9, %r15
rolq $0x19, %r15
xorq %r8, %r14
movq %r9, %r8
andq %rcx, %r8
movq %r9, %r11
xorq %r14, %r15
orq %rcx, %r11
andq %rax, %r11
orq %r8, %r11
addq %r15, %r11
addq %r12, %rdx
movq %rdx, %r8
movq %rdx, %r15
addq %r12, %r11
movq %rdx, %r12
movq %rdi, %r14
rolq $0x32, %r8
xorq %rbx, %r14
andq %rdx, %r14
rolq $0x2e, %r15
addq 0x70(%r13,%rsi,8), %r10
rolq $0x17, %r12
xorq %rbx, %r14
addq 0x40(%rsp,%rsi,8), %r10
xorq %r8, %r15
addq %r14, %r10
movq %r11, %r8
rolq $0x24, %r8
movq %r10, %r14
movq %r11, %r13
rolq $0x1e, %r13
movq %r11, %rbp
rolq $0x19, %rbp
xorq %r15, %r12
addq %r12, %r14
movq %r11, %r15
andq %r9, %r15
xorq %r8, %r13
movq %r11, %r10
orq %r9, %r10
andq %rcx, %r10
xorq %r13, %rbp
orq %r15, %r10
addq %rbp, %r10
addq %r14, %rax
addq %r14, %r10
movq %rax, %r8
movq %rax, %r14
rolq $0x32, %r8
movq %rax, %r15
movq %rdx, %r12
rolq $0x2e, %r14
xorq %rdi, %r12
andq %rax, %r12
rolq $0x17, %r15
xorq %rdi, %r12
leaq 0x15494(%rip), %r13 # 0x2ff30
addq 0x78(%r13,%rsi,8), %rbx
xorq %r8, %r14
addq 0x48(%rsp,%rsi,8), %rbx
addq %r12, %rbx
movq %rbx, %r8
movq %r10, %rbx
rolq $0x24, %rbx
xorq %r14, %r15
movq %r10, %r14
rolq $0x1e, %r14
addq %r15, %r8
movq %r10, %r15
rolq $0x19, %r15
xorq %rbx, %r14
movq %r10, %r12
andq %r11, %r12
movq %r10, %rbx
xorq %r14, %r15
orq %r11, %rbx
andq %r9, %rbx
orq %r12, %rbx
addq %r15, %rbx
addq %r8, %rcx
addq %r8, %rbx
addq $0x8, %rsi
cmpq $0x48, %rsi
jb 0x1a751
movq %rdi, -0x48(%rsp)
movq %rcx, -0x60(%rsp)
movq %rdx, -0x50(%rsp)
movq %rax, -0x58(%rsp)
movq %rbx, -0x80(%rsp)
movq %r10, -0x78(%rsp)
movq %r11, -0x70(%rsp)
movq %r9, -0x68(%rsp)
xorl %eax, %eax
movq -0x38(%rsp), %rdx
movq -0x80(%rsp,%rax,8), %rcx
addq %rcx, 0x10(%rdx,%rax,8)
incq %rax
cmpq $0x8, %rax
jne 0x1ab28
xorl %eax, %eax
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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;
gettimeofday( &now, NULL );
delta = ( now.tv_sec - t->start.tv_sec ) * 1000ul
+ ( now.tv_usec - t->start.tv_usec ) / 1000;
return( delta );
}
} | 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 = 0x3E8
subq 0x8(%rbx), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
movq %rdx, %r14
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r14
addq %rax, %r14
addq %rcx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /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_VALIDATE_RET( ctx != NULL );
AES_VALIDATE_RET( key != NULL );
ret = mbedtls_aes_xts_decode_keys( key, keybits, &key1, &key1bits,
&key2, &key2bits );
if( ret != 0 )
return( ret );
/* Set the tweak key. Always set tweak key for encryption. */
ret = mbedtls_aes_setkey_enc( &ctx->tweak, key2, key2bits );
if( ret != 0 )
return( ret );
/* Set crypt key for decryption. */
return mbedtls_aes_setkey_dec( &ctx->crypt, key1, key1bits );
} | 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 = 0xFFFFFFE0
xorl %ecx, %ecx
testb %cl, %cl
je 0x22989
leaq 0x120(%r14), %rdi
movq %rdx, %rsi
movl %ebp, %edx
callq 0x22089
testl %eax, %eax
je 0x2298e
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x2273c
| /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 );
AES_VALIDATE_RET( mode == MBEDTLS_AES_ENCRYPT ||
mode == MBEDTLS_AES_DECRYPT );
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_AES ) )
return( mbedtls_aesni_crypt_ecb( ctx, mode, input, output ) );
#endif
#if defined(MBEDTLS_PADLOCK_C) && defined(MBEDTLS_HAVE_X86)
if( aes_padlock_ace )
{
if( mbedtls_padlock_xcryptecb( ctx, mode, input, output ) == 0 )
return( 0 );
// If padlock data misaligned, we just fall back to
// unaccelerated mode
//
}
#endif
if( mode == MBEDTLS_AES_ENCRYPT )
return( mbedtls_internal_aes_encrypt( ctx, input, output ) );
else
return( mbedtls_internal_aes_decrypt( ctx, input, output ) );
} | 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
popq %rbp
jmp 0x2473f
movq %r14, %rsi
movq %rbx, %rdx
cmpl $0x1, %ebp
jne 0x23656
callq 0x2299f
jmp 0x2365b
callq 0x22fd1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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_UINT64_LE( ra, r, 0 );
PUT_UINT64_LE( rb, r, 8 );
} | 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
movzbl 0x1(%rsi), %r12d
movzbl (%rsi), %r13d
orq %r8, %r9
orl %r14d, %edx
orl %edx, %r13d
movzbl 0xf(%rsi), %ecx
movq %rcx, %r11
shlq $0x38, %r11
movzbl 0xe(%rsi), %ebx
shlq $0x30, %rbx
orq %r11, %rbx
movzbl 0xb(%rsi), %r15d
shll $0x18, %r15d
movzbl 0xa(%rsi), %r11d
shll $0x10, %r11d
movzbl 0x9(%rsi), %ebp
shll $0x9, %r12d
leal (%r12,%r13,2), %r12d
movl %r12d, -0x4(%rsp)
addl %r13d, %r13d
notb %cl
shrb $0x4, %cl
andb $0x8, %cl
movl $0x87, %r12d
shrq %cl, %r12
xorl %r13d, %r12d
movzbl 0x8(%rsi), %r13d
orl %r15d, %r11d
orl %r11d, %r13d
shrl $0x7, %r10d
shll $0x9, %ebp
leal (%rbp,%r13,2), %ecx
leal (%r10,%r13,2), %r10d
movzbl 0xd(%rsi), %r13d
movzbl 0xc(%rsi), %esi
shrq $0x37, %r8
movb %r8b, 0x7(%rdi)
shlq $0x20, %rax
orq %r9, %rax
shrq $0x2f, %r9
movb %r9b, 0x6(%rdi)
leaq (%rax,%r14), %r8
shrq $0x27, %rax
movb %al, 0x5(%rdi)
shrq $0x1f, %r8
movb %r8b, 0x4(%rdi)
shrl $0x17, %edx
movb %dl, 0x3(%rdi)
movl -0x4(%rsp), %edx
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rdi)
movb %dh, 0x1(%rdi)
movb %r12b, (%rdi)
shlq $0x28, %r13
orq %rbx, %r13
shrq $0x37, %rbx
movb %bl, 0xf(%rdi)
shlq $0x20, %rsi
orq %r13, %rsi
shrq $0x2f, %r13
movb %r13b, 0xe(%rdi)
leaq (%rsi,%r15), %rax
shrq $0x27, %rsi
movb %sil, 0xd(%rdi)
shrq $0x1f, %rax
movb %al, 0xc(%rdi)
shrl $0x17, %r11d
movb %r11b, 0xb(%rdi)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xa(%rdi)
movb %ch, 0x9(%rdi)
movb %r10b, 0x8(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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_CIPHER_MODE_CBC)
unsigned char prv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_CFB) || \
defined(MBEDTLS_CIPHER_MODE_OFB)
size_t offset;
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR) || defined(MBEDTLS_CIPHER_MODE_XTS)
int len;
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
unsigned char nonce_counter[16];
unsigned char stream_block[16];
#endif
mbedtls_aes_context ctx;
memset( key, 0, 32 );
mbedtls_aes_init( &ctx );
/*
* ECB mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-ECB-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( buf, 0, 16 );
if( mode == MBEDTLS_AES_DECRYPT )
{
ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
aes_tests = aes_test_ecb_dec[u];
}
else
{
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
aes_tests = aes_test_ecb_enc[u];
}
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
for( j = 0; j < 10000; j++ )
{
ret = mbedtls_aes_crypt_ecb( &ctx, mode, buf, buf );
if( ret != 0 )
goto exit;
}
if( memcmp( buf, aes_tests, 16 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#if defined(MBEDTLS_CIPHER_MODE_CBC)
/*
* CBC mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CBC-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( iv , 0, 16 );
memset( prv, 0, 16 );
memset( buf, 0, 16 );
if( mode == MBEDTLS_AES_DECRYPT )
{
ret = mbedtls_aes_setkey_dec( &ctx, key, keybits );
aes_tests = aes_test_cbc_dec[u];
}
else
{
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
aes_tests = aes_test_cbc_enc[u];
}
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
for( j = 0; j < 10000; j++ )
{
if( mode == MBEDTLS_AES_ENCRYPT )
{
unsigned char tmp[16];
memcpy( tmp, prv, 16 );
memcpy( prv, buf, 16 );
memcpy( buf, tmp, 16 );
}
ret = mbedtls_aes_crypt_cbc( &ctx, mode, 16, iv, buf, buf );
if( ret != 0 )
goto exit;
}
if( memcmp( buf, aes_tests, 16 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CBC */
#if defined(MBEDTLS_CIPHER_MODE_CFB)
/*
* CFB128 mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CFB128-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, aes_test_cfb128_iv, 16 );
memcpy( key, aes_test_cfb128_key[u], keybits / 8 );
offset = 0;
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
if( mode == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_cfb128_ct[u], 64 );
aes_tests = aes_test_cfb128_pt;
}
else
{
memcpy( buf, aes_test_cfb128_pt, 64 );
aes_tests = aes_test_cfb128_ct[u];
}
ret = mbedtls_aes_crypt_cfb128( &ctx, mode, 64, &offset, iv, buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, 64 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CFB */
#if defined(MBEDTLS_CIPHER_MODE_OFB)
/*
* OFB mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
keybits = 128 + u * 64;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-OFB-%3d (%s): ", keybits,
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( iv, aes_test_ofb_iv, 16 );
memcpy( key, aes_test_ofb_key[u], keybits / 8 );
offset = 0;
ret = mbedtls_aes_setkey_enc( &ctx, key, keybits );
/*
* AES-192 is an optional feature that may be unavailable when
* there is an alternative underlying implementation i.e. when
* MBEDTLS_AES_ALT is defined.
*/
if( ret == MBEDTLS_ERR_PLATFORM_FEATURE_UNSUPPORTED && keybits == 192 )
{
mbedtls_printf( "skipped\n" );
continue;
}
else if( ret != 0 )
{
goto exit;
}
if( mode == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_ofb_ct[u], 64 );
aes_tests = aes_test_ofb_pt;
}
else
{
memcpy( buf, aes_test_ofb_pt, 64 );
aes_tests = aes_test_ofb_ct[u];
}
ret = mbedtls_aes_crypt_ofb( &ctx, 64, &offset, iv, buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, 64 ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_OFB */
#if defined(MBEDTLS_CIPHER_MODE_CTR)
/*
* CTR mode
*/
for( i = 0; i < 6; i++ )
{
u = i >> 1;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-CTR-128 (%s): ",
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memcpy( nonce_counter, aes_test_ctr_nonce_counter[u], 16 );
memcpy( key, aes_test_ctr_key[u], 16 );
offset = 0;
if( ( ret = mbedtls_aes_setkey_enc( &ctx, key, 128 ) ) != 0 )
goto exit;
len = aes_test_ctr_len[u];
if( mode == MBEDTLS_AES_DECRYPT )
{
memcpy( buf, aes_test_ctr_ct[u], len );
aes_tests = aes_test_ctr_pt[u];
}
else
{
memcpy( buf, aes_test_ctr_pt[u], len );
aes_tests = aes_test_ctr_ct[u];
}
ret = mbedtls_aes_crypt_ctr( &ctx, len, &offset, nonce_counter,
stream_block, buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, len ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
#endif /* MBEDTLS_CIPHER_MODE_CTR */
#if defined(MBEDTLS_CIPHER_MODE_XTS)
{
static const int num_tests =
sizeof(aes_test_xts_key) / sizeof(*aes_test_xts_key);
mbedtls_aes_xts_context ctx_xts;
/*
* XTS mode
*/
mbedtls_aes_xts_init( &ctx_xts );
for( i = 0; i < num_tests << 1; i++ )
{
const unsigned char *data_unit;
u = i >> 1;
mode = i & 1;
if( verbose != 0 )
mbedtls_printf( " AES-XTS-128 (%s): ",
( mode == MBEDTLS_AES_DECRYPT ) ? "dec" : "enc" );
memset( key, 0, sizeof( key ) );
memcpy( key, aes_test_xts_key[u], 32 );
data_unit = aes_test_xts_data_unit[u];
len = sizeof( *aes_test_xts_ct32 );
if( mode == MBEDTLS_AES_DECRYPT )
{
ret = mbedtls_aes_xts_setkey_dec( &ctx_xts, key, 256 );
if( ret != 0)
goto exit;
memcpy( buf, aes_test_xts_ct32[u], len );
aes_tests = aes_test_xts_pt32[u];
}
else
{
ret = mbedtls_aes_xts_setkey_enc( &ctx_xts, key, 256 );
if( ret != 0)
goto exit;
memcpy( buf, aes_test_xts_pt32[u], len );
aes_tests = aes_test_xts_ct32[u];
}
ret = mbedtls_aes_crypt_xts( &ctx_xts, mode, len, data_unit,
buf, buf );
if( ret != 0 )
goto exit;
if( memcmp( buf, aes_tests, len ) != 0 )
{
ret = 1;
goto exit;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
mbedtls_aes_xts_free( &ctx_xts );
}
#endif /* MBEDTLS_CIPHER_MODE_XTS */
ret = 0;
exit:
if( ret != 0 && verbose != 0 )
mbedtls_printf( "failed\n" );
mbedtls_aes_free( &ctx );
return( ret );
} | 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(%rsp), %r13
xorl %r14d, %r14d
movl %r14d, %r12d
shrl %r12d
movl %r12d, %ebp
shll $0x6, %ebp
subl $-0x80, %ebp
movl %r14d, %ebx
andl $0x1, %ebx
cmpl $0x0, 0x14(%rsp)
je 0x23dab
testl %ebx, %ebx
leaq 0x106b9(%rip), %rdx # 0x34449
leaq 0x106ae(%rip), %rax # 0x34445
cmoveq %rax, %rdx
leaq 0x1068e(%rip), %rdi # 0x34430
movl %ebp, %esi
xorl %eax, %eax
callq 0x90c0
pxor %xmm0, %xmm0
movdqa %xmm0, 0x20(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl %ebp, %edx
testl %ebx, %ebx
jne 0x23dd9
callq 0x2273c
movl %eax, %r15d
leaq 0x106f9(%rip), %rcx # 0x344d0
jmp 0x23de8
callq 0x22089
movl %eax, %r15d
leaq 0x10718(%rip), %rcx # 0x34500
movl %r15d, %eax
xorl $-0x72, %eax
xorl $0xc0, %ebp
orl %eax, %ebp
leaq 0x106bc(%rip), %rdi # 0x344b9
je 0x23e6c
testl %r15d, %r15d
jne 0x246cc
movl %r12d, %eax
shlq $0x4, %rax
addq %rax, %rcx
movq %rcx, 0x68(%rsp)
movl $0x2710, %ebp # imm = 0x2710
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movl %ebx, %esi
movq %r13, %rdx
movq %r13, %rcx
callq 0x2360a
testl %eax, %eax
jne 0x246c9
decl %ebp
jne 0x23e24
movq 0x68(%rsp), %rax
movdqu (%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x2470b
leaq 0xaa21(%rip), %rdi # 0x2e886
cmpl $0x0, 0x14(%rsp)
je 0x23e71
callq 0x9060
incl %r14d
cmpl $0x6, %r14d
jne 0x23d6b
cmpl $0x0, 0x14(%rsp)
je 0x23e8f
movl $0xa, %edi
callq 0x9040
leaq 0xd0(%rsp), %r12
xorl %r14d, %r14d
movl %r14d, %ebp
shrl %ebp
movl %ebp, %ebx
shll $0x6, %ebx
subl $-0x80, %ebx
movl %r14d, %r13d
andl $0x1, %r13d
cmpl $0x0, 0x14(%rsp)
je 0x23eda
testl %r13d, %r13d
leaq 0x1058a(%rip), %rdx # 0x34449
leaq 0x1057f(%rip), %rax # 0x34445
cmoveq %rax, %rdx
leaq 0x1057c(%rip), %rdi # 0x3444d
movl %ebx, %esi
xorl %eax, %eax
callq 0x90c0
pxor %xmm0, %xmm0
movdqa %xmm0, 0x90(%rsp)
movdqa %xmm0, 0xa0(%rsp)
movdqa %xmm0, 0x20(%rsp)
movq %r12, %rdi
leaq 0x70(%rsp), %rsi
movl %ebx, %edx
testl %r13d, %r13d
jne 0x23f16
callq 0x2273c
movl %eax, %r15d
leaq 0x1061c(%rip), %rcx # 0x34530
jmp 0x23f25
callq 0x22089
movl %eax, %r15d
leaq 0x1063b(%rip), %rcx # 0x34560
movl %r15d, %eax
xorl $-0x72, %eax
xorl $0xc0, %ebx
orl %eax, %ebx
leaq 0x1057f(%rip), %rdi # 0x344b9
je 0x23fda
testl %r15d, %r15d
jne 0x246cc
movl %ebp, %eax
shlq $0x4, %rax
addq %rax, %rcx
movq %rcx, 0x68(%rsp)
movl $0x2710, %ebx # imm = 0x2710
leaq 0x20(%rsp), %rbp
testl %r13d, %r13d
je 0x23f84
movdqa 0xa0(%rsp), %xmm0
movdqa 0x20(%rsp), %xmm1
movdqa %xmm1, 0xa0(%rsp)
movdqa %xmm0, 0x20(%rsp)
movl $0x10, %edx
movq %r12, %rdi
movl %r13d, %esi
leaq 0x90(%rsp), %rcx
movq %rbp, %r8
movq %rbp, %r9
callq 0x23668
testl %eax, %eax
jne 0x246c9
decl %ebx
jne 0x23f61
movq 0x68(%rsp), %rax
movdqu (%rax), %xmm0
pcmpeqb 0x20(%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x2470b
leaq 0xa8b3(%rip), %rdi # 0x2e886
cmpl $0x0, 0x14(%rsp)
je 0x23fdf
callq 0x9060
incl %r14d
cmpl $0x6, %r14d
jne 0x23e9a
cmpl $0x0, 0x14(%rsp)
je 0x23ffd
movl $0xa, %edi
callq 0x9040
leaq 0x1091c(%rip), %r14 # 0x34920
xorl %ebp, %ebp
movl %ebp, %ebx
shrl %ebx
movl %ebx, %r13d
shll $0x6, %r13d
subl $-0x80, %r13d
movl %ebp, %r12d
andl $0x1, %r12d
cmpl $0x0, 0x14(%rsp)
je 0x24049
testl %r12d, %r12d
leaq 0x1041c(%rip), %rdx # 0x34449
leaq 0x10411(%rip), %rax # 0x34445
cmoveq %rax, %rdx
leaq 0x10423(%rip), %rdi # 0x34462
movl %r13d, %esi
xorl %eax, %eax
callq 0x90c0
movdqa 0x103cf(%rip), %xmm0 # 0x34420
movdqa %xmm0, 0x90(%rsp)
movl %ebx, %ebx
movq %rbx, %rsi
shlq $0x5, %rsi
addq %r14, %rsi
movl %r13d, %edx
shrl $0x3, %edx
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x9180
movq $0x0, 0x18(%rsp)
leaq 0xd0(%rsp), %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x22089
movl %eax, %r15d
xorl $-0x72, %eax
xorl $0xc0, %r13d
orl %eax, %r13d
leaq 0x1040d(%rip), %rdi # 0x344b9
je 0x2419b
testl %r15d, %r15d
jne 0x246cc
testl %r12d, %r12d
jne 0x240ff
shlq $0x6, %rbx
leaq 0x104c5(%rip), %rax # 0x34590
movdqa (%rbx,%rax), %xmm0
movdqa 0x10(%rbx,%rax), %xmm1
movaps 0x20(%rbx,%rax), %xmm2
movaps 0x30(%rbx,%rax), %xmm3
movaps %xmm3, 0x50(%rsp)
movaps %xmm2, 0x40(%rsp)
movdqa %xmm1, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0x10553(%rip), %rbx # 0x34650
jmp 0x2413f
movaps 0x1057a(%rip), %xmm0 # 0x34680
movaps %xmm0, 0x50(%rsp)
movaps 0x1055e(%rip), %xmm0 # 0x34670
movaps %xmm0, 0x40(%rsp)
movaps 0x10542(%rip), %xmm0 # 0x34660
movaps %xmm0, 0x30(%rsp)
movdqa 0x10525(%rip), %xmm0 # 0x34650
movdqa %xmm0, 0x20(%rsp)
shlq $0x6, %rbx
leaq 0x10454(%rip), %rax # 0x34590
addq %rax, %rbx
leaq 0x20(%rsp), %r13
movq %r13, (%rsp)
movl $0x40, %edx
leaq 0xd0(%rsp), %rdi
movl %r12d, %esi
leaq 0x18(%rsp), %rcx
leaq 0x90(%rsp), %r8
movq %r13, %r9
callq 0x23a5f
testl %eax, %eax
jne 0x246c9
movl $0x40, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x91a0
testl %eax, %eax
jne 0x2470b
leaq 0xa6f2(%rip), %rdi # 0x2e886
cmpl $0x0, 0x14(%rsp)
je 0x241a0
callq 0x9060
incl %ebp
cmpl $0x6, %ebp
jne 0x24006
cmpl $0x0, 0x14(%rsp)
je 0x241bc
movl $0xa, %edi
callq 0x9040
leaq 0x70(%rsp), %r12
leaq 0xd0(%rsp), %r13
xorl %r14d, %r14d
movl %r14d, %ebx
shrl %ebx
movl %ebx, %ebp
shll $0x6, %ebp
subl $-0x80, %ebp
cmpl $0x0, 0x14(%rsp)
je 0x24206
testb $0x1, %r14b
leaq 0x1025e(%rip), %rdx # 0x34449
leaq 0x10253(%rip), %rax # 0x34445
cmoveq %rax, %rdx
leaq 0x1027d(%rip), %rdi # 0x3447a
movl %ebp, %esi
xorl %eax, %eax
callq 0x90c0
movdqa 0x10212(%rip), %xmm0 # 0x34420
movdqa %xmm0, 0x90(%rsp)
movl %ebx, %ebx
movq %rbx, %rsi
shlq $0x5, %rsi
leaq 0x106f9(%rip), %rax # 0x34920
addq %rax, %rsi
movl %ebp, %edx
shrl $0x3, %edx
movq %r12, %rdi
callq 0x9180
movq $0x0, 0x18(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x22089
movl %eax, %r15d
xorl $-0x72, %eax
xorl $0xc0, %ebp
orl %eax, %ebp
leaq 0x10257(%rip), %rdi # 0x344b9
je 0x24349
testl %r15d, %r15d
jne 0x246cc
testb $0x1, %r14b
leaq 0x20(%rsp), %r15
jne 0x242bb
shlq $0x6, %rbx
leaq 0x10409(%rip), %rax # 0x34690
movdqa (%rbx,%rax), %xmm0
movdqa 0x10(%rbx,%rax), %xmm1
movaps 0x20(%rbx,%rax), %xmm2
movaps 0x30(%rbx,%rax), %xmm3
movaps %xmm3, 0x50(%rsp)
movaps %xmm2, 0x40(%rsp)
movdqa %xmm1, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
leaq 0x10497(%rip), %rbx # 0x34750
jmp 0x242fb
movaps 0x104be(%rip), %xmm0 # 0x34780
movaps %xmm0, 0x50(%rsp)
movaps 0x104a2(%rip), %xmm0 # 0x34770
movaps %xmm0, 0x40(%rsp)
movaps 0x10486(%rip), %xmm0 # 0x34760
movaps %xmm0, 0x30(%rsp)
movdqa 0x10469(%rip), %xmm0 # 0x34750
movdqa %xmm0, 0x20(%rsp)
shlq $0x6, %rbx
leaq 0x10398(%rip), %rax # 0x34690
addq %rax, %rbx
movl $0x40, %esi
movq %r13, %rdi
leaq 0x18(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r15, %r8
movq %r15, %r9
callq 0x23bfb
testl %eax, %eax
jne 0x246c9
movq %r15, %rdi
movl $0x40, %edx
movq %rbx, %rsi
callq 0x91a0
testl %eax, %eax
jne 0x2470b
leaq 0xa544(%rip), %rdi # 0x2e886
cmpl $0x0, 0x14(%rsp)
je 0x2434e
callq 0x9060
incl %r14d
cmpl $0x6, %r14d
jne 0x241cc
cmpl $0x0, 0x14(%rsp)
je 0x2436c
movl $0xa, %edi
callq 0x9040
leaq 0xd0(%rsp), %rbx
leaq 0x10605(%rip), %r12 # 0x34980
leaq 0x1068e(%rip), %r13 # 0x34a10
xorl %ebp, %ebp
cmpl $0x0, 0x14(%rsp)
je 0x243af
testb $0x1, %bpl
leaq 0x100b3(%rip), %rsi # 0x34449
leaq 0x100a8(%rip), %rax # 0x34445
cmoveq %rax, %rsi
leaq 0x100e7(%rip), %rdi # 0x3448f
xorl %eax, %eax
callq 0x90c0
movl %ebp, %eax
shrl %eax
movl %eax, %r14d
movq %r14, %rax
shlq $0x4, %rax
leaq 0x103cc(%rip), %rcx # 0x34790
movaps (%rax,%rcx), %xmm0
movaps %xmm0, 0xb0(%rsp)
leaq 0x103e9(%rip), %rcx # 0x347c0
movdqa (%rax,%rcx), %xmm0
movdqa %xmm0, 0x70(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
movl $0x80, %edx
callq 0x22089
testl %eax, %eax
jne 0x246c9
testb $0x1, %bpl
movq %r13, %rsi
cmoveq %r12, %rsi
movq %rbx, %r15
leaq 0x103d6(%rip), %rax # 0x347f0
movslq (%rax,%r14,4), %rbx
leaq (%r14,%r14,2), %r14
shlq $0x4, %r14
addq %r14, %rsi
movq %r12, %r13
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x9180
movq %r12, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
leaq 0x18(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
leaq 0xc0(%rsp), %r8
movq %r12, %r9
callq 0x23c84
testl %eax, %eax
jne 0x246c9
movq %r12, %rdi
movl %ebp, %r12d
testb $0x1, %bpl
movq %r13, %r15
movq %r13, %rsi
leaq 0x1058e(%rip), %r13 # 0x34a10
cmoveq %r13, %rsi
addq %r14, %rsi
movq %rbx, %rdx
callq 0x91a0
testl %eax, %eax
jne 0x2470b
cmpl $0x0, 0x14(%rsp)
je 0x244ac
leaq 0xa3df(%rip), %rdi # 0x2e886
callq 0x9060
movl %r12d, %ebp
incl %ebp
cmpl $0x6, %ebp
leaq 0xd0(%rsp), %rbx
movq %r15, %r12
jne 0x24384
cmpl $0x0, 0x14(%rsp)
je 0x244d6
movl $0xa, %edi
callq 0x9040
leaq 0x1f0(%rsp), %r13
movl $0x240, %edx # imm = 0x240
movq %r13, %rdi
xorl %esi, %esi
callq 0x9100
xorl %r12d, %r12d
movl %r12d, %ebx
andl $0x1, %ebx
cmpl $0x0, 0x14(%rsp)
je 0x2451f
testl %ebx, %ebx
leaq 0xff43(%rip), %rsi # 0x34449
leaq 0xff38(%rip), %rax # 0x34445
cmoveq %rax, %rsi
leaq 0xff8c(%rip), %rdi # 0x344a4
xorl %eax, %eax
callq 0x90c0
movl %r12d, %eax
shrl %eax
movl %eax, %r14d
movq %r14, %rbp
shlq $0x5, %rbp
leaq 0x102cb(%rip), %rax # 0x34800
movdqa (%rbp,%rax), %xmm0
movdqa 0x10(%rbp,%rax), %xmm1
movdqa %xmm1, 0x80(%rsp)
movdqa %xmm0, 0x70(%rsp)
movq %r13, %rdi
leaq 0x70(%rsp), %rsi
movl $0x100, %edx # imm = 0x100
testl %ebx, %ebx
jne 0x2457c
callq 0x2293f
movl %eax, %r15d
leaq 0x102f0(%rip), %rax # 0x34860
movq %r13, %rdi
leaq 0x10346(%rip), %r13 # 0x348c0
jmp 0x24595
callq 0x228df
movl %eax, %r15d
leaq 0x10335(%rip), %rax # 0x348c0
movq %r13, %rdi
leaq 0x102cb(%rip), %r13 # 0x34860
testl %r15d, %r15d
je 0x245a9
movl $0x5, %eax
xorl %ecx, %ecx
movq %rdi, %r13
jmp 0x2468a
shlq $0x4, %r14
leaq 0x104ec(%rip), %rcx # 0x34aa0
addq %rcx, %r14
movdqa (%rax,%rbp), %xmm0
movdqa 0x10(%rax,%rbp), %xmm1
movdqa %xmm1, 0x30(%rsp)
movdqa %xmm0, 0x20(%rsp)
movl $0x20, %edx
movl %ebx, %esi
movq %r14, %rcx
leaq 0x20(%rsp), %r8
movq %r8, %r9
callq 0x23736
testl %eax, %eax
je 0x24600
movl %eax, %r15d
movl $0x5, %eax
xorl %ecx, %ecx
leaq 0x1f0(%rsp), %r13
jmp 0x2468a
movdqu (%r13,%rbp), %xmm0
movdqu 0x10(%r13,%rbp), %xmm1
pcmpeqb 0x30(%rsp), %xmm1
pcmpeqb 0x20(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
xorl %r15d, %r15d
cmpl $0xffff, %eax # imm = 0xFFFF
sete %cl
setne %r15b
leal (%r15,%r15,4), %eax
cmpl $0x0, 0x14(%rsp)
je 0x245f3
movq 0x20(%rsp), %rdx
xorq (%r13,%rbp), %rdx
movq 0x28(%rsp), %rsi
xorq 0x8(%r13,%rbp), %rsi
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %r8
xorq 0x10(%r13,%rbp), %r8
orq %rdx, %r8
xorq 0x18(%r13,%rbp), %rdi
orq %rsi, %rdi
orq %r8, %rdi
leaq 0x1f0(%rsp), %r13
jne 0x2468a
leaq 0xa208(%rip), %rdi # 0x2e886
callq 0x9060
movb $0x1, %cl
xorl %r15d, %r15d
xorl %eax, %eax
testb %cl, %cl
je 0x246bb
incl %r12d
cmpl $0x6, %r12d
jne 0x244f0
cmpl $0x0, 0x14(%rsp)
je 0x246ac
movl $0xa, %edi
callq 0x9040
leaq 0x1f0(%rsp), %rdi
callq 0x22060
xorl %eax, %eax
cmpl $0x5, %eax
je 0x246cc
testl %eax, %eax
jne 0x246f6
xorl %r15d, %r15d
jmp 0x246cc
movl %eax, %r15d
cmpl $0x0, 0x14(%rsp)
je 0x246e4
testl %r15d, %r15d
je 0x246e4
leaq 0xe5d1(%rip), %rdi # 0x32cb0
callq 0x9060
leaq 0xd0(%rsp), %rdi
movl $0x120, %esi # imm = 0x120
callq 0x15804
movl %r15d, %eax
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r15d
jmp 0x246cc
nop
| /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 %%xmm1, %%xmm0 \n\t" // round 0
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // normal rounds = nr - 1
"test %2, %2 \n\t" // mode?
"jz 2f \n\t" // 0 = decrypt
"1: \n\t" // encryption loop
"movdqu (%1), %%xmm1 \n\t" // load round key
AESENC xmm1_xmm0 "\n\t" // do round
"add $16, %1 \n\t" // point to next round key
"subl $1, %0 \n\t" // loop
"jnz 1b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
AESENCLAST xmm1_xmm0 "\n\t" // last round
"jmp 3f \n\t"
"2: \n\t" // decryption loop
"movdqu (%1), %%xmm1 \n\t"
AESDEC xmm1_xmm0 "\n\t" // do round
"add $16, %1 \n\t"
"subl $1, %0 \n\t"
"jnz 2b \n\t"
"movdqu (%1), %%xmm1 \n\t" // load round key
AESDECLAST xmm1_xmm0 "\n\t" // last round
"3: \n\t"
"movdqu %%xmm0, (%4) \n\t" // export output
:
: "r" (ctx->nr), "r" (ctx->rk), "r" (mode), "r" (input), "r" (output)
: "memory", "cc", "xmm0", "xmm1" );
return( 0 );
} | 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), %xmm1
aesdec %xmm1, %xmm0
addq $0x10, %rdi
subl $0x1, %eax
jne 0x24779
movdqu (%rdi), %xmm1
aesdeclast %xmm1, %xmm0
movdqu %xmm0, (%rcx)
xorl %eax, %eax
retq
| /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_TOO_SMALL );
(*p) -= len;
MBEDTLS_MPI_CHK( mbedtls_mpi_write_binary( X, *p, len ) );
// DER format assumes 2s complement for numbers, so the leftmost bit
// should be 0 for positive numbers and 1 for negative numbers.
//
if( X->s ==1 && **p & 0x80 )
{
if( *p - start < 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
*--(*p) = 0x00;
len += 1;
}
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_INTEGER ) );
ret = (int) len;
cleanup:
return( ret );
} | 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)
movq %r12, %rdi
movq %rbx, %rdx
callq 0xac52
testl %eax, %eax
je 0x24d99
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%r12)
jne 0x24dc1
movq (%r14), %rax
cmpb $0x0, (%rax)
jns 0x24dc1
movq %rax, %rcx
subq %r15, %rcx
testq %rcx, %rcx
jle 0x24d8e
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0x0, -0x1(%rax)
incq %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x24b7c
testl %eax, %eax
js 0x24d8c
movq (%r14), %rdx
movq %rdx, %rcx
subq %r15, %rcx
testq %rcx, %rcx
jle 0x24df3
leaq -0x1(%rdx), %rsi
movq %rsi, (%r14)
movb $0x2, -0x1(%rdx)
movl $0x1, %ebp
jmp 0x24df8
movl $0xffffff94, %ebp # imm = 0xFFFFFF94
testq %rcx, %rcx
jle 0x24d8e
addl %ebp, %ebx
addl %ebx, %eax
jmp 0x24d8c
| /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 char *) oid, oid_len ) );
MBEDTLS_ASN1_CHK_ADD( len , mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len , mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_OID ) );
return( (int) len );
} | 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, %rdx
callq 0x9180
movl %r12d, %ebx
testl %ebx, %ebx
js 0x24ee0
movl %ebx, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x24b7c
testl %eax, %eax
js 0x24eda
movq (%r14), %rdx
movq %rdx, %rcx
subq %r15, %rcx
testq %rcx, %rcx
jle 0x24ecc
leaq -0x1(%rdx), %rsi
movq %rsi, (%r14)
movb $0x6, -0x1(%rdx)
movl $0x1, %edx
jmp 0x24ed1
movl $0xffffff94, %edx # imm = 0xFFFFFF94
testq %rcx, %rcx
jle 0x24ede
addl %ebx, %eax
addl %edx, %eax
movl %eax, %ebx
jmp 0x24ee0
movl %edx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BOOLEAN ) );
return( (int) len );
} | 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(%rax)
movl $0x1, %eax
jmp 0x25004
movl $0xffffff94, %eax # imm = 0xFFFFFF94
retq
movl $0xffffff94, %eax # imm = 0xFFFFFF94
testq %rcx, %rcx
jle 0x24ffe
movq (%rdi), %rdx
movq %rdx, %rcx
subq %rsi, %rcx
testq %rcx, %rcx
jle 0x25029
leaq -0x1(%rdx), %rsi
movq %rsi, (%rdi)
movb $0x1, -0x1(%rdx)
movl $0x1, %edx
jmp 0x2502e
movl $0xffffff94, %edx # imm = 0xFFFFFF94
testq %rcx, %rcx
jle 0x25038
addl %edx, %eax
incl %eax
retq
movl %edx, %eax
retq
| /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 ) - bits;
if( *p < start || (size_t)( *p - start ) < byte_len + 1 )
return( MBEDTLS_ERR_ASN1_BUF_TOO_SMALL );
len = byte_len + 1;
/* Write the bitstring. Ensure the unused bits are zeroed */
if( byte_len > 0 )
{
byte_len--;
*--( *p ) = buf[byte_len] & ~( ( 0x1 << unused_bits ) - 1 );
( *p ) -= byte_len;
memcpy( *p, buf, byte_len );
}
/* Write unused bits */
*--( *p ) = (unsigned char)unused_bits;
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_len( p, start, len ) );
MBEDTLS_ASN1_CHK_ADD( len, mbedtls_asn1_write_tag( p, start, MBEDTLS_ASN1_BIT_STRING ) );
return( (int) len );
} | 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
leaq 0x1(%r8), %r14
cmpq $0x8, %rdi
jb 0x252a9
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl %r12d, %ecx
shll %cl, %edi
andb -0x1(%rdx,%r8), %dil
leaq -0x1(%r8), %rax
leaq -0x1(%rsi), %rcx
movq %rcx, (%rbx)
movb %dil, -0x1(%rsi)
movq (%rbx), %rdi
subq %r8, %rdi
incq %rdi
movq %rdi, (%rbx)
movq %rdx, %rsi
movq %rax, %rdx
callq 0x9180
movq (%rbx), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%rbx)
movb %r12b, -0x1(%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x24b7c
movl %eax, %ecx
testl %eax, %eax
js 0x252fb
movq (%rbx), %rax
movq %rax, %rdx
subq %r15, %rdx
testq %rdx, %rdx
jle 0x252eb
leaq -0x1(%rax), %rsi
movq %rsi, (%rbx)
movb $0x3, -0x1(%rax)
movl $0x1, %eax
jmp 0x252f0
movl $0xffffff94, %eax # imm = 0xFFFFFF94
testq %rdx, %rdx
jle 0x252fd
addl %eax, %r14d
addl %r14d, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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_context *) p_rng;
size_t md_len = mbedtls_md_get_size( ctx->md_ctx.md_info );
size_t left = out_len;
unsigned char *out = output;
/* II. Check request length */
if( out_len > MBEDTLS_HMAC_DRBG_MAX_REQUEST )
return( MBEDTLS_ERR_HMAC_DRBG_REQUEST_TOO_BIG );
/* III. Check input length */
if( add_len > MBEDTLS_HMAC_DRBG_MAX_INPUT )
return( MBEDTLS_ERR_HMAC_DRBG_INPUT_TOO_BIG );
/* 1. (aka VII and IX) Check reseed counter and PR */
if( ctx->f_entropy != NULL && /* For no-reseeding instances */
( ctx->prediction_resistance == MBEDTLS_HMAC_DRBG_PR_ON ||
ctx->reseed_counter > ctx->reseed_interval ) )
{
if( ( ret = mbedtls_hmac_drbg_reseed( ctx, additional, add_len ) ) != 0 )
return( ret );
add_len = 0; /* VII.4 */
}
/* 2. Use additional data if any */
if( additional != NULL && add_len != 0 )
{
if( ( ret = mbedtls_hmac_drbg_update_ret( ctx,
additional, add_len ) ) != 0 )
goto exit;
}
/* 3, 4, 5. Generate bytes */
while( left != 0 )
{
size_t use_len = left > md_len ? md_len : left;
if( ( ret = mbedtls_md_hmac_reset( &ctx->md_ctx ) ) != 0 )
goto exit;
if( ( ret = mbedtls_md_hmac_update( &ctx->md_ctx,
ctx->V, md_len ) ) != 0 )
goto exit;
if( ( ret = mbedtls_md_hmac_finish( &ctx->md_ctx, ctx->V ) ) != 0 )
goto exit;
memcpy( out, ctx->V, use_len );
out += use_len;
left -= use_len;
}
/* 6. Update */
if( ( ret = mbedtls_hmac_drbg_update_ret( ctx,
additional, add_len ) ) != 0 )
goto exit;
/* 7. Update reseed counter */
ctx->reseed_counter++;
exit:
/* 8. Done */
return( ret );
} | 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 $0xfffffffb, %r14d # imm = 0xFFFFFFFB
cmpq $0x100, (%rsp) # imm = 0x100
ja 0x264e6
movl %eax, %ebp
cmpq $0x0, 0x70(%rbx)
je 0x2642b
cmpl $0x1, 0x68(%rbx)
movq 0x8(%rsp), %r12
je 0x26408
movl 0x58(%rbx), %eax
cmpl 0x6c(%rbx), %eax
jle 0x26430
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
xorl %ecx, %ecx
callq 0x261c7
testl %eax, %eax
jne 0x264e3
movq $0x0, (%rsp)
jmp 0x26430
movq 0x8(%rsp), %r12
testq %r12, %r12
sete %al
cmpq $0x0, (%rsp)
sete %cl
orb %al, %cl
jne 0x26459
movq %rbx, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x2601b
testl %eax, %eax
jne 0x264e3
movzbl %bpl, %r12d
leaq 0x18(%rbx), %r13
testq %r15, %r15
je 0x264ce
cmpq %r12, %r15
movq %r12, %rbp
cmovbq %r15, %rbp
movq %rbx, %rdi
callq 0x2714f
testl %eax, %eax
jne 0x2648e
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2709d
testl %eax, %eax
je 0x26499
movl %eax, %r14d
xorl %ecx, %ecx
testb %cl, %cl
jne 0x26461
jmp 0x264e6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x270b9
xorl %r14d, %r14d
testl %eax, %eax
je 0x264b2
xorl %ecx, %ecx
movl %eax, %r14d
jmp 0x26493
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x9180
addq %rbp, 0x10(%rsp)
subq %rbp, %r15
movb $0x1, %cl
jmp 0x26493
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2601b
testl %eax, %eax
je 0x264f8
movl %eax, %r14d
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incl 0x58(%rbx)
xorl %r14d, %r14d
jmp 0x264e6
| /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->md_info->type )
{
#if defined(MBEDTLS_MD2_C)
case MBEDTLS_MD_MD2:
mbedtls_md2_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_MD4_C)
case MBEDTLS_MD_MD4:
mbedtls_md4_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
mbedtls_md5_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
mbedtls_ripemd160_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
mbedtls_sha1_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA256_C)
case MBEDTLS_MD_SHA224:
case MBEDTLS_MD_SHA256:
mbedtls_sha256_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA512_C)
#if !defined(MBEDTLS_SHA512_NO_SHA384)
case MBEDTLS_MD_SHA384:
#endif
case MBEDTLS_MD_SHA512:
mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
break;
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
return( 0 );
} | 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), %rax # 0x34c4c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x2a95b
jmp 0x26b90
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1a56c
jmp 0x26b90
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x29043
jmp 0x26b90
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x272f7
jmp 0x26b90
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq 0x1905b
xorl %eax, %eax
addq $0x8, %rsp
retq
| /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_ctx, output ) );
#endif
#if defined(MBEDTLS_MD4_C)
case MBEDTLS_MD_MD4:
return( mbedtls_md4_finish_ret( ctx->md_ctx, output ) );
#endif
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
return( mbedtls_md5_finish_ret( ctx->md_ctx, output ) );
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
return( mbedtls_ripemd160_finish_ret( ctx->md_ctx, output ) );
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
return( mbedtls_sha1_finish_ret( ctx->md_ctx, output ) );
#endif
#if defined(MBEDTLS_SHA256_C)
case MBEDTLS_MD_SHA224:
return( mbedtls_sha256_finish_ret( ctx->md_ctx, output ) );
case MBEDTLS_MD_SHA256:
return( mbedtls_sha256_finish_ret( ctx->md_ctx, output ) );
#endif
#if defined(MBEDTLS_SHA512_C)
#if !defined(MBEDTLS_SHA512_NO_SHA384)
case MBEDTLS_MD_SHA384:
return( mbedtls_sha512_finish_ret( ctx->md_ctx, output ) );
#endif
case MBEDTLS_MD_SHA512:
return( mbedtls_sha512_finish_ret( ctx->md_ctx, output ) );
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
} | 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
movq 0x8(%rdi), %rdi
jmp 0x1ac22
movq 0x8(%rdi), %rdi
jmp 0x27bb6
movq 0x8(%rdi), %rdi
jmp 0x1a20c
movq 0x8(%rdi), %rdi
jmp 0x2a692
| /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;
fill = 64 - left;
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
if( ( ret = mbedtls_internal_md5_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 64 )
{
if( ( ret = mbedtls_internal_md5_process( ctx, input ) ) != 0 )
return( ret );
input += 64;
ilen -= 64;
}
if( ilen > 0 )
{
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
return( 0 );
} | 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, %r12d
subq %rax, %r12
movq %rdx, %r15
subq %r12, %r15
jae 0x27b40
movq %rdx, %r15
movl %eax, %ebp
jmp 0x27b67
movq %rdx, %r15
jmp 0x27b67
leaq 0x18(%r14), %r13
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x9180
movq %r14, %rdi
movq %r13, %rsi
callq 0x27333
addq %r12, %rbx
cmpq $0x40, %r15
jb 0x27b86
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27333
addq $0x40, %rbx
addq $-0x40, %r15
cmpq $0x3f, %r15
ja 0x27b6d
testq %r15, %r15
je 0x27ba0
movl %ebp, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
| /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 )
goto fail;
if( memcmp( md5sum, md5_test_sum[i], 16 ) != 0 )
{
ret = 1;
goto fail;
}
if( verbose != 0 )
mbedtls_printf( "passed\n" );
}
if( verbose != 0 )
mbedtls_printf( "\n" );
return( 0 );
fail:
if( verbose != 0 )
mbedtls_printf( "failed\n" );
return( ret );
} | 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, %eax
callq 0x90c0
leaq 0xd1fd(%rip), %rax # 0x34f90
movq (%r13,%rax), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x27cce
movdqu (%r12), %xmm0
pcmpeqb (%rsp), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jne 0x27def
testl %ebx, %ebx
je 0x27dc9
leaq 0x6ac2(%rip), %rdi # 0x2e886
callq 0x9060
incl %ebp
addq $0x10, %r12
addq $0x8, %r13
addq $0x51, %r14
cmpq $0x38, %r13
jne 0x27d78
xorl %ebp, %ebp
testl %ebx, %ebx
je 0x27e04
movl $0xa, %edi
callq 0x9040
jmp 0x27e04
movl $0x1, %ebp
testl %ebx, %ebx
je 0x27e04
leaq 0xaeb1(%rip), %rdi # 0x32cb0
callq 0x9060
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| /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_init( &des_ctx );
if( ( ret = pem_pbkdf1( des_key, 8, des_iv, pwd, pwdlen ) ) != 0 )
goto exit;
if( ( ret = mbedtls_des_setkey_dec( &des_ctx, des_key ) ) != 0 )
goto exit;
ret = mbedtls_des_crypt_cbc( &des_ctx, MBEDTLS_DES_DECRYPT, buflen,
des_iv, buf, buf );
exit:
mbedtls_des_free( &des_ctx );
mbedtls_platform_zeroize( des_key, 8 );
return( ret );
} | 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
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x2ca24
testl %eax, %eax
jne 0x28c1a
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %rbx, %r9
callq 0x2cea0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2c507
movq %rsp, %rdi
movl $0x8, %esi
callq 0x15804
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 );
GET_UINT32_LE( X[ 3], data, 12 );
GET_UINT32_LE( X[ 4], data, 16 );
GET_UINT32_LE( X[ 5], data, 20 );
GET_UINT32_LE( X[ 6], data, 24 );
GET_UINT32_LE( X[ 7], data, 28 );
GET_UINT32_LE( X[ 8], data, 32 );
GET_UINT32_LE( X[ 9], data, 36 );
GET_UINT32_LE( X[10], data, 40 );
GET_UINT32_LE( X[11], data, 44 );
GET_UINT32_LE( X[12], data, 48 );
GET_UINT32_LE( X[13], data, 52 );
GET_UINT32_LE( X[14], data, 56 );
GET_UINT32_LE( X[15], data, 60 );
A = Ap = ctx->state[0];
B = Bp = ctx->state[1];
C = Cp = ctx->state[2];
D = Dp = ctx->state[3];
E = Ep = ctx->state[4];
#define F1( x, y, z ) ( (x) ^ (y) ^ (z) )
#define F2( x, y, z ) ( ( (x) & (y) ) | ( ~(x) & (z) ) )
#define F3( x, y, z ) ( ( (x) | ~(y) ) ^ (z) )
#define F4( x, y, z ) ( ( (x) & (z) ) | ( (y) & ~(z) ) )
#define F5( x, y, z ) ( (x) ^ ( (y) | ~(z) ) )
#define S( x, n ) ( ( (x) << (n) ) | ( (x) >> (32 - (n)) ) )
#define P( a, b, c, d, e, r, s, f, k ) \
do \
{ \
(a) += f( (b), (c), (d) ) + X[r] + (k); \
(a) = S( (a), (s) ) + (e); \
(c) = S( (c), 10 ); \
} while( 0 )
#define P2( a, b, c, d, e, r, s, rp, sp ) \
do \
{ \
P( (a), (b), (c), (d), (e), (r), (s), F, K ); \
P( a ## p, b ## p, c ## p, d ## p, e ## p, \
(rp), (sp), Fp, Kp ); \
} while( 0 )
#define F F1
#define K 0x00000000
#define Fp F5
#define Kp 0x50A28BE6
P2( A, B, C, D, E, 0, 11, 5, 8 );
P2( E, A, B, C, D, 1, 14, 14, 9 );
P2( D, E, A, B, C, 2, 15, 7, 9 );
P2( C, D, E, A, B, 3, 12, 0, 11 );
P2( B, C, D, E, A, 4, 5, 9, 13 );
P2( A, B, C, D, E, 5, 8, 2, 15 );
P2( E, A, B, C, D, 6, 7, 11, 15 );
P2( D, E, A, B, C, 7, 9, 4, 5 );
P2( C, D, E, A, B, 8, 11, 13, 7 );
P2( B, C, D, E, A, 9, 13, 6, 7 );
P2( A, B, C, D, E, 10, 14, 15, 8 );
P2( E, A, B, C, D, 11, 15, 8, 11 );
P2( D, E, A, B, C, 12, 6, 1, 14 );
P2( C, D, E, A, B, 13, 7, 10, 14 );
P2( B, C, D, E, A, 14, 9, 3, 12 );
P2( A, B, C, D, E, 15, 8, 12, 6 );
#undef F
#undef K
#undef Fp
#undef Kp
#define F F2
#define K 0x5A827999
#define Fp F4
#define Kp 0x5C4DD124
P2( E, A, B, C, D, 7, 7, 6, 9 );
P2( D, E, A, B, C, 4, 6, 11, 13 );
P2( C, D, E, A, B, 13, 8, 3, 15 );
P2( B, C, D, E, A, 1, 13, 7, 7 );
P2( A, B, C, D, E, 10, 11, 0, 12 );
P2( E, A, B, C, D, 6, 9, 13, 8 );
P2( D, E, A, B, C, 15, 7, 5, 9 );
P2( C, D, E, A, B, 3, 15, 10, 11 );
P2( B, C, D, E, A, 12, 7, 14, 7 );
P2( A, B, C, D, E, 0, 12, 15, 7 );
P2( E, A, B, C, D, 9, 15, 8, 12 );
P2( D, E, A, B, C, 5, 9, 12, 7 );
P2( C, D, E, A, B, 2, 11, 4, 6 );
P2( B, C, D, E, A, 14, 7, 9, 15 );
P2( A, B, C, D, E, 11, 13, 1, 13 );
P2( E, A, B, C, D, 8, 12, 2, 11 );
#undef F
#undef K
#undef Fp
#undef Kp
#define F F3
#define K 0x6ED9EBA1
#define Fp F3
#define Kp 0x6D703EF3
P2( D, E, A, B, C, 3, 11, 15, 9 );
P2( C, D, E, A, B, 10, 13, 5, 7 );
P2( B, C, D, E, A, 14, 6, 1, 15 );
P2( A, B, C, D, E, 4, 7, 3, 11 );
P2( E, A, B, C, D, 9, 14, 7, 8 );
P2( D, E, A, B, C, 15, 9, 14, 6 );
P2( C, D, E, A, B, 8, 13, 6, 6 );
P2( B, C, D, E, A, 1, 15, 9, 14 );
P2( A, B, C, D, E, 2, 14, 11, 12 );
P2( E, A, B, C, D, 7, 8, 8, 13 );
P2( D, E, A, B, C, 0, 13, 12, 5 );
P2( C, D, E, A, B, 6, 6, 2, 14 );
P2( B, C, D, E, A, 13, 5, 10, 13 );
P2( A, B, C, D, E, 11, 12, 0, 13 );
P2( E, A, B, C, D, 5, 7, 4, 7 );
P2( D, E, A, B, C, 12, 5, 13, 5 );
#undef F
#undef K
#undef Fp
#undef Kp
#define F F4
#define K 0x8F1BBCDC
#define Fp F2
#define Kp 0x7A6D76E9
P2( C, D, E, A, B, 1, 11, 8, 15 );
P2( B, C, D, E, A, 9, 12, 6, 5 );
P2( A, B, C, D, E, 11, 14, 4, 8 );
P2( E, A, B, C, D, 10, 15, 1, 11 );
P2( D, E, A, B, C, 0, 14, 3, 14 );
P2( C, D, E, A, B, 8, 15, 11, 14 );
P2( B, C, D, E, A, 12, 9, 15, 6 );
P2( A, B, C, D, E, 4, 8, 0, 14 );
P2( E, A, B, C, D, 13, 9, 5, 6 );
P2( D, E, A, B, C, 3, 14, 12, 9 );
P2( C, D, E, A, B, 7, 5, 2, 12 );
P2( B, C, D, E, A, 15, 6, 13, 9 );
P2( A, B, C, D, E, 14, 8, 9, 12 );
P2( E, A, B, C, D, 5, 6, 7, 5 );
P2( D, E, A, B, C, 6, 5, 10, 15 );
P2( C, D, E, A, B, 2, 12, 14, 8 );
#undef F
#undef K
#undef Fp
#undef Kp
#define F F5
#define K 0xA953FD4E
#define Fp F1
#define Kp 0x00000000
P2( B, C, D, E, A, 4, 9, 12, 8 );
P2( A, B, C, D, E, 0, 15, 15, 5 );
P2( E, A, B, C, D, 5, 5, 10, 12 );
P2( D, E, A, B, C, 9, 11, 4, 9 );
P2( C, D, E, A, B, 7, 6, 1, 12 );
P2( B, C, D, E, A, 12, 8, 5, 5 );
P2( A, B, C, D, E, 2, 13, 8, 14 );
P2( E, A, B, C, D, 10, 12, 7, 6 );
P2( D, E, A, B, C, 14, 5, 6, 8 );
P2( C, D, E, A, B, 1, 12, 2, 13 );
P2( B, C, D, E, A, 3, 13, 13, 6 );
P2( A, B, C, D, E, 8, 14, 14, 5 );
P2( E, A, B, C, D, 11, 11, 0, 15 );
P2( D, E, A, B, C, 6, 8, 3, 13 );
P2( C, D, E, A, B, 15, 5, 9, 11 );
P2( B, C, D, E, A, 13, 6, 11, 11 );
#undef F
#undef K
#undef Fp
#undef Kp
C = ctx->state[1] + C + Dp;
ctx->state[1] = ctx->state[2] + D + Ep;
ctx->state[2] = ctx->state[3] + E + Ap;
ctx->state[3] = ctx->state[4] + A + Bp;
ctx->state[4] = ctx->state[0] + B + Cp;
ctx->state[0] = C;
return( 0 );
} | 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 0x18(%rdi), %edx
movl %eax, %edi
movl %eax, -0x1c(%rsp)
movl %eax, %r10d
xorl %r8d, %r10d
xorl %r9d, %r10d
movq %rcx, -0x8(%rsp)
addl %ecx, %r10d
addl %r11d, %r10d
roll $0xb, %r10d
addl %edx, %r10d
movl %edi, %r11d
roll $0xa, %r11d
movl %r9d, %eax
notl %eax
orl %edi, %eax
xorl %r8d, %eax
addl %ecx, %ebx
movl $0x50a28be6, %ecx # imm = 0x50A28BE6
addl %ecx, %ebx
addl %eax, %ebx
movl %r11d, %ebp
xorl %r8d, %ebp
xorl %r10d, %ebp
addl %edx, %ebp
addl %r14d, %ebp
roll $0x8, %ebx
roll $0xe, %ebp
addl %edx, %ebx
movq %rdx, -0x10(%rsp)
movl %r11d, %eax
notl %eax
movl %r8d, -0x20(%rsp)
orl %r8d, %eax
xorl %ebx, %eax
movl 0x38(%rsi), %ecx
movq %rcx, -0x40(%rsp)
leal (%rcx,%rdx), %r15d
movl $0x50a28be6, %edx # imm = 0x50A28BE6
addl %edx, %r15d
addl %eax, %r15d
movl %r8d, %r14d
roll $0xa, %r14d
addl %r9d, %ebp
roll $0x9, %r15d
movl %r10d, %r12d
xorl %r14d, %r12d
xorl %ebp, %r12d
movl 0x8(%rsi), %eax
movq %rax, -0x28(%rsp)
addl %r9d, %eax
addl %eax, %r12d
addl %r9d, %r15d
movq %r9, -0x18(%rsp)
movl %r14d, %eax
notl %eax
orl %ebx, %eax
xorl %r15d, %eax
movl 0x1c(%rsi), %ecx
movq %rcx, -0x30(%rsp)
leal (%rcx,%r9), %r13d
addl %edx, %r13d
movl $0x50a28be6, %ecx # imm = 0x50A28BE6
addl %eax, %r13d
roll $0xf, %r12d
addl %r11d, %r12d
roll $0xa, %r10d
movl %ebp, %edi
xorl %r10d, %edi
xorl %r12d, %edi
movl 0xc(%rsi), %eax
movq %rax, -0x38(%rsp)
addl %r11d, %edi
addl %eax, %edi
roll $0x9, %r13d
addl %r11d, %r13d
roll $0xa, %ebx
movl %ebx, %edx
notl %edx
orl %r15d, %edx
xorl %r13d, %edx
addl -0x48(%rsp), %r11d
addl %ecx, %r11d
addl %edx, %r11d
roll $0xc, %edi
addl %r14d, %edi
roll $0xa, %ebp
movl %r12d, %edx
xorl %ebp, %edx
xorl %edi, %edx
movl 0x10(%rsi), %ecx
movq %rcx, -0x50(%rsp)
addl %r14d, %edx
addl %ecx, %edx
roll $0xb, %r11d
roll $0xa, %r15d
addl %r14d, %r11d
movl %r15d, %r8d
notl %r8d
orl %r13d, %r8d
xorl %r11d, %r8d
movl 0x24(%rsi), %eax
movl %eax, -0x6c(%rsp)
addl %eax, %r14d
movl $0x50a28be6, %eax # imm = 0x50A28BE6
addl %eax, %r14d
addl %r8d, %r14d
roll $0x5, %edx
addl %r10d, %edx
roll $0xa, %r12d
roll $0xd, %r14d
movl %edi, %r8d
xorl %r12d, %r8d
xorl %edx, %r8d
addl -0x60(%rsp), %r10d
addl %r8d, %r10d
addl %ebx, %r14d
roll $0xa, %r13d
roll $0x8, %r10d
movl %r13d, %r8d
notl %r8d
orl %r11d, %r8d
xorl %r14d, %r8d
addl -0x28(%rsp), %ebx
addl %eax, %ebx
addl %r8d, %ebx
addl %ebp, %r10d
roll $0xa, %edi
movl %edx, %r8d
xorl %edi, %r8d
xorl %r10d, %r8d
movl 0x18(%rsi), %eax
addl %eax, %ebp
movl %eax, %r9d
movl %eax, -0x7c(%rsp)
addl %r8d, %ebp
roll $0xf, %ebx
roll $0xa, %r11d
roll $0x7, %ebp
addl %r15d, %ebx
movl %r11d, %r8d
notl %r8d
orl %r14d, %r8d
xorl %ebx, %r8d
movl 0x2c(%rsi), %eax
movl %eax, -0x70(%rsp)
addl %eax, %r15d
movl $0x50a28be6, %eax # imm = 0x50A28BE6
addl %eax, %r15d
addl %r8d, %r15d
addl %r12d, %ebp
roll $0xa, %edx
movl %r10d, %r8d
xorl %edx, %r8d
xorl %ebp, %r8d
addl -0x30(%rsp), %r12d
addl %r8d, %r12d
roll $0xf, %r15d
addl %r13d, %r15d
roll $0xa, %r14d
movl %r14d, %r8d
notl %r8d
orl %ebx, %r8d
xorl %r15d, %r8d
addl %ecx, %r13d
addl %eax, %r13d
addl %r8d, %r13d
roll $0x9, %r12d
addl %edi, %r12d
roll $0xa, %r10d
movl %ebp, %r8d
xorl %r10d, %r8d
xorl %r12d, %r8d
movl 0x20(%rsi), %ecx
addl %ecx, %edi
movl %ecx, -0x74(%rsp)
addl %r8d, %edi
roll $0x5, %r13d
roll $0xa, %ebx
addl %r11d, %r13d
movl %ebx, %r8d
notl %r8d
orl %r15d, %r8d
xorl %r13d, %r8d
movl 0x34(%rsi), %eax
movl %eax, -0x78(%rsp)
addl %eax, %r11d
movl $0x50a28be6, %eax # imm = 0x50A28BE6
addl %eax, %r11d
addl %r8d, %r11d
roll $0xb, %edi
addl %edx, %edi
roll $0xa, %ebp
roll $0x7, %r11d
movl %r12d, %r8d
xorl %ebp, %r8d
xorl %edi, %r8d
addl -0x6c(%rsp), %edx
addl %r8d, %edx
addl %r14d, %r11d
roll $0xa, %r15d
roll $0xd, %edx
movl %r15d, %r8d
notl %r8d
orl %r13d, %r8d
xorl %r11d, %r8d
addl %r9d, %r14d
addl %eax, %r14d
addl %r8d, %r14d
addl %r10d, %edx
roll $0xa, %r12d
movl %edi, %r8d
xorl %r12d, %r8d
xorl %edx, %r8d
movl 0x28(%rsi), %eax
addl %eax, %r10d
movl %eax, %r9d
movl %eax, -0x68(%rsp)
addl %r8d, %r10d
roll $0x7, %r14d
roll $0xa, %r13d
roll $0xe, %r10d
addl %ebx, %r14d
movl %r13d, %r8d
notl %r8d
orl %r11d, %r8d
xorl %r14d, %r8d
movl 0x3c(%rsi), %eax
movl %eax, -0x80(%rsp)
addl %eax, %ebx
movl $0x50a28be6, %eax # imm = 0x50A28BE6
addl %eax, %ebx
addl %r8d, %ebx
addl %ebp, %r10d
roll $0xa, %edi
movl %edx, %r8d
xorl %edi, %r8d
xorl %r10d, %r8d
addl -0x70(%rsp), %ebp
addl %r8d, %ebp
roll $0x8, %ebx
addl %r15d, %ebx
roll $0xa, %r11d
movl %r11d, %r8d
notl %r8d
orl %r14d, %r8d
xorl %ebx, %r8d
addl %ecx, %r15d
addl %eax, %r15d
addl %r8d, %r15d
movl 0x30(%rsi), %r8d
roll $0xf, %ebp
addl %r12d, %ebp
roll $0xa, %edx
movl %r10d, %esi
xorl %edx, %esi
xorl %ebp, %esi
addl %r8d, %r12d
movl %r8d, -0x64(%rsp)
addl %esi, %r12d
roll $0xb, %r15d
roll $0xa, %r14d
addl %r13d, %r15d
movl %r14d, %esi
notl %esi
orl %ebx, %esi
xorl %r15d, %esi
addl -0x58(%rsp), %r13d
addl %eax, %r13d
addl %esi, %r13d
roll $0x6, %r12d
roll $0xa, %r10d
addl %edi, %r12d
movl %ebp, %esi
xorl %r10d, %esi
xorl %r12d, %esi
addl -0x78(%rsp), %edi
addl %esi, %edi
roll $0xe, %r13d
addl %r11d, %r13d
roll $0xa, %ebx
movl %ebx, %esi
notl %esi
orl %r15d, %esi
xorl %r13d, %esi
addl %r9d, %r11d
addl %eax, %r11d
addl %esi, %r11d
roll $0x7, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %r12d, %esi
xorl %ebp, %esi
xorl %edi, %esi
addl -0x40(%rsp), %edx
addl %esi, %edx
roll $0xe, %r11d
roll $0xa, %r15d
addl %r14d, %r11d
movl %r15d, %esi
notl %esi
orl %r13d, %esi
xorl %r11d, %esi
movq -0x38(%rsp), %rcx
addl %ecx, %r14d
addl %eax, %r14d
addl %esi, %r14d
roll $0x9, %edx
roll $0xa, %r12d
addl %r10d, %edx
movl %edi, %esi
xorl %r12d, %esi
xorl %edx, %esi
addl -0x80(%rsp), %r10d
addl %esi, %r10d
roll $0xc, %r14d
addl %ebx, %r14d
roll $0xa, %r13d
addl %r8d, %ebx
addl %eax, %ebx
movl %r13d, %esi
notl %esi
orl %r11d, %esi
xorl %r14d, %esi
addl %esi, %ebx
roll $0x8, %r10d
roll $0xa, %edi
roll $0x6, %ebx
addl %ebp, %r10d
movl %edx, %esi
xorl %edi, %esi
andl %r10d, %esi
xorl %edi, %esi
movq -0x30(%rsp), %rax
addl %eax, %ebp
movl $0x5a827999, %r9d # imm = 0x5A827999
addl %r9d, %ebp
addl %esi, %ebp
addl %r15d, %ebx
roll $0xa, %r11d
movl %ebx, %r9d
xorl %r14d, %r9d
andl %r11d, %r9d
xorl %r14d, %r9d
addl -0x7c(%rsp), %r15d
movl $0x5c4dd124, %r8d # imm = 0x5C4DD124
addl %r8d, %r15d
addl %r9d, %r15d
roll $0x7, %ebp
roll $0xa, %edx
addl %r12d, %ebp
movl %r10d, %r9d
xorl %edx, %r9d
andl %ebp, %r9d
xorl %edx, %r9d
addl -0x50(%rsp), %r12d
movl $0x5a827999, %r8d # imm = 0x5A827999
addl %r8d, %r12d
addl %r9d, %r12d
roll $0x9, %r15d
roll $0xa, %r14d
addl %r13d, %r15d
movl %r15d, %r9d
xorl %ebx, %r9d
andl %r14d, %r9d
xorl %ebx, %r9d
addl -0x70(%rsp), %r13d
movl $0x5c4dd124, %esi # imm = 0x5C4DD124
addl %esi, %r13d
addl %r9d, %r13d
roll $0x6, %r12d
roll $0xa, %r10d
addl %edi, %r12d
movl %ebp, %r9d
xorl %r10d, %r9d
andl %r12d, %r9d
xorl %r10d, %r9d
addl -0x78(%rsp), %edi
addl %r8d, %edi
addl %r9d, %edi
roll $0xd, %r13d
roll $0xa, %ebx
addl %r11d, %r13d
movl %r13d, %r9d
xorl %r15d, %r9d
andl %ebx, %r9d
xorl %r15d, %r9d
addl %ecx, %r11d
addl %esi, %r11d
addl %r9d, %r11d
roll $0x8, %edi
roll $0xa, %ebp
addl %edx, %edi
movl %r12d, %r9d
xorl %ebp, %r9d
andl %edi, %r9d
xorl %ebp, %r9d
addl -0x58(%rsp), %edx
addl %r8d, %edx
addl %r9d, %edx
roll $0xf, %r11d
roll $0xa, %r15d
addl %r14d, %r11d
movl %r11d, %r9d
xorl %r13d, %r9d
andl %r15d, %r9d
xorl %r13d, %r9d
addl %eax, %r14d
movl $0x5c4dd124, %eax # imm = 0x5C4DD124
addl %eax, %r14d
addl %r9d, %r14d
roll $0xd, %edx
roll $0xa, %r12d
addl %r10d, %edx
movl %edi, %r9d
xorl %r12d, %r9d
andl %edx, %r9d
xorl %r12d, %r9d
movl -0x68(%rsp), %ecx
addl %ecx, %r10d
addl %r8d, %r10d
movl $0x5a827999, %esi # imm = 0x5A827999
addl %r9d, %r10d
roll $0x7, %r14d
roll $0xa, %r13d
addl %ebx, %r14d
movl %r14d, %r9d
xorl %r11d, %r9d
andl %r13d, %r9d
xorl %r11d, %r9d
movq -0x48(%rsp), %r8
addl %r8d, %ebx
addl %eax, %ebx
addl %r9d, %ebx
roll $0xb, %r10d
roll $0xa, %edi
addl %ebp, %r10d
movl %edx, %r9d
xorl %edi, %r9d
andl %r10d, %r9d
xorl %edi, %r9d
addl -0x7c(%rsp), %ebp
addl %esi, %ebp
addl %r9d, %ebp
roll $0xc, %ebx
roll $0xa, %r11d
addl %r15d, %ebx
movl %ebx, %r9d
xorl %r14d, %r9d
andl %r11d, %r9d
xorl %r14d, %r9d
addl -0x78(%rsp), %r15d
addl %eax, %r15d
addl %r9d, %r15d
roll $0x9, %ebp
roll $0xa, %edx
addl %r12d, %ebp
movl %r10d, %r9d
xorl %edx, %r9d
andl %ebp, %r9d
xorl %edx, %r9d
movl -0x80(%rsp), %eax
addl %eax, %r12d
addl %esi, %r12d
addl %r9d, %r12d
roll $0x8, %r15d
roll $0xa, %r14d
addl %r13d, %r15d
movl %r15d, %r9d
xorl %ebx, %r9d
andl %r14d, %r9d
xorl %ebx, %r9d
addl -0x60(%rsp), %r13d
movl $0x5c4dd124, %esi # imm = 0x5C4DD124
addl %esi, %r13d
addl %r9d, %r13d
roll $0x7, %r12d
roll $0xa, %r10d
addl %edi, %r12d
movl %ebp, %r9d
xorl %r10d, %r9d
andl %r12d, %r9d
xorl %r10d, %r9d
addl -0x38(%rsp), %edi
movl $0x5a827999, %esi # imm = 0x5A827999
addl %esi, %edi
addl %r9d, %edi
roll $0x9, %r13d
roll $0xa, %ebx
addl %r11d, %r13d
movl %r13d, %r9d
xorl %r15d, %r9d
andl %ebx, %r9d
xorl %r15d, %r9d
addl %ecx, %r11d
movl $0x5c4dd124, %ecx # imm = 0x5C4DD124
addl %ecx, %r11d
addl %r9d, %r11d
roll $0xf, %edi
roll $0xa, %ebp
addl %edx, %edi
movl %r12d, %r9d
xorl %ebp, %r9d
andl %edi, %r9d
xorl %ebp, %r9d
movl -0x64(%rsp), %ecx
addl %ecx, %edx
addl %esi, %edx
addl %r9d, %edx
roll $0xb, %r11d
roll $0xa, %r15d
addl %r14d, %r11d
movl %r11d, %r9d
xorl %r13d, %r9d
andl %r15d, %r9d
xorl %r13d, %r9d
addl -0x40(%rsp), %r14d
movl $0x5c4dd124, %esi # imm = 0x5C4DD124
addl %esi, %r14d
addl %r9d, %r14d
roll $0x7, %edx
roll $0xa, %r12d
addl %r10d, %edx
movl %edi, %r9d
xorl %r12d, %r9d
andl %edx, %r9d
xorl %r12d, %r9d
addl %r8d, %r10d
movl $0x5a827999, %esi # imm = 0x5A827999
addl %esi, %r10d
movl $0x5a827999, %r8d # imm = 0x5A827999
addl %r9d, %r10d
roll $0x7, %r14d
roll $0xa, %r13d
addl %ebx, %r14d
movl %r14d, %r9d
xorl %r11d, %r9d
andl %r13d, %r9d
xorl %r11d, %r9d
addl %eax, %ebx
movl $0x5c4dd124, %eax # imm = 0x5C4DD124
addl %eax, %ebx
movl $0x5c4dd124, %esi # imm = 0x5C4DD124
addl %r9d, %ebx
roll $0xc, %r10d
roll $0xa, %edi
addl %ebp, %r10d
movl %edx, %r9d
xorl %edi, %r9d
andl %r10d, %r9d
xorl %edi, %r9d
movl -0x6c(%rsp), %eax
addl %eax, %ebp
addl %r8d, %ebp
addl %r9d, %ebp
roll $0x7, %ebx
roll $0xa, %r11d
addl %r15d, %ebx
movl %ebx, %r9d
xorl %r14d, %r9d
andl %r11d, %r9d
xorl %r14d, %r9d
addl -0x74(%rsp), %r15d
addl %esi, %r15d
addl %r9d, %r15d
roll $0xf, %ebp
roll $0xa, %edx
addl %r12d, %ebp
movl %r10d, %r9d
xorl %edx, %r9d
andl %ebp, %r9d
xorl %edx, %r9d
addl -0x60(%rsp), %r12d
addl %r8d, %r12d
movl $0x5a827999, %esi # imm = 0x5A827999
addl %r9d, %r12d
roll $0xc, %r15d
roll $0xa, %r14d
addl %r13d, %r15d
movl %r15d, %r9d
xorl %ebx, %r9d
andl %r14d, %r9d
xorl %ebx, %r9d
addl %ecx, %r13d
movl $0x5c4dd124, %ecx # imm = 0x5C4DD124
addl %ecx, %r13d
addl %r9d, %r13d
roll $0x9, %r12d
roll $0xa, %r10d
addl %edi, %r12d
movl %ebp, %r9d
xorl %r10d, %r9d
andl %r12d, %r9d
xorl %r10d, %r9d
movq -0x28(%rsp), %r8
addl %r8d, %edi
addl %esi, %edi
addl %r9d, %edi
roll $0x7, %r13d
roll $0xa, %ebx
addl %r11d, %r13d
movl %r13d, %r9d
xorl %r15d, %r9d
andl %ebx, %r9d
xorl %r15d, %r9d
addl -0x50(%rsp), %r11d
addl %ecx, %r11d
addl %r9d, %r11d
roll $0xb, %edi
roll $0xa, %ebp
addl %edx, %edi
movl %r12d, %r9d
xorl %ebp, %r9d
andl %edi, %r9d
xorl %ebp, %r9d
addl -0x40(%rsp), %edx
addl %esi, %edx
addl %r9d, %edx
roll $0x6, %r11d
roll $0xa, %r15d
addl %r14d, %r11d
movl %r11d, %r9d
xorl %r13d, %r9d
andl %r15d, %r9d
xorl %r13d, %r9d
addl %eax, %r14d
addl %ecx, %r14d
movl $0x5c4dd124, %eax # imm = 0x5C4DD124
addl %r9d, %r14d
roll $0x7, %edx
roll $0xa, %r12d
addl %r10d, %edx
movl %edi, %r9d
xorl %r12d, %r9d
andl %edx, %r9d
xorl %r12d, %r9d
addl -0x70(%rsp), %r10d
addl %esi, %r10d
addl %r9d, %r10d
roll $0xf, %r14d
roll $0xa, %r13d
addl %ebx, %r14d
movl %r14d, %r9d
xorl %r11d, %r9d
andl %r13d, %r9d
xorl %r11d, %r9d
movq -0x58(%rsp), %rsi
addl %esi, %ebx
addl %eax, %ebx
addl %r9d, %ebx
roll $0xd, %r10d
roll $0xa, %edi
addl %ebp, %r10d
movl %r10d, %ecx
andl %edx, %ecx
movl %r10d, %r9d
notl %r9d
movl %edi, %eax
andl %r9d, %eax
orl %ecx, %eax
addl -0x74(%rsp), %ebp
movl $0x5a827999, %ecx # imm = 0x5A827999
addl %ecx, %ebp
roll $0xd, %ebx
addl %eax, %ebp
addl %r15d, %ebx
addl %r8d, %r15d
movl $0x5c4dd124, %eax # imm = 0x5C4DD124
addl %eax, %r15d
roll $0xa, %r11d
roll $0xc, %ebp
movl %ebx, %eax
xorl %r14d, %eax
andl %r11d, %eax
xorl %r14d, %eax
addl %eax, %r15d
addl %r12d, %ebp
roll $0xa, %edx
orl %ebp, %r9d
xorl %edx, %r9d
movq -0x38(%rsp), %r8
addl %r8d, %r12d
movl $0x6ed9eba1, %eax # imm = 0x6ED9EBA1
addl %eax, %r12d
addl %r9d, %r12d
roll $0xb, %r15d
roll $0xa, %r14d
roll $0xb, %r12d
addl %r13d, %r15d
movl %ebx, %eax
notl %eax
orl %r15d, %eax
xorl %r14d, %eax
addl -0x80(%rsp), %r13d
movl $0x6d703ef3, %r9d # imm = 0x6D703EF3
addl %r9d, %r13d
addl %eax, %r13d
addl %edi, %r12d
roll $0xa, %r10d
roll $0x9, %r13d
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %r10d, %eax
addl -0x68(%rsp), %edi
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %edi
addl %eax, %edi
addl %r11d, %r13d
roll $0xa, %ebx
roll $0xd, %edi
movl %r15d, %eax
notl %eax
orl %r13d, %eax
xorl %ebx, %eax
addl -0x60(%rsp), %r11d
addl %r9d, %r11d
addl %eax, %r11d
addl %edx, %edi
roll $0xa, %ebp
roll $0x7, %r11d
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %ebp, %eax
movq -0x40(%rsp), %r9
addl %r9d, %edx
addl %ecx, %edx
addl %eax, %edx
addl %r14d, %r11d
roll $0xa, %r15d
roll $0x6, %edx
movl %r13d, %eax
notl %eax
orl %r11d, %eax
xorl %r15d, %eax
addl %esi, %r14d
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %r14d
addl %eax, %r14d
addl %r10d, %edx
roll $0xa, %r12d
roll $0xf, %r14d
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r12d, %eax
addl -0x50(%rsp), %r10d
movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1
addl %esi, %r10d
addl %eax, %r10d
addl %ebx, %r14d
roll $0xa, %r13d
roll $0x7, %r10d
movl %r11d, %eax
notl %eax
orl %r14d, %eax
xorl %r13d, %eax
addl %r8d, %ebx
addl %ecx, %ebx
addl %eax, %ebx
addl %ebp, %r10d
roll $0xa, %edi
roll $0xb, %ebx
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %edi, %eax
movl -0x6c(%rsp), %esi
addl %esi, %ebp
movl $0x6ed9eba1, %r8d # imm = 0x6ED9EBA1
addl %r8d, %ebp
addl %eax, %ebp
addl %r15d, %ebx
roll $0xa, %r11d
roll $0xe, %ebp
movl %r14d, %eax
notl %eax
orl %ebx, %eax
xorl %r11d, %eax
movq -0x30(%rsp), %r8
addl %r8d, %r15d
addl %ecx, %r15d
addl %eax, %r15d
addl %r12d, %ebp
roll $0xa, %edx
roll $0x8, %r15d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %edx, %eax
addl -0x80(%rsp), %r12d
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %r12d
addl %eax, %r12d
addl %r13d, %r15d
roll $0xa, %r14d
roll $0x9, %r12d
movl %ebx, %eax
notl %eax
orl %r15d, %eax
xorl %r14d, %eax
addl %r9d, %r13d
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %r13d
addl %eax, %r13d
addl %edi, %r12d
roll $0xa, %r10d
roll $0x6, %r13d
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %r10d, %eax
movl -0x74(%rsp), %ecx
addl %ecx, %edi
movl $0x6ed9eba1, %r9d # imm = 0x6ED9EBA1
addl %r9d, %edi
addl %eax, %edi
addl %r11d, %r13d
roll $0xa, %ebx
roll $0xd, %edi
movl %r15d, %eax
notl %eax
orl %r13d, %eax
xorl %ebx, %eax
addl -0x7c(%rsp), %r11d
movl $0x6d703ef3, %r9d # imm = 0x6D703EF3
addl %r9d, %r11d
addl %eax, %r11d
addl %edx, %edi
roll $0xa, %ebp
roll $0x6, %r11d
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %ebp, %eax
addl -0x58(%rsp), %edx
movl $0x6ed9eba1, %r9d # imm = 0x6ED9EBA1
addl %r9d, %edx
addl %eax, %edx
addl %r14d, %r11d
roll $0xa, %r15d
roll $0xf, %edx
movl %r13d, %eax
notl %eax
orl %r11d, %eax
xorl %r15d, %eax
addl %esi, %r14d
movl $0x6d703ef3, %esi # imm = 0x6D703EF3
addl %esi, %r14d
addl %eax, %r14d
addl %r10d, %edx
roll $0xa, %r12d
roll $0xe, %r14d
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r12d, %eax
movq -0x28(%rsp), %r9
addl %r9d, %r10d
movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1
addl %esi, %r10d
addl %eax, %r10d
addl %ebx, %r14d
roll $0xa, %r13d
roll $0xe, %r10d
movl %r11d, %eax
notl %eax
orl %r14d, %eax
xorl %r13d, %eax
addl -0x70(%rsp), %ebx
movl $0x6d703ef3, %esi # imm = 0x6D703EF3
addl %esi, %ebx
addl %eax, %ebx
addl %ebp, %r10d
roll $0xa, %edi
roll $0xc, %ebx
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %edi, %eax
addl %r8d, %ebp
movl $0x6ed9eba1, %esi # imm = 0x6ED9EBA1
addl %esi, %ebp
addl %eax, %ebp
addl %r15d, %ebx
roll $0xa, %r11d
roll $0x8, %ebp
movl %r14d, %eax
notl %eax
orl %ebx, %eax
xorl %r11d, %eax
addl %ecx, %r15d
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %r15d
addl %eax, %r15d
addl %r12d, %ebp
roll $0xa, %edx
roll $0xd, %r15d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %edx, %eax
movq -0x48(%rsp), %r8
addl %r8d, %r12d
addl %esi, %r12d
addl %eax, %r12d
addl %r13d, %r15d
roll $0xa, %r14d
roll $0xd, %r12d
movl %ebx, %eax
notl %eax
orl %r15d, %eax
xorl %r14d, %eax
movl -0x64(%rsp), %esi
addl %esi, %r13d
addl %ecx, %r13d
addl %eax, %r13d
addl %edi, %r12d
roll $0xa, %r10d
roll $0x5, %r13d
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %r10d, %eax
addl -0x7c(%rsp), %edi
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %edi
addl %eax, %edi
addl %r11d, %r13d
roll $0xa, %ebx
roll $0x6, %edi
movl %r15d, %eax
notl %eax
orl %r13d, %eax
xorl %ebx, %eax
addl %r9d, %r11d
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %r11d
addl %eax, %r11d
addl %edx, %edi
roll $0xa, %ebp
roll $0xe, %r11d
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %ebp, %eax
movl -0x78(%rsp), %r9d
addl %r9d, %edx
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %edx
addl %eax, %edx
addl %r14d, %r11d
roll $0xa, %r15d
roll $0x5, %edx
movl %r13d, %eax
notl %eax
orl %r11d, %eax
xorl %r15d, %eax
addl -0x68(%rsp), %r14d
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %r14d
addl %eax, %r14d
addl %r10d, %edx
roll $0xa, %r12d
roll $0xd, %r14d
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r12d, %eax
addl -0x70(%rsp), %r10d
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %r10d
addl %eax, %r10d
addl %ebx, %r14d
roll $0xa, %r13d
roll $0xc, %r10d
movl %r11d, %eax
notl %eax
orl %r14d, %eax
xorl %r13d, %eax
addl %r8d, %ebx
movl $0x6d703ef3, %ecx # imm = 0x6D703EF3
addl %ecx, %ebx
movl $0x6d703ef3, %r8d # imm = 0x6D703EF3
addl %eax, %ebx
addl %ebp, %r10d
roll $0xa, %edi
roll $0xd, %ebx
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %edi, %eax
addl -0x60(%rsp), %ebp
movl $0x6ed9eba1, %ecx # imm = 0x6ED9EBA1
addl %ecx, %ebp
addl %eax, %ebp
addl %r15d, %ebx
roll $0xa, %r11d
roll $0x7, %ebp
movl %r14d, %eax
notl %eax
orl %ebx, %eax
xorl %r11d, %eax
addl -0x50(%rsp), %r15d
addl %r8d, %r15d
addl %eax, %r15d
addl %r12d, %ebp
addl %esi, %r12d
addl %ecx, %r12d
roll $0xa, %edx
roll $0x7, %r15d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %edx, %eax
addl %eax, %r12d
addl %r13d, %r15d
addl %r9d, %r13d
addl %r8d, %r13d
roll $0xa, %r14d
roll $0x5, %r12d
movl %ebx, %eax
notl %eax
orl %r15d, %eax
xorl %r14d, %eax
addl %eax, %r13d
addl %edi, %r12d
roll $0xa, %r10d
movl %r12d, %eax
xorl %ebp, %eax
andl %r10d, %eax
xorl %ebp, %eax
movq -0x58(%rsp), %rsi
addl %esi, %edi
movl $0x8f1bbcdc, %ecx # imm = 0x8F1BBCDC
addl %ecx, %edi
addl %eax, %edi
roll $0x5, %r13d
roll $0xa, %ebx
addl %r11d, %r13d
movl %r15d, %eax
xorl %ebx, %eax
andl %r13d, %eax
xorl %ebx, %eax
addl -0x74(%rsp), %r11d
movl $0x7a6d76e9, %ecx # imm = 0x7A6D76E9
addl %ecx, %r11d
addl %eax, %r11d
roll $0xb, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %edi, %eax
xorl %r12d, %eax
andl %ebp, %eax
xorl %r12d, %eax
addl -0x6c(%rsp), %edx
movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC
addl %r8d, %edx
addl %eax, %edx
roll $0xf, %r11d
addl %r14d, %r11d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
andl %r11d, %eax
xorl %r15d, %eax
addl -0x7c(%rsp), %r14d
addl %ecx, %r14d
addl %eax, %r14d
roll $0xc, %edx
addl %r10d, %edx
roll $0xa, %r12d
movl %edx, %eax
xorl %edi, %eax
andl %r12d, %eax
xorl %edi, %eax
movl -0x70(%rsp), %ecx
addl %ecx, %r10d
addl %r8d, %r10d
addl %eax, %r10d
roll $0x5, %r14d
addl %ebx, %r14d
roll $0xa, %r13d
movl %r11d, %eax
xorl %r13d, %eax
andl %r14d, %eax
xorl %r13d, %eax
addl -0x50(%rsp), %ebx
movl $0x7a6d76e9, %r8d # imm = 0x7A6D76E9
addl %r8d, %ebx
addl %eax, %ebx
roll $0xe, %r10d
addl %ebp, %r10d
roll $0xa, %edi
movl %r10d, %eax
xorl %edx, %eax
andl %edi, %eax
xorl %edx, %eax
addl -0x68(%rsp), %ebp
movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC
addl %r8d, %ebp
addl %eax, %ebp
roll $0x8, %ebx
addl %r15d, %ebx
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
andl %ebx, %eax
xorl %r11d, %eax
addl %esi, %r15d
movl $0x7a6d76e9, %esi # imm = 0x7A6D76E9
addl %esi, %r15d
addl %eax, %r15d
roll $0xf, %ebp
addl %r12d, %ebp
roll $0xa, %edx
movl %ebp, %eax
xorl %r10d, %eax
andl %edx, %eax
xorl %r10d, %eax
movq -0x48(%rsp), %rsi
addl %esi, %r12d
addl %r8d, %r12d
addl %eax, %r12d
roll $0xb, %r15d
addl %r13d, %r15d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
andl %r15d, %eax
xorl %r14d, %eax
movq -0x38(%rsp), %r8
addl %r8d, %r13d
movl $0x7a6d76e9, %r9d # imm = 0x7A6D76E9
addl %r9d, %r13d
addl %eax, %r13d
roll $0xe, %r12d
addl %edi, %r12d
roll $0xa, %r10d
movl %r12d, %eax
xorl %ebp, %eax
andl %r10d, %eax
xorl %ebp, %eax
addl -0x74(%rsp), %edi
movl $0x8f1bbcdc, %r9d # imm = 0x8F1BBCDC
addl %r9d, %edi
addl %eax, %edi
roll $0xe, %r13d
addl %r11d, %r13d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
andl %r13d, %eax
xorl %ebx, %eax
addl %ecx, %r11d
movl $0x7a6d76e9, %ecx # imm = 0x7A6D76E9
addl %ecx, %r11d
addl %eax, %r11d
roll $0xf, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %edi, %eax
xorl %r12d, %eax
andl %ebp, %eax
xorl %r12d, %eax
movl -0x64(%rsp), %ecx
addl %ecx, %edx
addl %r9d, %edx
addl %eax, %edx
roll $0xe, %r11d
addl %r14d, %r11d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
andl %r11d, %eax
xorl %r15d, %eax
addl -0x80(%rsp), %r14d
movl $0x7a6d76e9, %r9d # imm = 0x7A6D76E9
addl %r9d, %r14d
addl %eax, %r14d
roll $0x9, %edx
addl %r10d, %edx
roll $0xa, %r12d
movl %edx, %eax
xorl %edi, %eax
andl %r12d, %eax
xorl %edi, %eax
addl -0x50(%rsp), %r10d
movl $0x8f1bbcdc, %r9d # imm = 0x8F1BBCDC
addl %r9d, %r10d
addl %eax, %r10d
roll $0x6, %r14d
addl %ebx, %r14d
roll $0xa, %r13d
movl %r11d, %eax
xorl %r13d, %eax
andl %r14d, %eax
xorl %r13d, %eax
addl %esi, %ebx
movl $0x7a6d76e9, %esi # imm = 0x7A6D76E9
addl %esi, %ebx
addl %eax, %ebx
roll $0x8, %r10d
addl %ebp, %r10d
roll $0xa, %edi
movl %r10d, %eax
xorl %edx, %eax
andl %edi, %eax
xorl %edx, %eax
movl -0x78(%rsp), %esi
addl %esi, %ebp
addl %r9d, %ebp
addl %eax, %ebp
roll $0xe, %ebx
addl %r15d, %ebx
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
andl %ebx, %eax
xorl %r11d, %eax
addl -0x60(%rsp), %r15d
movl $0x7a6d76e9, %r9d # imm = 0x7A6D76E9
addl %r9d, %r15d
addl %eax, %r15d
roll $0x9, %ebp
addl %r12d, %ebp
roll $0xa, %edx
movl %ebp, %eax
xorl %r10d, %eax
andl %edx, %eax
xorl %r10d, %eax
addl %r8d, %r12d
movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC
addl %r8d, %r12d
addl %eax, %r12d
roll $0x6, %r15d
addl %r13d, %r15d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
andl %r15d, %eax
xorl %r14d, %eax
addl %ecx, %r13d
addl %r9d, %r13d
addl %eax, %r13d
roll $0xe, %r12d
addl %edi, %r12d
roll $0xa, %r10d
movl %r12d, %eax
xorl %ebp, %eax
andl %r10d, %eax
xorl %ebp, %eax
movq -0x30(%rsp), %rcx
addl %ecx, %edi
addl %r8d, %edi
addl %eax, %edi
roll $0x9, %r13d
addl %r11d, %r13d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
andl %r13d, %eax
xorl %ebx, %eax
movq -0x28(%rsp), %r9
addl %r9d, %r11d
movl $0x7a6d76e9, %r8d # imm = 0x7A6D76E9
addl %r8d, %r11d
addl %eax, %r11d
roll $0x5, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %edi, %eax
xorl %r12d, %eax
andl %ebp, %eax
xorl %r12d, %eax
addl -0x80(%rsp), %edx
movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC
addl %r8d, %edx
addl %eax, %edx
roll $0xc, %r11d
addl %r14d, %r11d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
andl %r11d, %eax
xorl %r15d, %eax
addl %esi, %r14d
movl $0x7a6d76e9, %esi # imm = 0x7A6D76E9
addl %esi, %r14d
addl %eax, %r14d
roll $0x6, %edx
addl %r10d, %edx
roll $0xa, %r12d
movl %edx, %eax
xorl %edi, %eax
andl %r12d, %eax
xorl %edi, %eax
movq -0x40(%rsp), %rsi
addl %esi, %r10d
addl %r8d, %r10d
addl %eax, %r10d
roll $0x9, %r14d
addl %ebx, %r14d
roll $0xa, %r13d
movl %r11d, %eax
xorl %r13d, %eax
andl %r14d, %eax
xorl %r13d, %eax
addl -0x6c(%rsp), %ebx
movl $0x7a6d76e9, %r8d # imm = 0x7A6D76E9
addl %r8d, %ebx
addl %eax, %ebx
roll $0x8, %r10d
addl %ebp, %r10d
roll $0xa, %edi
movl %r10d, %eax
xorl %edx, %eax
andl %edi, %eax
xorl %edx, %eax
addl -0x60(%rsp), %ebp
movl $0x8f1bbcdc, %r8d # imm = 0x8F1BBCDC
addl %r8d, %ebp
addl %eax, %ebp
roll $0xc, %ebx
addl %r15d, %ebx
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
andl %ebx, %eax
xorl %r11d, %eax
addl %ecx, %r15d
movl $0x7a6d76e9, %r8d # imm = 0x7A6D76E9
addl %r8d, %r15d
addl %eax, %r15d
roll $0x6, %ebp
addl %r12d, %ebp
roll $0xa, %edx
movl %ebp, %eax
xorl %r10d, %eax
andl %edx, %eax
xorl %r10d, %eax
addl -0x7c(%rsp), %r12d
movl $0x8f1bbcdc, %ecx # imm = 0x8F1BBCDC
addl %ecx, %r12d
addl %eax, %r12d
roll $0x5, %r15d
addl %r13d, %r15d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
andl %r15d, %eax
xorl %r14d, %eax
movl -0x68(%rsp), %ecx
addl %ecx, %r13d
addl %r8d, %r13d
addl %eax, %r13d
roll $0x5, %r12d
addl %edi, %r12d
addl %r9d, %edi
movl $0x8f1bbcdc, %eax # imm = 0x8F1BBCDC
addl %eax, %edi
roll $0xa, %r10d
movl %r12d, %eax
xorl %ebp, %eax
andl %r10d, %eax
xorl %ebp, %eax
addl %eax, %edi
roll $0xf, %r13d
addl %r11d, %r13d
addl %esi, %r11d
addl %r8d, %r11d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
andl %r13d, %eax
xorl %ebx, %eax
addl %eax, %r11d
roll $0xc, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %edi, %eax
movq -0x50(%rsp), %r9
addl %r9d, %edx
movl $0xa953fd4e, %esi # imm = 0xA953FD4E
addl %esi, %edx
addl %eax, %edx
roll $0x8, %r11d
addl %r14d, %r11d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
xorl %r11d, %eax
addl -0x64(%rsp), %r14d
addl %eax, %r14d
roll $0x9, %edx
roll $0xa, %r12d
addl %r10d, %edx
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %edx, %eax
addl -0x48(%rsp), %r10d
addl %esi, %r10d
addl %eax, %r10d
roll $0x8, %r14d
roll $0xa, %r13d
addl %ebx, %r14d
movl %r11d, %eax
xorl %r13d, %eax
xorl %r14d, %eax
addl -0x80(%rsp), %ebx
addl %eax, %ebx
roll $0xf, %r10d
addl %ebp, %r10d
roll $0xa, %edi
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r10d, %eax
movq -0x60(%rsp), %r8
addl %r8d, %ebp
addl %esi, %ebp
addl %eax, %ebp
roll $0x5, %ebx
addl %r15d, %ebx
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
xorl %ebx, %eax
addl %ecx, %r15d
addl %eax, %r15d
roll $0x5, %ebp
roll $0xa, %edx
addl %r12d, %ebp
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %ebp, %eax
addl -0x6c(%rsp), %r12d
addl %esi, %r12d
movl $0xa953fd4e, %ecx # imm = 0xA953FD4E
addl %eax, %r12d
roll $0xc, %r15d
addl %r13d, %r15d
addl %r9d, %r13d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
xorl %r15d, %eax
addl %eax, %r13d
roll $0xb, %r12d
addl %edi, %r12d
roll $0xa, %r10d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %r12d, %eax
movq -0x30(%rsp), %r9
addl %r9d, %edi
addl %ecx, %edi
addl %eax, %edi
roll $0x9, %r13d
addl %r11d, %r13d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
xorl %r13d, %eax
addl -0x58(%rsp), %r11d
addl %eax, %r11d
roll $0x6, %edi
addl %edx, %edi
addl -0x64(%rsp), %edx
roll $0xa, %ebp
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %edi, %eax
addl %esi, %edx
addl %eax, %edx
roll $0xc, %r11d
addl %r14d, %r11d
addl %r8d, %r14d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
xorl %r11d, %eax
addl %eax, %r14d
roll $0x8, %edx
addl %r10d, %edx
roll $0xa, %r12d
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %edx, %eax
movq -0x28(%rsp), %rsi
addl %esi, %r10d
addl %ecx, %r10d
addl %eax, %r10d
roll $0x5, %r14d
addl %ebx, %r14d
roll $0xa, %r13d
movl %r11d, %eax
xorl %r13d, %eax
xorl %r14d, %eax
addl -0x74(%rsp), %ebx
addl %eax, %ebx
roll $0xd, %r10d
addl %ebp, %r10d
addl -0x68(%rsp), %ebp
roll $0xa, %edi
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r10d, %eax
addl %ecx, %ebp
addl %eax, %ebp
roll $0xe, %ebx
addl %r15d, %ebx
addl %r9d, %r15d
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
xorl %ebx, %eax
addl %eax, %r15d
roll $0xc, %ebp
addl %r12d, %ebp
roll $0xa, %edx
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %ebp, %eax
movq -0x40(%rsp), %r9
addl %r9d, %r12d
addl %ecx, %r12d
movl $0xa953fd4e, %r8d # imm = 0xA953FD4E
addl %eax, %r12d
roll $0x6, %r15d
addl %r13d, %r15d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
xorl %r15d, %eax
addl -0x7c(%rsp), %r13d
addl %eax, %r13d
roll $0x5, %r12d
addl %edi, %r12d
addl -0x58(%rsp), %edi
roll $0xa, %r10d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %r12d, %eax
addl %r8d, %edi
addl %eax, %edi
roll $0x8, %r13d
addl %r11d, %r13d
addl %esi, %r11d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
xorl %r13d, %eax
addl %eax, %r11d
roll $0xc, %edi
addl %edx, %edi
roll $0xa, %ebp
movl %ebp, %eax
notl %eax
orl %r12d, %eax
xorl %edi, %eax
movq -0x38(%rsp), %rcx
addl %ecx, %edx
addl %r8d, %edx
movl $0xa953fd4e, %esi # imm = 0xA953FD4E
addl %eax, %edx
roll $0xd, %r11d
addl %r14d, %r11d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
xorl %r11d, %eax
addl -0x78(%rsp), %r14d
addl %eax, %r14d
roll $0xd, %edx
addl %r10d, %edx
addl -0x74(%rsp), %r10d
roll $0xa, %r12d
movl %r12d, %eax
notl %eax
orl %edi, %eax
xorl %edx, %eax
addl %esi, %r10d
addl %eax, %r10d
roll $0x6, %r14d
addl %ebx, %r14d
addl %r9d, %ebx
roll $0xa, %r13d
movl %r11d, %eax
xorl %r13d, %eax
xorl %r14d, %eax
addl %eax, %ebx
roll $0xe, %r10d
addl %ebp, %r10d
roll $0xa, %edi
movl %edi, %eax
notl %eax
orl %edx, %eax
xorl %r10d, %eax
movl -0x70(%rsp), %r8d
addl %r8d, %ebp
addl %esi, %ebp
addl %eax, %ebp
roll $0x5, %ebx
addl %r15d, %ebx
addl -0x48(%rsp), %r15d
roll $0xa, %r11d
movl %r14d, %eax
xorl %r11d, %eax
xorl %ebx, %eax
addl %eax, %r15d
roll $0xb, %ebp
addl %r12d, %ebp
addl -0x7c(%rsp), %r12d
roll $0xa, %edx
movl %edx, %eax
notl %eax
orl %r10d, %eax
xorl %ebp, %eax
addl %esi, %r12d
addl %eax, %r12d
roll $0xf, %r15d
addl %r13d, %r15d
addl %ecx, %r13d
roll $0xa, %r14d
movl %ebx, %eax
xorl %r14d, %eax
xorl %r15d, %eax
addl %eax, %r13d
roll $0x8, %r12d
addl %edi, %r12d
addl -0x80(%rsp), %edi
roll $0xa, %r10d
movl %r10d, %eax
notl %eax
orl %ebp, %eax
xorl %r12d, %eax
addl %esi, %edi
addl %eax, %edi
roll $0xd, %r13d
addl %r11d, %r13d
addl -0x6c(%rsp), %r11d
roll $0xa, %ebx
movl %r15d, %eax
xorl %ebx, %eax
xorl %r13d, %eax
addl %eax, %r11d
roll $0x5, %edi
addl %edx, %edi
addl -0x78(%rsp), %edx
addl %esi, %edx
roll $0xa, %ebp
movq -0x18(%rsp), %rax
addl %ebx, %eax
addl %ebp, %eax
movq %rax, %rcx
notl %ebp
orl %r12d, %ebp
xorl %edi, %ebp
addl %ebp, %edx
roll $0xb, %r11d
addl %r14d, %r11d
addl %r8d, %r14d
roll $0xa, %r15d
movl %r13d, %eax
xorl %r15d, %eax
xorl %r11d, %eax
addl %eax, %r14d
roll $0xa, %r13d
addl -0x20(%rsp), %r13d
addl %edi, %r13d
addl -0x1c(%rsp), %r15d
roll $0xa, %r12d
addl %r12d, %r15d
movq (%rsp), %rax
movl %r15d, 0xc(%rax)
movl %ecx, 0x10(%rax)
movq -0x10(%rsp), %rcx
addl %r10d, %ecx
addl %ebx, %ecx
roll $0xb, %r14d
addl %r14d, %ecx
movl %ecx, 0x14(%rax)
addl -0x8(%rsp), %r10d
addl %r11d, %r10d
roll $0x6, %edx
addl %edx, %r10d
movl %r10d, 0x18(%rax)
movl %r13d, 0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 = ctx->total[0] & 0x3F;
fill = 64 - left;
ctx->total[0] += (uint32_t) ilen;
ctx->total[0] &= 0xFFFFFFFF;
if( ctx->total[0] < (uint32_t) ilen )
ctx->total[1]++;
if( left && ilen >= fill )
{
memcpy( (void *) (ctx->buffer + left), input, fill );
if( ( ret = mbedtls_internal_ripemd160_process( ctx, ctx->buffer ) ) != 0 )
return( ret );
input += fill;
ilen -= fill;
left = 0;
}
while( ilen >= 64 )
{
if( ( ret = mbedtls_internal_ripemd160_process( ctx, input ) ) != 0 )
return( ret );
input += 64;
ilen -= 64;
}
if( ilen > 0 )
{
memcpy( (void *) (ctx->buffer + left), input, ilen );
}
return( 0 );
} | 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, %r12d
subq %rax, %r12
movq %rdx, %r15
subq %r12, %r15
jae 0x2a61c
movq %rdx, %r15
movl %eax, %ebp
jmp 0x2a643
movq %rdx, %r15
jmp 0x2a643
leaq 0x1c(%r14), %r13
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x9180
movq %r14, %rdi
movq %r13, %rsi
callq 0x2908d
addq %r12, %rbx
cmpq $0x40, %r15
jb 0x2a662
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2908d
addq $0x40, %rbx
addq $-0x40, %r15
cmpq $0x3f, %r15
ja 0x2a649
testq %r15, %r15
je 0x2a67c
movl %ebp, %eax
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9180
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
| /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 )
{
int ret;
size_t len;
/* Get main sequence tag */
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
{
return( ret );
}
if( *p + len != end )
return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
while( *p < end )
{
unsigned char const tag = *(*p)++;
if( ( tag & tag_must_mask ) != tag_must_val )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
if( ( ret = mbedtls_asn1_get_len( p, end, &len ) ) != 0 )
return( ret );
if( ( tag & tag_may_mask ) == tag_may_val )
{
if( cb != NULL )
{
ret = cb( ctx, tag, *p, len );
if( ret != 0 )
return( ret );
}
}
*p += len;
}
return( 0 );
} | 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
cmpb $0x30, (%rax)
jne 0x2bcd4
incq %rax
movq %rax, (%r13)
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2b92c
movl %eax, %ebx
jmp 0x2bcd4
movl $0xffffffa0, %ebx # imm = 0xFFFFFFA0
testl %ebx, %ebx
jne 0x2bd73
movq (%r13), %rax
addq 0x8(%rsp), %rax
movl $0xffffff9a, %ebx # imm = 0xFFFFFF9A
cmpq %r12, %rax
jne 0x2bd73
movq (%r13), %rax
cmpq %r12, %rax
jae 0x2bd71
leaq 0x1(%rax), %rcx
movq %rcx, (%r13)
movzbl (%rax), %ebp
movl %ebp, %eax
andb %r15b, %al
cmpb %r14b, %al
jne 0x2bd2b
movq %r13, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2b92c
testl %eax, %eax
je 0x2bd34
xorl %ecx, %ecx
movl %eax, %ebx
jmp 0x2bd6b
movl $0xffffff9e, %ebx # imm = 0xFFFFFF9E
xorl %ecx, %ecx
jmp 0x2bd6b
cmpq $0x0, 0x50(%rsp)
je 0x2bd60
movl %ebp, %eax
andb 0x10(%rsp), %al
cmpb 0x14(%rsp), %al
jne 0x2bd60
movq (%r13), %rdx
movq 0x8(%rsp), %rcx
movq 0x58(%rsp), %rdi
movl %ebp, %esi
callq *0x50(%rsp)
testl %eax, %eax
jne 0x2bd25
movq 0x8(%rsp), %rax
addq %rax, (%r13)
movb $0x1, %cl
testb %cl, %cl
jne 0x2bcf3
jmp 0x2bd73
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 ] = esk[30 - i];
dsk[i + 1] = esk[31 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
esk[i + 64] = esk[i ];
esk[i + 65] = esk[i + 1];
dsk[i + 64] = dsk[i ];
dsk[i + 65] = dsk[i + 1];
}
} | 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, -0x100(%rbx,%rcx,4)
movl -0x4(%rbx,%rax,4), %edx
movl %edx, -0x84(%r14,%rcx,4)
movl (%rbx,%rax,4), %edx
movl %edx, -0x80(%r14,%rcx,4)
movq -0x104(%r14,%rcx,4), %rdx
movq %rdx, -0x4(%r14,%rcx,4)
movq -0x104(%rbx,%rcx,4), %rdx
movq %rdx, -0x4(%rbx,%rcx,4)
leaq 0x2(%rcx), %rdx
addq $-0x41, %rcx
addq $-0x2, %rax
cmpq $0x1e, %rcx
movq %rdx, %rcx
jb 0x2cac5
popq %rbx
popq %r14
popq %r15
retq
| /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 )
{
dsk[i ] = esk[94 - i];
dsk[i + 1] = esk[95 - i];
esk[i + 32] = dsk[62 - i];
esk[i + 33] = dsk[63 - i];
dsk[i + 64] = esk[30 - i];
dsk[i + 65] = esk[31 - 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
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,%rax,4)
movl 0x84(%r14,%rcx,4), %edx
movl %edx, 0xc(%rbx,%rax,4)
movl (%rbx,%rcx,4), %edx
movl %edx, 0x88(%r14,%rax,4)
movl 0x4(%rbx,%rcx,4), %edx
movl %edx, 0x8c(%r14,%rax,4)
movl -0x80(%r14,%rcx,4), %edx
movl %edx, 0x108(%rbx,%rax,4)
movl -0x7c(%r14,%rcx,4), %edx
movl %edx, 0x10c(%rbx,%rax,4)
addq $0x2, %rax
addq $-0x2, %rcx
cmpq $0x1e, %rax
jb 0x2cbcd
popq %rbx
popq %r14
popq %r15
retq
| /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; i++ )
{
DES_ROUND( Y, X );
DES_ROUND( X, Y );
}
DES_FP( Y, X );
PUT_UINT32_BE( Y, output, 0 );
PUT_UINT32_BE( X, output, 4 );
return( 0 );
} | 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
movl %edx, %esi
shrl $0x10, %esi
movzwl %ax, %ecx
xorl %esi, %ecx
xorl %ecx, %eax
shll $0x10, %ecx
xorl %edx, %ecx
movl %eax, %edx
shrl $0x2, %edx
xorl %ecx, %edx
andl $0x33333333, %edx # imm = 0x33333333
xorl %edx, %ecx
shll $0x2, %edx
xorl %eax, %edx
movl %edx, %ebp
shrl $0x8, %ebp
xorl %ecx, %ebp
andl $0xff00ff, %ebp # imm = 0xFF00FF
xorl %ebp, %ecx
shll $0x8, %ebp
xorl %edx, %ebp
roll %ebp
movl %ebp, %eax
xorl %ecx, %eax
andl $0xaaaaaaaa, %eax # imm = 0xAAAAAAAA
xorl %eax, %ebp
xorl %ecx, %eax
roll %eax
xorl %ecx, %ecx
movl $0xfc, %r13d
movq -0x8(%rsp), %r8
leaq 0x9ad8(%rip), %r11 # 0x367c0
leaq 0x9bd1(%rip), %rbx # 0x368c0
leaq 0x9cca(%rip), %r14 # 0x369c0
leaq 0x9dc3(%rip), %r15 # 0x36ac0
leaq 0x9ebc(%rip), %r12 # 0x36bc0
movl %ebp, %edx
movl (%r8,%rcx), %ebp
xorl %edx, %ebp
movl %edx, %edi
movl %ebp, %edx
andl $0x3f, %edx
movl %ebp, %esi
shrl $0x6, %esi
andl %r13d, %esi
leaq 0x989e(%rip), %r9 # 0x365c0
xorl (%r9,%rdx,4), %eax
movl %ebp, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %ebp
andl %r13d, %ebp
leaq 0x9985(%rip), %r10 # 0x366c0
xorl (%rsi,%r10), %eax
movl %edi, %esi
movl %edi, %r10d
roll $0x1c, %esi
xorl 0x4(%r8,%rcx), %esi
xorl (%rdx,%r11), %eax
movl %esi, %edx
andl $0x3f, %edx
xorl (%rbp,%rbx), %eax
movl %esi, %ebp
shrl $0x6, %ebp
andl %r13d, %ebp
xorl (%r14,%rdx,4), %eax
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rbp,%r15), %eax
xorl (%rdx,%r12), %eax
leaq 0x9f3d(%rip), %rdi # 0x36cc0
xorl (%rsi,%rdi), %eax
movl 0x8(%r8,%rcx), %esi
xorl %eax, %esi
movl %esi, %edx
andl $0x3f, %edx
movl (%r9,%rdx,4), %ebp
movl %esi, %edx
shrl $0x6, %edx
andl %r13d, %edx
leaq 0x991b(%rip), %r9 # 0x366c0
xorl (%rdx,%r9), %ebp
movl %esi, %edx
shrl $0xe, %edx
andl %r13d, %edx
shrl $0x16, %esi
andl %r13d, %esi
xorl (%rdx,%r11), %ebp
movl %eax, %edx
roll $0x1c, %edx
xorl 0xc(%r8,%rcx), %edx
xorl (%rsi,%rbx), %ebp
movl %edx, %esi
andl $0x3f, %esi
xorl (%r14,%rsi,4), %ebp
movl %edx, %esi
shrl $0x6, %esi
andl %r13d, %esi
xorl (%rsi,%r15), %ebp
movl %edx, %esi
shrl $0xe, %esi
andl %r13d, %esi
xorl (%rsi,%r12), %ebp
shrl $0x16, %edx
andl %r13d, %edx
xorl (%rdx,%rdi), %ebp
xorl %r10d, %ebp
addq $0x10, %rcx
cmpl $0x80, %ecx
jne 0x2cd04
rorl %ebp
movl %ebp, %ecx
xorl %eax, %ecx
andl $0xaaaaaaaa, %ecx # imm = 0xAAAAAAAA
xorl %ecx, %ebp
xorl %eax, %ecx
rorl %ecx
movl %ecx, %edx
shrl $0x8, %edx
xorl %ebp, %edx
andl $0xff00ff, %edx # imm = 0xFF00FF
xorl %edx, %ebp
shll $0x8, %edx
xorl %ecx, %edx
movl %edx, %eax
shrl $0x2, %eax
xorl %ebp, %eax
andl $0x33333333, %eax # imm = 0x33333333
xorl %eax, %ebp
shll $0x2, %eax
xorl %edx, %eax
movl %ebp, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
xorl %ecx, %edx
xorl %edx, %eax
shll $0x10, %edx
xorl %ebp, %edx
movl %edx, %ecx
shrl $0x4, %ecx
xorl %eax, %ecx
andl $0xf0f0f0f, %ecx # imm = 0xF0F0F0F
xorl %ecx, %eax
shll $0x4, %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x18, %edx
movq -0x10(%rsp), %rsi
movb %dl, (%rsi)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x1(%rsi)
movb %ch, 0x2(%rsi)
movb %cl, 0x3(%rsi)
movl %eax, %ecx
shrl $0x18, %ecx
movb %cl, 0x4(%rsi)
movl %eax, %ecx
shrl $0x10, %ecx
movb %cl, 0x5(%rsi)
movb %ah, 0x6(%rsi)
movb %al, 0x7(%rsi)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 )
return( MBEDTLS_ERR_DES_INVALID_INPUT_LENGTH );
if( mode == MBEDTLS_DES_ENCRYPT )
{
while( length > 0 )
{
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( input[i] ^ iv[i] );
mbedtls_des_crypt_ecb( ctx, output, output );
memcpy( iv, output, 8 );
input += 8;
output += 8;
length -= 8;
}
}
else /* MBEDTLS_DES_DECRYPT */
{
while( length > 0 )
{
memcpy( temp, input, 8 );
mbedtls_des_crypt_ecb( ctx, input, output );
for( i = 0; i < 8; i++ )
output[i] = (unsigned char)( output[i] ^ iv[i] );
memcpy( iv, temp, 8 );
input += 8;
output += 8;
length -= 8;
}
}
return( 0 );
} | 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), %cl
xorb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x2ced5
movq %r13, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x2cc59
movq (%rbx), %rax
movq %rax, (%r15)
addq $0x8, %r14
addq $0x8, %rbx
addq $-0x8, %r12
jne 0x2ced3
jmp 0x2cf46
testq %r12, %r12
je 0x2cf46
movq (%r14), %rbp
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2cc59
xorl %eax, %eax
movb (%r15,%rax), %cl
xorb %cl, (%rbx,%rax)
incq %rax
cmpq $0x8, %rax
jne 0x2cf25
movq %rbp, (%r15)
addq $0x8, %r14
addq $0x8, %rbx
addq $-0x8, %r12
jne 0x2cf12
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::operator*() const | 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.object_iterator->second;
}
case basic_json::value_t::array:
{
assert(m_it.array_iterator != m_object->m_value.array->end());
return *m_it.array_iterator;
}
case basic_json::value_t::null:
{
JSON_THROW(std::out_of_range("cannot get value"));
}
default:
{
if (m_it.primitive_iterator.is_begin())
{
return *m_object;
}
JSON_THROW(std::out_of_range("cannot get value"));
}
}
} | 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 0x4080
jmp 0x7d46
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rax
cmpq 0x8(%rcx), %rax
jne 0x7d03
leaq 0x14469(%rip), %rdi # 0x1c13f
leaq 0x137cd(%rip), %rsi # 0x1b4aa
leaq 0x14acd(%rip), %rcx # 0x1c7b1
movl $0x2349, %edx # imm = 0x2349
callq 0x4220
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%rdi), %rax
cmpq %rcx, %rax
je 0x7d5c
addq $0x40, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x13bf8(%rip), %rdi # 0x1b90a
leaq 0x13791(%rip), %rsi # 0x1b4aa
leaq 0x14a91(%rip), %rcx # 0x1c7b1
movl $0x233d, %edx # imm = 0x233D
callq 0x4220
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq 0x14437(%rip), %rsi # 0x1c175
movq %rax, %rdi
callq 0x4080
movq 0x2027b(%rip), %rsi # 0x27fc8
movq 0x20264(%rip), %rdx # 0x27fb8
movq %rbx, %rdi
callq 0x44f0
leaq 0x143a4(%rip), %rdi # 0x1c107
leaq 0x13740(%rip), %rsi # 0x1b4aa
leaq 0x14a40(%rip), %rcx # 0x1c7b1
movl $0x2343, %edx # imm = 0x2343
callq 0x4220
jmp 0x7d7d
movq %rax, %r14
movq %rbx, %rdi
callq 0x4280
movq %r14, %rdi
callq 0x4530
| /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";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::discarded:
return "discarded";
default:
return "number";
}
}
} | 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 # 0x1b6f2
leaq 0x126c5(%rip), %rdx # 0x1b6f7
jmp 0x9082
leaq 0x126cc(%rip), %rsi # 0x1b707
leaq 0x126ce(%rip), %rdx # 0x1b710
jmp 0x9082
leaq 0x126c6(%rip), %rsi # 0x1b711
leaq 0x126c5(%rip), %rdx # 0x1b717
jmp 0x9082
leaq 0x12690(%rip), %rsi # 0x1b6eb
leaq 0x1268f(%rip), %rdx # 0x1b6f1
jmp 0x9082
leaq 0x1268d(%rip), %rsi # 0x1b6f8
leaq 0x1268c(%rip), %rdx # 0x1b6fe
jmp 0x9082
leaq 0x12684(%rip), %rsi # 0x1b6ff
leaq 0x12684(%rip), %rdx # 0x1b706
movq %rbx, %rdi
callq 0x59b2
movq %rbx, %rax
popq %rbx
retq
nop
| /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
movq %rbx, %rax
popq %rbx
retq
nop
| /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::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const>::set_end() | 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;
}
case basic_json::value_t::array:
{
m_it.array_iterator = m_object->m_value.array->end();
break;
}
default:
{
m_it.primitive_iterator.set_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 # 0x1b90a
leaq 0x11781(%rip), %rsi # 0x1b4aa
leaq 0x11d70(%rip), %rcx # 0x1baa0
movl $0x231e, %edx # imm = 0x231E
callq 0x4220
| /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_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::create<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_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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::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_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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&>(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_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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&) | 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)...);
assert(object != nullptr);
return object.release();
} | 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_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::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::create<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_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>>, 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_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>> const&>(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_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>> const&) | 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)...);
assert(object != nullptr);
return object.release();
} | 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, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 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)...);
assert(object != nullptr);
return object.release();
} | 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
callq 0x4330
movq %r14, %rdi
callq 0x4530
| /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::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_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::string_t&) | 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), %rsi # 0x1c186
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x8f80
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x43b0
xorl %ebp, %ebp
movq 0x1d9b2(%rip), %rsi # 0x27f90
movq 0x1d9c3(%rip), %rdx # 0x27fa8
movq %rbx, %rdi
callq 0x44f0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa613
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x4330
jmp 0xa613
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa636
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4330
jmp 0xa636
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0xa643
movq %rbx, %rdi
callq 0x4280
movq %r14, %rdi
callq 0x4530
nop
| /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_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&) | 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
movl %eax, %edx
xorb $0x5, %dl
movl %ecx, %r8d
xorb $0x7, %r8b
orb %r8b, %dl
jne 0xa987
cvtsi2sdq 0x8(%rdi), %xmm0
cmpeqsd 0x8(%rsi), %xmm0
jmp 0xaa2d
movl %eax, %r9d
xorb $0x7, %r9b
movl %ecx, %edx
xorb $0x5, %dl
orb %dl, %r9b
jne 0xa9a3
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0xaa27
movl %eax, %r9d
xorb $0x6, %r9b
orb %r8b, %r9b
jne 0xa9d7
movsd 0x8(%rdi), %xmm0
unpcklps 0x10775(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1077d(%rip), %xmm0 # 0x1b140
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cmpeqsd 0x8(%rsi), %xmm1
jmp 0xaa10
movl %eax, %r8d
xorb $0x7, %r8b
xorb $0x6, %cl
orb %cl, %r8b
jne 0xab01
movsd 0x8(%rsi), %xmm0
unpcklps 0x1073a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x10742(%rip), %xmm0 # 0x1b140
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cmpeqsd 0x8(%rdi), %xmm1
movq %xmm1, %rbx
jmp 0xaa32
movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
jmp 0xaad2
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0xab1d
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r14
movq 0x8(%rax), %r12
movq %r12, %rax
subq %r14, %rax
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
subq %r15, %rcx
cmpq %rcx, %rax
jne 0xab1b
cmpq %r12, %r14
sete %bl
je 0xab1d
movq %r14, %rdi
movq %r15, %rsi
callq 0xa92a
testb %al, %al
je 0xab1d
addq $0x10, %r14
addq $0x10, %r15
cmpq %r12, %r14
sete %bl
je 0xab1d
movq %r14, %rdi
movq %r15, %rsi
callq 0xa92a
addq $0x10, %r14
addq $0x10, %r15
testb %al, %al
jne 0xaa89
jmp 0xab1d
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %rdx
cmpq 0x8(%rcx), %rdx
jne 0xab1b
testq %rdx, %rdx
je 0xab1d
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x4340
testl %eax, %eax
sete %bl
jmp 0xab1d
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x28(%rax), %rdx
cmpq 0x28(%rcx), %rdx
jne 0xab1b
movq 0x18(%rax), %rdi
addq $0x8, %rax
movq 0x18(%rcx), %rdx
movq %rax, %rsi
callq 0xab60
movl %eax, %ebx
jmp 0xab1d
movl %eax, %r8d
xorb $0x6, %r8b
orb %dl, %r8b
je 0xa958
xorb $0x5, %al
orb %cl, %al
je 0xa958
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x5712
nop
| /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_string<char, std::char_traits<char>, std::allocator<char>>, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 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::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::set_begin() | 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;
}
case basic_json::value_t::array:
{
m_it.array_iterator = m_object->m_value.array->begin();
break;
}
case basic_json::value_t::null:
{
// set to end so begin()==end() is true: null is empty
m_it.primitive_iterator.set_end();
break;
}
default:
{
m_it.primitive_iterator.set_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, 0x18(%rdi)
retq
pushq %rax
leaq 0x10970(%rip), %rdi # 0x1b90a
leaq 0x10509(%rip), %rsi # 0x1b4aa
leaq 0x1120e(%rip), %rcx # 0x1c1b6
movl $0x22f9, %edx # imm = 0x22F9
callq 0x4220
| /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::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::set_end() | 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;
}
case basic_json::value_t::array:
{
m_it.array_iterator = m_object->m_value.array->end();
break;
}
default:
{
m_it.primitive_iterator.set_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 # 0x1b90a
leaq 0x104b1(%rip), %rsi # 0x1b4aa
leaq 0x1132c(%rip), %rcx # 0x1c32c
movl $0x231e, %edx # imm = 0x231E
callq 0x4220
| /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::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::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>::iter_impl<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&) const | 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_object != nullptr);
switch (m_object->m_type)
{
case basic_json::value_t::object:
{
return (m_it.object_iterator == other.m_it.object_iterator);
}
case basic_json::value_t::array:
{
return (m_it.array_iterator == other.m_it.array_iterator);
}
default:
{
return (m_it.primitive_iterator == other.m_it.primitive_iterator);
}
}
} | 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(%rsi), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x41b0
movq %rax, %rbx
leaq 0x10bbd(%rip), %rsi # 0x1bc20
movq %rax, %rdi
callq 0x4210
movq 0x1cf1e(%rip), %rsi # 0x27f90
movq 0x1cf2f(%rip), %rdx # 0x27fa8
movq %rbx, %rdi
callq 0x44f0
leaq 0x10882(%rip), %rdi # 0x1b90a
leaq 0x1041b(%rip), %rsi # 0x1b4aa
leaq 0x1140a(%rip), %rcx # 0x1c4a0
movl $0x23e2, %edx # imm = 0x23E2
callq 0x4220
movq %rax, %r14
movq %rbx, %rdi
callq 0x4280
movq %r14, %rdi
callq 0x4530
nop
| /antonio-ramadas[P]nurse-rostering-solution/code/json.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.