name string | code string | asm string | file string |
|---|---|---|---|
curl_easy_setopt | CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
{
va_list arg;
CURLcode result;
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
va_start(arg, tag);
result = Curl_vsetopt(data, tag, arg);
va_end(arg);
#ifdef DEBUGBUILD
if(result == CURLE_BAD_FUNCTION_ARGUMENT)
infof(data, "... | subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x525db
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0x... | /Unity-Technologies[P]curl/lib/setopt.c |
curl_share_cleanup | CURLSHcode
curl_share_cleanup(struct Curl_share *share)
{
if(!GOOD_SHARE_HANDLE(share))
return CURLSHE_INVALID;
if(share->lockfunc)
share->lockfunc(NULL, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE,
share->clientdata);
if(share->dirty) {
if(share->unlockfunc)
share->unloc... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x3, %ebp
testq %rdi, %rdi
je 0x52b8a
movq %rdi, %rbx
cmpl $0x7e117a1e, (%rdi) # imm = 0x7E117A1E
jne 0x52b8a
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x52aa9
movq 0x20(%rbx), %rcx
xorl %edi, %edi
movl $0x1, %esi
movl $0x2, %edx
callq *%rax
cmpl $0x0, 0x... | /Unity-Technologies[P]curl/lib/share.c |
Curl_share_lock | CURLSHcode
Curl_share_lock(struct Curl_easy *data, curl_lock_data type,
curl_lock_access accesstype)
{
struct Curl_share *share = data->share;
if(!share)
return CURLSHE_INVALID;
if(share->specifier & (unsigned int)(1<<type)) {
if(share->lockfunc) /* only call this if set! */
share-... | pushq %rbx
movq 0xe0(%rdi), %rax
testq %rax, %rax
je 0x52bc0
movl 0x4(%rax), %ecx
xorl %ebx, %ebx
btl %esi, %ecx
jae 0x52bc5
movq 0x10(%rax), %r8
testq %r8, %r8
je 0x52bc5
movq 0x20(%rax), %rcx
callq *%r8
jmp 0x52bc5
movl $0x3, %ebx
movl %ebx, %eax
popq %rbx
retq
| /Unity-Technologies[P]curl/lib/share.c |
Curl_share_unlock | CURLSHcode
Curl_share_unlock(struct Curl_easy *data, curl_lock_data type)
{
struct Curl_share *share = data->share;
if(!share)
return CURLSHE_INVALID;
if(share->specifier & (unsigned int)(1<<type)) {
if(share->unlockfunc) /* only call this if set! */
share->unlockfunc (data, type, share->clientdat... | pushq %rbx
movq 0xe0(%rdi), %rax
testq %rax, %rax
je 0x52bf1
movl 0x4(%rax), %ecx
xorl %ebx, %ebx
btl %esi, %ecx
jae 0x52bf6
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x52bf6
movq 0x20(%rax), %rdx
callq *%rcx
jmp 0x52bf6
movl $0x3, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
| /Unity-Technologies[P]curl/lib/share.c |
curl_slist_free_all | void curl_slist_free_all(struct curl_slist *list)
{
struct curl_slist *next;
struct curl_slist *item;
if(!list)
return;
item = list;
do {
next = item->next;
Curl_safefree(item->data);
free(item);
item = next;
} while(next);
} | testq %rdi, %rdi
je 0x52d6d
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4231f(%rip), %r14 # 0x95068
movq (%rbx), %rdi
movq 0x8(%rbx), %r15
callq *(%r14)
movq $0x0, (%rbx)
movq %rbx, %rdi
callq *(%r14)
movq %r15, %rbx
testq %r15, %r15
jne 0x52d49
popq %rbx
popq %r14
popq %r15
retq
nop
| /Unity-Technologies[P]curl/lib/slist.c |
smb_connect | static CURLcode smb_connect(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
char *slash;
(void) done;
/* Check we have a username and password to authenticate with */
if(!data->state.aptr.user)
return CURLE_LOGIN_DENIED;
/* Ini... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x1370(%rdi)
je 0x52f74
movq 0x18(%rdi), %r14
movl $0x1, 0x440(%r14)
leaq 0x42187(%rip), %r15 # 0x95060
movl $0x9000, %edi # imm = 0x9000
callq *(%r15)
movq %rax, 0x470(%r14)
movl $0x1b, %ebx
testq %rax, %rax
je 0x52f79
movl $0x9000, %edi ... | /Unity-Technologies[P]curl/lib/smb.c |
smb_connection_state | static CURLcode smb_connection_state(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_conn *smbc = &conn->proto.smbc;
struct smb_negotiate_response *nrsp;
struct smb_header *h;
CURLcode result;
void *msg = NULL;
if(smbc->state == SMB_CONNECTING) {
#ifdef USE_SSL
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rbx
movq $0x0, 0x10(%rsp)
cmpl $0x1, 0x440(%rbx)
jne 0x5303c
movq 0x3c0(%rbx), %rax
testb $0x1, 0x94(%rax)
je 0x5300d
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
xorl... | /Unity-Technologies[P]curl/lib/smb.c |
smb_request_state | static CURLcode smb_request_state(struct Curl_easy *data, bool *done)
{
struct connectdata *conn = data->conn;
struct smb_request *req = data->req.p.smb;
struct smb_header *h;
struct smb_conn *smbc = &conn->proto.smbc;
enum smb_req_state next_state = SMB_DONE;
unsigned short len;
unsigned short off;
CUR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %r13
movq 0x1b8(%rdi), %rbx
movq $0x0, 0x8(%rsp)
testb $0x2, 0x139e(%rdi)
je 0x53181
cmpq $0x0, 0x11d8(%r14)
js 0x53248
cmpl $0x0, (%rbx)
je 0x531f9
leaq 0x8(%rsp... | /Unity-Technologies[P]curl/lib/smb.c |
smb_disconnect | static CURLcode smb_disconnect(struct Curl_easy *data,
struct connectdata *conn, bool dead)
{
struct smb_conn *smbc = &conn->proto.smbc;
(void) dead;
(void) data;
Curl_safefree(smbc->share);
Curl_safefree(smbc->domain);
Curl_safefree(smbc->recv_buf);
Curl_safefree(smbc->send... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x41825(%rip), %r14 # 0x95068
movq 0x458(%rsi), %rdi
callq *(%r14)
xorl %r15d, %r15d
movq %r15, 0x458(%rbx)
movq 0x450(%rbx), %rdi
callq *(%r14)
movq %r15, 0x450(%rbx)
movq 0x470(%rbx), %rdi
callq *(%r14)
movq %r15, 0x470(%rbx)
movq 0x478(%rbx), %rdi
callq *(%r1... | /Unity-Technologies[P]curl/lib/smb.c |
smtp_do | static CURLcode smtp_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
*done = FALSE; /* default to false */
/* Parse the custom request */
result = smtp_parse_custom_request(data);
if(result)
return result;
result = smtp_regular_trans... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rsi)
movq 0x830(%rdi), %rdi
testq %rdi, %rdi
je 0x53df3
movq 0x1b8(%rbx), %rdx
addq $0x8, %rdx
xorl %esi, %esi
xorl %ecx, %ecx
movl $0x3, %r8d
callq 0x2566b
movl %eax, %ebp
testl %eax, %eax
jn... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_done | static CURLcode smtp_done(struct Curl_easy *data, CURLcode status,
bool premature)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct SMTP *smtp = data->req.p.smtp;
(void)premature;
if(!smtp)
return CURLE_OK;
/* Cleanup our per-request based variable... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x1b8(%rdi), %rbp
testq %rbp, %rbp
je 0x5449e
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r14
movq 0x18(%rdi), %r12
leaq 0x40beb(%rip), %rax # 0x95068
movq 0x8(%rbp), %rdi
callq *(%rax)
movq $0x0, 0x8(%rbp)
testl %ebx, %ebx
je 0x544a... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_connect | static CURLcode smtp_connect(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct smtp_conn *smtpc = &conn->proto.smtpc;
struct pingpong *pp = &smtpc->pp;
*done = FALSE; /* default to not done yet */
/* We always support persistent connections in ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdi, %r14
movq 0x18(%rdi), %r12
leaq 0x440(%r12), %r13
movq %rsi, 0x8(%rsp)
movb $0x0, (%rsi)
movq %r12, %rdi
xorl %esi, %esi
callq 0x1ae25
movq $0x1d4c0, 0x478(%r12) # imm = 0x1D4C0
leaq 0x36a(%rip), %rax... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_doing | static CURLcode smtp_doing(struct Curl_easy *data, bool *dophase_done)
{
CURLcode result = smtp_multi_statemach(data, dophase_done);
if(result)
DEBUGF(infof(data, "DO phase failed"));
else if(*dophase_done) {
result = smtp_dophase_done(data, FALSE /* not connected */);
DEBUGF(infof(data, "DO phase i... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x5471f
movl %eax, %ebx
testl %eax, %eax
jne 0x547e9
cmpb $0x1, (%r15)
jne 0x547e9
movq 0x1b8(%r14), %rax
cmpl $0x0, (%rax)
je 0x547ee
movq %r14, %rdi
callq 0x5c44e
jmp 0x547ee
testq %r14, %r14
je 0x5482e
testb $0x10, 0xa9d(%r14)
je 0x5482e
movq 0x1... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_endofresp | static bool smtp_endofresp(struct Curl_easy *data, struct connectdata *conn,
char *line, size_t len, int *resp)
{
struct smtp_conn *smtpc = &conn->proto.smtpc;
bool result = FALSE;
(void)data;
/* Nothing for us */
if(len < 4 || !ISDIGIT(line[0]) || !ISDIGIT(line[1]) || !ISDIGIT(lin... | cmpq $0x4, %rcx
jae 0x55040
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movb (%rdx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x55109
movb 0x1(%r14), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x55109
movb 0x2(%r14), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x551... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_state | static void smtp_state(struct Curl_easy *data, smtpstate newstate)
{
struct smtp_conn *smtpc = &data->conn->proto.smtpc;
#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
/* for debug purposes */
static const char * const names[] = {
"STOP",
"SERVERGREET",
"EHLO",
"HELO",
"STARTTLS",
"UPGRADETLS"... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x18(%rdi), %r14
movl 0x500(%r14), %eax
cmpl %esi, %eax
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x55180
testb $0x10, 0xa9d(%rdi)
je 0x55180
movq 0x1320(%rdi), %rcx
testq %rcx, %rcx
je 0x55154
cmpl $0x0, 0x8(%rcx)
jle 0x55180
leaq 0x3feb5(%rip), %rcx ... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_perform_ehlo | static CURLcode smtp_perform_ehlo(struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct smtp_conn *smtpc = &conn->proto.smtpc;
smtpc->sasl.authmechs = SASL_AUTH_NONE; /* No known auth. mechanism yet */
smtpc->sasl.authused = SASL_AUTH_NONE; /* Clear the authenti... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x440(%rax), %rsi
xorl %ecx, %ecx
movw %cx, 0x4f8(%rax)
movw %cx, 0x4fc(%rax)
andb $-0x13, 0x510(%rax)
movq 0x508(%rax), %rcx
leaq 0x22466(%rip), %rdx # 0x776cf
xorl %eax, %eax
callq 0x47887
movl %eax, %ebp
testl %eax, %eax
jne 0x55283
movq... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_perform_starttls | static CURLcode smtp_perform_starttls(struct Curl_easy *data,
struct connectdata *conn)
{
/* Send the STARTTLS command */
CURLcode result = Curl_pp_sendf(data, &conn->proto.smtpc.pp,
"%s", "STARTTLS");
if(!result)
smtp_state(data, SMTP_S... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x440, %rsi # imm = 0x440
leaq 0x1b4d0(%rip), %rdx # 0x70770
leaq 0x1f7e4(%rip), %rcx # 0x74a8b
xorl %eax, %eax
callq 0x47887
movl %eax, %ebp
testl %eax, %eax
jne 0x552c1
movq %rbx, %rdi
movl $0x4, %esi
callq 0x55119
movl %ebp, %eax
addq $0x8, %r... | /Unity-Technologies[P]curl/lib/smtp.c |
smtp_parse_address | static CURLcode smtp_parse_address(const char *fqma, char **address,
struct hostname *host)
{
CURLcode result = CURLE_OK;
size_t length;
/* Duplicate the fully qualified email address so we can manipulate it,
ensuring it does not contain the delimiters if specified */
ch... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x3fb1e(%rip), %rax # 0x95078
xorl %ecx, %ecx
cmpb $0x3c, (%rdi)
sete %cl
addq %rcx, %rdi
callq *(%rax)
testq %rax, %rax
je 0x555b6
movq %rax, %r15
movq %rax, %rdi
callq 0xf4b0
testq %rax, %rax
je 0x5558a
cmpb $0x3e, -0x1(%r15,%rax)
jne 0x5558a
m... | /Unity-Technologies[P]curl/lib/smtp.c |
cr_eob_read | static CURLcode cr_eob_read(struct Curl_easy *data,
struct Curl_creader *reader,
char *buf, size_t blen,
size_t *pnread, bool *peos)
{
struct cr_eob_ctx *ctx = reader->ctx;
CURLcode result = CURLE_OK;
size_t nread, i, start, n;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, %r12
movq 0x10(%rsi), %r14
testb $0x1, 0x70(%r14)
jne 0x55a13
movq %rsi, %r15
movq %rdi, %r13
leaq 0x20(%r14), %rbp
movq %rbp, %rdi
callq 0x12403
testb %al, %al
je 0x55... | /Unity-Technologies[P]curl/lib/smtp.c |
Curl_socketpair | int Curl_socketpair(int domain, int type, int protocol,
curl_socket_t socks[2], bool nonblocking)
{
#ifdef SOCK_NONBLOCK
type = nonblocking ? type | SOCK_NONBLOCK : type;
#endif
if(socketpair(domain, type, protocol, socks))
return -1;
#ifndef SOCK_NONBLOCK
if(nonblocking) {
if(curlx_no... | pushq %rax
movl %esi, %eax
orl $0x800, %eax # imm = 0x800
testl %r8d, %r8d
cmovnel %eax, %esi
callq 0xfa40
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
| /Unity-Technologies[P]curl/lib/socketpair.c |
curl_multi_strerror | const char *
curl_multi_strerror(CURLMcode error)
{
#ifndef CURL_DISABLE_VERBOSE_STRINGS
switch(error) {
case CURLM_CALL_MULTI_PERFORM:
return "Please call curl_multi_perform() soon";
case CURLM_OK:
return "No error";
case CURLM_BAD_HANDLE:
return "Invalid multi handle";
case CURLM_BAD_EASY_HAN... | incl %edi
cmpl $0xd, %edi
ja 0x57af6
movl %edi, %eax
leaq 0x21c66(%rip), %rcx # 0x79754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x215ce(%rip), %rax # 0x790cb
retq
| /Unity-Technologies[P]curl/lib/strerror.c |
Curl_now | struct curltime Curl_now(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
** clock drifting and external source time synchronization it can jump
** forward or backward in time.
*/
struct timeval now;
struct curltime ret;
(void)gettimeofday(&now, NULL);
ret.tv_sec = now... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movl $0x4, %edi
movq %rbx, %rsi
callq 0xfaa0
testl %eax, %eax
je 0x5b1b2
movq %rsp, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0xfaa0
testl %eax, %eax
je 0x5b1b2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10270
movq 0x8(%rbx), %rdx
jmp 0x5b1cf
movabsq $0x20... | /Unity-Technologies[P]curl/lib/timeval.c |
Curl_follow | CURLcode Curl_follow(struct Curl_easy *data,
char *newurl, /* the Location: string */
followtype type) /* see transfer.h */
{
#ifdef CURL_DISABLE_HTTP
(void)data;
(void)newurl;
(void)type;
/* Location: following will not happen when HTTP is disabled */
return CURLE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movl $0x1, %ebp
cmpl $0x1, %edx
jne 0x5bd0e
xorl %r15d, %r15d
jmp 0x5be7a
incl 0xce0(%rbx)
cmpl $0x2, %edx
je 0x5be57
cmpl $0x3, %edx
jne 0x5be75
movq 0x218(%rbx), %rcx
cmpq $-0x1, %rcx
sete %dl
movq ... | /Unity-Technologies[P]curl/lib/transfer.c |
Curl_retry_request | CURLcode Curl_retry_request(struct Curl_easy *data, char **url)
{
struct connectdata *conn = data->conn;
bool retry = FALSE;
*url = NULL;
/* if we are talking upload, we cannot do the checks below, unless the
protocol is HTTP as when uploading over HTTP we will still get a
response */
if(data->stat... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq $0x0, (%rsi)
movl 0x139c(%rdi), %eax
btl $0x11, %eax
jae 0x5c311
movq 0x3c0(%r14), %rcx
testl $0x40003, 0x8c(%rcx) # imm = 0x40003
je 0x5c3d0
movl 0x120(%rbx), %ecx
xorl %ebp, %ebp
addq 0x100(%rbx), %rcx... | /Unity-Technologies[P]curl/lib/transfer.c |
Curl_xfer_write_resp | CURLcode Curl_xfer_write_resp(struct Curl_easy *data,
const char *buf, size_t blen,
bool is_eos)
{
CURLcode result = CURLE_OK;
if(data->conn->handler->write_resp) {
/* protocol handlers offering this function take full responsibility
* for writin... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x3c0(%rax), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0x5c62d
movzbl %bpl, %ecx
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq *%rax
jmp 0x5c653
testq %rbx, %rbx... | /Unity-Technologies[P]curl/lib/transfer.c |
Curl_xfer_recv | CURLcode Curl_xfer_recv(struct Curl_easy *data,
char *buf, size_t blen,
ssize_t *pnrcvd)
{
int sockindex;
DEBUGASSERT(data);
DEBUGASSERT(data->conn);
DEBUGASSERT(data->set.buffer_size > 0);
sockindex = ((data->conn->sockfd != CURL_SOCKET_BAD) &&
... | movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x18(%rdi), %rax
movl 0x3e0(%rax), %r9d
xorl %esi, %esi
cmpl $-0x1, %r9d
je 0x5c7bc
cmpl 0x23c(%rax), %r9d
sete %sil
movl 0x6fc(%rdi), %eax
cmpq %rcx, %rax
cmovbq %rax, %rcx
jmp 0x18aa8
| /Unity-Technologies[P]curl/lib/transfer.c |
Curl_xfer_is_blocked | bool Curl_xfer_is_blocked(struct Curl_easy *data)
{
bool want_send = ((data)->req.keepon & KEEP_SEND);
bool want_recv = ((data)->req.keepon & KEEP_RECV);
if(!want_send)
return (want_recv && Curl_cwriter_is_paused(data));
else if(!want_recv)
return (want_send && Curl_creader_is_paused(data));
else
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %eax
testb $0x2, %al
jne 0x5c7f0
testb $0x1, %al
jne 0x5c816
xorl %ebp, %ebp
jmp 0x5c80d
testb $0x1, %al
sete %bpl
movq %rbx, %rdi
callq 0x4cb68
movl %eax, %ecx
notb %cl
orb %bpl, %cl
testb $0x1, %cl
je 0x5c816
andb %al, %bpl
movl %ebp, %eax
addq $0x8, ... | /Unity-Technologies[P]curl/lib/transfer.c |
up_free | static void up_free(struct Curl_easy *data)
{
struct urlpieces *up = &data->state.up;
Curl_safefree(up->scheme);
Curl_safefree(up->hostname);
Curl_safefree(up->port);
Curl_safefree(up->user);
Curl_safefree(up->password);
Curl_safefree(up->options);
Curl_safefree(up->path);
Curl_safefree(up->query);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3844b(%rip), %r15 # 0x95068
movq 0x11f8(%rdi), %rdi
callq *(%r15)
xorl %r14d, %r14d
movq %r14, 0x11f8(%rbx)
movq 0x1200(%rbx), %rdi
callq *(%r15)
movq %r14, 0x1200(%rbx)
movq 0x1208(%rbx), %rdi
callq *(%r15)
movq %r14, 0x1208(%rbx)
movq 0x1210(%rbx), %rdi
call... | /Unity-Technologies[P]curl/lib/url.c |
Curl_parse_login_details | CURLcode Curl_parse_login_details(const char *login, const size_t len,
char **userp, char **passwdp,
char **optionsp)
{
char *ubuf = NULL;
char *pbuf = NULL;
const char *psep = NULL;
const char *osep = NULL;
size_t ulen;
size_t plen;
size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movl $0x3a, %esi
movq %rbx, %rdx
callq 0xfd10
movq %rax, %r13
testq %r14, %r14
je 0x5d67e
movq %rbp, %rdi
movl $0x3b, %esi
movq %rbx, %rdx
callq 0xfd10... | /Unity-Technologies[P]curl/lib/url.c |
Curl_setup_conn | CURLcode Curl_setup_conn(struct Curl_easy *data,
bool *protocol_done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
Curl_pgrsTime(data, TIMER_NAMELOOKUP);
if(conn->handler->flags & PROTOPT_NONETWORK) {
/* nothing to setup when not using a network */
*pro... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
movl $0x4, %esi
callq 0x494fa
movq 0x3c0(%r15), %rax
testb $0x10, 0x94(%rax)
jne 0x5d7f8
callq 0x5b170
movq %rax, 0x208(%r15)
movl %edx, 0x210(%r15)
testb $0x40, 0x3b8(%r15)
jne 0x5d7ec
movq 0x48(%r15), %rcx
xor... | /Unity-Technologies[P]curl/lib/url.c |
ConnectionExists | static bool
ConnectionExists(struct Curl_easy *data,
struct connectdata *needle,
struct connectdata **usethis,
bool *force_reuse,
bool *waitpipe)
{
struct url_conn_match match;
bool result;
memset(&match, 0, sizeof(match));
match.data = data;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x3c0(%rsi), %rax
testb $0x3, 0x8c(%rax)
je 0... | /Unity-Technologies[P]curl/lib/url.c |
resolve_server | static CURLcode resolve_server(struct Curl_easy *data,
struct connectdata *conn,
bool *async)
{
struct hostname *ehost;
timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
const char *peertype = "host";
int rc;
#ifdef USE_UNIX_SOCKETS
char *un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorl %esi, %esi
movl $0x1, %edx
callq 0x1aa7c
movq 0x558(%r14), %r13
testq %r13, %r13
je 0x5fd7c
movb $0x6, 0x582(%r14)
movb $0x0, 0xf(%rsp)
leaq 0x35353(%rip), %rax # 0x95080
movl $0x1... | /Unity-Technologies[P]curl/lib/url.c |
findprotocol | static CURLcode findprotocol(struct Curl_easy *data,
struct connectdata *conn,
const char *protostr)
{
const struct Curl_handler *p = Curl_get_scheme_handler(protostr);
if(p && /* Protocol found in table. Check if allowed */
(data->set.allowed_protocol... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0xf4b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d591
testq %rax, %rax
je 0x6006e
movl 0x8c(%rax), %edx
leaq 0x1a67f(%rip), %rcx # 0x7a6bf
testl %edx, 0x9e4(%r14)
je 0x60075
testb $0x2, 0x139c(%r14)
je 0x6005c
test... | /Unity-Technologies[P]curl/lib/url.c |
urlencode_str | static CURLUcode urlencode_str(struct dynbuf *o, const char *url,
size_t len, bool relative,
bool query)
{
/* we must add this with whitespace-replacing */
bool left = !query;
const unsigned char *iptr;
const unsigned char *host_sep = (const unsigned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %r13
testl %ecx, %ecx
jne 0x61f90
leaq 0x1ac90(%rip), %rsi # 0x7cbc0
movq %r15, %rdi
callq 0xf210
leaq 0x2(%rax), %rbp
testq %rax, %rax
cmoveq %r15, %rbp
movq %rbp,... | /Unity-Technologies[P]curl/lib/urlapi.c |
concat_url | static CURLcode concat_url(char *base, const char *relurl, char **newurl)
{
/***
TRY to append this new path to the old URL
to the right of the host part. Oh crap, this is doomed to cause
problems in the future...
*/
struct dynbuf newest;
char *protsep;
char *pathsep;
bool host_changed = FALSE;
c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rdx)
leaq 0x19bfc(%rip), %rsi # 0x7cbc0
callq 0xf210
leaq 0x2(%rax), %r12
testq %rax, %rax
cmoveq %r15, %r12
movb (%r14), %bpl
cmpb $0x2f, %bpl
movq %rbx, 0x10(%rsp)
jne 0x... | /Unity-Technologies[P]curl/lib/urlapi.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /Unity-Technologies[P]curl/lib/warnless.c |
curl_ws_recv | CURL_EXTERN CURLcode curl_ws_recv(CURL *curl, void *buffer, size_t buflen,
size_t *nread,
const struct curl_ws_frame **metap)
{
(void)curl;
(void)buffer;
(void)buflen;
(void)nread;
(void)metap;
return CURLE_NOT_BUILT_IN;
} | movl $0x4, %eax
retq
| /Unity-Technologies[P]curl/lib/ws.c |
Curl_auth_create_cram_md5_message | CURLcode Curl_auth_create_cram_md5_message(const struct bufref *chlg,
const char *userp,
const char *passwdp,
struct bufref *out)
{
struct HMAC_context *ctxt;
unsigned char digest[MD5_DIG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0xf4b0
movq %rax, %rdi
callq 0x6384a
leaq 0x2ed4b(%rip), %rdi # 0x92790
movq %r12, %rsi
movl %eax, %edx
callq 0x2f5bc
movq %rax, %r12
movl $0x1b, %... | /Unity-Technologies[P]curl/lib/vauth/cram.c |
Curl_auth_digest_cleanup | void Curl_auth_digest_cleanup(struct digestdata *digest)
{
Curl_safefree(digest->nonce);
Curl_safefree(digest->cnonce);
Curl_safefree(digest->realm);
Curl_safefree(digest->opaque);
Curl_safefree(digest->qop);
Curl_safefree(digest->algorithm);
digest->nc = 0;
digest->algo = ALGO_MD5; /* default algorith... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3094c(%rip), %r14 # 0x95068
movq (%rdi), %rdi
callq *(%r14)
xorl %r15d, %r15d
movq %r15, (%rbx)
movq 0x8(%rbx), %rdi
callq *(%r14)
movq %r15, 0x8(%rbx)
movq 0x10(%rbx), %rdi
callq *(%r14)
movq %r15, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq *(%r14)
movq %r15, 0x1... | /Unity-Technologies[P]curl/lib/vauth/digest.c |
auth_digest_string_quoted | static char *auth_digest_string_quoted(const char *source)
{
char *dest;
const char *s = source;
size_t n = 1; /* null terminator */
/* Calculate size needed */
while(*s) {
++n;
if(*s == '"' || *s == '\\') {
++n;
}
++s;
}
dest = malloc(n);
if(dest) {
char *d = dest;
s = s... | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movq %rbx, %rax
movzbl (%rax), %ecx
cmpl $0x22, %ecx
je 0x64ede
testl %ecx, %ecx
je 0x64eec
cmpb $0x5c, %cl
jne 0x64ee4
addq $0x2, %rdi
jmp 0x64ee7
incq %rdi
incq %rax
jmp 0x64ecd
leaq 0x3016d(%rip), %rax # 0x95060
callq *(%rax)
testq %rax, %rax
je 0x64f25
movq %rax, %rcx
... | /Unity-Technologies[P]curl/lib/vauth/digest.c |
ossl_do_file_type | static int ossl_do_file_type(const char *type)
{
if(!type || !type[0])
return SSL_FILETYPE_PEM;
if(strcasecompare(type, "PEM"))
return SSL_FILETYPE_PEM;
if(strcasecompare(type, "DER"))
return SSL_FILETYPE_ASN1;
if(strcasecompare(type, "ENG"))
return SSL_FILETYPE_ENGINE;
if(strcasecompare(type,... | pushq %rbp
pushq %rbx
pushq %rax
movl $0x1, %ebp
testq %rdi, %rdi
je 0x6a7fc
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x6a7fc
leaq 0x11735(%rip), %rsi # 0x7bedc
movq %rbx, %rdi
callq 0x10580
testl %eax, %eax
jne 0x6a7fc
leaq 0x74e1(%rip), %rsi # 0x71c9b
movq %rbx, %rdi
callq 0x10580
movl $0x2, %ebp
testl %eax, %ea... | /Unity-Technologies[P]curl/lib/vtls/openssl.c |
ossl_bio_cf_out_write | static int ossl_bio_cf_out_write(BIO *bio, const char *buf, int blen)
{
struct Curl_cfilter *cf = BIO_get_data(bio);
struct ssl_connect_data *connssl = cf->ctx;
struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;
struct Curl_easy *data = CF_DATA_CURRENT(cf);
ssize_t nwritten;
CURLcode result = CURL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x10560
movq %rax, %r15
movq 0x10(%rax), %rax
movq 0x30(%rax), %r13
movq 0x38(%rax), %r12
movl $0x37, 0x4(%rsp)
testl %ebp, %ebp
js 0x6b3cd
movq 0x8(%r15), %rdi
movl %ebp, %ecx
leaq 0x4(%rs... | /Unity-Technologies[P]curl/lib/vtls/openssl.c |
ossl_bio_cf_create | static int ossl_bio_cf_create(BIO *bio)
{
BIO_set_shutdown(bio, 1);
BIO_set_init(bio, 1);
#if USE_PRE_1_1_API
bio->num = -1;
#endif
BIO_set_data(bio, NULL);
return 1;
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x103a0
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf700
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfc80
movl $0x1, %eax
popq %rbx
retq
| /Unity-Technologies[P]curl/lib/vtls/openssl.c |
multissl_setup | static int multissl_setup(const struct Curl_ssl *backend)
{
const char *env;
char *env_tmp;
if(Curl_ssl != &Curl_ssl_multi)
return 1;
if(backend) {
Curl_ssl = backend;
return 0;
}
if(!available_backends[0])
return 1;
env = env_tmp = curl_getenv("CURL_SSL_BACKEND");
#ifdef CURL_DEFAULT_... | movl $0x1, %eax
leaq 0x27f25(%rip), %rcx # 0x93c88
cmpq %rcx, 0x2b326(%rip) # 0x97090
je 0x6bd6d
retq
testq %rdi, %rdi
je 0x6bd7c
movq %rdi, 0x2b317(%rip) # 0x97090
xorl %eax, %eax
retq
cmpq $0x0, 0x2b31c(%rip) # 0x970a0
je 0x6bd6c
pushq %r14
pushq %rbx
pushq %rax
leaq 0x10f32(%rip), %rdi # 0x7ccc3
... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_ssl_delsessionid | void Curl_ssl_delsessionid(struct Curl_easy *data, void *ssl_sessionid)
{
size_t i;
for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++) {
struct Curl_ssl_session *check = &data->state.session[i];
if(check->sessionid == ssl_sessionid) {
Curl_ssl_kill_session(check);
break;
}
}
} | movq 0x6e8(%rdi), %rax
testq %rax, %rax
je 0x6c17a
movq 0xcc0(%rdi), %rdi
cmpq %rsi, 0x18(%rdi)
je 0x6c17b
addq $0xc8, %rdi
decq %rax
jne 0x6c168
retq
jmp 0x6c105
| /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_ssl_init_certinfo | CURLcode Curl_ssl_init_certinfo(struct Curl_easy *data, int num)
{
struct curl_certinfo *ci = &data->info.certs;
struct curl_slist **table;
/* Free any previous certificate information structures */
Curl_ssl_free_certinfo(data);
/* Allocate the required certificate information structures */
table = calloc... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6c766
leaq 0x28896(%rip), %rax # 0x95080
movslq %ebp, %rdi
movl $0x8, %esi
callq *(%rax)
testq %rax, %rax
je 0x6c80a
movl %ebp, 0x1478(%rbx)
movq %rax, 0x1480(%rbx)
xorl %eax, %eax
jmp 0x6c80f
movl $0x1b, %eax
addq $0x8, %rsp
popq %rbx
popq %r... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_none_shutdown | CURLcode Curl_none_shutdown(struct Curl_cfilter *cf UNUSED_PARAM,
struct Curl_easy *data UNUSED_PARAM,
bool send_shutdown UNUSED_PARAM,
bool *done)
{
(void)data;
(void)cf;
(void)send_shutdown;
/* Every SSL backend should have a ... | movb $0x1, (%rcx)
xorl %eax, %eax
retq
| /Unity-Technologies[P]curl/lib/vtls/vtls.c |
ssl_cf_shutdown | static CURLcode ssl_cf_shutdown(struct Curl_cfilter *cf,
struct Curl_easy *data,
bool *done)
{
CURLcode result = CURLE_OK;
*done = TRUE;
if(!cf->shutdown) {
struct cf_call_data save;
CF_DATA_SAVE(save, cf, data);
result = Curl_ssl->shut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, (%rdx)
xorl %ebp, %ebp
testb $0x2, 0x24(%rdi)
jne 0x6d383
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x38(%rax), %r12
movq %rsi, 0x38(%rax)
movq 0x29d7c(%rip), %rax # 0x97090
movl $0x1, %edx
movq %r14, %rcx
callq *0x40... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
ssl_cf_send | static ssize_t ssl_cf_send(struct Curl_cfilter *cf,
struct Curl_easy *data, const void *buf, size_t len,
bool eos, CURLcode *err)
{
struct cf_call_data save;
ssize_t nwritten;
(void)eos; /* unused */
CF_DATA_SAVE(save, cf, data);
*err = CURLE_OK;
nwritt... | pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r8
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x38(%rax), %r14
movq %rsi, 0x38(%rax)
movl $0x0, (%r9)
movq 0x29c6d(%rip), %rax # 0x97090
callq *0xd0(%rax)
movq 0x10(%rbx), %rcx
movq %r14, 0x38(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Unity-Technologies[P]curl/lib/vtls/vtls.c |
ssl_cf_recv | static ssize_t ssl_cf_recv(struct Curl_cfilter *cf,
struct Curl_easy *data, char *buf, size_t len,
CURLcode *err)
{
struct cf_call_data save;
ssize_t nread;
CF_DATA_SAVE(save, cf, data);
*err = CURLE_OK;
nread = Curl_ssl->recv_plain(cf, data, buf, len, er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x38(%rax), %rbp
movq %rsi, 0x38(%rax)
movl $0x0, (%r8)
movq 0x29c26(%rip), %rax # 0x97090
callq *0xc8(%rax)
movq %rax, %r13
testq %rax, %rax
jne 0x6... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
ssl_cf_cntrl | static CURLcode ssl_cf_cntrl(struct Curl_cfilter *cf,
struct Curl_easy *data,
int event, int arg1, void *arg2)
{
struct cf_call_data save;
(void)arg1;
(void)arg2;
switch(event) {
case CF_CTRL_DATA_ATTACH:
if(Curl_ssl->attach_data) {
CF_DATA_... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edx
je 0x6d517
cmpl $0x1, %edx
jne 0x6d543
movq 0x29b99(%rip), %rax # 0x97090
movq 0xb8(%rax), %rax
testq %rax, %rax
je 0x6d543
leaq 0x10(%rdi), %rbx
movq 0x10(%rdi), %rcx
movq 0x38(%rcx), %r14
movq %rsi, 0x38(%rcx)
callq *%rax
jmp 0x6d53c
movq 0x29b72(%rip), %rax # ... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
cf_ssl_is_alive | static bool cf_ssl_is_alive(struct Curl_cfilter *cf, struct Curl_easy *data,
bool *input_pending)
{
struct cf_call_data save;
int result;
/*
* This function tries to determine connection status.
*
* Return codes:
* 1 means the connection is still in place
* 0 mea... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq 0x38(%rax), %r12
movq %rsi, 0x38(%rax)
movq 0x29b1f(%rip), %rax # 0x97090
callq *0x38(%rax)
movq 0x10(%r15), %rcx
movq %r12, 0x38(%rcx)
testl %eax, %eax
jle 0x6d587
movb $0x1, (%rbx)
mov... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
ssl_cf_query | static CURLcode ssl_cf_query(struct Curl_cfilter *cf,
struct Curl_easy *data,
int query, int *pres1, void *pres2)
{
struct ssl_connect_data *connssl = cf->ctx;
switch(query) {
case CF_QUERY_TIMER_APPCONNECT: {
struct curltime *when = pres2;
if(cf-... | cmpl $0x5, %edx
jne 0x6d5e4
xorl %eax, %eax
testb $0x1, 0x24(%rdi)
je 0x6d5fb
movq (%rdi), %rcx
movl 0x8(%rcx), %ecx
notl %ecx
testb $0xa, %cl
je 0x6d5fb
movq 0x10(%rdi), %rcx
movups 0x40(%rcx), %xmm0
movups %xmm0, (%r8)
retq
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6d5f6
movq (%rdi), %rax
movq 0x70(%rax), %rax
jmpq ... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_cf_ssl_insert_after | CURLcode Curl_cf_ssl_insert_after(struct Curl_cfilter *cf_at,
struct Curl_easy *data)
{
struct Curl_cfilter *cf;
CURLcode result;
result = cf_ssl_create(&cf, data, cf_at->conn);
if(!result)
Curl_conn_cf_insert_after(cf_at, cf);
return result;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x3b8(%rax), %rsi
movq %rsp, %rdi
callq 0x6d63e
movl %eax, %ebp
testl %eax, %eax
jne 0x6d6e7
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x17f3c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_cf_ssl_proxy_insert_after | CURLcode Curl_cf_ssl_proxy_insert_after(struct Curl_cfilter *cf_at,
struct Curl_easy *data)
{
struct Curl_cfilter *cf;
CURLcode result;
result = cf_ssl_proxy_create(&cf, data, cf_at->conn);
if(!result)
Curl_conn_cf_insert_after(cf_at, cf);
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x3b8(%rax), %rax
movq $0x0, 0x8(%rsp)
shlq $0x27, %rax
sarq $0x3f, %rax
leaq 0xf692(%rip), %rdi # 0x7cdb0
andq %rax, %rdi
callq 0x6e0b2
testq %rax, %rax
je 0x6d75c
movq %rax, %r14
leaq 0x299f3(%rip), %rsi # 0x97128
le... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_ssl_get_internals | void *Curl_ssl_get_internals(struct Curl_easy *data, int sockindex,
CURLINFO info, int n)
{
void *result = NULL;
(void)n;
if(data->conn) {
struct Curl_cfilter *cf;
/* get first SSL filter in chain, if any is present */
cf = get_ssl_filter(data->conn->cfilter[sockindex]);
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x6d7cc
movslq %esi, %rcx
movq 0x260(%rax,%rcx,8), %rbx
testq %rbx, %rbx
je 0x6d7cc
leaq 0x29901(%rip), %rax # 0x970b0
leaq 0x29972(%rip), %rcx # 0x97128
movq (%rbx), %rsi
cmpq %rax, %rsi
je 0x6d7d6
cmpq %rcx, %rsi
je 0x6d7d6
movq 0x8(%r... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_ssl_cfilter_remove | CURLcode Curl_ssl_cfilter_remove(struct Curl_easy *data,
int sockindex, bool send_shutdown)
{
struct Curl_cfilter *cf, *head;
CURLcode result = CURLE_OK;
head = data->conn? data->conn->cfilter[sockindex] : NULL;
for(cf = head; cf; cf = cf->next) {
if(cf->cft == &Curl_cft_ss... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rdi), %rax
xorl %r13d, %r13d
testq %rax, %rax
je 0x6da4f
movslq %esi, %rcx
movq 0x260(%rax,%rcx,8), %rbp
testq %rbp, %rbp
je 0x6da4f
movl %edx, %r12d
movq %rdi, %rbx
leaq 0x29876(%rip), %rax # 0x970b0
movq %rbp, %r14
cmpq ... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_alpn_to_proto_buf | CURLcode Curl_alpn_to_proto_buf(struct alpn_proto_buf *buf,
const struct alpn_spec *spec)
{
size_t i, len;
int off = 0;
unsigned char blen;
memset(buf, 0, sizeof(*buf));
for(i = 0; spec && i < spec->count; ++i) {
len = strlen(spec->entries[i]);
if(len >= ALPN_NAME_MAX)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x6dae4
movq %rsi, %r14
cmpq $0x0, 0x20(%rsi)
je 0x6dae4
xorl %r13d, %r13d
movq %r14, %r15
xorl %ebp, %e... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_alpn_to_proto_str | CURLcode Curl_alpn_to_proto_str(struct alpn_proto_buf *buf,
const struct alpn_spec *spec)
{
size_t i, len;
size_t off = 0;
memset(buf, 0, sizeof(*buf));
for(i = 0; spec && i < spec->count; ++i) {
len = strlen(spec->entries[i]);
if(len >= ALPN_NAME_MAX)
return CURLE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
xorl %r13d, %r13d
testq %rsi, %rsi
je 0x6db8c
movq %rsi, %r14
cmpq $0x0, 0x20(%rsi)
je 0x6db89
xorl %ebp, %ebp
movq %r14, %r15
xorl %r13d, %... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
Curl_alpn_set_negotiated | CURLcode Curl_alpn_set_negotiated(struct Curl_cfilter *cf,
struct Curl_easy *data,
const unsigned char *proto,
size_t proto_len)
{
unsigned char *palpn =
#ifndef CURL_DISABLE_PROXY
(cf->conn->bits.tunnel_proxy &&... | movq %rdx, %rax
movq 0x18(%rdi), %rdx
testb $0x8, 0x3b8(%rdx)
je 0x6dbcb
movq (%rdi), %rdi
movl 0x8(%rdi), %r8d
notl %r8d
movl $0x581, %edi # imm = 0x581
testb $0xa, %r8b
je 0x6dbd0
movl $0x580, %edi # imm = 0x580
pushq %rax
testq %rax, %rax
sete %r8b
testq %rcx, %rcx
sete %r9b
orb %r8b, %r9b
jne ... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
cf_close | static void cf_close(struct Curl_cfilter *cf, struct Curl_easy *data)
{
struct ssl_connect_data *connssl = cf->ctx;
if(connssl) {
Curl_ssl->close(cf, data);
connssl->state = ssl_connection_none;
Curl_ssl_peer_cleanup(&connssl->peer);
}
cf->connected = FALSE;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x6e065
movq 0x2906e(%rip), %rax # 0x97090
movq %rbx, %rdi
callq *0x80(%rax)
movl $0x0, 0x50(%r14)
movq 0x8(%r14), %rdi
cmpq (%r14), %rdi
je 0x6e045
leaq 0x27025(%rip), %rax # 0x95068
callq *(%rax)
leaq 0x2701c(%rip), %r1... | /Unity-Technologies[P]curl/lib/vtls/vtls.c |
main | int main(int argc, char** argv)
{
unsigned long frame_count = 0;
double last_time, current_time;
GLFWwindow* window;
GLuint vertex_buffer, vertex_shader, fragment_shader, program;
GLint mvp_location, vpos_location;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
leaq -0x714e(%rip), %rdi # 0x6410
callq 0x12cd5
callq 0x128ea
testl %eax, %eax
je 0xd5ac
movl $0x22002, %edi # imm = 0x22002
movl $0x2, %esi
callq 0x16e7b
movl $0x22003, %edi # imm = 0x2200... | /TheCherno[P]glfw/tests/tearing.c |
key_callback | static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (action != GLFW_PRESS)
return;
switch (key)
{
case GLFW_KEY_UP:
{
if (swap_interval + 1 > swap_interval)
set_swap_interval(window, swap_interval + 1);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %ecx
jne 0x11714
movq %rdi, %rbx
leal -0x100(%rsi), %eax
cmpl $0x9, %eax
ja 0x1162e
leaq 0x13a91(%rip), %rcx # 0x250a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp... | /TheCherno[P]glfw/tests/tearing.c |
glfw_calloc | void* _glfw_calloc(size_t count, size_t size)
{
if (count && size)
{
void* block;
if (count > SIZE_MAX / size)
{
_glfwInputError(GLFW_INVALID_VALUE, "Allocation size overflow");
return NULL;
}
block = _glfw.allocator.allocate(count * size, _glfw.... | pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x12489
movq %rsi, %rbx
movq %rsi, %rax
mulq %rdi
jno 0x12453
leaq 0x162e0(%rip), %rsi # 0x2872c
movl $0x10004, %edi # imm = 0x10004
jmp 0x12482
leaq 0x4124e(%rip), %rax # 0x536a8
imulq %rdi, %rbx
movq 0x20(%rax), %rsi
movq... | /TheCherno[P]glfw/src/init.c |
glfw_realloc | void* _glfw_realloc(void* block, size_t size)
{
if (block && size)
{
void* resized = _glfw.allocator.reallocate(block, size, _glfw.allocator.user);
if (resized)
return resized;
else
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
... | pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x128ae
leaq 0x40e1b(%rip), %rax # 0x536a8
movq 0x20(%rax), %rdx
callq *0x10(%rax)
movq %rax, %rbx
testq %rax, %rax
jne 0x128c3
xorl %ebx, %ebx
movl $0x10005, %edi # imm = 0x10005
xorl %esi, %esi
xorl %eax, %eax
callq 0x124b7
j... | /TheCherno[P]glfw/src/init.c |
glfwInitHint | GLFWAPI void glfwInitHint(int hint, int value)
{
switch (hint)
{
case GLFW_JOYSTICK_HAT_BUTTONS:
_glfwInitHints.hatButtons = value;
return;
case GLFW_ANGLE_PLATFORM_TYPE:
_glfwInitHints.angleType = value;
return;
case GLFW_PLATFORM:
... | movl %edi, %edx
cmpl $0x51000, %edi # imm = 0x51000
jg 0x12ba8
cmpl $0x50001, %edx # imm = 0x50001
je 0x12bc7
cmpl $0x50002, %edx # imm = 0x50002
je 0x12be8
cmpl $0x50003, %edx # imm = 0x50003
jne 0x12bd5
movl %esi, 0x3e681(%rip) # 0x51228
retq
cmpl $0x51001, %edx # imm ... | /TheCherno[P]glfw/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[k... | cmpl $0x15c, %esi # imm = 0x15C
ja 0x12d31
movl %esi, %eax
cmpl $0x1, %ecx
je 0x12d11
testl %ecx, %ecx
jne 0x12d2a
cmpb $0x0, 0x90(%rdi,%rax)
je 0x12d59
cmpl $0x0, 0x78(%rdi)
je 0x12d5a
movb $0x3, 0x90(%rdi,%rax)
jmp 0x12d31
cmpb $0x1, 0x90(%rdi,%rax)
movb $0x1, 0x90(%rdi,%rax)
movl $0x2, %eax
jne 0x12d31
jm... | /TheCherno[P]glfw/src/input.c |
glfwSetWindowAspectRatio | GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(numer != 0);
assert(denom != 0);
_GLFW_REQUIRE_INIT();
if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
{
if (numer <... | pushq %rax
testq %rdi, %rdi
je 0x17643
movl %edx, %ecx
movl %esi, %edx
testl %esi, %esi
je 0x17662
testl %ecx, %ecx
je 0x17681
leaq 0x3c0d5(%rip), %rax # 0x536a8
cmpl $0x0, (%rax)
je 0x17620
cmpl $-0x1, %edx
sete %sil
cmpl $-0x1, %ecx
sete %r8b
orb %sil, %r8b
jne 0x17611
testl %edx, %edx
setg %sil
testl %ecx, %ecx
... | /TheCherno[P]glfw/src/window.c |
glfwGetFramebufferSize | GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfw.platform.getFramebufferSize(window, width, height)... | testq %rdi, %rdi
je 0x176de
testq %rsi, %rsi
je 0x176b0
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x176bb
movl $0x0, (%rdx)
leaq 0x3bfe6(%rip), %rax # 0x536a8
cmpl $0x0, (%rax)
je 0x176d0
movq 0x160(%rax), %rax
jmpq *%rax
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x124b7
pushq %ra... | /TheCherno[P]glfw/src/window.c |
glfwGetWindowContentScale | GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
float* xscale, float* yscale)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xscale)
*xscale = 0.f;
if (yscale)
*yscale = 0.f;
_GLFW_REQUIRE_INIT();
_gl... | testq %rdi, %rdi
je 0x177b1
testq %rsi, %rsi
je 0x17783
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1778e
movl $0x0, (%rdx)
leaq 0x3bf13(%rip), %rax # 0x536a8
cmpl $0x0, (%rax)
je 0x177a3
movq 0x170(%rax), %rax
jmpq *%rax
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x124b7
pushq %ra... | /TheCherno[P]glfw/src/window.c |
glfwSetWindowOpacity | GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(opacity == opacity);
assert(opacity >= 0.f);
assert(opacity <= 1.f);
_GLFW_REQUIRE_INIT();
if (opacity != opacity || opacity < 0.f || opacity >... | pushq %rax
testq %rdi, %rdi
je 0x17893
ucomiss %xmm0, %xmm0
jp 0x178b2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x178d1
movss 0xd7c4(%rip), %xmm1 # 0x25008
ucomiss %xmm0, %xmm1
jb 0x178f0
leaq 0x3be54(%rip), %rax # 0x536a8
cmpl $0x0, (%rax)
je 0x1787a
ucomiss 0xd7a8(%rip), %xmm0 # 0x25008
jbe 0x17889
cvts... | /TheCherno[P]glfw/src/window.c |
bsp_sync | void bsp_sync()
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_sync: can only be called within SPMD section\n");
if (s_spmd->normal_sync())
bsp_abort("bsp_sync/bsp_end: Some processes have called bsp_sync, "
"while others have called bsp_end instead\n");
#ifdef PROFILE
{ ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
cmpq $0x0, 0x29fd8(%rip) # 0x40338
je 0x16374
movq 0x29fcf(%rip), %rdi # 0x40338
callq 0x17c00
testb $0x1, %al
jne 0x16374
jmp 0x16382
leaq 0x1b2a9(%rip), %rdi # 0x31624
movb $0x0, %al
callq 0x157d0
movq 0x29faf(%rip), %rdi # 0x40338
callq 0x1b450
cmpl $0x0, %... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsplib::AlignedBuf::append(unsigned long) | void * append( size_t extra_bytes ) {
extra_bytes = align( extra_bytes );
if ( m_size + extra_bytes > m_capacity ) {
size_t newsize = std::max( 2 * m_capacity, m_size + extra_bytes );
void * ptr = std::malloc( newsize + 2*m_alignment );
void * aligned_ptr = align( ptr... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1ade0
movq -0x48(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq 0x20(%rcx), %rax
addq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jbe 0x2cd69
movq -0x48(%rbp), %rax
m... | /wijnand-suijlen[P]bsponmpi/src/aligned_buf.h |
hash_table_get_item | void * hash_table_get_item( const hash_table_t * table, void * key )
{
unsigned i = (unsigned) hash( table->ghash, (* table->hash )( key ) );
const hash_table_bucket_t *b = table->buckets[i].next;
while (b) {
if ( (*table->is_equal)(key, b->data) )
return b->data;
b = b->next;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
imulq %rcx, %rax
movq -0x10(%rbp), %rcx
add... | /wijnand-suijlen[P]bsponmpi/src/util.c |
ncnn::UnlockedPoolAllocator::~UnlockedPoolAllocator() | UnlockedPoolAllocator::~UnlockedPoolAllocator()
{
clear();
if (!payouts.empty())
{
fprintf(stderr, "FATAL ERROR! unlocked pool allocator destroyed too early\n");
std::list< std::pair<size_t, void*> >::iterator it = payouts.begin();
for (; it != payouts.end(); it++)
{
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x62f1b(%rip), %rax # 0x76670
movq %rax, (%rdi)
callq 0x137b6
leaq 0x28(%rbx), %r14
cmpq %r14, 0x28(%rbx)
jne 0x137ac
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x13784
movq (%rdi), %r15
movl $0x20, %esi
callq 0x101c0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x1376f
movq 0... | /tongxiaobin[P]ncnn/src/allocator.cpp |
ncnn::Layer::~Layer() | Layer::~Layer()
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x61329(%rip), %rax # 0x766e0
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x153cf
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x101c0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x153e4
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x101c0
movq 0x30(%rbx), %rdi
leaq 0x40(... | /tongxiaobin[P]ncnn/src/layer.cpp |
ncnn::Mat::create(int, int, unsigned long, int, ncnn::Allocator*) | inline void Mat::create(int _w, int _h, size_t _elemsize, int _packing, Allocator* _allocator)
{
if (dims == 2 && w == _w && h == _h && elemsize == _elemsize && packing == _packing && allocator == _allocator)
return;
release();
elemsize = _elemsize;
packing = _packing;
allocator = _allocat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movl %r8d, %r13d
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jne 0x199d2
cmpl %r12d, 0x2c(%rbx)
jne 0x199d2
cmpl %ebp, 0x30(%rbx)
jne 0x199d2
cmpq %r15, 0x10(%rbx)
jne 0x199d2
cmp... | /tongxiaobin[P]ncnn/src/mat.h |
ncnn::ModelBinFromStdio::load(int, int) const | Mat ModelBinFromStdio::load(int w, int type) const
{
if (!binfp)
return Mat();
if (type == 0)
{
int nread;
union
{
struct
{
unsigned char f0;
unsigned char f1;
unsigned char f2;
unsigned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp # imm = 0x478
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1a3a9
movl %edx, %r14d
movq %rsi, %r15
cmpl $0x1, %ecx
je 0x1a3c0
testl %ecx, %ecx
jne 0x1a681
movq %rsp, %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rax... | /tongxiaobin[P]ncnn/src/modelbin.cpp |
ncnn::Net::load_param_bin(char const*) | int Net::load_param_bin(const char* protopath)
{
FILE* fp = fopen(protopath, "rb");
if (!fp)
{
fprintf(stderr, "fopen %s failed\n", protopath);
return -1;
}
int ret = load_param_bin(fp);
fclose(fp);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x46451(%rip), %rsi # 0x62e7f
movq %rbx, %rdi
callq 0x10200
testq %rax, %rax
je 0x1ca5b
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1c5d6
movl %eax, %ebx
movq %r15, %rdi
callq 0x101a0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq... | /tongxiaobin[P]ncnn/src/net.cpp |
ncnn::Net::load_model(unsigned char const*) | int Net::upload_model()
{
ncnn::VkTransfer cmd(vkdev);
// create gpu device allocator if null
if (!weight_vkallocator)
{
weight_vkallocator = new VkWeightBufferAllocator(vkdev);
}
if (!weight_staging_vkallocator)
{
weight_staging_vkallocator = new VkWeightStagingBufferAlloca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
je 0x1d014
movq %rsi, %rbx
testb $0x3, %bl
jne 0x1d01b
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x14ea2
cmpl $0x0, 0xc(%r14)
setne 0x18(%r15)
movq (%r14), %rax
movq %rax, 0x1... | /tongxiaobin[P]ncnn/src/net.cpp |
ncnn::Extractor::input(int, ncnn::Mat const&) | int Extractor::input(int blob_index, const Mat& in)
{
if (blob_index < 0 || blob_index >= (int)blob_mats.size())
return -1;
blob_mats[blob_index] = in;
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x1df76
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
subq %r15, %rax
shrq $0x6, %rax
cmpl %esi, %eax
jle 0x1df76
movq %rdx, %r14
movl %esi, %eax
shlq $0x6, %rax
addq %rax, %r15
xorl %ebx, %ebx
cmpq %rdx, %r15
je 0x1df76
m... | /tongxiaobin[P]ncnn/src/net.cpp |
ncnn::Extractor::extract(int, ncnn::Mat&) | int Extractor::extract(int blob_index, Mat& feat)
{
if (blob_index < 0 || blob_index >= (int)blob_mats.size())
return -1;
int ret = 0;
if (blob_mats[blob_index].dims == 0)
{
int layer_index = net->blobs[blob_index].producer;
#if NCNN_VULKAN
if (opt.vulkan_compute)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x1e0a2
movq %rdx, %rbx
movq %rdi, %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
shrq $0x6, %rdx
cmpl %esi, %edx
jle 0x1e0a2
leaq 0x8(%rcx), %r14
movl %esi, %r15d
shlq $0x6, %r15
... | /tongxiaobin[P]ncnn/src/net.cpp |
ncnn::ParamDict::clear() | void ParamDict::clear()
{
for (int i = 0; i < NCNN_MAX_PARAM_COUNT; i++)
{
params[i].loaded = 0;
params[i].v = Mat();
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
leaq 0x40(%rdi), %r15
addq $0x8, %rbx
xorl %r12d, %r12d
xorps %xmm1, %xmm1
movq %rsp, %r13
movl $0x0, -0x40(%r15,%r12)
movups %xmm1, 0xc(%rsp)
movaps %xmm1, (%rsp)
movaps %xmm1, 0x10(%r14)
movaps %xmm1, (%r14)
... | /tongxiaobin[P]ncnn/src/paramdict.cpp |
ncnn::ParamDict::load_param_bin(_IO_FILE*) | int ParamDict::load_param_bin(FILE* fp)
{
clear();
// binary 0
// binary 100
// binary 1
// binary 1.250000
// binary 3 | array_bit
// binary 5
// binary 0.1
// binary 0.2
// binary 0.4
// binary 0.8
// binary 1.0
// binary -233(EOP)
int id = 0;
fread(&id, s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1efea
movq %rsp, %r15
movl $0x0, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x102b0
movl (%r15), %eax
cmpl $0xffffff17, %eax # imm = 0xFFFFFF17
je 0x1f8a4
leaq 0x4... | /tongxiaobin[P]ncnn/src/paramdict.cpp |
ncnn::Bias::load_model(ncnn::ModelBin const&) | int Bias::load_model(const ModelBin& mb)
{
bias_data = mb.load(bias_data_size, 1);
if (bias_data.empty())
return -100;
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x80(%rdi), %edx
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
movl $0x1, %ecx
callq *(%rax)
leaq 0x88(%rbx), %r15
cmpq %r14, %r15
je 0x2060b
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x2056f
lock
incl (%rax)
movq 0x90(%rbx), %rax
testq %rax, %ra... | /tongxiaobin[P]ncnn/src/layer/bias.cpp |
ncnn::BNLL::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BNLL::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr = bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq 0x34(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jle 0x208fa
movl 0x30(%rsi), %ebp
imull 0x2c(%rsi), %ebp
movq (%rsi), %r14
movq 0x38(%rsi), %r15
imulq 0x10(%rsi), %r15
movl %ebp, %r12d
xorl %r13d, %r13d
testl %ebp, %ebp
jle... | /tongxiaobin[P]ncnn/src/layer/bnll.cpp |
ncnn::Convolution::destroy_pipeline(ncnn::Option const&) | int Convolution::destroy_pipeline(const Option& opt)
{
Option opt_cpu = opt;
opt_cpu.vulkan_compute = false;
if (quantize)
{
quantize->destroy_pipeline(opt_cpu);
delete quantize;
quantize = 0;
}
for (int i=0; i<(int)dequantize_ops.size(); i++)
{
dequantize_o... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rsp)
movaps %xmm0, (%rsp)
movb $0x0, 0x18(%rsp)
movq 0x1c8(%rdi), %rdi
testq %rdi, %rdi
je 0x22744
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x28... | /tongxiaobin[P]ncnn/src/layer/convolution.cpp |
ncnn::Convolution_x86::destroy_pipeline(ncnn::Option const&) | int Convolution_x86::destroy_pipeline(const Option& opt)
{
Option opt_cpu = opt;
opt_cpu.vulkan_compute = false;
if (activation)
{
activation->destroy_pipeline(opt_cpu);
delete activation;
activation = 0;
}
return 0;
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rsp)
movaps %xmm0, (%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x25b61
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x28(%rax)
movq 0x8(%rbx), %... | /tongxiaobin[P]ncnn/src/layer/x86/convolution_x86.cpp |
ncnn::Proposal::Proposal() | Proposal::Proposal()
{
one_blob_only = false;
support_inplace = false;
// TODO load from param
ratios.create(3);
ratios[0] = 0.5f;
ratios[1] = 1.f;
ratios[2] = 2.f;
scales.create(3);
scales[0] = 8.f;
scales[1] = 16.f;
scales[2] = 32.f;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x14f28
leaq 0x4287d(%rip), %rax # 0x7bbb0
movq %rax, (%rbx)
leaq 0x98(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xa4(%rbx)
movups %xmm0, 0x98(%rbx)
leaq 0xd8(%rbx), %r14
movups %xmm0, 0x138(%rbx)
movups %xmm0, 0x148(%rbx)
movw $0x0, 0x... | /tongxiaobin[P]ncnn/src/layer/proposal.cpp |
ncnn::Proposal::forward(std::vector<ncnn::Mat, std::allocator<ncnn::Mat>> const&, std::vector<ncnn::Mat, std::allocator<ncnn::Mat>>&, ncnn::Option const&) const | int Proposal::forward(const std::vector<Mat>& bottom_blobs, std::vector<Mat>& top_blobs, const Option& opt) const
{
const Mat& score_blob = bottom_blobs[0];
const Mat& bbox_blob = bottom_blobs[1];
const Mat& im_info_blob = bottom_blobs[2];
int w = score_blob.w;
int h = score_blob.h;
// generat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdx, 0x180(%rsp)
movq (%rsi), %rax
movslq 0x2c(%rax), %rcx
movq %rax, 0xb0(%rsp)
movl 0x30(%rax), %r14d
movq %rdi, 0x8(%rsp)
movl 0x148(%rdi), %ebp
xorps %xmm0, %xmm0
leaq 0x98(%rsp), %rbx
movups %xmm0, -0... | /tongxiaobin[P]ncnn/src/layer/proposal.cpp |
ncnn::Reshape::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Reshape::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
size_t elemsize = bottom_blob.elemsize;
int total = bottom_blob.w * bottom_blob.h * bottom_blob.c;
if (ndim == 1)
{
int _w = w;
if (_w == 0)
_w = bottom_blob.w;
if (_w == -1)
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl 0x2c(%rsi), %r10d
movl 0x30(%rsi), %r11d
movl %r11d, %esi
imull %r10d, %esi
movl 0x34(%r14), %r8d
imull %r8d, %esi
movl 0x90(%rdi), %eax
cmpl $0x3, %eax
je 0x3e695
cmpl $0x2, %eax
je 0x3e600
cmpl $0x1, %eax
jne 0x3e946
movl 0x80(%rdi... | /tongxiaobin[P]ncnn/src/layer/reshape.cpp |
ncnn::Scale::load_model(ncnn::ModelBin const&) | int Scale::load_model(const ModelBin& mb)
{
if (scale_data_size == -233)
return 0;
scale_data = mb.load(scale_data_size, 1);
if (scale_data.empty())
return -100;
if (bias_term)
{
bias_data = mb.load(scale_data_size, 1);
if (bias_data.empty())
return -100... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl 0x80(%rdi), %edx
xorl %ebp, %ebp
cmpl $0xffffff17, %edx # imm = 0xFFFFFF17
je 0x3f37b
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movl $0x1, %ecx
callq *(%rax)
leaq 0x88(%rbx), %r12
cmpq %r15, %r12
j... | /tongxiaobin[P]ncnn/src/layer/scale.cpp |
ncnn::Sigmoid::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int Sigmoid::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int size = w * h;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q=0; q<channels; q++)
{
float* ptr =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x34(%rsi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jle 0x3f891
movl 0x30(%rsi), %ebp
imull 0x2c(%rsi), %ebp
movq (%rsi), %r14
movq 0x38(%rsi), %r15
imulq 0x10(%rsi), %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movaps 0x23924(%rip), %xmm1 ... | /tongxiaobin[P]ncnn/src/layer/sigmoid.cpp |
ncnn::Quantize::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Quantize::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
int dims = bottom_blob.dims;
if (dims == 1)
{
int w = bottom_blob.w;
top_blob.create(w, (size_t)1u, opt.blob_allocator);
if (top_blob.empty())
return -100;
const float* ptr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x18(%rsp)
movl 0x28(%rsi), %ebp
cmpl $0x3, %ebp
je 0x5c5f3
cmpl $0x2, %ebp
je 0x5c52c
cmpl $0x1, %ebp
jne 0x5c6e9
movq 0x18(%rsp), %rax
movl 0x2c(%rax), %r12d
movq 0x8(%rbx), %r... | /tongxiaobin[P]ncnn/src/layer/quantize.cpp |
ncnn::Yolov3DetectionOutput::Yolov3DetectionOutput() | Yolov3DetectionOutput::Yolov3DetectionOutput()
{
one_blob_only = false;
support_inplace = false;
//softmax = ncnn::create_layer(ncnn::LayerType::Softmax);
// set param
ncnn::ParamDict pd;
pd.set(0, 0);// axis
//softmax->load_param(pd);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5a8, %rsp # imm = 0x5A8
movq %rdi, %rbx
callq 0x14f28
leaq 0x1fe1b(%rip), %rax # 0x7cb78
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x9c(%rbx)
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x140(%rbx)
movw $0x0, 0x8(%rbx)
movu... | /tongxiaobin[P]ncnn/src/layer/yolov3detectionoutput.cpp |
ncnn::Yolov3DetectionOutput::load_param(ncnn::ParamDict const&) | int Yolov3DetectionOutput::load_param(const ParamDict& pd)
{
num_class = pd.get(0, 20);
num_box = pd.get(1, 5);
confidence_threshold = pd.get(2, 0.01f);
nms_threshold = pd.get(3, 0.45f);
biases = pd.get(4, Mat());
mask = pd.get(5, Mat());
anchors_scale = pd.get(6, Mat());
return 0;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x1f154
movl %eax, 0x80(%rbx)
movq %r14, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1f154
movl %eax, 0x84(%rbx)
movss 0x6ae3(%rip), %xmm0 # 0x63b1c
movq %r14, %rdi
mo... | /tongxiaobin[P]ncnn/src/layer/yolov3detectionoutput.cpp |
test | int test(char *URL)
{
CURL *curl = NULL;
CURLcode res = CURLE_FAILED_INIT;
char bURL[512];
snprintf(bURL, sizeof(bURL), "%s HTTP/1.1\r\nGET http://1529.com/1529", URL);
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
... | pushq %rbp
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdi, %rcx
leaq 0xe05(%rip), %rdx # 0x3004
movq %rsp, %rdi
movl $0x200, %esi # imm = 0x200
xorl %eax, %eax
callq 0x2060
movl $0x3, %edi
callq 0x20c0
testl %eax, %eax
je 0x223e
movq 0x2dbd(%rip), %rax # 0x4fe0
movq (%rax), %rdi
l... | /xyzz[P]vita-curl/tests/libtest/lib1529.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc4e(%rip), %rsi # 0x3044
movl $0x6, %edi
callq 0x2070
cmpl $0x1, %ebp
jg 0x2429
movq 0x2bd4(%rip), %rax # 0x4fe0
movq (%rax), %rdi
leaq 0xc4e(%rip), %rsi # 0x3064
xorl %eax, %eax
callq 0x20a0
movl $0x1, %eax
addq $0x8, %rsp
popq %r... | /xyzz[P]vita-curl/tests/libtest/first.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | movq %rdi, %rax
retq
| /xyzz[P]vita-curl/lib/warnless.c |
curlx_ultouc | unsigned char curlx_ultouc(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_UCHAR);
return (unsigned char)(ulnum & (unsigned long) CURL_MASK_UCHAR);
#ifdef __INTEL_... | movq %rdi, %rax
retq
| /xyzz[P]vita-curl/lib/warnless.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.