name string | code string | asm string | file string |
|---|---|---|---|
ares_hosts_entry_destroy | static void ares_hosts_entry_destroy(ares_hosts_entry_t *entry)
{
if (entry == NULL) {
return;
}
/* Honor reference counting */
if (entry->refcnt != 0) {
entry->refcnt--;
}
if (entry->refcnt > 0) {
return;
}
ares_llist_destroy(entry->hosts);
ares_llist_destroy(entry->ips);
ares_free(e... | pushq %rbx
testq %rdi, %rdi
je 0x12023
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x1201d
decq %rax
movq %rax, (%rbx)
cmpq $0x0, (%rbx)
je 0x12025
popq %rbx
retq
movq 0x10(%rbx), %rdi
callq 0xc5c0
movq 0x8(%rbx), %rdi
callq 0xc5c0
movq %rbx, %rdi
popq %rbx
jmp 0xddd8
| /c-ares[P]c-ares/src/lib/ares_hosts_file.c |
ares_realloc_zero | void *ares_realloc_zero(void *ptr, size_t orig_size, size_t new_size)
{
void *p = ares_realloc(ptr, new_size);
if (p == NULL) {
return NULL;
}
if (new_size > orig_size) {
memset((unsigned char *)p + orig_size, 0, new_size - orig_size);
}
return p;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %rsi
callq *0x24680(%rip) # 0x36ef8
testq %rax, %rax
je 0x12897
movq %rax, %rbx
subq %r15, %r14
jbe 0x12899
movq %rbx, %rdi
addq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xc9c0
jmp 0x12899
xorl %ebx, %ebx
movq %rbx, %rax
popq %... | /c-ares[P]c-ares/src/lib/ares_library_init.c |
ares_library_init | int ares_library_init(int flags)
{
if (ares_initialized) {
ares_initialized++;
return ARES_SUCCESS;
}
ares_initialized++;
/* NOTE: ARES_LIB_INIT_WIN32 flag no longer used */
ares_init_flags = flags;
return ARES_SUCCESS;
} | incl 0x24664(%rip) # 0x36f0c
xorl %eax, %eax
retq
| /c-ares[P]c-ares/src/lib/ares_library_init.c |
ares_process_pending_write | void ares_process_pending_write(ares_channel_t *channel)
{
ares_slist_node_t *node;
if (channel == NULL) {
return;
}
ares_channel_lock(channel);
if (!channel->notify_pending_write) {
ares_channel_unlock(channel);
return;
}
/* Set as untriggerd before calling into ares_conn_flush(), this is
... | testq %rdi, %rdi
je 0x142c5
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdb10
cmpl $0x0, 0x198(%rbx)
je 0x142b3
movl $0x0, 0x198(%rbx)
movq 0xb8(%rbx), %rdi
callq 0xd700
testq %rax, %rax
je 0x142b3
movq %rax, %r14
movq %r14, %rdi
callq 0xc1c0
movq 0x80(%rax), %r15
testq %r15, %r15
je 0... | /c-ares[P]c-ares/src/lib/ares_process.c |
end_query | static void end_query(ares_channel_t *channel, ares_server_t *server,
ares_query_t *query, ares_status_t status,
const ares_dns_record_t *dnsrec)
{
/* If we were probing for the server to come back online, lets mark it as
* no longer being probed */
if (server != NULL)... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x14945
movl $0x0, 0x70(%rsi)
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0xc780
movq 0x60(%r14), %rdi
movq 0x80(%r14), %rdx
movl %ebp, %esi
movq %r15, %rcx
callq *0x58(%r1... | /c-ares[P]c-ares/src/lib/ares_process.c |
invoke_server_state_cb | static void invoke_server_state_cb(const ares_server_t *server,
ares_bool_t success, int flags)
{
const ares_channel_t *channel = server->channel;
ares_buf_t *buf;
ares_status_t status;
char *server_string;
if (channel->server_state_cb == N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x220(%rdi), %r12
cmpq $0x0, 0x1d8(%r12)
je 0x14d11
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
callq 0xdc10
testq %rax, %rax
je 0x14d11
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xcf40
movq %r14, %rdi
testl %eax, %eax
je 0x14cdb
popq %rbx
popq... | /c-ares[P]c-ares/src/lib/ares_process.c |
ares_qcache_expire | static void ares_qcache_expire(ares_qcache_t *cache, const ares_timeval_t *now)
{
ares_slist_node_t *node;
if (cache == NULL) {
return;
}
while ((node = ares_slist_node_first(cache->expire)) != NULL) {
const ares_qcache_entry_t *entry = ares_slist_node_val(node);
/* If now is NULL, we're flushing... | testq %rdi, %rdi
je 0x14d80
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xd700
testq %rax, %rax
je 0x14d7b
movq %rax, %r15
movq %r15, %rdi
callq 0xc1c0
testq %rbx, %rbx
je 0x14d57
movq 0x10(%rax), %rcx
cmpq (%rbx), %rcx
jg 0x14d7b
movq (%r14), %rdi
movq (%rax), %rsi
callq... | /c-ares[P]c-ares/src/lib/ares_qcache.c |
ares_qcache_entry_destroy_cb | static void ares_qcache_entry_destroy_cb(void *arg)
{
ares_qcache_entry_t *entry = arg;
if (entry == NULL) {
return; /* LCOV_EXCL_LINE: DefensiveCoding */
}
ares_free(entry->key);
ares_dns_record_destroy(entry->dnsrec);
ares_free(entry);
} | testq %rdi, %rdi
je 0x14e78
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xddd8
movq 0x8(%rbx), %rdi
callq 0xc8b0
movq %rbx, %rdi
popq %rbx
jmp 0xddd8
retq
| /c-ares[P]c-ares/src/lib/ares_qcache.c |
ares_qcache_fetch | ares_status_t ares_qcache_fetch(ares_channel_t *channel,
const ares_timeval_t *now,
const ares_dns_record_t *dnsrec,
const ares_dns_record_t **dnsrec_resp)
{
char *key = NULL;
ares_qcache_en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
movl $0x2, %ebp
jne 0x14f1c
movq %rdi, %r12
movq 0x1c0(%rdi), %rdi
testq %rdi, %rdi
je 0x14f01
movq %rdx, %r15
movq %rsi, %r14
callq 0x14d20
movq... | /c-ares[P]c-ares/src/lib/ares_qcache.c |
ares_query_nolock | ares_status_t ares_query_nolock(ares_channel_t *channel, const char *name,
ares_dns_class_t dnsclass,
ares_dns_rec_type_t type,
ares_callback_dnsrec callback, void *arg,
unsigned short *q... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rdi, %r15
movq $0x0, 0x10(%rsp)
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %dil
andb %al, %dil
testq %r8, %r8
setne %al
testb %al, %dil
jne 0x15363
movl $0x2, %ebp
testq %rbx, %rbx
je 0x153fd
movq %r14, %rdi
movl $0x... | /c-ares[P]c-ares/src/lib/ares_query.c |
ares_query_dnsrec_cb | static void ares_query_dnsrec_cb(void *arg, ares_status_t status,
size_t timeouts,
const ares_dns_record_t *dnsrec)
{
ares_query_dnsrec_arg_t *qquery = arg;
if (status != ARES_SUCCESS) {
qquery->callback(qquery->arg, status, ti... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
testl %esi, %esi
jne 0x15441
movq %r14, %rdi
callq 0xc650
movl %eax, %ebp
movq %r14, %rdi
movl $0x1, %esi
callq 0xcf90
movl %ebp, %edi
movq %rax, %rsi
callq 0xc9d0
movl %eax, %esi
movq 0x8(%rbx), %rdi
movq %r15, %rdx
... | /c-ares[P]c-ares/src/lib/ares_query.c |
ares_query | void ares_query(ares_channel_t *channel, const char *name, int dnsclass,
int type, ares_callback callback, void *arg)
{
void *carg = NULL;
if (channel == NULL) {
return;
}
carg = ares_dnsrec_convert_arg(callback, arg);
if (carg == NULL) {
callback(arg, ARES_ENOMEM, 0, NULL, 0); /* LC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x155f2
movq %r9, %r13
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
movq %r8, %rbp
movq %r8, %rdi
movq %r9, %rsi
callq 0xd270
testq %rax, %rax
je 0x1552e
movq %rax, %r14
movq %rbx, %rdi
callq ... | /c-ares[P]c-ares/src/lib/ares_query.c |
ares_name_label_cnt | size_t ares_name_label_cnt(const char *name)
{
const char *p;
size_t ndots = 0;
if (name == NULL) {
return 0;
}
for (p = name; p != NULL && *p != 0; p++) {
if (*p == '.') {
ndots++;
}
}
/* Label count is 1 greater than ndots */
return ndots + 1;
} | xorl %eax, %eax
testq %rdi, %rdi
je 0x15624
movzbl (%rdi), %ecx
cmpl $0x2e, %ecx
je 0x15619
testl %ecx, %ecx
jne 0x1561c
jmp 0x15621
incq %rax
incq %rdi
jmp 0x1560b
incq %rax
retq
| /c-ares[P]c-ares/src/lib/ares_search.c |
ares_lookup_hostaliases | ares_status_t ares_lookup_hostaliases(const ares_channel_t *channel,
const char *name, char **alias)
{
ares_status_t status = ARES_SUCCESS;
const char *hostaliases = NULL;
ares_buf_t *buf = NULL;
ares_array_t *lines = NULL;
size_t num;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq $0x0, (%rsp)
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
movl $0x2, %r12d
jne 0x15934
movq %rdx, %rbx
movq $0x0, (%rdx)
movl $0x4, %r12d
testb $0x... | /c-ares[P]c-ares/src/lib/ares_search.c |
ares_dnsrec_convert_arg | void *ares_dnsrec_convert_arg(ares_callback callback, void *arg)
{
dnsrec_convert_arg_t *carg = ares_malloc_zero(sizeof(*carg));
if (carg == NULL) {
return NULL;
}
carg->callback = callback;
carg->arg = arg;
return carg;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0xcf80
testq %rax, %rax
je 0x15b51
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
jmp 0x15b53
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /c-ares[P]c-ares/src/lib/ares_search.c |
ares_dnsrec_convert_cb | void ares_dnsrec_convert_cb(void *arg, ares_status_t status, size_t timeouts,
const ares_dns_record_t *dnsrec)
{
dnsrec_convert_arg_t *carg = arg;
unsigned char *abuf = NULL;
size_t alen = 0;
if (dnsrec != NULL) {
ares_status_t mystatus = ares_dns_write(dns... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
testq %rcx, %rcx
je 0x15b90
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %rcx, %rdi
callq 0xc220
testl %eax, %eax
cmovnel %eax, %ebp
movq 0x8(%rbx), %rdi
movq (%rsp), %rc... | /c-ares[P]c-ares/src/lib/ares_search.c |
ares_send_nolock | ares_status_t ares_send_nolock(ares_channel_t *channel, ares_server_t *server,
ares_send_flags_t flags,
const ares_dns_record_t *dnsrec,
ares_callback_dnsrec callback, void *arg,
unsigned s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %r9, 0x10(%rsp)
movq %r8, %r13
movq %rcx, %r14
movl %edx, 0x1c(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
movq 0xc0(%r12), %rdi
callq 0xd970
movl %eax, %ebp
movq 0xd0(%r12), %rdi
movzwl %ax, %r15d
movq %r15, %rs... | /c-ares[P]c-ares/src/lib/ares_send.c |
ares_send | void ares_send(ares_channel_t *channel, const unsigned char *qbuf, int qlen,
ares_callback callback, void *arg)
{
ares_dns_record_t *dnsrec = NULL;
ares_status_t status;
void *carg = NULL;
if (channel == NULL) {
return;
}
/* Verify that the query is at least long enoug... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x16480
movq %r8, %rbx
movq %rcx, %r9
leal -0x10000(%rdx), %eax
cmpl $0xffff000b, %eax # imm = 0xFFFF000B
ja 0x1641d
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x10, %rsp
popq %rbx... | /c-ares[P]c-ares/src/lib/ares_send.c |
default_asocket | static ares_socket_t default_asocket(int domain, int type, int protocol,
void *user_data)
{
ares_socket_t s;
(void)user_data;
s = socket(domain, type, protocol);
if (s == ARES_SOCKET_BAD) {
return s;
}
if (setsocknonblock(s, 1) != 0) {
goto fail; /* LCOV_EXCL_L... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
callq 0xddb0
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x16664
movl %eax, %ebp
movl %eax, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc4b0
orl $0x800, %eax # imm = 0x800
movl %ebp, %edi
movl $0x4, %e... | /c-ares[P]c-ares/src/lib/ares_set_socket_functions.c |
default_aclose | static int default_aclose(ares_socket_t sock, void *user_data)
{
(void)user_data;
#if defined(HAVE_CLOSESOCKET)
return closesocket(sock);
#elif defined(HAVE_CLOSESOCKET_CAMEL)
return CloseSocket(sock);
#elif defined(HAVE_CLOSE_S)
return close_s(sock);
#else
return close(sock);
#endif
} | jmp 0xca70
| /c-ares[P]c-ares/src/lib/ares_set_socket_functions.c |
ares_socket_deref_error | static ares_conn_err_t ares_socket_deref_error(int err)
{
switch (err) {
#if defined(EWOULDBLOCK)
case EWOULDBLOCK:
return ARES_CONN_ERR_WOULDBLOCK;
#endif
#if defined(EAGAIN) && (!defined(EWOULDBLOCK) || EAGAIN != EWOULDBLOCK)
case EAGAIN:
return ARES_CONN_ERR_WOULDBLOCK;
#endif
case EINPROGR... | movl $0x1, %eax
leal -0x61(%rdi), %ecx
cmpl $0x12, %ecx
ja 0x16a26
leaq 0x138ad(%rip), %rdx # 0x2a2c4
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0xc, %eax
retq
cmpl $0x4, %edi
je 0x16a6c
cmpl $0xb, %edi
je 0x16a4d
movl $0x63, %eax
retq
movl $0x7, %eax
retq
movl $0x6, %eax
retq
movl $0x9, %eax
retq
... | /c-ares[P]c-ares/src/lib/ares_socket.c |
ares_socket_recv | ares_conn_err_t ares_socket_recv(ares_channel_t *channel, ares_socket_t s,
ares_bool_t is_tcp, void *data,
size_t data_len, size_t *read_bytes)
{
ares_ssize_t rv;
*read_bytes = 0;
rv = channel->sock_funcs.arecvfrom(s, data, data_len, 0, NULL, 0,
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movl %edx, %ebp
movq %rdi, %rax
movq $0x0, (%r9)
movq 0x170(%rdi), %rdx
movq %rdx, (%rsp)
xorl %ebx, %ebx
movl %esi, %edi
movq %rcx, %rsi
movq %r8, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq *0x140(%rax)
testq %rax, %rax
jle 0x16abf
movq %... | /c-ares[P]c-ares/src/lib/ares_socket.c |
ares_socket_configure | ares_status_t ares_socket_configure(ares_channel_t *channel, int family,
ares_bool_t is_tcp, ares_socket_t fd)
{
union {
struct sockaddr sa;
struct sockaddr_in sa4;
struct sockaddr_in6 sa6;
} local;
ares_socklen_t bindlen = 0;
int rv;
unsigned i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x0, 0x30(%rdi)
jle 0x16bd3
leaq 0x30(%r14), %rdx
movq 0x170(%r14), %r8
movl %ebx, %edi
xorl %esi, %esi
movl $0x4, %ecx
callq *0x130(%r14)
testl %eax, %eax
je 0x16bd3... | /c-ares[P]c-ares/src/lib/ares_socket.c |
ares_sortaddrinfo | ares_status_t ares_sortaddrinfo(ares_channel_t *channel,
struct ares_addrinfo_node *list_sentinel)
{
struct ares_addrinfo_node *cur;
size_t nelem = 0;
size_t i;
int has_src_addr;
struct addrinfo_sort_elem... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rsi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x16eb8
incq %rbx
movq 0x20(%rax), %rax
jmp 0x16eaa
testq %rbx, %rbx
je 0x16fff
movq %rbx, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0xc4... | /c-ares[P]c-ares/src/lib/ares_sortaddrinfo.c |
ares_sysconfig_parse_resolv_line | ares_status_t ares_sysconfig_parse_resolv_line(const ares_channel_t *channel,
ares_sysconfig_t *sysconfig,
ares_buf_t *line)
{
char option[32];
char value[512];
ares_status_t status = ARES... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x135f7(%rip), %rsi # 0x2b526
movl $0x1, %edx
movq %r15, %rdi
callq 0xcc90
xorl %ebp, %ebp
testl %eax, %eax
jne 0x17f5a
leaq 0x127fc(%rip), %rsi # 0x2a745
movl $... | /c-ares[P]c-ares/src/lib/ares_sysconfig_files.c |
ares_init_sysconfig_files | ares_status_t ares_init_sysconfig_files(const ares_channel_t *channel,
ares_sysconfig_t *sysconfig,
ares_bool_t process_resolvconf)
{
ares_status_t status = ARES_SUCCESS;
/* Resolv.conf */
if (process_resolvconf) {
status = p... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x1839e
movq 0x1a0(%r14), %rax
testq %rax, %rax
leaq 0x1241f(%rip), %rsi # 0x2a7a0
cmovneq %rax, %rsi
movq 0x1dc24(%rip), %rcx # 0x35fb0
movq %r14, %rdi
movq %rbx, %rdx
callq 0x18407
testl $0xfffffffb, %eax # imm = 0xFFFF... | /c-ares[P]c-ares/src/lib/ares_sysconfig_files.c |
process_config_lines | static ares_status_t process_config_lines(const ares_channel_t *channel,
const char *filename,
ares_sysconfig_t *sysconfig,
ares_sysconfig_line_cb_t cb)
{
ares_status_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
callq 0xdc10
movq %rax, %rbx
testq %rax, %rax
je 0x18451
movq %r13, %rdi
movq %rbx, %rsi
callq 0xca60
movl %eax, %ebp
testl %eax, %eax
jne 0x18456
movq %r12, %rdi
movq %r15, %rsi
... | /c-ares[P]c-ares/src/lib/ares_sysconfig_files.c |
ares_sconfig_append_fromstr | ares_status_t ares_sconfig_append_fromstr(const ares_channel_t *channel,
ares_llist_t **sconfig,
const char *str,
ares_bool_t ignore_invalid)
{
ares_status_t status ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq $0x0, 0x8(%rsp)
movq %rdx, %rdi
callq 0xd750
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc440
movq %rax, %rbx
testq %rax, %rax
je 0x18... | /c-ares[P]c-ares/src/lib/ares_update_servers.c |
set_servers_csv | static ares_status_t set_servers_csv(ares_channel_t *channel, const char *_csv)
{
ares_status_t status;
ares_llist_t *slist = NULL;
if (channel == NULL) {
return ARES_ENODATA;
}
if (ares_strlen(_csv) == 0) {
/* blank all servers */
ares_channel_lock(channel);
status = ares_servers_update(cha... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x19bc7
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd750
testq %rax, %rax
je 0x19bce
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xda90
testl %eax, %eax
je 0x19bf1
movl %eax, %ebp
jmp 0x... | /c-ares[P]c-ares/src/lib/ares_update_servers.c |
ares_addr_match | static ares_bool_t ares_addr_match(const struct ares_addr *addr1,
const struct ares_addr *addr2)
{
if (addr1 == NULL && addr2 == NULL) {
return ARES_TRUE; /* LCOV_EXCL_LINE: DefensiveCoding */
}
if (addr1 == NULL || addr2 == NULL) {
return ARES_FALSE; /* LCOV_EXCL_LINE:... | movl $0x1, %eax
movq %rdi, %rcx
orq %rsi, %rcx
je 0x19d4b
testq %rsi, %rsi
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x19d49
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0x19d49
cmpl $0xa, %ecx
je 0x19d2f
cmpl $0x2, %ecx
jne 0x19d49
movl 0x4(%rdi), %edx
cmpl 0x4(%rsi), %edx
je 0x19d4b
cmpl $0xa, %ecx
jne 0x19d49
m... | /c-ares[P]c-ares/src/lib/ares_update_servers.c |
ares_inet_net_pton_ipv4 | static int ares_inet_net_pton_ipv4(const char *src, unsigned char *dst,
size_t size)
{
static const char xdigits[] = "0123456789abcdef";
static const char digits[] = "0123456789";
int n;
int ch;
int tmp = 0;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0xc9c0
leaq 0x1(%r15), %rcx
movb (%r15), %al
cmpb $0x30, %al
jne 0x1a254
movzbl (%rcx), %edx
orl $0x20, %edx
cmpl $0x78, %edx
jne 0x1a254
movb 0x2(%r15), %dl... | /c-ares[P]c-ares/src/lib/inet_net_pton.c |
ares_inet_ntop | const char *ares_inet_ntop(int af, const void *src, char *dst,
ares_socklen_t size)
{
switch (af) {
case AF_INET:
return inet_ntop4(src, dst, (size_t)size);
case AF_INET6:
return inet_ntop6(src, dst, (size_t)size);
default:
break;
}
SET_SOCKER... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %eax
movq %rdx, %r11
movq %rsi, %r14
cmpl $0xa, %edi
je 0x1a513
cmpl $0x2, %edi
jne 0x1a689
movl %eax, %edx
movq %r14, %rdi
movq %r11, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a7... | /c-ares[P]c-ares/src/lib/inet_ntop.c |
ares_array_create | ares_array_t *ares_array_create(size_t member_size,
ares_array_destructor_t destruct)
{
ares_array_t *arr;
if (member_size == 0) {
return NULL;
}
arr = ares_malloc_zero(sizeof(*arr));
if (arr == NULL) {
return NULL;
}
arr->member_size = member_si... | testq %rdi, %rdi
je 0x1a7b7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0xcf80
testq %rax, %rax
je 0x1a7ba
movq %r14, 0x10(%rax)
movq %rbx, (%rax)
jmp 0x1a7bc
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /c-ares[P]c-ares/src/lib/dsa/ares_array.c |
ares_array_destroy | void ares_array_destroy(ares_array_t *arr)
{
size_t i;
if (arr == NULL) {
return;
}
if (arr->destruct != NULL) {
for (i = 0; i < arr->cnt; i++) {
arr->destruct(ares_array_at(arr, i));
}
}
ares_free(arr->arr);
ares_free(arr);
} | testq %rdi, %rdi
je 0x1a89f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x1a887
cmpq $0x0, 0x18(%rbx)
je 0x1a887
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
addq %r14, %rdi
imulq 0x10(%rbx), %rdi
addq 0x8(%rbx), %rdi
callq *(%rbx)
incq %r14
cmpq 0x18(%rbx), %r14
jb 0x1a86c
movq 0x8(%rbx), %rdi
cal... | /c-ares[P]c-ares/src/lib/dsa/ares_array.c |
ares_htable_buckets_destroy | static void ares_htable_buckets_destroy(ares_llist_t **buckets,
unsigned int size,
ares_bool_t destroy_vals)
{
unsigned int i;
if (buckets == NULL) {
return;
}
for (i = 0; i < size; i++) {
if (buckets[i] == NULL) {
... | testq %rdi, %rdi
je 0x1ad9c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
testl %esi, %esi
je 0x1ad89
movl %edx, %ebx
movl %esi, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
testq %rdi, %rdi
je 0x1ad81
testl %ebx, %ebx
jne 0x1ad78
xorl %esi, %esi
callq 0xcac0
movq (%r14,%r12,8), %rdi
callq ... | /c-ares[P]c-ares/src/lib/dsa/ares_htable.c |
ares_htable_hash_FNV1a | unsigned int ares_htable_hash_FNV1a(const unsigned char *key, size_t key_len,
unsigned int seed)
{
unsigned int hv = seed ^ 2166136261U;
size_t i;
for (i = 0; i < key_len; i++) {
hv ^= (unsigned int)key[i];
/* hv *= 16777619 (0x01000193) */
hv += (hv << 1) + ... | movl %edx, %eax
xorl $0x811c9dc5, %eax # imm = 0x811C9DC5
testq %rsi, %rsi
je 0x1b444
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
xorl %eax, %edx
imull $0x1000193, %edx, %eax # imm = 0x1000193
incq %rcx
cmpq %rcx, %rsi
jne 0x1b430
retq
| /c-ares[P]c-ares/src/lib/dsa/ares_htable.c |
ares_htable_asvp_get_direct | void *ares_htable_asvp_get_direct(const ares_htable_asvp_t *htable,
ares_socket_t key)
{
void *val = NULL;
ares_htable_asvp_get(htable, key, &val);
return val;
} | pushq %rax
movl %esi, 0x4(%rsp)
testq %rdi, %rdi
je 0x1b6df
movq 0x8(%rdi), %rdi
leaq 0x4(%rsp), %rsi
callq 0xd870
testq %rax, %rax
je 0x1b6df
movq 0x8(%rax), %rax
jmp 0x1b6e1
xorl %eax, %eax
popq %rcx
retq
| /c-ares[P]c-ares/src/lib/dsa/ares_htable_asvp.c |
ares_event_thread_destroy | void ares_event_thread_destroy(ares_channel_t *channel)
{
ares_event_thread_t *e = channel->sock_state_cb_data;
if (e == NULL) {
return; /* LCOV_EXCL_LINE: DefensiveCoding */
}
ares_event_thread_destroy_int(e);
channel->sock_state_cb_data = NULL;
channel->sock_state_cb = NULL;... | pushq %rbx
movq %rdi, %rbx
movq 0xf0(%rdi), %rdi
testq %rdi, %rdi
je 0x1d5e1
callq 0x1d5e3
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0x188(%rbx)
popq %rbx
retq
| /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
ares_event_thread_destroy_int | static void ares_event_thread_destroy_int(ares_event_thread_t *e)
{
/* Wake thread and tell it to shutdown if it exists */
ares_thread_mutex_lock(e->mutex);
if (e->isup) {
e->isup = ARES_FALSE;
ares_event_thread_wake(e);
}
ares_thread_mutex_unlock(e->mutex);
/* Wait for thread to shutdown */
if (... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd670
cmpl $0x0, (%rbx)
je 0x1d612
movl $0x0, (%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1d612
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1d612
callq *%rax
movq 0x10(%rbx), %rdi
callq 0xd380
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0... | /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
notifywrite_cb | static void notifywrite_cb(void *data)
{
ares_event_thread_t *e = data;
ares_thread_mutex_lock(e->mutex);
e->process_pending_write = ARES_TRUE;
ares_thread_mutex_unlock(e->mutex);
ares_event_thread_wake(e);
} | pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd670
movl $0x1, 0x20(%rbx)
movq 0x10(%rbx), %rdi
callq 0xd380
testq %rbx, %rbx
je 0x1d86a
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1d86a
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1d86a
popq %rbx
jmpq *%rax
popq %rbx
retq
| /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
ares_event_process_updates | static void ares_event_process_updates(ares_event_thread_t *e)
{
ares_llist_node_t *node;
/* Iterate across all updates and apply to internal list, removing from update
* list */
while ((node = ares_llist_node_first(e->ev_updates)) != NULL) {
ares_event_t *newev = ares_llist_node_claim(node);
ares_eve... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0xd590
testq %rax, %rax
je 0x1d959
movq %rax, %rdi
callq 0xc110
movq %rax, %r14
movl 0x18(%rax), %esi
cmpl $-0x1, %esi
je 0x1d8a4
movq 0x30(%rbx), %rdi
callq 0xcb50
jmp 0x1d8b1
movq 0x38(%rbx), %rdi
movq 0x20(%r14), %rsi
callq 0xdce0
movq %rax... | /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
ares_event_thread | static void *ares_event_thread(void *arg)
{
ares_event_thread_t *e = arg;
ares_thread_mutex_lock(e->mutex);
while (e->isup) {
struct timeval tv;
const struct timeval *tvout;
unsigned long timeout_ms = 0; /* 0 = unlimited */
ares_bool_t process_pending_write;
ares_eve... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd670
cmpl $0x0, (%rbx)
je 0x1da47
leaq 0x8(%rsp), %r14
movabsq $0x20c49ba5e353f7cf, %r15 # imm = 0x20C49BA5E353F7CF
movq %rbx, %rdi
callq 0x1d86c
movq 0x10(%rbx), %rdi
callq 0xd380
movq 0x18(%rbx), %rdi
xorl %esi,... | /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
ares_event_thread_process_fd | static void ares_event_thread_process_fd(ares_event_thread_t *e,
ares_socket_t fd, void *data,
ares_event_flags_t flags)
{
ares_fd_events_t event;
(void)data;
event.fd = fd;
event.events = 0;
if (flags & ARES_EVENT_FLAG_REA... | pushq %rax
movq %rsp, %rax
movl %esi, (%rax)
andl $0x3, %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rdi), %rdi
movl $0x1, %edx
movq %rax, %rsi
movl $0x1, %ecx
callq 0xca10
popq %rax
retq
nop
| /c-ares[P]c-ares/src/lib/event/ares_event_thread.c |
ares_pipeevent_create | ares_event_t *ares_pipeevent_create(ares_event_thread_t *e)
{
ares_event_t *event = NULL;
ares_pipeevent_t *p = NULL;
ares_status_t status;
p = ares_pipeevent_init();
if (p == NULL) {
return NULL;
}
status = ares_event_update(&event, e, ARES_EVENT_FLAG_READ, ares_pipeevent_cb,
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq $0x0, (%rsp)
movl $0x8, %edi
callq 0xcf80
testq %rax, %rax
je 0x1db55
movq %rax, %rbx
movq $-0x1, (%rax)
movq %rax, %rdi
movl $0x80800, %esi # imm = 0x80800
callq 0xda40
testl %eax, %eax
je 0x1db57
movq %rbx, %rdi
callq 0x1dbfe
xorl %ebx, %ebx
testq %rbx, %... | /c-ares[P]c-ares/src/lib/event/ares_event_wake_pipe.c |
ares_dns_name_write | ares_status_t ares_dns_name_write(ares_buf_t *buf, ares_llist_t **list,
ares_bool_t validate_hostname,
const char *name)
{
const ares_nameoffset_t *off = NULL;
size_t name_len;
size_t orig_name_len;
size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
callq 0xda10
movq %rax, 0x58(%rsp)
testq %r13, %r13
sete %al
movq %rbx, 0x50(%rsp)
testq %rbx, %rbx
sete %cl
orb %al, %cl
movl $0x2, %r14d
jne 0x20... | /c-ares[P]c-ares/src/lib/record/ares_dns_name.c |
ares_dns_rr_get_u16 | unsigned short ares_dns_rr_get_u16(const ares_dns_rr_t *dns_rr,
ares_dns_rr_key_t key)
{
const unsigned short *u16;
if (ares_dns_rr_key_datatype(key) != ARES_DATATYPE_U16) {
return 0;
}
u16 = ares_dns_rr_data_ptr_const(dns_rr, key, NULL);
if (u16 == NULL) {
retu... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
callq 0xc840
xorl %ebx, %ebx
cmpl $0x4, %eax
jne 0x22dd3
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x22f98
testq %rax, %rax
je 0x22dd3
movzwl (%rax), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /c-ares[P]c-ares/src/lib/record/ares_dns_record.c |
ares_dns_rr_set_abin_own | ares_status_t ares_dns_rr_set_abin_own(ares_dns_rr_t *dns_rr,
ares_dns_rr_key_t key,
ares_dns_multistring_t *strs)
{
ares_dns_multistring_t **strs_ptr;
if (ares_dns_rr_key_datatype(key) != ARES_DATATYPE_ABINP) {
return... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl %esi, %edi
callq 0xc840
movl $0x2, %ebp
cmpl $0xb, %eax
jne 0x23981
movq %r15, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x22f98
testq %rax, %rax
je 0x23981
movq %rax, %r14
movq (%rax), %rdi
testq %rdi, %rdi
j... | /c-ares[P]c-ares/src/lib/record/ares_dns_record.c |
ares_dns_write_rr_caa | static ares_status_t ares_dns_write_rr_caa(ares_buf_t *buf,
const ares_dns_rr_t *rr,
ares_llist_t **namelist)
{
const unsigned char *data = NULL;
size_t data_len = 0;
ares_status_t status;... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movl $0x6465, %edx # imm = 0x6465
callq 0x25371
testl %eax, %eax
jne 0x251a7
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6466, %edx # imm = 0x6466
callq 0x252c2
testl %eax, %eax
jne 0x251a7
leaq 0x8(%r... | /c-ares[P]c-ares/src/lib/record/ares_dns_write.c |
ares_dns_write_rr_str | static ares_status_t ares_dns_write_rr_str(ares_buf_t *buf,
const ares_dns_rr_t *rr,
ares_dns_rr_key_t key)
{
const char *str;
size_t len;
ares_status_t status;
str = ares_dns_rr_get_str(rr, key);
if (s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0xc710
movl $0x2, %ebp
testq %rax, %rax
je 0x25308
movq %rax, %r14
movq %rax, %rdi
callq 0xd750
cmpq $0xff, %rax
ja 0x25308
movq %rax, %r15
movzbl %r15b, %esi
movq %rbx, %rdi
callq 0xd770
movl %eax, %ebp
testl %... | /c-ares[P]c-ares/src/lib/record/ares_dns_write.c |
ares_buf_set_length | ares_status_t ares_buf_set_length(ares_buf_t *buf, size_t len)
{
if (buf == NULL || ares_buf_is_const(buf)) {
return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
}
if (len >= buf->alloc_buf_len - buf->offset) {
return ARES_EFORMERR; /* LCOV_EXCL_LINE: DefensiveCoding */
}
buf->data_len = len... | movl $0x2, %eax
testq %rdi, %rdi
je 0x254db
cmpq $0x0, (%rdi)
je 0x254c2
cmpq $0x0, 0x10(%rdi)
je 0x254db
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
subq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x254db
addq %rsi, %rcx
movq %rcx, 0x8(%rdi)
xorl %eax, %eax
retq
| /c-ares[P]c-ares/src/lib/str/ares_buf.c |
ares_buf_append_be32 | ares_status_t ares_buf_append_be32(ares_buf_t *buf, unsigned int u32)
{
ares_status_t status;
status = ares_buf_append_byte(buf, ((unsigned char)(u32 >> 24) & 0xff));
if (status != ARES_SUCCESS) {
return status; /* LCOV_EXCL_LINE: OutOfMemory */
}
status = ares_buf_append_byte(buf, ((unsigned char)(u32 ... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x25531
testl %eax, %eax
jne 0x25681
movl %ebp, %eax
shrl $0x18, %eax
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
movb %al, (%rdx,%rcx)
incq 0x8(%rbx)
xorl %eax, %eax
testl %eax, %eax
jne 0x256fb
movl $0x1, %esi
movq %rbx, %rdi
callq ... | /c-ares[P]c-ares/src/lib/str/ares_buf.c |
ares_buf_consume_charset | size_t ares_buf_consume_charset(ares_buf_t *buf, const unsigned char *charset,
size_t len)
{
size_t remaining_len = 0;
const unsigned char *ptr = ares_buf_fetch(buf, &remaining_len);
size_t i;
if (ptr == NULL || charset == NULL || len == 0) ... | testq %rdi, %rdi
je 0x261a2
movq (%rdi), %rax
testq %rax, %rax
je 0x261a2
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r9
addq %r9, %rax
xorl %r8d, %r8d
subq %r9, %rcx
cmovneq %rax, %r8
jmp 0x261a7
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %eax, %eax
testq %rdx, %rdx
je 0x26210
testq %rsi, %rsi
je 0x26210
testq %r8, %r8
je 0x2621... | /c-ares[P]c-ares/src/lib/str/ares_buf.c |
ares_memmem | unsigned char *ares_memmem(const unsigned char *big, size_t big_len,
const unsigned char *little, size_t little_len)
{
unsigned char *ptr;
if (big == NULL || little == NULL || big_len == 0 || little_len == 0) {
return NULL;
}
#ifdef HAVE_MEMMEM
ptr = memmem(big, big_len, little,... | testq %rcx, %rcx
je 0x27200
testq %rsi, %rsi
je 0x27200
testq %rdi, %rdi
je 0x27200
testq %rdx, %rdx
jne 0xce30
xorl %eax, %eax
retq
| /c-ares[P]c-ares/src/lib/str/ares_str.c |
ares_iface_ips_get_flags | ares_iface_ip_flags_t ares_iface_ips_get_flags(const ares_iface_ips_t *ips,
size_t idx)
{
const ares_iface_ip_t *ip;
if (ips == NULL) {
return 0;
}
ip = ares_array_at_const(ips->ips, idx);
if (ip == NULL) {
return 0;
}
return ip->f... | pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x27927
movq (%rdi), %rdi
callq 0xc680
testq %rax, %rax
je 0x27927
movl 0x24(%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
| /c-ares[P]c-ares/src/lib/util/ares_iface_ips.c |
ares_os_if_indextoname | const char *ares_os_if_indextoname(unsigned int index, char *name, size_t name_len)
{
#ifdef HAVE_IF_INDEXTONAME
if (name_len < IF_NAMESIZE) {
return NULL;
}
return if_indextoname(index, name);
#else
ares_status_t status;
ares_iface_ips_t *ips = NULL;
size_t i;
const char *ptr = N... | cmpq $0x10, %rdx
jae 0xd410
xorl %eax, %eax
retq
| /c-ares[P]c-ares/src/lib/util/ares_iface_ips.c |
ares_thread_mutex_create | ares_thread_mutex_t *ares_thread_mutex_create(void)
{
pthread_mutexattr_t attr;
ares_thread_mutex_t *mut = ares_malloc_zero(sizeof(*mut));
if (mut == NULL) {
return NULL;
}
if (pthread_mutexattr_init(&attr) != 0) {
ares_free(mut); /* LCOV_EXCL_LINE: UntestablePath */
return NULL; /* LCOV_EXCL... | pushq %rbx
subq $0x10, %rsp
movl $0x28, %edi
callq 0xcf80
testq %rax, %rax
je 0x279eb
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0xdb50
testl %eax, %eax
jne 0x279e3
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
callq 0xc870
testl %eax, %eax
jne 0x279d9
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0xdc90
testl %eax, %eax
je 0x279f... | /c-ares[P]c-ares/src/lib/util/ares_threads.c |
ares_channel_threading_init | ares_status_t ares_channel_threading_init(ares_channel_t *channel)
{
ares_status_t status = ARES_SUCCESS;
/* Threading is optional! */
if (!ares_threadsafety()) {
return ARES_SUCCESS;
}
channel->lock = ares_thread_mutex_create();
if (channel->lock == NULL) {
status = ARES_ENOMEM;
goto done;
... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xc7f0
movq %rax, 0xa8(%rbx)
xorl %r14d, %r14d
testq %rax, %rax
je 0x27cbb
callq 0xd330
movq %rax, 0xb0(%rbx)
testq %rax, %rax
movl $0xf, %ebp
cmovnel %r14d, %ebp
setne %al
movl %eax, %r14d
jmp 0x27cc0
movl $0xf, %ebp
testb %r14b, %r14b
jne 0x27ccd
movq %rbx, %rdi
... | /c-ares[P]c-ares/src/lib/util/ares_threads.c |
ares_queue_notify_empty | void ares_queue_notify_empty(ares_channel_t *channel)
{
if (channel == NULL) {
return;
}
/* We are guaranteed to be holding a channel lock already */
if (ares_llist_len(channel->all_queries)) {
return;
}
/* Notify all waiters of the conditional */
ares_thread_cond_broadcast(channel->cond_empty);... | pushq %rbx
testq %rdi, %rdi
je 0x27eb6
movq %rdi, %rbx
movq 0xc8(%rdi), %rdi
callq 0xdc60
testq %rax, %rax
je 0x27eb8
popq %rbx
retq
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x27eb6
popq %rbx
jmp 0xc320
nop
| /c-ares[P]c-ares/src/lib/util/ares_threads.c |
ares_pow | size_t ares_pow(size_t x, size_t y)
{
size_t res = 1;
while (y > 0) {
/* If y is odd, multiply x with result */
if (y & 1) {
res = res * x;
}
/* y must be even now */
y = y >> 1; /* y /= 2; */
x = x * x; /* x^2 */
}
return res;
} | testq %rsi, %rsi
je 0x27fd1
movl $0x1, %ecx
movl $0x1, %eax
movq %rsi, %rdx
testb $0x1, %sil
movq %rdi, %r8
cmoveq %rcx, %r8
imulq %r8, %rax
shrq %rdx
imulq %rdi, %rdi
cmpq $0x1, %rsi
movq %rdx, %rsi
ja 0x27fb1
retq
movl $0x1, %eax
retq
| /c-ares[P]c-ares/src/lib/util/ares_math.c |
ares_count_hexdigits | size_t ares_count_hexdigits(size_t n)
{
size_t digits;
for (digits = 0; n > 0; digits++) {
n /= 16;
}
if (digits == 0) {
digits = 1;
}
return digits;
} | xorl %eax, %eax
testq %rdi, %rdi
je 0x28024
movq %rdi, %rcx
shrq $0x4, %rcx
incq %rax
cmpq $0xf, %rdi
movq %rcx, %rdi
ja 0x28014
cmpq $0x1, %rax
adcq $0x0, %rax
retq
| /c-ares[P]c-ares/src/lib/util/ares_math.c |
ares_init_rand_state | ares_rand_state *ares_init_rand_state(void)
{
ares_rand_state *state = NULL;
state = ares_malloc_zero(sizeof(*state));
if (!state) {
return NULL;
}
if (!ares_init_rand_engine(state)) {
ares_free(state); /* LCOV_EXCL_LINE: UntestablePath */
return NULL; /* LCOV_EXCL_LINE: UntestablePath */
... | pushq %rbx
movl $0x220, %edi # imm = 0x220
callq 0xcf80
testq %rax, %rax
je 0x28059
movq %rax, %rbx
movq %rax, %rdi
callq 0x28060
jmp 0x2805b
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
| /c-ares[P]c-ares/src/lib/util/ares_rand.c |
ares_init_rand_engine | static ares_bool_t ares_init_rand_engine(ares_rand_state *state)
{
state->cache_remaining = 0;
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
/* For fuzzing, random should be deterministic */
state->bad_backends |= ARES_RAND_OS | ARES_RAND_FILE;
#endif
#if defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_GETRANDOM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq $0x0, 0x218(%rdi)
movl 0x4(%rdi), %eax
testb $0x1, %al
jne 0x2808e
movl $0x1, (%rbx)
jmp 0x281ce
testb $0x2, %al
jne 0x280d3
movl $0x2, (%rbx)
leaq 0x3471(%rip), %rdi # 0x2b510
leaq 0x321b(%rip), %rsi # 0x2... | /c-ares[P]c-ares/src/lib/util/ares_rand.c |
ares_uri_destroy | void ares_uri_destroy(ares_uri_t *uri)
{
if (uri == NULL) {
return;
}
ares_free(uri->username);
ares_free(uri->password);
ares_free(uri->path);
ares_free(uri->fragment);
ares_htable_dict_destroy(uri->query);
ares_free(uri);
} | testq %rdi, %rdi
je 0x2849f
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xddd8
movq 0x18(%rbx), %rdi
callq 0xddd8
movq 0x128(%rbx), %rdi
callq 0xddd8
movq 0x138(%rbx), %rdi
callq 0xddd8
movq 0x130(%rbx), %rdi
callq 0xc3b0
movq %rbx, %rdi
popq %rbx
jmp 0xddd8
retq
| /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_set_scheme | ares_status_t ares_uri_set_scheme(ares_uri_t *uri, const char *scheme)
{
if (uri == NULL) {
return ARES_EFORMERR;
}
if (!ares_uri_scheme_is_valid(scheme)) {
return ARES_EBADSTR;
}
ares_strcpy(uri->scheme, scheme, sizeof(uri->scheme));
ares_str_lower(uri->scheme);
return ARES_SUCCESS;
} | testq %rdi, %rdi
je 0x28504
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd750
movq %rax, %rcx
movl $0x11, %eax
testq %rcx, %rcx
je 0x28524
movb (%r14), %cl
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0x28524
movq %r14, %rcx
movb (%rcx), %dl
movzbl %dl, %esi
leal -0x2... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_set_host | ares_status_t ares_uri_set_host(ares_uri_t *uri, const char *host)
{
struct ares_addr addr;
size_t addrlen;
char hoststr[256];
char *ll_scope;
if (uri == NULL || ares_strlen(host) == 0 ||
ares_strlen(host) >= sizeof(hoststr)) {
return ARES_EFORMERR;
}
ares_strc... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl $0x2, %ebp
testq %rdi, %rdi
je 0x287be
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xd750
testq %rax, %rax
je 0x287be
movq %r14, %rdi
callq 0xd750
cmpq $0xff, %rax
ja 0x287be
leaq 0x50(%rsp), %r15
movl $0x100, %edx ... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_set_query_key | ares_status_t ares_uri_set_query_key(ares_uri_t *uri, const char *key,
const char *val)
{
if (uri == NULL || key == NULL || *key == 0) {
return ARES_EFORMERR;
}
if (!ares_str_isprint(key, ares_strlen(key)) ||
(val != NULL && !ares_str_isprint(val, ares_strlen(val)))... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0x2, %ebp
jne 0x28ad9
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x28ad9
movq %rdx, %rbx
movq %rdi, %r15
movq %r14, %rdi
callq 0xd750
movq %r14, %rdi
movq %rax, %rsi
callq 0xc800
movl $0x11, %ebp
test... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_write_fragment | static ares_status_t ares_uri_write_fragment(const ares_uri_t *uri,
ares_buf_t *buf)
{
ares_status_t status;
if (!ares_strlen(uri->fragment)) {
return ARES_SUCCESS;
}
status = ares_buf_append_byte(buf, '#');
if (status != ARES_SUCCESS) {
return stat... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x138(%rdi), %rdi
callq 0xd750
testq %rax, %rax
je 0x29066
movq %rbx, %rdi
movl $0x23, %esi
callq 0xd770
testl %eax, %eax
jne 0x29068
movq 0x138(%r14), %rsi
leaq 0xd53(%rip), %rdx # 0x29daa
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jm... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_parse_query | static ares_status_t ares_uri_parse_query(ares_uri_t *uri, ares_buf_t *buf)
{
unsigned char b;
ares_status_t status;
ares_buf_t *query = NULL;
size_t len;
if (ares_buf_len(buf) == 0) {
return ARES_SUCCESS;
}
status = ares_buf_peek_byte(buf, &b);
if (status != ARES_SUCCESS) {
return st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x18(%rsp)
movq %rsi, %rdi
callq 0xda10
xorl %r15d, %r15d
testq %rax, %rax
je 0x29a35
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0xc9b0
testl %eax, %eax
je 0x2978d
movl %eax, %r15d
jmp 0x29a35
c... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ares_uri_chis_fragment | static ares_bool_t ares_uri_chis_fragment(char x)
{
switch (x) {
case '/':
return ARES_TRUE;
case '?':
return ARES_TRUE;
default:
break;
}
return ares_uri_chis_path(x);
} | pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %ebx
leal -0x2f(%rdi), %eax
cmpl $0x11, %eax
ja 0x29dcf
movl $0x30801, %ecx # imm = 0x30801
btl %eax, %ecx
jae 0x29dcf
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movsbl %dil, %r14d
movl %r14d, %edi
callq 0x29cbe
testl %eax, %eax
jne 0x29dc5
cmpl $0x3d, ... | /c-ares[P]c-ares/src/lib/util/ares_uri.c |
ClipperLib::Area(ClipperLib::OutPt const*) | double Area(const OutPt *op)
{
const OutPt *startOp = op;
if (!op) return 0;
double a = 0;
do {
a += (double)(op->Prev->Pt.X + op->Pt.X) * (double)(op->Prev->Pt.Y - op->Pt.Y);
op = op->Next;
} while (op != startOp);
return a * 0.5;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x32951
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x329c5
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
a... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::ClearJoins() | void Clipper::ClearJoins()
{
for (JoinList::size_type i = 0; i < m_Joins.size(); i++)
delete m_Joins[i];
m_Joins.resize(0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x2e110
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x38bc9
movq -0x18(%rbp), %r... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::AddJoin(ClipperLib::OutPt*, ClipperLib::OutPt*, ClipperLib::IntPoint) | void Clipper::AddJoin(OutPt *op1, OutPt *op2, const IntPoint OffPt)
{
Join* j = new Join;
j->OutPt1 = op1;
j->OutPt2 = op2;
j->OffPt = OffPt;
m_Joins.push_back(j);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x2f810
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x31770
jmp 0x3987f
movq ... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::DeleteFromSEL(ClipperLib::TEdge*) | void Clipper::DeleteFromSEL(TEdge *e)
{
TEdge* SelPrev = e->PrevInSEL;
TEdge* SelNext = e->NextInSEL;
if( !SelPrev && !SelNext && (e != m_SortedEdges) ) return; //already deleted
if( SelPrev ) SelPrev->NextInSEL = SelNext;
else m_SortedEdges = SelNext;
if( SelNext ) SelNext->PrevInSEL = SelPrev;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x39dad
cmpq $0x0, -0x20(%rbp)
jne 0x39d... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::InsertEdgeIntoAEL(ClipperLib::TEdge*, ClipperLib::TEdge*) | void Clipper::InsertEdgeIntoAEL(TEdge *edge, TEdge* startEdge)
{
if(!m_ActiveEdges)
{
edge->PrevInAEL = 0;
edge->NextInAEL = 0;
m_ActiveEdges = edge;
}
else if(!startEdge && E2InsertsBeforeE1(*m_ActiveEdges, *edge))
{
edge->PrevInAEL = 0;
edge->NextInAEL = m_ActiveEdges;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq $0x0, 0x68(%rax,%rcx)
jne 0x39f7c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq $0x0, 0x70(%rcx)
movq -0x10(%rbp... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::SetHoleState(ClipperLib::TEdge*, ClipperLib::OutRec*) | void Clipper::SetHoleState(TEdge *e, OutRec *outrec)
{
TEdge *e2 = e->PrevInAEL;
TEdge *eTmp = 0;
while (e2)
{
if (e2->OutIdx >= 0 && e2->WindDelta != 0)
{
if (!eTmp) eTmp = e2;
else if (eTmp->OutIdx == e2->OutIdx) eTmp = 0;
}
e2 = e2->PrevInAEL;
}
if (!eTmp)... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3a846
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4c... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::ProcessHorizontal(ClipperLib::TEdge*) | void Clipper::ProcessHorizontal(TEdge *horzEdge)
{
Direction dir;
cInt horzLeft, horzRight;
bool IsOpen = (horzEdge->WindDelta == 0);
GetHorzDirection(*horzEdge, dir, horzLeft, horzRight);
TEdge* eLastHorz = horzEdge, *eMaxPair = 0;
while (eLastHorz->NextInLML && IsHorizontal(*eLastHorz->NextInLM... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x20(%rbp), %rdx... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::SwapPositionsInSEL(ClipperLib::TEdge*, ClipperLib::TEdge*) | void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2)
{
if( !( Edge1->NextInSEL ) && !( Edge1->PrevInSEL ) ) return;
if( !( Edge2->NextInSEL ) && !( Edge2->PrevInSEL ) ) return;
if( Edge1->NextInSEL == Edge2 )
{
TEdge* Next = Edge2->NextInSEL;
if( Next ) Next->PrevInSEL = Edge1;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x3b9a6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3b9a6
jmp 0x3bbf4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x3b9... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::DisposeIntersectNodes() | void Clipper::DisposeIntersectNodes()
{
for (size_t i = 0; i < m_IntersectList.size(); ++i )
delete m_IntersectList[i];
m_IntersectList.clear();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x300e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c1c9
movq -0x18(%rbp), %... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::Clipper::FixupFirstLefts1(ClipperLib::OutRec*, ClipperLib::OutRec*) | void Clipper::FixupFirstLefts1(OutRec* OldOutRec, OutRec* NewOutRec)
{
//tests if NewOutRec contains the polygon before reassigning FirstLeft
for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
{
OutRec* outRec = m_PolyOuts[i];
OutRec* firstLeft = ParseFirstLeft(outRec->FirstLeft);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
addq $0x50, %rdi
callq 0x2e210... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
ClipperLib::ClipperOffset::DoSquare(int, int) | void ClipperOffset::DoSquare(int j, int k)
{
double dx = std::tan(std::atan2(m_sinA,
m_normals[k].X * m_normals[j].X + m_normals[k].Y * m_normals[j].Y) / 4);
m_destPoly.push_back(IntPoint(
Round(m_srcPoly[j].X + m_delta * (m_normals[k].X - m_normals[k].Y * dx)),
Round(m_srcPoly[j].Y + m_delt... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movsd 0x78(%rdi), %xmm0
movsd %xmm0, -0xc8(%rbp)
addq $0x58, %rdi
movslq -0x10(%rbp), %rsi
callq 0x2e070
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x... | /apicici[P]clipper-luajit-ffi/src/clipper/clipper.cpp |
libyuv::ScalePlaneSimple_16(int, int, int, int, int, int, unsigned short const*, unsigned short*) | static void ScalePlaneSimple_16(int src_width,
int src_height,
int dst_width,
int dst_height,
int src_stride,
int dst_stride,
co... | subq $0x58, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movl %r9d, 0x40(%rsp)
leaq 0x3b11(%rip), %rax # 0x69d80
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
I420Scale_16 | LIBYUV_API
int I420Scale_16(const uint16_t* src_y,
int src_stride_y,
const uint16_t* src_u,
int src_stride_u,
const uint16_t* src_v,
int src_stride_v,
int src_width,
int src_height,
ui... | subq $0x78, %rsp
movl 0xd0(%rsp), %eax
movl 0xc8(%rsp), %eax
movl 0xc0(%rsp), %eax
movl 0xb8(%rsp), %eax
movq 0xb0(%rsp), %rax
movl 0xa8(%rsp), %eax
movq 0xa0(%rsp), %rax
movl 0x98(%rsp), %eax
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movl 0x80(%rsp), %eax
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
I444Scale | LIBYUV_API
int I444Scale(const uint8_t* src_y,
int src_stride_y,
const uint8_t* src_u,
int src_stride_u,
const uint8_t* src_v,
int src_stride_v,
int src_width,
int src_height,
uint8_t* dst_y,
in... | subq $0x58, %rsp
movl 0xb0(%rsp), %eax
movl 0xa8(%rsp), %eax
movl 0xa0(%rsp), %eax
movl 0x98(%rsp), %eax
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
I444Scale_16 | LIBYUV_API
int I444Scale_16(const uint16_t* src_y,
int src_stride_y,
const uint16_t* src_u,
int src_stride_u,
const uint16_t* src_v,
int src_stride_v,
int src_width,
int src_height,
ui... | subq $0x58, %rsp
movl 0xb0(%rsp), %eax
movl 0xa8(%rsp), %eax
movl 0xa0(%rsp), %eax
movl 0x98(%rsp), %eax
movq 0x90(%rsp), %rax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movl 0x68(%rsp), %eax
movl 0x60(%rsp), %eax
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
NV12Scale | LIBYUV_API
int NV12Scale(const uint8_t* src_y,
int src_stride_y,
const uint8_t* src_uv,
int src_stride_uv,
int src_width,
int src_height,
uint8_t* dst_y,
int dst_stride_y,
uint8_t* dst_uv,
int d... | subq $0x68, %rsp
movl 0xa0(%rsp), %eax
movl 0x98(%rsp), %eax
movl 0x90(%rsp), %eax
movl 0x88(%rsp), %eax
movq 0x80(%rsp), %rax
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl %r8d, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
cmpl $0x0, 0x40(%... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
libyuv::ScaleAddCols2_C(int, int, int, int, unsigned short const*, unsigned char*) | static void ScaleAddCols2_C(int dst_width,
int boxheight,
int x,
int dx,
const uint16_t* src_ptr,
uint8_t* dst_ptr) {
int i;
int scaletbl[2];
int minboxwidth = dx >> 16;
in... | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl 0x38(%rsp), %eax
sarl $0x10, %eax
movl %eax, 0x18(%rsp)
cmpl $0x1, 0x18(%rsp)
jge 0x670ab
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x670b3
movl 0x18(%rsp), %eax
movl %e... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
libyuv::ScaleAddCols1_C(int, int, int, int, unsigned short const*, unsigned char*) | static void ScaleAddCols1_C(int dst_width,
int boxheight,
int x,
int dx,
const uint16_t* src_ptr,
uint8_t* dst_ptr) {
int boxwidth = MIN1(dx >> 16);
int scaleval = 65536 / (box... | subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movl 0x28(%rsp), %eax
sarl $0x10, %eax
cmpl $0x1, %eax
jge 0x671f5
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x67200
movl 0x28(%rsp), %eax
sarl $0x10, %eax
movl %eax, 0x8(%rs... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
libyuv::ScaleAddCols0_C(int, int, int, int, unsigned short const*, unsigned char*) | static void ScaleAddCols0_C(int dst_width,
int boxheight,
int x,
int dx,
const uint16_t* src_ptr,
uint8_t* dst_ptr) {
int scaleval = 65536 / boxheight;
int i;
(void)dx;
src... | movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movl %ecx, -0x10(%rsp)
movq %r8, -0x18(%rsp)
movq %r9, -0x20(%rsp)
movl $0x10000, %eax # imm = 0x10000
cltd
idivl -0x8(%rsp)
movl %eax, -0x24(%rsp)
movl -0xc(%rsp), %ecx
sarl $0x10, %ecx
movq -0x18(%rsp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %r... | /m-ab-s[P]aom/third_party/libyuv/source/scale.cc |
decoder_get_frame | static aom_image_t *decoder_get_frame(aom_codec_alg_priv_t *ctx,
aom_codec_iter_t *iter) {
aom_image_t *img = NULL;
if (!iter) {
return NULL;
}
// To avoid having to allocate any extra storage, treat 'iter' as
// simply a pointer to an integer index
uintptr_t *ind... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq $0x0, 0xa8(%rsp)
cmpq $0x0, 0xb0(%rsp)
jne 0xa2acf
movq $0x0, 0xc0(%rsp)
jmp 0xa326b
movq 0xb0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xb8(%rsp), %rax
cmpq $0x0, 0x69f0(%rax)
jne 0xa2b02
movq $0x0, 0xc0(%rsp)
jmp 0xa326b
callq 0x5ae270
movq %rax, 0x98(%r... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_set_inspection_callback | static aom_codec_err_t ctrl_set_inspection_callback(aom_codec_alg_priv_t *ctx,
va_list args) {
#if !CONFIG_INSPECTION
(void)ctx;
(void)args;
return AOM_CODEC_INCAPABLE;
#else
aom_inspect_init *init = va_arg(args, aom_inspect_init *);
ctx->inspect_cb = init->... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x4, %eax
retq
| /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_set_skip_film_grain | static aom_codec_err_t ctrl_set_skip_film_grain(aom_codec_alg_priv_t *ctx,
va_list args) {
ctx->skip_film_grain = va_arg(args, int);
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_worker_data = (FrameWorkerD... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movl (%rax), %eax
movl %eax, -0x24(%rsp)
cmpl $0x28, %eax
ja 0xa3fab
movq -0x30(%rsp), %rcx
movl -0x24(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rsp)
jmp 0xa3fc4
movq ... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_frame_corrupted | static aom_codec_err_t ctrl_get_frame_corrupted(aom_codec_alg_priv_t *ctx,
va_list args) {
int *corrupted = va_arg(args, int *);
if (corrupted) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_worker... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa405b
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa4074
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_img_format | static aom_codec_err_t ctrl_get_img_format(aom_codec_alg_priv_t *ctx,
va_list args) {
aom_img_fmt_t *const img_fmt = va_arg(args, aom_img_fmt_t *);
AVxWorker *const worker = ctx->frame_worker;
if (img_fmt) {
if (worker) {
FrameWorkerData *const frame_worker_da... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x28, %eax
ja 0xa43ef
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x8(%rsp)
jmp 0xa4... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_tile_count | static aom_codec_err_t ctrl_get_tile_count(aom_codec_alg_priv_t *ctx,
va_list args) {
unsigned int *const tile_count = va_arg(args, unsigned int *);
if (tile_count) {
AVxWorker *const worker = ctx->frame_worker;
if (worker) {
FrameWorkerData *const frame_wor... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x40(%rsp)
movl (%rax), %eax
movl %eax, -0x34(%rsp)
cmpl $0x28, %eax
ja 0xa460b
movq -0x40(%rsp), %rcx
movl -0x34(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x48(%rsp)
jmp 0xa4624
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
ctrl_get_render_size | static aom_codec_err_t ctrl_get_render_size(aom_codec_alg_priv_t *ctx,
va_list args) {
int *const render_size = va_arg(args, int *);
if (render_size) {
if (ctx->frame_worker) {
AVxWorker *const worker = ctx->frame_worker;
FrameWorkerData *const frame_work... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x48(%rsp)
movl (%rax), %eax
movl %eax, -0x3c(%rsp)
cmpl $0x28, %eax
ja 0xa46db
movq -0x48(%rsp), %rcx
movl -0x3c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rsp)
jmp 0xa46f4
movq... | /m-ab-s[P]aom/av1/av1_dx_iface.c |
av1_free_mc_tmp_buf | void av1_free_mc_tmp_buf(ThreadData *thread_data) {
int ref;
for (ref = 0; ref < 2; ref++) {
if (thread_data->mc_buf_use_highbd)
aom_free(CONVERT_TO_SHORTPTR(thread_data->mc_buf[ref]));
else
aom_free(thread_data->mc_buf[ref]);
thread_data->mc_buf[ref] = NULL;
}
thread_data->mc_buf_size =... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
jge 0xa7e4c
movq 0x10(%rsp), %rax
cmpl $0x0, 0x3eb84(%rax)
je 0xa7e12
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x3eb68(%rax,%rcx,8), %rdi
shlq %rdi
callq 0xa1fc0
jmp 0xa7e29
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq 0x3eb6... | /m-ab-s[P]aom/av1/decoder/decodeframe.c |
get_dec_job_info | static TileJobsDec *get_dec_job_info(AV1DecTileMT *tile_mt_info) {
TileJobsDec *cur_job_info = NULL;
#if CONFIG_MULTITHREAD
pthread_mutex_lock(tile_mt_info->job_mutex);
if (tile_mt_info->jobs_dequeued < tile_mt_info->jobs_enqueued) {
cur_job_info = tile_mt_info->job_queue + tile_mt_info->jobs_dequeued;
t... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x18720
movq 0x10(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xb397d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x4, %rcx
a... | /m-ab-s[P]aom/av1/decoder/decodeframe.c |
av1_tpl_preload_rc_estimate | void av1_tpl_preload_rc_estimate(AV1_COMP *cpi,
const EncodeFrameParams *const frame_params) {
AV1_COMMON *cm = &cpi->common;
GF_GROUP *gf_group = &cpi->ppi->gf_group;
int bottom_index, top_index;
if (cpi->use_ducky_encode) return;
cm->current_frame.frame_type = frame_params-... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x3bf80, %rax # imm = 0x3BF80
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq $0x190, %rax # imm = 0x190
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x9d658(%rax)
je 0x222184
jmp 0x... | /m-ab-s[P]aom/av1/encoder/tpl_model.c |
is_alike_mv | static int is_alike_mv(int_mv candidate_mv, center_mv_t *center_mvs,
int center_mvs_count, int skip_alike_starting_mv) {
// MV difference threshold is in 1/8 precision.
const int mv_diff_thr[3] = { 1, (8 << 3), (16 << 3) };
int thr = mv_diff_thr[skip_alike_starting_mv];
int i;
for (i =... | movl %edi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq 0x896da0(%rip), %rax # 0xabdda8
movq %rax, -0x24(%rsp)
movl 0x896d9d(%rip), %eax # 0xabddb0
movl %eax, -0x1c(%rsp)
movslq -0x18(%rsp), %rax
movl -0x24(%rsp,%rax,4), %eax
movl %eax, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
mo... | /m-ab-s[P]aom/av1/encoder/tpl_model.c |
is_noise_model_different | static int is_noise_model_different(aom_noise_model_t *const noise_model) {
// These thresholds are kind of arbitrary and will likely need further tuning
// (or exported as parameters). The threshold on noise strength is a weighted
// difference between the noise strength histograms
const double kCoeffThreshold... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movsd 0x7d55af(%rip), %xmm0 # 0xa8fef0
movsd %xmm0, 0x60(%rsp)
movq 0x68(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x8, %ecx
movl $0x1, %eax
shll %cl, %eax
cvtsi2sd %eax, %xmm1
movsd 0x7fb943(%rip), %xmm0 # 0xab62a8
mulsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movl $0x0, 0x54(%rsp)... | /m-ab-s[P]aom/aom_dsp/noise_model.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.