name string | code string | asm string | file string |
|---|---|---|---|
ossl_connect | static CURLcode ossl_connect(struct Curl_cfilter *cf,
struct Curl_easy *data,
bool *done)
{
CURLcode result = CURLE_OK;
struct ssl_connect_data *connssl = cf->ctx;
/* check if the connection has already been established */
if(ssl_connection_complete == ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movl $0x3, %eax
cmpl 0xb8(%rcx), %eax
jne 0xb5d4b
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
mo... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_close_all | static void ossl_close_all(struct Curl_easy *data)
{
#ifdef USE_OPENSSL_ENGINE
if(data->state.engine) {
ENGINE_finish(data->state.engine);
ENGINE_free(data->state.engine);
data->state.engine = NULL;
}
#else
(void)data;
#endif
#ifdef OPENSSL_HAS_PROVIDERS
ossl_provider_cleanup(data);
#endif
#ifndef H... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd60(%rax)
je 0xb6209
movq -0x8(%rbp), %rax
movq 0xd60(%rax), %rdi
callq 0x11550
movq -0x8(%rbp), %rax
movq 0xd60(%rax), %rdi
callq 0x117f0
movq -0x8(%rbp), %rax
movq $0x0, 0xd60(%rax)
movq -0x8(%rbp), %rdi
callq 0xb7d70... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_set_engine_default | static CURLcode ossl_set_engine_default(struct Curl_easy *data)
{
#ifdef USE_OPENSSL_ENGINE
if(data->state.engine) {
if(ENGINE_set_default(data->state.engine, ENGINE_METHOD_ALL) > 0) {
infof(data, "set default crypto engine '%s'",
ENGINE_get_id(data->state.engine));
}
else {
failf(... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd60(%rax)
je 0xb6421
movq -0x10(%rbp), %rax
movq 0xd60(%rax), %rdi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x11520
cmpl $0x0, %eax
jle 0xb63e9
jmp 0xb637a
cmpq $0x0, -0x10(%rbp)
je 0xb63e5
movq -0x10(%rbp), ... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_get_channel_binding | static CURLcode ossl_get_channel_binding(struct Curl_easy *data, int sockindex,
struct dynbuf *binding)
{
/* required for X509_get_signature_nid support */
#if OPENSSL_VERSION_NUMBER > 0x10100000L
X509 *cert;
int algo_nid;
const EVP_MD *algo_type;
const char *algo_name... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x1a783(%rip), %rax # 0xd12d0
movq %rax, -0xb0(%rbp)
movq 0x1a77d(%rip), %rax # 0xd12d8
movq %rax, -0xa8(%rbp)
movl 0x1a778(%rip), %eax # 0xd12e0
movl %eax, -0xa0(%rbp)
movw 0x1a76f(%rip), %... | /AraHaan[P]curl/lib/vtls/openssl.c |
load_cacert_from_memory | static CURLcode load_cacert_from_memory(X509_STORE *store,
const struct curl_blob *ca_info_blob)
{
/* these need to be freed at the end */
BIO *cbio = NULL;
STACK_OF(X509_INFO) *inf = NULL;
/* everything else is just a reference */
int i, count = 0;
X509_INFO *itmp =... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x7fffffff, 0x8(%rax) # imm = 0x7FFFFFFF
jbe 0xb6f59
movl $0x4d, -0x4(%rbp)
jmp 0xb70b9
movq -0x18(%rbp), %r... | /AraHaan[P]curl/lib/vtls/openssl.c |
passwd_callback | static int passwd_callback(char *buf, int num, int encrypting,
void *password)
{
DEBUGASSERT(0 == encrypting);
if(!encrypting && num >= 0 && password) {
int klen = curlx_uztosi(strlen((char *)password));
if(num > klen) {
memcpy(buf, password, klen + 1);
return klen;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0xb7538
cmpl $0x0, -0x18(%rbp)
jne 0xb7587
cmpl $0x0, -0x14(%rbp)
jl 0xb7587
cmpq $0x0, -0x20(%rbp)
je 0xb7587
movq -0x20(%rbp), %rdi
callq 0x10540
movq %rax, %rdi
callq 0xa8400
mo... | /AraHaan[P]curl/lib/vtls/openssl.c |
use_certificate_blob | static int use_certificate_blob(SSL_CTX *ctx, const struct curl_blob *blob,
int type, const char *key_passwd)
{
int ret = 0;
X509 *x = NULL;
/* the typecast of blob->len is fine since it is guaranteed to never be
larger than CURL_MAX_INPUT_LENGTH */
BIO *in = BIO_new_mem_buf... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0x101e0
movq %rax, -0x40(%rbp)
... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_set_provider | static CURLcode ossl_set_provider(struct Curl_easy *data, const char *iname)
{
char name[MAX_PROVIDER_LEN + 1];
struct Curl_str prov;
const char *propq = NULL;
if(!iname) {
/* clear and cleanup provider use */
ossl_provider_cleanup(data);
return CURLE_OK;
}
if(Curl_str_until(&iname, &prov, MAX_... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0xb8(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb788a
movq -0x10(%rbp), %rdi
callq 0xb7d70
movl $0x0, -0x4(%rbp)
jmp 0xb7ad2
leaq -0x18(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x80, %edx
movl $0x3a, ... | /AraHaan[P]curl/lib/vtls/openssl.c |
use_privatekey_blob | static int use_privatekey_blob(SSL_CTX *ctx, const struct curl_blob *blob,
int type, const char *key_passwd)
{
int ret = 0;
EVP_PKEY *pkey = NULL;
BIO *in = BIO_new_mem_buf(blob->data, (int)(blob->len));
if(!in)
return CURLE_OUT_OF_MEMORY;
if(type == SSL_FILETYPE_PEM)
p... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
callq 0x101e0
movq %rax, -0x40(%rbp)
... | /AraHaan[P]curl/lib/vtls/openssl.c |
ssl_ui_reader | static int ssl_ui_reader(UI *ui, UI_STRING *uis)
{
const char *password;
switch(UI_get_string_type(uis)) {
case UIT_PROMPT:
case UIT_VERIFY:
password = (const char *)UI_get0_user_data(ui);
if(password && (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD)) {
UI_set_result(ui, uis, password);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x118f0
decl %eax
subl $0x1, %eax
ja 0xb7c43
jmp 0xb7c02
movq -0x10(%rbp), %rdi
callq 0x10580
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb7c41
movq -0x18(%rbp), %rdi
callq 0x10480
andl $0x2, %e... | /AraHaan[P]curl/lib/vtls/openssl.c |
subj_alt_hostcheck | static bool subj_alt_hostcheck(struct Curl_easy *data,
const char *match_pattern,
size_t matchlen,
const char *hostname,
size_t hostlen,
const char *dispname)
{
#ifd... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xaf350
testb $0x1, %al
jne 0xb816b
jmp 0x... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_connect_step3 | static CURLcode ossl_connect_step3(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
CURLcode result = CURLE_OK;
struct ssl_connect_data *connssl = cf->ctx;
struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;
DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb8ff1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp)... | /AraHaan[P]curl/lib/vtls/openssl.c |
ossl_bio_cf_ctrl | static long ossl_bio_cf_ctrl(BIO *bio, int cmd, long num, void *ptr)
{
struct Curl_cfilter *cf = BIO_get_data(bio);
long ret = 1;
(void)cf;
(void)ptr;
switch(cmd) {
case BIO_CTRL_GET_CLOSE:
ret = (long)BIO_get_shutdown(bio);
break;
case BIO_CTRL_SET_CLOSE:
BIO_set_shutdown(bio, (int)num);
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11760
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0xa, %eax
ja 0xb... | /AraHaan[P]curl/lib/vtls/openssl.c |
Curl_ssl_free_certinfo | void Curl_ssl_free_certinfo(struct Curl_easy *data)
{
struct curl_certinfo *ci = &data->info.certs;
if(ci->num_of_certs) {
/* free all individual lists used */
int i;
for(i = 0; i < ci->num_of_certs; i++) {
curl_slist_free_all(ci->certinfo[i]);
ci->certinfo[i] = NULL;
}
free(ci->ce... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x13d0, %rax # imm = 0x13D0
addq $0xe0, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xbae69
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xbae... | /AraHaan[P]curl/lib/vtls/vtls.c |
Curl_ssl_push_certinfo_len | CURLcode Curl_ssl_push_certinfo_len(struct Curl_easy *data,
int certnum,
const char *label,
const char *value,
size_t valuelen)
{
struct curl_certinfo *ci = &data->info.certs... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x13d0, %rax # imm = 0x13D0
addq $0xe0, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
jmp 0xbaf28
leaq -0x68(%rbp), %r... | /AraHaan[P]curl/lib/vtls/vtls.c |
get_peer_type | static ssl_peer_type get_peer_type(const char *hostname)
{
if(hostname && hostname[0]) {
#ifdef USE_IPV6
struct in6_addr addr;
#else
struct in_addr addr;
#endif
if(curlx_inet_pton(AF_INET, hostname, &addr))
return CURL_SSL_PEER_IPV4;
#ifdef USE_IPV6
else if(curlx_inet_pton(AF_INET6, hostname, &a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbbca3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xbbca3
movq -0x10(%rbp), %rsi
movl $0x2, %edi
leaq -0x20(%rbp), %rdx
callq 0x117c0
cmpl $0x0, %eax
je 0xbbc7f
movl $0x1, -0x4(%rbp)
jmp 0xbbcaa
movq -0x10(%... | /AraHaan[P]curl/lib/vtls/vtls.c |
ssl_cf_destroy | static void ssl_cf_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
{
struct cf_call_data save;
CF_DATA_SAVE(save, cf, data);
cf_close(cf, data);
CF_DATA_RESTORE(cf, save);
cf_ctx_free(cf->ctx);
cf->ctx = NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x... | /AraHaan[P]curl/lib/vtls/vtls.c |
ssl_cf_close | static void ssl_cf_close(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_call_data save;
CF_DATA_SAVE(save, cf, data);
cf_close(cf, data);
if(cf->next)
cf->next->cft->do_close(cf->next, data);
CF_DATA_RESTORE(cf, save);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x... | /AraHaan[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 blen,
bool eos, CURLcode *err)
{
struct ssl_connect_data *connssl = cf->ctx;
struct cf_call_data save;
ssize_t nwritten = 0, early_wr... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp... | /AraHaan[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-... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
subl $0x5, %eax
jne 0xbc7f7
jmp 0xbc7b1
movq -0x30(%rbp), %rax
movq %ra... | /AraHaan[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_s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbcc82
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x298(%rax,%rcx,8), %rax
movq %... | /AraHaan[P]curl/lib/vtls/vtls.c |
Curl_ssl_cf_get_config | struct ssl_config_data *
Curl_ssl_cf_get_config(struct Curl_cfilter *cf, struct Curl_easy *data)
{
#ifdef CURL_DISABLE_PROXY
(void)cf;
return &data->set.ssl;
#else
return Curl_ssl_cf_is_proxy(cf) ? &data->set.proxy_ssl : &data->set.ssl;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbbc00
testb $0x1, %al
jne 0xbd03f
jmp 0xbd055
movq -0x10(%rbp), %rax
addq $0x190, %rax # imm = 0x190
addq $0x418, %rax # imm = 0x418
movq %rax, -0x18(%rbp)
jmp 0xbd069
movq -0x10(... | /AraHaan[P]curl/lib/vtls/vtls.c |
Curl_alpn_contains_proto | bool Curl_alpn_contains_proto(const struct alpn_spec *spec,
const char *proto)
{
size_t i, plen = proto ? strlen(proto) : 0;
for(i = 0; spec && plen && i < spec->count; ++i) {
size_t slen = strlen(spec->entries[i]);
if((slen == plen) && !memcmp(proto, spec->entries[i], plen))
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbd336
movq -0x18(%rbp), %rdi
callq 0x10540
movq %rax, -0x38(%rbp)
jmp 0xbd33e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xbd33e
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
xorl... | /AraHaan[P]curl/lib/vtls/vtls.c |
blobcmp | static bool blobcmp(struct curl_blob *first, struct curl_blob *second)
{
if(!first && !second) /* both are NULL */
return TRUE;
if(!first || !second) /* one is NULL */
return FALSE;
if(first->len != second->len) /* different sizes */
return FALSE;
return !memcmp(first->data, second->data, first->len... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbd8e4
cmpq $0x0, -0x18(%rbp)
jne 0xbd8e4
movb $0x1, -0x1(%rbp)
jmp 0xbd938
cmpq $0x0, -0x10(%rbp)
je 0xbd8f2
cmpq $0x0, -0x18(%rbp)
jne 0xbd8f8
movb $0x0, -0x1(%rbp)
jmp 0xbd938
movq -0x10(%rbp), %rax
... | /AraHaan[P]curl/lib/vtls/vtls.c |
ssl_cf_connect_deferred | static CURLcode ssl_cf_connect_deferred(struct Curl_cfilter *cf,
struct Curl_easy *data,
const void *buf, size_t blen,
bool *done)
{
struct ssl_connect_data *connssl = cf->ctx;
CURLcode result = C... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
jmp 0xbdff1
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), ... | /AraHaan[P]curl/lib/vtls/vtls.c |
ssl_cf_set_earlydata | static CURLcode ssl_cf_set_earlydata(struct Curl_cfilter *cf,
struct Curl_easy *data,
const void *buf, size_t blen)
{
struct ssl_connect_data *connssl = cf->ctx;
ssize_t nwritten = 0;
CURLcode result = CURLE_OK;
DEBUGASSERT(connssl->earl... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
jmp 0xbe235
jmp 0xbe237
jmp 0xbe239
cmpq $0x0, -0x28(%rbp)
je 0xbe304
... | /AraHaan[P]curl/lib/vtls/vtls.c |
Curl_ssl_scache_create | CURLcode Curl_ssl_scache_create(size_t max_peers,
size_t max_sessions_per_peer,
struct Curl_ssl_scache **pscache)
{
struct Curl_ssl_scache *scache;
struct Curl_ssl_scache_peer *peers;
size_t i;
*pscache = NULL;
peers = calloc(max_peers, sizeof(*... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
leaq 0x2ec0a(%rip), %rax # 0xed2f0
movq (%rax), %rax
movq -0x10(%rbp), %rdi
movl $0xa8, %esi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xbe70b... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
Curl_ssl_scache_destroy | void Curl_ssl_scache_destroy(struct Curl_ssl_scache *scache)
{
if(scache && GOOD_SCACHE(scache)) {
size_t i;
scache->magic = 0;
for(i = 0; i < scache->peer_count; ++i) {
cf_ssl_scache_clear_peer(&scache->peers[i]);
}
free(scache->peers);
free(scache);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbe890
cmpq $0x0, -0x8(%rbp)
je 0xbe890
movq -0x8(%rbp), %rax
cmpl $0xe1551, (%rax) # imm = 0xE1551
jne 0xbe890
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
c... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
Curl_ssl_scache_add_obj | CURLcode Curl_ssl_scache_add_obj(struct Curl_cfilter *cf,
struct Curl_easy *data,
const char *ssl_peer_key,
void *sobj,
Curl_ssl_scache_obj_dtor *sobj_free)
{
struct Curl_ssl_scache *sca... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf2b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd080
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0xbfec0
jmp 0xbfe... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
Curl_ssl_scache_get_obj | void *Curl_ssl_scache_get_obj(struct Curl_cfilter *cf,
struct Curl_easy *data,
const char *ssl_peer_key)
{
struct Curl_ssl_scache *scache = cf_ssl_scache_get(data);
struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
struct Curl_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf2b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd080
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xc01ea
movq $0x0, -0x8(%rbp)
jmp 0xc... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
Curl_ssl_scache_remove_all | void Curl_ssl_scache_remove_all(struct Curl_cfilter *cf,
struct Curl_easy *data,
const char *ssl_peer_key)
{
struct Curl_ssl_scache *scache = cf_ssl_scache_get(data);
struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
struct... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf2b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd080
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc030f
jmp 0xc0353
movq -0x10(%rbp), %... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
cf_ssl_get_free_peer | static struct Curl_ssl_scache_peer *
cf_ssl_get_free_peer(struct Curl_ssl_scache *scache)
{
struct Curl_ssl_scache_peer *peer = NULL;
size_t i;
/* find empty or oldest peer */
for(i = 0; i < scache->peer_count; ++i) {
/* free peer entry? */
if(!scache->peers[i].ssl_peer_key && !scache->peers[i].hmac_se... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc07f3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0xa8, -0x18(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xc0746
movq -0x8... | /AraHaan[P]curl/lib/vtls/vtls_scache.c |
main | int main(){
// 目录管理和磁盘管理测试
Dirs.CreatDir("admin", "test1", "1");
A_Disk.CreateFile("test1", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
Dirs.CreatDir("admin", "test2", "1");
A_Disk.CreateFile("test2", "dsfasdf");
Dirs.ShowDirMan();
cout << "Data is " << A_Disk.ReadFile("test1") << end... | pushq %rbx
subq $0x210, %rsp # imm = 0x210
leaq 0x34ee(%rip), %rsi # 0x7071
leaq 0x1f0(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2080
leaq 0x34db(%rip), %rsi # 0x7077
leaq 0x1d0(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x2080
leaq 0x34c6(%rip), %rsi # 0x707b
leaq 0x1b0(%rsp), %rdi
leaq 0xf(%rsp)... | /bonkyzhu[P]OSProject/unit_test.cpp |
Memory::show() | void show() { //显示内存数据
for(int i=0; i<16; i++) {
cout<<i<<" "<<Mem[i].sign<<" "<<Mem[i].thread_id<<" "<<Mem[i].name<<" "<<Mem[i].datasize<<" "<<Mem[i].message<<endl;
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x28, %rbx
xorl %r14d, %r14d
movq 0x659f(%rip), %r15 # 0xafd8
leaq 0x269d(%rip), %r12 # 0x70dd
cmpq $0x10, %r14
je 0x4ad8
movq %r15, %rdi
movl %r14d, %esi
callq 0x2290
movq %rax, %rdi
movq %r12, %rsi
callq 0x21b0
movl 0x20(%rbx), %es... | /bonkyzhu[P]OSProject/memmanager.h |
task_func | void *task_func(void *args)
{
int i;
thread_local_t *tls = args;
int *data = tp_get_tls(tls);
for (i = 0; i < 3; ++i) {
*data += 2 + *data;
// fprintf(stderr, "[%lu] %d\n", pthread_self(), *data);
}
sleep(1);
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10d0
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x131a
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %e... | /WqyJh[P]thread_pool/test/test_tls.c |
numeric_suite::test_adjacent_difference() | void test_adjacent_difference_back_inserter()
{
std::vector<int> data = {11, 22, 33, 44, 55};
circular_array<int, 4> result;
std::adjacent_difference(data.begin(), data.end(), std::back_inserter(result));
std::vector<int> expect = {22 - 11, 33 - 22, 44 - 33, 55 - 44};
BOOST_TEST_ALL_EQ(result.begin(... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movaps 0x274e(%rip), %xmm0 # 0x4010
leaq 0x58(%rsp), %r14
movups %xmm0, -0x10(%r14)
leaq 0x48(%rsp), %r15
movq %r15, 0x10(%r15)
movl $0x3, %eax
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
movl $0x10, %edi
callq 0x1120
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0,... | /breese[P]vista/test/circular_array_numeric_suite.cpp |
numeric_suite::test_adjacent_difference_back_inserter() | void test_adjacent_difference_back_inserter()
{
std::vector<int> data = {11, 22, 33, 44, 55};
circular_array<int, 4> result;
std::adjacent_difference(data.begin(), data.end(), std::back_inserter(result));
std::vector<int> expect = {22 - 11, 33 - 22, 44 - 33, 55 - 44};
BOOST_TEST_ALL_EQ(result.begin(... | pushq %r14
pushq %rbx
subq $0xa8, %rsp
movups 0x2cac(%rip), %xmm0 # 0x4690
leaq 0x80(%rsp), %rbx
movaps %xmm0, (%rbx)
movl $0x37, 0x10(%rbx)
leaq 0x48(%rsp), %r14
leaq 0x30(%rsp), %rcx
movl $0x5, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x264e
movq %rbx, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq $0x4, 0x20(%rbx)
movq... | /breese[P]vista/test/circular_array_numeric_suite.cpp |
setUp | void setUp(void)
{
FFF_RESET_HISTORY()
RESET_FAKE(epoll_create1)
RESET_FAKE(eventfd)
RESET_FAKE(epoll_ctl)
RESET_FAKE(epoll_wait)
RESET_FAKE(close)
RESET_FAKE(epoll_callback)
RESET_FAKE(epoll_callback_second_fd)
RESET_FAKE(epoll_callback_third_fd)
RESET_FAKE(epoll_callback_forth_fd)
RESET_FAKE(epoll_callbac... | pushq %rbx
leaq 0x91cc(%rip), %rdi # 0xb250
movl $0x194, %edx # imm = 0x194
xorl %esi, %esi
callq 0x1060
leaq 0x8fe9(%rip), %rdi # 0xb080
movl $0x1d0, %edx # imm = 0x1D0
xorl %esi, %esi
callq 0x1060
pushq $0x32
popq %rbx
movl %ebx, 0x90a4(%rip) # 0xb150
leaq 0x9335(%rip), %rdi ... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
main | int main(void)
{
UNITY_BEGIN();
RUN_TEST(test_create_loop);
RUN_TEST(test_createloop_epoll_create1_fails);
RUN_TEST(test_createloop_epoll_eventfd_fails);
RUN_TEST(test_createloop_epoll_eventloop_add_fails);
RUN_TEST(test_createloop_epoll_eventloop_register_read_fails);
RUN_TEST(test_add_event);
RUN_TEST(test_ad... | pushq %rax
leaq 0x4e33(%rip), %rdi # 0x7004
callq 0x60ab
leaq 0x1af(%rip), %rdi # 0x238c
leaq 0x4e7e(%rip), %rsi # 0x7062
movl $0x38d, %edx # imm = 0x38D
callq 0x604a
leaq 0x213(%rip), %rdi # 0x2408
leaq 0x4e77(%rip), %rsi # 0x7073
movl $0x38e, %edx # imm = 0x38E
callq 0... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_createloop_epoll_eventloop_register_read_fails | static void test_createloop_epoll_eventloop_register_read_fails(void)
{
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_save, epoll_ctl_fail};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_eventloop loop = {0};
enum cio_error err = cio_eventlo... | pushq %r14
pushq %rbx
subq $0x4f8, %rsp # imm = 0x4F8
movaps 0x876d(%rip), %xmm0 # 0xad70
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x9568(%rip) # 0xbb78
movl $0x2, 0x954e(%rip) # 0xbb68
leaq 0x10(%rsp), %rbx
movl $0x4e8, %edx # imm = 0x4E8
movq %rbx, %rdi
xorl %esi, %esi
callq... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_cancel | static void test_cancel(void)
{
epoll_ctl_fake.custom_fake = epoll_ctl_save;
epoll_wait_fake.custom_fake = notify_single_fd;
struct cio_eventloop loop = {0};
enum cio_error err = cio_eventloop_init(&loop);
TEST_ASSERT_EQUAL(CIO_SUCCESS, err);
TEST_ASSERT_EQUAL(1, epoll_create1_fake.call_count);
cio_eventloop_c... | pushq %rbp
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
leaq 0x1a91(%rip), %rax # 0x43e8
movq %rax, 0x9212(%rip) # 0xbb70
leaq 0x1aa9(%rip), %rax # 0x440e
movq %rax, 0x9704(%rip) # 0xc070
movq %rsp, %rbx
movl $0x4e8, %edx # imm = 0x4E8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1060... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_register_event_fails | static void test_register_event_fails(void)
{
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_save, epoll_ctl_save, epoll_ctl_mod_fail};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
static const int fake_fd = 42;
struct cio_eventloop loop = {0};
enum c... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x520, %rsp # imm = 0x520
movq 0x83af(%rip), %rax # 0xadb0
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movaps 0x8391(%rip), %xmm0 # 0xada0
movaps %xmm0, (%rcx)
movq %rcx, 0x915f(%rip) # 0xbb78
movl $0x3, 0x9145(%rip) # 0xbb68
leaq 0x38(%rsp), %rbx
movl $0x4... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_event | static void test_notify_event(void)
{
epoll_wait_fake.custom_fake = notify_single_fd;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_eventloop loop = {0};
enum cio_error ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp # imm = 0x518
leaq 0x1898(%rip), %rax # 0x440e
movq %rax, 0x94f3(%rip) # 0xc070
movaps 0x823c(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x8fe7(%rip) # 0xbb78
movl $0x2, 0x8fcd(%r... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_error_event | static void test_notify_error_event(void)
{
epoll_wait_fake.custom_fake = notify_write_and_error;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_eventloop loop = {0};
enu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp # imm = 0x518
leaq 0x169a(%rip), %rax # 0x444e
movq %rax, 0x92b5(%rip) # 0xc070
movaps 0x7ffe(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x8da9(%rip) # 0xbb78
movl $0x2, 0x8d8f(%r... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_hup_event | static void test_notify_hup_event(void)
{
epoll_wait_fake.custom_fake = notify_write_and_hup;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_eventloop loop = {0};
enum ci... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp # imm = 0x518
leaq 0x147c(%rip), %rax # 0x4470
movq %rax, 0x9075(%rip) # 0xc070
movaps 0x7dbe(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x8b69(%rip) # 0xbb78
movl $0x2, 0x8b4f(%r... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_three_event_and_remove | static void test_notify_three_event_and_remove(void)
{
epoll_wait_fake.custom_fake = notify_four_fds;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_eventloop loop = {0};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x578, %rsp # imm = 0x578
leaq 0x125e(%rip), %rax # 0x4492
movq %rax, 0x8e35(%rip) # 0xc070
movaps 0x7b7e(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x8929(%rip) # 0xbb78
movl $0x2, 0x890f(%r... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_single_fd_multiple_events | static void test_notify_single_fd_multiple_events(void)
{
epoll_wait_fake.custom_fake = notify_single_fd_multiple_events;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes))
struct cio_ev... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x520, %rsp # imm = 0x520
leaq 0xd20(%rip), %rax # 0x44e9
movq %rax, 0x88a0(%rip) # 0xc070
movaps 0x75e9(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x8394(%rip) # 0xbb78
movl $0x2, 0x837a(%rip) # ... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_single_fd_multiple_events_remove_from_loop | static void test_notify_single_fd_multiple_events_remove_from_loop(void)
{
epoll_wait_fake.custom_fake = notify_single_fd_multiple_events;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_fakes)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4f8, %rsp # imm = 0x4F8
leaq 0xa41(%rip), %rax # 0x44e9
movq %rax, 0x85c1(%rip) # 0xc070
movaps 0x730a(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x80b5(%rip) # 0xbb78
movl $0x2, 0x809b(%r... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_notify_single_fd_multiple_events_unregister_write_event | static void test_notify_single_fd_multiple_events_unregister_write_event(void)
{
epoll_wait_fake.custom_fake = notify_single_fd_multiple_events;
int (*epoll_ctrl_fakes[])(int, int, int, struct epoll_event *) = {epoll_ctl_nosave, epoll_ctl_save};
SET_CUSTOM_FAKE_SEQ(epoll_ctl, epoll_ctrl_fakes, ARRAY_SIZE(epoll_ctrl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x520, %rsp # imm = 0x520
leaq 0x7cc(%rip), %rax # 0x44e9
movq %rax, 0x834c(%rip) # 0xc070
movaps 0x7095(%rip), %xmm0 # 0xadc0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq %rax, 0x7e40(%rip) # 0xbb78
movl $0x2, 0x7e26(%rip) # ... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
test_epoll_wait_interrupted | static void test_epoll_wait_interrupted(void)
{
epoll_wait_fake.custom_fake = notify_no_fd_interrupt;
struct cio_eventloop loop = {0};
enum cio_error err = cio_eventloop_init(&loop);
TEST_ASSERT_EQUAL(CIO_SUCCESS, err);
TEST_ASSERT_EQUAL(1, epoll_create1_fake.call_count);
cio_eventloop_run(&loop);
TEST_ASSERT_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x4f0, %rsp # imm = 0x4F0
leaq 0x25d(%rip), %rax # 0x4570
movq %rax, 0x7d56(%rip) # 0xc070
leaq 0x8(%rsp), %rbx
movl $0x4e8, %edx # imm = 0x4E8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1060
movq %rbx, %rdi
callq 0x4590
movslq %eax, %rsi
pushq $0x14
... | /gatzka[P]cio/tests/linux/test_linux_epoll.c |
notify_single_fd | static int notify_single_fd(int epfd, struct epoll_event *events,
int maxevents, int timeout)
{
(void)epfd;
(void)maxevents;
(void)timeout;
if (epoll_wait_fake.call_count == 1) {
events[0].events = EPOLLIN;
events[0].data.ptr = event_list[0];
return 1;
} else {
return -1;
}
} | cmpl $0x1, 0x7b6b(%rip) # 0xbf80
jne 0x442c
movl $0x1, (%rsi)
movq 0x95bc(%rip), %rax # 0xd9e0
movq %rax, 0x4(%rsi)
pushq $0x1
popq %rax
retq
pushq $-0x1
popq %rax
retq
| /gatzka[P]cio/tests/linux/test_linux_epoll.c |
epoll_ctl_mod_fail | static int epoll_ctl_mod_fail(int epfd, int op, int fd, struct epoll_event *event)
{
(void)epfd;
(void)fd;
(void)event;
if (op == EPOLL_CTL_MOD) {
errno = ENOSPC;
return -1;
} else {
return 0;
}
} | xorl %eax, %eax
cmpl $0x3, %esi
jne 0x444a
pushq %rax
callq 0x1050
movl $0x1c, (%rax)
pushq $-0x1
popq %rax
addq $0x8, %rsp
retq
| /gatzka[P]cio/tests/linux/test_linux_epoll.c |
notify_single_fd_multiple_events | static int notify_single_fd_multiple_events(int epfd, struct epoll_event *events,
int maxevents, int timeout)
{
(void)epfd;
(void)maxevents;
(void)timeout;
if (epoll_wait_fake.call_count == 1) {
events[0].events = EPOLLIN | EPOLLOUT;
events[0].data.ptr = event_list[0... | cmpl $0x1, 0x7a90(%rip) # 0xbf80
jne 0x4507
movl $0x5, (%rsi)
movq 0x94e1(%rip), %rax # 0xd9e0
movq %rax, 0x4(%rsi)
pushq $0x1
popq %rax
retq
pushq $-0x1
popq %rax
retq
| /gatzka[P]cio/tests/linux/test_linux_epoll.c |
notify_two_fds | static int notify_two_fds(int epfd, struct epoll_event *events,
int maxevents, int timeout)
{
(void)epfd;
(void)maxevents;
(void)timeout;
if (epoll_wait_fake.call_count == 1) {
events[0].events = EPOLLOUT;
events[0].data.ptr = event_list[0];
events[1].events = EPOLLIN;
events[1].d... | cmpl $0x1, 0x7a49(%rip) # 0xbf80
jne 0x4560
movl $0x4, (%rsi)
movq 0x949a(%rip), %rax # 0xd9e0
movq %rax, 0x4(%rsi)
movl $0x1, 0xc(%rsi)
movq 0x9490(%rip), %rax # 0xd9e8
movq %rax, 0x10(%rsi)
pushq $0x2
popq %rax
retq
pushq $-0x1
popq %rax
retq
| /gatzka[P]cio/tests/linux/test_linux_epoll.c |
notify_no_fd_interrupt | static int notify_no_fd_interrupt(int epfd, struct epoll_event *events,
int maxevents, int timeout)
{
(void)epfd;
(void)maxevents;
(void)timeout;
(void)events;
if (epoll_wait_fake.call_count == 1) {
errno = EINTR;
return -1;
} else {
errno = EINVAL;
return -1;
}
} | pushq %rbx
movl 0x7a09(%rip), %ebx # 0xbf80
callq 0x1050
cmpl $0x1, %ebx
pushq $0x4
popq %rcx
pushq $0x16
popq %rdx
cmovel %ecx, %edx
movl %edx, (%rax)
pushq $-0x1
popq %rax
popq %rbx
retq
nop
| /gatzka[P]cio/tests/linux/test_linux_epoll.c |
cio_eventloop_init | enum cio_error cio_eventloop_init(struct cio_eventloop *loop)
{
enum cio_error err = CIO_SUCCESS;
loop->num_events = 0;
loop->event_counter = 0;
loop->current_ev = NULL;
loop->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
if (cio_unlikely(loop->epoll_fd == -1)) {
return (enum cio_error)(-errno);
}
loop->stop_ev... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movl $0x80000, %edi # imm = 0x80000
callq 0x11ac
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x45f9
xorl %ebp, %ebp
xorl %edi, %edi
movl $0x800, %esi # imm = 0x800
callq 0x12df
movl %eax, 0x2... | /gatzka[P]cio/lib/src/platform/linux/epoll.c |
cio_linux_eventloop_add | enum cio_error cio_linux_eventloop_add(const struct cio_eventloop *loop, struct cio_event_notifier *evn)
{
struct epoll_event epoll_ev;
evn->registered_events = 0;
epoll_ev.data.ptr = evn;
epoll_ev.events = evn->registered_events;
if (cio_unlikely(epoll_ctl(loop->epoll_fd, EPOLL_CTL_ADD, evn->fd, &epoll_ev) < 0))... | subq $0x18, %rsp
andl $0x0, 0x1c(%rsi)
leaq 0xc(%rsp), %rcx
movq %rsi, 0x4(%rcx)
andl $0x0, (%rcx)
movl (%rdi), %edi
movl 0x18(%rsi), %edx
pushq $0x1
popq %rsi
callq 0x1425
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x4661
addq $0x18, %rsp
retq
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp... | /gatzka[P]cio/lib/src/platform/linux/epoll.c |
epoll_mod | static enum cio_error epoll_mod(const struct cio_eventloop *loop, struct cio_event_notifier *evn, uint32_t events)
{
struct epoll_event epoll_ev;
epoll_ev.data.ptr = evn;
epoll_ev.events = events;
if (cio_unlikely(epoll_ctl(loop->epoll_fd, EPOLL_CTL_MOD, evn->fd, &epoll_ev) < 0)) {
return (enum cio_error)(-errno... | subq $0x18, %rsp
leaq 0xc(%rsp), %rcx
movq %rsi, 0x4(%rcx)
movl %edx, (%rcx)
movl (%rdi), %edi
movl 0x18(%rsi), %edx
pushq $0x3
popq %rsi
callq 0x1425
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x474a
addq $0x18, %rsp
retq
callq 0x1050
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x4745
| /gatzka[P]cio/lib/src/platform/linux/epoll.c |
cio_eventloop_run | enum cio_error cio_eventloop_run(struct cio_eventloop *loop)
{
struct epoll_event *events = loop->epoll_events;
while (true) {
int num_events =
epoll_wait(loop->epoll_fd, events, CONFIG_MAX_EPOLL_EVENTS, -1);
if (cio_unlikely(num_events < 0)) {
if (errno == EINTR) {
continue;
}
return (enum ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x8(%rdi), %rbp
movl (%rbx), %edi
movq %r14, %rsi
pushq $0x64
popq %rdx
pushq $-0x1
popq %rcx
callq 0x15a4
testl %eax, %eax
js 0x481d
movl %eax, 0x2c(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x28(%rbx)
cmpl %... | /gatzka[P]cio/lib/src/platform/linux/epoll.c |
UnityPrint | void UnityPrint(const char* string)
{
const char* pch = string;
if (pch != NULL)
{
while (*pch)
{
#ifdef UNITY_OUTPUT_COLOR
/* print ANSI escape code */
if ((*pch == 27) && (*(pch + 1) == '['))
{
pch += UnityPrintAnsiEscapeString(pch);
... | testq %rdi, %rdi
je 0x48dd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5c
popq %rbp
pushq $0x72
popq %r15
pushq $0x78
popq %r12
pushq $0x2
popq %r13
movzbl (%rbx), %r14d
testl %r14d, %r14d
je 0x48cf
leal -0x20(%r14), %eax
cmpb $0x5e, %al
ja 0x4894
movl %r14d, %e... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityPrintLen | void UnityPrintLen(const char* string, const UNITY_UINT32 length)
{
const char* pch = string;
if (pch != NULL)
{
while (*pch && ((UNITY_UINT32)(pch - string) < length))
{
/* printable characters plus CR & LF are printed */
if ((*pch <= 126) && (*pch >= 32))
... | testq %rdi, %rdi
je 0x496a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r13d, %r13d
pushq $0x5c
popq %rbp
pushq $0x2
popq %r15
movsbl (%r14,%r13), %r12d
testl %r12d, %r12d
je 0x495c
cmpl %ebx, %r13d
jae 0x495c
leal -0x20(%r12), %eax
cmpb $0x5e, %al
j... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityPrintFloat | void UnityPrintFloat(const UNITY_DOUBLE input_number)
{
#ifdef UNITY_INCLUDE_DOUBLE
static const int sig_digits = 9;
static const UNITY_INT32 min_scaled = 100000000;
static const UNITY_INT32 max_scaled = 1000000000;
#else
static const int sig_digits = 7;
static const UNITY_INT32 min_scaled = 1000000... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x4b6d
pushq $0x2d
popq %rdi
movaps %xmm0, 0x10(%rsp)
callq 0x1040
xorps %xmm1, %xmm1
movaps 0x10(%rsp), %xmm0
xorps 0x2893(%rip), %xmm0 # 0x7400
ucomiss %xmm1, %xmm0
jne 0x4b7d
jp 0x4b7d
l... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityAddMsgIfSpecified | static void UnityAddMsgIfSpecified(const char* msg)
{
if (msg)
{
UnityPrint(UnityStrSpacer);
#ifdef UNITY_PRINT_TEST_CONTEXT
UNITY_PRINT_TEST_CONTEXT();
#endif
#ifndef UNITY_EXCLUDE_DETAILS
if (Unity.CurrentDetail1)
{
UnityPrint(UnityStrDetail1Name);
Unit... | testq %rdi, %rdi
je 0x4fa2
pushq %rbx
movq %rdi, %rbx
leaq 0x272a(%rip), %rdi # 0x766e
callq 0x485c
cmpq $0x0, 0x8dbf(%rip) # 0xdd10
je 0x4f99
leaq 0x26ff(%rip), %rdi # 0x7659
callq 0x485c
movq 0x8daa(%rip), %rdi # 0xdd10
callq 0x485c
cmpq $0x0, 0x8da5(%rip) # 0xdd18
je 0x4f8d
leaq 0x26e7(%rip)... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityAssertNumbersWithin | void UnityAssertNumbersWithin(const UNITY_UINT delta,
const UNITY_INT expected,
const UNITY_INT actual,
const char* msg,
const UNITY_LINE_TYPE lineNumber,
const UNITY_DIS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x867b(%rip), %rax # 0xdd48
orq 0x866c(%rip), %rax # 0xdd40
jne 0x577b
movl %r9d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rax
testb $0x10, %bpl
jne 0x5717
subq %r15, %rax
ja 0x56fd
movq %r15, %rax
subq %r14, %... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityAssertEqualString | void UnityAssertEqualString(const char* expected,
const char* actual,
const char* msg,
const UNITY_LINE_TYPE lineNumber)
{
UNITY_UINT32 i;
RETURN_IF_FAIL_OR_IGNORE;
/* if both pointers not null compare the strings */
i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x83b9(%rip), %rax # 0xdd48
orq 0x83aa(%rip), %rax # 0xdd40
jne 0x59f8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x5a07
xorl %eax, %eax
movl %eax, %esi
movb (%r15,%rsi), %dl
m... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityPrintExpectedAndActualStrings | static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
{
UnityPrint(UnityStrExpected);
if (expected != NULL)
{
UNITY_OUTPUT_CHAR('\'');
UnityPrint(expected);
UNITY_OUTPUT_CHAR('\'');
}
else
{
UnityPrint(UnityStrNull);
}
Un... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1ae5(%rip), %rdi # 0x750e
callq 0x485c
testq %r14, %r14
je 0x5a4e
pushq $0x27
popq %rbp
movl %ebp, %edi
callq 0x1040
movq %r14, %rdi
callq 0x485c
movl %ebp, %edi
callq 0x1040
jmp 0x5a5a
leaq 0x1ca4(%rip), %rdi # 0x76f9
callq 0x485c
leaq 0... | /gatzka[P]cio/tests/unity/src/unity.c |
UnityAssertEqualStringLen | void UnityAssertEqualStringLen(const char* expected,
const char* actual,
const UNITY_UINT32 length,
const char* msg,
const UNITY_LINE_TYPE lineNumber)
{
UNITY_UINT32 i;
RETURN_IF_FAIL_OR_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x82a1(%rip), %rax # 0xdd48
orq 0x8292(%rip), %rax # 0xdd40
jne 0x5b1a
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x5b29
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %r... | /gatzka[P]cio/tests/unity/src/unity.c |
smf::MidiFile::extractMidiData(std::istream&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char&) | int MidiFile::extractMidiData(std::istream& input, std::vector<uchar>& array,
uchar& runningCommand) {
int character;
uchar byte;
array.clear();
int runningQ;
character = input.get();
if (character == EOF) {
std::cerr << "Error: unexpected end of file." << std::endl;
return 0;
} else {
byte = (uchar)cha... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x47b20
movq -0x18(%rbp), %rdi
callq 0x33470
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x40889
movq ... | /craigsapp[P]midifile/src/MidiFile.cpp |
usage(char**) | static void usage(char* argv[]) {
std::cout << "Usage: " << argv[0] << " [OPTIONS] INFILE" << std::endl;
std::cout << "This program reads the VPack INFILE into a string and "
<< std::endl;
std::cout << "validates it. Will work only for input files up to 2 GB size."
<< std::endl;
std::cou... | pushq %rax
movq %rdi, (%rsp)
movq 0x2b1c4(%rip), %rdi # 0x2ffd0
leaq 0x1f2e4(%rip), %rsi # 0x240f7
callq 0x4160
movq %rax, %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x4160
movq %rax, %rdi
leaq 0x1f2ce(%rip), %rsi # 0x240ff
callq 0x4160
movq %rax, %rdi
movq 0x2b178(%rip), %rsi # 0x2ffb8
callq 0x4190... | /arangodb[P]velocypack/tools/vpack-validate.cpp |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 1u, 24u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0x9980
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
arangodb::velocypack::(anonymous namespace)::JSONStringCopyC(unsigned char*, unsigned char const*, unsigned long) | inline std::size_t JSONStringCopyC(uint8_t* dst, uint8_t const* src,
std::size_t limit) {
// Copy up to limit uint8_t from src to dst.
// Stop at the first control character or backslash or double quote.
// Report the number of bytes copied. May copy less bytes, for example
//... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
xorl %eax, %eax
cmpq -0x20(%rsp), %rcx
movb %al, -0x21(%rsp)
jae 0xbef8
movq -0x10(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0... | /arangodb[P]velocypack/src/asm-functions.cpp |
arangodb::velocypack::(anonymous namespace)::JSONStringCopyCheckUtf8C(unsigned char*, unsigned char const*, unsigned long) | inline std::size_t JSONStringCopyCheckUtf8C(uint8_t* dst, uint8_t const* src,
std::size_t limit) {
// Copy up to limit uint8_t from src to dst.
// Stop at the first control character or backslash or double quote.
// Also stop at byte with high bit set.
// Report the n... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
xorl %eax, %eax
cmpq -0x20(%rsp), %rcx
movb %al, -0x21(%rsp)
jae 0xbfbd
movq -0x10(%rsp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0... | /arangodb[P]velocypack/src/asm-functions.cpp |
arangodb::velocypack::(anonymous namespace)::JSONSkipWhiteSpaceC(unsigned char const*, unsigned long) | inline std::size_t JSONSkipWhiteSpaceC(uint8_t const* src, std::size_t limit) {
// Skip up to limit uint8_t from src as long as they are whitespace.
// Advance ptr and return the number of skipped bytes.
uint8_t const* end = src + limit;
while (src < end &&
(*src == ' ' || *src == '\t' || *src == '\n' ... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rcx
xorl %eax, %eax
cmpq -0x18(%rsp), %rcx
movb %al, -0x19(%rsp)
jae 0xc08e
movq -0x8(%rsp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1a(%rsp)
je 0xc086
movq -0... | /arangodb[P]velocypack/src/asm-functions.cpp |
arangodb::velocypack::(anonymous namespace)::JSONStringCopySSE42(unsigned char*, unsigned char const*, unsigned long) | std::size_t JSONStringCopySSE42(uint8_t* dst, uint8_t const* src,
std::size_t limit) {
alignas(16) static char const ranges[17] =
"\x20\x21\x23\x5b\x5d\xff ";
//= "\x01\x1f\"\"\\\\\"\"\"\"\"\"\"\"\"\"";
__m128i const r = _mm_load_si128(reinterpret_cast<__m128i const... | subq $0x98, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x184c3(%rip), %rax # 0x246e0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
cmpq $0x10, 0x48(%rsp)
jb 0xc324
movq 0x50(%rsp), %rax
movq %rax... | /arangodb[P]velocypack/src/asm-functions.cpp |
arangodb::velocypack::(anonymous namespace)::JSONSkipWhiteSpaceSSE42(unsigned char const*, unsigned long) | std::size_t JSONSkipWhiteSpaceSSE42(uint8_t const* ptr, std::size_t limit) {
alignas(16) static char const white[17] = " \t\n\r ";
__m128i const w = _mm_load_si128(reinterpret_cast<__m128i const*>(white));
std::size_t count = 0;
int x = 0;
while (limit >= 16) {
__m128i const s = _mm_loadu_si128... | movq %rdi, -0x28(%rsp)
movq %rsi, -0x30(%rsp)
leaq 0x1818f(%rip), %rax # 0x24720
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
movl $0x0, -0x54(%rsp)
cmpq $0x10, -0x30(%rsp)
jb 0xc645
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), ... | /arangodb[P]velocypack/src/asm-functions.cpp |
arangodb::velocypack::validate_utf8_fast_sse42(unsigned char const*, unsigned long) | bool validate_utf8_fast_sse42(uint8_t const* src, std::size_t len) {
std::size_t i = 0;
__m128i has_error = _mm_setzero_si128();
struct processed_utf_bytes previous = {
.rawbytes = _mm_setzero_si128(),
.high_nibbles = _mm_setzero_si128(),
.carried_continuations = _mm_setzero_si128()};
if (len ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq $0x0, 0xe8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x130(%rsp)
movaps 0x130(%rsp), %xmm1
movaps %xmm1, 0xd0(%rsp)
movaps %xmm0, 0x120(%rsp)
movaps 0x120(%rsp), %xm... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
arangodb::velocypack::checkUTF8Bytes(long long vector[2], arangodb::velocypack::processed_utf_bytes*, long long vector[2]*) | static struct processed_utf_bytes checkUTF8Bytes(
__m128i current_bytes, struct processed_utf_bytes* previous,
__m128i* has_error) {
struct processed_utf_bytes pb;
count_nibbles(current_bytes, &pb);
checkSmallerThan0xF4(current_bytes, has_error);
__m128i initial_lengths = continuationLengths(pb.high_n... | subq $0x58, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movaps 0x40(%rsp), %xmm0
callq 0xce10
movaps 0x40(%rsp), %xmm0
movq 0x30(%rsp), %rdi
callq 0xcf80
movq (%rsp), %rdi
movaps 0x10(%rdi), %xmm0
callq 0xd0e0
movaps %xmm0, 0x20(%rsp)
... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
arangodb::velocypack::carryContinuations(long long vector[2], long long vector[2]) | static inline __m128i carryContinuations(__m128i initial_lengths,
__m128i previous_carries) {
__m128i right1 =
_mm_subs_epu8(_mm_alignr_epi8(initial_lengths, previous_carries, 16 - 1),
_mm_set1_epi8(1));
__m128i sum = _mm_add_epi8(initial_lengths, r... | subq $0xa8, %rsp
movaps %xmm0, -0x40(%rsp)
movaps %xmm1, -0x50(%rsp)
movaps -0x40(%rsp), %xmm1
movaps -0x50(%rsp), %xmm0
palignr $0xf, %xmm0, %xmm1 # xmm1 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
movb $0x1, -0x21(%rsp)
movb -0x21(%rsp), %al
movb %al, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb %al, -0x3(%rsp)
... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
arangodb::velocypack::checkContinuations(long long vector[2], long long vector[2], long long vector[2]*) | static inline void checkContinuations(__m128i initial_lengths, __m128i carries,
__m128i* has_error) {
// overlap || underlap
// carry > length && length > 0 || !(carry > length) && !(length > 0)
// (carries > length) == (lengths > 0)
__m128i overunder =
_mm_cmpeq_epi8... | subq $0x58, %rsp
movaps %xmm0, -0x50(%rsp)
movaps %xmm1, -0x60(%rsp)
movq %rdi, -0x68(%rsp)
movaps -0x60(%rsp), %xmm1
movaps -0x50(%rsp), %xmm0
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps 0x20(%rsp), %xmm1
movaps 0x10(%rsp), %xmm0
pcmpgtb %xmm0, %xmm1
movaps -0x50(%rsp), %xmm2
xorps %xmm0, %xmm0
movaps %xm... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
arangodb::velocypack::checkFirstContinuationMax(long long vector[2], long long vector[2], long long vector[2]*) | static inline void checkFirstContinuationMax(__m128i current_bytes,
__m128i off1_current_bytes,
__m128i* has_error) {
__m128i maskED = _mm_cmpeq_epi8(off1_current_bytes, _mm_set1_epi8(0xED));
__m128i maskF4 = _mm_cmpeq_epi8(of... | subq $0x188, %rsp # imm = 0x188
movaps %xmm0, -0x20(%rsp)
movaps %xmm1, -0x30(%rsp)
movq %rdi, -0x38(%rsp)
movaps -0x30(%rsp), %xmm1
movb $-0x13, 0xbf(%rsp)
movb 0xbf(%rsp), %al
movb %al, 0xdf(%rsp)
movb %al, 0xde(%rsp)
movb %al, 0xdd(%rsp)
movb %al, 0xdc(%rsp)
movb %al, 0xdb(%rsp)
movb %al, 0xda(%rsp)
movb ... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
arangodb::velocypack::checkOverlong(long long vector[2], long long vector[2], long long vector[2], long long vector[2], long long vector[2]*) | static inline void checkOverlong(__m128i current_bytes,
__m128i off1_current_bytes, __m128i hibits,
__m128i previous_hibits, __m128i* has_error) {
__m128i off1_hibits = _mm_alignr_epi8(hibits, previous_hibits, 16 - 1);
__m128i initial_mins = _mm_shuf... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movaps %xmm0, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm2, (%rsp)
movaps %xmm3, -0x10(%rsp)
movq %rdi, -0x18(%rsp)
movaps (%rsp), %xmm0
movaps -0x10(%rsp), %xmm1
palignr $0xf, %xmm1, %xmm0 # xmm0 = xmm... | /arangodb[P]velocypack/src/asm-utf8check.cpp |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 1ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
retq
nop
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 8ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerNonEmpty<unsigned long>(unsigned char const*, unsigned long) | static inline T readIntegerNonEmpty(uint8_t const* start,
ValueLength length) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
VELOCYPACK_ASSERT(length > 0);
VELOCYPACK_ASSERT(length <= sizeof(T));
VELOCYPACK_ASSERT(length <= 8);
switch ... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
decq %rax
movq %rax, 0x8(%rsp)
subq $0x7, %rax
ja 0xee43
movq 0x8(%rsp), %rax
leaq 0x15d9f(%rip), %rcx # 0x24b50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movzbl (%rax), %eax
movq %rax, 0x20(%rsp)
jm... | /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
arangodb::velocypack::getVariableValueLength(unsigned long) | static inline ValueLength getVariableValueLength(ValueLength value) noexcept {
ValueLength len = 1;
while (value >= 0x80U) {
value >>= 7;
++len;
}
return len;
} | movq %rdi, -0x8(%rsp)
movq $0x1, -0x10(%rsp)
cmpq $0x80, -0x8(%rsp)
jb 0xeef7
movq -0x8(%rsp), %rax
shrq $0x7, %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xeece
movq -0x10(%rsp), %rax
retq
nopl (%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntegerFixed<unsigned int, 4ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xf2e0
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 2ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xf370
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 4ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xf3e0
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 3ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xf240
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntegerFixed<unsigned long, 6ul>(unsigned char const*) | static inline T readIntegerFixed(uint8_t const* start) noexcept {
static_assert(std::is_unsigned<T>::value, "result type must be unsigned");
static_assert(length > 0, "length must be > 0");
static_assert(length <= sizeof(T), "length must be <= sizeof(T)");
static_assert(length <= 8);
if constexpr (1 == length... | movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
movl %ecx, -0x10(%rsp)
movw 0x4(%rax), %ax
movw %ax, -0xc(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 8u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf2a0
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 1u, 16u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf2d0
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 0u, 24u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | movq %rdi, -0x8(%rsp)
xorl %eax, %eax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntFixedHelper<unsigned int, 4u, 0u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf300
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntFixedHelper<unsigned int, 3u, 8u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf320
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntFixedHelper<unsigned int, 2u, 16u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf340
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntFixedHelper<unsigned int, 1u, 24u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf360
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
popq %rcx
retq
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned int arangodb::velocypack::readIntFixedHelper<unsigned int, 0u, 32u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | movq %rdi, -0x8(%rsp)
xorl %eax, %eax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 2u, 0u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x1, %rdi
callq 0xf3a0
movq (%rsp), %rcx
movzbl (%rcx), %ecx
shlq $0x0, %rcx
orq %rcx, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
unsigned long arangodb::velocypack::readIntFixedHelper<unsigned long, 0u, 16u>(unsigned char const*) | static inline T readIntFixedHelper(uint8_t const* p) noexcept {
// bailout if nothing to shift or target type is too small for shift
// to avoid compiler warning
if constexpr (Bytes == 0 || sizeof(T) * 8 <= Shift) {
return 0;
} else {
return readIntFixedHelper<T, Bytes - 1, Shift + 8>(p + 1) |
... | movq %rdi, -0x8(%rsp)
xorl %eax, %eax
retq
nopl (%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
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.