name string | code string | asm string | file string |
|---|---|---|---|
maybe_new_socket | static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) {
struct sockaddr_storage saddr;
socklen_t slen;
if (domain == AF_UNSPEC) {
handle->flags |= flags;
return 0;
}
if (uv__stream_fd(handle) != -1) {
if (flags & UV_HANDLE_BOUND) {
if (handle->flags & UV_HANDLE_B... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testl %esi, %esi
je 0x628399
movl 0xb8(%rbx), %edi
cmpl $-0x1, %edi
je 0x6283af
btl $0xd, %r14d
jb 0x6283ea
orl %r14d, 0x58(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv__tcp_connect | int uv__tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr* addr,
unsigned int addrlen,
uv_connect_cb cb) {
int err;
int r;
assert(handle->type == UV_TCP);
if (handle->connect_req != NULL)
return UV_EALREAD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xc, 0x10(%rsi)
jne 0x628752
movq %rsi, %rbx
movl $0xffffff8e, %r13d # imm = 0xFFFFFF8E
cmpq $0x0, 0x78(%rsi)
jne 0x6286e2
movq %rdi, %r14
movq %r8, (%rsp)
cmpl $0x0, 0xe8(%rbx)
je 0x6286c6
movl $0x2, 0x8(%r14)
movq 0x8(%rbx), %rax
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_tcp_getsockname | int uv_tcp_getsockname(const uv_tcp_t* handle,
struct sockaddr* name,
int* namelen) {
if (handle->delayed_error)
return handle->delayed_error;
return uv__getsockpeername((const uv_handle_t*) handle,
getsockname,
... | movl 0xe8(%rdi), %eax
testl %eax, %eax
je 0x6287c7
retq
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x235694(%rip), %rsi # 0x85de68
jmp 0x6201f4
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_tcp_keepalive | int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
int err;
if (uv__stream_fd(handle) != -1) {
err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);
if (err)
return err;
}
if (on)
handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
else
handle->flags &= ~UV_HANDLE_TCP_KEEPA... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0xb8(%rdi), %edi
cmpl $-0x1, %edi
je 0x628a6d
movl %ebp, %esi
callq 0x628951
testl %eax, %eax
jne 0x628a86
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movl $0xfdffffff, %ecx # imm = 0xFDFFFFFF
andl 0x58(%rbx), %ecx
shll $0x19, %eax
orl %ecx, %ea... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_barrier_wait | int uv_barrier_wait(uv_barrier_t* barrier) {
int rc;
rc = pthread_barrier_wait(barrier);
if (rc != 0)
if (rc != PTHREAD_BARRIER_SERIAL_THREAD)
abort();
return rc == PTHREAD_BARRIER_SERIAL_THREAD;
} | pushq %rax
callq 0x40c00
leal -0x1(%rax), %ecx
cmpl $-0x3, %ecx
jbe 0x628b88
xorl %ecx, %ecx
cmpl $-0x1, %eax
sete %cl
movl %ecx, %eax
popq %rcx
retq
callq 0x40a90
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_mutex_init | int uv_mutex_init(uv_mutex_t* mutex) {
#if defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
return UV__ERR(pthread_mutex_init(mutex, NULL));
#else
pthread_mutexattr_t attr;
int err;
if (pthread_mutexattr_init(&attr))
abort();
if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
abort... | pushq %rax
xorl %esi, %esi
callq 0x3fcd0
negl %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_sem_post | void uv_sem_post(uv_sem_t* sem) {
if (platform_needs_custom_semaphore)
uv__custom_sem_post(sem);
else
uv__sem_post(sem);
} | pushq %rbx
cmpl $0x0, 0x242cce(%rip) # 0x86bc84
je 0x628feb
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x3f8d0
testl %eax, %eax
jne 0x628ff6
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
testl %eax, %eax
jne 0x628fe1
leaq 0x28(%rbx), %rdi
callq 0x40970
testl %eax, %eax
jne 0x628ff6
movq %rbx, %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_sem_trywait | int uv_sem_trywait(uv_sem_t* sem) {
if (platform_needs_custom_semaphore)
return uv__custom_sem_trywait(sem);
else
return uv__sem_trywait(sem);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0x242c09(%rip) # 0x86bc84
je 0x6290b7
movq (%r14), %r14
movq %r14, %rdi
callq 0x628da0
movl $0xfffffff5, %ebx # imm = 0xFFFFFFF5
testl %eax, %eax
jne 0x6290db
movl 0x58(%r14), %eax
testl %eax, %eax
je 0x6290e5
decl %eax
movl %eax, 0x58(%r14)
movq %r14... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_cond_destroy | void uv_cond_destroy(uv_cond_t* cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mute... | pushq %rax
callq 0x3f9b0
testl %eax, %eax
jne 0x629175
popq %rax
retq
callq 0x40a90
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv__tcsetattr | int uv__tcsetattr(int fd, int how, const struct termios *term) {
int rc;
do
rc = tcsetattr(fd, how, term);
while (rc == -1 && errno == EINTR);
if (rc == -1)
return UV__ERR(errno);
return 0;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl %r14d, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x40290
cmpl $-0x1, %eax
jne 0x62928a
callq 0x415e0
movl (%rax), %eax
cmpl $0x4, %eax
je 0x629268
negl %eax
jmp 0x62928c
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv_guess_handle | uv_handle_type uv_guess_handle(uv_file file) {
struct sockaddr_storage ss;
struct stat s;
socklen_t len;
int type;
if (file < 0)
return UV_UNKNOWN_HANDLE;
if (isatty(file))
return UV_TTY;
if (fstat(file, &s)) {
#if defined(__PASE__)
/* On ibmi receiving RST from TCP instead of FIN immediate... | testl %edi, %edi
js 0x62942a
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movl %edi, %ebx
callq 0x41210
movl %eax, %ecx
movl $0xe, %eax
testl %ecx, %ecx
jne 0x629421
leaq 0x90(%rsp), %rsi
movl %ebx, %edi
callq 0x41090
testl %eax, %eax
je 0x62942d
xorl %eax, %eax
addq $0x120, %rsp # imm = 0x120
popq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv_tty_get_winsize | int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
struct winsize ws;
int err;
do
err = ioctl(uv__stream_fd(tty), TIOCGWINSZ, &ws);
while (err == -1 && errno == EINTR);
if (err == -1)
return UV__ERR(errno);
*width = ws.ws_col;
*height = ws.ws_row;
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movl 0xb8(%r15), %edi
movl $0x5413, %esi # imm = 0x5413
movq %r12, %rdx
xorl %eax, %eax
callq 0x3f3d0
cmpl $-0x1, %eax
jne 0x6296b4
callq 0x415e0
movl (%rax), %eax
cmpl $0x4, %eax
je 0x629689... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv__udp_finish_close | void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;
assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
assert(handle->io_watcher.fd == -1);
while (!QUEUE_EMPTY(&handle->write_queue)) {
q = QUEUE_HEAD(&handle->write_queue);
QUEUE_REMOVE(q);
req = QUEUE_DATA(q,... | pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
movl $0x5, %esi
callq 0x61f927
testl %eax, %eax
jne 0x62981e
cmpl $-0x1, 0xb0(%rbx)
jne 0x62983d
leaq 0xb8(%rbx), %rax
movq 0xb8(%rbx), %rcx
cmpq %rcx, %rax
je 0x6297ff
leaq 0xc8(%rbx), %rdx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
movq %rsi, (%rdi)
movq 0x8(%rcx), %rdi
movq %r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_bind | int uv__udp_bind(uv_udp_t* handle,
const struct sockaddr* addr,
unsigned int addrlen,
unsigned int flags) {
int err;
int yes;
int fd;
/* Check for bad flags. */
if (flags & ~(UV_UDP_IPV6ONLY | UV_UDP_REUSEADDR | UV_UDP_LINUX_RECVERR))
return UV_EINVAL;
... | movl $0xffffffea, %eax # imm = 0xFFFFFFEA
testl $0xffffffda, %ecx # imm = 0xFFFFFFDA
je 0x629a24
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x1, %r15b
je 0x629a4c
cmpw $0xa, (%r14)
jne 0x629b79
movl 0xb... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_source_membership | int uv_udp_set_source_membership(uv_udp_t* handle,
const char* multicast_addr,
const char* interface_addr,
const char* source_addr,
uv_membership membership) {
#if !defined(__OpenBSD__) &&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x61dc19
testl %eax, %eax
je 0x62ad11
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
xorl %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_uptime | int uv_uptime(double* uptime) {
static volatile int no_clock_boottime;
char buf[128];
struct timespec now;
int r;
/* Try /proc/uptime first, then fallback to clock_gettime(). */
if (0 == uv__slurp("/proc/uptime", buf, sizeof(buf)))
if (1 == sscanf(buf, "%lf", uptime))
return 0;
/* Try CLOCK_B... | pushq %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0xb0150(%rip), %rdi # 0x6dbdc8
leaq 0x10(%rsp), %rsi
movl $0x80, %edx
callq 0x61fa26
testl %eax, %eax
jne 0x62bca8
leaq 0xb017a(%rip), %rsi # 0x6dbe0c
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3f280
cmpl $0x1, %eax
j... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv__read_proc_meminfo | static uint64_t uv__read_proc_meminfo(const char* what) {
uint64_t rc;
char* p;
char buf[4096]; /* Large enough to hold all of /proc/meminfo. */
if (uv__slurp("/proc/meminfo", buf, sizeof(buf)))
return 0;
p = strstr(buf, what);
if (p == NULL)
return 0;
p += strlen(what);
rc = 0;
sscanf(p... | pushq %r14
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
movq %rdi, %rbx
leaq 0x74977(%rip), %rdi # 0x6a0f30
leaq 0x10(%rsp), %rsi
movl $0x1000, %edx # imm = 0x1000
callq 0x61fa26
testl %eax, %eax
je 0x62c5d0
xorl %eax, %eax
jmp 0x62c617
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x40020
testq %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_get_constrained_memory | static uint64_t uv__read_cgroups_uint64(const char* cgroup, const char* param) {
char filename[256];
char buf[32]; /* Large enough to hold an encoded uint64_t. */
uint64_t rc;
rc = 0;
snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%s/%s", cgroup, param);
if (0 == uv__slurp(filename, buf, sizeof(buf)... | pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq $0x0, 0x8(%rsp)
leaq 0xaf8d6(%rip), %rdx # 0x6dbf48
leaq 0x8d8f7(%rip), %rcx # 0x6b9f70
leaq 0xaf760(%rip), %r8 # 0x6dbde0
xorl %ebx, %ebx
leaq 0x30(%rsp), %r14
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
c... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_loadavg | void uv_loadavg(double avg[3]) {
struct sysinfo info;
char buf[128]; /* Large enough to hold all of /proc/loadavg. */
if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf)))
if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]))
return;
if (sysinfo(&info) < 0)
return;
avg[0] = (doubl... | pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0xaf70c(%rip), %rdi # 0x6dbdf6
leaq 0x70(%rsp), %rsi
movl $0x80, %edx
callq 0x61fa26
testl %eax, %eax
jne 0x62c720
leaq 0x8(%rbx), %rcx
leaq 0x10(%rbx), %r8
leaq 0xaf6f8(%rip), %rsi # 0x6dbe04
leaq 0x70(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3f280
cm... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv__inotify_fork | int uv__inotify_fork(uv_loop_t* loop, void* old_watchers) {
/* Open the inotify_fd, and re-arm all the inotify watchers. */
int err;
struct watcher_list* tmp_watcher_list_iter;
struct watcher_list* watcher_list;
struct watcher_list tmp_watcher_list;
QUEUE queue;
QUEUE* q;
uv_fs_event_t* handle;
char* ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
testq %rsi, %rsi
je 0x62c9b3
movq %rdi, %rbx
movq %rsi, 0x340(%rdi)
leaq 0x40(%rsp), %rax
movq %rax, (%rax)
movq %rax, 0x8(%rax)
leaq 0x18(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, %rbp
movq (%rax), %rax
movq %rax, %rc... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv_fs_event_stop | int uv_fs_event_stop(uv_fs_event_t* handle) {
struct watcher_list* w;
if (!uv__is_active(handle))
return 0;
w = find_watcher(handle->loop, handle->wd);
assert(w != NULL);
handle->wd = -1;
handle->path = NULL;
uv__handle_stop(handle);
QUEUE_REMOVE(&handle->watchers);
maybe_free_watcher_list(w, ... | pushq %rax
movl 0x58(%rdi), %ecx
testb $0x4, %cl
je 0x62ca7b
movq 0x8(%rdi), %rdx
movq 0x340(%rdx), %rax
testq %rax, %rax
je 0x62ca1b
movl 0x80(%rdi), %esi
cmpl %esi, 0x40(%rax)
jg 0x62ca13
jge 0x62ca3a
addq $0x8, %rax
movq (%rax), %rax
testq %rax, %rax
jne 0x62ca08
leaq 0xaf604(%rip), %rdi # 0x6dc026
leaq 0xaf55f(... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv_fs_event_start | int uv_fs_event_start(uv_fs_event_t* handle,
uv_fs_event_cb cb,
const char* path,
unsigned int flags) {
struct watcher_list* w;
size_t len;
int events;
int err;
int wd;
if (uv__is_active(handle))
return UV_EINVAL;
err = init_inotify(h... | movl $0xffffffea, %eax # imm = 0xFFFFFFEA
testb $0x4, 0x58(%rdi)
jne 0x62d249
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpl $-0x1, 0x348(%r15)
jne 0x62ceec
movl $0x80800, %edi # imm = 0x80800
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv__sendmmsg | int uv__sendmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) {
#if defined(__i386__)
unsigned long args[4];
int rc;
args[0] = (unsigned long) fd;
args[1] = (unsigned long) mmsg;
args[2] = (unsigned long) vlen;
args[3] = /* flags */ 0;
/* socketcall() raises EINVAL when SYS_SENDMMSG is not suppo... | movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %esi
movl $0x133, %edi # imm = 0x133
xorl %r8d, %r8d
xorl %eax, %eax
jmp 0x3f6e0
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-syscalls.c |
uv__fs_copy_file_range | ssize_t
uv__fs_copy_file_range(int fd_in,
off_t* off_in,
int fd_out,
off_t* off_out,
size_t len,
unsigned int flags)
{
#ifdef __NR_copy_file_range
return syscall(__NR_copy_file_range,
fd... | pushq %rax
movq %r8, %rax
movq %rcx, %r8
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %esi
movl %r9d, (%rsp)
movl $0x146, %edi # imm = 0x146
movq %rax, %r9
xorl %eax, %eax
callq 0x3f6e0
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-syscalls.c |
uv_fs_poll_start | int uv_fs_poll_start(uv_fs_poll_t* handle,
uv_fs_poll_cb cb,
const char* path,
unsigned int interval) {
struct poll_ctx* ctx;
uv_loop_t* loop;
size_t len;
int err;
if (uv_is_active((uv_handle_t*)handle))
return 0;
loop = handle->loop;
le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
callq 0x61f139
xorl %r12d, %r12d
testl %eax, %eax
je 0x62d869
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r1... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_fs_poll_stop | int uv_fs_poll_stop(uv_fs_poll_t* handle) {
struct poll_ctx* ctx;
if (!uv_is_active((uv_handle_t*)handle))
return 0;
ctx = handle->poll_ctx;
assert(ctx != NULL);
assert(ctx->parent_handle == handle);
/* Close the timer if it's active. If it's inactive, there's a stat request
* in progress and poll... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x61f139
testl %eax, %eax
je 0x62dc1c
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x62dc26
cmpq %rbx, (%r14)
jne 0x62dc45
addq $0x28, %r14
movq %r14, %rdi
callq 0x61f139
testl %eax, %eax
je 0x62dc02
leaq 0x6a(%rip), %rsi # 0x62dc64
movq %r14, %rdi
callq 0x61eb... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_inet_pton | int uv_inet_pton(int af, const char* src, void* dst) {
if (src == NULL || dst == NULL)
return UV_EINVAL;
switch (af) {
case AF_INET:
return (inet_pton4(src, dst));
case AF_INET6: {
int len;
char tmp[UV__INET6_ADDRSTRLEN], *s, *p;
s = (char*) src;
p = strchr(src, '%');
if (p != NULL)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
jne 0x62e36a
movq %rdx, %rbx
movq %rsi, %r13
cmpl $0xa, %edi
je 0x62e122
movl $0xffffff9f, %ecx # imm = 0xFFFFFF9F
cmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_pton4 | static int inet_pton4(const char *src, unsigned char *dst) {
static const char digits[] = "0123456789";
int saw_digit, octets, ch;
unsigned char tmp[sizeof(struct in_addr)], *tp;
saw_digit = 0;
octets = 0;
*(tp = tmp) = 0;
while ((ch = *src++) != '\0') {
const char *pch;
if ((pch = strchr(digits... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
leaq 0xc(%rsp), %r12
movb $0x0, (%r12)
xorl %ebx, %ebx
leaq 0xadea8(%rip), %r15 # 0x6dc24c
movq $0x0, (%rsp)
xorl %r13d, %r13d
movsbl (%r14), %ebp
testl %ebp, %ebp
je 0x62e44e
movl $0xb, %edx
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
uv__strtok | char* uv__strtok(char* str, const char* sep, char** itr) {
const char* sep_itr;
char* tmp;
char* start;
if (str == NULL)
start = tmp = *itr;
else
start = tmp = str;
if (tmp == NULL)
return NULL;
while (*tmp != '\0') {
sep_itr = sep;
while (*sep_itr != '\0') {
if (*tmp == *sep_... | movq %rdi, %rax
testq %rdi, %rdi
jne 0x62e4c4
movq (%rdx), %rax
testq %rax, %rax
je 0x62e50d
movb (%rax), %cl
testb %cl, %cl
je 0x62e4f9
movb (%rsi), %dil
incq %rsi
movq %rax, %r8
movq %rsi, %r9
movl %edi, %r10d
testb %dil, %dil
je 0x62e4ee
cmpb %r10b, %cl
je 0x62e501
movb (%r9), %r10b
incq %r9
testb %r10b, %r10b
jne 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/strtok.c |
post | static void post(QUEUE* q, enum uv__work_kind kind) {
uv_mutex_lock(&mutex);
if (kind == UV__WORK_SLOW_IO) {
/* Insert into a separate queue. */
QUEUE_INSERT_TAIL(&slow_io_pending_wq, q);
if (!QUEUE_EMPTY(&run_slow_work_message)) {
/* Running slow I/O tasks is already scheduled => Nothing to do he... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x23d85d(%rip), %rdi # 0x86be20
callq 0x628d8f
cmpl $0x2, %ebp
jne 0x62e5fc
leaq 0x23d8ac(%rip), %rax # 0x86be80
movq %rax, (%rbx)
movq 0x23d8aa(%rip), %rax # 0x86be88
movq %rax, 0x8(%rbx)
movq %rbx, (%rax)
movq %rbx, 0x23d89c(%rip) # 0x8... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
uv__queue_done | static void uv__queue_done(struct uv__work* w, int err) {
uv_work_t* req;
req = container_of(w, uv_work_t, work_req);
uv__req_unregister(req->loop, req);
if (req->after_work_cb == NULL)
return;
req->after_work_cb(req, err);
} | movq -0x18(%rdi), %rax
movl 0x20(%rax), %ecx
testl %ecx, %ecx
je 0x62e985
decl %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rdi), %rax
testq %rax, %rax
je 0x62e984
addq $-0x58, %rdi
jmpq *%rax
retq
pushq %rax
leaq 0xabcbd(%rip), %rdi # 0x6da64a
leaq 0xad910(%rip), %rsi # 0x6dc2a4
leaq 0xad975(%rip), %rcx # 0x6dc31... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
uv_cancel | int uv_cancel(uv_req_t* req) {
struct uv__work* wreq;
uv_loop_t* loop;
switch (req->type) {
case UV_FS:
loop = ((uv_fs_t*) req)->loop;
wreq = &((uv_fs_t*) req)->work_req;
break;
case UV_GETADDRINFO:
loop = ((uv_getaddrinfo_t*) req)->loop;
wreq = &((uv_getaddrinfo_t*) req)->work_req;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
addl $-0x6, %eax
movl $0xffffffea, %ebp # imm = 0xFFFFFFEA
cmpl $0x4, %eax
ja 0x62eaad
movq %rdi, %r15
movl %eax, %eax
leaq 0xad970(%rip), %rcx # 0x6dc340
movq (%rcx,%rax,8), %rcx
leaq 0xad98d(%rip), %rdx # 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
x2nmodp | local z_crc_t x2nmodp(n, k)
z_off64_t n;
unsigned k;
{
z_crc_t p;
p = (z_crc_t)1 << 31; /* x^0 == 1 */
while (n) {
if (n & 1)
p = multmodp(x2n_table[k & 31], p);
n >>= 1;
k++;
}
return p;
} | testq %rdi, %rdi
je 0x62f188
movl $0x3, %ecx
movl $0x80000000, %esi # imm = 0x80000000
leaq 0xaf667(%rip), %rdx # 0x6de790
testb $0x1, %dil
jne 0x62f146
movl %esi, %eax
movq %rdi, %r8
sarq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x62f129
jmp 0x62f187
movl %ecx, %eax
andl $0x1f, %eax
mo... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
cm_zlib_crc32_combine_op | uLong crc32_combine_op(crc1, crc2, op)
uLong crc1;
uLong crc2;
uLong op;
{
return multmodp(op, crc1) ^ crc2;
} | xorl %eax, %eax
movl $0x80000000, %ecx # imm = 0x80000000
testl %edx, %ecx
je 0x62f1bd
xorl %edi, %eax
leal -0x1(%rcx), %r8d
testl %edx, %r8d
je 0x62f1dc
shrl %ecx
movl %edi, %r8d
shrl %r8d
movl %r8d, %r9d
xorl $0xedb88320, %r9d # imm = 0xEDB88320
testb $0x1, %dil
cmovel %r8d, %r9d
movl %r9d, %edi
jmp 0x62f... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
cm_zlib_deflateEnd | int ZEXPORT deflateEnd (strm)
z_streamp strm;
{
int status;
if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
status = strm->state->status;
/* Deallocate in reverse order of allocations: */
TRY_FREE(strm, strm->state->pending_buf);
TRY_FREE(strm, strm->state->head);
TRY_FREE(strm, s... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x62f859
movl %eax, %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
testl %ecx, %ecx
jne 0x62f57f
movq 0x38(%rbx), %rsi
movl 0x8(%rsi), %ebp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x62f51d
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%r... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
std::pair<llvm::StringRef, llvm::StringRef>& llvm::SmallVectorTemplateBase<std::pair<llvm::StringRef, llvm::StringRef>, true>::growAndEmplaceBack<llvm::StringRef&, llvm::StringRef&>(llvm::StringRef&, llvm::StringRef&) | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Use push_back with a copy in case Args has an internal reference,
// side-stepping reference invalidation problems without losing the realloc
// optimization.
push_back(T(std::forward<ArgTypes>(Args)...));
return this->back();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups (%rdx), %xmm0
movaps %xmm0, 0x10(%rsi)
movl $0x1, %edx
callq 0x303ce
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
shlq $0x5, %rdx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rcx,%rdx)
movups %xmm... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseMapPair<clang::FileID, std::pair<clang::FileID, unsigned int>>* llvm::DenseMapBase<llvm::DenseMap<clang::FileID, std::pair<clang::FileID, unsigned int>, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, std::pair<clang::FileID, unsigned int>>>, clang::FileID, std::pai... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x358cf
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x3... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [40], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<bool>>(char const (&) [40], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<bool> const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x3aaca
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0xe814f(%... | /llvm/Support/CommandLine.h |
llvm::cl::Option::Option(llvm::cl::NumOccurrencesFlag, llvm::cl::OptionHidden) | explicit Option(enum NumOccurrencesFlag OccurrencesFlag,
enum OptionHidden Hidden)
: NumOccurrences(0), Occurrences(OccurrencesFlag), Value(0),
HiddenFlag(Hidden), Formatting(NormalFormatting), Misc(0),
FullyInitialized(false), Position(0), AdditionalVals(0) {
Categories.push... | pushq %rbx
leaq 0xea32e(%rip), %rax # 0x124e00
addq $0x10, %rax
movq %rax, (%rdi)
movw $0x0, 0x8(%rdi)
movzwl 0xa(%rdi), %eax
andl $0x7, %esi
andl $0xffff8000, %eax # imm = 0xFFFF8000
shll $0x5, %edx
andl $0x60, %edx
orl %esi, %edx
orl %eax, %edx
movw %dx, 0xa(%rdi)
leaq 0x40(%rdi), %rbx
leaq 0x50(%rdi), %rax... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [17], llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [17], llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x3aaca
movb %bpl, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb %bpl, 0x91(%rbx)
leaq 0xe7192(%rip), %rax # 0x1228a8
addq $0x10,... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [30], llvm::cl::initializer<int>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [30], llvm::cl::initializer<int> const&, llvm::cl::OptionHidden cons... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x15120
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x51cf8
movq (%r15), %rax
movl (%rax), %eax
movl %eax, 0x80(%r13)
movb $0x1, 0x94(%r13)
movl %eax, 0x9... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [25], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [25], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x15120
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x51cf8
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [22], llvm::cl::initializer<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [22], llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x15120
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x51cf8
movq (%r12), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [25], llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [25], llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %rsi, %rdi
callq 0x15120
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x51cf8
movl (%r12), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
or... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [36], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [36], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> cons... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x15120
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x51cf8
movl (%r15), %eax
movzwl 0xa(%r13), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
or... | /llvm/Support/CommandLine.h |
llvm::DebugCounter::addCounter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | unsigned addCounter(const std::string &Name, const std::string &Desc) {
unsigned Result = RegisteredCounters.insert(Name);
Counters[Result] = {};
Counters[Result].Desc = Desc;
return Result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %r14
addq $0x18, %rdi
callq 0x3f0a0
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %r15
leaq 0x38(%rsp), %rbp
xorl %eax, %eax
movb %al, -0x18(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x28(%rbp)
mov... | /llvm/Support/DebugCounter.h |
llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [26], llvm::cl::OptionHidden, llvm::cl::initializer<bool>>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [26], llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x15120
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x51cf8
movl (%r14), %eax
movzwl 0xa(%r12), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
mo... | /llvm/Support/CommandLine.h |
llvm::cl::opt<llvm::PGOViewCountsType, false, llvm::cl::parser<llvm::PGOViewCountsType>>::getValueExpectedFlagDefault() const | enum ValueExpected getValueExpectedFlagDefault() const {
// If there is an ArgStr specified, then we are of the form:
//
// -opt=O2 or -opt O2 or -optO2
//
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
// -... | movq 0xa0(%rdi), %rcx
xorl %eax, %eax
cmpq $0x1, 0x18(%rcx)
adcl $0x2, %eax
retq
| /llvm/Support/CommandLine.h |
llvm::cl::parser<llvm::PGOViewCountsType>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, llvm::PGOViewCountsType&) | bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x409c9
movq 0x10(%rdi), %r13
shlq $0x4, %rax
leaq (%rax,%rax,2), %r... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [17], llvm::cl::LocationClass<bool>, llvm::cl::OptionHidden, llvm::cl::desc>(char const (&) [17], llvm::cl::LocationClass<bool> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x3aaca
movq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0xe07f9(%rip), %rax # 0x1228a8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0xe0867(%rip... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [29], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<bool>>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [29], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<bool> const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x15120
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x51cf8
movl (%r12), %eax
movzwl 0xa(%rbx), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
or... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [24], llvm::cl::OptionHidden, llvm::cl::initializer<int>>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [24], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x15120
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x51cf8
movl (%r14), %eax
movzwl 0xa(%r12), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
mo... | /llvm/Support/CommandLine.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [30], llvm::cl::initializer<bool>, llvm::cl::desc>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [30], llvm::cl::initializer<bool> const&, llvm::cl::desc const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
callq 0x15120
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x51cf8
movq (%r14), %rax
movb (%rax), %cl
movb %cl, 0x80(%r12)
movb $0x1, 0x91(%r12)
movb (%rax), %al
movb %al, 0x90... | /llvm/Support/CommandLine.h |
llvm::AMDGPU::parseArchAMDGCN(llvm::StringRef) | AMDGPU::GPUKind llvm::AMDGPU::parseArchAMDGCN(StringRef CPU) {
for (const auto &C : AMDGCNGPUs) {
if (CPU == C.Name)
return C.Kind;
}
return AMDGPU::GPUKind::GK_NONE;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0xd72cb(%rip), %r13 # 0x123f50
testq %r14, %r14
sete %cl
cmpq %r14, 0x8(%r12,%r13)
sete %al
setne %dl
orb %cl, %dl
jne 0x4ccae
movq (%r12,%r13), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x153b0
testl %eax... | /TargetParser/TargetParser.cpp |
parseFormat(llvm::StringRef) | static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
// "xcoff" must come before "coff" because of the order-dependendent
// pattern matching.
.EndsWith("xcoff", Triple::XCOFF)
.EndsWith("coff", Triple::COFF)
... | movabsq $0x100000000, %rcx # imm = 0x100000000
cmpq $0x5, %rsi
jae 0x50e3c
xorl %eax, %eax
jmp 0x50e5c
movl $0x666f6378, %edx # imm = 0x666F6378
xorl -0x5(%rdi,%rsi), %edx
movzbl -0x1(%rdi,%rsi), %r8d
xorl $0x66, %r8d
leaq 0x8(%rcx), %r9
xorl %eax, %eax
orl %edx, %r8d
cmoveq %r9, %rax
cmpq $0x4, %rsi
jb 0x50... | /TargetParser/Triple.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
testl %edx, %edx
je 0x5178b
subq $0x18, %rsp
movl 0x80(%rdi), %edx
leaq 0xd125e(%rip), %rax # 0x1229b0
addq $0x10, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movl 0x90(%rdi), %eax
movl %eax, 0x8(%rcx)
movb 0x94(%rdi), %al
movb %al, 0xc(%rcx)
leaq 0xd1219(%rip), %rax # 0x122990
addq $0x10, %rax
m... | /llvm/Support/CommandLine.h |
llvm::cl::OptionCategory::registerCategory() | void OptionCategory::registerCategory() {
GlobalParser->registerCategory(this);
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0xeead1(%rip), %rax # 0x140888
testq %rax, %rax
jne 0x51dd6
leaq 0xeeac5(%rip), %rdi # 0x140888
leaq 0x20a0(%rip), %rsi # 0x53e6a
leaq 0x2167(%rip), %rdx # 0x53f38
callq 0x561fc
movq 0xeeaab(%rip), %rsi # 0x140888
addq $0x78, %rsi
leaq 0x8(%rsp), %r... | /Support/CommandLine.cpp |
operator new(unsigned long, (anonymous namespace)::NamedBufferAlloc const&) | void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
SmallString<256> NameBuf;
StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
// We use malloc() and manually handle it returning null instead of calling
// operator new because we need all uses of NamedBufferAlloc to be
// deallocated with a cal... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %r14
leaq 0x20(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x100, -0x8(%r13) # imm = 0x100
movq (%rsi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2fe12
movq %rax, %r12
movq %rdx, %r15
leaq (%r14... | /Support/MemoryBuffer.cpp |
llvm::SmallVectorBase<unsigned int>::grow_pod(void*, unsigned long, unsigned long) | void SmallVectorBase<Size_T>::grow_pod(void *FirstEl, size_t MinSize,
size_t TSize) {
size_t NewCapacity = getNewCapacity<Size_T>(MinSize, TSize, this->capacity());
void *NewElts;
if (BeginX == FirstEl) {
NewElts = llvm::safe_malloc(NewCapacity * TSize);
if (NewElts ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movq %rdx, %rdi
callq 0x56d90
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rbp
imulq %r15, %rbp
cmpq %r12, %rdi
je 0x56ec6
movq %rbp, %rsi
callq 0x15040
testq %rax, %rax
jne... | /Support/SmallVector.cpp |
llvm::operator<<(llvm::raw_ostream&, llvm::VersionTuple const&) | raw_ostream &llvm::operator<<(raw_ostream &Out, const VersionTuple &V) {
Out << V.getMajor();
if (std::optional<unsigned> Minor = V.getMinor())
Out << '.' << *Minor;
if (std::optional<unsigned> Subminor = V.getSubminor())
Out << '.' << *Subminor;
if (std::optional<unsigned> Build = V.getBuild())
Out... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x58574
movq (%r14), %r15
testq %r15, %r15
jns 0x583d2
movq %r15, %r12
shrq $0x20, %r12
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x583b3
leaq 0x1(%rax), %... | /Support/VersionTuple.cpp |
llvm::raw_ostream::indent(unsigned int) | raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
return write_padding<' '>(*this, NumSpaces);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x50, %esi
jae 0x58934
movl %ebp, %edx
leaq 0xae25e(%rip), %rsi # 0x106b80
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x58672
leaq 0xae245(%rip), %r14 # 0x106b80
cmpl $0x4f, %ebp
movl $0... | /Support/raw_ostream.cpp |
llvm::raw_fd_ostream::~raw_fd_ostream() | raw_fd_ostream::~raw_fd_ostream() {
if (FD >= 0) {
flush();
if (ShouldClose) {
if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
error_detected(EC);
}
}
#ifdef __MINGW32__
// On mingw, global dtors should not call exit().
// report_fatal_error() invokes exit(). We know report... | pushq %rbx
movq %rdi, %rbx
callq 0x58fbc
movl $0x60, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15050
nop
| /Support/raw_ostream.cpp |
fprintf | int fprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
rc = vfprintf( stream, format, ap );
va_end( ap );
return rc;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3f08
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)... | /DevSolar[P]pdclib/functions/stdio/fprintf.c |
strcat | char * strcat( char * _PDCLIB_restrict s1, const char * _PDCLIB_restrict s2 )
{
char * rc = s1;
if ( *s1 )
{
while ( *++s1 )
{
/* EMPTY */
}
}
while ( ( *s1++ = *s2++ ) )
{
/* EMPTY */
}
return rc;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4518
jmp 0x44ff
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, 0x1(%rax)
je 0x4516
jmp 0x44ff
jmp 0x4518
jmp 0x451a
mo... | /DevSolar[P]pdclib/functions/string/strcat.c |
try_realloc_chunk | static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb,
int can_move) {
mchunkptr newp = 0;
size_t oldsize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, oldsize);
if (RTCHECK(ok_address(m, p) && ok_inuse(p) &&
ok_next(p, next) && ok_pinuse(ne... | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
mmap_resize | static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) {
size_t oldsize = chunksize(oldp);
(void)flags; /* placate people compiling -Wunused */
if (is_small(nb)) /* Can't shrink mmap regions below small size */
return 0;
/* Keep old chunk if big enough but not too big */
if (oldsize ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
shrq $0x3, %rax
cmpq $0x20, %rax
jae 0xc32e
movq $0x0, -0x8(%rbp)
jmp 0xc47f
movq -0x30(%rbp),... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_init_file_t | struct _PDCLIB_file_t * _PDCLIB_init_file_t( struct _PDCLIB_file_t * stream )
{
struct _PDCLIB_file_t * rc = stream;
if ( rc == NULL )
{
if ( ( rc = (struct _PDCLIB_file_t *)malloc( sizeof( struct _PDCLIB_file_t ) ) ) == NULL )
{
/* No memory */
return NULL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd80e
movl $0x80, %edi
callq 0x4650
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xd80c
movq $0x0, -0x8(%rbp)
jmp 0xd8d6
jmp 0xd80e
movl $0x400, %edi # imm = 0x400
callq ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_init_file_t.c |
PDCLIB_prepread | int _PDCLIB_prepread( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx > stream->bufend ) ||
( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FREAD | _PDCLIB_FRW ) ) )
{
/* Func... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
ja 0xdaae
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0xe30, %eax # imm = 0xE30
cmpl $0x0, %eax
jne 0xdaae
movq -0x10(%rbp), %rax
movl 0x44(%rax)... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepread.c |
PDCLIB_print_hexa | static void _PDCLIB_print_hexa( int sign,
int exp,
int dec,
unsigned char const * mant,
size_t mant_dig,
struct _PDCLIB_status_t * status )
{
size_t excess_... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x12, %edx
callq 0x11220
movq $0x0, -0x58(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x28(%rbp), %rax
movl... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
fseek | int fseek( struct _PDCLIB_file_t * stream, long offset, int whence )
{
int rc;
_PDCLIB_LOCK( stream->mtx );
if ( stream->status & _PDCLIB_FWRITE )
{
if ( _PDCLIB_flushbuffer( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
}
stre... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x10990
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x10ba8
movq -0x10(%rbp), %rdi
callq 0x10650
cmpl $-0x1, %eax
jne 0x10ba... | /DevSolar[P]pdclib/functions/stdio/fseek.c |
PDCLIB_closeall | void _PDCLIB_closeall( void )
{
struct _PDCLIB_file_t * stream = _PDCLIB_filelist;
struct _PDCLIB_file_t * next;
while ( stream != NULL )
{
next = stream->next;
fclose( stream );
stream = next;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4e19(%rip), %rax # 0x160e8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x112fc
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c40
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x112d6
addq ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_closeall.c |
PDCLIB_strtox_prelim | const char * _PDCLIB_strtox_prelim( const char * p, char * sign, int * base )
{
/* skipping leading whitespace */
while ( isspace( (unsigned char)*p ) )
{
++p;
}
/* determining / skipping sign */
if ( *p != '+' && *p != '-' )
{
*sign = '+';
}
else
{
*sign... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
callq 0x116a0
cmpl $0x0, %eax
je 0x11483
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11464
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b,... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_strtox_prelim.c |
void asio::detail::epoll_reactor::add_timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>(asio::detail::timer_queue<asio::detail::chrono_time_traits<std::chrono::_V2::steady_clock, asio::wait_traits<std::chrono::_V2::steady_clock>>>&) | void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue)
{
do_add_timer_queue(queue);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x68(%rdi)
jne 0x61d70
leaq 0x40(%r14), %r15
movq %r15, %rdi
callq 0x4f9e0
movq 0x80(%r14), %rax
movq %rax, 0x8(%rbx)
movq %rbx, 0x80(%r14)
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4f570
movq 0x80(%r14), %rax
movq %rax, 0x8(%rbx)
mov... | /qicosmos[P]rest_rpc/tests/../thirdparty/asio/asio/detail/impl/epoll_reactor.hpp |
msgpack::v1::adaptor::convert<std::tuple<int>, void>::operator()(msgpack::v2::object const&, std::tuple<int>&) const | msgpack::object const& operator()(
msgpack::object const& o,
std::tuple<Args...>& v) const {
if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
StdTupleConverter<decltype(v), sizeof...(Args)>::convert(o, v);
return o;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x7, (%rsi)
jne 0x77e66
movq %rsi, %rbx
cmpl $0x0, 0x8(%rsi)
je 0x77e5b
movq %rdx, %r14
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rcx
movq %rsp, %rdi
movq %rcx, 0x10(%rdi)
movups (%rax), %xmm0
movaps %xmm0, (%rdi)
callq 0x6ae74
movl %eax, (%r14)
movq %rbx, %rax
addq $0x18, %rs... | /qicosmos[P]rest_rpc/tests/../thirdparty/msgpack-c/include/msgpack/v1/adaptor/cpp11/tuple.hpp |
std::tuple<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> rest_rpc::rpc_service::msgpack_codec::unpack<std::tuple<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(char const*, unsigned long) | T unpack(char const *data, size_t length) {
try {
msgpack::unpack(msg_, data, length);
return msg_.get().as<T>();
} catch (...) {
throw std::invalid_argument("unpack failed: Args not match!");
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %r10
movq %rax, (%r10)
movq %rax, 0x8(%r10)
movq %rax, 0x10(%r10)
movq %rax, 0x18(%r10)
movq %rax, 0x20(%r10)
movq %rax, 0x28(%r10)
xorl %r11d, %r11d
leaq 0x8(%rsp), %rax
mo... | /qicosmos[P]rest_rpc/include/rest_rpc/codec.h |
bool doctest::detail::ResultBuilder::binary_assert<0, int, int>(int const&, int const&) | DOCTEST_NOINLINE bool binary_assert(const DOCTEST_REF_WRAP(L) lhs,
const DOCTEST_REF_WRAP(R) rhs) {
m_failed = !RelationalComparator<comparison, L, R>()(lhs, rhs);
if(m_failed || getContextOptions()->success)
m_decomp = ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl (%rsi), %eax
cmpl (%rdx), %eax
movq %rdi, %rbx
setne 0x28(%rdi)
jne 0x7807b
callq 0x84217
cmpb $0x1, 0x6c(%rax)
jne 0x780a7
leaq 0x21056(%rip), %rdx # 0x990d8
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, ... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
msgpack::v1::packer<msgpack::v1::sbuffer>& msgpack::v1::adaptor::pack<char [2], void>::operator()<msgpack::v1::sbuffer>(msgpack::v1::packer<msgpack::v1::sbuffer>&, char const (&) [2]) const | msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const char(&v)[N]) const {
char const* p = v;
uint32_t size = checked_get_container_size(N);
char const* p2 = static_cast<char const*>(std::memchr(p, '\0', size));
uint32_t adjusted_size = p2 ? static_cast<uint32_t>(p2 - p) ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl $0x2, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x4f780
movl %eax, %ecx
subl %r14d, %ecx
testq %rax, %rax
movl $0x2, %ebp
cmovnel %ecx, %ebp
cmpl $0x1f, %ebp
ja 0x7982b
movl %ebp, %eax
orb $-0x60, %al
leaq 0x5(%rsp), %rsi
movb %al, ... | /qicosmos[P]rest_rpc/tests/../thirdparty/msgpack-c/include/msgpack/v1/adaptor/carray.hpp |
asio::detail::executor_function::executor_function<asio::detail::binder1<rest_rpc::rpc_client::call_t::start_timer()::'lambda'(std::error_code), std::error_code>, std::allocator<void>>(asio::detail::binder1<rest_rpc::rpc_client::call_t::start_timer()::'lambda'(std::error_code), std::error_code>, std::allocator<void> co... | explicit executor_function(F f, const Alloc& a)
{
// Allocate and construct an object to wrap the function.
typedef impl<F, Alloc> impl_type;
typename impl_type::ptr p = {
detail::addressof(a), impl_type::ptr::allocate(a), 0 };
impl_ = new (p.v) impl_type(ASIO_MOVE_CAST(F)(f), a);
p.v = 0;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %fs:-0x1e0, %rax
testq %rax, %rax
je 0x7d233
movq 0x8(%rax), %rdi
jmp 0x7d235
xorl %edi, %edi
movl $0x38, %esi
movl $0x8, %edx
callq 0x6489c
movq %rsp, %rdi
movq %rax, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movups (%r... | /qicosmos[P]rest_rpc/tests/../thirdparty/asio/asio/detail/executor_function.hpp |
asio::detail::executor_function::executor_function<asio::detail::binder0<rest_rpc::rpc_service::connection::response(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, rest_rpc::request_type)::'lambda'()>, std::allocator<void>>(asio::detail::binder0<rest_rpc::rpc_service::con... | explicit executor_function(F f, const Alloc& a)
{
// Allocate and construct an object to wrap the function.
typedef impl<F, Alloc> impl_type;
typename impl_type::ptr p = {
detail::addressof(a), impl_type::ptr::allocate(a), 0 };
impl_ = new (p.v) impl_type(ASIO_MOVE_CAST(F)(f), a);
p.v = 0;
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, (%rsp)
movq %fs:-0x1e0, %rax
testq %rax, %rax
je 0x7f42d
movq 0x8(%rax), %rdi
jmp 0x7f42f
xorl %edi, %edi
movl $0x48, %esi
movl $0x8, %edx
callq 0x6489c
movq %rsp, %rdi
movq %rax, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movups (%r... | /qicosmos[P]rest_rpc/tests/../thirdparty/asio/asio/detail/executor_function.hpp |
void rest_rpc::rpc_service::rpc_server::publish<char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*) | void publish(std::string key, std::string token, T data) {
{
std::unique_lock<std::mutex> lock(sub_mtx_);
if (sub_map_.empty())
return;
}
std::shared_ptr<std::string> shared_data =
get_shared_data<T>(std::move(data));
std::unique_lock<std::mutex> lock(sub_mtx_);
auto ran... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %rbx
movq %rdx, 0x30(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
leaq 0x298(%rdi), %r15
movq %rsp, %r14
movq %r15, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x63c9e
movb $0x1, 0x8(%r14)
movq 0x248(%r12), %r13
movq %r14... | /qicosmos[P]rest_rpc/include/rest_rpc/rpc_server.h |
void rest_rpc::rpc_service::router::register_handler<false, void (*)(std::weak_ptr<rest_rpc::rpc_service::connection>)>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(std::weak_ptr<rest_rpc::rpc_service::connection>), bool) | void register_handler(std::string const &name, Function f, bool pub = false) {
uint32_t key = MD5::MD5Hash32(name.data());
if (key2func_name_.find(key) != key2func_name_.end()) {
throw std::invalid_argument("duplicate registration key !");
} else {
key2func_name_.emplace(key, name);
return... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
cmpb $0x0, (%rdi,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x82397
decl %esi
callq 0x6b386
movq %rax, %rcx
bswapl %ecx
movl %ecx, 0x8(%rsp)
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %r8
xorl ... | /qicosmos[P]rest_rpc/include/rest_rpc/router.h |
doctest::skipPathFromFilename(char const*) | const char* skipPathFromFilename(const char* file) {
#ifndef DOCTEST_CONFIG_DISABLE
if(getContextOptions()->no_path_in_filenames) {
auto back = std::strrchr(file, '\\');
auto forward = std::strrchr(file, '/');
if(back || forward) {
if(back > forward)
forward = ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x35894(%rip), %rax # 0xb9a68
cmpb $0x1, 0x7c(%rax)
jne 0x8420c
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x4f770
movq %rax, %r14
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x4f770
cmpq %rax, %r14
movq %rax, %rcx
cmovaq %r14, %rcx
orq %rax, %r14
je 0x8420c
incq %rcx
mo... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
doctest::detail::Subcase::~Subcase() | Subcase::~Subcase() {
if(m_entered) {
// only mark the subcase stack as passed if no subcases have been skipped
if(g_cs->should_reenter == false)
g_cs->subcasesPassed.insert(g_cs->subcasesStack);
g_cs->subcasesStack.pop_back();
#if defined(__cpp_lib_uncaught_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x85510
movq 0x34672(%rip), %rsi # 0xb9a68
cmpb $0x0, 0x115c(%rsi)
jne 0x85412
leaq 0x1128(%rsi), %rdi
addq $0x1110, %rsi # imm = 0x1110
callq 0x922da
movq 0x3464f(%rip), %rcx #... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
doctest::detail::TestCase::TestCase(doctest::detail::TestCase const&) | TestCase::TestCase(const TestCase& other)
: TestCaseData() {
*this = other;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movb $0x17, %al
movb %al, 0x17(%rdi)
movb $0x0, 0x68(%rdi)
movb %al, 0x7f(%rdi)
callq 0x85714
addq $0x8, %rsp
popq %rbx
popq %r14
r... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
doctest::detail::isDebuggerActive() | ~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x4f070
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x12b83(%rip), %rsi # 0x98527
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x4fc20
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, ... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
doctest::(anonymous namespace)::ConsoleReporter::file_line_to_stream(char const*, int, char const*) | virtual void file_line_to_stream(const char* file, int line,
const char* tail = "") {
s << Color::LightGrey << skipPathFromFilename(file) << (opt.gnu_file_line ? ":" : "(")
<< (opt.no_line_numbers ? 0 : line) // 0 or the real num depending on the option
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %r15, %rdi
movl $0x17, %esi
callq 0x83d38
movq %r12, %rdi
callq 0x841c6
testq %rax, %rax
je 0x90cbc
movq %rax, %r12
movq %rax, %rdi
callq 0x4f310
movq %r15, %rdi
movq %r12, %r... | /qicosmos[P]rest_rpc/tests/doctest/doctest.h |
test | int test(char *URL)
{
struct cb_data data;
CURL *curl = NULL;
CURLcode res = CURLE_FAILED_INIT;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
curl = curl_easy_init();
if(curl == NULL) {
fprintf(stderr, "curl_e... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x2, -0x34(%rbp)
movl $0x3, %edi
callq 0x2100
cmpl $0x0, %eax
je 0x227e
movq 0x2d7f(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0xd99(%rip), %rsi # 0x3004
movb $0x0, %al
callq 0x20e0
movl $0x7e, -0x4(%rbp)
jmp 0x2... | /kfalconspb[P]curl/tests/libtest/lib1533.c |
read_callback | static size_t read_callback(void *ptr, size_t size, size_t nitems,
void *userdata)
{
struct cb_data *data = (struct cb_data *)userdata;
/* wait until the server has sent all response headers */
if(data->response_received) {
size_t totalsize = nitems * size;
size_t bytes_to_se... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x2584
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rb... | /kfalconspb[P]curl/tests/libtest/lib1533.c |
perform_and_check_connections | static int perform_and_check_connections(CURL *curl, const char *description,
long expected_connections)
{
CURLcode res;
long connections = 0;
res = curl_easy_perform(curl);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed\n");
return TEST_ERR_M... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2040
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x266f
movq 0x298b(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0xaa5(%rip), %rsi # 0x310... | /kfalconspb[P]curl/tests/libtest/lib1533.c |
select_wrapper | int select_wrapper(int nfds, fd_set *rd, fd_set *wr, fd_set *exc,
struct timeval *tv)
{
if(nfds < 0) {
SET_SOCKERRNO(EINVAL);
return -1;
}
#ifdef USE_WINSOCK
/*
* Winsock select() requires that at least one of the three fd_set
* pointers is not NULL and points to a non-empty fdset... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2735
callq 0x2030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2750
movl -0x8(%rbp), %edi
movq -0x10(%rbp),... | /kfalconspb[P]curl/tests/libtest/first.c |
hexdump | char *hexdump(const unsigned char *buffer, size_t len)
{
static char dump[200 * 3 + 1];
char *p = dump;
size_t i;
if(len > 200)
return NULL;
for(i = 0; i<len; i++, p += 3)
msnprintf(p, 4, "%02x ", buffer[i]);
return dump;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x28f9(%rip), %rax # 0x50d0
movq %rax, -0x20(%rbp)
cmpq $0xc8, -0x18(%rbp)
jbe 0x27ef
movq $0x0, -0x8(%rbp)
jmp 0x2849
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x283e
movq -0x20(%rbp), %rd... | /kfalconspb[P]curl/tests/libtest/first.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2878
movl $0x6, %edi
leaq 0x89b(%rip), %rsi # 0x311f
callq 0x20a0
cmpl $0x2, -0x8(%rbp)
jge 0x28b0
movq 0x274a(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0x8da(%rip), %rsi # 0x317a
movb... | /kfalconspb[P]curl/tests/libtest/first.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2a7a
movq -0x8(%rbp), %rax
andq $0xffff, %rax # imm = 0xFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kfalconspb[P]curl/lib/warnless.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2a9a
movq -0x8(%rbp), %rax
andq $0xff, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kfalconspb[P]curl/lib/warnless.c |
curlx_ultosi | int curlx_ultosi(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_SINT);
return (int)(ulnum & (unsigned long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma war... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2aba
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2b5a
jmp 0x2b5c
jmp 0x2b5e
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
popq %rbp
retq
nopw (%rax,%rax)
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sotouz | size_t curlx_sotouz(curl_off_t sonum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sonum >= 0);
return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
jmp 0x2bda
movq -0x8(%rbp), %rax
andq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kfalconspb[P]curl/lib/warnless.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x2c39
movslq -0x4(%rbp), %rax
popq %rbp
retq
| /kfalconspb[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /nomaster[P]curl/lib/warnless.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.