name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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_BOUND) {
/* It is already bound to a port. */
handle->flags |= flags;
return 0;
}
/* Query to see if tcp socket is bound. */
slen = sizeof(saddr);
memset(&saddr, 0, sizeof(saddr));
if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen))
return UV__ERR(errno);
if ((saddr.ss_family == AF_INET6 &&
((struct sockaddr_in6*) &saddr)->sin6_port != 0) ||
(saddr.ss_family == AF_INET &&
((struct sockaddr_in*) &saddr)->sin_port != 0)) {
/* Handle is already bound to a port. */
handle->flags |= flags;
return 0;
}
/* Bind to arbitrary port */
if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen))
return UV__ERR(errno);
}
handle->flags |= flags;
return 0;
}
return new_socket(handle, domain, flags);
}
|
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
movl %esi, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x61f143
movl %eax, %r15d
testl %eax, %eax
js 0x628478
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x62711f
testl %eax, %eax
je 0x628480
movl %eax, %ebp
movl %r15d, %edi
callq 0x61f25b
jmp 0x62839f
movl 0x58(%rbx), %eax
btl $0xd, %eax
jb 0x62846d
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
callq 0x41e58
testl %eax, %eax
jne 0x6284f2
movzwl 0x10(%rsp), %eax
andl $-0x9, %eax
cmpw $0x2, %ax
jne 0x62844c
cmpw $0x0, 0x12(%rsp)
jne 0x628399
movl 0xb8(%rbx), %edi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
callq 0x41310
testl %eax, %eax
jne 0x6284f2
jmp 0x628399
orl %r14d, %eax
movl %eax, 0x58(%rbx)
jmp 0x62839d
movl %r15d, %ebp
jmp 0x62839f
xorl %ebp, %ebp
btl $0xd, %r14d
jae 0x62839f
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl 0xb8(%rbx), %edi
callq 0x41e58
testl %eax, %eax
jne 0x6284ea
movl 0xb8(%rbx), %edi
movl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
callq 0x41310
testl %eax, %eax
je 0x62839f
movl %r15d, %edi
callq 0x61f25b
callq 0x415e0
xorl %ebp, %ebp
subl (%rax), %ebp
jmp 0x62839f
|
/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_EALREADY; /* FIXME(bnoordhuis) UV_EINVAL or maybe UV_EBUSY. */
if (handle->delayed_error != 0)
goto out;
err = maybe_new_socket(handle,
addr->sa_family,
UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
if (err)
return err;
do {
errno = 0;
r = connect(uv__stream_fd(handle), addr, addrlen);
} while (r == -1 && errno == EINTR);
/* We not only check the return value, but also check the errno != 0.
* Because in rare cases connect() will return -1 but the errno
* is 0 (for example, on Android 4.3, OnePlus phone A0001_12_150227)
* and actually the tcp three-way handshake is completed.
*/
if (r == -1 && errno != 0) {
if (errno == EINPROGRESS)
; /* not an error */
else if (errno == ECONNREFUSED
#if defined(__OpenBSD__)
|| errno == EINVAL
#endif
)
/* If we get ECONNREFUSED (Solaris) or EINVAL (OpenBSD) wait until the
* next tick to report the error. Solaris and OpenBSD wants to report
* immediately -- other unixes want to wait.
*/
handle->delayed_error = UV__ERR(ECONNREFUSED);
else
return UV__ERR(errno);
}
out:
uv__req_init(handle->loop, req, UV_CONNECT);
req->cb = cb;
req->handle = (uv_stream_t*) handle;
QUEUE_INIT(&req->queue);
handle->connect_req = req;
uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
if (handle->delayed_error)
uv__io_feed(handle->loop, &handle->io_watcher);
return 0;
}
|
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
incl 0x20(%rax)
movq (%rsp), %rax
movq %rax, 0x40(%r14)
movq %rbx, 0x48(%r14)
leaq 0x50(%r14), %rax
movq %rax, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %r14, 0x78(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r14
movq %r14, %rsi
movl $0x4, %edx
callq 0x61f5e9
xorl %r13d, %r13d
cmpl $0x0, 0xe8(%rbx)
je 0x6286e2
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x61f904
jmp 0x6286e2
movl %ecx, %ebp
movq %rdx, %r12
movzwl (%rdx), %esi
movl $0xc000, %edx # imm = 0xC000
movq %rbx, %rdi
callq 0x628370
movl %eax, %r13d
testl %eax, %eax
je 0x6286f4
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x415e0
movq %rax, %r15
movl $0x0, (%r15)
movl 0xb8(%rbx), %edi
movq %r12, %rsi
movl %ebp, %edx
callq 0x3fcc0
cmpl $-0x1, %eax
jne 0x628669
movl (%r15), %r13d
cmpl $0x4, %r13d
je 0x6286fc
testl %r13d, %r13d
je 0x628669
cmpl $0x73, %r13d
je 0x628669
cmpl $0x6f, %r13d
jne 0x62874d
movl $0xffffff91, 0xe8(%rbx) # imm = 0xFFFFFF91
jmp 0x628669
negl %r13d
jmp 0x6286e2
leaq 0xb2eef(%rip), %rdi # 0x6db648
leaq 0xb2eff(%rip), %rsi # 0x6db65f
leaq 0xb2f62(%rip), %rcx # 0x6db6c9
movl $0xd5, %edx
callq 0x3f4b0
|
/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,
name,
namelen);
}
|
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_KEEPALIVE;
/* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge
* uv_tcp_t with an int that's almost never used...
*/
return 0;
}
|
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, %eax
movl %eax, 0x58(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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();
err = pthread_mutex_init(mutex, &attr);
if (pthread_mutexattr_destroy(&attr))
abort();
return UV__ERR(err);
#endif
}
|
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
callq 0x3f7d0
jmp 0x628ff0
callq 0x415c0
testl %eax, %eax
jne 0x628ff6
popq %rbx
retq
callq 0x40a90
|
/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, %rdi
callq 0x3f7d0
xorl %ebx, %ebx
jmp 0x6290ed
callq 0x415e0
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x6290d1
movq %r14, %rdi
callq 0x400d0
cmpl $-0x1, %eax
je 0x6290ab
movl %eax, %ebx
testl %eax, %eax
je 0x6290db
callq 0x415e0
movl (%rax), %eax
movl $0xfffffff5, %ebx # imm = 0xFFFFFFF5
cmpl $0xb, %eax
jne 0x6290f1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x3f7d0
testl %eax, %eax
je 0x6290db
callq 0x40a90
|
/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 mutex;
struct timespec ts;
int err;
if (pthread_mutex_init(&mutex, NULL))
abort();
if (pthread_mutex_lock(&mutex))
abort();
ts.tv_sec = 0;
ts.tv_nsec = 1;
err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
if (err != 0 && err != ETIMEDOUT)
abort();
if (pthread_mutex_unlock(&mutex))
abort();
if (pthread_mutex_destroy(&mutex))
abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
if (pthread_cond_destroy(cond))
abort();
}
|
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 immediately puts fd into
* an error state. fstat will return EINVAL, getsockname will also return
* EINVAL, even if sockaddr_storage is valid. (If file does not refer to a
* socket, ENOTSOCK is returned instead.)
* In such cases, we will permit the user to open the connection as uv_tcp
* still, so that the user can get immediately notified of the error in
* their read callback and close this fd.
*/
len = sizeof(ss);
if (getsockname(file, (struct sockaddr*) &ss, &len)) {
if (errno == EINVAL)
return UV_TCP;
}
#endif
return UV_UNKNOWN_HANDLE;
}
if (S_ISREG(s.st_mode))
return UV_FILE;
if (S_ISCHR(s.st_mode))
return UV_FILE; /* XXX UV_NAMED_PIPE? */
if (S_ISFIFO(s.st_mode))
return UV_NAMED_PIPE;
if (!S_ISSOCK(s.st_mode))
return UV_UNKNOWN_HANDLE;
len = sizeof(ss);
if (getsockname(file, (struct sockaddr*) &ss, &len)) {
#if defined(_AIX)
/* On aix receiving RST from TCP instead of FIN immediately puts fd into
* an error state. In such case getsockname will return EINVAL, even if
* sockaddr_storage is valid.
* In such cases, we will permit the user to open the connection as uv_tcp
* still, so that the user can get immediately notified of the error in
* their read callback and close this fd.
*/
if (errno == EINVAL) {
return UV_TCP;
}
#endif
return UV_UNKNOWN_HANDLE;
}
len = sizeof(type);
if (getsockopt(file, SOL_SOCKET, SO_TYPE, &type, &len))
return UV_UNKNOWN_HANDLE;
if (type == SOCK_DGRAM)
if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6)
return UV_UDP;
if (type == SOCK_STREAM) {
#if defined(_AIX) || defined(__DragonFly__)
/* on AIX/DragonFly the getsockname call returns an empty sa structure
* for sockets of type AF_UNIX. For all other types it will
* return a properly filled in structure.
*/
if (len == 0)
return UV_NAMED_PIPE;
#endif /* defined(_AIX) || defined(__DragonFly__) */
if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6)
return UV_TCP;
if (ss.ss_family == AF_UNIX)
return UV_NAMED_PIPE;
}
return UV_UNKNOWN_HANDLE;
}
|
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 %rbx
retq
xorl %eax, %eax
retq
movl $0xf000, %ecx # imm = 0xF000
andl 0xa8(%rsp), %ecx
movl $0x11, %eax
cmpl $0x7fff, %ecx # imm = 0x7FFF
jg 0x62945c
cmpl $0x1000, %ecx # imm = 0x1000
je 0x6294df
cmpl $0x2000, %ecx # imm = 0x2000
je 0x629421
jmp 0x62941f
cmpl $0x8000, %ecx # imm = 0x8000
je 0x629421
cmpl $0xc000, %ecx # imm = 0xC000
jne 0x62941f
leaq 0xc(%rsp), %rdx
movl $0x80, (%rdx)
leaq 0x10(%rsp), %rsi
movl %ebx, %edi
callq 0x41e58
testl %eax, %eax
jne 0x62941f
leaq 0xc(%rsp), %r8
movl $0x4, (%r8)
leaq 0x8(%rsp), %rcx
movl %ebx, %edi
movl $0x1, %esi
movl $0x3, %edx
callq 0x40b30
testl %eax, %eax
jne 0x62941f
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
je 0x6294e9
cmpl $0x2, %eax
jne 0x62941f
movzwl 0x10(%rsp), %ecx
andl $-0x9, %ecx
movl $0xf, %eax
cmpw $0x2, %cx
jne 0x62941f
jmp 0x629421
movl $0x7, %eax
jmp 0x629421
movzwl 0x10(%rsp), %ecx
movl %ecx, %edx
andl $-0x9, %edx
movl $0xc, %eax
cmpw $0x2, %dx
je 0x629421
movl $0x7, %eax
cmpw $0x1, %cx
jne 0x62941f
jmp 0x629421
|
/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
negl %eax
jmp 0x6296c4
movzwl 0x2(%rsp), %eax
movl %eax, (%r14)
movzwl (%rsp), %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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, uv_udp_send_t, queue);
req->status = UV_ECANCELED;
QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue);
}
uv__udp_run_completed(handle);
assert(handle->send_queue_size == 0);
assert(handle->send_queue_count == 0);
/* Now tear down the handle. */
handle->recv_cb = NULL;
handle->alloc_cb = NULL;
/* but _do not_ touch close_cb */
}
|
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 %rdi, 0x8(%rsi)
movq $-0x7d, 0xa0(%rcx)
movq %rdx, (%rcx)
movq 0xd0(%rbx), %rsi
movq %rsi, 0x8(%rcx)
movq %rcx, (%rsi)
movq %rcx, 0xd0(%rbx)
movq 0xb8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x6297be
movq %rbx, %rdi
callq 0x62989a
cmpq $0x0, 0x60(%rbx)
jne 0x62985c
cmpq $0x0, 0x68(%rbx)
jne 0x62987b
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
popq %rbx
retq
leaq 0xb19cf(%rip), %rdi # 0x6db1f4
leaq 0xb1f44(%rip), %rsi # 0x6db770
leaq 0xb1fa7(%rip), %rcx # 0x6db7da
movl $0x67, %edx
callq 0x3f4b0
leaq 0xb1fbc(%rip), %rdi # 0x6db800
leaq 0xb1f25(%rip), %rsi # 0x6db770
leaq 0xb1f88(%rip), %rcx # 0x6db7da
movl $0x68, %edx
callq 0x3f4b0
leaq 0xb1fb9(%rip), %rdi # 0x6db81c
leaq 0xb1f06(%rip), %rsi # 0x6db770
leaq 0xb1f69(%rip), %rcx # 0x6db7da
movl $0x75, %edx
callq 0x3f4b0
leaq 0xb1fb7(%rip), %rdi # 0x6db839
leaq 0xb1ee7(%rip), %rsi # 0x6db770
leaq 0xb1f4a(%rip), %rcx # 0x6db7da
movl $0x76, %edx
callq 0x3f4b0
|
/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;
/* Cannot set IPv6-only mode on non-IPv6 socket. */
if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6)
return UV_EINVAL;
fd = handle->io_watcher.fd;
if (fd == -1) {
err = uv__socket(addr->sa_family, SOCK_DGRAM, 0);
if (err < 0)
return err;
fd = err;
handle->io_watcher.fd = fd;
}
if (flags & UV_UDP_LINUX_RECVERR) {
err = uv__set_recverr(fd, addr->sa_family);
if (err)
return err;
}
if (flags & UV_UDP_REUSEADDR) {
err = uv__set_reuse(fd);
if (err)
return err;
}
if (flags & UV_UDP_IPV6ONLY) {
#ifdef IPV6_V6ONLY
yes = 1;
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof yes) == -1) {
err = UV__ERR(errno);
return err;
}
#else
err = UV_ENOTSUP;
return err;
#endif
}
if (bind(fd, addr, addrlen)) {
err = UV__ERR(errno);
if (errno == EAFNOSUPPORT)
/* OSX, other BSDs and SunoS fail with EAFNOSUPPORT when binding a
* socket created with AF_INET to an AF_INET6 address or vice versa. */
err = UV_EINVAL;
return err;
}
if (addr->sa_family == AF_INET6)
handle->flags |= UV_HANDLE_IPV6;
handle->flags |= UV_HANDLE_BOUND;
return 0;
}
|
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 0xb0(%rbx), %r12d
cmpl $-0x1, %r12d
jne 0x629a7b
movzwl (%r14), %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x61f143
movl %eax, %r12d
testl %eax, %eax
js 0x629b68
movl %r12d, 0xb0(%rbx)
cmpl $0x20, %r15d
jb 0x629adb
movzwl (%r14), %eax
movl $0x1, 0x8(%rsp)
cmpl $0xa, %eax
je 0x629aa8
cmpl $0x2, %eax
jne 0x629adb
leaq 0x8(%rsp), %rcx
movl %r12d, %edi
xorl %esi, %esi
movl $0xb, %edx
jmp 0x629aba
leaq 0x8(%rsp), %rcx
movl %r12d, %edi
movl $0x29, %esi
movl $0x19, %edx
movl $0x4, %r8d
callq 0x3f400
testl %eax, %eax
je 0x629adb
callq 0x415e0
movl (%rax), %eax
testl %eax, %eax
je 0x629adb
negl %eax
jmp 0x629b79
testb $0x4, %r15b
je 0x629af1
movl %r12d, %edi
callq 0x629b86
testl %eax, %eax
jne 0x629b79
testb $0x1, %r15b
je 0x629b1f
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %r12d, %edi
movl $0x29, %esi
movl $0x1a, %edx
movl $0x4, %r8d
callq 0x3f400
cmpl $-0x1, %eax
je 0x629b6d
movl %r12d, %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x41310
testl %eax, %eax
je 0x629b48
callq 0x415e0
movl (%rax), %eax
movl %eax, %ecx
negl %ecx
cmpl $0x61, %eax
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmovnel %ecx, %eax
jmp 0x629b79
movl 0x58(%rbx), %eax
movl %eax, %ecx
orl $0x400000, %ecx # imm = 0x400000
cmpw $0xa, (%r14)
cmovnel %eax, %ecx
orl $0x2000, %ecx # imm = 0x2000
movl %ecx, 0x58(%rbx)
xorl %eax, %eax
jmp 0x629b79
movl %r12d, %eax
jmp 0x629b79
callq 0x415e0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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__) && \
!defined(__NetBSD__) && \
!defined(__ANDROID__) && \
!defined(__DragonFly__) && \
!defined(__QNX__) && \
!defined(__GNU__)
int err;
union uv__sockaddr mcast_addr;
union uv__sockaddr src_addr;
err = uv_ip4_addr(multicast_addr, 0, &mcast_addr.in);
if (err) {
err = uv_ip6_addr(multicast_addr, 0, &mcast_addr.in6);
if (err)
return err;
err = uv_ip6_addr(source_addr, 0, &src_addr.in6);
if (err)
return err;
return uv__udp_set_source_membership6(handle,
&mcast_addr.in6,
interface_addr,
&src_addr.in6,
membership);
}
err = uv_ip4_addr(source_addr, 0, &src_addr.in);
if (err)
return err;
return uv__udp_set_source_membership4(handle,
&mcast_addr.in,
interface_addr,
&src_addr.in,
membership);
#else
return UV_ENOSYS;
#endif
}
|
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 %esi, %esi
callq 0x61dc4c
testl %eax, %eax
jne 0x62ad24
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x61dc4c
testl %eax, %eax
jne 0x62ad24
cmpl $-0x1, 0xb0(%rbx)
je 0x62adc1
leaq 0x60(%rsp), %rdi
xorl %r15d, %r15d
movl $0x108, %edx # imm = 0x108
xorl %esi, %esi
callq 0x3fa90
testq %r14, %r14
je 0x62acc1
leaq 0x44(%rsp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x61dc4c
testl %eax, %eax
jne 0x62ad24
movl 0x5c(%rsp), %r15d
movl %r15d, 0x60(%rsp)
movups 0x28(%rsp), %xmm0
movups 0x34(%rsp), %xmm1
movups %xmm0, 0x68(%rsp)
movups %xmm1, 0x74(%rsp)
movups 0xc(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups %xmm0, 0xe8(%rsp)
movups %xmm1, 0xf4(%rsp)
cmpl $0x1, %ebp
je 0x62ae2b
movl $0xffffffea, %r15d # imm = 0xFFFFFFEA
testl %ebp, %ebp
jne 0x62ad27
movl $0x2f, %edx
jmp 0x62ae30
leaq 0xc(%rsp), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x61dc19
testl %eax, %eax
je 0x62ad3a
movl %eax, %r15d
movl %r15d, %eax
addq $0x170, %rsp # imm = 0x170
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $-0x1, 0xb0(%rbx)
je 0x62ad95
movl $0x0, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
testq %r14, %r14
je 0x62ad6f
leaq 0x64(%rsp), %rdx
movl $0x2, %edi
movq %r14, %rsi
callq 0x62e0c9
testl %eax, %eax
jne 0x62ad24
movl 0x2c(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x68(%rsp)
cmpl $0x1, %ebp
je 0x62ae02
movl $0xffffffea, %r15d # imm = 0xFFFFFFEA
testl %ebp, %ebp
jne 0x62ad27
movl $0x28, %edx
jmp 0x62ae07
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movw $0x2, (%rsi)
movq %rbx, %rdi
movl $0x10, %edx
movl $0x4, %ecx
callq 0x629a16
testl %eax, %eax
jne 0x62ad24
jmp 0x62ad43
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movups %xmm0, 0xc(%rsi)
movw $0xa, (%rsi)
movq 0x2331a4(%rip), %rax # 0x85df80
movups (%rax), %xmm0
movups %xmm0, 0x8(%rsi)
movq %rbx, %rdi
movl $0x1c, %edx
movl $0x4, %ecx
callq 0x629a16
testl %eax, %eax
jne 0x62ad24
jmp 0x62ac90
movl $0x27, %edx
movl 0xb0(%rbx), %edi
xorl %r15d, %r15d
leaq 0x60(%rsp), %rcx
xorl %esi, %esi
movl $0xc, %r8d
callq 0x3f400
testl %eax, %eax
jne 0x62ae4f
jmp 0x62ad27
movl $0x2e, %edx
movl 0xb0(%rbx), %edi
leaq 0x60(%rsp), %rcx
movl $0x29, %esi
movl $0x108, %r8d # imm = 0x108
callq 0x3f400
testl %eax, %eax
je 0x62ae5f
callq 0x415e0
xorl %r15d, %r15d
subl (%rax), %r15d
jmp 0x62ad27
xorl %r15d, %r15d
jmp 0x62ad27
|
/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_BOOTTIME first, fall back to CLOCK_MONOTONIC if not available
* (pre-2.6.39 kernels). CLOCK_MONOTONIC doesn't increase when the system
* is suspended.
*/
if (no_clock_boottime) {
retry_clock_gettime: r = clock_gettime(CLOCK_MONOTONIC, &now);
}
else if ((r = clock_gettime(CLOCK_BOOTTIME, &now)) && errno == EINVAL) {
no_clock_boottime = 1;
goto retry_clock_gettime;
}
if (r)
return UV__ERR(errno);
*uptime = now.tv_sec;
return 0;
}
|
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
je 0x62bd02
cmpl $0x0, 0x24002d(%rip) # 0x86bcdc
je 0x62bcc9
movq %rsp, %rsi
movl $0x1, %edi
callq 0x3fba0
testl %eax, %eax
je 0x62bcf6
callq 0x415e0
jmp 0x62bcf0
movq %rsp, %rsi
movl $0x7, %edi
callq 0x3fba0
testl %eax, %eax
je 0x62bcf6
callq 0x415e0
cmpl $0x16, (%rax)
jne 0x62bcf0
movl $0x1, 0x23ffee(%rip) # 0x86bcdc
jmp 0x62bcb1
xorl %ebp, %ebp
subl (%rax), %ebp
jmp 0x62bd02
cvtsi2sdq (%rsp), %xmm0
movsd %xmm0, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
|
/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, "%" PRIu64 " kB", &rc);
return rc * 1024;
}
|
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 %rax, %rax
je 0x62c5cc
movq %rax, %r14
movq %rbx, %rdi
callq 0x3fd60
addq %rax, %r14
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x74970(%rip), %rsi # 0x6a0f73
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3f280
movq (%rbx), %rax
shlq $0xa, %rax
addq $0x1018, %rsp # imm = 0x1018
popq %rbx
popq %r14
retq
|
/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)))
sscanf(buf, "%" PRIu64, &rc);
return rc;
}
|
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
callq 0x40190
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
movq %r14, %rdi
callq 0x61fa26
testl %eax, %eax
jne 0x62c6ca
leaq 0x77300(%rip), %rsi # 0x6a39b3
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3f280
movq (%rbx), %rbx
movq %rbx, %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r14
retq
|
/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] = (double) info.loads[0] / 65536.0;
avg[1] = (double) info.loads[1] / 65536.0;
avg[2] = (double) info.loads[2] / 65536.0;
}
|
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
cmpl $0x3, %eax
je 0x62c799
movq %rsp, %rdi
callq 0x41a10
testl %eax, %eax
js 0x62c799
movdqu 0x8(%rsp), %xmm0
movdqa 0xaf626(%rip), %xmm1 # 0x6dbd60
pand %xmm0, %xmm1
por 0xaf62a(%rip), %xmm1 # 0x6dbd70
psrlq $0x20, %xmm0
por 0xaf62d(%rip), %xmm0 # 0x6dbd80
subpd 0xaf635(%rip), %xmm0 # 0x6dbd90
addpd %xmm1, %xmm0
mulpd 0xaf639(%rip), %xmm0 # 0x6dbda0
movupd %xmm0, (%rbx)
movsd 0x18(%rsp), %xmm0
unpcklps 0xefe8(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xeff0(%rip), %xmm0 # 0x63b770
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0xaf61c(%rip), %xmm1 # 0x6dbdb0
movsd %xmm1, 0x10(%rbx)
addq $0xf0, %rsp
popq %rbx
retq
nop
|
/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* tmp_path;
if (old_watchers != NULL) {
/* We must restore the old watcher list to be able to close items
* out of it.
*/
loop->inotify_watchers = old_watchers;
QUEUE_INIT(&tmp_watcher_list.watchers);
/* Note that the queue we use is shared with the start and stop()
* functions, making QUEUE_FOREACH unsafe to use. So we use the
* QUEUE_MOVE trick to safely iterate. Also don't free the watcher
* list until we're done iterating. c.f. uv__inotify_read.
*/
RB_FOREACH_SAFE(watcher_list, watcher_root,
CAST(&old_watchers), tmp_watcher_list_iter) {
watcher_list->iterating = 1;
QUEUE_MOVE(&watcher_list->watchers, &queue);
while (!QUEUE_EMPTY(&queue)) {
q = QUEUE_HEAD(&queue);
handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
/* It's critical to keep a copy of path here, because it
* will be set to NULL by stop() and then deallocated by
* maybe_free_watcher_list
*/
tmp_path = uv__strdup(handle->path);
assert(tmp_path != NULL);
QUEUE_REMOVE(q);
QUEUE_INSERT_TAIL(&watcher_list->watchers, q);
uv_fs_event_stop(handle);
QUEUE_INSERT_TAIL(&tmp_watcher_list.watchers, &handle->watchers);
handle->path = tmp_path;
}
watcher_list->iterating = 0;
maybe_free_watcher_list(watcher_list, loop);
}
QUEUE_MOVE(&tmp_watcher_list.watchers, &queue);
while (!QUEUE_EMPTY(&queue)) {
q = QUEUE_HEAD(&queue);
QUEUE_REMOVE(q);
handle = QUEUE_DATA(q, uv_fs_event_t, watchers);
tmp_path = handle->path;
handle->path = NULL;
err = uv_fs_event_start(handle, handle->cb, tmp_path, 0);
uv__free(tmp_path);
if (err)
return err;
}
}
return 0;
}
|
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, %rcx
testq %rax, %rax
jne 0x62c7dd
testq %rbp, %rbp
je 0x62c95b
movq %rsp, %r13
movq %rbx, 0x10(%rsp)
movq %rbp, %r14
movq 0x8(%rbp), %rax
testq %rax, %rax
je 0x62c8c7
movq %rax, %rbp
movq (%rax), %rax
testq %rax, %rax
jne 0x62c80c
movl $0x1, 0x30(%r14)
leaq 0x20(%r14), %rbx
movq 0x20(%r14), %rax
cmpq %rax, %rbx
je 0x62c8f4
movq 0x28(%r14), %rcx
movq %rcx, 0x8(%rsp)
movq %r13, (%rcx)
movq %rax, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%r14)
movq %rbx, (%rcx)
movq %r13, 0x8(%rax)
movq (%rsp), %r12
cmpq %r12, %r13
je 0x62c8fd
movq -0x10(%r12), %rdi
callq 0x61c940
testq %rax, %rax
je 0x62c9c6
movq %rax, %r15
leaq -0x70(%r12), %rdi
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rax, (%rcx)
movq 0x8(%r12), %rcx
movq %rcx, 0x8(%rax)
movq %rbx, (%r12)
movq 0x28(%r14), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x28(%r14)
callq 0x62c9e5
leaq 0x40(%rsp), %rax
movq %rax, (%r12)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%r12)
movq %r12, (%rax)
movq %r12, 0x48(%rsp)
movq %r15, -0x10(%r12)
jmp 0x62c84f
movq 0x10(%r14), %rbp
testq %rbp, %rbp
je 0x62c8da
cmpq %r14, (%rbp)
je 0x62c817
movq %r14, %rax
movq 0x10(%rax), %rbp
testq %rbp, %rbp
je 0x62c91d
cmpq 0x8(%rbp), %rax
movq %rbp, %rax
je 0x62c8dd
jmp 0x62c817
movq %r13, (%rsp)
movq %r13, 0x8(%rsp)
movl $0x0, 0x30(%r14)
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x62ca7f
testq %rbp, %rbp
jne 0x62c7fc
jmp 0x62c924
xorl %ebp, %ebp
jmp 0x62c817
movq 0x40(%rsp), %rax
leaq 0x40(%rsp), %rcx
cmpq %rax, %rcx
je 0x62c95b
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %r13, (%rcx)
movq %rax, (%rsp)
movq 0x8(%rax), %rcx
addq $0x8, %rax
movq %rcx, 0x48(%rsp)
leaq 0x40(%rsp), %rdx
movq %rdx, (%rcx)
jmp 0x62c966
movq %rsp, %rax
movq %rax, (%rax)
leaq 0x8(%rsp), %rax
movq %rsp, %r15
movq %r15, (%rax)
movq (%rsp), %rax
cmpq %rax, %r15
je 0x62c9b3
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
leaq -0x70(%rax), %rdi
movq -0x10(%rax), %r14
movq -0x8(%rax), %rsi
movq $0x0, -0x10(%rax)
movq %r14, %rdx
callq 0x62ce7a
movl %eax, %ebx
movq %r14, %rdi
callq 0x61c9db
testl %ebx, %ebx
je 0x62c96c
jmp 0x62c9b5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaf5aa(%rip), %rdi # 0x6dbf77
leaq 0xaf5b4(%rip), %rsi # 0x6dbf88
leaq 0xaf621(%rip), %rcx # 0x6dbffc
movl $0x79, %edx
callq 0x3f4b0
|
/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, handle->loop);
return 0;
}
|
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(%rip), %rsi # 0x6dbf88
leaq 0xaf600(%rip), %rcx # 0x6dc030
movl $0x138, %edx # imm = 0x138
callq 0x3f4b0
movl $0xffffffff, 0x80(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x60(%rdi)
movl %ecx, %esi
andl $-0x5, %esi
movl %esi, 0x58(%rdi)
testb $0x8, %cl
je 0x62ca5c
decl 0x8(%rdx)
movq 0x70(%rdi), %rcx
movq 0x78(%rdi), %rdx
movq %rcx, (%rdx)
movq 0x78(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x62ca7f
xorl %eax, %eax
popq %rcx
retq
|
/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(handle->loop);
if (err)
return err;
events = IN_ATTRIB
| IN_CREATE
| IN_MODIFY
| IN_DELETE
| IN_DELETE_SELF
| IN_MOVE_SELF
| IN_MOVED_FROM
| IN_MOVED_TO;
wd = inotify_add_watch(handle->loop->inotify_fd, path, events);
if (wd == -1)
return UV__ERR(errno);
w = find_watcher(handle->loop, wd);
if (w)
goto no_insert;
len = strlen(path) + 1;
w = uv__malloc(sizeof(*w) + len);
if (w == NULL)
return UV_ENOMEM;
w->wd = wd;
w->path = memcpy(w + 1, path, len);
QUEUE_INIT(&w->watchers);
w->iterating = 0;
RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w);
no_insert:
uv__handle_start(handle);
QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers);
handle->path = w->path;
handle->cb = cb;
handle->wd = wd;
return 0;
}
|
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 0x408c0
testl %eax, %eax
js 0x62d1b7
movl %eax, 0x348(%r15)
leaq 0x308(%r15), %r13
leaq 0x3b5(%rip), %rsi # 0x62d287
movq %r13, %rdi
movl %eax, %edx
callq 0x61f578
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x61f5e9
movq 0x8(%rbx), %rax
movl 0x348(%rax), %edi
movq %r12, %rsi
movl $0xfc6, %edx # imm = 0xFC6
callq 0x3fd80
cmpl $-0x1, %eax
je 0x62d19c
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x340(%rax), %r15
testq %r15, %r15
je 0x62cf33
cmpl %ebp, 0x40(%r15)
jg 0x62cf2e
jge 0x62d1f2
addq $0x8, %r15
movq (%r15), %r15
jmp 0x62cf19
movq %r12, %rdi
callq 0x3fd60
movq %rax, %r13
leaq 0x49(%rax), %rdi
callq 0x61c981
testq %rax, %rax
je 0x62d1ad
movq %rax, %r15
movq %r14, (%rsp)
incq %r13
movl %ebp, 0x40(%rax)
leaq 0x48(%rax), %r14
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3f250
movq %r14, 0x38(%r15)
movq %r15, %rax
addq $0x20, %rax
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movl $0x0, 0x30(%r15)
movq 0x8(%rbx), %rax
movq 0x340(%rax), %rsi
addq $0x340, %rax # imm = 0x340
testq %rsi, %rsi
je 0x62d1ca
movq (%rsp), %r14
movq %rsi, %rcx
movl 0x40(%rsi), %edx
cmpl %edx, %ebp
jl 0x62cfbc
jle 0x62d1f2
leaq 0x8(%rcx), %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x62cfa8
xorl %esi, %esi
cmpl %edx, %ebp
setge %sil
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movl $0x1, 0x18(%r15)
movq %r15, (%rcx,%rsi,8)
xorl %edx, %edx
movq %r15, %rdi
cmpl $0x1, 0x18(%rcx)
jne 0x62d197
movq 0x10(%rcx), %rsi
movq (%rsi), %r8
cmpq %r8, %rcx
je 0x62d023
testq %r8, %r8
je 0x62d010
cmpl $0x1, 0x18(%r8)
jne 0x62d010
movl %edx, 0x18(%r8)
jmp 0x62d037
movq (%rcx), %r8
cmpq %rdi, %r8
je 0x62d05d
movq %rcx, %r8
movq %rdi, %rcx
jmp 0x62d0cc
movq 0x8(%rsi), %r9
testq %r9, %r9
je 0x62d049
cmpl $0x1, 0x18(%r9)
jne 0x62d049
movl %edx, 0x18(%r9)
movl %edx, 0x18(%rcx)
movl $0x1, 0x18(%rsi)
movq %rsi, %rcx
jmp 0x62d187
movq 0x8(%rcx), %r9
cmpq %rdi, %r9
je 0x62d07f
movq %rcx, %r9
movq %rdi, %rcx
jmp 0x62d13f
movq 0x8(%r8), %r9
movq %r9, (%rcx)
testq %r9, %r9
je 0x62d0a8
movq %rcx, 0x10(%r9)
movq 0x10(%rcx), %r9
movq %r9, 0x10(%r8)
movq %rax, %r10
testq %r9, %r9
jne 0x62d0b0
jmp 0x62d0be
movq (%r9), %r8
movq %r8, 0x8(%rcx)
testq %r8, %r8
je 0x62d119
movq %rcx, 0x10(%r8)
movq 0x10(%rcx), %r8
movq %r8, 0x10(%r9)
movq %rax, %r10
testq %r8, %r8
jne 0x62d121
jmp 0x62d12f
movq %rsi, 0x10(%r8)
movq 0x10(%rcx), %r9
xorl %r10d, %r10d
cmpq (%r9), %rcx
setne %r10b
leaq (%r9,%r10,8), %r10
movq %r8, (%r10)
movq %rcx, 0x8(%r8)
movq %r8, 0x10(%rcx)
movq %rdi, %r8
movl $0x0, 0x18(%r8)
movl $0x1, 0x18(%rsi)
movq 0x8(%rsi), %rdi
movq (%rdi), %r8
movq %r8, 0x8(%rsi)
testq %r8, %r8
je 0x62d0ef
movq %rsi, 0x10(%r8)
movq 0x10(%rsi), %r8
movq %r8, 0x10(%rdi)
movq %rax, %r9
testq %r8, %r8
je 0x62d10d
xorl %r9d, %r9d
cmpq (%r8), %rsi
setne %r9b
leaq (%r8,%r9,8), %r9
movq %rdi, (%r9)
movq %rsi, (%rdi)
movq %rdi, 0x10(%rsi)
jmp 0x62d187
movq %rsi, 0x10(%r9)
movq 0x10(%rcx), %r8
xorl %r10d, %r10d
cmpq (%r8), %rcx
setne %r10b
leaq (%r8,%r10,8), %r10
movq %r9, (%r10)
movq %rcx, (%r9)
movq %r9, 0x10(%rcx)
movq (%rsi), %r8
movq %rdi, %r9
movl $0x0, 0x18(%r9)
movl $0x1, 0x18(%rsi)
movq 0x8(%r8), %rdi
movq %rdi, (%rsi)
testq %rdi, %rdi
je 0x62d15e
movq %rsi, 0x10(%rdi)
movq 0x10(%rsi), %rdi
movq %rdi, 0x10(%r8)
movq %rax, %r9
testq %rdi, %rdi
je 0x62d17c
xorl %r9d, %r9d
cmpq (%rdi), %rsi
setne %r9b
leaq (%rdi,%r9,8), %r9
movq %r8, (%r9)
movq %rsi, 0x8(%r8)
movq %r8, 0x10(%rsi)
movq %rcx, %rdi
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x62cfe8
movq (%rax), %rax
jmp 0x62d1eb
callq 0x415e0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x62d23b
movl $0xfffffff4, %eax # imm = 0xFFFFFFF4
jmp 0x62d23b
callq 0x415e0
movl (%rax), %eax
testl %eax, %eax
je 0x62ceec
negl %eax
jmp 0x62d23b
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0x1, 0x18(%r15)
movq %r15, (%rax)
movq %r15, %rax
movq (%rsp), %r14
movl $0x0, 0x18(%rax)
movl 0x58(%rbx), %eax
testb $0x4, %al
jne 0x62d20c
movl %eax, %ecx
orl $0x4, %ecx
movl %ecx, 0x58(%rbx)
testb $0x8, %al
je 0x62d20c
movq 0x8(%rbx), %rax
incl 0x8(%rax)
leaq 0x20(%r15), %rax
leaq 0x70(%rbx), %rcx
movq %rax, 0x70(%rbx)
movq 0x28(%r15), %rax
movq %rax, 0x78(%rbx)
movq %rcx, (%rax)
movq %rcx, 0x28(%r15)
movq 0x38(%r15), %rax
movq %rax, 0x60(%rbx)
movq %r14, 0x68(%rbx)
movl %ebp, 0x80(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 supported. */
rc = syscall(/* __NR_socketcall */ 102, 20 /* SYS_SENDMMSG */, args);
if (rc == -1)
if (errno == EINVAL)
errno = ENOSYS;
return rc;
#elif defined(__NR_sendmmsg)
return syscall(__NR_sendmmsg, fd, mmsg, vlen, /* flags */ 0);
#else
return errno = ENOSYS, -1;
#endif
}
|
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_in,
off_in,
fd_out,
off_out,
len,
flags);
#else
return errno = ENOSYS, -1;
#endif
}
|
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;
len = strlen(path);
ctx = uv__calloc(1, sizeof(*ctx) + len);
if (ctx == NULL)
return UV_ENOMEM;
ctx->loop = loop;
ctx->poll_cb = cb;
ctx->interval = interval ? interval : 1;
ctx->start_time = uv_now(loop);
ctx->parent_handle = handle;
memcpy(ctx->path, path, len + 1);
err = uv_timer_init(loop, &ctx->timer_handle);
if (err < 0)
goto error;
ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
uv__handle_unref(&ctx->timer_handle);
err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
if (err < 0)
goto error;
if (handle->poll_ctx != NULL)
ctx->previous = handle->poll_ctx;
handle->poll_ctx = ctx;
uv__handle_start(handle);
return 0;
error:
uv__free(ctx);
return err;
}
|
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(%r14), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
callq 0x3fd60
movq %rax, %r12
leaq 0x328(%rax), %rsi
movl $0x1, %edi
callq 0x61c9fd
testq %rax, %rax
je 0x62d996
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rax)
movq %rbx, 0x20(%rax)
cmpl $0x1, %ebp
adcl $0x0, %ebp
movl %ebp, 0xc(%rax)
movq %rdi, %rbx
callq 0x61e1d6
movq %rax, 0x10(%r15)
movq %r14, 0x8(%rsp)
movq %r14, (%r15)
leaq 0x320(%r15), %rbp
incq %r12
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3f250
leaq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x61c4a0
testl %eax, %eax
js 0x62d986
movl 0x80(%r15), %eax
movl %eax, %ecx
orl $0x10, %ecx
movl %ecx, 0x80(%r15)
testb $0x8, %al
je 0x62d920
andl $-0x9, %ecx
movl %ecx, 0x80(%r15)
andl $0x5, %eax
cmpl $0x4, %eax
jne 0x62d920
movq 0x30(%r15), %rax
decl 0x8(%rax)
movq %r15, %rsi
addq $0xc0, %rsi
leaq 0x70(%rip), %rcx # 0x62d9a1
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x623231
testl %eax, %eax
movl $0x0, %r12d
movq 0x8(%rsp), %rbx
js 0x62d986
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x62d95b
movq %rax, 0x318(%r15)
movq %r15, 0x60(%rbx)
movl 0x58(%rbx), %eax
testb $0x4, %al
jne 0x62d857
movl %eax, %ecx
orl $0x4, %ecx
movl %ecx, 0x58(%rbx)
testb $0x8, %al
je 0x62d857
movq 0x8(%rbx), %rax
incl 0x8(%rax)
jmp 0x62d857
movl %eax, %r12d
movq %r15, %rdi
callq 0x61c9db
jmp 0x62d857
movl $0xfffffff4, %r12d # imm = 0xFFFFFFF4
jmp 0x62d857
|
/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_cb will take care of the cleanup.
*/
if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
uv__handle_stop(handle);
return 0;
}
|
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 0x61eb37
movl 0x58(%rbx), %eax
testb $0x4, %al
je 0x62dc1c
movl %eax, %ecx
andl $-0x5, %ecx
movl %ecx, 0x58(%rbx)
testb $0x8, %al
je 0x62dc1c
movq 0x8(%rbx), %rax
decl 0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xae48e(%rip), %rdi # 0x6dc0bb
leaq 0xae493(%rip), %rsi # 0x6dc0c7
leaq 0xae4f5(%rip), %rcx # 0x6dc130
movl $0x7b, %edx
callq 0x3f4b0
leaq 0xae508(%rip), %rdi # 0x6dc154
leaq 0xae474(%rip), %rsi # 0x6dc0c7
leaq 0xae4d6(%rip), %rcx # 0x6dc130
movl $0x7c, %edx
callq 0x3f4b0
|
/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) {
s = tmp;
len = p - src;
if (len > UV__INET6_ADDRSTRLEN-1)
return UV_EINVAL;
memcpy(s, src, len);
s[len] = '\0';
}
return inet_pton6(s, dst);
}
default:
return UV_EAFNOSUPPORT;
}
/* NOTREACHED */
}
|
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
cmpl $0x2, %edi
jne 0x62e36a
movq %r13, %rdi
movq %rbx, %rsi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62e37b
movq %r13, %rdi
movl $0x25, %esi
callq 0x40250
testq %rax, %rax
je 0x62e164
subq %r13, %rax
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
cmpl $0x2d, %eax
jg 0x62e36a
movslq %eax, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3f250
movb $0x0, 0x40(%rsp,%r14)
movq %r12, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movzbl (%r13), %r15d
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
testl %r15d, %r15d
je 0x62e36a
cmpl $0x3a, %r15d
jne 0x62e19d
cmpb $0x3a, 0x1(%r13)
jne 0x62e36a
movq %rbx, 0x38(%rsp)
incq %r13
movb $0x3a, %r15b
jmp 0x62e1a2
movq %rbx, 0x38(%rsp)
movq %r13, 0x18(%rsp)
leaq 0x1(%r13), %r14
movq $0x0, (%rsp)
leaq 0x20(%rsp), %r13
leaq 0xae0a1(%rip), %rbp # 0x6dc260
xorl %ebx, %ebx
xorl %eax, %eax
movq $0x0, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movsbl %r15b, %r12d
movl $0x11, %edx
movq %rbp, %rdi
movl %r12d, %esi
callq 0x3fe70
testq %rax, %rax
je 0x62e1ef
movq %rbp, %rcx
jmp 0x62e20f
movl $0x11, %edx
leaq 0xae085(%rip), %rdi # 0x6dc280
movl %r12d, %esi
callq 0x3fe70
testq %rax, %rax
je 0x62e243
leaq 0xae071(%rip), %rcx # 0x6dc280
cmpl $0x3, %ebx
jg 0x62e2ef
movq (%rsp), %rsi
shll $0x4, %esi
subl %ecx, %eax
orl %esi, %eax
incl %ebx
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
leaq (%rsp,%rax), %r13
addq $0x20, %r13
movb (%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0x62e1cc
jmp 0x62e2a7
cmpb $0x3a, %r15b
jne 0x62e2cd
testl %ebx, %ebx
je 0x62e28c
cmpb $0x0, (%r14)
movq 0x8(%rsp), %rax
je 0x62e2ef
cmpq $0xe, %rax
jg 0x62e2ef
addq $0x2, %rax
movq (%rsp), %rcx
rolw $0x8, %cx
movw %cx, (%r13)
xorl %ebx, %ebx
movq %r14, 0x18(%rsp)
movq $0x0, (%rsp)
jmp 0x62e22e
xorl %ebx, %ebx
movq %r14, 0x18(%rsp)
cmpq $0x0, 0x10(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rax
je 0x62e22e
jmp 0x62e2ef
testl %ebx, %ebx
je 0x62e2ff
cmpq $0xe, %rax
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
jg 0x62e36a
movq (%rsp), %rdx
rolw $0x8, %dx
movw %dx, 0x20(%rsp,%rax)
addq $0x2, %rax
jmp 0x62e304
movzbl %r15b, %eax
cmpl $0x2e, %eax
jne 0x62e2ef
cmpq $0xc, 0x8(%rsp)
jg 0x62e2ef
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x62e37b
testl %eax, %eax
je 0x62e2f6
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
jmp 0x62e36a
movq 0x8(%rsp), %rax
addq $0x4, %rax
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
movq 0x38(%rsp), %rdi
je 0x62e35a
cmpq $0x10, %rax
je 0x62e36a
leaq (%rsp,%rax), %rcx
addq $0x20, %rcx
subq %rsi, %rcx
testl %ecx, %ecx
jle 0x62e360
movl %ecx, %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
incl %ecx
movl $0x1, %eax
subq %rcx, %rax
leaq (%rdx,%rsi), %rcx
decq %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %sil
movb %sil, 0x2f(%rsp,%rdx)
movb $0x0, (%rcx,%rdx)
decq %rdx
cmpq %rdx, %rax
jne 0x62e343
jmp 0x62e360
cmpq $0x10, %rax
jne 0x62e36a
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, ch)) != NULL) {
unsigned int nw = *tp * 10 + (pch - digits);
if (saw_digit && *tp == 0)
return UV_EINVAL;
if (nw > 255)
return UV_EINVAL;
*tp = nw;
if (!saw_digit) {
if (++octets > 4)
return UV_EINVAL;
saw_digit = 1;
}
} else if (ch == '.' && saw_digit) {
if (octets == 4)
return UV_EINVAL;
*++tp = 0;
saw_digit = 0;
} else
return UV_EINVAL;
}
if (octets < 4)
return UV_EINVAL;
memcpy(dst, tmp, sizeof(struct in_addr));
return 0;
}
|
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
movq %r15, %rdi
movl %ebp, %esi
callq 0x3fe70
testq %rax, %rax
je 0x62e424
movq %rax, %rcx
testb %bl, %bl
sete %dl
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
testb %dl, %r13b
jne 0x62e466
movzbl %bl, %edx
leal (%rdx,%rdx,4), %edx
subl %r15d, %ecx
leal (%rcx,%rdx,2), %ebx
cmpl $0xff, %ebx
ja 0x62e466
incq %r14
movb %bl, (%r12)
testb $0x1, %r13b
movb $0x1, %r13b
jne 0x62e3af
movq (%rsp), %rcx
cmpl $0x4, %ecx
leal 0x1(%rcx), %ecx
setb %r13b
movl %ecx, %edx
movq %rdx, (%rsp)
cmpl $0x5, %ecx
jne 0x62e3af
jmp 0x62e466
cmpl $0x4, (%rsp)
setne %al
cmpb $0x2e, %bpl
sete %cl
andb %r13b, %al
andb %cl, %al
cmpb $0x1, %al
jne 0x62e475
incq %r14
movb $0x0, 0x1(%r12)
incq %r12
xorl %ebx, %ebx
jmp 0x62e3ac
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpl $0x4, (%rsp)
jb 0x62e466
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
jmp 0x62e466
|
/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_itr) {
*itr = tmp + 1;
*tmp = '\0';
return start;
}
sep_itr++;
}
tmp++;
}
*itr = NULL;
return start;
}
|
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 0x62e4de
movb 0x1(%r8), %cl
incq %r8
testb %cl, %cl
jne 0x62e4d3
movq $0x0, (%rdx)
retq
leaq 0x1(%r8), %rcx
movq %rcx, (%rdx)
movb $0x0, (%r8)
retq
xorl %eax, %eax
retq
|
/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 here.
The worker that runs said other task will schedule this one as well. */
uv_mutex_unlock(&mutex);
return;
}
q = &run_slow_work_message;
}
QUEUE_INSERT_TAIL(&wq, q);
if (idle_threads > 0)
uv_cond_signal(&cond);
uv_mutex_unlock(&mutex);
}
|
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) # 0x86be88
leaq 0x23d89d(%rip), %rbx # 0x86be90
cmpq %rbx, 0x23d896(%rip) # 0x86be90
jne 0x62e630
leaq 0x23d89d(%rip), %rax # 0x86bea0
movq %rax, (%rbx)
movq 0x23d89b(%rip), %rax # 0x86bea8
movq %rax, 0x8(%rbx)
movq %rbx, (%rax)
movq %rbx, 0x23d88d(%rip) # 0x86bea8
cmpl $0x0, 0x23d88e(%rip) # 0x86beb0
je 0x62e630
leaq 0x23d81d(%rip), %rdi # 0x86be48
callq 0x62917a
leaq 0x23d7e9(%rip), %rdi # 0x86be20
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x628dc0
|
/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 # 0x6dc310
movl $0x14e, %edx # imm = 0x14E
callq 0x3f4b0
|
/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;
break;
case UV_GETNAMEINFO:
loop = ((uv_getnameinfo_t*) req)->loop;
wreq = &((uv_getnameinfo_t*) req)->work_req;
break;
case UV_RANDOM:
loop = ((uv_random_t*) req)->loop;
wreq = &((uv_random_t*) req)->work_req;
break;
case UV_WORK:
loop = ((uv_work_t*) req)->loop;
wreq = &((uv_work_t*) req)->work_req;
break;
default:
return UV_EINVAL;
}
return uv__work_cancel(loop, req, wreq);
}
|
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 # 0x6dc368
movq (%rdx,%rax,8), %rbp
leaq (%rdi,%rbp), %r13
movq (%rdi,%rcx), %r14
leaq 0x23d432(%rip), %rbx # 0x86be20
movq %rbx, %rdi
callq 0x628d8f
movl $0x88, %r12d
addq %rbp, %r15
addq $0x18, %r15
movq -0x8(%r15), %rdi
addq %r12, %rdi
callq 0x628d8f
movq (%r15), %rax
cmpq %rax, %r15
je 0x62ea94
cmpq $0x0, (%r13)
je 0x62ea94
movq 0x20(%r13), %rcx
movq %rax, (%rcx)
movq 0x18(%r13), %rax
movq 0x20(%r13), %rcx
movq %rcx, 0x8(%rax)
movl $0x88, %ebx
movq 0x10(%r13), %rdi
addq %rbx, %rdi
callq 0x628dc0
leaq 0x23d3d7(%rip), %rdi # 0x86be20
callq 0x628dc0
leaq -0x170(%rip), %rax # 0x62e8e5
movq %rax, (%r13)
addq %r14, %rbx
movq %rbx, %rdi
callq 0x628d8f
leaq 0x78(%r14), %rax
movq %rax, 0x18(%r13)
movq 0x80(%r14), %rax
movq %rax, 0x20(%r13)
movq %r15, (%rax)
movq %r15, 0x80(%r14)
addq $0xb0, %r14
movq %r14, %rdi
callq 0x61e86f
xorl %ebp, %ebp
jmp 0x62eaa5
addq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x628dc0
movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0
movq %rbx, %rdi
callq 0x628dc0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d # imm = 0x80000000
testl %r8d, %r9d
je 0x62f167
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0x62f131
shrl %r9d
movl %esi, %r10d
shrl %r10d
movl %r10d, %r11d
xorl $0xedb88320, %r11d # imm = 0xEDB88320
testb $0x1, %sil
cmovel %r10d, %r11d
movl %r11d, %esi
jmp 0x62f157
retq
movl $0x80000000, %eax # imm = 0x80000000
retq
|
/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 0x62f1ae
movl %eax, %eax
xorq %rsi, %rax
retq
nop
|
/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, strm->state->prev);
TRY_FREE(strm, strm->state->window);
ZFREE(strm, strm->state);
strm->state = Z_NULL;
return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
}
|
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(%rbx), %rsi
movq 0x78(%rsi), %rax
testq %rax, %rax
je 0x62f534
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x70(%rsi), %rax
testq %rax, %rax
je 0x62f54b
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x62f562
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x50(%rbx), %rdi
callq *0x48(%rbx)
movq $0x0, 0x38(%rbx)
xorl %eax, %eax
cmpl $0x71, %ebp
setne %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/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 %xmm0, (%rcx,%rdx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
shlq $0x5, %rax
addq %rcx, %rax
addq $-0x20, %rax
addq $0x20, %rsp
popq %rbx
retq
|
/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::pair<clang::FileID, unsigned int>, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, std::pair<clang::FileID, unsigned int>>>::InsertIntoBucketImpl<clang::FileID>(clang::FileID const&, clang::FileID const&, llvm::detail::DenseMapPair<clang::FileID, std::pair<clang::FileID, unsigned int>>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x358d1
incl 0x8(%rbx)
cmpl $0x0, (%rax)
je 0x358c5
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x358f2
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x35804
movq (%r15), %rax
jmp 0x358ba
nop
|
/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(%rip), %rax # 0x1228a8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0xea9c5(%rip), %rax # 0x125130
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xea72f(%rip), %rax # 0x124ea8
addq $0x10, %rax
movq %rax, 0x98(%r14)
movups %xmm0, 0xa0(%r14)
leaq 0x481(%rip), %rax # 0x3ac14
movq %rax, 0xb8(%r14)
leaq 0x475(%rip), %rax # 0x3ac16
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x3ab4f
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x515c2
|
/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_back(&getGeneralCategory());
}
|
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
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x2c(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x3c(%rdi)
movq %rax, 0x40(%rdi)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x48(%rdi)
leaq 0x78(%rdi), %rax
movq %rax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movq $0x1, 0x68(%rdi)
movl %ecx, 0x70(%rdi)
callq 0x51d8a
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x3abc0
|
/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, %rax
movq %rax, 0x88(%rbx)
leaq 0xe9a08(%rip), %rax # 0x125130
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0xe9772(%rip), %rax # 0x124ea8
addq $0x10, %rax
movq %rax, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq -0xb3b(%rip), %rax # 0x3ac14
movq %rax, 0xb8(%rbx)
leaq -0xb47(%rip), %rax # 0x3ac16
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3bf69
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x515c2
nop
|
/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 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, %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, 0x90(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r13)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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
movb %al, 0x90(%r14)
movl (%r15), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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
movb %al, 0x90(%r14)
movl (%r15), %eax
movzwl 0xa(%r14), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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
orl %eax, %ecx
movw %cx, 0xa(%r14)
movq (%r15), %rax
movb (%rax), %cl
movb %cl, 0x80(%r14)
movb $0x1, 0x91(%r14)
movb (%rax), %al
movb %al, 0x90(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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> 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, %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
orl %eax, %ecx
movw %cx, 0xa(%r13)
movq (%r14), %rax
movl (%rax), %eax
movl %eax, 0x80(%r13)
movb $0x1, 0x94(%r13)
movl %eax, 0x90(%r13)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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)
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x48(%rsp), %r12
leaq 0x58(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movabsq $0x300000000, %rax # imm = 0x300000000
movq %rax, -0x8(%rbx)
movq %r14, %rdi
callq 0x3f402
movq %rax, %r13
movaps -0x48(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
movb -0x38(%rbx), %al
movb %al, 0x18(%r13)
leaq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x15370
addq $0x40, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3f97a
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3f055
callq 0x152b0
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f06c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x15050
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f402
leaq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x15260
movl (%r15), %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x7, %rdi
movl $0x8, %esi
callq 0x2eaff
movq %rax, (%r15)
testq %r14, %r14
je 0x3f606
shlq $0x7, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f736
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2eb04
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x3f730
movabsq $0x1ffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x4, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x180, %rax # imm = 0x180
xorl %edx, %edx
movdqa 0x2cafe(%rip), %xmm1 # 0x6c150
movdqa 0x1d9a6(%rip), %xmm2 # 0x5d000
movdqa 0x1d9ae(%rip), %xmm3 # 0x5d010
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x3f6b7
movl $0xffffffff, -0x180(%rax) # imm = 0xFFFFFFFF
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x3f6d0
movl $0xffffffff, -0x100(%rax) # imm = 0xFFFFFFFF
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x3f70c
movl $0xffffffff, -0x80(%rax) # imm = 0xFFFFFFFF
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x3f71d
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
addq $0x4, %rdx
addq $0x200, %rax # imm = 0x200
cmpq %rdx, %rcx
jne 0x3f66a
popq %rbx
popq %r14
popq %r15
retq
|
/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
movw %cx, 0xa(%r12)
movq (%rbx), %rax
movb (%rax), %cl
movb %cl, 0x80(%r12)
movb $0x1, 0x91(%r12)
movb (%rax), %al
movb %al, 0x90(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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:
//
// -O2 or O2 or -la (where -l and -a are separate options)
//
// If this is the case, we cannot allow a value.
//
if (Owner.hasArgStr())
return ValueRequired;
else
return ValueDisallowed;
}
|
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 false;
}
return O.error("Cannot find option named '" + ArgVal + "'!");
}
|
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), %r12
xorl %ebp, %ebp
movq 0x8(%r13,%rbp), %rdx
cmpq %r14, %rdx
jne 0x409c0
testq %rdx, %rdx
je 0x40a19
movq (%r13,%rbp), %rdi
movq %r15, %rsi
callq 0x153b0
testl %eax, %eax
je 0x40a19
addq $0x30, %rbp
cmpq %rbp, %r12
jne 0x409a0
leaq 0x8(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0x47a63(%rip), %rcx # 0x8843e
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
leaq 0x51a00(%rip), %rax # 0x923f5
movq %rax, 0x10(%r14)
movw $0x302, 0x20(%r14) # imm = 0x302
callq 0x58ea1
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x51f00
jmp 0x40a2a
movl 0x28(%r13,%rbp), %eax
movq 0x90(%rsp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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), %rax # 0x122928
addq $0x10, %rax
movq %rax, (%r14)
leaq 0xe2dd9(%rip), %rax # 0x124ea8
addq $0x10, %rax
movq %rax, 0x98(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
leaq -0x5af8(%rip), %rax # 0x3c5f4
movq %rax, 0xb8(%r14)
leaq -0x5b04(%rip), %rax # 0x3c5f6
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x42126
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x515c2
|
/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
orl %eax, %ecx
movw %cx, 0xa(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x20(%rbx)
movq (%r14), %rax
movb (%rax), %cl
movb %cl, 0x80(%rbx)
movb $0x1, 0x91(%rbx)
movb (%rax), %al
movb %al, 0x90(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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
movw %cx, 0xa(%r12)
movq (%rbx), %rax
movl (%rax), %eax
movl %eax, 0x80(%r12)
movb $0x1, 0x94(%r12)
movl %eax, 0x90(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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(%r12)
movups (%rbx), %xmm0
movups %xmm0, 0x20(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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, %eax
sete %al
testb %al, %al
je 0x4ccb7
movl 0x20(%r12,%r13), %ebx
testb %al, %al
jne 0x4ccca
addq $0x28, %r12
cmpq $0xaa0, %r12 # imm = 0xAA0
jne 0x4cc85
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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)
.EndsWith("elf", Triple::ELF)
.EndsWith("goff", Triple::GOFF)
.EndsWith("macho", Triple::MachO)
.EndsWith("wasm", Triple::Wasm)
.EndsWith("spirv", Triple::SPIRV)
.Default(Triple::UnknownObjectFormat);
}
|
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 0x50e7b
movq %rax, %rdx
shrq $0x20, %rdx
jne 0x50e7b
leaq 0x1(%rcx), %rdx
cmpl $0x66666f63, -0x4(%rdi,%rsi) # imm = 0x66666F63
cmoveq %rdx, %rax
cmpq $0x3, %rsi
jb 0x50eaa
movq %rax, %rdx
andq %rcx, %rdx
jne 0x50eaa
movzwl -0x3(%rdi,%rsi), %edx
xorl $0x6c65, %edx # imm = 0x6C65
movzbl -0x1(%rdi,%rsi), %r8d
xorl $0x66, %r8d
leaq 0x3(%rcx), %r9
orw %dx, %r8w
cmoveq %r9, %rax
cmpq $0x4, %rsi
jb 0x50ec8
movq %rax, %rdx
andq %rcx, %rdx
jne 0x50ec8
leaq 0x4(%rcx), %rdx
cmpl $0x66666f67, -0x4(%rdi,%rsi) # imm = 0x66666F67
cmoveq %rdx, %rax
cmpq $0x5, %rsi
jb 0x50ef4
movq %rax, %rdx
andq %rcx, %rdx
jne 0x50ef4
movl $0x6863616d, %edx # imm = 0x6863616D
xorl -0x5(%rdi,%rsi), %edx
movzbl -0x1(%rdi,%rsi), %r8d
xorl $0x6f, %r8d
leaq 0x5(%rcx), %r9
orl %edx, %r8d
cmoveq %r9, %rax
cmpq $0x4, %rsi
jb 0x50f12
movq %rax, %rdx
andq %rcx, %rdx
jne 0x50f12
leaq 0x7(%rcx), %rdx
cmpl $0x6d736177, -0x4(%rdi,%rsi) # imm = 0x6D736177
cmoveq %rdx, %rax
cmpq $0x5, %rsi
jb 0x50f3b
movq %rax, %rdx
andq %rcx, %rdx
jne 0x50f3b
movl $0x72697073, %edx # imm = 0x72697073
xorl -0x5(%rdi,%rsi), %edx
movzbl -0x1(%rdi,%rsi), %esi
xorl $0x76, %esi
leaq 0x6(%rcx), %rdi
orl %edx, %esi
cmoveq %rdi, %rax
xorl %edx, %edx
testq %rcx, %rax
cmovel %edx, %eax
retq
|
/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
movq %rax, (%rcx)
movq %rdi, %rsi
callq 0x52f20
addq $0x18, %rsp
retq
cmpb $0x1, 0x94(%rdi)
jne 0x51741
movl 0x80(%rdi), %eax
cmpl %eax, 0x90(%rdi)
jne 0x51741
retq
nop
|
/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), %rdi
movq %rbx, %rdx
callq 0x53dc2
addq $0x20, %rsp
popq %rbx
retq
|
/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 call to free() due to needing to use malloc() in
// WritableMemoryBuffer::getNewUninitMemBuffer() to work around the out-of-
// memory handler installed by default in LLVM. See operator delete() member
// functions within this file for the paired call to free().
char *Mem =
static_cast<char *>(std::malloc(N + sizeof(size_t) + NameRef.size() + 1));
if (!Mem)
llvm::report_bad_alloc_error("Allocation failed");
*reinterpret_cast<size_t *>(Mem + N) = NameRef.size();
CopyStringRef(Mem + N + sizeof(size_t), NameRef);
return Mem;
}
|
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,%rdx), %rdi
addq $0x9, %rdi
callq 0x15460
testq %rax, %rax
je 0x56349
movq %rax, %rbx
movq %r15, (%rax,%r14)
addq %rax, %r14
addq $0x8, %r14
testq %r15, %r15
je 0x56321
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x15280
movb $0x0, (%r14,%r15)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x56335
callq 0x152b0
movq %rbx, %rax
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb064c(%rip), %rdi # 0x10699c
movl $0x1, %esi
callq 0x559b5
|
/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 == FirstEl)
NewElts = replaceAllocation(NewElts, TSize, NewCapacity);
// Copy the elements over. No need to run dtors on PODs.
memcpy(NewElts, this->BeginX, size() * TSize);
} else {
// If this wasn't grown from the inline copy, grow the allocated space.
NewElts = llvm::safe_realloc(this->BeginX, NewCapacity * TSize);
if (NewElts == FirstEl)
NewElts = replaceAllocation(NewElts, TSize, NewCapacity, size());
}
this->set_allocation_range(NewElts, NewCapacity);
}
|
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 0x56ea4
testq %rbp, %rbp
jne 0x56f2e
movl $0x1, %edi
callq 0x15460
testq %rax, %rax
je 0x56f2e
movq %rax, %r13
cmpq %r12, %rax
jne 0x56f18
movl 0x8(%rbx), %r8d
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x56dd0
movq %rax, %r13
jmp 0x56f18
movq %rbp, %rdi
callq 0x15460
testq %rax, %rax
jne 0x56ee7
testq %rbp, %rbp
jne 0x56f2e
movl $0x1, %edi
callq 0x15460
testq %rax, %rax
je 0x56f2e
movq %rax, %r13
cmpq %r12, %rax
jne 0x56f06
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x56dd0
movq %rax, %r13
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
imulq %r15, %rdx
movq %r13, %rdi
callq 0x15280
movq %r13, (%rbx)
movl %r14d, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xafa67(%rip), %rdi # 0x10699c
movl $0x1, %esi
callq 0x559b5
nop
|
/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 << '.' << *Build;
return 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), %rcx
movq %rcx, 0x20(%rbx)
movb $0x2e, (%rax)
movq %rbx, %rdi
jmp 0x583c3
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x585fc
movq %rax, %rdi
sarq $0x3f, %r15
andl %r12d, %r15d
movq %r15, %rsi
callq 0x58574
movq 0x8(%r14), %r15
testl %r15d, %r15d
jns 0x58414
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x583fc
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x2e, (%rax)
movq %rbx, %rdi
jmp 0x5840c
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x585fc
movq %rax, %rdi
movq %r15, %rsi
callq 0x58574
movq 0x8(%r14), %r14
testq %r14, %r14
jns 0x58464
movq %r14, %r15
shrq $0x20, %r15
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x58445
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x2e, (%rax)
movq %rbx, %rdi
jmp 0x58455
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x585fc
movq %rax, %rdi
sarq $0x3f, %r14
andl %r15d, %r14d
movq %r14, %rsi
callq 0x58574
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 $0x4f, %r15d
cmovbl %ebp, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x58672
subl %r15d, %ebp
jne 0x5893b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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_fatal_error()
// might not write messages to stderr when any errors were detected
// on FD == 2.
if (FD == 2) return;
#endif
// If there are any pending errors, report them now. Clients wishing
// to avoid report_fatal_error calls should check for errors with
// has_error() and clear the error flag with clear_error() before
// destructing raw_ostream objects which may have errors.
if (has_error())
report_fatal_error(Twine("IO failure on output stream: ") +
error().message(),
/*gen_crash_diag=*/false);
}
|
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)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4320
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
|
/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
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
je 0x4542
jmp 0x451a
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
/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(next))) {
if (is_mmapped(p)) {
newp = mmap_resize(m, p, nb, can_move);
}
else if (oldsize >= nb) { /* already big enough */
size_t rsize = oldsize - nb;
if (rsize >= MIN_CHUNK_SIZE) { /* split off remainder */
mchunkptr r = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
set_inuse(m, r, rsize);
dispose_chunk(m, r, rsize);
}
newp = p;
}
else if (next == m->top) { /* extend into top */
if (oldsize + m->topsize > nb) {
size_t newsize = oldsize + m->topsize;
size_t newtopsize = newsize - nb;
mchunkptr newtop = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
newtop->head = newtopsize |PINUSE_BIT;
m->top = newtop;
m->topsize = newtopsize;
newp = p;
}
}
else if (next == m->dv) { /* extend into dv */
size_t dvs = m->dvsize;
if (oldsize + dvs >= nb) {
size_t dsize = oldsize + dvs - nb;
if (dsize >= MIN_CHUNK_SIZE) {
mchunkptr r = chunk_plus_offset(p, nb);
mchunkptr n = chunk_plus_offset(r, dsize);
set_inuse(m, p, nb);
set_size_and_pinuse_of_free_chunk(r, dsize);
clear_pinuse(n);
m->dvsize = dsize;
m->dv = r;
}
else { /* exhaust dv */
size_t newsize = oldsize + dvs;
set_inuse(m, p, newsize);
m->dvsize = 0;
m->dv = 0;
}
newp = p;
}
}
else if (!cinuse(next)) { /* extend into next free chunk */
size_t nextsize = chunksize(next);
if (oldsize + nextsize >= nb) {
size_t rsize = oldsize + nextsize - nb;
unlink_chunk(m, next, nextsize);
if (rsize < MIN_CHUNK_SIZE) {
size_t newsize = oldsize + nextsize;
set_inuse(m, p, newsize);
}
else {
mchunkptr r = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
set_inuse(m, r, rsize);
dispose_chunk(m, r, rsize);
}
newp = p;
}
}
}
else {
USAGE_ERROR_ACTION(m, chunk2mem(p));
}
return newp;
}
|
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 %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x109(%rbp)
jb 0x8bd9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x3, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x109(%rbp)
je 0x8bd9
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x38(%rbp), %rcx
movb %al, -0x109(%rbp)
jae 0x8bd9
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
movb %al, -0x109(%rbp)
movb -0x109(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x95b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x8c1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0xc2f0
movq %rax, -0x28(%rbp)
jmp 0x95b7
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x8cd2
movq -0x30(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x20, -0x40(%rbp)
jb 0x8cc5
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x18(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x40(%rbp), %rcx
orq $0x2, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xc490
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x95b5
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x8d89
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x10(%rcx), %rax
cmpq -0x18(%rbp), %rax
jbe 0x8d84
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x18(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x58(%rbp), %rcx
orq $0x1, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x95b3
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x8ed4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
addq -0x68(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x8ecf
movq -0x30(%rbp), %rax
addq -0x68(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x20, -0x70(%rbp)
jb 0x8e68
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
addq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x18(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x70(%rbp), %rcx
orq $0x1, %rcx
movq -0x78(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rdx, (%rax,%rcx)
movq -0x80(%rbp), %rax
movq 0x8(%rax), %rcx
andq $-0x2, %rcx
movq %rcx, 0x8(%rax)
movq -0x70(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x78(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x8ec7
movq -0x30(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x88(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x88(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x95b1
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
jne 0x95af
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x8, %rax
movq %rax, -0x90(%rbp)
movq -0x30(%rbp), %rax
addq -0x90(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x95ad
movq -0x30(%rbp), %rax
addq -0x90(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rax
shrq $0x3, %rax
cmpq $0x20, %rax
jae 0x90d2
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x90(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0xac(%rbp)
movq -0xa0(%rbp), %rcx
movq -0x8(%rbp), %rdx
addq $0x48, %rdx
movl -0xac(%rbp), %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x10a(%rbp)
je 0x8fd6
movq -0xa0(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x10b(%rbp)
jb 0x8fca
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x38(%rbp), %rax
sete %al
movb %al, -0x10b(%rbp)
movb -0x10b(%rbp), %al
movb %al, -0x10a(%rbp)
movb -0x10a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x90c8
movq -0xa8(%rbp), %rax
cmpq -0xa0(%rbp), %rax
jne 0x901c
movl -0xac(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x8(%rbp), %rax
andl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x90c6
movq -0xa8(%rbp), %rcx
movq -0x8(%rbp), %rdx
addq $0x48, %rdx
movl -0xac(%rbp), %eax
shll %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x10c(%rbp)
je 0x9086
movq -0xa8(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x10d(%rbp)
jb 0x907a
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x38(%rbp), %rax
sete %al
movb %al, -0x10d(%rbp)
movb -0x10d(%rbp), %al
movb %al, -0x10c(%rbp)
movb -0x10c(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x90bf
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0xa0(%rbp), %rcx
movq -0xa8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x90c4
callq 0x10ef0
jmp 0x90c6
jmp 0x90cd
callq 0x10ef0
jmp 0x94b3
movq -0x38(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0xb8(%rbp), %rax
je 0x91be
movq -0xb8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0xd0(%rbp), %rcx
movq -0x8(%rbp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x10e(%rbp)
jb 0x917b
movq -0xd0(%rbp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq -0xb8(%rbp), %rcx
movb %al, -0x10e(%rbp)
jne 0x917b
movq -0xc8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0xb8(%rbp), %rax
sete %al
movb %al, -0x10e(%rbp)
movb -0x10e(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x91b4
movq -0xc8(%rbp), %rcx
movq -0xd0(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0xd0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x91b9
callq 0x10ef0
jmp 0x92bd
movq -0xb8(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
addq $0x8, %rcx
movq %rcx, -0xd8(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
jne 0x9212
movq -0xb8(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, -0xd8(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0x92bb
jmp 0x9214
movq -0xc8(%rbp), %rcx
movq %rcx, %rax
addq $0x20, %rax
addq $0x8, %rax
movq %rax, -0xe0(%rbp)
movb $0x1, %al
cmpq $0x0, 0x28(%rcx)
movb %al, -0x10f(%rbp)
jne 0x925f
movq -0xc8(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, -0xe0(%rbp)
cmpq $0x0, 0x20(%rax)
setne %al
movb %al, -0x10f(%rbp)
movb -0x10f(%rbp), %al
testb $0x1, %al
jne 0x926b
jmp 0x9285
movq -0xe0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
jmp 0x9214
movq -0xd8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x92b4
movq -0xd8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x92b9
callq 0x10ef0
jmp 0x92bb
jmp 0x92bd
cmpq $0x0, -0xc0(%rbp)
je 0x94b1
movq -0x8(%rbp), %rax
addq $0x258, %rax # imm = 0x258
movq -0xb8(%rbp), %rcx
movl 0x38(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xb8(%rbp), %rax
movq -0xe8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x9339
movq -0xc8(%rbp), %rax
movq -0xe8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x9337
movq -0xb8(%rbp), %rax
movl 0x38(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x8(%rbp), %rax
andl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x939b
movq -0xc0(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x9394
movq -0xc0(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0xb8(%rbp), %rax
jne 0x9380
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x9392
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x9399
callq 0x10ef0
jmp 0x939b
cmpq $0x0, -0xc8(%rbp)
je 0x94af
movq -0xc8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x94a8
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0xb8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, %rax
je 0x9442
movq -0xf0(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x943b
movq -0xf0(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0xc8(%rbp), %rcx
movq -0xf0(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x9440
callq 0x10ef0
jmp 0x9442
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xf8(%rbp)
cmpq $0x0, %rax
je 0x94a6
movq -0xf8(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x949f
movq -0xf8(%rbp), %rcx
movq -0xc8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0xc8(%rbp), %rcx
movq -0xf8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x94a4
callq 0x10ef0
jmp 0x94a6
jmp 0x94ad
callq 0x10ef0
jmp 0x94af
jmp 0x94b1
jmp 0x94b3
cmpq $0x20, -0x98(%rbp)
jae 0x950c
movq -0x30(%rbp), %rax
addq -0x90(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x100(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x100(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
jmp 0x95a5
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x18(%rbp), %rcx
orq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rcx
andq $0x1, %rcx
orq -0x98(%rbp), %rcx
orq $0x2, %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x108(%rbp), %rax
movq -0x98(%rbp), %rcx
movq 0x8(%rax,%rcx), %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x108(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0xc490
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x95af
jmp 0x95b1
jmp 0x95b3
jmp 0x95b5
jmp 0x95b7
jmp 0x95be
callq 0x10ef0
movq -0x28(%rbp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopl (%rax,%rax)
|
/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 >= nb + SIZE_T_SIZE &&
(oldsize - nb) <= (mparams.granularity << 1))
return oldp;
else {
size_t offset = oldp->prev_foot;
size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
oldmmsize, newmmsize, flags);
if (cp != CMFAIL) {
mchunkptr newp = (mchunkptr)(cp + offset);
size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
newp->head = psize;
mark_inuse_foot(m, newp, psize);
chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0;
if (cp < m->least_addr)
m->least_addr = cp;
if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
m->max_footprint = m->footprint;
check_mmapped_chunk(m, newp);
return newp;
}
}
return 0;
}
|
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), %rax
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jb 0xc363
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movq 0xa98a(%rip), %rcx # 0x16cd8
shlq %rcx
cmpq %rcx, %rax
ja 0xc363
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc47f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rax
addq $0xf, %rax
movq 0xa93f(%rip), %rcx # 0x16cd0
subq $0x1, %rcx
addq %rcx, %rax
movq 0xa931(%rip), %rcx # 0x16cd0
subq $0x1, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x48(%rbp)
movq $-0x1, %rax
movq %rax, -0x50(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x50(%rbp)
je 0xc475
movq -0x50(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
subq -0x38(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq $0xb, 0x8(%rax,%rcx)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx)
movq -0x50(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xc42e
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x358(%rcx), %rax
movq %rax, 0x358(%rcx)
movq -0x10(%rbp), %rcx
cmpq 0x360(%rcx), %rax
jbe 0xc46b
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x360(%rax)
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc47f
jmp 0xc477
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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;
}
}
if ( ( rc->buffer = (char *)malloc( BUFSIZ ) ) == NULL )
{
/* No memory */
free( rc );
return NULL;
}
rc->bufsize = BUFSIZ;
rc->bufidx = 0;
rc->bufend = 0;
rc->pos.offset = 0;
rc->pos.status = 0;
rc->ungetidx = 0;
rc->status = _PDCLIB_FREEBUFFER;
#ifndef __STDC_NO_THREADS__
if ( stream == NULL )
{
/* If called by freopen() (stream not NULL), mutex is already
initialized.
*/
if ( mtx_init( &rc->mtx, mtx_plain | mtx_recursive ) != thrd_success )
{
/* could not initialize stream mutex */
free( rc->buffer );
free( rc );
return NULL;
}
}
#endif
/* TODO: Setting mbstate */
return rc;
}
|
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 0x4650
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0xd83c
movq -0x18(%rbp), %rdi
callq 0x6af0
movq $0x0, -0x8(%rbp)
jmp 0xd8d6
movq -0x18(%rbp), %rax
movq $0x400, 0x10(%rax) # imm = 0x400
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x100, 0x44(%rax) # imm = 0x100
cmpq $0x0, -0x10(%rbp)
jne 0xd8ce
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movl $0x1, %esi
callq 0x10920
cmpl $0x1, %eax
je 0xd8cc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6af0
movq -0x18(%rbp), %rdi
callq 0x6af0
movq $0x0, -0x8(%rbp)
jmp 0xd8d6
jmp 0xd8ce
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
/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 ) ) )
{
/* Function called on illegal (e.g. output) stream. */
*_PDCLIB_errno_func() = _PDCLIB_EBADF;
stream->status |= _PDCLIB_ERRORFLAG;
return EOF;
}
stream->status |= _PDCLIB_FREAD | _PDCLIB_BYTESTREAM;
return 0;
}
|
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), %eax
andl $0x48, %eax
cmpl $0x0, %eax
jne 0xdad2
callq 0xd620
movl $0x9, (%rax)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
orl $0x200, %ecx # imm = 0x200
movl %ecx, 0x44(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdae9
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
orl $0x1008, %ecx # imm = 0x1008
movl %ecx, 0x44(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%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_bits;
char value;
unsigned char mantissa[ _PDCLIB_LDBL_MANT_DIG / 4 + 2 ] = { 0 };
size_t m = 0;
char exponent[ 7 ];
size_t e = 0;
size_t i;
char const * digit_chars = ( status->flags & E_lower ) ? _PDCLIB_digits : _PDCLIB_Xdigits;
int index_offset = 0;
_PDCLIB_static_assert( _PDCLIB_FLT_RADIX == 2, "Assuming 2-based FP" );
_PDCLIB_static_assert( _PDCLIB_CHAR_BIT == 8, "Assuming 8-bit bytes" );
/* Mantissa */
/* -------- */
/* Handle the most significant byte (which might need masking) */
excess_bits = ( mant_dig - 1 ) % 8;
if ( excess_bits > 0 )
{
value = *mant & ( ( 1 << excess_bits ) - 1 );
if ( excess_bits >= 4 )
{
mantissa[1] = value & 0x0f;
value >>= 4;
excess_bits -= 4;
++m;
}
index_offset = 1;
}
mantissa[0] = ( dec << excess_bits ) | ( value & ( ( 1 << excess_bits ) - 1 ) );
/* Now handle the remaining bytes. */
/* This is doing a little trick: m is the highest valid index
(or a count of *fractional* digits, if you like), not a count
of elements (0..1, not 1..2), so it can double as an index
into the mant[] array (when divided by 2).
*/
while ( m < ( ( mant_dig + 3 ) / 4 - 1 ) )
{
value = *(mant OP ( ( m / 2 ) + index_offset ) );
mantissa[++m] = ( value & 0xf0 ) >> 4;
mantissa[++m] = ( value & 0x0f );
}
/* Roll back trailing zeroes */
while ( m > 0 && mantissa[m] == 0 )
{
--m;
}
/* Exponent */
/* -------- */
exp -= excess_bits;
if ( ( m == 0 && dec == 0 ) || exp == 0 )
{
/* All zero */
exponent[0] = '+';
exponent[1] = '0';
e = 2;
}
else
{
if ( dec == 0 )
{
/* Subnormal */
++exp;
}
if ( exp >= 0 )
{
exponent[0] = '+';
}
else
{
exponent[0] = '-';
exp *= -1;
}
for ( e = 1; exp > 0; ++e )
{
div_t d = div( exp, 10 );
exponent[e] = digit_chars[ d.rem ];
exp = d.quot;
}
}
exponent[e] = '\0';
/* Rounding */
/* -------- */
if ( ( status->prec >= 0 ) && ( m > (size_t)status->prec ) )
{
i = status->prec;
if ( ( mantissa[ i + 1 ] > 8 ) ||
( ( mantissa[ i + 1 ] == 8 ) &&
( ( m >= i + 2 ) || ( mantissa[ i ] % 2 ) )
)
)
{
while ( ( ++mantissa[ i ] ) > 0xf )
{
mantissa[ i-- ] = 0;
}
}
m = i;
}
/* Padding */
/* ------- */
status->current = m + 4 + ( sign != '\0' ) + ( ( m > 0 ) || ( status->prec > 0 ) || ( status->flags & E_alt ) ) + e;
if ( ! ( status->flags & ( E_zero | E_minus ) ) )
{
for ( i = status->current; i < status->width; ++i )
{
PUT( ' ' );
}
}
if ( sign != '\0' )
{
PUT( sign );
}
/* Output */
/* ------ */
PUT( '0' );
PUT( ( status->flags & E_lower ) ? 'x' : 'X' );
PUT( digit_chars[ mantissa[0] ] );
if ( ( ( m > 0 ) && ( status->prec != 0 ) ) || ( status->prec > 0 ) || ( status->flags & E_alt ) )
{
PUT( '.' );
}
if ( ( status->flags & E_zero ) && ! ( status->flags & E_minus ) )
{
for ( i = status->current; i < status->width; ++i )
{
PUT( '0' );
}
}
for ( i = 1; i <= m; ++i )
{
PUT( digit_chars[ mantissa[i] ] );
}
while ( (int)i <= status->prec )
{
PUT( '0' );
++i;
}
PUT( ( status->flags & E_lower ) ? 'p' : 'P' );
PUT( exponent[0] );
for ( i = e - 1; i > 0; --i )
{
PUT( exponent[i] );
}
}
|
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 0x4(%rax), %edx
andl $0x10000, %edx # imm = 0x10000
leaq 0x3dec(%rip), %rax # 0x130c0
leaq 0x3db5(%rip), %rcx # 0x13090
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
movq -0x20(%rbp), %rax
subq $0x1, %rax
andq $0x7, %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0xf35a
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movb %al, -0x31(%rbp)
cmpq $0x4, -0x30(%rbp)
jb 0xf353
movsbl -0x31(%rbp), %eax
andl $0xf, %eax
movb %al, -0x4f(%rbp)
movsbl -0x31(%rbp), %eax
sarl $0x4, %eax
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movl $0x1, -0x7c(%rbp)
movl -0xc(%rbp), %eax
movq -0x30(%rbp), %rcx
shll %cl, %eax
movsbl -0x31(%rbp), %ecx
movl %ecx, -0xb8(%rbp)
movq -0x30(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl -0xb8(%rbp), %ecx
subl $0x1, %edx
andl %edx, %ecx
orl %ecx, %eax
movb %al, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x3, %rcx
shrq $0x2, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xf3fd
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rdx
shrq %rdx
movslq -0x7c(%rbp), %rcx
addq %rcx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movb %al, %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, -0x4f(%rbp,%rax)
movsbl -0x31(%rbp), %eax
andl $0xf, %eax
movb %al, %cl
movq -0x58(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x58(%rbp)
movb %cl, -0x4f(%rbp,%rax)
jmp 0xf388
jmp 0xf3ff
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -0xb9(%rbp)
jbe 0xf423
movq -0x58(%rbp), %rax
movzbl -0x50(%rbp,%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0xf42f
jmp 0xf43d
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xf3ff
movq -0x30(%rbp), %rcx
movslq -0x8(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x8(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xf458
cmpl $0x0, -0xc(%rbp)
je 0xf45e
cmpl $0x0, -0x8(%rbp)
jne 0xf470
movb $0x2b, -0x5f(%rbp)
movb $0x30, -0x5e(%rbp)
movq $0x2, -0x68(%rbp)
jmp 0xf4e4
cmpl $0x0, -0xc(%rbp)
jne 0xf47f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0xf48b
movb $0x2b, -0x5f(%rbp)
jmp 0xf496
movb $0x2d, -0x5f(%rbp)
imull $-0x1, -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq $0x1, -0x68(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0xf4e2
movl -0x8(%rbp), %edi
movl $0xa, %esi
callq 0x10f10
movq %rax, -0x84(%rbp)
movq -0x78(%rbp), %rax
movslq -0x80(%rbp), %rcx
movb (%rax,%rcx), %cl
movq -0x68(%rbp), %rax
movb %cl, -0x5f(%rbp,%rax)
movl -0x84(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0xf49e
jmp 0xf4e4
movq -0x68(%rbp), %rax
movb $0x0, -0x5f(%rbp,%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0xf597
movq -0x58(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq 0x30(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xf597
movq -0x28(%rbp), %rax
movslq 0x30(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movzbl -0x4f(%rbp,%rax), %eax
cmpl $0x8, %eax
jg 0xf55f
movq -0x70(%rbp), %rax
movzbl -0x4f(%rbp,%rax), %eax
cmpl $0x8, %eax
jne 0xf58f
movq -0x58(%rbp), %rax
movq -0x70(%rbp), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0xf55f
movq -0x70(%rbp), %rax
movzbl -0x50(%rbp,%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xf58f
jmp 0xf561
movq -0x70(%rbp), %rcx
movb -0x50(%rbp,%rcx), %al
addb $0x1, %al
movb %al, -0x50(%rbp,%rcx)
movzbl %al, %eax
cmpl $0xf, %eax
jle 0xf58d
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x70(%rbp)
movb $0x0, -0x50(%rbp,%rax)
jmp 0xf561
jmp 0xf58f
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x4, %rax
cmpl $0x0, -0x4(%rbp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0xc8(%rbp)
movb $0x1, %al
cmpq $0x0, -0x58(%rbp)
movb %al, -0xba(%rbp)
ja 0xf5f0
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpl $0x0, 0x30(%rcx)
movb %al, -0xba(%rbp)
jg 0xf5f0
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xba(%rbp)
movq -0xc8(%rbp), %rcx
movb -0xba(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq %rax, %rcx
addq -0x68(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x11, %eax
cmpl $0x0, %eax
jne 0xf6c0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xf6be
jmp 0xf642
movl $0x20, -0x88(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf69b
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf67e
movl -0x88(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf699
movl -0x88(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf69b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf6ad
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xf632
jmp 0xf6c0
cmpl $0x0, -0x4(%rbp)
je 0xf732
jmp 0xf6c8
movl -0x4(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf720
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf703
movl -0x8c(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf71e
movl -0x8c(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf720
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf732
jmp 0xf734
movl $0x30, -0x90(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf78d
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf770
movl -0x90(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf78b
movl -0x90(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf78d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf79f
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
andl $0x10000, %edx # imm = 0x10000
movl $0x58, %eax
movl $0x78, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x94(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf811
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf7f4
movl -0x94(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf80f
movl -0x94(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf811
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf823
movq -0x78(%rbp), %rax
movzbl -0x50(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf884
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf867
movl -0x98(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf882
movl -0x98(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf884
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x58(%rbp)
jbe 0xf8a5
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0xf8be
movq -0x28(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jg 0xf8be
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xf92b
jmp 0xf8c0
movl $0x2e, -0x9c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf919
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf8fc
movl -0x9c(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf917
movl -0x9c(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf919
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf92b
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xf9eb
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xf9eb
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0xf9e9
jmp 0xf96d
movl $0x30, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xf9c6
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xf9a9
movl -0xa0(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xf9c4
movl -0xa0(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xf9c6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xf9d8
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xf95d
jmp 0xf9eb
movq $0x1, -0x70(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x58(%rbp), %rax
ja 0xfa8c
jmp 0xfa03
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movzbl -0x50(%rbp,%rcx), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, -0xa4(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xfa69
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfa4c
movl -0xa4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xfa67
movl -0xa4(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xfa69
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xfa7b
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xf9f3
jmp 0xfa8e
movq -0x70(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jg 0xfb17
jmp 0xfa9d
movl $0x30, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xfaf6
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfad9
movl -0xa8(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xfaf4
movl -0xa8(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xfaf6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xfa8e
jmp 0xfb19
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
andl $0x10000, %edx # imm = 0x10000
movl $0x50, %eax
movl $0x70, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xac(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xfb8b
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfb6e
movl -0xac(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xfb89
movl -0xac(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xfb8b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xfb9d
movsbl -0x5f(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xfbf6
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfbd9
movl -0xb0(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xfbf4
movl -0xb0(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xfbf6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x68(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jbe 0xfca0
jmp 0xfc1f
movq -0x70(%rbp), %rax
movsbl -0x5f(%rbp,%rax), %eax
movl %eax, -0xb4(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xfc7d
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xfc60
movl -0xb4(%rbp), %edi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x10d10
jmp 0xfc7b
movl -0xb4(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0xfc7d
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xfc8f
movq -0x70(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xfc12
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
|
/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;
}
}
stream->status &= ~ _PDCLIB_EOFFLAG;
if ( stream->status & _PDCLIB_FRW )
{
stream->status &= ~( _PDCLIB_FREAD | _PDCLIB_FWRITE );
}
if ( whence == SEEK_CUR )
{
offset -= ( ( ( int )stream->bufend - ( int )stream->bufidx ) + stream->ungetidx );
}
rc = ( _PDCLIB_seek( stream, offset, whence ) != EOF ) ? 0 : EOF;
_PDCLIB_UNLOCK( stream->mtx );
return rc;
}
|
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 0x10ba6
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x109d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10c39
jmp 0x10ba8
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
andl $0xfffffbff, %ecx # imm = 0xFFFFFBFF
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x10bd4
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
andl $-0x19, %ecx
movl %ecx, 0x44(%rax)
cmpl $0x1, -0x1c(%rbp)
jne 0x10c02
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
subl %ecx, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x115e0
movq %rax, %rdx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpq $-0x1, %rdx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x109d0
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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 $0x10, %rsp
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
|
/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 = *( p++ );
}
/* determining base */
if ( *p == '0' )
{
++p;
if ( ( *base == 0 || *base == 16 ) && ( *p == 'x' || *p == 'X' ) )
{
*base = 16;
++p;
/* catching a border case here: "0x" followed by a non-digit should
be parsed as the unprefixed zero.
We have to "rewind" the parsing; having the base set to 16 if it
was zero previously does not hurt, as the result is zero anyway.
*/
if ( memchr( _PDCLIB_digits, tolower( (unsigned char)*p ), *base ) == NULL )
{
p -= 2;
}
}
else if ( *base == 0 )
{
*base = 8;
/* back up one digit, so that a plain zero is decoded correctly
(and endptr is set correctly as well).
(2019-01-15, Giovanni Mascellani)
*/
--p;
}
else
{
--p;
}
}
else if ( ! *base )
{
*base = 10;
}
return ( ( *base >= 2 ) && ( *base <= 36 ) ) ? p : NULL;
}
|
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, %eax
je 0x114a4
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x114a4
movq -0x10(%rbp), %rax
movb $0x2b, (%rax)
jmp 0x114bb
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x1157d
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x114e9
movq -0x18(%rbp), %rax
cmpl $0x10, (%rax)
jne 0x1154c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0x11501
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0x1154c
movq -0x18(%rbp), %rax
movl $0x10, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
callq 0x116d0
movl %eax, %esi
movq -0x18(%rbp), %rax
movslq (%rax), %rdx
leaq 0x1b5d(%rip), %rdi # 0x13090
callq 0x11aa0
cmpq $0x0, %rax
jne 0x1154a
movq -0x8(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x1157b
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1156d
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11579
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1157b
jmp 0x11592
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x11590
movq -0x18(%rbp), %rax
movl $0xa, (%rax)
jmp 0x11592
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jl 0x115ae
movq -0x18(%rbp), %rax
cmpl $0x24, (%rax)
jg 0x115ae
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x115b6
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x115b6
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
/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)
movq %rbx, 0x80(%r14)
popq %rbx
popq %r14
popq %r15
retq
|
/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, %rsp
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x4f370
leaq 0x3ffc1(%rip), %rcx # 0xb7e38
movq %rcx, (%rax)
leaq 0x3ff8f(%rip), %rsi # 0xb7e10
movq 0x410e0(%rip), %rdx # 0xb8f68
movq %rax, %rdi
callq 0x4fb40
|
/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
movq %r11, (%rax)
leaq 0x7(%rsp), %r8
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
xorl %r9d, %r9d
pushq %r10
pushq %r11
callq 0x68fda
addq $0x10, %rsp
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movq 0x10(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x10(%rsi)
movups (%r14), %xmm0
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x77fa8
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x77f49
callq 0x4f6a0
jmp 0x77f49
movq %rax, %r14
movq %r14, %rdi
callq 0x4f2f0
movl $0x10, %edi
callq 0x4f370
movq %rax, %rbx
leaq 0x1d70a(%rip), %rsi # 0x9566f
movq %rax, %rdi
callq 0x4fca0
movq 0x41044(%rip), %rsi # 0xb8fb8
movq 0x40ffd(%rip), %rdx # 0xb8f78
movq %rbx, %rdi
callq 0x4fb40
movq %rax, %r14
jmp 0x77f93
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f520
callq 0x4fac0
movq %r14, %rdi
callq 0x4fba0
movq %rax, %rdi
callq 0x5cc8d
|
/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 = stringifyBinaryExpr(lhs, ", ", rhs);
return !m_failed;
}
|
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, %rcx
callq 0x780cb
leaq 0x48(%rbx), %rdi
movq %r12, %rsi
callq 0x83a3a
movq %rsp, %rdi
callq 0x837a4
movb 0x28(%rbx), %al
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x837a4
movq %rbx, %rdi
callq 0x4fba0
|
/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) : size;
o.pack_str(adjusted_size);
o.pack_str_body(p, adjusted_size);
return o;
}
|
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, (%rsi)
movq (%rbx), %rdi
movl $0x1, %edx
jmp 0x79884
cmpl $0xff, %ebp
ja 0x79849
leaq 0x6(%rsp), %rsi
movb $-0x27, (%rsi)
movb %bpl, 0x1(%rsi)
movq (%rbx), %rdi
movl $0x2, %edx
jmp 0x79884
cmpl $0xffff, %ebp # imm = 0xFFFF
ja 0x7986d
leaq 0x8(%rsp), %rsi
movb $-0x26, (%rsi)
movl %ebp, %eax
rolw $0x8, %ax
movw %ax, 0x1(%rsi)
movq (%rbx), %rdi
movl $0x3, %edx
jmp 0x79884
leaq 0xb(%rsp), %rsi
movb $-0x25, (%rsi)
movl %ebp, %eax
bswapl %eax
movl %eax, 0x1(%rsi)
movq (%rbx), %rdi
movl $0x5, %edx
callq 0x6b1ba
movl %ebp, %edx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6b1ba
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/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> const&)
|
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 (%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq %rcx, 0x18(%rax)
movq 0x10(%r14), %rdx
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%rax)
movq %rcx, 0x8(%r14)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x31(%rip), %rdx # 0x7d2ae
movq %rdx, (%rax)
movq %rax, (%rbx)
movq %rcx, 0x8(%rdi)
callq 0x7d34a
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5cc8d
|
/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::connection::response(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, rest_rpc::request_type)::'lambda'()>, std::allocator<void> const&)
|
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 (%r14), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x10(%r14), %rdx
movq %rdx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %rcx, 0x28(%rax)
movups 0x18(%r14), %xmm0
movq %rcx, 0x20(%r14)
movups %xmm0, 0x20(%rax)
movq %rcx, 0x18(%r14)
movb 0x30(%r14), %dl
movb %dl, 0x38(%rax)
movq 0x28(%r14), %rdx
movq %rdx, 0x30(%rax)
leaq 0xf6(%rip), %rdx # 0x7f584
movq %rdx, (%rax)
movq %rax, (%rbx)
movq %rcx, 0x8(%rdi)
callq 0x7f676
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5cc8d
nop
|
/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 range = sub_map_.equal_range(key + token);
if (range.first != range.second) {
for (auto it = range.first; it != range.second; ++it) {
auto conn = it->second.lock();
if (conn == nullptr || conn->has_closed()) {
continue;
}
conn->publish(key + token, *shared_data);
}
} else {
error_callback(
asio::error::make_error_code(asio::error::invalid_argument),
"The subscriber of the key: " + key + " does not exist.");
}
}
|
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, %rdi
callq 0x63c88
testq %r13, %r13
je 0x7fb6b
leaq 0x48(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x4f2e0
movl $0x30, %edi
callq 0x4f6f0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x38a34(%rip), %rcx # 0xb8358
movq %rcx, (%rax)
leaq 0x10(%rax), %r13
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
leaq 0x58(%rsp), %rsi
movq -0x10(%rsi), %rdx
cmpq %rsi, %rdx
je 0x7f952
movq %rdx, (%r13)
movq 0x58(%rsp), %rdx
movq %rdx, (%rcx)
jmp 0x7f958
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x50(%rsp), %rcx
movq %rax, 0x28(%rsp)
movq %rcx, 0x18(%rax)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
xorl %eax, %eax
movb %al, 0x58(%rsp)
leaq 0x38(%rsp), %rdi
movq %r15, (%rdi)
movb %al, 0x8(%rdi)
callq 0x63c9e
movb $0x1, 0x40(%rsp)
movq %rsp, %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x7eb63
leaq 0x230(%r12), %rdi
movq %rsp, %rsi
callq 0x7ed06
movq %rax, %rbp
movq %rdx, %rbx
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x7f9ca
callq 0x4f6a0
cmpq %rbx, %rbp
je 0x7fa75
movq %rsp, %r14
movq 0x30(%rbp), %r12
testq %r12, %r12
je 0x7f9f9
movl 0x8(%r12), %eax
testl %eax, %eax
je 0x7f9f6
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%r12)
jne 0x7f9e4
jmp 0x7f9f9
xorl %r12d, %r12d
testq %r12, %r12
je 0x7fa0a
movl 0x8(%r12), %eax
testl %eax, %eax
sete %al
jmp 0x7fa0c
movb $0x1, %al
testb %al, %al
jne 0x7fa56
movq 0x28(%rbp), %r15
testq %r15, %r15
je 0x7fa56
cmpb $0x0, 0x148(%r15)
jne 0x7fa56
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x7eb63
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x7ebb8
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7fa56
callq 0x4f6a0
testq %r12, %r12
je 0x7fa63
movq %r12, %rdi
callq 0x5cc1e
movq (%rbp), %rbp
cmpq %rbx, %rbp
jne 0x7f9d6
jmp 0x7fb57
movb 0x39fbd(%rip), %al # 0xb9a38
testb %al, %al
je 0x7fb7d
leaq 0x16017(%rip), %rsi # 0x95aa1
leaq 0x68(%rsp), %rdi
movq 0x20(%rsp), %rdx
callq 0x7ec84
leaq 0x1601d(%rip), %rsi # 0x95abd
leaq 0x68(%rsp), %rdi
callq 0x4fcc0
movq %r14, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7facb
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x7fad2
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
cmpq $0x0, 0x1e0(%r12)
je 0x7fb36
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
leaq 0x1d0(%r12), %rdi
leaq 0x98(%rsp), %rsi
movl $0x16, (%rsi)
leaq 0x39b8d(%rip), %rdx # 0xb96a8
movq %rdx, 0x8(%rsi)
leaq 0x88(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
callq *0x1e8(%r12)
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x7fb44
callq 0x4f6a0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fb57
callq 0x4f6a0
leaq 0x38(%rsp), %rdi
callq 0x63c88
movq 0x28(%rsp), %rdi
callq 0x5cc1e
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x50cf4
jmp 0x7fa83
movq %r14, %rcx
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rcx, %rdi
je 0x7fba0
callq 0x4f6a0
jmp 0x7fba0
movq %rax, %r14
leaq 0x78(%rsp), %rax
jmp 0x7fbb1
jmp 0x7fbc1
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fc10
callq 0x4f6a0
jmp 0x7fc10
movq %rax, %r14
jmp 0x7fc10
movq %rax, %r14
jmp 0x7fc1a
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fc24
callq 0x4f6a0
jmp 0x7fc24
movq %rax, %r14
jmp 0x7fc24
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7fc03
callq 0x4f6a0
jmp 0x7fc03
movq %rax, %r14
testq %r12, %r12
je 0x7fc10
movq %r12, %rdi
callq 0x5cc1e
leaq 0x38(%rsp), %rdi
callq 0x63c88
movq 0x28(%rsp), %rdi
callq 0x5cc1e
movq %r14, %rdi
callq 0x4fba0
|
/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 register_nonmember_func<is_pub>(key, std::move(f));
}
}
|
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 %r10d, %r10d
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x8240a
movq (%rax), %r9
movq %rax, %r10
cmpl 0x8(%r9), %ecx
je 0x8240a
movq %rdx, %rsi
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x82407
movl 0x8(%r9), %edi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rsi, %rdx
jne 0x8240a
movq %r11, %r10
cmpl %edi, %ecx
jne 0x823dc
jmp 0x8240a
xorl %r10d, %r10d
testq %r10, %r10
je 0x82415
cmpq $0x0, (%r10)
jne 0x8245b
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %r15, %rdx
callq 0x759b2
movl (%r12), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x10(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
callq 0x75d72
movq %rax, %rdi
movq %r15, %rsi
callq 0x824a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x4f370
movq %rax, %rbx
leaq 0x1342c(%rip), %rsi # 0x9589b
movq %rax, %rdi
callq 0x4fca0
movq 0x36b3a(%rip), %rsi # 0xb8fb8
movq 0x36af3(%rip), %rdx # 0xb8f78
movq %rbx, %rdi
callq 0x4fb40
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f520
movq %r14, %rdi
callq 0x4fba0
|
/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 = back;
return forward + 1;
}
}
#endif // DOCTEST_CONFIG_DISABLE
return file;
}
|
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
movq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
if(std::uncaught_exceptions() > 0
#else
if(std::uncaught_exception()
#endif
&& g_cs->shouldLogCurrentException) {
DOCTEST_ITERATE_THROUGH_REPORTERS(
test_case_exception, {"exception thrown in subcase - will translate later "
"when the whole test case has been exited (cannot "
"translate while there is an active exception)",
false});
g_cs->shouldLogCurrentException = false;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
}
}
|
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 # 0xb9a68
movq 0x1118(%rcx), %rdx
leaq -0x28(%rdx), %rax
movq %rax, 0x1118(%rcx)
cmpb $0x0, -0x11(%rdx)
jns 0x8543e
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8543e
callq 0x4f880
callq 0x4f080
testb %al, %al
je 0x854e7
movq 0x34616(%rip), %rax # 0xb9a68
movb 0x115d(%rax), %al
testb $0x1, %al
je 0x854e7
movq 0x34601(%rip), %rax # 0xb9a68
movq 0x10d0(%rax), %r13
movq 0x10d8(%rax), %rbp
cmpq %rbp, %r13
je 0x854d8
leaq 0x8(%rsp), %r14
leaq 0x1300f(%rip), %r15 # 0x98495
movq (%r13), %r12
movq %r14, %rdi
movl $0x91, %esi
callq 0x83712
movl $0x91, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f5d0
movb $0x0, 0x20(%rsp)
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x30(%rax)
cmpb $0x0, 0x1f(%rsp)
jns 0x854cf
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x854cf
callq 0x4f880
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x85486
movq 0x34589(%rip), %rax # 0xb9a68
xorl %ecx, %ecx
xchgb %cl, 0x115d(%rax)
movq 0x3457a(%rip), %rax # 0xb9a68
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x85510
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r14
jmp 0x854fc
cmpb $0x0, 0x17(%rbx)
jns 0x85523
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x85523
callq 0x4f880
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x85536
jmp 0x85536
movq %rax, %rdi
callq 0x5cc8d
|
/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
retq
movq %rax, %r14
cmpb $0x0, 0x7f(%rbx)
jns 0x856f9
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x856f9
callq 0x4f880
cmpb $0x0, 0x17(%rbx)
jns 0x8570c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8570c
callq 0x4f880
movq %r14, %rdi
callq 0x4fba0
|
/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, -0x8(%r13)
movb $0x0, (%r13)
movq %rsp, %r15
leaq 0x12b63(%rip), %r12 # 0x98539
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4f6d0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4fc30
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x85a37
movl $0xb, %edx
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x4f8f0
testl %eax, %eax
jne 0x859d6
movl %ebp, %r14d
cmpq $0xc, 0x8(%rsp)
jb 0x85a3a
movq (%rsp), %rax
cmpb $0x30, 0xb(%rax)
setne %bpl
jmp 0x85a3c
movl %ebp, %r14d
xorl %ebp, %ebp
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x85a4a
callq 0x4f6a0
leaq 0x20(%rsp), %rdi
callq 0x4f1a0
movl %r14d, (%rbx)
movl %ebp, %eax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x85a8b
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x85a81
callq 0x4f6a0
leaq 0x20(%rsp), %rdi
callq 0x4f1a0
movl %ebp, (%rbx)
movq %r14, %rdi
callq 0x4fba0
|
/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
<< (opt.gnu_file_line ? ":" : "):") << tail;
}
|
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, %rsi
movq %rax, %rdx
callq 0x4f7b0
jmp 0x90cd4
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x4fb10
movq 0x60(%r14), %rax
leaq 0x83c6(%rip), %r12 # 0x990a5
leaq 0x83bc(%rip), %rsi # 0x990a2
cmpb $0x0, 0x7b(%rax)
cmovneq %r12, %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x4f7b0
movq 0x60(%r14), %rax
xorl %ecx, %ecx
cmpb $0x0, 0x7d(%rax)
cmovnel %ecx, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x4fb50
movq %rax, %r15
movq 0x60(%r14), %rax
movzbl 0x7b(%rax), %eax
leaq 0x8380(%rip), %rsi # 0x990a4
testq %rax, %rax
cmovneq %r12, %rsi
movl $0x2, %edx
subq %rax, %rdx
movq %r15, %rdi
callq 0x4f7b0
testq %rbx, %rbx
je 0x90d5e
movq %rbx, %rdi
callq 0x4f310
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f7b0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4fb10
|
/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_easy_init() failed\n");
curl_global_cleanup();
return TEST_ERR_MAJOR_BAD;
}
reset_data(&data, curl);
test_setopt(curl, CURLOPT_URL, URL);
test_setopt(curl, CURLOPT_POST, 1L);
test_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE,
(curl_off_t)data.remaining_bytes);
test_setopt(curl, CURLOPT_VERBOSE, 1L);
test_setopt(curl, CURLOPT_READFUNCTION, read_callback);
test_setopt(curl, CURLOPT_READDATA, &data);
test_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
test_setopt(curl, CURLOPT_WRITEDATA, &data);
res = perform_and_check_connections(curl,
"First request without CURLOPT_KEEP_SENDING_ON_ERROR", 1);
if(res != TEST_ERR_SUCCESS) {
goto test_cleanup;
}
reset_data(&data, curl);
res = perform_and_check_connections(curl,
"Second request without CURLOPT_KEEP_SENDING_ON_ERROR", 1);
if(res != TEST_ERR_SUCCESS) {
goto test_cleanup;
}
test_setopt(curl, CURLOPT_KEEP_SENDING_ON_ERROR, 1L);
reset_data(&data, curl);
res = perform_and_check_connections(curl,
"First request with CURLOPT_KEEP_SENDING_ON_ERROR", 1);
if(res != TEST_ERR_SUCCESS) {
goto test_cleanup;
}
reset_data(&data, curl);
res = perform_and_check_connections(curl,
"Second request with CURLOPT_KEEP_SENDING_ON_ERROR", 0);
if(res != TEST_ERR_SUCCESS) {
goto test_cleanup;
}
res = TEST_ERR_SUCCESS;
test_cleanup:
curl_easy_cleanup(curl);
curl_global_cleanup();
return (int)res;
}
|
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 0x24b7
callq 0x2060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x22b7
movq 0x2d4b(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0xd80(%rip), %rsi # 0x301f
movb $0x0, %al
callq 0x20e0
callq 0x2120
movl $0x7e, -0x4(%rbp)
jmp 0x24b7
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x24c0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2712, %esi # imm = 0x2712
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x22e5
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x2f, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x2307
jmp 0x24a3
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x75a8, %esi # imm = 0x75A8
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x2328
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x29, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x234a
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x4e2c, %esi # imm = 0x4E2C
leaq 0x1a6(%rip), %rdx # 0x2500
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x236e
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x2719, %esi # imm = 0x2719
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x238f
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x4e2b, %esi # imm = 0x4E2B
leaq 0x211(%rip), %rdx # 0x25b0
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x23b3
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0x2711, %esi # imm = 0x2711
leaq -0x28(%rbp), %rdx
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x23d4
jmp 0x24a3
movq -0x30(%rbp), %rdi
leaq 0xc59(%rip), %rsi # 0x3038
movl $0x1, %edx
callq 0x2620
movl %eax, -0x34(%rbp)
cmpl $0x78, -0x34(%rbp)
je 0x23f7
jmp 0x24a3
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x24c0
movq -0x30(%rbp), %rdi
leaq 0xc5d(%rip), %rsi # 0x306c
movl $0x1, %edx
callq 0x2620
movl %eax, -0x34(%rbp)
cmpl $0x78, -0x34(%rbp)
je 0x2424
jmp 0x24a3
movq -0x30(%rbp), %rdi
movl $0xf5, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x20f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x2443
jmp 0x24a3
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x24c0
movq -0x30(%rbp), %rdi
leaq 0xc46(%rip), %rsi # 0x30a1
movl $0x1, %edx
callq 0x2620
movl %eax, -0x34(%rbp)
cmpl $0x78, -0x34(%rbp)
je 0x2470
jmp 0x24a3
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x24c0
movq -0x30(%rbp), %rdi
leaq 0xc4a(%rip), %rsi # 0x30d2
xorl %eax, %eax
movl %eax, %edx
callq 0x2620
movl %eax, -0x34(%rbp)
cmpl $0x78, -0x34(%rbp)
je 0x249c
jmp 0x24a3
movl $0x78, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20d0
callq 0x2120
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
|
/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_send = data->remaining_bytes;
if(bytes_to_send > totalsize) {
bytes_to_send = totalsize;
}
memset(ptr, 'a', bytes_to_send);
data->remaining_bytes -= bytes_to_send;
return bytes_to_send;
}
else {
data->paused = 1;
return CURL_READFUNC_PAUSE;
}
}
|
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(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jbe 0x2555
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl $0x61, %esi
callq 0x2080
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2597
movq -0x30(%rbp), %rax
movl $0x1, 0xc(%rax)
movq $0x10000001, -0x8(%rbp) # imm = 0x10000001
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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_MAJOR_BAD;
}
res = curl_easy_getinfo(curl, CURLINFO_NUM_CONNECTS, &connections);
if(res != CURLE_OK) {
fprintf(stderr, "curl_easy_getinfo() failed\n");
return TEST_ERR_MAJOR_BAD;
}
fprintf(stderr, "%s: expected: %ld connections; actual: %ld connections\n",
description, expected_connections, connections);
if(connections != expected_connections) {
return TEST_ERR_FAILURE;
}
return TEST_ERR_SUCCESS;
}
|
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 # 0x3104
movb $0x0, %al
callq 0x20e0
movl $0x7e, -0x4(%rbp)
jmp 0x26eb
movq -0x10(%rbp), %rdi
movl $0x20001a, %esi # imm = 0x20001A
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x2050
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x26ad
movq 0x294d(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0xa83(%rip), %rsi # 0x3120
movb $0x0, %al
callq 0x20e0
movl $0x7e, -0x4(%rbp)
jmp 0x26eb
movq 0x292c(%rip), %rax # 0x4fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xa72(%rip), %rsi # 0x313c
movb $0x0, %al
callq 0x20e0
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x26e4
movl $0x77, -0x4(%rbp)
jmp 0x26eb
movl $0x78, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
/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. IOW Winsock
* select() can not be used to sleep without a single fd_set.
*/
if(!nfds) {
Sleep((1000*tv->tv_sec) + (DWORD)(((double)tv->tv_usec)/1000.0));
return 0;
}
#endif
return select(nfds, rd, wr, exc, tv);
}
|
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), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x20c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/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), %rdi
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0x4, %esi
leaq 0x957(%rip), %rdx # 0x3174
movb $0x0, %al
callq 0x2070
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
jmp 0x27f7
leaq 0x288b(%rip), %rax # 0x50d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
}
|
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 $0x0, %al
callq 0x20e0
movl $0x1, -0x4(%rbp)
jmp 0x2928
movl -0x8(%rbp), %eax
movl %eax, 0x2a73(%rip) # 0x532c
movq -0x10(%rbp), %rax
movq %rax, 0x2a6c(%rip) # 0x5330
cmpl $0x2, -0x8(%rbp)
jle 0x28d9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x27e7(%rip) # 0x50c0
cmpl $0x3, -0x8(%rbp)
jle 0x28ee
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x27da(%rip) # 0x50c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x26df(%rip), %rax # 0x4fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x888(%rip), %rsi # 0x3197
movb $0x0, %al
callq 0x20e0
movq -0x18(%rbp), %rdi
callq 0x2230
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/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 __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
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_COMPILER
# pragma warning(pop)
#endif
}
|
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 warning(pop)
#endif
}
|
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 & (long) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
}
|
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(pop)
#endif
}
|
movq %rdi, %rax
btrq $0x3f, %rax
retq
|
/nomaster[P]curl/lib/warnless.c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.