name string | code string | asm string | file string |
|---|---|---|---|
dedotdotify | UNITTEST char *dedotdotify(const char *input, size_t clen)
{
char *out = malloc(clen + 1);
char *outptr;
const char *orginput = input;
char *queryp;
if(!out)
return NULL; /* out of memory */
*out = 0; /* null-terminates, for inputs like "./" */
outptr = out;
if(!*input)
/* zero length input st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x369fdb(%rip), %rax # 0x787f48
leaq 0x1(%rsi), %rdi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x41e1a4
movb $0x0, (%rbx)
movb (%r12), %r13b
testb %r13b, %r13b
je 0x41e1a4
movq %r12, %rdi
movl $0x3f, %esi
callq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/urlapi.c |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if INT_MAX < LONG_MAX
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum & (long) ... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/warnless.c |
curlx_sztosi | int curlx_sztosi(ssize_t sznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sznum >= 0);
#if INT_MAX < SSIZE_T_MAX
DEBUGASSERT((size_t) sznum <= (size_t) CURL_MASK_SINT);
#endif
return (int)(sznum & (ssize_t) CURL_... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/warnless.c |
Curl_auth_create_digest_http_message | CURLcode Curl_auth_create_digest_http_message(struct Curl_easy *data,
const char *userp,
const char *passwdp,
const unsigned char *request,
... | pushq %rbx
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %rax
cmpb $0x1, 0x34(%r9)
ja 0x41f3c9
leaq 0x17678(%rip), %r11 # 0x436a38
leaq 0x585(%rip), %rbx # 0x41f94c
jmp 0x41f3d7
leaq 0x18fb8(%rip), %r11 # 0x438388
leaq 0x5bd(%rip), %rbx # 0x41f994
pushq %r11
pushq %rbx
pushq %r10
pushq %rax
callq 0x41f3e8
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vauth/digest.c |
Curl_auth_allowed_to_host | bool Curl_auth_allowed_to_host(struct Curl_easy *data)
{
struct connectdata *conn = data->conn;
return (!data->state.this_is_a_follow ||
data->set.allow_auth_to_other_hosts ||
(data->state.first_host &&
strcasecompare(data->state.first_host, conn->host.name) &&
(data->state... | movb $0x1, %al
testb $0x2, 0x1300(%rdi)
je 0x41fbca
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x20, 0xa94(%rdi)
jne 0x41fbc3
movq 0xc88(%rbx), %rdi
testq %rdi, %rdi
je 0x41fbc1
movq 0x18(%rbx), %r14
movq 0x98(%r14), %rsi
callq 0x41546a
testl %eax, %eax
je 0x41fbc1
movl 0xc90(%rbx), %eax
cmpl 0x56c(%r14), ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vauth/vauth.c |
Curl_ssl_connect | CURLcode
Curl_ssl_connect(struct Curl_easy *data, struct connectdata *conn,
int sockindex)
{
CURLcode result;
#ifndef CURL_DISABLE_PROXY
if(conn->bits.proxy_ssl_connected[sockindex]) {
result = ssl_connect_init_proxy(conn, sockindex);
if(result)
return result;
}
#endif
if(!ssl_p... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r15
cmpb $0x1, 0x372(%rsi,%r15)
jne 0x4201a8
movq %r14, %rdi
movl %ebp, %esi
callq 0x420215
testl %eax, %eax
jne 0x42020a
movq %rbx, %rdi
callq 0x420294
movl %eax, %ecx
movl $0x23, %eax
testb %cl, %cl
je... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/vtls.c |
Curl_init_sslset_nolock | CURLsslset Curl_init_sslset_nolock(curl_sslbackend id, const char *name,
const curl_ssl_backend ***avail)
{
int i;
if(avail)
*avail = (const curl_ssl_backend **)&available_backends;
if(Curl_ssl != &Curl_ssl_multi)
return id == Curl_ssl->info.id ||
(name && s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
testq %rdx, %rdx
je 0x42124a
leaq 0x366e09(%rip), %rax # 0x788050
movq %rax, (%rdx)
movq 0x366def(%rip), %rax # 0x788040
leaq 0x35f738(%rip), %rcx # 0x780990
cmpq %rcx, %rax
je 0x42127f
xorl %ebp, %ebp
cmpl %r14d, (%rax)
je... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/vtls.c |
multissl_version | static size_t multissl_version(char *buffer, size_t size)
{
static const struct Curl_ssl *selected;
static char backends[200];
static size_t backends_len;
const struct Curl_ssl *current;
current = Curl_ssl == &Curl_ssl_multi ? available_backends[0] : Curl_ssl;
if(current != selected) {
char *p = backe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x366d26(%rip), %rax # 0x788040
leaq 0x35f66f(%rip), %rcx # 0x780990
cmpq %rcx, %rax
movq 0x366d25(%rip), %rbp # 0x788050
cmoveq %rbp, %rax
cmpq 0x3714f2(%rip), %rax # 0x792828
je 0x42140e... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/vtls.c |
Curl_bufref_memdup | CURLcode Curl_bufref_memdup(struct bufref *br, const void *ptr, size_t len)
{
unsigned char *cpy = NULL;
DEBUGASSERT(br);
DEBUGASSERT(br->signature == SIGNATURE);
DEBUGASSERT(br->ptr || !br->len);
DEBUGASSERT(ptr || !len);
DEBUGASSERT(len <= CURL_MAX_INPUT_LENGTH);
if(ptr) {
cpy = malloc(len + 1);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4219e7
movq %rsi, %r12
leaq 0x366589(%rip), %rax # 0x787f48
leaq 0x1(%r14), %rdi
callq *(%rax)
testq %rax, %rax
je 0x421a13
movq %rax, %r15
testq %r14, %r14
je 0x4219e0
movq %r15, %rdi
movq %r12, %rsi
movq %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/bufref.c |
Curl_connalive | bool Curl_connalive(struct connectdata *conn)
{
/* First determine if ssl */
if(conn->ssl[FIRSTSOCKET].use) {
/* use the SSL context */
if(!Curl_ssl_check_cxn(conn))
return false; /* FIN received */
}
/* Minix 3.1 doesn't support any flags on recv; just assume socket is OK */
#ifdef MSG_PEEK
els... | pushq %rax
testb $0x1, 0x228(%rdi)
jne 0x423c8d
movl 0x1e0(%rdi), %edi
cmpl $-0x1, %edi
je 0x423c89
leaq 0x7(%rsp), %rsi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3b400
testq %rax, %rax
jne 0x423c96
xorl %eax, %eax
jmp 0x423c98
callq 0x420b06
testl %eax, %eax
je 0x423c89
movb $0x1, %al
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/connect.c |
Curl_unencode_cleanup | void Curl_unencode_cleanup(struct Curl_easy *data)
{
struct SingleRequest *k = &data->req;
struct contenc_writer *writer = k->writer_stack;
while(writer) {
k->writer_stack = writer->downstream;
writer->handler->close_writer(data, writer);
free(writer);
writer = k->writer_stack;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq 0x160(%rdi), %r14
testq %r14, %r14
je 0x424000
movq %rdi, %rbx
leaq 0x363f79(%rip), %r15 # 0x787f50
movq 0x8(%r14), %rax
movq %rax, 0x160(%rbx)
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movq %r14, %rdi
callq *(%r15)
movq 0x160(%rbx), %r14
testq %r14, %r... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/content_encoding.c |
Curl_cookie_add | struct Cookie *
Curl_cookie_add(struct Curl_easy *data,
/*
* The 'data' pointer here may be NULL at times, and thus
* must only be used very carefully for things that can deal
* with data being NULL. Such as infof() and similar
*/
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2048, %rsp # imm = 0x2048
movq %r9, %r12
movq %r8, %rbp
movl %ecx, 0x28(%rsp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r13
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x3aaa0
cmpb $0x31, 0x1a8(%r13)
ja 0x425b15
movq %rax, 0x20(%rsp)
leaq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/cookie.c |
Curl_flush_cookies | void Curl_flush_cookies(struct Curl_easy *data, bool cleanup)
{
CURLcode res;
if(data->set.str[STRING_COOKIEJAR]) {
if(data->state.cookielist) {
/* If there is a list of cookie files to read, do it first so that
we have all the told files read before we write the new jar.
Curl_cookie_lo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x758(%rdi)
je 0x4265a6
cmpq $0x0, 0x11f8(%rbx)
je 0x426531
movq %rbx, %rdi
callq 0x424a3c
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x413ded
movq 0xaa0(%rbx), %r12
movq 0x758(%rbx),... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/cookie.c |
get_netscape_format | static char *get_netscape_format(const struct Cookie *co)
{
return aprintf(
"%s" /* httponly preamble */
"%s%s\t" /* domain */
"%s\t" /* tailmatch */
"%s\t" /* path */
"%s\t" /* secure */
"%" CURL_FORMAT_CURL_OFF_T "\t" /* expires */
"%s\t" /* name */
"%s", /* value */... | movq %rdi, %r10
movb 0x53(%rdi), %al
movq 0x28(%rdi), %r9
leaq 0x1e6679(%rip), %rdi # 0x60ce89
leaq 0x177520(%rip), %r11 # 0x59dd37
cmpb $0x1, 0x50(%r10)
leaq 0x176978(%rip), %rsi # 0x59d19b
jne 0x426845
testq %r9, %r9
je 0x42684a
cmpb $0x2e, (%r9)
leaq 0x1e6654(%rip), %rcx # 0x60ce89
leaq 0x1b76a8(%rip), %... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/cookie.c |
Curl_dyn_vaddf | CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
{
#ifdef BUILDING_LIBCURL
int rc;
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
rc = Curl_dyn_vprintf(s, fmt, ap);
if(!rc)
return CURLE_OK;
#else
char *str;
str = vaprintf(fmt, ap); /* this a... | pushq %rax
callq 0x409d58
testl %eax, %eax
movl $0x1b, %ecx
cmovnel %ecx, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmcurl/lib/dynbuf.c |
file_connect | static CURLcode file_connect(struct Curl_easy *data, bool *done)
{
char *real_path;
struct FILEPROTO *file = data->req.p.file;
int fd;
#ifdef DOS_FILESYSTEM
size_t i;
char *actual_path;
#endif
size_t real_path_len;
CURLcode result = Curl_urldecode(data->state.up.path, 0, &real_path,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x198(%rdi), %r12
movq 0x11d0(%rdi), %rdi
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
xorl %esi, %esi
movl $0x4, %r8d
callq 0x426d54
movl %eax, %ebp
testl %eax, %eax
jne 0x427601
movq (%rsp), %r15
movq 0x8(%rsp), %rdx
... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/file.c |
ftp_do | static CURLcode ftp_do(struct Curl_easy *data, bool *done)
{
CURLcode result = CURLE_OK;
struct connectdata *conn = data->conn;
struct ftp_conn *ftpc = &conn->proto.ftpc;
*done = FALSE; /* default to false */
ftpc->wait_data_conn = FALSE; /* default to no such wait */
if(data->state.wildcardmatch) {
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r13
xorl %eax, %eax
movb %al, (%rsi)
movb %al, 0x4f5(%r13)
testb $0x40, 0x1300(%rdi)
jne 0x4278e8
movq %rbx, %rdi
callq 0x42bf81
movl %eax, %ebp
testl %eax, %eax
jne 0x427d7d
jmp 0x427c9a... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
ftp_state_user | static CURLcode ftp_state_user(struct Curl_easy *data,
struct connectdata *conn)
{
CURLcode result = Curl_pp_sendf(data,
&conn->proto.ftpc.pp, "USER %s",
conn->user?conn->user:"");
if(!result) {
struct ftp_conn *f... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x448, %rsi # imm = 0x448
movq 0x188(%r14), %rax
testq %rax, %rax
leaq 0x1e36a0(%rip), %rcx # 0x60ce89
cmovneq %rax, %rcx
leaq 0x1cdfa3(%rip), %rdx # 0x5f7797
xorl %eax, %eax
callq 0x437f55
testl %eax, %eax
jne 0x429815
andb $-0x2, ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/ftp.c |
Curl_pp_statemach | CURLcode Curl_pp_statemach(struct Curl_easy *data,
struct pingpong *pp, bool block,
bool disconnecting)
{
struct connectdata *conn = data->conn;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
int rc;
timediff_t interval_ms;
timediff_t timeout_ms = Curl_pp_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movl 0x1e0(%r15), %r12d
movl %ecx, %edx
callq 0x437bf0
testq %rax, %rax
jle 0x437d4f
movl %r12d, 0x4(%rsp)
movl $0x3e8, %r13d # imm = 0x3E8
cmpq %r13, %rax
cmovbq ... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/pingpong.c |
Curl_tls_keylog_open | void
Curl_tls_keylog_open(void)
{
char *keylog_file_name;
if(!keylog_file_fp) {
keylog_file_name = curl_getenv("SSLKEYLOGFILE");
if(keylog_file_name) {
keylog_file_fp = fopen(keylog_file_name, FOPEN_APPENDTEXT);
if(keylog_file_fp) {
#ifdef WIN32
if(setvbuf(keylog_file_fp, NULL, _IONBF, ... | pushq %rbx
cmpq $0x0, 0x34f973(%rip) # 0x7929c8
je 0x443059
popq %rbx
retq
leaq 0x1b85e5(%rip), %rdi # 0x5fb645
callq 0x42d224
testq %rax, %rax
je 0x443057
movq %rax, %rbx
leaq 0x16bc0a(%rip), %rsi # 0x5aec7e
movq %rax, %rdi
callq 0x3b7f0
movq %rax, 0x34f945(%rip) # 0x7929c8
testq %rax, %rax
je 0x4430b7
mov... | /JKorbelRA[P]CMake/Utilities/cmcurl/lib/vtls/keylog.c |
nghttp2_session_destroy_stream | int nghttp2_session_destroy_stream(nghttp2_session *session,
nghttp2_stream *stream) {
nghttp2_mem *mem;
int rv;
DEBUGF("stream: destroy closed stream(%p)=%d\n", stream, stream->stream_id);
mem = &session->mem;
if (nghttp2_stream_in_dep_tree(stream)) {
rv = nghttp2_st... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x44cbf8
testl %eax, %eax
je 0x444e41
movq %rbx, %rdi
callq 0x44c7c9
testl %eax, %eax
jne 0x444e6b
leaq 0x9e0(%r14), %r15
movl 0xa8(%rbx), %esi
movq %r14, %rdi
callq 0x4536ba
movq %rbx, %rdi
callq 0x44c21a
movq %r15, %rdi
movq %rbx, ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_on_request_headers_received | int nghttp2_session_on_request_headers_received(nghttp2_session *session,
nghttp2_frame *frame) {
int rv = 0;
nghttp2_stream *stream;
if (frame->hd.stream_id == 0) {
return session_inflate_handle_invalid_connection(
session, frame, NGHTTP2_ERR_PROTO, "re... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %esi
testl %esi, %esi
je 0x44667a
cmpb $0x0, 0xb1c(%r14)
je 0x446692
testb $0x1, %sil
je 0x446683
cmpl %esi, 0xaa0(%r14)
jge 0x446683
movl %esi, 0xaa0(%r14)
movq 0xa48(%r14), %rcx
movl 0xaf4(%r14), %eax
cmpq %rax, %rcx
jae 0x4466ec
movl $0... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_update_local_settings | int nghttp2_session_update_local_settings(nghttp2_session *session,
nghttp2_settings_entry *iv,
size_t niv) {
int rv;
size_t i;
int32_t new_initial_window_size = -1;
uint32_t header_table_size = 0;
uint32_t min_header_table_si... | testq %rdx, %rdx
je 0x446e57
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rcx
negq %rcx
xorl %r12d, %r12d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movb $0x1, %dl
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
xorl ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_add_ping | int nghttp2_session_add_ping(nghttp2_session *session, uint8_t flags,
const uint8_t *opaque_data) {
int rv;
nghttp2_outbound_item *item;
nghttp2_frame *frame;
nghttp2_mem *mem;
mem = &session->mem;
if ((flags & NGHTTP2_FLAG_ACK) &&
session->obq_flood_counter_ >= session-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
testb $0x1, %bpl
je 0x4477fe
movq 0xa78(%rbx), %rax
movl $0xfffffc78, %r15d # imm = 0xFFFFFC78
cmpq 0xa80(%rbx), %rax
jae 0x447870
leaq 0x9e0(%rbx), %r14
movl $0x98, %esi
movq %r14, %rdi
cal... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_update_recv_stream_window_size | int nghttp2_session_update_recv_stream_window_size(nghttp2_session *session,
nghttp2_stream *stream,
size_t delta_size,
int send_window_update) {
int rv;
rv = adju... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb0(%rsi), %esi
movl 0xbc(%rbx), %edi
movl %edi, %eax
subl %edx, %eax
cmpl %eax, %esi
setg %al
movl %edx, %r8d
xorl $0x7fffffff, %r8d # imm = 0x7FFFFFFF
cmpl %r8d, %esi
setg %r8b
orb %al, %r8b
cmpb $0x1, %r8b
jne 0x447f9e
movl 0xa8(%rbx), %esi... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_update_recv_connection_window_size | int nghttp2_session_update_recv_connection_window_size(nghttp2_session *session,
size_t delta_size) {
int rv;
rv = adjust_recv_window_size(&session->recv_window_size, delta_size,
session->local_window_size);
if (rv != 0) {
r... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movl 0xab8(%rdi), %esi
movl 0xac4(%rdi), %edi
movl %edi, %ecx
subl %eax, %ecx
cmpl %ecx, %esi
setg %cl
movl %eax, %edx
xorl $0x7fffffff, %edx # imm = 0x7FFFFFFF
cmpl %edx, %esi
setg %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x4480d1
movl 0xaa4(%rbx), %esi... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
session_call_error_callback | static int session_call_error_callback(nghttp2_session *session,
int lib_error_code, const char *fmt,
...) {
size_t bufsize;
va_list ap;
char *buf;
int rv;
nghttp2_mem *mem;
if (!session->callbacks.error_callback &&
!sessio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %rbx
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x44a410
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rs... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
session_process_headers_frame | static int session_process_headers_frame(nghttp2_session *session) {
int rv;
nghttp2_inbound_frame *iframe = &session->iframe;
nghttp2_frame *frame = &iframe->frame;
nghttp2_stream *stream;
rv = nghttp2_frame_unpack_headers_payload(&frame->headers, iframe->sbuf.pos);
if (rv != 0) {
return nghttp2_sess... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d8(%rdi), %r14
movq 0x350(%rdi), %rsi
movq %r14, %rdi
callq 0x44e7e9
testl %eax, %eax
je 0x44a6aa
movl 0xaa4(%rbx), %esi
leaq 0x1b3c4a(%rip), %rcx # 0x5fe2e0
movq %rbx, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4437e8
movl 0x2e0(%rbx), %es... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
session_process_push_promise_frame | static int session_process_push_promise_frame(nghttp2_session *session) {
int rv;
nghttp2_inbound_frame *iframe = &session->iframe;
nghttp2_frame *frame = &iframe->frame;
rv = nghttp2_frame_unpack_push_promise_payload(&frame->push_promise,
iframe->sbuf.pos);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d8(%rdi), %r14
movq 0x350(%rdi), %rsi
movq %r14, %rdi
callq 0x44eb8e
testl %eax, %eax
je 0x44a840
movl 0xaa4(%rbx), %esi
leaq 0x1b3b04(%rip), %rcx # 0x5fe330
movq %rbx, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4437e8
movq %rbx, %rdi
movq ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
session_reschedule_stream | static void session_reschedule_stream(nghttp2_session *session,
nghttp2_stream *stream) {
stream->last_writelen = stream->item->frame.hd.length;
if (!(stream->flags & NGHTTP2_STREAM_FLAG_NO_RFC7540_PRIORITIES)) {
nghttp2_stream_reschedule(stream);
return;
}
if (!s... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x98(%rsi), %rax
movq (%rax), %r15
movq %r15, 0xa0(%rsi)
testb $0x10, 0xd8(%rsi)
jne 0x44af83
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x44c22b
cmpb $0x0, 0xb1c(%rdi)
je 0x44afdb
movzbl 0xdc(%rbx), %ecx
movl %ecx, %eax
andl $0x7f, %eax
cmpb $0x8, %al
jae 0x... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_get_stream_user_data | void *nghttp2_session_get_stream_user_data(nghttp2_session *session,
int32_t stream_id) {
nghttp2_stream *stream;
stream = nghttp2_session_get_stream(session, stream_id);
if (stream) {
return stream->stream_user_data;
} else {
return NULL;
}
} | pushq %rax
callq 0x45363a
testq %rax, %rax
je 0x44b03c
testb $0x2, 0xd8(%rax)
jne 0x44b03c
cmpl $0x5, 0xcc(%rax)
jne 0x44b040
xorl %eax, %eax
popq %rcx
retq
movq 0x90(%rax), %rax
jmp 0x44b03e
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_get_stream_local_window_size | int32_t nghttp2_session_get_stream_local_window_size(nghttp2_session *session,
int32_t stream_id) {
nghttp2_stream *stream;
int32_t size;
stream = nghttp2_session_get_stream(session, stream_id);
if (stream == NULL) {
return -1;
}
size = stream->local... | pushq %rax
callq 0x45363a
testq %rax, %rax
je 0x44b224
testb $0x2, 0xd8(%rax)
jne 0x44b224
cmpl $0x5, 0xcc(%rax)
jne 0x44b22b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
movl 0xbc(%rax), %ecx
subl 0xb0(%rax), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
jmp 0x44b229
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_session_upgrade_internal | static int nghttp2_session_upgrade_internal(nghttp2_session *session,
const uint8_t *settings_payload,
size_t settings_payloadlen,
void *stream_user_data) {
nghttp2_stream *stream;
ngh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rcx
movq %rdi, %rbx
cmpb $0x0, 0xb1c(%rdi)
je 0x44b3bd
movl $0xfffffe07, %ebp # imm = 0xFFFFFE07
cmpl $0x0, 0xaa0(%rbx)
jg 0x44b535
jmp 0x44b3cf
movl $0xfffffe07, %ebp # imm = 0xFFF... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
session_headers_add_pad | static int session_headers_add_pad(nghttp2_session *session,
nghttp2_frame *frame) {
int rv;
ssize_t padded_payloadlen;
nghttp2_active_outbound_item *aob;
nghttp2_bufs *framebufs;
size_t padlen;
size_t max_payloadlen;
aob = &session->aob;
framebufs = &aob->framebufs;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x100, %edx # imm = 0x100
addq (%rsi), %rdx
movl $0x4000, %eax # imm = 0x4000
cmpq %rax, %rdx
cmovaeq %rax, %rdx
callq 0x44aef9
movq %rax, %r15
cmpl $0xfffffc7c, %r15d # imm = 0xFFFFFC7C
jl 0x44bdcf
addq $0x290, %r14 ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_session.c |
nghttp2_stream_get_state | nghttp2_stream_proto_state nghttp2_stream_get_state(nghttp2_stream *stream) {
if (stream->flags & NGHTTP2_STREAM_FLAG_CLOSED) {
return NGHTTP2_STREAM_STATE_CLOSED;
}
if (stream->flags & NGHTTP2_STREAM_FLAG_PUSH) {
if (stream->shut_flags & NGHTTP2_SHUT_RD) {
return NGHTTP2_STREAM_STATE_RESERVED_LOCA... | movzbl 0xd8(%rdi), %edx
movl $0x7, %eax
testb $0x2, %dl
jne 0x44ccbd
movzbl 0xd9(%rdi), %ecx
testb $0x1, %dl
jne 0x44cca9
movl $0x6, %eax
testb $0x1, %cl
jne 0x44ccbd
movl $0x5, %eax
testb $0x2, %cl
jne 0x44ccbd
xorl %eax, %eax
cmpl $0x5, 0xcc(%rdi)
setne %al
incl %eax
retq
movl $0x3, %eax
testb $0x1, %cl
jne 0x44ccbd
... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_stream.c |
nghttp2_submit_headers | int32_t nghttp2_submit_headers(nghttp2_session *session, uint8_t flags,
int32_t stream_id,
const nghttp2_priority_spec *pri_spec,
const nghttp2_nv *nva, size_t nvlen,
void *stream_user_data) {
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r12
cmpl $-0x1, %edx
je 0x44cea1
testl %ebp, %ebp
jg 0x44ceb7
movl $0xfffffe0b, %eax # imm = 0xFFFFFE0B
jmp 0x44ceb1
movl $0xfffffe07, %eax ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_submit.c |
nghttp2_bufs_wrap_init2 | int nghttp2_bufs_wrap_init2(nghttp2_bufs *bufs, const nghttp2_vec *vec,
size_t veclen, nghttp2_mem *mem) {
size_t i = 0;
nghttp2_buf_chain *cur_chain;
nghttp2_buf_chain *head_chain;
nghttp2_buf_chain **dst_chain = &head_chain;
if (veclen == 0) {
return nghttp2_bufs_wrap_init(b... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x44de82
movq %rdx, %r14
movq %rsi, %r12
movq %rdx, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
movq %r15, %rdi
callq 0x453800
movq %rax, (%rsp)
testq %rax, %rax
je 0x44de9c
addq $0x8, %r12
movq %rsp, %rsi
xorl ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_buf.c |
nghttp2_bufs_len | size_t nghttp2_bufs_len(nghttp2_bufs *bufs) {
nghttp2_buf_chain *ci;
size_t len;
len = 0;
for (ci = bufs->head; ci; ci = ci->next) {
len += nghttp2_buf_len(&ci->buf);
}
return len;
} | movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x44def8
addq 0x20(%rcx), %rax
subq 0x18(%rcx), %rax
movq (%rcx), %rcx
jmp 0x44dee6
retq
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_buf.c |
nghttp2_frame_push_promise_init | void nghttp2_frame_push_promise_init(nghttp2_push_promise *frame, uint8_t flags,
int32_t stream_id,
int32_t promised_stream_id,
nghttp2_nv *nva, size_t nvlen) {
nghttp2_frame_hd_init(&frame->hd, 0, NGHTTP2_P... | xorl %eax, %eax
movq %rax, (%rdi)
movb $0x5, 0xc(%rdi)
movb %sil, 0xd(%rdi)
movl %edx, 0x8(%rdi)
movb %al, 0xe(%rdi)
movq %rax, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %r9, 0x20(%rdi)
movl %ecx, 0x28(%rdi)
movb %al, 0x2c(%rdi)
retq
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
nghttp2_frame_altsvc_free | void nghttp2_frame_altsvc_free(nghttp2_extension *frame, nghttp2_mem *mem) {
nghttp2_ext_altsvc *altsvc;
altsvc = frame->payload;
if (altsvc == NULL) {
return;
}
/* We use the same buffer for altsvc->origin and
altsvc->field_value. */
nghttp2_mem_free(mem, altsvc->origin);
} | movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x44e511
movq (%rax), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x45380f
retq
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
nghttp2_frame_origin_init | void nghttp2_frame_origin_init(nghttp2_extension *frame,
nghttp2_origin_entry *ov, size_t nov) {
nghttp2_ext_origin *origin;
size_t payloadlen = 0;
size_t i;
for (i = 0; i < nov; ++i) {
payloadlen += 2 + ov[i].origin_len;
}
nghttp2_frame_hd_init(&frame->hd, payloadlen, N... | testq %rdx, %rdx
je 0x44e535
leaq 0x8(%rsi), %rcx
xorl %eax, %eax
movq %rdx, %r8
movq (%rcx), %r9
addq %r9, %rax
addq $0x2, %rax
addq $0x10, %rcx
decq %r8
jne 0x44e520
jmp 0x44e537
xorl %eax, %eax
movq %rax, (%rdi)
movw $0xc, 0xc(%rdi)
movl $0x0, 0x8(%rdi)
movb $0x0, 0xe(%rdi)
movq 0x10(%rdi), %rax
movq %rsi, 0x8(%rax)... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
nghttp2_frame_pack_goaway | int nghttp2_frame_pack_goaway(nghttp2_bufs *bufs, nghttp2_goaway *frame) {
int rv;
nghttp2_buf *buf;
assert(bufs->head == bufs->cur);
buf = &bufs->head->buf;
buf->pos -= NGHTTP2_FRAME_HDLEN;
nghttp2_frame_pack_frame_hd(buf->pos, &frame->hd);
nghttp2_put_uint32be(buf->last, (uint32_t)frame->last_strea... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
cmpq 0x8(%rdi), %r15
jne 0x44ecb7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%r15), %rdi
addq $-0x9, %rdi
movq %rdi, 0x18(%r15)
callq 0x44e264
movq 0x20(%r15), %rdi
movl 0x10(%r14), %esi
callq 0x443340
movq 0x20(%r15), %rdi
addq $0x4, %rdi
movq %rdi, 0x20(%r15)
movl 0x1... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
nghttp2_frame_pack_window_update | int nghttp2_frame_pack_window_update(nghttp2_bufs *bufs,
nghttp2_window_update *frame) {
nghttp2_buf *buf;
assert(bufs->head == bufs->cur);
buf = &bufs->head->buf;
assert(nghttp2_buf_avail(buf) >= 4);
buf->pos -= NGHTTP2_FRAME_HDLEN;
nghttp2_frame_pack_frame_hd(buf-... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
jne 0x44ee19
movq 0x10(%r14), %rax
subq 0x20(%r14), %rax
cmpq $0x3, %rax
jbe 0x44ee38
movq %rsi, %rbx
movq 0x18(%r14), %rdi
addq $-0x9, %rdi
movq %rdi, 0x18(%r14)
callq 0x44e264
movq 0x20(%r14), %rdi
movl 0x10(%rbx), %esi
callq 0x443340
addq $0x4, ... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
nghttp2_frame_pack_priority_update | int nghttp2_frame_pack_priority_update(nghttp2_bufs *bufs,
nghttp2_extension *frame) {
int rv;
nghttp2_buf *buf;
nghttp2_ext_priority_update *priority_update;
/* This is required with --disable-assert. */
(void)rv;
priority_update = frame->payload;
buf = &bufs->he... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
movq 0x10(%r14), %rax
subq 0x20(%r14), %rax
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rcx
addq $0x4, %rcx
cmpq %rcx, %rax
jb 0x44f233
movq %rdi, %rbx
movq 0x18(%r14), %rdi
addq $-0x9, %rdi
movq %rdi, 0x18(%r14)
callq 0x44e264
movq 0x20(%r14), %rdi
movl (%r15), %esi
callq... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_frame.c |
hd_context_init | static int hd_context_init(nghttp2_hd_context *context, nghttp2_mem *mem) {
int rv;
context->mem = mem;
context->bad = 0;
context->hd_table_bufsize_max = NGHTTP2_HD_DEFAULT_MAX_BUFFER_SIZE;
rv = hd_ringbuf_init(
&context->hd_table,
context->hd_table_bufsize_max / NGHTTP2_HD_ENTRY_OVERHEAD, mem);
... | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movb $0x0, 0x3c(%rdi)
movq $0x1000, 0x30(%rdi) # imm = 0x1000
movl $0x400, %esi # imm = 0x400
movq %rax, %rdi
callq 0x453800
movq %rax, (%rbx)
testq %rax, %rax
je 0x44f885
movq $0x7f, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
mo... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_hd.c |
nghttp2_hd_table_get | nghttp2_hd_nv nghttp2_hd_table_get(nghttp2_hd_context *context, size_t idx) {
assert(INDEX_RANGE_VALID(context, idx));
if (idx >= NGHTTP2_STATIC_TABLE_LENGTH) {
return hd_ringbuf_get(&context->hd_table, idx - NGHTTP2_STATIC_TABLE_LENGTH)
->nv;
} else {
const nghttp2_hd_static_entry *ent = &static_... | pushq %rbx
movq 0x18(%rsi), %rax
addq $0x3d, %rax
cmpq %rdx, %rax
jbe 0x44fbaf
movq %rdi, %rbx
cmpq $0x3d, %rdx
jb 0x44fb83
addq $-0x3d, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x44fbce
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
jmp 0x44fbaa
shlq $0x7, %rdx
leaq 0x331672(%r... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_hd.c |
nghttp2_hd_deflate_bound | size_t nghttp2_hd_deflate_bound(nghttp2_hd_deflater *deflater,
const nghttp2_nv *nva, size_t nvlen) {
size_t n = 0;
size_t i;
(void)deflater;
/* Possible Maximum Header Table Size Change. Encoding (1u << 31) -
1 using 4 bit prefix requires 6 bytes. We may emit this at mos... | leaq (%rdx,%rdx,2), %rax
leaq 0xc(,%rax,4), %rax
testq %rdx, %rdx
je 0x450305
addq $0x18, %rsi
addq -0x8(%rsi), %rax
addq (%rsi), %rax
addq $0x28, %rsi
decq %rdx
jne 0x4502f5
retq
| /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_hd.c |
nghttp2_hd_inflate_hd2 | ssize_t nghttp2_hd_inflate_hd2(nghttp2_hd_inflater *inflater,
nghttp2_nv *nv_out, int *inflate_flags,
const uint8_t *in, size_t inlen, int in_final) {
ssize_t rv;
nghttp2_hd_nv hd_nv;
rv = nghttp2_hd_inflate_hd_nv(inflater, &hd_nv, inflate_flags, in, ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rsp, %rsi
callq 0x450434
testq %rax, %rax
js 0x45042c
testb $0x2, (%r14)
je 0x45042c
movq (%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, (%rbx)
movq 0x18(%rcx), %rcx
movq %rcx, 0x10(%rbx)
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_hd.c |
emit_indname_block | static int emit_indname_block(nghttp2_bufs *bufs, size_t idx,
const nghttp2_nv *nv, int indexing_mode) {
int rv;
uint8_t *bufp;
size_t blocklen;
uint8_t sb[16];
size_t prefixlen;
if (indexing_mode == NGHTTP2_HD_WITH_INDEXING) {
prefixlen = 6;
} else {
prefixlen = 4;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
incq %r15
testl %ecx, %ecx
movl $0xffffffc0, %eax # imm = 0xFFFFFFC0
movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0
cmovel %eax, %ebp
movl %ebp, %r13d
notl %r13d
movq %r15, %r12
subq... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_hd.c |
parse_uint | static int64_t parse_uint(const uint8_t *s, size_t len) {
int64_t n = 0;
size_t i;
if (len == 0) {
return -1;
}
for (i = 0; i < len; ++i) {
if ('0' <= s[i] && s[i] <= '9') {
if (n > INT64_MAX / 10) {
return -1;
}
n *= 10;
if (n > INT64_MAX - (s[i] - '0')) {
retu... | testq %rsi, %rsi
je 0x452fc7
xorl %ecx, %ecx
movabsq $0xccccccccccccccc, %rdx # imm = 0xCCCCCCCCCCCCCCC
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
xorl %eax, %eax
movzbl (%rdi,%rcx), %r9d
leal -0x3a(%r9), %r10d
cmpb $-0xa, %r10b
jb 0x452fc7
cmpq %rdx, %rax
jg 0x452fc7
addq %rax, %rax
leaq (%rax,%rax,4)... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_http.c |
nghttp2_map_print_distance | void nghttp2_map_print_distance(nghttp2_map *map) {
uint32_t i;
size_t idx;
nghttp2_map_bucket *bkt;
for (i = 0; i < map->tablelen; ++i) {
bkt = &map->table[i];
if (bkt->data == NULL) {
fprintf(stderr, "@%u <EMPTY>\n", i);
continue;
}
idx = h2idx(bkt->hash, map->tablelenbits);
... | cmpl $0x0, 0x18(%rdi)
je 0x453431
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1c(%rdi), %r14
movq 0x332b2c(%rip), %r13 # 0x785f08
leaq 0x1b1d56(%rip), %r15 # 0x605139
xorl %ebp, %ebp
xorl %r12d, %r12d
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi,%rbp)
jne 0x453406
... | /JKorbelRA[P]CMake/Utilities/cmnghttp2/lib/nghttp2_map.c |
Json::Features::strictMode() | Features Features::strictMode() {
Features features;
features.allowComments_ = false;
features.strictRoot_ = true;
features.allowDroppedNullPlaceholders_ = false;
features.allowNumericKeys_ = false;
return features;
} | movl $0x100, %eax # imm = 0x100
retq
| /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::Reader() | Reader::Reader() : features_(Features::all()) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0x45b52c
leaq 0x50(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movups %x... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::parse(char const*, char const*, Json::Value&, bool) | bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root,
bool collectComments) {
if (!features_.allowComments_) {
collectComments = false;
}
begin_ = beginDoc;
end_ = endDoc;
collectComments_ = collectComments;
current_ = begin_;
lastValueEnd_ = nullptr;
lastValu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
andb 0x108(%rdi), %r8b
movq %rsi, 0xc0(%rdi)
movq %rdx, 0xc8(%rdi)
movb %r8b, 0x10c(%rdi)
movq %rsi, 0xd0(%rdi)
movq $0x0, 0xf0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::readComment() | bool Reader::readComment() {
Location commentBegin = current_ - 1;
Char c = getNextChar();
bool successful = false;
if (c == '*')
successful = readCStyleComment();
else if (c == '/')
successful = readCppStyleComment();
if (!successful)
return false;
if (collectComments_) {
CommentPlacemen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xd0(%rdi), %rbx
cmpq 0xc8(%rdi), %rbx
je 0x455531
movq %rdi, %r14
leaq 0x1(%rbx), %rax
movq %rax, 0xd0(%rdi)
movzbl (%rbx), %r12d
cmpl $0x2a, %r12d
je 0x4554c4
cmpl $0x2f, %r12d
jne 0x455531
movq %r14, %rdi
callq 0x455694
jmp 0x4554d0
movq %r14, %rdi
callq 0x... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::Reader::getFormattedErrorMessages[abi:cxx11]() const | String Reader::getFormattedErrorMessages() const {
String formattedMessage;
for (const auto& error : errors_) {
formattedMessage +=
"* " + getLocationLineAndColumn(error.token_.start_) + "\n";
formattedMessage += " " + error.message_ + "\n";
if (error.extra_)
formattedMessage +=
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %r15
movq %rsi, 0x48(%rsp)
movq 0x80(%rsi), %rax
movq %rax, 0x80(%rsp)
cmpq %rax, %r15
je 0x456936
... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::OurReader::skipCommentTokens(Json::OurReader::Token&) | void OurReader::skipCommentTokens(Token& token) {
if (features_.allowComments_) {
do {
readToken(token);
} while (token.type_ == tokenComment);
} else {
readToken(token);
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x110(%rdi)
jne 0x4578c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x458376
cmpl $0xf, (%rbx)
je 0x4578ab
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x458376
nop
| /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::OurReader::decodeString(Json::OurReader::Token&) | bool OurReader::decodeString(Token& token) {
String decoded_string;
if (!decodeString(token, decoded_string))
return false;
Value decoded(decoded_string);
currentValue().swapPayload(decoded);
currentValue().setOffsetStart(token.start_ - begin_);
currentValue().setOffsetLimit(token.end_ - begin_);
retu... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %rdx
callq 0x458cee
movl %eax, %ebx
testb %al, %al
je 0x45831f
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x45d4e6
movq 0x30(%r14)... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::CharReaderBuilder::newCharReader() const | CharReader* CharReaderBuilder::newCharReader() const {
bool collectComments = settings_["collectComments"].asBool();
OurFeatures features = OurFeatures::all();
features.allowComments_ = settings_["allowComments"].asBool();
features.allowTrailingCommas_ = settings_["allowTrailingCommas"].asBool();
features.str... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
addq $0x8, %r14
leaq 0x166df8(%rip), %rsi # 0x5c0ee8
movq %r14, %rdi
callq 0x45f97e
movq %rax, %rdi
callq 0x45e7fe
movl %eax, %ebp
leaq 0x8(%rsp), %rbx
movq $0x0, 0x8(%rbx)
leaq 0x1ab9c0(%rip), %rsi # 0x605ad6
movq %r14, %rdi
callq 0x45f97e
movq %r... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_reader.cpp |
Json::Value::CZString::~CZString() | Value::CZString::~CZString() {
if (cstr_ && storage_.policy_ == duplicate) {
releaseStringValue(const_cast<char*>(cstr_),
storage_.length_ + 1U); // +1 for null terminating
// character for sake of
... | movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x45cf3c
movl 0x8(%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x3be90
retq
nop
| /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_value.cpp |
Json::duplicateAndPrefixStringValue(char const*, unsigned int) | static inline char* duplicateAndPrefixStringValue(const char* value,
unsigned int length) {
// Avoid an integer overflow in the call to malloc below by limiting length
// to a sane value.
JSON_ASSERT_MESSAGE(length <= static_cast<unsigned>(Value::maxInt) -
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
cmpl $0x7ffffffb, %esi # imm = 0x7FFFFFFB
jae 0x45d3b4
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
leaq 0x5(%r14), %rdi
callq 0x3bee0
testq %rax, %rax
je 0x45d3ea
movq %rax, %r15
movl %ebp, (%rax)
movq %rax, %rdi
addq $0x4... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_value.cpp |
Json::Value::releasePayload() | void Value::releasePayload() {
switch (type()) {
case nullValue:
case intValue:
case uintValue:
case realValue:
case booleanValue:
break;
case stringValue:
if (isAllocated())
releasePrefixedStringValue(value_.string_);
break;
case arrayValue:
case objectValue:
delete value_.map_;... | pushq %rbx
movzwl 0x8(%rdi), %eax
cmpb $0x7, %al
ja 0x45d805
movzbl %al, %ecx
movl $0x2f, %edx
btl %ecx, %edx
jae 0x45d7ce
popq %rbx
retq
movl $0xc0, %edx
btl %ecx, %edx
jae 0x45d7f6
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x45d7e8
movq %rbx, %rdi
callq 0x461472
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x39320
btl ... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_value.cpp |
Json::Value::operator[](int) const | const Value& Value::operator[](int index) const {
JSON_ASSERT_MESSAGE(
index >= 0,
"in Json::Value::operator[](int index) const: index cannot be negative");
return (*this)[ArrayIndex(index)];
} | pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
testl %esi, %esi
js 0x45f217
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
jmp 0x45f0d0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3b3d0
leaq 0x1a706e(%rip), %rsi # 0x606299
movl $0x45, %edx
movq %rbx, %rdi
callq 0x3b4d0
leaq 0x30(%rsp), %rsi
leaq 0x8(%... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_value.cpp |
Json::FastWriter::write[abi:cxx11](Json::Value const&) | String FastWriter::write(const Value& root) {
document_.clear();
writeValue(root);
if (!omitEndingLineFeed_)
document_ += '\n';
return document_;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rsi)
movq 0x8(%rsi), %rax
movb $0x0, (%rax)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x462de2
cmpb $0x0, 0x2a(%r14)
jne 0x462dbd
leaq 0x8(%r14), %rdi
movl $0xa, %esi
callq 0x3bc40
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp |
Json::StyledWriter::writeValue(Json::Value const&) | void StyledWriter::writeValue(const Value& value) {
switch (value.type()) {
case nullValue:
pushValue("null");
break;
case intValue:
pushValue(valueToString(value.asLargestInt()));
break;
case uintValue:
pushValue(valueToString(value.asLargestUInt()));
break;
case realValue:
pushVa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
callq 0x45d8e0
cmpl $0x7, %eax
ja 0x4636dc
movl %eax, %eax
leaq 0x1a3324(%rip), %rcx # 0x60668c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rsp), %r14
movq %r1... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp |
Json::StyledStreamWriter::isMultilineArray(Json::Value const&) | bool StyledStreamWriter::isMultilineArray(const Value& value) {
ArrayIndex const size = value.size();
bool isMultiLine = size * 3 >= rightMargin_;
childValues_.clear();
for (ArrayIndex index = 0; index < size && !isMultiLine; ++index) {
const Value& childValue = value[index];
isMultiLine = ((childValue.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x45eab6
movl %eax, %r15d
leal (%r15,%r15,2), %eax
cmpl 0x40(%rbx), %eax
setae %bpl
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x9a1e8
testl %r15d, %r15d
sete %al
orb %bpl, %al
testb $0x1, %al... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp |
Json::BuiltStyledStreamWriter::write(Json::Value const&, std::ostream*) | int BuiltStyledStreamWriter::write(Value const& root, OStream* sout) {
sout_ = sout;
addChildValues_ = false;
indented_ = true;
indentString_.clear();
writeCommentBeforeValue(root);
if (!indented_)
writeIndent();
indented_ = true;
writeValue(root);
writeCommentAfterValueOnSameLine(root);
*sout_ ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, 0x8(%rdi)
movb 0xd8(%rdi), %al
andb $-0x4, %al
orb $0x2, %al
movb %al, 0xd8(%rdi)
movq $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
callq 0x464d48
movb 0xd8(%rbx), %al
testb $0x2, %al
jne 0x464d00
movq %rbx, %rdi
callq 0x464e60
movb... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp |
Json::BuiltStyledStreamWriter::writeCommentBeforeValue(Json::Value const&) | void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root) {
if (cs_ == CommentStyle::None)
return;
if (!root.hasComment(commentBefore))
return;
if (!indented_)
writeIndent();
const String& comment = root.getComment(commentBefore);
String::const_iterator iter = comment.begin();
wh... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0x70(%rdi)
je 0x464e2d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x460716
testb %al, %al
je 0x464e2d
testb $0x2, 0xd8(%rbx)
jne 0x464d86
movq %rbx, %rdi
callq 0x464e60
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi... | /JKorbelRA[P]CMake/Utilities/cmjsoncpp/src/lib_json/json_writer.cpp |
archive_entry_new2 | struct archive_entry *
archive_entry_new2(struct archive *a)
{
struct archive_entry *entry;
entry = (struct archive_entry *)calloc(1, sizeof(*entry));
if (entry == NULL)
return (NULL);
entry->archive = a;
entry->ae_symlink_type = AE_SYMLINK_TYPE_UNDEFINED;
return (entry);
} | pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x500, %esi # imm = 0x500
callq 0x3bed8
testq %rax, %rax
je 0x466ce3
movq %rbx, (%rax)
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c |
archive_entry_gname | const char *
archive_entry_gname(struct archive_entry *entry)
{
const char *p;
if (archive_mstring_get_mbs(entry->archive, &entry->ae_gname, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
movq (%rdi), %rax
leaq 0x140(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x49552b
testl %eax, %eax
je 0x466fbe
callq 0x3b610
cmpl $0xc, (%rax)
je 0x466fc4
xorl %eax, %eax
jmp 0x466fc2
movq (%rsp), %rax
popq %rcx
retq
leaq 0x19fdd9(%rip), %rsi # 0x606da4
movl $0x1, %edi
callq 0x498c83
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c |
archive_entry_hardlink_utf8 | const char *
archive_entry_hardlink_utf8(struct archive_entry *entry)
{
const char *p;
if ((entry->ae_set & AE_SET_HARDLINK) == 0)
return (NULL);
if (archive_mstring_get_utf8(
entry->archive, &entry->ae_hardlink, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
testb $0x1, 0xc0(%rdi)
je 0x4670e3
movq %rdi, %rsi
movq (%rdi), %rdi
addq $0x1a8, %rsi # imm = 0x1A8
movq %rsp, %rdx
callq 0x495461
testl %eax, %eax
je 0x4670e7
callq 0x3b610
cmpl $0xc, (%rax)
je 0x4670ed
xorl %eax, %eax
popq %rcx
retq
movq (%rsp), %rax
jmp 0x4670e5
leaq 0x19fcb0(%rip), %rsi # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c |
archive_entry_symlink | const char *
archive_entry_symlink(struct archive_entry *entry)
{
const char *p;
if ((entry->ae_set & AE_SET_SYMLINK) == 0)
return (NULL);
if (archive_mstring_get_mbs(
entry->archive, &entry->ae_symlink, &p) == 0)
return (p);
if (errno == ENOMEM)
__archive_errx(1, "No memory");
return (NULL);
} | pushq %rax
testb $0x2, 0xc0(%rdi)
je 0x46739a
movq %rdi, %rsi
movq (%rdi), %rdi
addq $0x278, %rsi # imm = 0x278
movq %rsp, %rdx
callq 0x49552b
testl %eax, %eax
je 0x46739e
callq 0x3b610
cmpl $0xc, (%rax)
je 0x4673a4
xorl %eax, %eax
popq %rcx
retq
movq (%rsp), %rax
jmp 0x46739c
leaq 0x19f9f9(%rip), %rsi # ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry.c |
archive_entry_sparse_next | int
archive_entry_sparse_next(struct archive_entry * entry,
la_int64_t *offset, la_int64_t *length)
{
if (entry->sparse_p) {
*offset = entry->sparse_p->offset;
*length = entry->sparse_p->length;
entry->sparse_p = entry->sparse_p->next;
return (ARCHIVE_OK);
} else {
*offset = 0;
*length = 0;
return (A... | movq 0x4e8(%rdi), %rax
testq %rax, %rax
je 0x4686c3
movq 0x8(%rax), %rcx
movq %rcx, (%rsi)
movq (%rax), %rsi
movq 0x10(%rax), %rcx
movq %rsi, 0x4e8(%rdi)
xorl %eax, %eax
jmp 0x4686d1
movq $0x0, (%rsi)
movl $0xffffffec, %eax # imm = 0xFFFFFFEC
xorl %ecx, %ecx
movq %rcx, (%rdx)
retq
nopl (%rax)
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_entry_sparse.c |
archive_match_include_date_w | int
archive_match_include_date_w(struct archive *_a, int flag,
const wchar_t *datestr)
{
int r;
r = validate_time_flag(_a, flag, "archive_match_include_date_w");
if (r != ARCHIVE_OK)
return (r);
return set_timefilter_date_w((struct archive_match *)_a, flag, datestr);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x19d7a4(%rip), %rdx # 0x6073e5
callq 0x469a3d
movl %eax, %r15d
testl %eax, %eax
jne 0x469ce1
testq %r14, %r14
je 0x469cc5
cmpl $0x0, (%r14)
je 0x469cc5
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c |
match_path_inclusion | static int
match_path_inclusion(struct archive_match *a, struct match *m,
int mbs, const void *pn)
{
/* Recursive operation requires only a prefix match. */
int flag = a->recursive_include ?
PATHMATCH_NO_ANCHOR_END :
0;
int r;
if (mbs) {
const char *p;
r = archive_mstring_get_mbs(&(a->archive), &(m->pa... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl 0x94(%rdi), %ebp
addq $0x10, %rsi
leaq 0x8(%rsp), %rdx
callq 0x49552b
testl %eax, %eax
je 0x46a661
callq 0x3b610
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xc, (%rcx)
jne 0x46a677
leaq 0x19c760(%rip), %rdx # 0x606da4
movq %rbx, %rdi
m... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_match.c |
_archive_pathmatch | int
__archive_pathmatch(const char *p, const char *s, int flags)
{
/* Empty pattern only matches the empty string. */
if (p == NULL || *p == '\0')
return (s == NULL || *s == '\0');
else if (s == NULL)
return (0);
/* Leading '^' anchors the start of the pattern. */
if (*p == '^') {
++p;
flags &= ~PATHMATCH... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
testq %rdi, %rdi
je 0x46a79a
movq %rdi, %r14
movb (%rdi), %sil
testb %sil, %sil
je 0x46a79a
xorl %ebp, %ebp
testq %rax, %rax
je 0x46a7fd
movl %edx, %ebx
andl $-0x2, %ebx
xorl %ecx, %ecx
cmpb $0x5e, %sil
sete %cl
cmovnel %edx, %ebx
movzbl (%r14,%rcx)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_pathmatch.c |
_archive_rb_tree_find_node | struct archive_rb_node *
__archive_rb_tree_find_node(struct archive_rb_tree *rbt, const void *key)
{
archive_rbto_compare_key_fn compare_key = rbt->rbt_ops->rbto_compare_key;
struct archive_rb_node *parent = rbt->rbt_root;
while (!RB_SENTINEL_P(parent)) {
const signed int diff = (*compare_key)(parent, key);
if ... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x46af98
movq %rsi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
je 0x46af9a
setg %al
movzbl %al, %eax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
jne 0x46af7c
xorl %ebx, %ebx
movq %rbx, %... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_rb.c |
archive_read_extract_set_skip_file | void
archive_read_extract_set_skip_file(struct archive *_a, la_int64_t d,
la_int64_t i)
{
struct archive_read *a = (struct archive_read *)_a;
if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_ANY, "archive_read_extract_set_skip_file"))
return;
a->skip_file_set = 1;
a->skip_file_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x19bffd(%rip), %rcx # 0x607622
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x7fff, %edx # imm = 0x7FFF
callq 0x4b87c0
testl %eax, %eax
jne 0x46b651
movl $0x1, 0x98(%r14)
movq %r15, 0xa0(%r14)
movq %rbx, 0xa8(%r14... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c |
close_filters | static int
close_filters(struct archive_read *a)
{
struct archive_read_filter *f = a->filter;
int r = ARCHIVE_OK;
/* Close each filter in the pipeline. */
while (f != NULL) {
struct archive_read_filter *t = f->upstream;
if (!f->closed && f->vtable != NULL) {
int r1 = (f->vtable->close)(f);
f->closed = 1;
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x46bee1
movq %rdi, %r14
xorl %ebx, %ebx
movq %r14, %r15
movq 0x10(%r14), %r14
cmpb $0x0, 0x89(%r15)
jne 0x46bec9
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x46bec9
movq %r15, %rdi
callq *0x8(%rax)
movb $0x1, 0x89(%r15)
cmpl %ebx, %eax
cmovll %eax, %ebx
movq 0x48(%r1... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c |
_archive_read_register_format | int
__archive_read_register_format(struct archive_read *a,
void *format_data,
const char *name,
int (*bid)(struct archive_read *, int),
int (*options)(struct archive_read *, const char *, const char *),
int (*read_header)(struct archive_read *, struct archive_entry *),
int (*read_data)(struct ar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x19b516(%rip), %rcx # 0x607847
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x4b87c0
movl $0xffffffe2, %ebp #... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c |
client_seek_proxy | static int64_t
client_seek_proxy(struct archive_read_filter *self, int64_t offset, int whence)
{
/* DO NOT use the skipper here! If we transparently handled
* forward seek here by using the skipper, that will break
* other libarchive code that assumes a successful forward
* seek means it can also seek backwards... | movq %rdi, %rax
movq 0x18(%rdi), %rdi
movq 0xc8(%rdi), %r8
testq %r8, %r8
je 0x46cdec
movl %edx, %ecx
movq %rsi, %rdx
movq 0x28(%rax), %rsi
jmpq *%r8
pushq %rax
leaq 0x19ac8a(%rip), %rdx # 0x607a7e
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x498bac
movq $-0x19, %rax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read.c |
tree_current_is_physical_dir | static int
tree_current_is_physical_dir(struct tree *t)
{
const struct stat *st;
/*
* If stat() says it isn't a dir, then it's not a dir.
* If stat() data is cached, this check is free, so do it first.
*/
if (t->flags & hasStat) {
st = tree_current_stat(t);
if (st == NULL)
return (0);
if (!S_ISDIR(st... | pushq %rbx
movq %rdi, %rbx
testb $0x10, 0x20(%rdi)
je 0x46e01b
movq %rbx, %rdi
callq 0x46f8a0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x46e03f
movl $0xf000, %edx # imm = 0xF000
andl 0x18(%rcx), %edx
cmpl $0x4000, %edx # imm = 0x4000
jne 0x46e03f
movq %rbx, %rdi
callq 0x46f86c
testq %rax,... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
tree_pop | static void
tree_pop(struct tree *t)
{
struct tree_entry *te;
t->path.s[t->dirname_length] = '\0';
t->path.length = t->dirname_length;
if (t->stack == t->current && t->current != NULL)
t->current = t->current->parent;
te = t->stack;
t->stack = te->next;
t->dirname_length = te->dirname_length;
t->basename = t... | pushq %rbx
movq 0x30(%rdi), %rax
movq 0x50(%rdi), %rcx
movb $0x0, (%rax,%rcx)
movq 0x50(%rdi), %rax
movq %rax, 0x38(%rdi)
movq (%rdi), %rbx
movq 0x8(%rdi), %rax
cmpq %rax, %rbx
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x46f812
movq 0x10(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rbx), %rax
movq %rax, (%rdi)... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
get_xfer_size | static int
get_xfer_size(struct tree *t, int fd, const char *path)
{
t->current_filesystem->xfer_align = -1;
errno = 0;
if (fd >= 0) {
t->current_filesystem->incr_xfer_size =
fpathconf(fd, _PC_REC_INCR_XFER_SIZE);
t->current_filesystem->max_xfer_size =
fpathconf(fd, _PC_REC_MAX_XFER_SIZE);
t->curre... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x1e8(%rdi), %rax
movq $-0x1, 0x30(%rax)
callq 0x3b610
movq %rax, %rbx
movl $0x0, (%rax)
testl %ebp, %ebp
js 0x46fbf2
movl %ebp, %edi
movl $0xe, %esi
callq 0x3a4a0
movq 0x1e8(%r14), %rcx
movq %rax, 0x18(%rcx)
movl %ebp, %edi
movl $0xf, %esi
callq 0x3... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_disk_posix.c |
archive_read_open_filename_w | int
archive_read_open_filename_w(struct archive *a, const wchar_t *wfilename,
size_t block_size)
{
struct read_file_data *mine = (struct read_file_data *)calloc(1,
sizeof(*mine) + wcslen(wfilename) * sizeof(wchar_t));
if (!mine)
{
archive_set_error(a, ENOMEM, "No memory");
return (ARCHIVE_FATAL);
}
mine-... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3a830
leaq 0x28(,%rax,4), %rsi
movl $0x1, %edi
callq 0x3bed8
testq %rax, %rax
je 0x470686
movq %rax, %r14
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq %r12, 0x8(%rax)
testq %r15, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_open_filename.c |
archive_read_support_filter_all | int
archive_read_support_filter_all(struct archive *a)
{
archive_check_magic(a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_filter_all");
/* Bzip falls back to "bunzip2" command-line */
archive_read_support_filter_bzip2(a);
/* The decompress code doesn't use an outside library. */
archive_re... | pushq %rbx
movq %rdi, %rbx
leaq 0x1978b8(%rip), %rcx # 0x6080a0
movl $0xdeb0c5, %esi # imm = 0xDEB0C5
movl $0x1, %edx
callq 0x4b87c0
movl %eax, %ecx
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
cmpl $-0x1e, %ecx
je 0x470875
movq %rbx, %rdi
callq 0x47089a
movq %rbx, %rdi
callq 0x470c05
movq %rbx, %rdi
call... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_all.c |
archive_read_support_filter_gzip | int
archive_read_support_filter_gzip(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "gzip",
&gzip_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
/* Signal the extent of gzip support with the return value here. */
#if HAVE_ZLIB_H
r... | pushq %rax
leaq 0x185cbc(%rip), %rdx # 0x5f6e4e
leaq 0x3125ff(%rip), %rcx # 0x783798
xorl %esi, %esi
callq 0x46c3f9
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_gzip.c |
program_bidder_bid | static int
program_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *upstream)
{
struct program_bidder *state = self->data;
const char *p;
/* If we have a signature, use that to match. */
if (state->signature_len > 0) {
p = __archive_read_filter_ahead(upstream,
state->sign... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x18(%r14), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x471c72
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x46c4ac
testq %rax, %rax
je 0x471c86
movq 0x10(%r14), %rsi
movq 0x18(%r14), %r14
movq %rax, %rdi
movq %r14, %rdx
callq 0x3a8a0
testl %eax, %eax
jne... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_program.c |
program_filter_close | static int
program_filter_close(struct archive_read_filter *self)
{
struct program_filter *state;
int e;
state = (struct program_filter *)self->data;
e = child_stop(self, state);
/* Release our private data. */
free(state->out_buf);
archive_string_free(&state->description);
free(state);
return (e);
} | pushq %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
movq %rbx, %rsi
callq 0x471ee4
movl %eax, %ebp
movq 0x30(%rbx), %rdi
callq 0x3be90
movq %rbx, %rdi
callq 0x4948e7
movq %rbx, %rdi
callq 0x3be90
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_program.c |
rpm_bidder_bid | static int
rpm_bidder_bid(struct archive_read_filter_bidder *self,
struct archive_read_filter *filter)
{
const unsigned char *b;
ssize_t avail;
int bits_checked;
(void)self; /* UNUSED */
b = __archive_read_filter_ahead(filter, 8, &avail);
if (b == NULL)
return (0);
bits_checked = 0;
/*
* Verify Heade... | pushq %rax
movq %rsi, %rdi
movq %rsp, %rdx
movl $0x8, %esi
callq 0x46c4ac
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x472060
cmpl $0xdbeeabed, (%rcx) # imm = 0xDBEEABED
jne 0x472060
movb 0x4(%rcx), %dl
addb $-0x3, %dl
cmpb $0x1, %dl
ja 0x472060
cmpb $0x0, 0x6(%rcx)
jne 0x472060
xorl %edx, %edx
cmpb $0x2, ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_rpm.c |
uudecode_filter_close | static int
uudecode_filter_close(struct archive_read_filter *self)
{
struct uudecode *uudecode;
uudecode = (struct uudecode *)self->data;
free(uudecode->in_buff);
free(uudecode->out_buff);
free(uudecode);
return (ARCHIVE_OK);
} | pushq %rbx
movq 0x28(%rdi), %rbx
movq 0x8(%rbx), %rdi
callq 0x3be90
movq 0x20(%rbx), %rdi
callq 0x3be90
movq %rbx, %rdi
callq 0x3be90
xorl %eax, %eax
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_uu.c |
archive_read_support_filter_zstd | int
archive_read_support_filter_zstd(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
if (__archive_read_register_bidder(a, NULL, "zstd",
&zstd_bidder_vtable) != ARCHIVE_OK)
return (ARCHIVE_FATAL);
#if HAVE_ZSTD_H && HAVE_LIBZSTD
return (ARCHIVE_OK);
#else
archive_set_error(_a, ARCH... | pushq %rax
leaq 0x123093(%rip), %rdx # 0x596ae3
leaq 0x30fec1(%rip), %rcx # 0x783918
xorl %esi, %esi
callq 0x46c3f9
testl %eax, %eax
movl $0xffffffe2, %ecx # imm = 0xFFFFFFE2
cmovnel %ecx, %eax
popq %rcx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_filter_zstd.c |
archive_read_format_ar_skip | static int
archive_read_format_ar_skip(struct archive_read *a)
{
int64_t bytes_skipped;
struct ar* ar;
ar = (struct ar *)(a->format->data);
bytes_skipped = __archive_read_consume(a,
ar->entry_bytes_remaining + ar->entry_padding
+ ar->entry_bytes_unconsumed);
if (bytes_skipped < 0)
return (ARCHIVE_FAT... | pushq %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movq 0x18(%rbx), %rsi
addq (%rbx), %rsi
addq 0x8(%rbx), %rsi
callq 0x46c7ce
testq %rax, %rax
js 0x47449a
movq $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
jmp 0x47449f
movl $0xffffffe2, %eax # imm = 0xFFFFFFE2
popq %rbx
retq
| /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_ar.c |
archive_read_format_cab_bid | static int
archive_read_format_cab_bid(struct archive_read *a, int best_bid)
{
const char *p;
ssize_t bytes_avail, offset, window;
/* If there's already a better bid than we can ever
make, don't bother testing. */
if (best_bid > 64)
return (-1);
if ((p = __archive_read_ahead(a, 8, NULL)) == NULL)
return ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x40, %esi
jg 0x4748d2
movq %rdi, %rbx
movl $0x8, %esi
xorl %edx, %edx
callq 0x46c4a0
testq %rax, %rax
je 0x4748d2
cmpq $0x4643534d, (%rax) # imm = 0x4643534D
je 0x4748cd
xorl %ebp, %eb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c |
cab_minimum_consume_cfdata | static int64_t
cab_minimum_consume_cfdata(struct archive_read *a, int64_t consumed_bytes)
{
struct cab *cab = (struct cab *)(a->format->data);
struct cfdata *cfdata;
int64_t cbytes, rbytes;
int err;
cfdata = cab->entry_cfdata;
rbytes = consumed_bytes;
if (cab->entry_cffolder->comptype == COMPTYPE_NONE) {
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x818(%rdi), %rax
movq (%rax), %r13
movq 0x28(%r13), %rax
movq 0x38(%r13), %rbp
cmpw $0x0, 0x6(%rax)
je 0x475df1
movzwl 0xc(%rbp), %eax
movzwl 0xe(%rbp), %ecx
subq %rcx, %rax
jle 0x475dda
cmpq %rbx, %rax
cm... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c |
cab_checksum_cfdata | static uint32_t
cab_checksum_cfdata(const void *p, size_t bytes, uint32_t seed)
{
const unsigned char *b;
uint32_t sum;
uint32_t t;
sum = cab_checksum_cfdata_4(p, bytes, seed);
b = p;
b += bytes & ~3;
t = 0;
switch (bytes & 3) {
case 3:
t |= ((uint32_t)(*b++)) << 16;
/* FALL THROUGH */
case 2:
t |= ((u... | cmpl $0x4, %esi
jb 0x477cdb
movl %esi, %eax
shrl $0x2, %eax
xorl %ecx, %ecx
xorl (%rdi,%rcx,4), %edx
incq %rcx
cmpl %ecx, %eax
jne 0x477cd1
movq %rsi, %rax
andq $-0x4, %rax
addq %rax, %rdi
andl $0x3, %esi
xorl %eax, %eax
leaq 0x19136b(%rip), %rcx # 0x60905c
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
movzb... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cab.c |
archive_read_format_cpio_bid | static int
archive_read_format_cpio_bid(struct archive_read *a, int best_bid)
{
const unsigned char *p;
struct cpio *cpio;
int bid;
(void)best_bid; /* UNUSED */
cpio = (struct cpio *)(a->format->data);
if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
return (-1);
bid = 0;
if (memcmp(p, "070707", 6) == ... | pushq %rbx
movq 0x818(%rdi), %rax
movq (%rax), %rbx
movl $0x6, %esi
xorl %edx, %edx
callq 0x46c4a0
testq %rax, %rax
je 0x47890b
movl $0x37303730, %esi # imm = 0x37303730
movl (%rax), %edi
xorl %esi, %edi
movzwl 0x4(%rax), %r8d
xorl $0x3730, %r8d # imm = 0x3730
movl $0x30, %ecx
leaq 0x5e9(%rip), %rdx ... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
header_odc | static int
header_odc(struct archive_read *a, struct cpio *cpio,
struct archive_entry *entry, size_t *namelength, size_t *name_pad)
{
const void *h;
int r;
const char *header;
a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX;
a->archive.archive_format_name = "POSIX octet-oriented cpio";
/* Find the sta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, %r14
movl $0x10001, 0x10(%rdi) # imm = 0x10001
leaq 0x19067f(%rip), %rax # 0x609538
movq %rax, 0x18(%rdi)
leaq 0x30(%rsp), %rdx
movl $... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
header_newc | static int
header_newc(struct archive_read *a, struct cpio *cpio,
struct archive_entry *entry, size_t *namelength, size_t *name_pad)
{
const void *h;
const char *header;
int r;
r = find_newc_header(a);
if (r < ARCHIVE_WARN)
return (r);
/* Read fixed-size portion of header. */
h = __archive_read_ahead(a, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movl $0x6e, %esi
callq 0x46c4a0
testq %rax, %rax
je 0x4795bb
xorl %r14d, %r14d
movl $0x37303730, %r9d # imm = 0x3... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_cpio.c |
isSVD | static int
isSVD(struct iso9660 *iso9660, const unsigned char *h)
{
const unsigned char *p;
ssize_t logical_block_size;
int32_t volume_block;
int32_t location;
(void)iso9660; /* UNUSED */
/* Type 2 means it's a SVD. */
if (h[SVD_type_offset] != 2)
return (0);
/* Reserved field must be 0. */
if (!isNull(is... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpb $0x2, (%rsi)
jne 0x47b2a2
movq %rsi, %r14
movq 0x210(%rdi), %rax
cmpq 0x48(%rsi), %rax
jne 0x47b2a2
addq $0x210, %rdi # imm = 0x210
movb (%rdi), %al
cmpb 0x372(%r14), %al
jne 0x47b2a2
leaq 0x573(%r14), %rsi
movl $0x28d, %edx # imm = 0x28D
callq... | /JKorbelRA[P]CMake/Utilities/cmlibarchive/libarchive/archive_read_support_format_iso9660.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.