name string | code string | asm string | file string |
|---|---|---|---|
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::ParserRefImpl<long>(long&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x56830(%rip), %rax # 0xb5f80
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x5f7b6
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%rbx)
andq $0x0, -0x8(%rdi)
callq 0x5181c
leaq 0x20(%rbx),... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::SectionNode::SectionNode(Catch::SectionStats const&) | explicit SectionNode(SectionStats const& _stats) : stats(_stats) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x45ddb(%rip), %rax # 0xb7c88
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x71f0e
leaq 0xc8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movq %rax, 0xb8(%rbx)
andq $0x0, 0xc0(%rbx)
xorl %eax, %eax
movb %al, 0xc8(%rbx)
leaq 0xe8... | /Neargye[P]magic_enum/test/3rdparty/Catch2/include/catch2/catch.hpp |
end | static bool
end(void *ud) {
struct ctx *ctx = (struct ctx *)ud;
int err;
if (ctx->compress) {
err = deflateEnd(&ctx->zstr);
}
else {
err = inflateEnd(&ctx->zstr);
}
if (err != Z_OK) {
zip_error_set(ctx->error, ZIP_ER_ZLIB, err);
return false;
}
retu... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
cmpb $0x1, 0x8(%rbx)
jne 0x5b74
callq 0x52d0
jmp 0x5b79
callq 0x5510
movl %eax, %ebp
testl %eax, %eax
je 0x5b8e
movq (%rbx), %rdi
movl $0xd, %esi
movl %ebp, %edx
callq 0x50c0
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /nih-at[P]libzip/lib/zip_algorithm_deflate.c |
zip_buffer_peek | zip_uint8_t *
_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length) {
zip_uint8_t *data;
if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) {
buffer->ok = false;
return NULL;
}
data = buffer->data + buffer->offset;
return data;
} | cmpb $0x1, (%rdi)
jne 0x5d56
movq 0x18(%rdi), %rax
addq %rax, %rsi
jb 0x5d56
cmpq 0x10(%rdi), %rsi
jbe 0x5d5c
movb $0x0, (%rdi)
xorl %eax, %eax
retq
addq 0x8(%rdi), %rax
retq
| /nih-at[P]libzip/lib/zip_buffer.c |
zip_buffer_get_32 | zip_uint8_t *
_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length) {
zip_uint8_t *data;
if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) {
buffer->ok = false;
return NULL;
}
data = buffer->data + buffer->offset;
return data;
} | cmpb $0x1, (%rdi)
jne 0x5dab
movq 0x18(%rdi), %rax
cmpq $-0x5, %rax
ja 0x5dab
leaq 0x4(%rax), %rcx
cmpq 0x10(%rdi), %rcx
jbe 0x5db1
movb $0x0, (%rdi)
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x5dae
movq %rcx, 0x18(%rdi)
movl (%rdx,%rax), %eax
retq
| /nih-at[P]libzip/lib/zip_buffer.c |
zip_dirent_process_ef_zip64 | bool
zip_dirent_process_ef_zip64(zip_dirent_t *zde, const zip_uint8_t *ef, zip_uint64_t got_len, bool local, zip_error_t *error) {
zip_buffer_t *ef_buffer;
if ((ef_buffer = _zip_buffer_new((zip_uint8_t *)ef, got_len)) == NULL) {
zip_error_set(error, ZIP_ER_MEMORY, 0);
return false;
}
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x5e8c
testq %rax, %rax
je 0x8af6
movq %rax, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, 0x28(%r15)
jne 0x8b0c
movq %r14, %rdi
callq 0x5dc2
movq... | /nih-at[P]libzip/lib/zip_dirent.c |
zip_source_begin_write_cloning | ZIP_EXTERN int
zip_source_begin_write_cloning(zip_source_t *src, zip_uint64_t offset) {
if (ZIP_SOURCE_IS_LAYERED(src)) {
zip_error_set(&src->error, ZIP_ER_OPNOTSUPP, 0);
return -1;
}
if (ZIP_SOURCE_IS_OPEN_WRITING(src)) {
zip_error_set(&src->error, ZIP_ER_INVAL, 0);
return ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0xe2db
addq $0x18, %rbx
movq %rbx, %rdi
movl $0x1c, %esi
jmp 0xe2ed
cmpl $0x1, 0x34(%rbx)
jne 0xe305
addq $0x18, %rbx
movq %rbx, %rdi
movl $0x12, %esi
xorl %edx, %edx
callq 0x50c0
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl %r14d, %eax
addq ... | /nih-at[P]libzip/lib/zip_source_begin_write_cloning.c |
zip_source_layered_create | zip_source_t *
zip_source_layered_create(zip_source_t *src, zip_source_layered_callback cb, void *ud, zip_error_t *error) {
zip_source_t *zs;
zip_int64_t lower_supports, supports;
lower_supports = zip_source_supports(src);
supports = cb(src, ud, &lower_supports, sizeof(lower_supports), ZIP_SOURCE_SUPPO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x112d0
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x8, %ecx
movq %r15, %rdi
movq %r14, %rsi
movl $0xe, %r8d
callq *%rbx
testq %rax, %rax
js 0x106db
movq %rax, %rbp
movq %r12, ... | /nih-at[P]libzip/lib/zip_source_layered.c |
zip_source_open | ZIP_EXTERN int
zip_source_open(zip_source_t *src) {
if (src->source_closed) {
return -1;
}
if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {
zip_error_set(&src->error, ZIP_ER_DELETED, 0);
return -1;
}
if (ZIP_SOURCE_IS_OPEN_READING(src)) {
if ((zip_source_supports(... | pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpb $0x0, 0x38(%rdi)
jne 0x107b0
movq %rdi, %r14
cmpl $0x3, 0x34(%rdi)
jne 0x10746
addq $0x18, %r14
movq %r14, %rdi
movl $0x17, %esi
jmp 0x10765
cmpl $0x0, 0x30(%r14)
je 0x1076e
movq %r14, %rdi
callq 0x112d0
testb $0x40, %al
jne 0x10792
a... | /nih-at[P]libzip/lib/zip_source_open.c |
zip_source_pass_to_lower_layer | zip_int64_t zip_source_pass_to_lower_layer(zip_source_t *src, void *data, zip_uint64_t length, zip_source_cmd_t command) {
switch (command) {
case ZIP_SOURCE_OPEN:
case ZIP_SOURCE_CLOSE:
case ZIP_SOURCE_FREE:
case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
case ZIP_SOURCE_SUPPORTS_REOPEN:
return 0;... | pushq %rax
cmpl $0x15, %ecx
ja 0x107f4
movl %ecx, %eax
leaq 0x4a31(%rip), %r8 # 0x1521c
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
addq $0x18, %rdi
movl $0x1c, %esi
xorl %edx, %edx
callq 0x50c0
movq $-0x1, %rax
jmp 0x10815
popq %rax
jmp 0xed54
xorl %eax, %eax
popq %rcx
retq
cmpq $0x7, %rdx
ja 0x1082f
add... | /nih-at[P]libzip/lib/zip_source_pass_to_lower_layer.c |
zip_source_pkware_decode | zip_source_t *
zip_source_pkware_decode(zip_t *za, zip_source_t *src, zip_uint16_t em, int flags, const char *password) {
struct trad_pkware *ctx;
zip_source_t *s2;
if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {
zip_error_set(&za->error, ZIP_ER_INVAL, 0);
return NULL;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %edx
jne 0x108be
movq %rsi, %r15
testq %rsi, %rsi
je 0x108be
movq %r8, %r12
testq %r8, %r8
je 0x108be
leaq 0x10(%rbx), %r13
testb $0x1, %cl
jne 0x108cf
movl $0x28, %edi
callq 0x5690
testq %rax, %rax
je 0x108dc
movq %rax, %r14
movq %r12, %... | /nih-at[P]libzip/lib/zip_source_pkware_decode.c |
pkware_decrypt | static zip_int64_t
pkware_decrypt(zip_source_t *src, void *ud, void *data, zip_uint64_t len, zip_source_cmd_t cmd) {
struct trad_pkware *ctx;
zip_int64_t n;
ctx = (struct trad_pkware *)ud;
switch (cmd) {
case ZIP_SOURCE_OPEN:
_zip_pkware_keys_reset(&ctx->keys);
_zip_pkware_decrypt(... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, %r14
cmpl $0xe, %r8d
ja 0x10a12
movq %rsi, %rbx
movl %r8d, %eax
leaq 0x4935(%rip), %rdx # 0x15274
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0xd72c
movq (%rbx), %r12
movq %r... | /nih-at[P]libzip/lib/zip_source_pkware_decode.c |
zip_source_pkware_encode | zip_source_t *
zip_source_pkware_encode(zip_t *za, zip_source_t *src, zip_uint16_t em, int flags, const char *password) {
struct trad_pkware *ctx;
zip_source_t *s2;
if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {
zip_error_set(&za->error, ZIP_ER_INVAL, 0);
return NULL;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpl $0x1, %edx
jne 0x10b92
movq %rsi, %r15
testq %rsi, %rsi
je 0x10b92
movq %r8, %r13
testq %r8, %r8
je 0x10b92
leaq 0x10(%r14), %r12
testb $0x1, %cl
jne 0x10ba6
xorl %r15d, %r15d
movq %r12, %rdi
movl $0x18, %esi
jmp 0x10c44
addq $... | /nih-at[P]libzip/lib/zip_source_pkware_encode.c |
trad_pkware_free | static void
trad_pkware_free(struct trad_pkware *ctx) {
if (ctx == NULL) {
return;
}
free(ctx->password);
_zip_buffer_free(ctx->buffer);
zip_error_fini(&ctx->error);
free(ctx);
} | testq %rdi, %rdi
je 0x10cdb
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5930
movq 0x18(%rbx), %rdi
callq 0x5ce1
leaq 0x28(%rbx), %rdi
callq 0x57e0
movq %rbx, %rdi
popq %rbx
jmp 0x5930
retq
| /nih-at[P]libzip/lib/zip_source_pkware_encode.c |
zip_source_tell | ZIP_EXTERN zip_int64_t
zip_source_tell(zip_source_t *src) {
if (src->source_closed) {
return -1;
}
if (!ZIP_SOURCE_IS_OPEN_READING(src)) {
zip_error_set(&src->error, ZIP_ER_INVAL, 0);
return -1;
}
if ((src->supports & (ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_TELL) | ZIP_S... | pushq %rax
movq $-0x1, %rax
cmpb $0x0, 0x38(%rdi)
jne 0x113e7
cmpl $0x0, 0x30(%rdi)
je 0x113c5
testb $-0x40, 0x28(%rdi)
je 0x113de
xorl %esi, %esi
xorl %edx, %edx
movl $0x7, %ecx
popq %rax
jmp 0xed54
addq $0x18, %rdi
movl $0x12, %esi
xorl %edx, %edx
callq 0x50c0
movq $-0x1, %rax
jmp 0x113e7
movq 0x50(%rdi), %rax
testq ... | /nih-at[P]libzip/lib/zip_source_tell.c |
window_read | static zip_int64_t
window_read(zip_source_t *src, void *_ctx, void *data, zip_uint64_t len, zip_source_cmd_t cmd) {
struct window *ctx;
zip_int64_t ret;
zip_uint64_t n, i;
ctx = (struct window *)_ctx;
switch (cmd) {
case ZIP_SOURCE_CLOSE:
return 0;
case ZIP_SOURCE_ERROR:
r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2000, %rsp # imm = 0x2000
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
cmpl $0x15, %r8d
ja 0x118a8
movq %rsi, %rbx
movl %r8d, %eax
leaq 0x3c8d(%rip), %rcx # 0x15308
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rbx), %rd... | /nih-at[P]libzip/lib/zip_source_window.c |
zip_source_zip_create | ZIP_EXTERN zip_source_t *zip_source_zip_create(zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags, zip_uint64_t start, zip_int64_t len, zip_error_t *error) {
if (len < -1) {
zip_error_set(error, ZIP_ER_INVAL, 0);
return NULL;
}
if (len == 0) {
len = -1;
}
if (star... | pushq %rax
cmpq $-0x2, %r8
jg 0x11b4e
movq %r9, %rdi
movl $0x12, %esi
xorl %edx, %edx
callq 0x50c0
xorl %eax, %eax
popq %rcx
retq
xorl %eax, %eax
cmpq $0x1, %r8
sbbq %rax, %rax
orq %r8, %rax
movq %rax, %r8
notq %r8
xorl %r10d, %r10d
orq %rcx, %r8
sete %r10b
andl $-0x5, %edx
leal (%rdx,%r10,4), %edx
movq %r9, (%rsp)
mov... | /nih-at[P]libzip/lib/zip_source_zip.c |
zip_crypto_hmac_output | bool
_zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data) {
#ifdef USE_OPENSSL_3_API
size_t length = 0;
return EVP_MAC_final(hmac->ctx, data, &length, ZIP_CRYPTO_SHA1_LENGTH) == 1 && length == ZIP_CRYPTO_SHA1_LENGTH;
#else
unsigned int length = 0;
return HMAC_Final(hmac, data, &length) =... | pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq 0x8(%rdi), %rdi
movl $0x14, %ecx
movq %rbx, %rdx
callq 0x53d0
cmpl $0x1, %eax
sete %cl
cmpq $0x14, (%rbx)
sete %al
andb %cl, %al
addq $0x10, %rsp
popq %rbx
retq
| /nih-at[P]libzip/lib/zip_crypto_openssl.c |
zip_winzip_aes_new | zip_winzip_aes_t *
_zip_winzip_aes_new(const zip_uint8_t *password, zip_uint64_t password_length, const zip_uint8_t *salt, zip_uint16_t encryption_method, zip_uint8_t *password_verify, zip_error_t *error) {
zip_winzip_aes_t *ctx;
zip_uint8_t buffer[2 * (MAX_KEY_LENGTH / 8) + WINZIP_AES_PASSWORD_VERIFY_LENGTH];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movl %ecx, %r14d
addl $0xfffffeff, %r14d # imm = 0xFFFFFEFF
cmpw $0x2, %r14w
ja 0x13dd1
movq %rsi, %rbp
testq %rsi, %rsi
je 0x13dd1
movq %rdi, %r12
testq %rdi, %rdi
je 0x13dd1
movq %rdx, %r13
testq %rdx, %rdx
je 0x13d... | /nih-at[P]libzip/lib/zip_winzip_aes.c |
dlmalloc_stats | static void internal_malloc_stats(mstate m) {
ensure_initialization();
if (!PREACTION(m)) {
size_t maxfp = 0;
size_t fp = 0;
size_t used = 0;
check_malloc_state(m);
if (is_initialized(m)) {
msegmentptr s = &m->seg;
maxfp = m->max_footprint;
fp = m->footprint;
used = fp - ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0xbb69(%rip) # 0xecb8
jne 0x3156
callq 0x4d20
testb $0x2, 0xbefb(%rip) # 0xf058
je 0x3172
pushq $0x1
popq %rbx
movl %ebx, %eax
xchgl %eax, 0xbef2(%rip) # 0xf05c
testl %eax, %eax
jne 0x3273
movq 0xbb97(%rip), %rax # 0xed10
testq %rax, ... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
fclose | int fclose( struct _PDCLIB_file_t * stream )
{
_PDCLIB_LOCK( _PDCLIB_filelist_mtx );
_PDCLIB_LOCK( stream->mtx );
/* Flush buffer */
if ( stream->status & _PDCLIB_FWRITE )
{
if ( _PDCLIB_flushbuffer( stream ) == EOF )
{
/* Flush failed, errno already set */
_... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xbb4e(%rip), %rdi # 0xf0a0
callq 0x8a1c
leaq 0x48(%rbx), %r14
movq %r14, %rdi
callq 0x8a1c
testb $0x10, 0x44(%rbx)
je 0x3576
movq %rbx, %rdi
callq 0x88dc
cmpl $-0x1, %eax
je 0x3589
movl (%rbx), %edi
callq 0x88d4
movq %rbx, %rdi
callq 0x7574
testl %eax, %eax
je... | /DevSolar[P]pdclib/functions/stdio/fclose.c |
fopen | struct _PDCLIB_file_t * fopen( const char * _PDCLIB_restrict filename, const char * _PDCLIB_restrict mode )
{
struct _PDCLIB_file_t * rc;
unsigned int filemode = _PDCLIB_filemode( mode );
if ( filemode == 0 )
{
/* mode invalid */
return NULL;
}
if ( filename == NULL || filename... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rdi
callq 0x750c
movl %eax, %ebp
testl %eax, %eax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x36c3
cmpb $0x0, (%r14)
je 0x36c3
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x75c4
testq %rax, %rax
je 0x36c6
movq %rax, %rbx
orl 0x44(%... | /DevSolar[P]pdclib/functions/stdio/fopen.c |
realloc | void* dlrealloc(void* oldmem, size_t bytes) {
void* mem = 0;
if (oldmem == 0) {
mem = dlmalloc(bytes);
}
else if (bytes >= MAX_REQUEST) {
MALLOC_FAILURE_ACTION;
}
#ifdef REALLOC_ZERO_BYTES_FREES
else if (bytes == 0) {
dlfree(oldmem);
}
#endif /* REALLOC_ZERO_BYTES_FREES */
else {
size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x5b8c
cmpq $-0x80, %r14
jb 0x5b9c
callq 0x7504
movl $0xc, (%rax)
xorl %r15d, %r15d
jmp 0x5c73
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x38f4
movq %rdi, %rbx
leaq 0x17(%r14), %rax
andq $-0x10, %rax
c... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
try_realloc_chunk | static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb,
int can_move) {
mchunkptr newp = 0;
size_t oldsize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, oldsize);
if (RTCHECK(ok_address(m, p) && ok_inuse(p) &&
ok_next(p, next) && ok_pinuse(ne... | pushq %r15
pushq %r14
pushq %rbx
movq 0x9075(%rip), %r10 # 0xed00
cmpq %rdi, %r10
ja 0x6012
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movl %edx, %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x6012
movq %rdx, %rdi
andq $-0x8, %rdi
jle 0x6012
leaq (%rbx,%rdi), %r9
movq 0x8(%r9), %rcx
testb $0x1, %cl
je 0x6012
testq %rax, %rax... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmalloc_set_footprint_limit | size_t dlmalloc_set_footprint_limit(size_t bytes) {
size_t result; /* invert sense of 0 */
if (bytes == 0)
result = granularity_align(1); /* Use minimal size */
if (bytes == MAX_SIZE_T)
result = 0; /* disable */
else
result = granularity_align(bytes);
return gm->footprint_limit... | cmpq $-0x1, %rdi
je 0x67e5
movq 0x84f2(%rip), %rax # 0xecc8
leaq (%rdi,%rax), %rcx
decq %rcx
negq %rax
andq %rcx, %rax
jmp 0x67e7
xorl %eax, %eax
movq %rax, 0x8862(%rip) # 0xf050
retq
| /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dlmallopt | int dlmallopt(int param_number, int value) {
return change_mparam(param_number, value);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
cmpq $0x0, 0x8353(%rip) # 0xecb8
jne 0x696c
callq 0x4d20
movslq %ebp, %rcx
cmpl $-0x3, %ebx
je 0x6a0c
cmpl $-0x1, %ebx
je 0x6a03
xorl %eax, %eax
cmpl $-0x2, %ebx
jne 0x6a1b
cmpq %rcx, 0x832d(%rip) # 0xecc0
ja 0x6a1b
movq %rcx, %rdx
shrq %rdx
mov... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
dispose_chunk | static void dispose_chunk(mstate m, mchunkptr p, size_t psize) {
mchunkptr next = chunk_plus_offset(p, psize);
if (!pinuse(p)) {
mchunkptr prev;
size_t prevsize = p->prev_foot;
if (is_mmapped(p)) {
psize += prevsize + MMAP_FOOT_PAD;
if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
m... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdi,%rsi), %r15
movq 0x8(%rdi), %rax
testb $0x1, %al
jne 0x70b4
movq (%rbx), %rcx
testb $0x2, %al
jne 0x6e9d
addq %rcx, %r14
addq $0x20, %r14
movq %rbx, %rdi
subq %rcx, %rdi
movq %r14, %rsi
callq 0x30f0
testl %eax, %eax
jne 0x6f61
subq %r14, 0x81a8... | /DevSolar[P]pdclib/functions/_dlmalloc/malloc.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rdi), %rax
movq %rax, 0x18(%rsp)
movb 0x1(%rdi), %al
cmpb $0x25, %al
jne 0x772f
movq 0x10(%rbx), %rcx
cmpq 0x8(%rbx), %rcx
jae 0x785f
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x7858
movl $0x25, %edi
callq 0x8adc
jmp ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
PDCLIB_print_double | void _PDCLIB_print_double( double value, struct _PDCLIB_status_t * status )
{
unsigned char bytes[ sizeof( double ) ];
int exp;
memcpy( bytes, &value, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( bytes ) - _PDCLIB_DBL_BIAS;
if ( exp == _PDCLIB_DBL_MAX_EXP )
{
/* ... | pushq %rax
movq %rdi, %r9
leaq 0x6(%rsp), %rcx
movsd %xmm0, -0x6(%rcx)
movzbl 0x1(%rcx), %edi
movl %edi, %eax
andl $0x7f, %eax
shll $0x4, %eax
movzbl (%rcx), %r8d
shrl $0x4, %r8d
leal (%r8,%rax), %edx
addl $0xfffffc01, %edx # imm = 0xFFFFFC01
xorl %esi, %esi
ucomisd %xmm0, %xmm0
setp %sil
addl $0x7fffffff, %esi ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
PDCLIB_print_string | void _PDCLIB_print_string( const char * s, struct _PDCLIB_status_t * status )
{
if ( status->flags & E_char )
{
status->prec = 1;
}
else
{
if ( status->prec < 0 )
{
status->prec = strlen( s );
}
else
{
int i;
for ( ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %ebp
movl $0x1, %eax
testb $0x40, %bpl
jne 0x87cf
movl 0x30(%rbx), %ecx
testl %ecx, %ecx
js 0x87c7
testq %rcx, %rcx
je 0x87d2
xorl %eax, %eax
cmpb $0x0, (%r14,%rax)
je 0x87cf
incq %rax
cmpq %rax, %rcx
jne 0x87b6
jmp 0x87d2
movq %r14, %rdi
... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_string.c |
PDCLIB_open | _PDCLIB_fd_t _PDCLIB_open( const char * const filename, unsigned int mode )
{
/* This is an example implementation of _PDCLIB_open() fit for use with
POSIX kernels.
*/
int osmode;
_PDCLIB_fd_t rc;
switch ( mode & ( _PDCLIB_FREAD | _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FRW ) )
{
... | pushq %rbp
pushq %rbx
pushq %rax
andl $0x78, %esi
addl $-0x8, %esi
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x5f, %esi
ja 0x89cd
shrl $0x3, %esi
movl $0xb0b, %eax # imm = 0xB0B
btl %esi, %eax
jae 0x89cd
movl %esi, %eax
leaq 0x185b(%rip), %rcx # 0xa1ec
movl (%rcx,%rax,4), %eax
movl $0x5f5, %... | /DevSolar[P]pdclib/platform/example/functions/_PDCLIB/_PDCLIB_open.c |
fprintf | int fprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
rc = vfprintf( stream, format, ap );
va_end( ap );
return rc;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x8aaf
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%... | /DevSolar[P]pdclib/functions/stdio/fprintf.c |
strtol | long int strtol( const char * s, char ** endptr, int base )
{
long int rc;
char sign = '+';
const char * p = _PDCLIB_strtox_prelim( s, &sign, &base );
if ( base < 2 || base > 36 )
{
return 0;
}
if ( sign == '+' )
{
rc = ( long int )_PDCLIB_strtox_main( &p, ( unsigned )b... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c(%rsp), %r15
movl %edx, (%r15)
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movq %r15, %rdx
callq 0x8ef8
movq %rax, 0x10(%rsp)
movslq (%r15), %rsi
leal -0x25(%rsi), %eax
cmpl $-0x23, %eax
jae 0x8c52
xorl %ecx, %ecx
jmp 0x8ced
movabsq ... | /DevSolar[P]pdclib/functions/stdlib/strtol.c |
signal | void ( *signal( int sig, void ( *func )( int ) ) )( int )
{
void ( *oldhandler )( int );
if ( sig <= 0 || func == SIG_ERR )
{
return SIG_ERR;
}
switch ( sig )
{
case SIGABRT:
oldhandler = _PDCLIB_sigabrt;
_PDCLIB_sigabrt = func;
break;
... | pushq %rbx
testl %edi, %edi
setle %al
cmpq $-0x1, %rsi
sete %cl
orb %al, %cl
movq $-0x1, %rbx
je 0x9055
movq %rbx, %rax
popq %rbx
retq
addl $-0x2, %edi
cmpl $0xd, %edi
ja 0x909d
leaq 0x1db8(%rip), %rax # 0xae1c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x12534(%rip), %rbx # 0x1b5a8
movq %rsi, ... | /DevSolar[P]pdclib/platform/example/functions/signal/signal.c |
fputc | int fputc( int c, struct _PDCLIB_file_t * stream )
{
_PDCLIB_LOCK( stream->mtx );
if ( _PDCLIB_prepwrite( stream ) == EOF )
{
_PDCLIB_UNLOCK( stream->mtx );
return EOF;
}
stream->buffer[stream->bufidx++] = ( char )c;
if ( ( stream->bufidx == stream->bufsize ) ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movl %edi, %ebx
leaq 0x48(%rsi), %r14
movq %r14, %rdi
callq 0x8a1c
movq %r15, %rdi
callq 0x7698
cmpl $-0x1, %eax
je 0x9132
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%r15)
movb %bl, (%rax,%rcx)
movq 0x18(%r15), %rax
cmpq 0x10(%r15), %... | /DevSolar[P]pdclib/functions/stdio/fputc.c |
roaring_bitmap_and_inplace | void roaring_bitmap_and_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2) {
if (x1 == x2) return;
int pos1 = 0, pos2 = 0, intersection_size = 0;
const int length1 = ra_get_size(&x1->high_low_container);
const int length2 = ra_get_size(&x2->high_low_container);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpq %rsi, %rdi
je 0x7ab9
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %r15d
movl (%rsi), %r12d
testl %r15d, %r15d
setg %al
testl %r12d, %r12d
setg %cl
andb %al, %cl
movq $0x0, 0x20(%rsp)
movl $0x0, %eax
cmpb $0x1, %cl
jne 0x7a86
xorl %e... | /lucaderi[P]CRoaring/src/roaring.c |
container_or | static inline container_t *container_or(const container_t *c1, uint8_t type1,
const container_t *c2, uint8_t type2,
uint8_t *result_type) {
c1 = container_unwrap_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
cont... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r15
cmpl $0x4, %esi
jne 0x7e4a
movb 0x8(%r15), %sil
movq (%r15), %r15
cmpb $0x4, %cl
jne 0x7e56
movb 0x8(%r14), %cl
movq (%r14), %r14
movq $0x0, (%rsp)
movzbl %sil, %eax
movzbl %cl, %ecx
leal (%rcx,%rax,4), %eax
addl $-0x5... | /lucaderi[P]CRoaring/include/roaring/containers/containers.h |
roaring_bitmap_xor | roaring_bitmap_t *roaring_bitmap_xor(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2) {
uint8_t result_type = 0;
const int length1 = x1->high_low_container.size,
length2 = x2->high_low_container.size;
if (0 == length1) {
return roaring_bitmap... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movb $0x0, 0x5(%rsp)
movl (%rdi), %r14d
testl %r14d, %r14d
je 0x84c4
movq %rdi, %rbx
movl (%r15), %eax
testl %eax, %eax
je 0x8805
movq %rax, 0x10(%rsp)
leal (%rax,%r14), %edi
callq 0x3393
testb $0x1, 0x20(%rbx)
movq %rax,... | /lucaderi[P]CRoaring/src/roaring.c |
container_ixor | static inline container_t *container_ixor(container_t *c1, uint8_t type1,
const container_t *c2, uint8_t type2,
uint8_t *result_type) {
c1 = get_writable_copy_if_shared(c1, &type1);
c2 = container_unwrap_shared(c2, &type2);
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movb %sil, 0x7(%rsp)
cmpl $0x4, %esi
jne 0x8c53
leaq 0x7(%rsp), %rsi
callq 0x1a907
movq %rax, %rdi
cmpb $0x4, %bpl
jne 0x8c60
movb 0x8(%r14), %bpl
movq (%r14), %r14
movq $0x0, 0x8(%rsp)
movzbl 0x7(%rsp), %eax
movzbl %bpl, %... | /lucaderi[P]CRoaring/include/roaring/containers/containers.h |
roaring_bitmap_andnot_inplace | void roaring_bitmap_andnot_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2) {
assert(x1 != x2);
uint8_t result_type = 0;
int length1 = x1->high_low_container.size;
const int length2 = x2->high_low_container.size;
int intersection_size = 0;
if (0 == l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movb $0x0, 0x7(%rsp)
movl (%rsi), %r11d
testl %r11d, %r11d
je 0x9682
movq %rdi, %rbx
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x9691
movq %rsi, %r10
movq 0x10(%rbx), %rax
movzwl (%rax), %r14d
movq 0x10(%rsi), %rax
movzwl (%rax), %r13d
movl ... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_shrink_to_fit | size_t roaring_bitmap_shrink_to_fit(roaring_bitmap_t *r) {
size_t answer = 0;
for (int i = 0; i < r->high_low_container.size; i++) {
uint8_t type_original;
container_t *c = ra_get_container_at_index(&r->high_low_container,
(uint16_t)i, &type_ori... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
cmpl $0x0, (%rdi)
jle 0x9b18
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rax
movzwl %r15w, %edx
movb (%rax,%rdx), %al
movq (%rcx,%rdx,8), %rdi
cmpb $0x4, %al
jne 0x9aed
movb 0x8(%rdi), %al
movq (%rdi), %rdi
cmpb $0x1, %al
je 0x9b00
movzbl %... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_portable_deserialize_safe | roaring_bitmap_t *roaring_bitmap_portable_deserialize_safe(const char *buf,
size_t maxbytes) {
roaring_bitmap_t *ans =
(roaring_bitmap_t *)roaring_malloc(sizeof(roaring_bitmap_t));
if (ans == NULL) {
return NULL;
}
size_t bytesre... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0x32fd
testq %rax, %rax
je 0x9ced
movq %rax, %rbx
leaq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe733
testb %al, %al
je 0x9ce5
andb $-0x2, 0x20(%rbx)
jmp 0x9cef
movq %rbx, %rdi
callq 0x... | /lucaderi[P]CRoaring/src/roaring.c |
loadfirstvalue | CROARING_WARN_UNUSED static bool loadfirstvalue(
roaring_uint32_iterator_t *newit) {
if (iter_new_container_partial_init(newit)) {
uint16_t value = 0;
newit->container_it =
container_init_iterator(newit->container, newit->typecode, &value);
newit->current_value = newit->highb... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd1b6
testb %al, %al
je 0x9f38
leaq 0x6(%rsp), %r14
movw $0x0, (%r14)
movq 0x8(%rbx), %rdi
movzbl 0x10(%rbx), %esi
movq %r14, %rdx
callq 0x1a932
movl %eax, 0x1c(%rbx)
movzwl (%r14), %eax
orl 0x18(%rbx), %eax
movl %eax, 0x20(%rbx)
movb 0x24(%rbx), %al
addq $0x8, %r... | /lucaderi[P]CRoaring/src/roaring.c |
bitset_container_from_array | bitset_container_t *bitset_container_from_array(const array_container_t *ac) {
bitset_container_t *ans = bitset_container_create();
int limit = array_container_cardinality(ac);
for (int i = 0; i < limit; ++i) bitset_container_set(ans, ac->array[i]);
return ans;
} | pushq %rbx
movq %rdi, %rbx
callq 0x137c5
movslq (%rbx), %rdx
testq %rdx, %rdx
jle 0x1b314
movq 0x8(%rbx), %rsi
movq 0x8(%rax), %r8
movl (%rax), %edi
xorl %r9d, %r9d
movzwl (%rsi,%r9,2), %ecx
movl %ecx, %r10d
shrl $0x6, %r10d
movq (%r8,%r10,8), %r11
movq %r11, %rbx
btsq %rcx, %rbx
xorq %rbx, %r11
shrq %cl, %r11
addl %r1... | /lucaderi[P]CRoaring/src/containers/convert.c |
bitset_bitset_container_intersection | bool bitset_bitset_container_intersection(const bitset_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
const int newCardinality = bitset_container_and_justcard(src_1, src_2);
if (newCardinality > DEFAUL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x16a02
movl %eax, %ebx
cmpl $0x1001, %eax # imm = 0x1001
jl 0x1cb1d
callq 0x137c5
movq %rax, (%r12)
testq %rax, %rax
je 0x1cb48
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x167a8
movq (%r12... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
bitset_bitset_container_intersection_inplace | bool bitset_bitset_container_intersection_inplace(
bitset_container_t *src_1, const bitset_container_t *src_2,
container_t **dst) {
const int newCardinality = bitset_container_and_justcard(src_1, src_2);
if (newCardinality > DEFAULT_MAX_SIZE) {
*dst = src_1;
bitset_container_and_nocard(s... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x16a02
movl %eax, %ebx
cmpl $0x1001, %eax # imm = 0x1001
jl 0x1cb96
movq %r15, (%r12)
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x167a8
movq (%r12), %rax
movl %ebx, (%rax)
jmp 0x1cbc1
movl... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
array_container_is_subset_bitset | bool array_container_is_subset_bitset(const array_container_t* container1,
const bitset_container_t* container2) {
if (container2->cardinality != BITSET_UNKNOWN_CARDINALITY) {
if (container2->cardinality < container1->cardinality) {
return false;
}
... | movl (%rsi), %eax
cmpl $-0x1, %eax
je 0x1d87e
cmpl (%rdi), %eax
jge 0x1d87e
xorl %eax, %eax
retq
movslq (%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x1d87d
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
movzwl (%rdx), %edi
movl %edi, %r8d
shrl $0x6, %r8d
movq (%rsi,%r8,8), %r8
btq %rdi, %r8
jae 0x1d87d
movl $0x1, %edi
movq ... | /lucaderi[P]CRoaring/src/containers/mixed_subset.c |
run_container_is_subset_array | bool run_container_is_subset_array(const run_container_t* container1,
const array_container_t* container2) {
if (run_container_cardinality(container1) > container2->cardinality)
return false;
int32_t start_pos = -1, stop_pos = -1;
for (int i = 0; i < container1->n_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20a24
movl (%rbx), %ecx
cmpl %ecx, %eax
jle 0x1d8f5
xorl %eax, %eax
jmp 0x1da96
movslq (%r14), %rdx
testq %rdx, %rdx
setle %al
jle 0x1da96
movq 0x8(%r14), %rsi
movq 0x8(%rbx), %rdi
leal -0x1(%rcx), %r8d
... | /lucaderi[P]CRoaring/src/containers/mixed_subset.c |
array_bitset_container_xor | bool array_bitset_container_xor(const array_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_2, result);
result->cardinality = (int32_t)b... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x137c5
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x13820
movq 0x8(%r14), %rdi
movslq (%r14), %rsi
movq 0x8(%r12), %rdx
movslq (%r12), %rcx
callq 0x11356
movq %rax, %r15
movl %r15d, (%r14)
cmpl $0x10... | /lucaderi[P]CRoaring/src/containers/mixed_xor.c |
run_bitset_container_xor | bool run_bitset_container_xor(const run_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_2, result);
for (int32_t rlepos = 0; rlepos < src_1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x137c5
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x13820
movslq (%r15), %rdx
testq %rdx, %rdx
jle 0x1e661
movq 0x8(%r15), %rsi
movq 0x8(%r14), %rdi
xorl %r8d, %r8d
movzwl (%rsi,%r8,4), %ecx
movzwl 0... | /lucaderi[P]CRoaring/src/containers/mixed_xor.c |
run_bitset_container_lazy_xor | void run_bitset_container_lazy_xor(const run_container_t *src_1,
const bitset_container_t *src_2,
bitset_container_t *dst) {
if (src_2 != dst) bitset_container_copy(src_2, dst);
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq %rdx, %rsi
je 0x1e6b9
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x13820
movslq (%r14), %rdx
testq %rdx, %rdx
jle 0x1e734
movq 0x8(%r14), %rsi
movq 0x8(%rbx), %rdi
xorl %r8d, %r8d
movzwl (%rsi,%r8,4), %ecx
movzwl 0x2(%rsi,%r8,4), %eax
leal (%rax,%rcx), %r... | /lucaderi[P]CRoaring/src/containers/mixed_xor.c |
bitset_bitset_container_ixor | bool bitset_bitset_container_ixor(bitset_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
int card = bitset_container_xor(src_1, src_2, src_1);
if (card <= DEFAULT_MAX_SIZE) {
*dst = array_container_from_bitset(... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rdi, %rdx
callq 0x17eb9
movl %eax, %ebp
cmpl $0x1000, %eax # imm = 0x1000
jle 0x1eaee
movq %rbx, (%r14)
jmp 0x1eb01
movq %rbx, %rdi
callq 0x1b49b
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x13af1
cmpl $0x1001, %ebp # imm = 0x1001
s... | /lucaderi[P]CRoaring/src/containers/mixed_xor.c |
array_bitset_container_andnot | void array_bitset_container_andnot(const array_container_t *src_1,
const bitset_container_t *src_2,
array_container_t *dst) {
// follows Java implementation as of June 2016
if (dst->capacity < src_1->cardinality) {
array_container_gro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %esi
cmpl %esi, 0x4(%rdx)
jge 0x1ec0f
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12f53
movslq (%r15), %rax
testq %rax, %rax
jle 0x1ec51
movq 0x8(%r15), %rcx
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rdi
xorl %r8d, %r8d
xorl %esi, %es... | /lucaderi[P]CRoaring/src/containers/mixed_andnot.c |
bitset_array_container_iandnot | bool bitset_array_container_iandnot(bitset_container_t *src_1,
const array_container_t *src_2,
container_t **dst) {
*dst = src_1;
src_1->cardinality =
(int32_t)bitset_clear_list(src_1->words, (uint64_t)src_1->cardinality,
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rdi, (%rdx)
movq 0x8(%rdi), %rdi
movslq (%rbx), %rax
movq 0x8(%rsi), %rdx
movslq (%rsi), %rcx
movq %rax, %rsi
callq 0x11149
movq %rax, %r15
movl %r15d, (%rbx)
cmpl $0x1000, %r15d # imm = 0x1000
jg 0x1ed1d
movq %rbx, %rdi
callq 0x1b49b
movq ... | /lucaderi[P]CRoaring/src/containers/mixed_andnot.c |
bitset_run_container_andnot | bool bitset_run_container_andnot(const bitset_container_t *src_1,
const run_container_t *src_2,
container_t **dst) {
// follows Java implementation
bitset_container_t *result = bitset_container_create();
bitset_container_copy(src_1, result);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
callq 0x137c5
movq %r12, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
callq 0x13820
movslq (%r15), %r12
testq %r12, %r12
jle 0x1f0a1
movq 0x8(%r15), %r13
movq 0x8(%rsp), %rax
movq 0x8(%rax),... | /lucaderi[P]CRoaring/src/containers/mixed_andnot.c |
bitset_bitset_container_andnot | bool bitset_bitset_container_andnot(const bitset_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
bitset_container_t *ans = bitset_container_create();
int card = bitset_container_andnot(src_1, src_2, ans);
if (c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x137c5
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x18d8f
movl %eax, %ebp
cmpl $0x1000, %eax # imm = 0x1000
jle 0x1f74e
movq %r14, (%rbx)
jmp 0x1f761
movq %r14, %rdi
callq 0... | /lucaderi[P]CRoaring/src/containers/mixed_andnot.c |
run_container_copy | void run_container_copy(const run_container_t *src, run_container_t *dst) {
const int32_t n_runs = src->n_runs;
if (src->n_runs > dst->capacity) {
run_container_grow(dst, n_runs, false);
}
dst->n_runs = n_runs;
memcpy(dst->runs, src->runs, sizeof(rle16_t) * n_runs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %ebp
movslq %ebp, %rbx
cmpl 0x4(%rsi), %ebx
jle 0x1fe46
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x1fd99
movl %ebp, (%r15)
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
shlq $0x2, %rbx
movq %rbx, %rdx
addq $0x8,... | /lucaderi[P]CRoaring/src/containers/run.c |
run_container_intersection_cardinality | int run_container_intersection_cardinality(const run_container_t *src_1,
const run_container_t *src_2) {
const bool if1 = run_container_is_full(src_1);
const bool if2 = run_container_is_full(src_2);
if (if1 || if2) {
if (if1) {
return run_contai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movzwl (%rcx), %r8d
movl (%rdi), %edx
cmpl $0x1, %edx
sete %al
testw %r8w, %r8w
sete %sil
andb %al, %sil
cmpb $0x1, %sil
jne 0x207d9
cmpw $-0x1, 0x2(%rcx)
sete %al
jmp 0x207db
xorl %eax, %eax
movq 0x8(%r14), %rsi... | /lucaderi[P]CRoaring/src/containers/run.c |
run_container_to_uint32_array | ALLOW_UNALIGNED
int run_container_to_uint32_array(void *vout, const run_container_t *cont,
uint32_t base) {
int outpos = 0;
uint32_t *out = (uint32_t *)vout;
for (int i = 0; i < cont->n_runs; ++i) {
uint32_t run_start = base + cont->runs[i].value;
uint16_t l... | cmpl $0x0, (%rsi)
jle 0x20d30
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r8, %rax
movq 0x8(%rsi), %r8
movzwl (%r8,%rcx,4), %r10d
movzwl 0x2(%r8,%rcx,4), %r11d
movslq %eax, %r8
notl %r11d
addl %edx, %r10d
xorl %r9d, %r9d
movl %r10d, (%rdi,%r8,4)
incq %r8
decl %r9d
incl %r10d
cmpl %r9d, %r11d
jne 0x20d0f
incq %rcx
movslq (%rs... | /lucaderi[P]CRoaring/src/containers/run.c |
run_container_rank_many | uint32_t run_container_rank_many(const run_container_t *container,
uint64_t start_rank, const uint32_t *begin,
const uint32_t *end, uint64_t *ans) {
const uint16_t high = (uint16_t)((*begin) >> 16);
const uint32_t *iter = begin;
int sum = 0;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r9
movq %rdx, -0x18(%rsp)
cmpq %rcx, %rdx
je 0x2130b
movq -0x18(%rsp), %r9
movl (%r9), %r10d
leaq 0x1(%rsi), %rax
xorl %ebx, %ebx
movq %rdx, -0x8(%rsp)
xorl %ebp, %ebp
movq %rcx, -0x10(%rsp)
movl %r10d, -0x1c(%rsp)
movl (%r9), %edx
movl %edx,... | /lucaderi[P]CRoaring/src/containers/run.c |
mock | LargestIntegralType _mock(const char * const function, const char* const file,
const int line) {
void *result;
const int rc = get_symbol_value(&global_function_result_map_head,
&function, 1, &result);
if (rc) {
SymbolValue * const symbol ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %fs:0x0, %rax
movq %rax, %rbx
leaq -0x190(%rax), %rdi
movq %rsp, %rcx
movl $0x1, %edx
movq %r15, %rsi
callq 0x2195c
testl %eax, %eax
je 0x218... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
check_in_range | static int check_in_range(const LargestIntegralType value,
const LargestIntegralType check_value_data) {
CheckIntegerRange * const check_integer_range =
cast_largest_integral_type_to_pointer(CheckIntegerRange*,
check_value_data);
as... | pushq %rbx
testq %rsi, %rsi
je 0x22418
movq %rdi, %rax
movq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rcx
cmpq %rdi, %rdx
setbe %sil
cmpq %rdi, %rcx
setae %dil
movl $0x1, %ebx
testb %dil, %sil
jne 0x22414
leaq 0x9a0d(%rip), %rdi # 0x2be15
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x21620
movl %ebx, %eax
popq ... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
check_not_in_range | void _assert_true(const LargestIntegralType result,
const char * const expression,
const char * const file, const int line) {
if (!result) {
cm_print_error("%s\n", expression);
_fail(file, line);
}
} | pushq %rbx
testq %rsi, %rsi
je 0x224dd
movq %rdi, %rax
movq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rcx
cmpq %rdi, %rdx
seta %sil
cmpq %rdi, %rcx
setb %dil
orb %sil, %dil
movl $0x1, %ebx
jne 0x224d9
leaq 0x996d(%rip), %rdi # 0x2be3a
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x21620
movl %ebx, %eax
popq %rbx... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
assert_return_code | void _assert_return_code(const LargestIntegralType result,
size_t rlen,
const LargestIntegralType error,
const char * const expression,
const char * const file,
const int line)
{
LargestInteg... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
cmpq $0x1, %rsi
je 0x2299b
cmpq $0x4, %rsi
je 0x22994
cmpq $0x2, %rsi
jne 0x229a2
movl $0x7ffe, %eax # imm = 0x7FFE
jmp 0x229b9
movl $0x7ffffffe, %eax # imm = 0x7FFFFFFE
jmp 0x229b9
movl... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
assert_float_not_equal | void _assert_float_not_equal(const float a,
const float b,
const float epsilon,
const char * const file,
const int line) {
if (!float_values_not_equal_display_error(a, b, epsilon)) {
_fail(fil... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movaps %xmm0, %xmm4
subss %xmm1, %xmm4
movaps 0x8837(%rip), %xmm5 # 0x2b2e0
xorps %xmm4, %xmm5
movaps %xmm5, %xmm3
cmpless %xmm4, %xmm3
andps %xmm3, %xmm4
andnps %xmm5, %xmm3
orps %xmm4, %xmm3
ucomiss %xmm3, %xmm2
jae 0x22b00
movaps %xmm1, %xmm2
unpck... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
test_realloc | void *_test_realloc(void *ptr,
const size_t size,
const char *file,
const int line)
{
MallocBlockInfo block_info;
char *block = ptr;
size_t block_size = size;
void *new_block;
if (ptr == NULL) {
return _test_malloc(size, file, line);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r13
testq %rdi, %rdi
je 0x232f7
movq %rdi, %r15
testq %r13, %r13
je 0x2330d
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x22f80
testq %rax, %rax
je 0x2331a
movq %rax, %r12
movq -0x48(%r15), %rax
cmpq %r13, %rax
... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
fail_if_leftover_values | static void fail_if_leftover_values(const char *test_name) {
int error_occurred = 0;
(void)test_name;
remove_always_return_values(&global_function_result_map_head, 1);
if (check_for_leftover_values(
&global_function_result_map_head,
"%s() has remaining non-returned values.\n", 1)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %fs:0x0, %rax
movq %rax, %r15
leaq -0x190(%rax), %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x252e7
leaq 0x7b64(%rip), %rsi # 0x2c268
movl $0x1, %edx
movq %rbx, %rdi
callq 0x25413
movq %rax, %r13
leaq -0x140(%r15), %r14
movl $0... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
run_group_tests | int _run_group_tests(const UnitTest * const tests, const size_t number_of_tests)
{
UnitTestFunction setup = NULL;
const char *setup_name;
size_t num_setups = 0;
UnitTestFunction teardown = NULL;
const char *teardown_name = NULL;
size_t num_teardowns = 0;
size_t current_test = 0;
size_t i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movq %fs:0x0, %rax
leaq -0x38(%rax), %r14
cmpq $0x0, (%r14)
jne 0x24cb0
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movl $0x1, 0x8(%r14)
movq $0x1, (%r14)
movq 0x1... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
list_free | static ListNode* list_free(
ListNode * const head, const CleanupListValue cleanup_value,
void * const cleanup_value_data) {
assert_non_null(head);
while (!list_empty(head)) {
list_remove_free(head->next, cleanup_value, cleanup_value_data);
}
return head;
} | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x25096
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %r14, %rdi
callq 0x24fcb
testl %eax, %eax
jne 0x2508d
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21d39
jmp 0x25070
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6ecd(%rip), %r... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
remove_always_return_values | static void remove_always_return_values(ListNode * const map_head,
const size_t number_of_symbol_names) {
ListNode *current;
assert_non_null(map_head);
assert_true(number_of_symbol_names);
current = map_head->next;
while (current != map_head) {
SymbolM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x253c7
movq %rsi, %rbx
testq %rsi, %rsi
je 0x253ed
movq %rdi, %r14
movq 0x10(%rdi), %r12
cmpq %rdi, %r12
je 0x25392
movq (%r12), %r15
testq %r15, %r15
je 0x253a1
movq 0x10(%r12), %rbp
leaq 0x8(%r15), %r13
cmpq %r13, 0x18(%... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
check_for_leftover_values | static size_t check_for_leftover_values(
const ListNode * const map_head, const char * const error_message,
const size_t number_of_symbol_names) {
const ListNode *current;
size_t symbols_with_leftover_values = 0;
assert_non_null(map_head);
assert_true(number_of_symbol_names);
for (c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x25528
movq %rdx, %rax
testq %rdx, %rdx
je 0x2554e
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %r14
cmpq %rcx, %r14
je 0x254ed
leaq 0x6ea8(%rip), %rbp # 0x2c301
xorl %r12d, ... | /lucaderi[P]CRoaring/build_O1/_deps/cmocka-src/src/cmocka.c |
add_userid_option | static void *add_userid_option(pcp_flow_t *f, void *cur) {
pcp_userid_option_t *userid_op = (pcp_userid_option_t *)cur;
userid_op->option = PCP_OPTION_USERID;
userid_op->len =
htons(sizeof(pcp_userid_option_t) - sizeof(pcp_options_hdr_t));
memcpy(&(userid_op->userid[0]), &(f->f_userid.userid[0]... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $0x62, (%rax)
movl $0x200, %edi # imm = 0x200
callq 0x20f0
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rdi
addq $0... | /libpcp[P]pcp/lib/src/pcp_msg.c |
m2d::savanna::load_root_cert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, boost::asio::ssl::context&) | static void load_root_cert(std::string const &cert, ssl::context &ctx)
{
boost::system::error_code ec;
ctx.add_certificate_authority(boost::asio::buffer(cert.data(), cert.size()), ec);
if (ec) {
throw beast::system_error { ec };
}
ctx.set_verify_mode(ssl::verify_peer);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
andl $0x0, (%r15)
movb $0x0, 0x4(%r15)
callq 0xded4
movq %rax, 0x8(%r15)
movups (%r14), %xmm0
leaq 0x10(%rsp), %rsi
movups %xmm0, (%rsi)
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe68a
cmpb $0x1, 0x4(%r15)
je 0xcc59
pushq $0x... | /0x0c[P]savanna/include/savanna/util.hpp |
m2d::savanna::websocket::session<boost::beast::websocket::stream<boost::beast::ssl_stream<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::execution::any_executor<boost::asio::execution::context_as_t<boost::asio::execution_context&>, boost::asio::execution::detail::blocking::never_t<0>, boost::asio::... | void make_connection(websocket::tls_stream &stream, tcp::resolver::results_type const &results, std::string path)
{
net::connect(beast::get_lowest_layer(stream), results.begin(), results.end());
stream.set_option(beast::websocket::stream_base::decorator([](beast::websocket::request_type &req) {
req.set(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x28187
movq %rax, %r13
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x273ba
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
and... | /0x0c[P]savanna/include/savanna/websocket.hpp |
void tinyformat::formatValue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, char const*, char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
const char* fmtEnd, int ntrunc, const T& value)
{
#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
// Since we don't support printing of wchar_t using "%ls", make it fail at
// compile time in preference to printing as a void* at... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
testl %ecx, %ecx
js 0x177dc
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0x177f4
movq %r8, %rsi
movl %ecx, %edx
popq %rax
jmp 0x177f9
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0x177f4
movq %r8, %rsi
popq %rax
jmp 0xd570
callq 0xd6f0
| /brunoerg[P]bitcoin/src/tinyformat.h |
void tinyformat::detail::formatTruncated<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | inline void formatTruncated(std::ostream& out, const T& value, int ntrunc)
{
std::ostringstream tmp;
tmp << value;
std::string result = tmp.str();
out.write(result.c_str(), (std::min)(ntrunc, static_cast<int>(result.size())));
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x1a0(%rsp)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xd840
movq %r15, %rdi
movq %r14, %rsi
callq 0xd570
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), ... | /brunoerg[P]bitcoin/src/tinyformat.h |
std::optional<uint256> detail::FromHex<uint256>(std::basic_string_view<char, std::char_traits<char>>) | std::optional<uintN_t> FromHex(std::string_view str)
{
if (uintN_t::size() * 2 != str.size() || !IsHex(str)) return std::nullopt;
uintN_t rv;
rv.SetHexDeprecated(str);
return rv;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
cmpq $0x40, %rsi
jne 0x19429
movq %rdx, %r14
pushq $0x40
popq %rdi
movq %rdx, %rsi
callq 0xb369c
testb %al, %al
je 0x19429
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
... | /brunoerg[P]bitcoin/src/uint256.h |
void tinyformat::format<unsigned int, int>(std::ostream&, char const*, unsigned int const&, int const&) | void format(std::ostream& out, const char* fmt, const Args&... args)
{
vformat(out, fmt, makeFormatList(args...));
} | endbr64
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x2, -0x8(%rax)
movq %rdx, (%rax)
leaq -0x312(%rip), %rdx # 0x1b526
movq %rdx, 0x8(%rax)
leaq -0x2f1(%rip), %rdx # 0x1b552
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
leaq 0x32(%rip), %rcx ... | /brunoerg[P]bitcoin/src/tinyformat.h |
(anonymous namespace)::CScriptVisitor::operator()(WitnessUnknown const&) const | CScript operator()(const WitnessUnknown& id) const
{
return CScript() << CScript::EncodeOP_N(id.GetWitnessVersion()) << id.GetWitnessProgram();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movl (%rsi), %edi
callq 0x230ea
movq %r15, %rdi
movl %eax, %esi
callq 0x1ba60
movq 0x8(%r14), %rsi
movq 0x10(%r14),... | /brunoerg[P]bitcoin/src/addresstype.cpp |
PayToAnchor::PayToAnchor() | PayToAnchor() : WitnessUnknown(1, {0x4e, 0x73}) {
Assume(CScript::IsPayToAnchor(1, {0x4e, 0x73}));
} | endbr64
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
leaq 0x2e(%rsp), %rsi
movw $0x734e, (%rsi) # imm = 0x734E
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x22caa
movl $0x1, (%rbx)
addq $0x8, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi... | /brunoerg[P]bitcoin/src/addresstype.h |
std::vector<unsigned char, std::allocator<unsigned char>> ToByteVector<CPubKey>(CPubKey const&) | std::vector<unsigned char> ToByteVector(const T& in)
{
return std::vector<unsigned char>(in.begin(), in.end());
} | endbr64
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movb (%rsi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0x22edb
pushq $0x21
popq %rdx
jmp 0x22ef3
addb $-0x4, %al
cmpb $0x3, %al
ja 0x22ef1
movzbl %al, %eax
leaq 0xffac5(%rip), %rcx # 0x1229b0
movq (%rcx,%rax,8)... | /brunoerg[P]bitcoin/src/script/script.h |
void tinyformat::formatValue<long>(std::ostream&, char const*, char const*, int, long const&) | inline void formatValue(std::ostream& out, const char* /*fmtBegin*/,
const char* fmtEnd, int ntrunc, const T& value)
{
#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS
// Since we don't support printing of wchar_t using "%ls", make it fail at
// compile time in preference to printing as a void* at... | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
cmpb $0x63, -0x1(%rdx)
jne 0x263de
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0x26414
movq %r8, %rsi
popq %rax
jmp 0x2641a
testl %ecx, %ecx
js 0x263fc
movq %fs:0x28, %rax
cmpq (%rsp), %rax
jne 0x26414
movq %r8, %rsi
movl %ecx, %edx
popq %rax
jmp 0x2644b
movq (%r8)... | /brunoerg[P]bitcoin/src/tinyformat.h |
CCoinsViewCache::CCoinsViewCache(CCoinsView*, bool) | CCoinsViewCache::CCoinsViewCache(CCoinsView* baseIn, bool deterministic) :
CCoinsViewBacked(baseIn), m_deterministic(deterministic),
cacheCoins(0, SaltedOutpointHasher(/*deterministic=*/deterministic), CCoinsMap::key_equal{}, &m_cache_coins_memory_resource)
{
m_sentinel.second.SelfRef(m_sentinel);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq %rsi, 0x8(%rdi)
leaq 0x297eb6(%rip), %rax # 0x2bf288
addq $0x10, %rax
movq %rax, (%rdi)
movb %bpl, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x11(%rdi)
movups %xmm0, 0... | /brunoerg[P]bitcoin/src/coins.cpp |
CCoinsViewCache::HaveInputs(CTransaction const&) const | bool CCoinsViewCache::HaveInputs(const CTransaction& tx) const
{
if (!tx.IsCoinBase()) {
for (unsigned int i = 0; i < tx.vin.size(); i++) {
if (!HaveCoin(tx.vin[i].prevout)) {
return false;
}
}
}
return true;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rdi
callq 0x28854
movb $0x1, %bpl
testb %al, %al
jne 0x28197
xorl %ecx, %ecx
pushq $0x68
popq %r15
movl %ecx, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
... | /brunoerg[P]bitcoin/src/coins.cpp |
InterpretValue(KeyInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
unsigned int flags, std::string& error)
{
// Return negated settings as false values.
if (key.negated) {
if (flags & ArgsManager::DISALLOW_NEGATION) {
... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
cmpb $0x1, 0x40(%rsi)
jne 0x2a8d8
testb $0x20, %cl
jne 0x2a8fc
testq %r14, %r14
je 0x2a8cb
movq %r14, %rdi
callq 0x2aa16
testb %al, %al
je 0x2a97a... | /brunoerg[P]bitcoin/src/common/args.cpp |
common::OnlyHasDefaultSectionSetting(common::Settings const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool OnlyHasDefaultSectionSetting(const Settings& settings, const std::string& section, const std::string& name)
{
bool has_default_section_setting = false;
bool has_other_setting = false;
MergeSettings(settings, section, name, [&](SettingsSpan span, Source source) {
if (span.empty()) return;
... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
xorl %eax, %eax
leaq 0x1f(%rsp), %rcx
movb %al, (%rcx)
leaq 0x1e(%rsp), %rdx
movb %al, (%rdx)
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, %rsi
callq 0x... | /brunoerg[P]bitcoin/src/common/settings.cpp |
decltype(&fp.at(fp0)) common::FindKey<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<UniValue, std::allocator<UniValue>>, std::less<std::__cxx11::basic_string<char, std::char_tr... | auto FindKey(Map&& map, Key&& key) -> decltype(&map.at(key))
{
auto it = map.find(key);
return it == map.end() ? nullptr : &it->second;
} | endbr64
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x15fb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38218
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x15bca
addq $0x8, %rbx
leaq 0x40(%r14), %rcx
xorl %... | /brunoerg[P]bitcoin/src/common/settings.h |
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>,... | void Unserialize(Stream& is, std::vector<T, A>& v)
{
if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
// Limit size per read so bogus size value won't cause out of memory
v.clear();
unsigned int nSize = ReadCompactSize(is);
unsigned int i = 0;
... | endbr64
subq $0x18, %rsp
movq %rdi, %rax
movq %fs:0x28, %rcx
movq %rcx, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
movq %rax, %rsi
callq 0x3c7ac
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x3c7a6
addq $0x18, %rsp
retq
callq 0xd6f0
nop
| /brunoerg[P]bitcoin/src/serialize.h |
DescriptorCache::GetCachedParentExtPubKey(unsigned int, CExtPubKey&) const | bool DescriptorCache::GetCachedParentExtPubKey(uint32_t key_exp_pos, CExtPubKey& xpub) const
{
const auto& it = m_parent_xpubs.find(key_exp_pos);
if (it == m_parent_xpubs.end()) return false;
xpub = it->second;
return true;
} | endbr64
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x813f8
testq %rax, %rax
je 0x55bda
leaq 0xc(%rax), %rsi
pushq $0x71
popq %rcx
movq %rbx, %rdi
rep movsb (%rsi), %es:(%rdi)
testq %rax, %rax
setne %... | /brunoerg[P]bitcoin/src/script/descriptor.cpp |
(anonymous namespace)::PolyMod(unsigned long, int) | uint64_t PolyMod(uint64_t c, int val)
{
uint8_t c0 = c >> 35;
c = ((c & 0x7ffffffff) << 5) ^ val;
if (c0 & 1) c ^= 0xf5dee51989;
if (c0 & 2) c ^= 0xa9fdca3312;
if (c0 & 4) c ^= 0x1bab10e32d;
if (c0 & 8) c ^= 0x3706b1677a;
if (c0 & 16) c ^= 0x644d626ffd;
return c;
} | pushq %rax
movq %rdi, %rcx
shrq $0x23, %rcx
movq %rdi, %rax
shlq $0x5, %rax
movabsq $0xffffffffe0, %rdx # imm = 0xFFFFFFFFE0
andq %rax, %rdx
movslq %esi, %rax
xorq %rdx, %rax
movabsq $0xf5dee51989, %rdx # imm = 0xF5DEE51989
xorq %rax, %rdx
btq $0x23, %rdi
cmovaeq %rax, %rdx
movabsq $0xa9fdca3312, %rax # imm... | /brunoerg[P]bitcoin/src/script/descriptor.cpp |
(anonymous namespace)::ParsePubkey(unsigned int, Span<char const> const&, (anonymous namespace)::ParseScriptContext, FlatSigningProvider&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | std::vector<std::unique_ptr<PubkeyProvider>> ParsePubkey(uint32_t key_exp_index, const Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)
{
std::vector<std::unique_ptr<PubkeyProvider>> ret;
auto origin_split = Split(sp, ']');
if (origin_split.size() > 2) {
er... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r9, %r15
movq %r8, %r12
movl %ecx, %r13d
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x140(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xc0(%rsp)
andq $0x0, 0xd0(%rsp)
leaq 0xa8(%rsp), %rdi
p... | /brunoerg[P]bitcoin/src/script/descriptor.cpp |
(anonymous namespace)::WSHDescriptor::Clone() const | std::unique_ptr<DescriptorImpl> Clone() const override
{
return std::make_unique<WSHDescriptor>(m_subdescriptor_args.at(0)->Clone());
} | endbr64
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsi), %rdi
callq 0x5e684
movq (%rax), %rsi
movq (%rsi), %rax
movq %rsp, %r14
movq %r14, %rdi
callq *0xa8(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x57579
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
and... | /brunoerg[P]bitcoin/src/script/descriptor.cpp |
std::optional<unsigned int> (anonymous namespace)::KeyParser::FromPKBytes<__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigne... | std::optional<Key> FromPKBytes(I begin, I end) const
{
assert(m_in);
Key key = m_keys.size();
if (miniscript::IsTapscript(m_script_ctx) && end - begin == 32) {
XOnlyPubKey pubkey;
std::copy(begin, end, pubkey.begin());
if (auto pubkey_provider = InferPubke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x6aa5f
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %r15
movq 0x10(%rdi), %rbp
movq 0x18(%rdi), %rbx
movl 0x48(%rdi), %edi
callq 0x74f08
movq %r13, %r... | /brunoerg[P]bitcoin/src/script/descriptor.cpp |
operator<(CPubKey const&, CPubKey const&) | bool operator<(const CPubKey& a, const CPubKey& b)
{
return a.vch[0] < b.vch[0] ||
(a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) < 0);
} | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movb (%rdi), %cl
movb (%rsi), %dl
movb $0x1, %al
cmpb %dl, %cl
jb 0x6f26e
jne 0x6f248
movl %ecx, %eax
andb $-0x2, %al
cmpb $0x2, %al
jne 0x6f24c
pushq $0x21
popq %rdx
jmp 0x6f266
xorl %eax, %eax
jmp 0x6f26e
addb $-0x4, %cl
cmpb $0x3, %cl
ja 0x6f264
movzbl %cl, %e... | /brunoerg[P]bitcoin/src/pubkey.h |
operator>(CPubKey const&, CPubKey const&) | bool operator>(const CPubKey& a, const CPubKey& b)
{
return a.vch[0] > b.vch[0] ||
(a.vch[0] == b.vch[0] && memcmp(a.vch, b.vch, a.size()) > 0);
} | endbr64
pushq %rax
movq %fs:0x28, %rax
movq %rax, (%rsp)
movb (%rdi), %cl
movb (%rsi), %dl
movb $0x1, %al
cmpb %dl, %cl
ja 0x6f640
jne 0x6f618
movl %ecx, %eax
andb $-0x2, %al
cmpb $0x2, %al
jne 0x6f61c
pushq $0x21
popq %rdx
jmp 0x6f636
xorl %eax, %eax
jmp 0x6f640
addb $-0x4, %cl
cmpb $0x3, %cl
ja 0x6f634
movzbl %cl, %e... | /brunoerg[P]bitcoin/src/pubkey.h |
CScript BuildScript<int const&>(int const&) | CScript BuildScript(Ts&&... inputs)
{
CScript ret;
int cnt{0};
([&ret, &cnt] (Ts&& input) {
if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<Ts>>, CScript>) {
// If it is a CScript, extend ret with it. Move or copy the first element instead.
if (cnt == 0... | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x1c(%rsp), %rax
andl $0x0, (%rax)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
callq 0x7065a
movq %fs:0x28, %rax
cmpq 0x20(%rsp),... | /brunoerg[P]bitcoin/src/script/script.h |
CScript BuildScript<opcodetype, opcodetype, CScript&, opcodetype>(opcodetype&&, opcodetype&&, CScript&, opcodetype&&) | CScript BuildScript(Ts&&... inputs)
{
CScript ret;
int cnt{0};
([&ret, &cnt] (Ts&& input) {
if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<Ts>>, CScript>) {
// If it is a CScript, extend ret with it. Move or copy the first element instead.
if (cnt == 0... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x44(%rsp), %r13
andl $0x0, (%r13)
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rdi
movq %rb... | /brunoerg[P]bitcoin/src/script/script.h |
CScript BuildScript<CScript, unsigned int const&, opcodetype>(CScript&&, unsigned int const&, opcodetype&&) | CScript BuildScript(Ts&&... inputs)
{
CScript ret;
int cnt{0};
([&ret, &cnt] (Ts&& input) {
if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<Ts>>, CScript>) {
// If it is a CScript, extend ret with it. Move or copy the first element instead.
if (cnt == 0... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x3c(%rsp), %r12
andl $0x0, (%r12)
movups %xmm0, (%rdi)
leaq 0x28(%rsp), %rdi
movq %rbx, (%rdi)
movq %r12, 0x8(%... | /brunoerg[P]bitcoin/src/script/script.h |
CreateSig(BaseSignatureCreator const&, SignatureData&, SigningProvider const&, std::vector<unsigned char, std::allocator<unsigned char>>&, CPubKey const&, CScript const&, SigVersion) | static bool CreateSig(const BaseSignatureCreator& creator, SignatureData& sigdata, const SigningProvider& provider, std::vector<unsigned char>& sig_out, const CPubKey& pubkey, const CScript& scriptcode, SigVersion sigversion)
{
CKeyID keyid = pubkey.GetID();
const auto it = sigdata.signatures.find(keyid);
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, 0x28(%rsp)
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x20(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xd0(%rsp)
leaq 0xbc(%rsp), %r14
movq %r14, %rdi
movq %r8, %rsi
callq 0x225c2
leaq 0x160(%r12), %r15... | /brunoerg[P]bitcoin/src/script/sign.cpp |
std::shared_ptr<miniscript::Node<WshSatisfier::Key> const> miniscript::FromScript<WshSatisfier>(CScript const&, WshSatisfier const&) | inline NodeRef<typename Ctx::Key> FromScript(const CScript& script, const Ctx& ctx) {
using namespace internal;
// A too large Script is necessarily invalid, don't bother parsing it.
if (script.size() > MaxScriptSize(ctx.MsContext())) return {};
auto decomposed = DecomposeScript(script);
if (!decomp... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x38(%rsp)
movl 0x1c(%rsi), %eax
movl %eax, %ebp
subl $0x1d, %ebp
cmovbl %eax, %ebp
movl 0x20(%rdx), %edi
callq 0x74cf8
cmpl %eax, %ebp
jbe 0x863a9
movq %fs:0x28... | /brunoerg[P]bitcoin/src/script/miniscript.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.