name string | code string | asm string | file string |
|---|---|---|---|
rhash_sha1_process_block | static void rhash_sha1_process_block(unsigned* hash, const unsigned* block)
{
int t; /* Loop counter */
uint32_t temp; /* Temporary word value */
uint32_t W[80]; /* Word sequence */
uint32_t A, B, C, D, E; /* Word buffers */
/* initialize the f... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x274f83
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
bswapl %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x160(%rbp,%rax,4)
movl... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha1.c |
rhash_sha256_init | void rhash_sha256_init(sha256_ctx* ctx)
{
/* Initial values. These words were obtained by taking the first 32
* bits of the fractional parts of the square roots of the first
* eight prime numbers. */
static const unsigned SHA256_H0[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c,... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x20, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x5d1c6(%rip), %rcx # 0x2d26a0
movq %rcx, 0x48(%rax)
movq 0x5d1c3(%rip), %rcx # 0x2d26a8
movq %rcx, 0x50(%rax)
movq 0x5d1c0(%rip), %rcx # 0x2d2... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha256_update | void rhash_sha256_update(sha256_ctx* ctx, const unsigned char* msg, size_t size)
{
size_t index = (size_t)ctx->length & 63;
ctx->length += size;
/* fill partial block */
if (index) {
size_t left = sha256_block_size - index;
memcpy((char*)ctx->message + index, msg, (size < left ? size : left));
if (size < lef... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x275638
... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha256_process_block | static void rhash_sha256_process_block(unsigned hash[8], unsigned block[16])
{
unsigned A, B, C, D, E, F, G, H;
unsigned W[16];
const unsigned* k;
int i;
A = hash[0], B = hash[1], C = hash[2], D = hash[3];
E = hash[4], F = hash[5], G = hash[6], H = hash[7];
/* Compute SHA using alternate Method: FIPS 180-3 6.1... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha256.c |
rhash_sha384_init | void rhash_sha384_init(struct sha512_ctx* ctx)
{
/* Initial values from FIPS 180-3. These words were obtained by taking
* the first sixty-four bits of the fractional parts of the square
* roots of ninth through sixteenth prime numbers. */
static const uint64_t SHA384_H0[8] = {
I64(0xcbbb9d5dc1059ed8), I64(0x629... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rbp), %rax
movl $0x30, 0xc8(%rax)
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
leaq 0x59fb5(%rip), %rsi # 0x2d2930
movl $0x40, %edx
callq 0x101e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha512.c |
rhash_sha512_update | void rhash_sha512_update(sha512_ctx* ctx, const unsigned char* msg, size_t size)
{
size_t index = (size_t)ctx->length & 127;
ctx->length += size;
/* fill partial block */
if (index) {
size_t left = sha512_block_size - index;
memcpy((char*)ctx->message + index, msg, (size < left ? size : left));
if (size < le... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
andq $0x7f, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x80(%rax), %rcx
movq %rcx, 0x80(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x278a64
... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha512.c |
rhash_sha512_process_block | static void rhash_sha512_process_block(uint64_t hash[8], uint64_t block[16])
{
uint64_t A, B, C, D, E, F, G, H;
uint64_t W[16];
const uint64_t* k;
int i;
A = hash[0], B = hash[1], C = hash[2], D = hash[3];
E = hash[4], F = hash[5], G = hash[6], H = hash[7];
/* Compute SHA using alternate Method: FIPS 180-3 6.1... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/sha512.c |
rhash_swap_copy_str_to_u32 | void rhash_swap_copy_str_to_u32(void* to, int index, const void* from, size_t length)
{
/* if all pointers and length are 32-bits aligned */
if ( 0 == (( (int)((char*)to - (char*)0) | ((char*)from - (char*)0) | index | length ) & 3) ) {
/* copy memory as 32-bit words */
const uint32_t* src = (const uint32_t*)from... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
subq $0x0, %rax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
subq $0x0, %rax
orq %rax, %rcx
movslq -0xc(%rbp), %rax
orq %rax, %rcx
orq -0x20(%rbp), %rcx
andq $0x3, %rcx
xorl %eax, %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibrhash/librhash/byte_order.c |
uv_fs_lchown | int uv_fs_lchown(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_uid_t uid,
uv_gid_t gid,
uv_fs_cb cb) {
INIT(LCHOWN);
PATH;
req->uid = uid;
req->gid = gid;
POST;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27c5f2
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x27c74a
jmp 0x27c5f4
movq -0x18(%rbp), %rax
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv_fs_sendfile | int uv_fs_sendfile(uv_loop_t* loop,
uv_fs_t* req,
uv_file out_fd,
uv_file in_fd,
int64_t off,
size_t len,
uv_fs_cb cb) {
INIT(SENDFILE);
req->flags = in_fd; /* hack */
req->file = out_fd;
req->off =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27e5b5
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x27e6c0
jmp 0x27e5b7
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv_fs_utime | int uv_fs_utime(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
double atime,
double mtime,
uv_fs_cb cb) {
INIT(UTIME);
PATH;
req->atime = atime;
req->mtime = mtime;
POST;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27ebe5
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x27ed48
jmp 0x27ebe7
movq -0x18(%rbp), %rax
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv_fs_write | int uv_fs_write(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
const uv_buf_t bufs[],
unsigned int nbufs,
int64_t off,
uv_fs_cb cb) {
INIT(WRITE);
if (bufs == NULL || nbufs == 0)
return UV_EINVAL;
req->file = file;... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x27ed96
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x27ef1d
jmp 0x27ed98
movq -0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv_fs_req_cleanup | void uv_fs_req_cleanup(uv_fs_t* req) {
if (req == NULL)
return;
/* Only necessary for asychronous requests, i.e., requests with a callback.
* Synchronous ones don't copy their arguments and have req->path and
* req->new_path pointing to user-owned memory. UV_FS_MKDTEMP and
* UV_FS_MKSTEMP are the exc... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x27ef48
jmp 0x27f048
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x27ef7f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x27ef72
movq -0x8(%rbp), %rax
cmpl $0x14, 0x40(%rax)
je 0x27ef72
movq -0x8(%rbp), %rax
cmpl $0x23, 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_copyfile | static ssize_t uv__fs_copyfile(uv_fs_t* req) {
uv_fs_t fs_req;
uv_file srcfd;
uv_file dstfd;
struct stat src_statsbuf;
struct stat dst_statsbuf;
int dst_flags;
int result;
int err;
off_t bytes_to_send;
off_t in_offset;
off_t bytes_written;
size_t bytes_chunk;
dstfd = -1;
err = 0;
/* Open... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdi, -0x10(%rbp)
movl $0xffffffff, -0x1d0(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2fc(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdx
xorl %eax, %eax
movl %eax, %r9d
leaq -0x1c8(%rbp), %rsi
xorl %r8d, %r8d
movq %r9, %rdi
movl %r8d, %ecx
callq... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_lutime | static ssize_t uv__fs_lutime(uv_fs_t* req) {
#if defined(__linux__) || \
defined(_AIX71) || \
defined(__sun) || \
defined(__HAIKU__) ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x140(%rax), %xmm0
callq 0x280c60
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x148(%rax), %xmm0
callq 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_mkstemp | static int uv__fs_mkstemp(uv_fs_t* req) {
static uv_once_t once = UV_ONCE_INIT;
int r;
#ifdef O_CLOEXEC
static int no_cloexec_support;
#endif
static const char pattern[] = "XXXXXX";
static const size_t pattern_size = sizeof(pattern) - 1;
char* path;
size_t path_length;
path = (char*) req->path;
path_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x109c0
movq %rax, -0x28(%rbp)
cmpq $0x6, -0x28(%rbp)
jb 0x27fbc9
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
addq $-0x6, %rdi
leaq 0x530c1(%rip), %rsi ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_read | static ssize_t uv__fs_read(uv_fs_t* req) {
#if defined(__linux__)
static int no_preadv;
#endif
unsigned int iovmax;
ssize_t result;
iovmax = uv__getiovmax();
if (req->nbufs > iovmax)
req->nbufs = iovmax;
if (req->off < 0) {
if (req->nbufs == 1)
result = read(req->file, req->bufs[0].base, req... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x28bda0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x124(%rax), %eax
cmpl -0xc(%rbp), %eax
jbe 0x27fd60
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x124(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jge 0x27fdda
movq -0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_realpath | static ssize_t uv__fs_realpath(uv_fs_t* req) {
char* buf;
#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L
buf = realpath(req->path, NULL);
if (buf == NULL)
return -1;
#else
ssize_t len;
len = uv__fs_pathmax_size(req->path);
buf = uv__malloc(len + 1);
if (buf == NULL) {
errno = ENOMEM;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10ee0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x280312
movq $-0x1, -0x8(%rbp)
jmp 0x280326
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_stat | static int uv__fs_stat(const char *path, uv_stat_t *buf) {
struct stat pbuf;
int ret;
ret = uv__fs_statx(-1, path, /* is_fstat */ 0, /* is_lstat */ 0, buf);
if (ret != UV_ENOSYS)
return ret;
ret = stat(path, &pbuf);
if (ret == 0)
uv__to_stat(&pbuf, buf);
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x280870
movl %eax, -0xac(%rbp)
cmpl $-0x26, -0xac(%rbp)
je 0x2804b3
movl -0xac(%rbp), %eax
movl %e... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__fs_statfs | static int uv__fs_statfs(uv_fs_t* req) {
uv_statfs_t* stat_fs;
#if defined(__sun) || \
defined(__MVS__) || \
defined(__NetBSD__) || \
defined(__HAIKU__) || \
defined(__QNX__)
struct statvfs buf;
if (0 != statvfs(req->path, &buf))
#else
struct statfs buf;
if (0 != statfs(req->path, &... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
leaq -0x90(%rbp), %rsi
callq 0x10ba0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x280537
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2805cc
movl $0x58, %edi
callq 0x2866c0
movq %rax, -0x18(%... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/fs.c |
uv__custom_sem_init | static int uv__custom_sem_init(uv_sem_t* sem_, unsigned int value) {
int err;
uv_semaphore_t* sem;
sem = uv__malloc(sizeof(*sem));
if (sem == NULL)
return UV_ENOMEM;
if ((err = uv_mutex_init(&sem->mutex)) != 0) {
uv__free(sem);
return err;
}
if ((err = uv_cond_init(&sem->cond)) != 0) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x60, %edi
callq 0x2866c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x281e6d
movl $0xfffffff4, -0x4(%rbp) # imm = 0xFFFFFFF4
jmp 0x281eda
movq -0x20(%rbp), %rdi
callq 0x281a10
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
j... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv__custom_sem_trywait | static int uv__custom_sem_trywait(uv_sem_t* sem_) {
uv_semaphore_t* sem;
sem = *(uv_semaphore_t**)sem_;
if (uv_mutex_trylock(&sem->mutex) != 0)
return UV_EAGAIN;
if (sem->value == 0) {
uv_mutex_unlock(&sem->mutex);
return UV_EAGAIN;
}
sem->value--;
uv_mutex_unlock(&sem->mutex);
return 0;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x281b10
cmpl $0x0, %eax
je 0x2821ee
movl $0xfffffff5, -0x4(%rbp) # imm = 0xFFFFFFF5
jmp 0x282227
movq -0x18(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x28220a
movq... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv__sem_trywait | static int uv__sem_trywait(uv_sem_t* sem) {
int r;
do
r = sem_trywait(sem);
while (r == -1 && errno == EINTR);
if (r) {
if (errno == EAGAIN)
return UV_EAGAIN;
abort();
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c30
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x15(%rbp)
jne 0x282261
callq 0x11940
cmpl $0x4, (%rax)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x28223c
cmpl... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_cond_init | int uv_cond_init(uv_cond_t* cond) {
pthread_condattr_t attr;
int err;
err = pthread_condattr_init(&attr);
if (err)
return UV__ERR(err);
#if !defined(__hpux)
err = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
if (err)
goto error2;
#endif
err = pthread_cond_init(cond, &attr);
if (err)
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x11520
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2822c8
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x282330
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x11780
movl %eax, -0x18(%rbp)
cmpl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv_cond_destroy | void uv_cond_destroy(uv_cond_t* cond) {
#if defined(__APPLE__) && defined(__MACH__)
/* It has been reported that destroying condition variables that have been
* signalled but not waited on can sometimes result in application crashes.
* See https://codereview.chromium.org/1323293005.
*/
pthread_mutex_t mute... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10760
cmpl $0x0, %eax
je 0x28235f
callq 0x11290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/thread.c |
uv__io_fork | int uv__io_fork(uv_loop_t* loop) {
int err;
void* old_watchers;
old_watchers = loop->inotify_watchers;
uv__close(loop->backend_fd);
loop->backend_fd = -1;
uv__platform_loop_delete(loop);
err = uv__platform_loop_init(loop);
if (err)
return err;
return uv__inotify_fork(loop, old_watchers);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x340(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %edi
callq 0x28c4a0
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0x2825f0
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
read_times | static int read_times(FILE* statfile_fp,
unsigned int numcpus,
uv_cpu_info_t* ci) {
struct uv_cpu_times_s ts;
unsigned int ticks;
unsigned int multiplier;
uint64_t user;
uint64_t nice;
uint64_t sys;
uint64_t idle;
uint64_t dummy;
uint64_t irq;
uint64_t num... | pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2, %edi
callq 0x10e30
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
je 0x282ebb
jmp 0x282eda
leaq 0x5047f(%rip), %rdi # 0x2d3341
leaq 0x50493(%rip), %rsi # 0x2d335c
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_get_free_memory | uint64_t uv_get_free_memory(void) {
struct sysinfo info;
uint64_t rc;
rc = uv__read_proc_meminfo("MemAvailable:");
if (rc != 0)
return rc;
if (0 == sysinfo(&info))
return (uint64_t) info.freeram * info.mem_unit;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x4fcfe(%rip), %rdi # 0x2d32b0
callq 0x283610
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x2835cc
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2835f6
leaq -0x78(%rbp), %rdi
callq 0x11b60
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2835ee
movq -0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv_loadavg | void uv_loadavg(double avg[3]) {
struct sysinfo info;
char buf[128]; /* Large enough to hold all of /proc/loadavg. */
if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf)))
if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2]))
return;
if (sysinfo(&info) < 0)
return;
avg[0] = (doubl... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
leaq -0x100(%rbp), %rsi
leaq 0x4fae1(%rip), %rdi # 0x2d32de
movl $0x80, %edx
callq 0x28d330
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x28384a
leaq -0x100(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rcx
add... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-core.c |
uv__inotify_fork | int uv__inotify_fork(uv_loop_t* loop, void* old_watchers) {
/* Open the inotify_fd, and re-arm all the inotify watchers. */
int err;
struct watcher_list* tmp_watcher_list_iter;
struct watcher_list* watcher_list;
struct watcher_list tmp_watcher_list;
QUEUE queue;
QUEUE* q;
uv_fs_event_t* handle;
char* ... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x283de3
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x340(%rax)
leaq -0x78(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
leaq -0x78(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv_fs_event_start | int uv_fs_event_start(uv_fs_event_t* handle,
uv_fs_event_cb cb,
const char* path,
unsigned int flags) {
struct watcher_list* w;
size_t len;
int events;
int err;
int wd;
if (uv__is_active(handle))
return UV_EINVAL;
err = init_inotify(h... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2840e2
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2842c3
movq -0x10(%rbp), %rax
movq 0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
uv__inotify_read | static void uv__inotify_read(uv_loop_t* loop,
uv__io_t* dummy,
unsigned int events) {
const struct inotify_event* e;
struct watcher_list* w;
uv_fs_event_t* h;
QUEUE queue;
QUEUE* q;
const char* path;
ssize_t size;
const char *p;
/* needs to be ... | pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp # imm = 0x1080
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
jmp 0x284ed8
movq -0x8(%rbp), %rax
movl 0x348(%rax), %edi
leaq -0x1060(%rbp), %rsi
movl $0x1000, %edx # imm = 0x1000
callq 0x11310
movq %rax, -0x58(%rbp)
xorl %eax, %eax
c... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/linux-inotify.c |
post | static void post(QUEUE* q, enum uv__work_kind kind) {
uv_mutex_lock(&mutex);
if (kind == UV__WORK_SLOW_IO) {
/* Insert into a separate queue. */
QUEUE_INSERT_TAIL(&slow_io_pending_wq, q);
if (!QUEUE_EMPTY(&run_slow_work_message)) {
/* Running slow I/O tasks is already scheduled => Nothing to do he... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xa5d3a(%rip), %rdi # 0x32b760
callq 0x281ae0
cmpl $0x2, -0xc(%rbp)
jne 0x285a93
jmp 0x285a33
movq -0x8(%rbp), %rax
leaq 0xa5d82(%rip), %rcx # 0x32b7c0
movq %rcx, (%rax)
movq 0xa5d80(%rip), %rcx # 0x32b7c8
movq -0x8... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
uv__work_done | void uv__work_done(uv_async_t* handle) {
struct uv__work* w;
uv_loop_t* loop;
QUEUE* q;
QUEUE wq;
int err;
loop = container_of(handle, uv_loop_t, wq_async);
uv_mutex_lock(&loop->wq_mutex);
QUEUE_MOVE(&loop->wq, &wq);
uv_mutex_unlock(&loop->wq_mutex);
while (!QUEUE_EMPTY(&wq)) {
q = QUEUE_HEAD(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0xb0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x281ae0
movq -0x18(%rbp), %rax
addq $0x78, %rax
movq -0x18(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jne 0x285bf0
jmp 0x285bde
leaq -0x30(%rbp), %rax
mo... | /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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $-0x58, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
cmpl $0x0, 0x20(%rax)
jbe 0x285e0b
jmp 0x285e2a
leaq 0x4d3fe(%rip), %rdi # 0x2d3210
leaq 0x4d7da(%rip), %rsi # 0x2d3... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/threadpool.c |
uv__free | void uv__free(void* ptr) {
int saved_errno;
/* Libuv expects that free() does not clobber errno. The system allocator
* honors that assumption but custom allocators may not be so careful.
*/
saved_errno = errno;
uv__allocator.local_free(ptr);
errno = saved_errno;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x11940
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq 0xa3283(%rip), %rax # 0x329a30
movq -0x8(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x11940
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__reallocf | void* uv__reallocf(void* ptr, size_t size) {
void* newptr;
newptr = uv__realloc(ptr, size);
if (newptr == NULL)
if (size > 0)
uv__free(ptr);
return newptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x286800
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x28688a
cmpq $0x0, -0x10(%rbp)
jbe 0x286888
movq -0x8(%rbp), %rdi
callq 0x286790
jmp 0x28688a
movq -0x18(%rbp), %rax
add... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_replace_allocator | int uv_replace_allocator(uv_malloc_func malloc_func,
uv_realloc_func realloc_func,
uv_calloc_func calloc_func,
uv_free_func free_func) {
if (malloc_func == NULL || realloc_func == NULL ||
calloc_func == NULL || free_func == NULL) {
r... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2868d0
cmpq $0x0, -0x18(%rbp)
je 0x2868d0
cmpq $0x0, -0x20(%rbp)
je 0x2868d0
cmpq $0x0, -0x28(%rbp)
jne 0x2868d9
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28690c... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_err_name | const char* uv_err_name(int err) {
switch (err) {
UV_ERRNO_MAP(UV_ERR_NAME_GEN)
}
return uv__unknown_err_code(err);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xfffff001, %eax # imm = 0xFFFFF001
je 0x2880fd
jmp 0x2877de
movl -0x10(%rbp), %eax
subl $0xfffff002, %eax # imm = 0xFFFFF002
je 0x2880ed
jmp 0x2877ee
movl -0x10(%rbp), %eax
subl $0xfffff010,... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_strerror_r | char* uv_strerror_r(int err, char* buf, size_t buflen) {
switch (err) {
UV_ERRNO_MAP(UV_STRERROR_GEN_R)
default: snprintf(buf, buflen, "Unknown system error %d", err);
}
return buf;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0xfffff001, %eax # imm = 0xFFFFF001
je 0x289057
jmp 0x288216
movl -0x1c(%rbp), %eax
subl $0xfffff002, %eax # imm = 0xFFFFF002
je 0x289035
jmp 0x2... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_ip_name | int uv_ip_name(const struct sockaddr *src, char *dst, size_t size) {
switch (src->sa_family) {
case AF_INET:
return uv_inet_ntop(AF_INET, &((struct sockaddr_in *)src)->sin_addr,
dst, size);
case AF_INET6:
return uv_inet_ntop(AF_INET6, &((struct sockaddr_in6 *)src)->sin6_addr,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x289d5f
jmp 0x289d55
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x289d7e
jmp 0x289d9d
movq -0x10(%rbp), %rsi
addq $0x4, %r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_tcp_bind | int uv_tcp_bind(uv_tcp_t* handle,
const struct sockaddr* addr,
unsigned int flags) {
unsigned int addrlen;
if (handle->type != UV_TCP)
return UV_EINVAL;
if (uv__is_closing(handle)) {
return UV_EINVAL;
}
if (addr->sa_family == AF_INET)
addrlen = sizeof(struct sockad... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xc, 0x10(%rax)
je 0x289dd6
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x289e39
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x289dee
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_udp_init_ex | int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned flags) {
unsigned extra_flags;
int domain;
int rc;
/* Use the lower 8 bits for the domain. */
domain = flags & 0xFF;
if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
return UV_EINVAL;
/* Use the higher bits for extra f... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
je 0x289e89
cmpl $0xa, -0x24(%rbp)
je 0x289e89
cmpl $0x0, -0x24(%rbp)
je 0x289e89
movl $0xffffffea, -0x4(%rbp) # imm = 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_tcp_connect | int uv_tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr* addr,
uv_connect_cb cb) {
unsigned int addrlen;
if (handle->type != UV_TCP)
return UV_EINVAL;
if (addr->sa_family == AF_INET)
addrlen = sizeof(struct sockaddr_in);
el... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, 0x10(%rax)
je 0x289fdb
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28a02b
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x2, %eax
jne 0x2... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__udp_is_connected | int uv__udp_is_connected(uv_udp_t* handle) {
struct sockaddr_storage addr;
int addrlen;
if (handle->type != UV_UDP)
return 0;
addrlen = sizeof(addr);
if (uv_udp_getpeername(handle, (struct sockaddr*) &addr, &addrlen) != 0)
return 0;
return addrlen > 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0xf, 0x10(%rax)
je 0x28a122
movl $0x0, -0x4(%rbp)
jmp 0x28a163
movl $0x80, -0x94(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x94(%rbp), %rdx
callq 0x29a240
cmpl $0x0, %eax
je 0x28a151
movl $0x0, -0x4(%rbp)
jmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_walk | void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
QUEUE queue;
QUEUE* q;
uv_handle_t* h;
QUEUE_MOVE(&loop->handle_queue, &queue);
while (!QUEUE_EMPTY(&queue)) {
q = QUEUE_HEAD(&queue);
h = QUEUE_DATA(q, uv_handle_t, handle_queue);
QUEUE_REMOVE(q);
QUEUE_INSERT_TAIL(&loop->handle... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x28a3ea
jmp 0x28a3d8
leaq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__print_handles | static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) {
const char* type;
QUEUE* q;
uv_handle_t* h;
if (loop == NULL)
loop = uv_default_loop();
QUEUE_FOREACH(q, &loop->handle_queue) {
h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (only_active && !uv__is_active(h))
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x28a563
callq 0x28adc0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x10, %rcx
cmpq %rc... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__count_bufs | size_t uv__count_bufs(const uv_buf_t bufs[], unsigned int nbufs) {
unsigned int i;
size_t bytes;
bytes = 0;
for (i = 0; i < nbufs; i++)
bytes += (size_t) bufs[i].len;
return bytes;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x28a907
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_fs_event_getpath | int uv_fs_event_getpath(uv_fs_event_t* handle, char* buffer, size_t* size) {
size_t required_len;
if (!uv__is_active(handle)) {
*size = 0;
return UV_EINVAL;
}
required_len = strlen(handle->path);
if (required_len >= *size) {
*size = required_len + 1;
return UV_ENOBUFS;
}
memcpy(buffer, ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x28a9a7
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28aa10
movq -0x10(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_fs_scandir_next | int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent) {
uv__dirent_t** dents;
uv__dirent_t* dent;
unsigned int* nbufs;
/* Check to see if req passed */
if (req->result < 0)
return req->result;
/* Ptr will be null if req was canceled or no files found */
if (!req->ptr)
return UV_EOF;
nbufs = ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jge 0x28ab0b
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x28abf7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x28ab22
movl $0xfffff001, -0x4(%rbp) # imm... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_loop_configure | int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...) {
va_list ap;
int err;
va_start(ap, option);
/* Any platform-agnostic options should be handled here. */
err = uv__loop_configure(loop, option, ap);
va_end(ap);
return err;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x28ad5b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_loop_new | uv_loop_t* uv_loop_new(void) {
uv_loop_t* loop;
loop = uv__malloc(sizeof(*loop));
if (loop == NULL)
return NULL;
if (uv_loop_init(loop)) {
uv__free(loop);
return NULL;
}
return loop;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x350, %edi # imm = 0x350
callq 0x2866c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28ae47
movq $0x0, -0x8(%rbp)
jmp 0x28ae70
movq -0x10(%rbp), %rdi
callq 0x28f180
cmpl $0x0, %eax
je 0x28ae68
movq -0x10(%rbp), %rdi
callq 0x286790
movq $0x0, -0x8(%rbp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv_loop_delete | void uv_loop_delete(uv_loop_t* loop) {
uv_loop_t* default_loop;
int err;
default_loop = default_loop_ptr;
err = uv_loop_close(loop);
(void) err; /* Squelch compiler warnings. */
assert(err == 0);
if (loop != default_loop)
uv__free(loop);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa0895(%rip), %rax # 0x32b7f8
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28ae80
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x28af7b
jmp 0x28af9a
leaq 0x4925c(%rip), %rdi # 0x2d41de
leaq 0x491b9(%rip), %rsi # 0x2d4142
mo... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__metrics_update_idle_time | void uv__metrics_update_idle_time(uv_loop_t* loop) {
uv__loop_metrics_t* loop_metrics;
uint64_t entry_time;
uint64_t exit_time;
if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
return;
loop_metrics = uv__get_loop_metrics(loop);
/* The thread running uv__metrics_update_idle_time() i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x28b150
jmp 0x28b1b9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x28b1... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__metrics_set_provider_entry_time | void uv__metrics_set_provider_entry_time(uv_loop_t* loop) {
uv__loop_metrics_t* loop_metrics;
uint64_t now;
if (!(uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME))
return;
now = uv_hrtime();
loop_metrics = uv__get_loop_metrics(loop);
uv_mutex_lock(&loop_metrics->lock);
loop_metrics->prov... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x28b1e0
jmp 0x28b21e
callq 0x28baa0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/uv-common.c |
uv__async_start | static int uv__async_start(uv_loop_t* loop) {
int pipefd[2];
int err;
if (loop->async_io_watcher.fd != -1)
return 0;
#ifdef __linux__
err = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
if (err < 0)
return UV__ERR(errno);
pipefd[0] = err;
pipefd[1] = -1;
#else
err = uv__make_pipe(pipefd, UV_NONBLOC... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x1f8(%rax)
je 0x28b422
movl $0x0, -0x4(%rbp)
jmp 0x28b49c
xorl %edi, %edi
movl $0x80800, %esi # imm = 0x80800
callq 0x11d90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x28b448
callq 0x11940
movq %rax, ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv__async_stop | void uv__async_stop(uv_loop_t* loop) {
if (loop->async_io_watcher.fd == -1)
return;
if (loop->async_wfd != -1) {
if (loop->async_wfd != loop->async_io_watcher.fd)
uv__close(loop->async_wfd);
loop->async_wfd = -1;
}
uv__io_stop(loop, &loop->async_io_watcher, POLLIN);
uv__close(loop->async_i... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x1f8(%rax)
jne 0x28b77b
jmp 0x28b7f1
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x200(%rax)
je 0x28b7bb
movq -0x8(%rbp), %rax
movl 0x200(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1f8(%rcx), %eax
je 0x28b7ad
movq -0x8(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
cpu_relax | UV_UNUSED(static void cpu_relax(void)) {
#if defined(__i386__) || defined(__x86_64__)
__asm__ __volatile__ ("rep; nop" ::: "memory"); /* a.k.a. PAUSE */
#elif (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__)
__asm__ __volatile__ ("yield" ::: "memory");
#elif (defined(__ppc__) || defined(__ppc64__)) &&... | pushq %rbp
movq %rsp, %rbp
pause
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/atomic-ops.h |
uv__async_io | static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
char buf[1024];
ssize_t r;
QUEUE queue;
QUEUE* q;
uv_async_t* h;
assert(w == &loop->async_io_watcher);
for (;;) {
r = read(w->fd, buf, sizeof(buf));
if (r == sizeof(buf))
continue;
if (r != -1)
break;... | pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x1c8, %rcx # imm = 0x1C8
cmpq %rcx, %rax
jne 0x28b83c
jmp 0x28b85b
leaq 0x48a33(%rip), %rdi # 0x2d4276
leaq 0x48a49... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/async.c |
uv_close | void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
assert(!uv__is_closing(handle));
handle->flags |= UV_HANDLE_CLOSING;
handle->close_cb = close_cb;
switch (handle->type) {
case UV_NAMED_PIPE:
uv__pipe_close((uv_pipe_t*)handle);
break;
case UV_TTY:
uv__stream_close((uv_stream_t*)handl... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x28bad1
jmp 0x28baf0
leaq 0x4890c(%rip), %rdi # 0x2d43e4
leaq 0x4891d(%rip), %rsi # 0x2d43fc
movl $0x7a, %edx
leaq 0x4897c(%rip), %rcx # 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__getiovmax | int uv__getiovmax(void) {
#if defined(IOV_MAX)
return IOV_MAX;
#elif defined(_SC_IOV_MAX)
static int iovmax_cached = -1;
int iovmax;
iovmax = uv__load_relaxed(&iovmax_cached);
if (iovmax != -1)
return iovmax;
/* On some embedded devices (arm-linux-uclibc based ip camera),
* sysconf(_SC_IOV_MAX) can... | pushq %rbp
movq %rsp, %rbp
movl $0x400, %eax # imm = 0x400
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__nonblock_ioctl | int uv__nonblock_ioctl(int fd, int set) {
int r;
do
r = ioctl(fd, FIONBIO, &set);
while (r == -1 && errno == EINTR);
if (r)
return UV__ERR(errno);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x5421, %esi # imm = 0x5421
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x10340
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x28c3ed
callq 0x11940
cmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__accept | int uv__accept(int sockfd) {
int peerfd;
int err;
(void) &err;
assert(sockfd >= 0);
do
#ifdef uv__accept4
peerfd = uv__accept4(sockfd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
#else
peerfd = accept(sockfd, NULL, NULL);
#endif
while (peerfd == -1 && errno == EINTR);
if (peerfd == -1)
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x28c5a3
jmp 0x28c5c2
leaq 0x47f58(%rip), %rdi # 0x2d4502
leaq 0x47e4b(%rip), %rsi # 0x2d43fc
movl $0x20e, %edx # imm = 0x20E
leaq 0x47f51(%rip), %rcx # 0x2d450e
callq 0x103e0
jmp 0x28c5c4
movl -0x8(%rbp), ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__close_nocancel | int uv__close_nocancel(int fd) {
#if defined(__APPLE__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdollar-in-identifier-extension"
#if defined(__LP64__) || TARGET_OS_IPHONE
extern int close$NOCANCEL(int);
return close$NOCANCEL(fd);
#else
extern int close$NOCANCEL$UNIX2003(int);
return close$N... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
movl $0x3, %edi
movb $0x0, %al
callq 0x10540
addq $0x10, %rsp
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__close_nocheckstdio | int uv__close_nocheckstdio(int fd) {
int saved_errno;
int rc;
assert(fd > -1); /* Catch uninitialized io_watcher.fd bugs. */
saved_errno = errno;
rc = uv__close_nocancel(fd);
if (rc == -1) {
rc = UV__ERR(errno);
if (rc == UV_EINTR || rc == UV__ERR(EINPROGRESS))
rc = 0; /* The close is in... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jle 0x28c663
jmp 0x28c682
leaq 0x47eb8(%rip), %rdi # 0x2d4522
leaq 0x47d8b(%rip), %rsi # 0x2d43fc
movl $0x250, %edx # imm = 0x250
leaq 0x47ead(%rip), %rcx # 0x2d452a
callq 0x103e0
callq 0x11940
movl (%rax), %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__recvmsg | ssize_t uv__recvmsg(int fd, struct msghdr* msg, int flags) {
#if defined(__ANDROID__) || \
defined(__DragonFly__) || \
defined(__FreeBSD__) || \
defined(__NetBSD__) || \
defined(__OpenBSD__) || \
defined(__linux__)
ssize_t rc;
rc = recvmsg(fd, msg, flags | MSG_CMSG_CLOEXEC);
if (rc ==... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
orl $0x40000000, %edx # imm = 0x40000000
callq 0x103f0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x28c836
callq 0x11940
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_cwd | int uv_cwd(char* buffer, size_t* size) {
char scratch[1 + UV__PATH_MAX];
if (buffer == NULL || size == NULL)
return UV_EINVAL;
/* Try to read directly into the user's buffer first... */
if (getcwd(buffer, *size) != NULL)
goto fixup;
if (errno != ERANGE)
return UV__ERR(errno);
/* ...or into s... | pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp # imm = 0x1020
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x28c871
cmpq $0x0, -0x18(%rbp)
jne 0x28c87d
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28c969
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_fileno | int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) {
int fd_out;
switch (handle->type) {
case UV_TCP:
case UV_NAMED_PIPE:
case UV_TTY:
fd_out = uv__stream_fd((uv_stream_t*) handle);
break;
case UV_UDP:
fd_out = ((uv_udp_t *) handle)->io_watcher.fd;
break;
case UV_POLL:
fd_out ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $-0x7, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x8, %eax
ja 0x28ca62
movq -0x28(%rbp), %rax
leaq 0x47954(%rip), %rcx # 0x2d4380
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__io_start | void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
assert(0 != events);
assert(w->fd >= 0);
assert(w->fd < INT_MAX);
w->pevents |= events;
maybe_resize(loop, w->fd + 1);
#if !defined(__sun)
/* The event ports ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
andl $0xffffdff8, %ecx # imm = 0xFFFFDFF8
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x28cba4
jmp 0x28cbc3
leaq 0x479fb(%rip), %rdi # 0x2d45a6
leaq 0x4784a(%rip), %rsi # 0x2d43fc... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
maybe_resize | static void maybe_resize(uv_loop_t* loop, unsigned int len) {
uv__io_t** watchers;
void* fake_watcher_list;
void* fake_watcher_count;
unsigned int nwatchers;
unsigned int i;
if (len <= loop->nwatchers)
return;
/* Preserve fake watcher list and count at the end of the watchers */
if (loop->watchers... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x70(%rcx), %eax
ja 0x28cd40
jmp 0x28ce31
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x28cd80
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x70(%rcx), %e... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__io_stop | void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
assert(0 == (events & ~(POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI)));
assert(0 != events);
if (w->fd == -1)
return;
assert(w->fd >= 0);
/* Happens when uv__io_stop() is called on a handle that was never started. */
if ((unsign... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
andl $0xffffdff8, %ecx # imm = 0xFFFFDFF8
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x28ce64
jmp 0x28ce83
leaq 0x4773b(%rip), %rdi # 0x2d45a6
leaq 0x4758a(%rip), %rsi # 0x2d43fc... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__dup2_cloexec | int uv__dup2_cloexec(int oldfd, int newfd) {
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__linux__)
int r;
r = dup3(oldfd, newfd, O_CLOEXEC);
if (r == -1)
return UV__ERR(errno);
return r;
#else
int err;
int r;
r = dup2(oldfd, newfd); /* Never retry. */
if (r == -1)
return UV__... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl $0x80000, %edx # imm = 0x80000
callq 0x114d0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x28d448
callq 0x11940
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_homedir | int uv_os_homedir(char* buffer, size_t* size) {
uv_passwd_t pwd;
size_t len;
int r;
/* Check if the HOME environment variable is set first. The task of
performing input validation on buffer and size is taken care of by
uv_os_getenv(). */
r = uv_os_getenv("HOME", buffer, size);
if (r != UV_ENOENT... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x231f5(%rip), %rdi # 0x2b0674
callq 0x28d530
movl %eax, -0x4c(%rbp)
cmpl $-0x2, -0x4c(%rbp)
je 0x28d498
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x28d51d
leaq -0x40(%... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv__getpwuid_r | int uv__getpwuid_r(uv_passwd_t* pwd) {
struct passwd pw;
struct passwd* result;
char* buf;
uid_t uid;
size_t bufsize;
size_t name_size;
size_t homedir_size;
size_t shell_size;
int r;
if (pwd == NULL)
return UV_EINVAL;
uid = geteuid();
/* Calling sysconf(_SC_GETPW_R_SIZE_MAX) would get the... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28d612
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28d7b4
callq 0x10690
movl %eax, -0x54(%rbp)
movq $0x7d0, -0x60(%rbp) # imm = 0x7D0
movq -0x60(%rbp), %rdi
callq 0x2866c0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x5... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_free_passwd | void uv_os_free_passwd(uv_passwd_t* pwd) {
if (pwd == NULL)
return;
/*
The memory for name, shell, and homedir are allocated in a single
uv__malloc() call. The base of the pointer is stored in pwd->username, so
that is the field that needs to be freed.
*/
uv__free(pwd->username);
pwd->usernam... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x28d7d5
jmp 0x28d804
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x286790
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_environ | int uv_os_environ(uv_env_item_t** envitems, int* count) {
int i, j, cnt;
uv_env_item_t* envitem;
*envitems = NULL;
*count = 0;
for (i = 0; environ[i] != NULL; i++);
*envitems = uv__calloc(i, sizeof(**envitems));
if (*envitems == NULL)
return UV_ENOMEM;
for (j = 0, cnt = 0; j < i; j++) {
cha... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
movq 0x995fd(%rip), %rax # 0x326fe0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x28d9fe
jmp 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_os_getpriority | int uv_os_getpriority(uv_pid_t pid, int* priority) {
int r;
if (priority == NULL)
return UV_EINVAL;
errno = 0;
r = getpriority(PRIO_PROCESS, (int) pid);
if (r == -1 && errno != 0)
return UV__ERR(errno);
*priority = r;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28dd5f
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x28dda8
callq 0x11940
movl $0x0, (%rax)
movl -0x8(%rbp), %esi
xorl %edi, %edi
callq 0x10b80
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/core.c |
uv_pipe_connect | void uv_pipe_connect(uv_connect_t* req,
uv_pipe_t* handle,
const char* name,
uv_connect_cb cb) {
struct sockaddr_un saddr;
int new_sock;
int err;
int r;
new_sock = (uv__stream_fd(handle) == -1);
if (new_sock) {
err = uv__socket(AF_UNIX, SOCK_... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xb8(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
je 0x28fecf
movl $0x1, %esi
xorl %edx, %edx
movl %es... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/pipe.c |
uv_signal_init | int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) {
int err;
err = uv__signal_loop_once_init(loop);
if (err)
return err;
uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
handle->signum = 0;
handle->caught_signals = 0;
handle->dispatched_signals = 0;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x292090
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29239d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29243e
jmp 0x29239f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__signal_register_handler | static int uv__signal_register_handler(int signum, int oneshot) {
/* When this function is called, the signal lock must be held. */
struct sigaction sa;
/* XXX use a separate signal stack? */
memset(&sa, 0, sizeof(sa));
if (sigfillset(&sa.sa_mask))
abort();
sa.sa_handler = uv__signal_handler;
sa.sa_f... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x10810
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x10fb0
cmpl $0x0, %eax
je 0x292abe
callq 0x11290
leaq 0x38b(%rip), %rax # 0x292e50
movq %rax, -0xa8(%rbp)
movl... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__signal_compare | static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
int f1;
int f2;
/* Compare signums first so all watchers with the same signnum end up
* adjacent.
*/
if (w1->signum < w2->signum) return -1;
if (w1->signum > w2->signum) return 1;
/* Handlers without UV_SIGNAL_ONE_SHOT set will come fi... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x68(%rcx), %eax
jge 0x292d88
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x292e47
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x68(%rcx)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__signal_handler | static void uv__signal_handler(int signum) {
uv__signal_msg_t msg;
uv_signal_t* handle;
int saved_errno;
saved_errno = errno;
memset(&msg, 0, sizeof msg);
if (uv__signal_lock()) {
errno = saved_errno;
return;
}
for (handle = uv__signal_first_handle(signum);
handle != NULL && handle->si... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
callq 0x11940
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10810
callq 0x292c70
cmpl $0x0, %eax
je 0x292e94
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x11940
movl -0x2c(%rbp), %ecx
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__signal_unregister_handler | static void uv__signal_unregister_handler(int signum) {
/* When this function is called, the signal lock must be held. */
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
/* sigaction can only fail with EINVAL or EFAULT; an attempt to deregister a
* signal implies that it was suc... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x10810
movq $0x0, -0xa0(%rbp)
movl -0x4(%rbp), %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11400
cmpl $0x0, %eax
je 0x293889
callq 0x11290
addq $0xa0, %rsp
popq %rbp
r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/signal.c |
uv__stream_init | void uv__stream_init(uv_loop_t* loop,
uv_stream_t* stream,
uv_handle_type type) {
int err;
uv__handle_init(loop, (uv_handle_t*)stream, type);
stream->read_cb = NULL;
stream->alloc_cb = NULL;
stream->close_cb = NULL;
stream->connection_cb = NULL;
stream->connect_r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x58(%rax)
movq -0x8(%rbp), %rcx
addq $0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__stream_io | static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
uv_stream_t* stream;
stream = container_of(w, uv_stream_t, io_watcher);
assert(stream->type == UV_TCP ||
stream->type == UV_NAMED_PIPE ||
stream->type == UV_TTY);
assert(!(stream->flags & UV_HANDLE_CLOSING));
i... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $-0x88, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, 0x10(%rax)
je 0x2942bf
movq -0x20(%rbp), %rax
cmpl $0x7, 0x10(%rax)
je 0x2942bf
movq -0x20(%rbp), %rax
cmpl $0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__stream_open | int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
#if defined(__APPLE__)
int enable;
#endif
if (!(stream->io_watcher.fd == -1 || stream->io_watcher.fd == fd))
return UV_EBUSY;
assert(fd >= 0);
stream->flags |= flags;
if (stream->type == UV_TCP) {
if ((stream->flags & UV_HANDLE_TCP_NODEL... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xb8(%rax)
je 0x29446a
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x29446a
movl $0xfffffff0, -0x4(%rbp) # imm = 0xFFFFFFF0
jmp 0x29452b
cmpl $0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__write_callbacks | static void uv__write_callbacks(uv_stream_t* stream) {
uv_write_t* req;
QUEUE* q;
QUEUE pq;
if (QUEUE_EMPTY(&stream->write_completed_queue))
return;
QUEUE_MOVE(&stream->write_completed_queue, &pq);
while (!QUEUE_EMPTY(&pq)) {
/* Pop a req off write_completed_queue. */
q = QUEUE_HEAD(&pq);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rax
movq -0x8(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
jne 0x294778
jmp 0x294921
jmp 0x29477a
movq -0x8(%rbp), %rax
addq $0xd0, %rax
movq -0x8(%rbp), %rcx
cmpq 0xd0(%rcx), %rax
jne 0x2947a5
jmp 0x294793
leaq -0x30(%rbp), %rax
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__drain | static void uv__drain(uv_stream_t* stream) {
uv_shutdown_t* req;
int err;
assert(QUEUE_EMPTY(&stream->write_queue));
if (!(stream->flags & UV_HANDLE_CLOSING)) {
uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
uv__stream_osx_interrupt_select(stream);
}
if (!(stream->flags & UV_HANDLE_SHUTT... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rax
movq -0x8(%rbp), %rcx
cmpq 0xc0(%rcx), %rax
jne 0x294955
jmp 0x294974
leaq 0x409e4(%rip), %rdi # 0x2d5340
leaq 0x4056a(%rip), %rsi # 0x2d4ecd
movl $0x296, %edx # imm = 0x296
leaq 0x409f3(%rip), %r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv_accept | int uv_accept(uv_stream_t* server, uv_stream_t* client) {
int err;
assert(server->loop == client->loop);
if (server->accepted_fd == -1)
return UV_EAGAIN;
switch (client->type) {
case UV_NAMED_PIPE:
case UV_TCP:
err = uv__stream_open(client,
server->accepted_fd,
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x294df4
jmp 0x294e13
leaq 0x402b3(%rip), %rdi # 0x2d50ae
leaq 0x400cb(%rip), %rsi # 0x2d4ecd
movl $0x23b, %edx # imm =... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv_try_write2 | int uv_try_write2(uv_stream_t* stream,
const uv_buf_t bufs[],
unsigned int nbufs,
uv_stream_t* send_handle) {
int err;
/* Connecting or already writing some data */
if (stream->connect_req != NULL || stream->write_queue_size != 0)
return UV_EAGAIN;
err... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x2957dd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x2957e6
movl $0xfffffff5, -0x4(%rbp) # imm = 0xFFFFFFF5
jmp 0x29581e
movq -0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__try_write | static int uv__try_write(uv_stream_t* stream,
const uv_buf_t bufs[],
unsigned int nbufs,
uv_stream_t* send_handle) {
struct iovec* iov;
int iovmax;
int iovcnt;
ssize_t n;
/*
* Cast to iovec. We had to have our own uv_buf_t instead ... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
callq 0x28bda0
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x29... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__stream_eof | static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) {
stream->flags |= UV_HANDLE_READ_EOF;
stream->flags &= ~UV_HANDLE_READING;
uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
uv__handle_stop(stream);
uv__stream_osx_interrupt_select(stream);
stream->read_cb(stream, UV_EOF, buf);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
orl $0x800, %ecx # imm = 0x800
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
andl $0xffffefff, %ecx # imm = 0xFFFFEFFF
movl %ecx, 0x58(%rax)
movq -0x8... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv__write_req_update | static int uv__write_req_update(uv_stream_t* stream,
uv_write_t* req,
size_t n) {
uv_buf_t* buf;
size_t len;
assert(n <= stream->write_queue_size);
stream->write_queue_size -= n;
buf = req->bufs + req->write_index;
do {
len = n < buf->le... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x60(%rcx), %rax
ja 0x2969f4
jmp 0x296a13
leaq 0x3eccb(%rip), %rdi # 0x2d56c6
leaq 0x3e4cb(%rip), %rsi # 0x2d4ecd
movl $0x2d7, %edx # imm =... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/stream.c |
uv_tcp_init_ex | int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) {
int domain;
/* Use the lower 8 bits for the domain */
domain = flags & 0xFF;
if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
return UV_EINVAL;
if (flags & ~0xFF)
return UV_EINVAL;
uv__stream_init(loop, (u... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
cmpl $0x2, -0x20(%rbp)
je 0x296c9c
cmpl $0xa, -0x20(%rbp)
je 0x296c9c
cmpl $0x0, -0x20(%rbp)
je 0x296c9c
movl $0xffffffea, -0x4(%rbp) # imm = 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
maybe_new_socket | static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) {
struct sockaddr_storage saddr;
socklen_t slen;
if (domain == AF_UNSPEC) {
handle->flags |= flags;
return 0;
}
if (uv__stream_fd(handle) != -1) {
if (flags & UV_HANDLE_BOUND) {
if (handle->flags & UV_HANDLE_B... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x296d69
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
orq %rdx, %rcx
movl %ecx, 0x58(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x296ed6
movq -0x10(%rbp), %rax
cmpl $-0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv__tcp_connect | int uv__tcp_connect(uv_connect_t* req,
uv_tcp_t* handle,
const struct sockaddr* addr,
unsigned int addrlen,
uv_connect_cb cb) {
int err;
int r;
assert(handle->type == UV_TCP);
if (handle->connect_req != NULL)
return UV_EALREAD... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xc, 0x10(%rax)
jne 0x297117
jmp 0x297136
leaq 0x3e67a(%rip), %rdi # 0x2d5798
leaq 0x3e68a(%rip), %rsi # 0x2d57af
movl $0xd5,... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_tcp_open | int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
int err;
if (uv__fd_exists(handle->loop, sock))
return UV_EEXIST;
err = uv__nonblock(sock, 1);
if (err)
return err;
return uv__stream_open((uv_stream_t*)handle,
sock,
UV_HANDLE_READABLE | UV_HAN... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x28d1b0
cmpl $0x0, %eax
je 0x29730d
movl $0xffffffef, -0x4(%rbp) # imm = 0xFFFFFFEF
jmp 0x29733f
movl -0x14(%rbp), %edi
movl $0x1, %esi
callq 0x28c3b0
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_tcp_close_reset | int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) {
int fd;
struct linger l = { 1, 0 };
/* Disallow setting SO_LINGER to zero due to some platform inconsistencies */
if (handle->flags & UV_HANDLE_SHUTTING)
return UV_EINVAL;
fd = uv__stream_fd(handle);
if (0 != setsockopt(fd, SOL_SOCKET, S... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x3e46d(%rip), %rax # 0x2d5894
movq %rax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x100, %eax # imm = 0x100
cmpl $0x0, %eax
je 0x297445
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv__tcp_listen | int uv__tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
static int single_accept_cached = -1;
unsigned long flags;
int single_accept;
int err;
if (tcp->delayed_error)
return tcp->delayed_error;
single_accept = uv__load_relaxed(&single_accept_cached);
if (single_accept == -1) {
cons... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe8(%rax)
je 0x2974f2
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x297603
movl 0x92548(%rip), %eax # 0x329a40
movl %eax, -0x2c(%rbp)
cmpl $-... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_tcp_nodelay | int uv_tcp_nodelay(uv_tcp_t* handle, int on) {
int err;
if (uv__stream_fd(handle) != -1) {
err = uv__tcp_nodelay(uv__stream_fd(handle), on);
if (err)
return err;
}
if (on)
handle->flags |= UV_HANDLE_TCP_NODELAY;
else
handle->flags &= ~UV_HANDLE_TCP_NODELAY;
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xb8(%rax)
je 0x2977b1
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %edi
movl -0x14(%rbp), %esi
callq 0x297610
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2977af
movl -0x18(%rbp), %eax
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.