name string | code string | asm string | file string |
|---|---|---|---|
uv_tcp_keepalive | int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
int err;
if (uv__stream_fd(handle) != -1) {
err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);
if (err)
return err;
}
if (on)
handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
else
handle->flags &= ~UV_HANDLE_TCP_KEEPA... | pushq %rbp
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 0x297837
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %edi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x297660
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rb... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tcp.c |
uv_guess_handle | uv_handle_type uv_guess_handle(uv_file file) {
struct sockaddr_storage ss;
struct stat s;
socklen_t len;
int type;
if (file < 0)
return UV_UNKNOWN_HANDLE;
if (isatty(file))
return UV_TTY;
if (fstat(file, &s)) {
#if defined(__PASE__)
/* On ibmi receiving RST from TCP instead of FIN immediate... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x297dc0
movl $0x0, -0x4(%rbp)
jmp 0x297f5c
movl -0x8(%rbp), %edi
callq 0x11720
cmpl $0x0, %eax
je 0x297dd9
movl $0xe, -0x4(%rbp)
jmp 0x297f5c
movl -0x8(%rbp), %edi
leaq -0x118(%rbp), %rsi
callq 0x11660... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv_tty_set_mode | int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) {
struct termios tmp;
int fd;
int rc;
if (tty->mode == (int) mode)
return 0;
fd = uv__stream_fd(tty);
if (tty->mode == UV_TTY_MODE_NORMAL && mode != UV_TTY_MODE_NORMAL) {
do
rc = tcgetattr(fd, &tty->orig_termios);
while (rc == -1 && ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x134(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x297fda
movl $0x0, -0x4(%rbp)
jmp 0x298154
movq -0x10(%rbp), %rax
movl 0xb8(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x134(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv__tty_make_raw | static void uv__tty_make_raw(struct termios* tio) {
assert(tio != NULL);
#if defined __sun || defined __MVS__ || defined __hpux
/*
* This implementation of cfmakeraw for Solaris and derivatives is taken from
* http://www.perkin.org.uk/posts/solaris-portability-cfmakeraw.html.
*/
tio->c_iflag &= ~(IMAXBE... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2981c5
jmp 0x2981e4
leaq 0x3d6d0(%rip), %rdi # 0x2d589c
leaq 0x3d6d5(%rip), %rsi # 0x2d58a8
movl $0xf4, %edx
leaq 0x3d733(%rip), %rcx # 0x2d5912
callq 0x103e0
movq -0x8(%rbp), %rdi
callq 0x106b0
addq $0x10, %rsp
pop... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv_tty_reset_mode | int uv_tty_reset_mode(void) {
int saved_errno;
int err;
saved_errno = errno;
if (!uv_spinlock_trylock(&termios_spinlock))
return UV_EBUSY; /* In uv_tty_set_mode(). */
err = 0;
if (orig_termios_fd != -1)
err = uv__tcsetattr(orig_termios_fd, TCSANOW, &orig_termios);
uv_spinlock_unlock(&termios_s... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11940
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x938bf(%rip), %rdi # 0x32bb68
callq 0x298310
cmpl $0x0, %eax
jne 0x2982bc
movl $0xfffffff0, -0x4(%rbp) # imm = 0xFFFFFFF0
jmp 0x298305
movl $0x0, -0xc(%rbp)
cmpl $-0x1, 0x9177a(%rip) # 0x329a44
je 0x2982e3
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/tty.c |
uv__udp_finish_close | void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;
assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
assert(handle->io_watcher.fd == -1);
while (!QUEUE_EMPTY(&handle->write_queue)) {
q = QUEUE_HEAD(&handle->write_queue);
QUEUE_REMOVE(q);
req = QUEUE_DATA(q,... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
movl $0x5, %esi
callq 0x28d120
cmpl $0x0, %eax
jne 0x298468
jmp 0x298487
leaq 0x3ce76(%rip), %rdi # 0x2d52e5
leaq 0x3d4c4(%rip), %rsi # 0x2d593a
movl $0x67, %edx
leaq 0x3d522(%rip), %rcx # 0x2d59a4
callq... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_run_completed | static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;
assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
handle->flags |= UV_HANDLE_UDP_PROCESSING;
while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
q = QUEUE_HEAD(&handle->write_completed_queue);
QUEUE_REMOVE(q);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x1000000, %eax # imm = 0x1000000
cmpl $0x0, %eax
jne 0x29861f
jmp 0x29863e
leaq 0x3d5ad(%rip), %rdi # 0x2d5bd3
leaq 0x3d30d(%rip), %rsi # 0x2d593a
movl $0x83, %edx
leaq 0x3d5c6(%rip), %rcx... | /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;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %eax
andl $-0x26, %eax
cmpl $0x0, %eax
je 0x2988ad
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x298a39
movl -0x20(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__set_reuse | static int uv__set_reuse(int fd) {
int yes;
yes = 1;
#if defined(SO_REUSEPORT) && defined(__MVS__)
struct sockaddr_in sockfd;
unsigned int sockfd_len = sizeof(sockfd);
if (getsockname(fd, (struct sockaddr*) &sockfd, &sockfd_len) == -1)
return UV__ERR(errno);
if (sockfd.sin_family == AF_UNIX) {
if... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x10360
cmpl $0x0, %eax
je 0x298b44
callq 0x11940
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x298b4b... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_connect | int uv__udp_connect(uv_udp_t* handle,
const struct sockaddr* addr,
unsigned int addrlen) {
int err;
err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);
if (err)
return err;
do {
errno = 0;
err = connect(handle->io_watcher.fd, addr, addrlen);
} w... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
xorl %edx, %edx
callq 0x298c20
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x298b96
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_maybe_deferred_bind | static int uv__udp_maybe_deferred_bind(uv_udp_t* handle,
int domain,
unsigned int flags) {
union uv__sockaddr taddr;
socklen_t addrlen;
if (handle->io_watcher.fd != -1)
return 0;
switch (domain) {
case AF_INET:
{
struct ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xb0(%rax)
je 0x298c4b
movl $0x0, -0x4(%rbp)
jmp 0x298d10
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x2, %eax
je 0x298c62
jmp 0x298c58
movl -0x4c(%rbp), %eax
subl... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_disconnect | int uv__udp_disconnect(uv_udp_t* handle) {
int r;
#if defined(__MVS__)
struct sockaddr_storage addr;
#else
struct sockaddr addr;
#endif
memset(&addr, 0, sizeof(addr));
#if defined(__MVS__)
addr.ss_family = AF_UNSPEC;
#else
addr.sa_family = AF_UNSPEC;
#endif
do {
errno = 0;
#ifdef __... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10810
movw $0x0, -0x24(%rbp)
callq 0x11940
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0xb0(%rax), %edi
leaq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x10, %e... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_send | int uv__udp_send(uv_udp_send_t* req,
uv_udp_t* handle,
const uv_buf_t bufs[],
unsigned int nbufs,
const struct sockaddr* addr,
unsigned int addrlen,
uv_udp_send_cb send_cb) {
int err;
int empty_queue;
assert(nbu... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0x298dfb
jmp 0x298e1a
leaq 0x3a3bb(%rip), %rdi # 0x2d31bd
leaq 0x3cb31(%rip), %rsi ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_try_send | int uv__udp_try_send(uv_udp_t* handle,
const uv_buf_t bufs[],
unsigned int nbufs,
const struct sockaddr* addr,
unsigned int addrlen) {
int err;
struct msghdr h;
ssize_t size;
assert(nbufs > 0);
/* already sending a message *... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x2993e6
jmp 0x299405
leaq 0x39dd0(%rip), %rdi # 0x2d31bd
leaq 0x3c546(%rip), %rsi # 0x2d593a
movl $0x327, %edx # i... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_io | static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents) {
uv_udp_t* handle;
handle = container_of(w, uv_udp_t, io_watcher);
assert(handle->type == UV_UDP);
if (revents & POLLIN)
uv__udp_recvmsg(handle);
if (revents & POLLOUT) {
uv__udp_sendmsg(handle);
uv__udp_run_completed(h... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $-0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xf, 0x10(%rax)
jne 0x2996db
jmp 0x2996fa
leaq 0x3c5f4(%rip), %rdi # 0x2d5cd6
leaq 0x3c251(%rip), %rsi # 0x... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_mmsg_init | static void uv__udp_mmsg_init(void) {
int ret;
int s;
s = uv__socket(AF_INET, SOCK_DGRAM, 0);
if (s < 0)
return;
ret = uv__sendmmsg(s, NULL, 0);
if (ret == 0 || errno != ENOSYS) {
uv__sendmmsg_avail = 1;
uv__recvmmsg_avail = 1;
} else {
ret = uv__recvmmsg(s, NULL, 0);
if (ret == 0 || e... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x28c2e0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x2997b1
jmp 0x29981d
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x285760
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x2997d2
ca... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_open | int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
int err;
/* Check for already active socket. */
if (handle->io_watcher.fd != -1)
return UV_EBUSY;
if (uv__fd_exists(handle->loop, sock))
return UV_EEXIST;
err = uv__nonblock(sock, 1);
if (err)
return err;
err = uv__set_reuse(sock);
i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xb0(%rax)
je 0x299858
movl $0xfffffff0, -0x4(%rbp) # imm = 0xFFFFFFF0
jmp 0x2998df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x28d1b0
cmpl $0x0, %eax
je 0x299876
m... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_membership | int uv_udp_set_membership(uv_udp_t* handle,
const char* multicast_addr,
const char* interface_addr,
uv_membership membership) {
int err;
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
if (uv_ip4_addr(multicast_addr, 0, &addr4) ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
leaq -0x38(%rbp), %rdx
callq 0x289b70
cmpl $0x0, %eax
jne 0x299958
movq -0x10(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x298c20
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_set_membership4 | static int uv__udp_set_membership4(uv_udp_t* handle,
const struct sockaddr_in* multicast_addr,
const char* interface_addr,
uv_membership membership) {
struct ip_mreq mreq;
int optname;
int err;
memset(&mreq... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10810
cmpq $0x0, -0x20(%rbp)
je 0x299a1a
movq -0x20(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
ca... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_set_membership6 | static int uv__udp_set_membership6(uv_udp_t* handle,
const struct sockaddr_in6* multicast_addr,
const char* interface_addr,
uv_membership membership) {
int optname;
struct ipv6_mreq mreq;
struct sockaddr_in6 a... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x10810
cmpq $0x0, -0x20(%rbp)
je 0x299b06
movq -0x20(%rbp), %rdi
xorl %esi, %esi
leaq -0x5c(%rbp), %rdx
callq 0x289bd0
cm... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_set_source_membership6 | static int uv__udp_set_source_membership6(uv_udp_t* handle,
const struct sockaddr_in6* multicast_addr,
const char* interface_addr,
const struct sockaddr_in6* source_addr,
... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movl $0xa, %esi
movl $0x4, %edx
callq 0x298c20
movl %eax, -0x15c(%rbp)
cmpl $0x0, -0x15c(%rbp)
je 0x299ccf
movl ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_broadcast | int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
if (setsockopt(handle->io_watcher.fd,
SOL_SOCKET,
SO_BROADCAST,
&on,
sizeof(on))) {
return UV__ERR(errno);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0xb0(%rax), %edi
movl $0x1, %esi
movl $0x6, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x10360
cmpl $0x0, %eax
je 0x299f78
callq 0x11940
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %ea... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_ttl | int uv_udp_set_ttl(uv_udp_t* handle, int ttl) {
if (ttl < 1 || ttl > 255)
return UV_EINVAL;
#if defined(__MVS__)
if (!(handle->flags & UV_HANDLE_IPV6))
return UV_ENOTSUP; /* zOS does not support setting ttl for IPv4 */
#endif
/*
* On Solaris and derivatives such as SmartOS, the length of socket options
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x299fae
cmpl $0xff, -0x14(%rbp)
jle 0x299fb7
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x299fd0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x2, %esi
movl $0x10, %edx
callq 0x299fe0
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__setsockopt_maybe_char | static int uv__setsockopt_maybe_char(uv_udp_t* handle,
int option4,
int option6,
int val) {
#if defined(__sun) || defined(_AIX) || defined(__MVS__)
char arg = val;
#elif defined(__OpenBSD__)
unsigned char ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x29a00a
cmpl $0xff, -0x1c(%rbp)
jle 0x29a013
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x29a02f
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_multicast_loop | int uv_udp_set_multicast_loop(uv_udp_t* handle, int on) {
/*
* On Solaris and derivatives such as SmartOS, the length of socket options
* is sizeof(int) for IPV6_MULTICAST_LOOP and sizeof(char) for
* IP_MULTICAST_LOOP, so hardcode the size of the option in the IPv6 case,
* and use the general uv__setsockopt_maybe_c... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x22, %esi
movl $0x13, %edx
callq 0x299fe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_udp_set_multicast_interface | int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr) {
struct sockaddr_storage addr_st;
struct sockaddr_in* addr4;
struct sockaddr_in6* addr6;
addr4 = (struct sockaddr_in*) &addr_st;
addr6 = (struct sockaddr_in6*) &addr_st;
if (!interface_addr) {
memset(&addr_st, 0, sizeof ... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29a131
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10810
movq -0x10(%rbp), %rax
movl 0x58... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv__udp_recv_start | int uv__udp_recv_start(uv_udp_t* handle,
uv_alloc_cb alloc_cb,
uv_udp_recv_cb recv_cb) {
int err;
if (alloc_cb == NULL || recv_cb == NULL)
return UV_EINVAL;
if (uv__io_active(&handle->io_watcher, POLLIN))
return UV_EALREADY; /* FIXME(bnoordhuis) Should be U... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29a2e2
cmpq $0x0, -0x20(%rbp)
jne 0x29a2ee
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x29a3b8
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
movl $0x1, %esi
callq 0x28d120
cmpl... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/udp.c |
uv_set_process_title | int uv_set_process_title(const char* title) {
struct uv__process_title* pt;
size_t len;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
pt = &process_title;
len = strlen(title);
uv_once(&process_title_mutex_once, init_process_title_mutex_o... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x8fb3c(%rip) # 0x32bbc0
jne 0x29c092
movl $0xffffff97, -0x4(%rbp) # imm = 0xFFFFFF97
jmp 0x29c159
leaq 0x8fb2f(%rip), %rax # 0x32bbc8
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x109c0
movq %rax, -0x20(%rbp)
leaq 0x8fb2f(%ri... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/unix/proctitle.c |
uv_fs_poll_start | int uv_fs_poll_start(uv_fs_poll_t* handle,
uv_fs_poll_cb cb,
const char* path,
unsigned int interval) {
struct poll_ctx* ctx;
uv_loop_t* loop;
size_t len;
int err;
if (uv_is_active((uv_handle_t*)handle))
return 0;
loop = handle->loop;
le... | pushq %rbp
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), %rdi
callq 0x28c2c0
cmpl $0x0, %eax
je 0x29c351
movl $0x0, -0x4(%rbp)
jmp 0x29c558
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
poll_cb | static void poll_cb(uv_fs_t* req) {
uv_stat_t* statbuf;
struct poll_ctx* ctx;
uint64_t interval;
uv_fs_poll_t* handle;
ctx = container_of(req, struct poll_ctx, fs_req);
handle = ctx->parent_handle;
if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
goto out;
if (req->result != 0) ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0xc0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x28c2c0
cmpl $0x0, %eax
je 0x29c5b2
movq -0x28(%rbp), %rax
movl 0x58(%rax), %eax
andl $0x3, %eax
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_fs_poll_stop | int uv_fs_poll_stop(uv_fs_poll_t* handle) {
struct poll_ctx* ctx;
if (!uv_is_active((uv_handle_t*)handle))
return 0;
ctx = handle->poll_ctx;
assert(ctx != NULL);
assert(ctx->parent_handle == handle);
/* Close the timer if it's active. If it's inactive, there's a stat request
* in progress and poll... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28c2c0
cmpl $0x0, %eax
jne 0x29c766
movl $0x0, -0x4(%rbp)
jmp 0x29c83b
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29c77b
jmp 0x29c79a
leaq 0x397a6(%rip), %rdi # 0x2d... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
timer_close_cb | static void timer_close_cb(uv_handle_t* timer) {
struct poll_ctx* ctx;
struct poll_ctx* it;
struct poll_ctx* last;
uv_fs_poll_t* handle;
ctx = container_of(timer, struct poll_ctx, timer_handle);
handle = ctx->parent_handle;
if (ctx == handle->poll_ctx) {
handle->poll_ctx = ctx->previous;
if (hand... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x60(%rcx), %rax
jne 0x29c8bc
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rcx
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_fs_poll_getpath | int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
struct poll_ctx* ctx;
size_t required_len;
if (!uv_is_active((uv_handle_t*)handle)) {
*size = 0;
return UV_EINVAL;
}
ctx = handle->poll_ctx;
assert(ctx != NULL);
required_len = strlen(ctx->path);
if (required_len >= *s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28c2c0
cmpl $0x0, %eax
jne 0x29c989
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x29ca2c
movq -0x10(%rbp), %rax
movq 0x60(%rax)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
statbuf_eq | static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec
&& a->st_mtim.tv_nsec == b->st_mtim.tv_nsec
&& a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec
&& a->st_ctim.tv_sec == b->st_ctim.tv_sec
&& a->st_mtim.tv_sec == b->st_mtim.tv_sec
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x88(%rdx), %rcx
movb %al, -0x11(%rbp)
jne 0x29cbf3
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x78(%rdx), %rcx
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
timer_cb | static void timer_cb(uv_timer_t* timer) {
struct poll_ctx* ctx;
ctx = container_of(timer, struct poll_ctx, timer_handle);
assert(ctx->parent_handle != NULL);
assert(ctx->parent_handle->poll_ctx == ctx);
ctx->start_time = uv_now(ctx->loop);
if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
a... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x28, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29cc24
jmp 0x29cc43
leaq 0x393ec(%rip), %rdi # 0x2d6017
leaq 0x39302(%rip), %rsi # 0x2d5f34
movl $0xb0, %edx
leaq 0x393f4(%rip), %rcx ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/fs-poll.c |
uv_inet_ntop | int uv_inet_ntop(int af, const void* src, char* dst, size_t size) {
switch (af) {
case AF_INET:
return (inet_ntop4(src, dst, size));
case AF_INET6:
return (inet_ntop6(src, dst, size));
default:
return UV_EAFNOSUPPORT;
}
/* NOTREACHED */
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x29ccfe
jmp 0x29ccf4
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x29cd14
jmp 0x29cd2a
movq -0x10(%rbp), %rdi
movq -0x18(%... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_ntop4 | static int inet_ntop4(const unsigned char *src, char *dst, size_t size) {
static const char fmt[] = "%u.%u.%u.%u";
char tmp[UV__INET_ADDRSTRLEN];
int l;
l = snprintf(tmp, sizeof(tmp), fmt, src[0], src[1], src[2], src[3]);
if (l <= 0 || (size_t) l >= size) {
return UV_ENOSPC;
}
uv__strscpy(dst, tmp, s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %r8d
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %r9d
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
mov... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_ntop6 | static int inet_ntop6(const unsigned char *src, char *dst, size_t size) {
/*
* Note that int32_t and int16_t need only be "at least" large enough
* to contain a value of the specified size. On some systems, like
* Crays, there is no such thing as an integer variable with 16 bits.
* Keep this in mind if y... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10810
movl $0x0, -0x94(%rbp)
cmpl $0x10, -0x94(%rbp)
jge 0x29ce73
movq -0x10(%rbp), %rax
movslq -0x94(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
uv_inet_pton | int uv_inet_pton(int af, const char* src, void* dst) {
if (src == NULL || dst == NULL)
return UV_EINVAL;
switch (af) {
case AF_INET:
return (inet_pton4(src, dst));
case AF_INET6: {
int len;
char tmp[UV__INET6_ADDRSTRLEN], *s, *p;
s = (char*) src;
p = strchr(src, '%');
if (p != NULL)... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29d121
cmpq $0x0, -0x18(%rbp)
jne 0x29d12d
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x29d1d5
movl -0x8(%rbp), %eax
movl %eax, -0x64(%rbp)
subl $0x2, %eax
je 0x29d147
jmp... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/inet.c |
inet_pton6 | static int inet_pton6(const char *src, unsigned char *dst) {
static const char xdigits_l[] = "0123456789abcdef",
xdigits_u[] = "0123456789ABCDEF";
unsigned char tmp[sizeof(struct in6_addr)], *tp, *endp, *colonp;
const char *xdigits, *curtok;
int ch, seen_xdigits;
unsigned int val;
memse... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x10810
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x... | /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_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x29d778
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
jmp 0x29d784
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%r... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/strtok.c |
timer_less_than | static int timer_less_than(const struct heap_node* ha,
const struct heap_node* hb) {
const uv_timer_t* a;
const uv_timer_t* b;
a = container_of(ha, uv_timer_t, heap_node);
b = container_of(hb, uv_timer_t, heap_node);
if (a->timeout < b->timeout)
return 1;
if (b->timeout < a-... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $-0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $-0x68, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x29dc85
movl $0x1, -0x4(... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
heap_remove | HEAP_EXPORT(void heap_remove(struct heap* heap,
struct heap_node* node,
heap_compare_fn less_than)) {
struct heap_node* smallest;
struct heap_node** max;
struct heap_node* child;
unsigned int path;
unsigned int k;
unsigned int n;
if (heap->nelts =... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x29dcf3
jmp 0x29df43
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
jb 0... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/heap-inl.h |
uv_timer_again | int uv_timer_again(uv_timer_t* handle) {
if (handle->timer_cb == NULL)
return UV_EINVAL;
if (handle->repeat) {
uv_timer_stop(handle);
uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x29df70
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x29dfb5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x29dfae
movq -0x10(%rbp), %rdi
callq 0x29da30
movq -0x10(%rbp), %rdi
movq -0x10(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
uv__next_timeout | int uv__next_timeout(const uv_loop_t* loop) {
const struct heap_node* heap_node;
const uv_timer_t* handle;
uint64_t diff;
heap_node = heap_min(timer_heap(loop));
if (heap_node == NULL)
return -1; /* block indefinitely */
handle = container_of(heap_node, uv_timer_t, heap_node);
if (handle->timeout <=... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29dc20
movq %rax, %rdi
callq 0x29e100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29e091
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29e0f1
movq -0x18(%rbp), %rax
addq $-0x68, %rax
movq %rax, -0x20(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
uv__run_timers | void uv__run_timers(uv_loop_t* loop) {
struct heap_node* heap_node;
uv_timer_t* handle;
for (;;) {
heap_node = heap_min(timer_heap(loop));
if (heap_node == NULL)
break;
handle = container_of(heap_node, uv_timer_t, heap_node);
if (handle->timeout > loop->time)
break;
uv_timer_sto... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29dc20
movq %rax, %rdi
callq 0x29e100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x29e14a
jmp 0x29e192
movq -0x10(%rbp), %rax
addq $-0x68, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movq ... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/timer.c |
heap_node_swap | static void heap_node_swap(struct heap* heap,
struct heap_node* parent,
struct heap_node* child) {
struct heap_node* sibling;
struct heap_node t;
t = *parent;
*parent = *child;
*child = t;
parent->parent = child;
if (child->left == child) {
child... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rd... | /JKorbelRA[P]CMake/Utilities/cmlibuv/src/heap-inl.h |
cm_zlib_crc32_z | unsigned long ZEXPORT crc32_z(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
z_size_t len;
{
/* Return initial CRC, if requested. */
if (buf == Z_NULL) return 0;
#ifdef DYNAMIC_CRC_TABLE
once(&made, make_crc_table);
#endif /* DYNAMIC_CRC_TABLE */
/* Pre-condition the CRC *... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29e34b
movq $0x0, -0x8(%rbp)
jmp 0x29eccd
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x2f, -0x20(%rbp)
jb 0x29ea85
jmp... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
byte_swap | local z_word_t byte_swap(word)
z_word_t word;
{
# if W == 8
return
(word & 0xff00000000000000) >> 56 |
(word & 0xff000000000000) >> 40 |
(word & 0xff0000000000) >> 24 |
(word & 0xff00000000) >> 8 |
(word & 0xff000000) << 8 |
(word & 0xff0000) << 24 |
(wor... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x8(%rbp), %rax
shrq $0x38, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq -0x8(%rbp), %rcx
shrq $0x28, %rcx
orq %rcx, %rax
movabsq $0xff0000000000, %rcx # imm = 0xFF0000000000
andq ... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
crc_word_big | local z_word_t crc_word_big(data)
z_word_t data;
{
int k;
for (k = 0; k < W; k++)
data = (data << 8) ^
crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
return data;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x29ee26
movq -0x8(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rdx
shrq $0x38, %rdx
andq $0xff, %rdx
leaq 0x3d6fd(%rip), %rcx # 0x2dc510
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, ... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
multmodp | local z_crc_t multmodp(a, b)
z_crc_t a;
z_crc_t b;
{
z_crc_t m, p;
m = (z_crc_t)1 << 31;
p = 0;
for (;;) {
if (a & m) {
p ^= b;
if ((a & (m - 1)) == 0)
break;
}
m >>= 1;
b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
}
retur... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x80000000, -0xc(%rbp) # imm = 0x80000000
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x29eee0
movl -0x8(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl -0xc(%rbp),... | /JKorbelRA[P]CMake/Utilities/cmzlib/crc32.c |
cm_zlib_deflateInit2_ | int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
version, stream_size)
z_streamp strm;
int level;
int method;
int windowBits;
int memLevel;
int strategy;
const char *version;
int stream_size;
{
deflate_state *s;
int wrap = 1;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x1, -0x34(%rbp)
cmpq $0x0, 0x10(%rbp)
je 0x29f0ee
movq 0x10(%rbp), %rax
movsbl (%rax), ... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
deflateStateCheck | local int deflateStateCheck (strm)
z_streamp strm;
{
deflate_state *s;
if (strm == Z_NULL ||
strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
return 1;
s = strm->state;
if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
#ifdef GZIP
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29f9a5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x29f9a5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x29f9b1
movl $0x1, -0x4(%rbp)
jmp 0x29fa34
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
fill_window | local void fill_window(s)
deflate_state *s;
{
unsigned n;
unsigned more; /* Amount of free space at the end of the window. */
uInt wsize = s->w_size;
Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
do {
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xb4(%rcx), %ecx
subq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0xac(%rcx), %ecx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
lm_init | local void lm_init (s)
deflate_state *s;
{
s->window_size = (ulg)2L*s->w_size;
CLEAR_HASH(s);
/* Set the default configuration parameters:
*/
s->max_lazy_match = configuration_table[s->level].max_lazy;
s->good_match = configuration_table[s->level].good_length;
s->nice_match ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
shlq %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x84(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rc... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflatePending | int ZEXPORT deflatePending (strm, pending, bits)
unsigned *pending;
int *bits;
z_streamp strm;
{
if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
if (pending != Z_NULL)
*pending = strm->state->pending;
if (bits != Z_NULL)
*bits = strm->state->bi_valid;
return Z_OK;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29f980
cmpl $0x0, %eax
je 0x2a029b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a02d8
cmpq $0x0, -0x18(%rbp)
je 0x2a02b6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflateParams | int ZEXPORT deflateParams(strm, level, strategy)
z_streamp strm;
int level;
int strategy;
{
deflate_state *s;
compress_func func;
if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state;
#ifdef FASTEST
if (level != 0) level = 1;
#else
if (level == Z_DEFAULT_COMPRESSION)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29f980
cmpl $0x0, %eax
je 0x2a043c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a0668
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x1, ... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflate | int ZEXPORT deflate (strm, flush)
z_streamp strm;
int flush;
{
int old_flush; /* value of flush param for previous deflate call */
deflate_state *s;
if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
return Z_STREAM_ERROR;
}
s = strm->state;
if (strm->next_out == Z_... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29f980
cmpl $0x0, %eax
jne 0x2a06ac
cmpl $0x5, -0x14(%rbp)
jg 0x2a06ac
cmpl $0x0, -0x14(%rbp)
jge 0x2a06b8
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a18a0
movq -0x10(%rbp), %rax
movq 0x3... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
cm_zlib_deflateBound | uLong ZEXPORT deflateBound(strm, sourceLen)
z_streamp strm;
uLong sourceLen;
{
deflate_state *s;
uLong complen, wraplen;
/* conservative upper bound for compressed data */
complen = sourceLen +
((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
/* if can't get parameters, ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x7, %rcx
shrq $0x3, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
addq $0x3f, %rcx
shrq $0x6, %rcx
addq %rcx, %rax
addq $0x5, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
ca... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
flush_pending | local void flush_pending(strm)
z_streamp strm;
{
unsigned len;
deflate_state *s = strm->state;
_tr_flush_bits(s);
len = s->pending;
if (len > strm->avail_out) len = strm->avail_out;
if (len == 0) return;
zmemcpy(strm->next_out, s->pending_out, len);
strm->next_out += len;
s->p... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a8f30
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jbe 0x2a1c62
mov... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
deflate_stored | local block_state deflate_stored(s, flush)
deflate_state *s;
int flush;
{
/* Smallest worthy block size when not flushing or finishing. By default
* this is 32K. This can be as small as 507 bytes for memLevel == 1. For
* large input and output buffers, the stored block size will be larger.
*/... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x5, %rax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x2a1da4
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq %rax, -0x38(%rbp)
jmp 0x2a1db4
movq -0x10(%rb... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
read_buf | local unsigned read_buf(strm, buf, size)
z_streamp strm;
Bytef *buf;
unsigned size;
{
unsigned len = strm->avail_in;
if (len > size) len = size;
if (len == 0) return 0;
strm->avail_in -= len;
zmemcpy(buf, strm->next_in, len);
if (strm->state->wrap == 1) {
strm->adler = ad... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x2a4a7b
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2a4a8d... | /JKorbelRA[P]CMake/Utilities/cmzlib/deflate.c |
inflateStateCheck | local int inflateStateCheck(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
if (strm == Z_NULL ||
strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
return 1;
state = (struct inflate_state FAR *)strm->state;
if (state == Z_NULL || state->strm != strm ||
state-... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2a4ca5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2a4ca5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2a4cae
movl $0x1, -0x4(%rbp)
jmp 0x2a4cf8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateReset | int ZEXPORT inflateReset(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
state->wsize = 0;
state->whave = 0;
state->wnext = 0;
return inflateResetKeep(strm);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a4d23
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a4d5c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x18(%r... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateReset2 | int ZEXPORT inflateReset2(strm, windowBits)
z_streamp strm;
int windowBits;
{
int wrap;
struct inflate_state FAR *state;
/* get the state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* extract wrap request from windowBits parameter */... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a4d99
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a4e51
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2a4dbc... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateInit2_ | int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
z_streamp strm;
int windowBits;
const char *version;
int stream_size;
{
int ret;
struct inflate_state FAR *state;
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
stream_size != (int)(sizeof(z_stream)))
return Z_VERS... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2a4e95
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movsbl 0xcf63(%rip), %ecx # 0x2b1dee
cmpl %ecx, %eax
jne 0x2a4e95
cmpl $0x70, -0x24(%rbp)
je 0x2a4ea1... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflatePrime | int ZEXPORT inflatePrime(strm, bits, value)
z_streamp strm;
int bits;
int value;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (bits < 0) {
state->hold = 0;
state->bits = 0;
return Z_OK;... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a500c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a50aa
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
fixedtables | local void fixedtables(state)
struct inflate_state FAR *state;
{
#ifdef BUILDFIXED
static int virgin = 1;
static code *lenfix, *distfix;
static code fixed[544];
/* build fixed huffman tables if first call (may not be thread safe) */
if (virgin) {
unsigned sym, bits;
static code *nex... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x356dd(%rip), %rcx # 0x2dcea0
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x78(%rax)
movq -0x8(%rbp), %rax
leaq 0x35ec3(%rip), %rcx # 0x2dd6a0
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x7c(%rax)
popq %rbp
retq
... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
updatewindow | local int updatewindow(strm, end, copy)
z_streamp strm;
const Bytef *end;
unsigned copy;
{
struct inflate_state FAR *state;
unsigned dist;
state = (struct inflate_state FAR *)strm->state;
/* if it hasn't been done already, allocate space for the window */
if (state->window == Z_NULL) {
sta... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2a7863
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rc... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateGetDictionary | int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength)
z_streamp strm;
Bytef *dictionary;
uInt *dictLength;
{
struct inflate_state FAR *state;
/* check state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
/* copy dictionary */
if... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a7aae
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a7b48
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateSetDictionary | int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
z_streamp strm;
const Bytef *dictionary;
uInt dictLength;
{
struct inflate_state FAR *state;
unsigned long dictid;
int ret;
/* check state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)st... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a7b8d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a7c4d
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateGetHeader | int ZEXPORT inflateGetHeader(strm, head)
z_streamp strm;
gz_headerp head;
{
struct inflate_state FAR *state;
/* check state */
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
/* save header ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a7c87
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a7cc9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%r... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateSync | int ZEXPORT inflateSync(strm)
z_streamp strm;
{
unsigned len; /* number of bytes to look at or looked at */
int flags; /* temporary to save header status */
unsigned long in, out; /* temporary to save total_in and total_out */
unsigned char buf[4]; /* to restore... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a7d06
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a7ee1
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x2a7d32
m... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
syncsearch | local unsigned syncsearch(have, buf, len)
unsigned FAR *have;
const unsigned char FAR *buf;
unsigned len;
{
unsigned got;
unsigned next;
got = *have;
next = 0;
while (next < len && got < 4) {
if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
got++;
else if (buf[next])
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x1d(%rbp)
jae 0x2a7f26
cmpl $0x4, -0x18(%rbp)
setb %al
movb %al, ... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateCopy | int ZEXPORT inflateCopy(dest, source)
z_streamp dest;
z_streamp source;
{
struct inflate_state FAR *state;
struct inflate_state FAR *copy;
unsigned char FAR *window;
unsigned wsize;
/* check input */
if (inflateStateCheck(source) || dest == Z_NULL)
return Z_STREAM_ERROR;
state = (st... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
jne 0x2a8035
cmpq $0x0, -0x10(%rbp)
jne 0x2a8041
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a8244
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateUndermine | int ZEXPORT inflateUndermine(strm, subvert)
z_streamp strm;
int subvert;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
state->sane = !subvert;
return Z_OK;
#el... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a8276
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a8297
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, 0... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateValidate | int ZEXPORT inflateValidate(strm, check)
z_streamp strm;
int check;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (check && state->wrap)
state->wrap |= 4;
else
state->wrap &= ~4;
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a82c6
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2a8305
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2a82f1
... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflateMark | long ZEXPORT inflateMark(strm)
z_streamp strm;
{
struct inflate_state FAR *state;
if (inflateStateCheck(strm))
return -(1L << 16);
state = (struct inflate_state FAR *)strm->state;
return (long)(((unsigned long)((long)state->back)) << 16) +
(state->mode == COPY ? state->length :
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a4c80
cmpl $0x0, %eax
je 0x2a8334
movq $-0x10000, -0x8(%rbp) # imm = 0xFFFF0000
jmp 0x2a83ac
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x1bec(%rax), %rax
shlq $0x1... | /JKorbelRA[P]CMake/Utilities/cmzlib/inflate.c |
cm_zlib_inflate_table | int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
codetype type;
unsigned short FAR *lens;
unsigned codes;
code FAR * FAR *table;
unsigned FAR *bits;
unsigned short FAR *work;
{
unsigned len; /* a code's length in bits */
unsigned sym; /* index of code symbols */
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0xf, -0x34(%rbp)
ja 0x2a8463
movl -0x34(%rbp), %eax
movw $0x0, -0xb0(%rbp,%rax,2)
movl -0x34(%rbp), %eax
addl $0... | /JKorbelRA[P]CMake/Utilities/cmzlib/inftrees.c |
cm_zlib__tr_init | void ZLIB_INTERNAL _tr_init(s)
deflate_state *s;
{
tr_static_init();
s->l_desc.dyn_tree = s->dyn_ltree;
s->l_desc.stat_desc = &static_l_desc;
s->d_desc.dyn_tree = s->dyn_dtree;
s->d_desc.stat_desc = &static_d_desc;
s->bl_desc.dyn_tree = s->bl_tree;
s->bl_desc.stat_desc = &static_bl_de... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2a8b30
movq -0x8(%rbp), %rcx
addq $0xd4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb58(%rax)
movq -0x8(%rbp), %rax
leaq 0x7e1be(%rip), %rcx # 0x326c60
movq %rcx, 0xb68(%rax)
movq -0x8(%rbp), %rcx
addq $0x9c8, %rcx # imm = 0x9C8
movq ... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
init_block | local void init_block(s)
deflate_state *s;
{
int n; /* iterates over tree elements */
/* Initialize the trees. */
for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0;
for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0;
for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
s->dyn_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x11e, -0xc(%rbp) # imm = 0x11E
jge 0x2a8b75
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw $0x0, 0xd4(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a8b4f
movl $0x0, -0xc(%rbp)
cmpl $0x1e, -0xc(%rbp)
... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
bi_windup | local void bi_windup(s)
deflate_state *s;
{
if (s->bi_valid > 8) {
put_short(s, s->bi_buf);
} else if (s->bi_valid > 0) {
put_byte(s, (Byte)s->bi_buf);
}
s->bi_buf = 0;
s->bi_valid = 0;
#ifdef ZLIB_DEBUG
s->bits_sent = (s->bits_sent+7) & ~7;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x1734(%rax)
jle 0x2a8ed5
movq -0x8(%rbp), %rax
movzwl 0x1730(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
bi_flush | local void bi_flush(s)
deflate_state *s;
{
if (s->bi_valid == 16) {
put_short(s, s->bi_buf);
s->bi_buf = 0;
s->bi_valid = 0;
} else if (s->bi_valid >= 8) {
put_byte(s, (Byte)s->bi_buf);
s->bi_buf >>= 8;
s->bi_valid -= 8;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10, 0x1734(%rax)
jne 0x2a8fe0
movq -0x8(%rbp), %rax
movzwl 0x1730(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
cm_zlib__tr_align | void ZLIB_INTERNAL _tr_align(s)
deflate_state *s;
{
send_bits(s, STATIC_TREES<<1, 3);
send_code(s, END_BLOCK, static_ltree);
#ifdef ZLIB_DEBUG
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
bi_flush(s);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %eax
movl $0x10, %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x2a9145
movl $0x2, -0x10(%rbp)
movl -0x10(%rbp), %eax
movzwl %ax, %edx
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %ecx
shll %cl,... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
detect_data_type | local int detect_data_type(s)
deflate_state *s;
{
/* block_mask is the bit mask of block-listed bytes
* set bits 0..6, 14..25, and 28..31
* 0xf3ffc07f = binary 11110011111111111100000001111111
*/
unsigned long block_mask = 0xf3ffc07fUL;
int n;
/* Check for non-textual ("block-listed"... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0xf3ffc07f, %eax # imm = 0xF3FFC07F
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x1f, -0x1c(%rbp)
jg 0x2a9725
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x2a970d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl 0xd4(%rax,%rcx,4),... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
build_tree | local void build_tree(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
const ct_data *stree = desc->stat_desc->static_tree;
int elems = desc->stat_desc->elems;
int n, m; /* iterate over heap elements */
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
build_bl_tree | local int build_bl_tree(s)
deflate_state *s;
{
int max_blindex; /* index of last bit length code of non zero freq */
/* Determine the bit length frequencies for literal and distance trees */
scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0xd4, %rsi
movq -0x8(%rbp), %rax
movl 0xb60(%rax), %edx
callq 0x2ab230
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x9c8, %rsi # imm = 0x9C8
movq -0x8(%rbp), %rax
movl 0xb78(%rax), %edx
c... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
compress_block | local void compress_block(s, ltree, dtree)
deflate_state *s;
const ct_data *ltree; /* literal tree */
const ct_data *dtree; /* distance tree */
{
unsigned dist; /* distance of matched string */
int lc; /* match length or unmatched char (if dist == 0) */
unsigned sx = 0; /* ru... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x170c(%rax)
je 0x2aa3bb
jmp 0x2a9c5a
movq -0x8(%rbp), %rax
movq 0x1700(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movl %e... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
send_all_trees | local void send_all_trees(s, lcodes, dcodes, blcodes)
deflate_state *s;
int lcodes, dcodes, blcodes; /* number of codes for each tree */
{
int rank; /* index in bl_order */
Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
Assert (lcodes <= L_CODES && dco... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x5, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x1734(%rax), %eax
movl $0x10, %ecx
subl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jle 0x2aa602
movl -0xc(%rbp), %eax
subl $0x101, %eax ... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
cm_zlib__tr_tally | int ZLIB_INTERNAL _tr_tally (s, dist, lc)
deflate_state *s;
unsigned dist; /* distance of matched string */
unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
s->sym_buf[s->sym_next++] = dist;
s->sym_buf[s->sym_next++] = dist >> 8;
s->sym_buf[s->sym_next++] = lc;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
pqdownheap | local void pqdownheap(s, tree, k)
deflate_state *s;
ct_data *tree; /* the tree to restore */
int k; /* node to move down */
{
int v = s->heap[k];
int j = k << 1; /* left son of k */
while (j <= s->heap_len) {
/* Set j to the smallest of the two sons: */
if (j < s-... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl 0xbc0(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14b4(%rcx), %eax
... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
gen_bitlen | local void gen_bitlen(s, desc)
deflate_state *s;
tree_desc *desc; /* the tree descriptor */
{
ct_data *tree = desc->dyn_tree;
int max_code = desc->max_code;
const ct_data *stree = desc->stat_desc->static_tree;
const intf *extra = desc->stat_desc->extra_bits;
int base ... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x1... | /JKorbelRA[P]CMake/Utilities/cmzlib/trees.c |
cm_zlib_zlibCompileFlags | uLong ZEXPORT zlibCompileFlags()
{
uLong flags;
flags = 0;
switch ((int)(sizeof(uInt))) {
case 2: break;
case 4: flags += 1; break;
case 8: flags += 2; break;
default: flags += 3;
}
switch ((int)(sizeof(uLong))) {
case 2: break;
case 4: flags +... | pushq %rbp
movq %rsp, %rbp
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %r... | /JKorbelRA[P]CMake/Utilities/cmzlib/zutil.c |
cm_zlib_adler32_z | uLong ZEXPORT adler32_z(adler, buf, len)
uLong adler;
const Bytef *buf;
z_size_t len;
{
unsigned long sum2;
unsigned n;
/* split Adler-32 into component sums */
sum2 = (adler >> 16) & 0xffff;
adler &= 0xffff;
/* in case user likes doing a byte at a time, keep it fast */
if (len... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xffff, %rax # imm = 0xFFFF
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
andq $0xffff, %rax # imm = 0xFFFF
movq %rax, -0x10(%rbp)
cmpq $0x1, -0x20(%rbp)
jne ... | /JKorbelRA[P]CMake/Utilities/cmzlib/adler32.c |
adler32_combine_ | local uLong adler32_combine_(adler1, adler2, len2)
uLong adler1;
uLong adler2;
z_off64_t len2;
{
unsigned long sum1;
unsigned long sum2;
unsigned rem;
/* for negative len, return invalid adler32 as a clue for debugging */
if (len2 < 0)
return 0xffffffffUL;
/* the derivation... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x2ac605
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x2ac70d
movq -0x20(%rbp), %rax
movl $0xfff1, %ecx # imm = 0xFFF1
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)... | /JKorbelRA[P]CMake/Utilities/cmzlib/adler32.c |
cm_zlib_inflate_fast | void ZLIB_INTERNAL inflate_fast(strm, start)
z_streamp strm;
unsigned start; /* inflate()'s starting value for strm->avail_out */
{
struct inflate_state FAR *state;
z_const unsigned char FAR *in; /* local strm->next_in */
z_const unsigned char FAR *last; /* have enough input while in < last ... | pushq %rbp
movq %rsp, %rbp
subq $0x48, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x5, %ecx
movl %ecx, %ecx
addq... | /JKorbelRA[P]CMake/Utilities/cmzlib/inffast.c |
Name_pairs::sort() | void Name_pairs::sort()
{
auto name_orig{ name };
std::vector<double> sorted_age(age.size());
std::vector<size_t> processed_indexes;
std::sort(name.begin(), name.end());
for (size_t i = 0; i < name.size(); ++i)
{
auto pos = std::find(name_orig.begin(), name_orig.end(), name.at(i)) - name_orig.begin();
// hand... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x269a
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x38(%rsp), %rdi
movq %rsp, %rdx
callq 0x3384
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rs... | /vocasle[P]principles_and_practice_using_cpp/part_1_the_basics/chapter_9/name_pairs.cpp |
testing::internal::FilePath::RemoveTrailingPathSeparator() const | FilePath FilePath::RemoveTrailingPathSeparator() const {
return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1))
: *this;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x128a6
movq (%rsi), %rax
cmpb $0x2f, -0x1(%rax,%rcx)
sete %bpl
jmp 0x128a8
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x128e0
decq %rcx
movq %rsp, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xac46
leaq 0x10(%rbx), %rax
... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::DirectoryExists() const | bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this
: RemoveTrailingPathSeparator());
#else
cons... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8270
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8400
movl 0x18(%r14), %ecx
andl $0xf000, %ecx # imm = 0xF000
xorl $0x4000, %ecx # imm = 0x4000
orl %eax, %ecx
sete %al
a... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateFolder() const | bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
delete[] unicode;
#elif GTEST_OS_WINDOWS
int result = _mkdir(pathnam... | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x81d0
movl %eax, %ecx
movb $0x1, %al
cmpl $-0x1, %ecx
jne 0x12c67
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x8270
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x8400
m... | /bevanwsjones[P]Disa/build_O1/_deps/googletest-src/googletest/src/gtest-filepath.cc |
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.