Hugging Face's logo

Datasets:
LLM4Binary
/
decompile-bench

Modalities:
Text
Formats:
arrow
Size:
1M - 10M
Libraries:
Datasets
License:
Dataset card Data Studio Files Community
1
Dataset Viewer (First 5GB)
Auto-converted to Parquet
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
End of preview. Expand in Data Studio

This is the benchmark of LLM4Decompile project.

Downloads last month
253
Size of the auto-converted Parquet files (First 5GB):
1.39 GB
Number of rows (First 5GB):
1,359,586
Estimated number of rows:
2,296,239

Collection including LLM4Binary/decompile-bench