name string | code string | asm string | file string |
|---|---|---|---|
curlx_sltous | unsigned short curlx_sltous(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(slnum & (long) CURL_M... | movq %rdi, %rax
retq
| /xyzz[P]vita-curl/lib/warnless.c |
bsplib::Rdma::put(void const*, int, unsigned long, unsigned long, unsigned long) | void Rdma::put( const void * src,
int dst_pid, Memslot dst_slot, size_t dst_offset, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::PUT );
size_t t_a = m_second_exchange.send_size(dst_pid);
#endif
assert( ! (slot( m_pid, dst_slot ).status & Memblock::PUSHED) );
serial( m_second_exchange, dst_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movslq 0x2f4(%rdi), %rax
imulq %rcx, %rax
imulq $0x18, %rax, %rax
addq 0x338(%rdi), %rax
movslq 0x2f0(%rdi), %rcx
imulq $0x18, %rcx, %rcx
testb $0x1, 0x10(%rcx,%rax)
jne 0xd1d8
movq %r9, %rbx
movq %r8, %r15
movl %edx, %ebp
movq... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
bsplib::Rdma::ActionBuf::clear() | void clear()
{
m_dummy_bsmp = false;
m_actions.clear();
std::fill( m_counts.begin(), m_counts.end(), 0);
std::fill( m_get_buffer_offset.begin(), m_get_buffer_offset.end(), 0);
} | andl $0x0, 0x48(%rdi)
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0xe8d9
movq %rax, 0x8(%rdi)
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0xe8f0
andq $0x0, (%rax)
addq $0x8, %rax
jmp 0xe8e1
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
cmpq %rcx, %rax
je 0xe907
andq $0x0, (%rax)
addq $0x8, %rax
jmp 0xe8f... | /wijnand-suijlen[P]bsponmpi/src/rdma.h |
bsplib::UIntSerialize<unsigned int>::read(unsigned char const*, unsigned int&) | static int read( const unsigned char * cs, UInt & x ) {
x = 0;
int i = 0;
unsigned char m = (1 << (CHAR_BIT-1));
unsigned char c = 0;
UInt power = 1;
do {
c = cs[i++];
x += power * (c & (m-1));
power <<= (CHAR_BIT-1);
} while (c... | andl $0x0, (%rsi)
pushq $0x1
popq %rcx
xorl %eax, %eax
xorl %edx, %edx
movzbl (%rdi,%rax), %r8d
incq %rax
movl %r8d, %r9d
andl $0x7f, %r9d
imull %ecx, %r9d
addl %r9d, %edx
movl %edx, (%rsi)
shll $0x7, %ecx
testb %r8b, %r8b
js 0xf72a
retq
nop
| /wijnand-suijlen[P]bsponmpi/src/uintserialize.h |
uint32_log2 | int uint32_log2( uint32_t x )
{
int a0, a1, a2, a3, a4;
if (x == 0) return INT_MIN;
a4 = (x > 0xffff)?16:0;
x >>= a4;
a3 = (x > 0xff)?8:0;
x >>= a3;
a2 = (x > 0xf)?4:0;
x >>= a2;
a1 = (x > 0x3)?2:0;
x >>= a1;
a0 = (x > 0x1)?1:0;
return a0 + a1 + a2 + a3 + a4;
} | testl %edi, %edi
je 0x10d31
xorl %eax, %eax
cmpl $0x10000, %edi # imm = 0x10000
setae %al
shll $0x4, %eax
movl %eax, %ecx
shrl %cl, %edi
xorl %edx, %edx
cmpl $0x100, %edi # imm = 0x100
setae %dl
leal (,%rdx,8), %ecx
shrl %cl, %edi
xorl %esi, %esi
cmpl $0x10, %edi
setae %sil
leal (,%rsi,4), %ecx
shrl... | /wijnand-suijlen[P]bsponmpi/src/util.c |
rand_next_uint64 | double rand_next_uint64( uint64_t * next )
{
/* According to Wikipedia this comes from Knuth */
uint64_t a = 6364136223846793005;
uint64_t c = 1442695040888963407;
uint64_t x = (*next) * a + c;
*next = x;
return x / (1.0 + UINT64_MAX) ;
} | movabsq $0x5851f42d4c957f2d, %rax # imm = 0x5851F42D4C957F2D
imulq (%rdi), %rax
movabsq $0x14057b7ef767814f, %rcx # imm = 0x14057B7EF767814F
addq %rax, %rcx
movq %rcx, (%rdi)
movq %rcx, %xmm1
punpckldq 0x2eeb(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2ef3(%rip), %xmm1 # 0x13d80
movapd %xmm1, %xmm0... | /wijnand-suijlen[P]bsponmpi/src/util.c |
hash_table_create | void hash_table_create( hash_table_t * table, unsigned initial_size,
int (*is_equal)(const void * a, const void * b),
size_t (*hash)(const void * x) )
{
unsigned i;
if (initial_size < 2 ) initial_size = 2;
table->n_items = 0;
table->n_buckets = 1u << (int_log2( initial_size-1) + 1 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
cmpl $0x3, %esi
pushq $0x2
popq %rbp
cmovbl %ebp, %r12d
andl $0x0, (%rdi)
decl %r12d
movl %r12d, %edi
callq 0x10cd0
movl %eax, %ecx
shll %cl, %ebp
movl %ebp, 0x4(%rbx)
pushq $0x4
popq... | /wijnand-suijlen[P]bsponmpi/src/util.c |
hash_table_clear | void hash_table_clear( hash_table_t * table )
{
unsigned i;
/* return all blocks to the free list */
for ( i = 0; i < table->n_buckets; ++i ) {
hash_table_bucket_t *c, * b = table->buckets[i].next;
while (b) {
c = b->next;
b->next = table->free_buckets;
b->da... | movl 0x4(%rdi), %eax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cmpq %rax, %rcx
jae 0x1116f
movq 0x8(%rdi), %rdx
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x8(%rdx,%rsi), %r8
testq %r8, %r8
je 0x11166
movq 0x8(%r8), %r9
movq 0x10(%rdi), %r10
movq %r10, 0x8(%r8)
andq $0x0, (%r8)
movq %r8, 0x10(%rdi)
movq %r9, %r8
jmp 0x11148
incq %r... | /wijnand-suijlen[P]bsponmpi/src/util.c |
initial_state(MetaConfiguration&, std::basic_ifstream<char, std::char_traits<char>>&, int&) | callback_t initial_state(MetaConfiguration &conf, std::ifstream &f,
int &error) {
clear_empty(f);
char c = f.peek();
qCDebug(parser) << "Peeking" << c;
switch (c) {
case '#':
return state_include;
case '{':
return begin_class_state;
// case '[' : return begin_array_state;... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x7341
movq %r14, %rdi
callq 0x34e0
movl %eax, %ebp
callq 0x48dc
movb 0xe733(%rip), %al # 0x132e0
testb $0x1, %al
je 0x4c09
callq 0x48dc
movq 0xe71b(%rip), %rax # 0x132d8
leaq 0x10(%rsp), %rsi
movl $0x2, (... | /tcanabrava[P]configuration-parser/parser/statemachine.cpp |
create_transfer | static CURLcode create_transfer(struct GlobalConfig *global,
CURLSH *share,
bool *added)
{
CURLcode result = CURLE_OK;
*added = FALSE;
while(global->current) {
result = transfer_per_config(global, global->current, share, added);
if(!result &&... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x0, (%rdx)
movq 0x68(%rdi), %rbp
testq %rbp, %rbp
je 0x13ff4
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, (%r14)
movq 0x1d8(%rbp), %rax
testq %rax, %rax
je 0x13ff8
cmpq $0x0, 0x8(%rax)
je 0x13ff8
cmpq $0x0, 0x248(%rb... | /Rachelmorrell[P]curl/src/tool_operate.c |
pre_transfer | static CURLcode pre_transfer(struct GlobalConfig *global,
struct per_transfer *per)
{
curl_off_t uploadfilesize = -1;
struct_stat fileinfo;
CURLcode result = CURLE_OK;
if(per->separator_err)
fprintf(global->errors, "%s\n", per->separator_err);
if(per->separator)
printf("%... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2b0(%rsi), %rdx
testq %rdx, %rdx
je 0x1408f
movq 0x8(%r14), %rdi
leaq 0xae22(%rip), %rsi # 0x1eeaa
xorl %eax, %eax
callq 0xa4a0
movq 0x2b8(%rbx), %rsi
testq %rsi, %rsi
je 0x140a9
leaq 0xae08(%rip), %rdi ... | /Rachelmorrell[P]curl/src/tool_operate.c |
add_file_name_to_url | char *add_file_name_to_url(char *url, const char *filename)
{
/* If no file name part is given in the URL, we add this file name */
char *ptr = strstr(url, "://");
CURL *curl = curl_easy_init(); /* for url escaping */
if(!curl)
return NULL; /* error! */
if(ptr)
ptr += 3;
else
ptr = url;
ptr = ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb7bf(%rip), %rsi # 0x24045
callq 0xa0b0
movq %rax, %r12
callq 0xa0e0
testq %rax, %rax
je 0x1894e
movq %rax, %r14
leaq 0x3(%r12), %rdi
testq %r12, %r12
cmoveq %rbx, %rdi
movl $0x2f, %esi
callq 0xa440
movq %rax, %r12
testq ... | /Rachelmorrell[P]curl/src/tool_operhlp.c |
file2string | ParameterError file2string(char **bufp, FILE *file)
{
struct curlx_dynbuf dyn;
curlx_dyn_init(&dyn, MAX_FILE2STRING);
if(file) {
char buffer[256];
while(fgets(buffer, sizeof(buffer), file)) {
char *ptr = strchr(buffer, '\r');
if(ptr)
*ptr = '\0';
ptr = strchr(buffer, '\n');
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x10000000, %esi # imm = 0x10000000
callq 0x1c84c
testq %r14, %r14
je 0x18acf
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movl $0x100, %esi # imm = 0x10... | /Rachelmorrell[P]curl/src/tool_paramhlp.c |
getnum | static ParameterError getnum(long *val, const char *str, int base)
{
if(str) {
char *endptr = NULL;
long num;
errno = 0;
num = strtol(str, &endptr, base);
if(errno == ERANGE)
return PARAM_NUMBER_TOO_LARGE;
if((endptr != str) && (endptr == str + strlen(str))) {
*val = num;
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xa, %ebx
testq %rsi, %rsi
je 0x18c1a
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq $0x0, (%r12)
callq 0xa040
movq %rax, %r13
movl $0x0, (%rax)
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0xa5a0
movq %rax... | /Rachelmorrell[P]curl/src/tool_paramhlp.c |
str2unum | ParameterError str2unum(long *val, const char *str)
{
ParameterError result = getnum(val, str, 10);
if(result != PARAM_OK)
return result;
if(*val < 0)
return PARAM_NEGATIVE_NUMERIC;
return PARAM_OK;
} | pushq %rbx
movq %rdi, %rbx
movl $0xa, %edx
callq 0x18bab
testl %eax, %eax
jne 0x18c84
movq (%rbx), %rax
sarq $0x3f, %rax
andl $0xb, %eax
popq %rbx
retq
| /Rachelmorrell[P]curl/src/tool_paramhlp.c |
str2udouble | ParameterError str2udouble(double *valp, const char *str, long max)
{
double value;
ParameterError result = str2double(&value, str, max);
if(result != PARAM_OK)
return result;
if(value < 0)
return PARAM_NEGATIVE_NUMERIC;
*valp = value;
return PARAM_OK;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0xa, %ebx
testq %rsi, %rsi
je 0x18d50
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq 0xa040
movq %rax, %r13
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xa2c0
cmpl $0x22, (%r13)
je 0x18d4b
cvtsi2sd %r12, %xmm1
ucomisd ... | /Rachelmorrell[P]curl/src/tool_paramhlp.c |
delegation | long delegation(struct OperationConfig *config, const char *str)
{
if(curl_strequal("none", str))
return CURLGSSAPI_DELEGATION_NONE;
if(curl_strequal("policy", str))
return CURLGSSAPI_DELEGATION_POLICY_FLAG;
if(curl_strequal("always", str))
return CURLGSSAPI_DELEGATION_FLAG;
warnf(config->global, "... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb076(%rip), %rdi # 0x240fb
callq 0xa750
testl %eax, %eax
je 0x19093
xorl %r15d, %r15d
jmp 0x190e0
leaq 0xb066(%rip), %rdi # 0x24100
movq %rbx, %rsi
callq 0xa750
movl $0x1, %r15d
testl %eax, %eax
jne 0x190e0
leaq 0xb054(%rip), %rdi # ... | /Rachelmorrell[P]curl/src/tool_paramhlp.c |
checkpasswd | static CURLcode checkpasswd(const char *kind, /* for what purpose */
const size_t i, /* operation index */
const bool last, /* TRUE if last operation */
char **userpwd) /* pointer to allocated string */
{
char *psep;
char *osep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x938, %rsp # imm = 0x938
movq (%rcx), %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x192ec
movq %rcx, %rbx
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
movq %r14, %rdi
movl $0x3a, %esi
callq 0xa150
movq %rax, %r15
movq %r14, %rdi
m... | /Rachelmorrell[P]curl/src/tool_paramhlp.c |
parseconfig | int parseconfig(const char *filename, struct GlobalConfig *global)
{
FILE *file = NULL;
bool usedarg = FALSE;
int rc = 0;
struct OperationConfig *operation = global->last;
char *pathalloc = NULL;
if(!filename || !*filename) {
/* NULL or no file name attempts to load .curlrc from the homedir! */
ch... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1068, %rsp # imm = 0x1068
movq %rsi, %r14
movb $0x0, 0xb(%rsp)
movq 0x70(%rsi), %r15
testq %rdi, %rdi
je 0x1938f
movq %rdi, %r12
movb (%rdi), %al
testb %al, %al
je 0x193ad
xorl %ebx, %ebx
jmp 0x193fd
leaq 0x6244(%rip), %rdi # 0x1f5... | /Rachelmorrell[P]curl/src/tool_parsecfg.c |
progress_meter | bool progress_meter(struct GlobalConfig *global,
struct timeval *start,
bool final)
{
static struct timeval stamp;
static bool header = FALSE;
struct timeval now;
long diff;
if(global->noprogress)
return FALSE;
now = tvnow();
diff = tvdiff(now, stamp);
if(!... | cmpb $0x0, 0x5(%rdi)
je 0x198f8
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rsi, %rbp
movq %rdi, %r14
callq 0x1bd08
movq %rax, %r13
movq %rdx, %r12
movq 0x13bc5(%rip), %rdx # 0x2d4e8
movq 0x13bc6(%rip), %rcx # 0x2d4f0
movq %rax, %... | /Rachelmorrell[P]curl/src/tool_progress.c |
tool_setopt_enum | CURLcode tool_setopt_enum(CURL *curl, struct GlobalConfig *config,
const char *name, CURLoption tag,
const struct NameValue *nvlist, long lval)
{
CURLcode ret = CURLE_OK;
bool skip = FALSE;
ret = curl_easy_setopt(curl, tag, lval);
if(!lval)
skip = TRUE;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rdx, %rbx
movq %rsi, %r12
movl %ecx, %esi
movq %r9, %rdx
xorl %eax, %eax
callq 0xa5d0
testq %r14, %r14
sete %cl
cmpq $0x0, 0x38(%r12)
sete %dl
testl %eax, %eax
setne %sil
orb %cl, %sil
orb %dl, %sil
jne 0x1a004
movq (%r15), %rcx
... | /Rachelmorrell[P]curl/src/tool_setopt.c |
tool_setopt_bitmask | CURLcode tool_setopt_bitmask(CURL *curl, struct GlobalConfig *config,
const char *name, CURLoption tag,
const struct NameValueUnsigned *nvlist,
long lval)
{
CURLcode ret = CURLE_OK;
bool skip = FALSE;
ret = curl_easy_setopt(cu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %ecx, %esi
movq %r9, %rdx
xorl %eax, %eax
callq 0xa5d0
testq %rbx, %rbx
sete %cl
cmpq $0x0, 0x38(%r12)
sete %dl
testl %eax, %eax
setne %sil
orb %cl, %sil
orb %dl, %sil
jn... | /Rachelmorrell[P]curl/src/tool_setopt.c |
libcurl_generate_slist | static CURLcode libcurl_generate_slist(struct curl_slist *slist, int *slistno)
{
CURLcode ret = CURLE_OK;
char *escaped = NULL;
/* May need several slist variables, so invent name */
*slistno = ++easysrc_slist_count;
DECL1("struct curl_slist *slist%d;", *slistno);
DATA1("slist%d = NULL;", *slistno);
CLE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12ff2(%rip), %rax # 0x2d434
movl (%rax), %edx
incl %edx
movl %edx, (%rax)
movl %edx, (%rsi)
leaq 0x12fb7(%rip), %rdi # 0x2d408
leaq 0xa81f(%rip), %rsi # 0x24c77
xorl %r15d, %r15d
xorl %eax, %... | /Rachelmorrell[P]curl/src/tool_setopt.c |
glob_url | CURLcode glob_url(struct URLGlob **glob, char *url, unsigned long *urlnum,
FILE *error)
{
/*
* We can deal with any-size, just make a buffer with the same length
* as the specified URL!
*/
struct URLGlob *glob_expand;
unsigned long amount = 0;
char *glob_buffer;
CURLcode res;
*gl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
movq %rcx, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, %r15
movq $0x0, (%rdi)
movq %rsi, 0x60(%rsp)
movq %rsi, %rdi
callq 0xa180
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0xa550
movl $0x1b, %ebx
testq %rax, %ra... | /Rachelmorrell[P]curl/src/tool_urlglob.c |
tvnow | struct timeval tvnow(void)
{
/*
** clock_gettime() is granted to be increased monotonically when the
** monotonic clock is queried. Time starting point is unspecified, it
** could be the system start-up time, the Epoch, or something else,
** in any case the time starting point does not change once that the
... | pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0xa320
testl %eax, %eax
je 0x1bd36
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa670
movq 0x8(%rbx), %rdx
jmp 0x1bd55
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%rsp)
movq %rdx, %rax
shrq $0x3f... | /Rachelmorrell[P]curl/src/tool_util.c |
ourWriteOut | void ourWriteOut(const char *writeinfo, struct per_transfer *per,
CURLcode per_result)
{
FILE *stream = stdout;
const char *ptr = writeinfo;
bool done = FALSE;
while(ptr && *ptr && !done) {
if('%' == *ptr && ptr[1]) {
if('%' == ptr[1]) {
/* an escaped %-letter */
fput... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
testl %edx, %edx
sete 0xb(%rsp)
testq %rdi, %rdi
je 0x1bfda
movl %edx, %ebp
movq %rdi, %r13
movq 0x11201(%rip), %rax # 0x2cfc0
movq (%rax), %r12
leaq 0x9032(%rip), %r15 # 0x24dfb
movb (%r13), %al
testb %al,... | /Rachelmorrell[P]curl/src/tool_writeout.c |
ourWriteOutJSON | void ourWriteOutJSON(FILE *stream, const struct writeoutvar mappings[],
struct per_transfer *per, CURLcode per_result)
{
int i;
fputs("{", stream);
for(i = 0; mappings[i].name != NULL; i++) {
if(mappings[i].writefunc &&
mappings[i].writefunc(stream, &mappings[i], per, per_result,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x89b1(%rip), %rdi # 0x24dfc
movq %rbx, %rsi
callq 0xa490
cmpq $0x0, (%r15)
je 0x1c496
leaq 0x7bf2(%rip), %r12 # 0x24052
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x1c48b
movq %rbx, %rdi... | /Rachelmorrell[P]curl/src/tool_writeout_json.c |
fwrite_xattr | int fwrite_xattr(CURL *curl, int fd)
{
int i = 0;
int err = 0;
/* loop through all xattr-curlinfo pairs and abort on a set error */
while(err == 0 && mappings[i].attr != NULL) {
char *value = NULL;
CURLcode result = curl_easy_getinfo(curl, mappings[i].info, &value);
if(!result && value) {
boo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %r15
cmpq $0x40, %r15
je 0x1c607
leaq 0x10850(%rip), %rcx # 0x2cd50
movq (%rax,%rcx), %r13
movq $0x0, (%rsp)
movl 0x8(%rax,%rcx), %ebx
xorl %ebp, %ebp... | /Rachelmorrell[P]curl/src/tool_xattr.c |
curlx_uztosi | int curlx_uztosi(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SINT);
return (int)(uznum & (size_t) CURL_MASK_SINT);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /Rachelmorrell[P]curl/lib/warnless.c |
curlx_sltoui | unsigned int curlx_sltoui(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if UINT_MAX < LONG_MAX
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_UINT);
#endif
return (unsigned i... | movq %rdi, %rax
retq
| /Rachelmorrell[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /Rachelmorrell[P]curl/lib/warnless.c |
curlx_dyn_reset | void Curl_dyn_reset(struct dynbuf *s)
{
DEBUGASSERT(s);
DEBUGASSERT(s->init == DYNINIT);
DEBUGASSERT(!s->leng || s->bufr);
if(s->leng)
s->bufr[0] = 0;
s->leng = 0;
} | cmpq $0x0, 0x8(%rdi)
je 0x1c888
movq (%rdi), %rax
movb $0x0, (%rax)
movq $0x0, 0x8(%rdi)
retq
| /Rachelmorrell[P]curl/lib/dynbuf.c |
main | int main(int argc, char **argv)
{
int s; /* can raw socket */
int required_mtu;
int mtu;
int enable_canfx = 1;
struct sockaddr_can addr;
struct can_raw_vcid_options vcid_opts = {
.flags = CAN_RAW_XL_VCID_TX_PASS,
};
static cu_t cu;
struct ifreq ifr;
/* check command line options */
if (argc != 3) {
prin... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movl $0x1, 0x8(%rsp)
movl $0x2, 0xc(%rsp)
cmpl $0x3, %edi
jne 0x13c9
movq 0x10(%r15), %rdi
leaq 0x4e7b(%rip), %rsi # 0x6138
callq 0x163d
testl %eax, %eax
je 0x13d6
movl %eax, %ebp
movl $0x1, %r14d
movl $0x1d, %edi
movl $0x3, %esi
movl $0x... | /hartkopp[P]can-utils/cansend.c |
asc2nibble | unsigned char asc2nibble(char c)
{
if ((c >= '0') && (c <= '9'))
return c - '0';
if ((c >= 'A') && (c <= 'F'))
return c - 'A' + 10;
if ((c >= 'a') && (c <= 'f'))
return c - 'a' + 10;
return 16; /* error */
} | leal -0x30(%rdi), %eax
cmpb $0xa, %al
jb 0x1525
leal -0x41(%rdi), %eax
cmpb $0x5, %al
ja 0x1526
addb $-0x37, %dil
movl %edi, %eax
retq
leal -0x61(%rdi), %eax
addb $-0x57, %dil
cmpb $0x6, %al
movzbl %dil, %ecx
movl $0x10, %eax
cmovbl %ecx, %eax
retq
| /hartkopp[P]can-utils/lib.c |
hexstring2data | int hexstring2data(char *arg, unsigned char *data, int maxdlen)
{
int len = strlen(arg);
int i;
unsigned char tmp;
if (!len || len % 2 || len > maxdlen * 2)
return 1;
memset(data, 0, maxdlen);
for (i = 0; i < len / 2; i++) {
tmp = asc2nibble(*(arg + (2 * i)));
if (tmp > 0x0F)
return 1;
data[i] = (t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1070
movq %rax, %r15
testl %r15d, %r15d
sete %al
movl %r15d, %ecx
orb %al, %cl
leal (%r12,%r12), %eax
cmpl %r15d, %eax
setl %al
orb %cl, %al
testb $0x1, %al
je 0x157a
movl $0x1, %ebp
jmp 0x1632
movslq %r12d, ... | /hartkopp[P]can-utils/lib.c |
snprintf_long_canframe | int snprintf_long_canframe(char *buf, size_t size, cu_t *cu, int view)
{
/* documentation see lib.h */
unsigned char is_canfd = cu->fd.flags;
int i, j, dlen, offset;
size_t maxsize;
int len;
/* ensure space for string termination */
if (size < 1)
return size;
/* handle CAN XL frames */
if (cu->xl.flags & ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x2086
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0x4(%rdx), %bpl
testb %bpl, %bpl
js 0x208e
movb 0x5(%r14), %dil
testb %dil, %dil
movl $0x8, %eax
movl $0x40, %r13d
cmovel %eax, %r13d
movzbl %bpl, %r10d
cmpb... | /hartkopp[P]can-utils/lib.c |
snprintf_can_error_frame | int snprintf_can_error_frame(char *buf, size_t len, const struct canfd_frame *cf,
const char* sep)
{
canid_t class, mask;
int i, n = 0, classes = 0;
char *defsep = ",";
if (!(cf->can_id & CAN_ERR_FLAG))
return 0;
class = cf->can_id & CAN_EFF_MASK;
if (class > (1 << ARRAY_SIZE(error_classes))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rax
movl (%rdx), %edx
btl $0x1d, %edx
jb 0x266d
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edx, 0x10(%rsp)
andl $0x1fffffff, %edx # imm = 0... | /hartkopp[P]can-utils/lib.c |
LD_AwareHash_debug | uint64_t LD_AwareHash_debug(unsigned char* data, uint64_t n,
uint64_t hash, uint64_t scale, uint64_t hardener) {
while (n) {
fprintf(stderr, " %lu %lu %lu %u\n", n, hash, scale, *data);
hash *= scale;
hash += *data++;
n--;
fprintf(stderr, " internal %lu\n", hash);
}
return hash ^ hardener;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
testq %rsi, %rsi
je 0x387d
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x1079c(%rip), %rbp # 0x13fd0
movq (%rbp), %rdi
movzbl (%r13), %r9d
leaq 0x9930(%rip), %rsi # 0xd174
movq %r12, %rdx
movq %... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/hash.c |
LD_mangle | void LD_mangle(const unsigned char* key, unsigned char* ret_key,
int nbytes) {
unsigned long long new_key = 0;
int i;
for (i = 0; i < nbytes; ++i) {
new_key |= key[nbytes - i - 1] << (i * 8);
}
new_key = (new_key * 2083697005) & (0xffffffff);
for (i = 0; i < nbytes; ++i) {
ret_key[i] = (new_key >> (i * 8)) &... | movl %edx, %eax
testl %edx, %edx
jle 0x3962
leal 0x3(%rdx), %ecx
leaq -0x1(%rax), %r8
vpbroadcastq %r8, %ymm0
addq %rax, %rdi
addq $-0x4, %rdi
andl $-0x4, %ecx
vpmovsxbd 0x9898(%rip), %xmm1 # 0xd154
negq %rcx
vpxor %xmm7, %xmm7, %xmm7
vpmovsxbq 0x9888(%rip), %ymm8 # 0xd154
xorl %r8d, %r8d
vpermq $0x1b, %ymm0, %ymm2 ... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/hash.c |
LD_GenHashSeed | uint64_t LD_GenHashSeed(int index) {
/*
if (index == 0) {
srand(0);
}
*/
if (LD_seed == 0) {
LD_seed = rand();
}
uint64_t x, y = LD_seed + index;
LD_mangle((const unsigned char*)&y, (unsigned char*)&x, 8);
return LD_AwareHash((uint8_t*)&y, 8, 388650253, 388650319, 1176845762);
} | pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
cmpq $0x0, 0x1073f(%rip) # 0x14278
jne 0x3b49
callq 0x3090
cltq
movq %rax, 0x1072f(%rip) # 0x14278
movslq %ebx, %rax
addq 0x10725(%rip), %rax # 0x14278
movq %rax, 0x8(%rsp)
movl $0x172a550d, %eax # imm = 0x172A550D
xorl %ecx, %ecx
imulq $0x172a554f, %rax, %r... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/hash.c |
is_prime | int is_prime(int num) {
int i;
for (i = 2; i < num; i++) {
if ((num % i) == 0) {
break;
}
}
if (i == num) {
return 1;
}
return 0;
} | movl $0x2, %ecx
cmpl $0x3, %edi
jl 0x3b9f
movl %edi, %eax
xorl %edx, %edx
divl %ecx
testl %edx, %edx
je 0x3b9f
incl %ecx
cmpl %ecx, %edi
jne 0x3b8d
movl %edi, %ecx
xorl %eax, %eax
cmpl %edi, %ecx
sete %al
retq
nop
| /WavingSketch[P]Waving-Sketch/include/LD-Sketch/hash.c |
dyn_tbl_get_heavy_key(dyn_tbl_s*, long long, unsigned char*, int*) | void dyn_tbl_get_heavy_key(dyn_tbl_t* dyn_tbl, long long thresh, unsigned char* keys, int* num_key) {
long long bias = dyn_tbl->decrement;
thresh = thresh - bias;
//for(std::unordered_map<dyn_tbl_key_t, long long>::iterator it = dyn_tbl->array.begin(); it != dyn_tbl->array.end(); ++it) {
int n = 0;
for (auto it = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x10(%rdi), %r13
testq %r13, %r13
je 0x3c0c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x44(%rdi), %eax
subq %rax, %r15
xorl %ebp, %ebp
movq 0x18(%r13), %rax
movq %rax, %rcx
negq %rcx
cmovsq %rax, %rcx
cmpq %r15,... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
dyn_tbl_low_estimate(dyn_tbl_s*, unsigned char*) | long long dyn_tbl_low_estimate(dyn_tbl_t* dyn_tbl, unsigned char* key_str) {
dyn_tbl_key_t key;
memset(key.key, 0, sizeof(key.key));
memcpy(key.key, key_str, dyn_tbl->lgn / 8);
if (dyn_tbl->array.find(key) != dyn_tbl->array.end()) {
return dyn_tbl->array[key];
}
else {
return 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rsp, %r15
movq %r14, 0x5(%r15)
movq %r14, (%r15)
movl 0x58(%rdi), %edx
shrl $0x3, %edx
movq %r15, %rdi
callq 0x31f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4424
testq %rax, %rax
je 0x3c64
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x44... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
dyn_tbl_up_estimate(dyn_tbl_s*, unsigned char*) | long long dyn_tbl_up_estimate(dyn_tbl_t* dyn_tbl, unsigned char* key_str) {
long long ret = 0;
dyn_tbl_key_t key;
memset(key.key, 0, sizeof(key.key));
memcpy(key.key, key_str, dyn_tbl->lgn / 8);
if (dyn_tbl->array.find(key) != dyn_tbl->array.end()) {
ret = dyn_tbl->array[key];
}
double bias = dyn_tbl->decreme... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, 0x5(%r14)
movq %rax, (%r14)
movl 0x58(%rdi), %edx
shrl $0x3, %edx
movq %r14, %rdi
callq 0x31f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4424
testq %rax, %rax
je 0x3cbb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x44cc
... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
dyn_tbl_print(dyn_tbl_s*, char const*) | void dyn_tbl_print(dyn_tbl_t* dyn_tbl, const char* output) {
FILE* fp;
// open a file
if ((fp = fopen(output, "w")) == NULL) {
fprintf(stderr, "ERR: cannot open %s\n", output);
exit(-1);
}
unsigned int len = dyn_tbl->array.size();
fprintf(fp, "length: %u\n", len);
// for(std::unordered_map<dyn_tbl_key_t, l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x9c76(%rip), %rsi # 0xd968
movq %r15, %rdi
callq 0x32a0
testq %rax, %rax
je 0x3e3d
movq %rax, %r14
movl 0x18(%rbx), %edx
leaq 0x94a3(%rip), %rsi # 0xd1b3
movq %rax, %rdi
xorl %eax, %eax
cal... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
dyn_tbl_copy(dyn_tbl_s*, dyn_tbl_s*) | void dyn_tbl_copy(dyn_tbl_t* dyn_tbl_from, dyn_tbl_t* dyn_tbl_to) {
dyn_tbl_to->array = dyn_tbl_from->array;
dyn_tbl_to->decrement = dyn_tbl_from->decrement;
dyn_tbl_to->total = dyn_tbl_from->total;
dyn_tbl_to->max_len = dyn_tbl_from->max_len;
dyn_tbl_to->max_value = dyn_tbl_from->max_value;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x3e63
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4058
movl 0x44(%r14), %eax
movl %eax, 0x44(%rbx)
movq 0x38(%r14), %rax
movq %rax, 0x38(%rbx)
movl 0x40(%r14), %eax
movl %eax, 0x40(%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x50(%rbx)
addq $0x... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
dyn_tbl_update(dyn_tbl_s*, unsigned char*, int) | void dyn_tbl_update(dyn_tbl_t* dyn_tbl, unsigned char* key_str, int val) {
dyn_tbl_key_t key;
memset(key.key, 0, sizeof(key.key));
memcpy(key.key, key_str, dyn_tbl->lgn / 8);
dyn_tbl->total += val;
if (dyn_tbl->array.find(key) != dyn_tbl->array.end()) {
dyn_tbl->array[key] += val;
}
else {
unsigned int frac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rsp, %r14
movq %rax, 0x5(%r14)
movq %rax, (%r14)
movl 0x58(%rdi), %edx
shrl $0x3, %edx
movq %r14, %rdi
callq 0x31f0
movslq %ebp, %r15
addq %r15, 0x38(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq ... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/dyn_tbl.cpp |
LDSketch_init(int, int, int, int, long long, unsigned int) | LDSketch_t* LDSketch_init(int w, int h, int l, int lgn, long long thresh_abs,
unsigned int tbl_id) {
LDSketch_t* LDSketch;
// error checking
if (lgn / 8 > 13 || lgn % 8 != 0) { // maximum # of bits of a key = 104
fprintf(stderr, "ERR: n too large or n not multiple of 8\n");
exit(-1);
}
// safe calloc
LDSk... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, 0xc(%rsp)
movl %edi, 0x4(%rsp)
cmpl $0x6f, %ecx
jg 0x498f
movl %ecx, %r14d
movl %ecx, %eax
andl $0x7, %eax
jne 0x498f
movq %r8, %rbx
movl %edx, %r15d
movl %esi, %r13d
leaq 0x28(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x8998(%r... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
safe_calloc(unsigned long, unsigned long, char const*) | static void* safe_calloc(size_t nmemb, size_t size, const char* name) {
void* ret;
ret = calloc(nmemb, size);
if (ret == NULL) {
fprintf(stderr, "ERR: cannot alloc %s\n", name);
exit(-1);
}
return ret;
} | pushq %rbx
movq %rdx, %rbx
callq 0x3170
testq %rax, %rax
je 0x49a4
popq %rbx
retq
movq %rbx, %rdi
callq 0x355e
| /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_find(LDSketch_s*, unsigned char const*, int, int, int) | unsigned int LDSketch_find(LDSketch_t* tbl, const unsigned char* key,
int start_bit, int end_bit, int row_no) {
unsigned char key_str[50]; // assume n/8 + 4 <= 50
unsigned int oper;
char bit;
unsigned int ret_bucket;
int i;
// set the key string
memset(key_str, 0, sizeof(key_str));
i = start_bit; // start_... | vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, -0x26(%rsp)
vmovups %ymm0, -0x38(%rsp)
cmpl %ecx, %edx
jg 0x4a1e
movl %ecx, %r11d
subl %edx, %r11d
leal 0x7(%rdx), %r9d
testl %edx, %edx
cmovnsl %edx, %r9d
movl %r9d, %eax
sarl $0x3, %eax
cltq
movb (%rsi,%rax), %r10b
cmpl $0x7, %r11d
jl 0x49ee
movb %r10b, -0x38(%rsp,%rax)
movl ... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_update(LDSketch_s*, unsigned char*, long long) | void LDSketch_update(LDSketch_t* sk, unsigned char* key, long long val) {
int j, k;
// mangle
// mangle(key, key_to_add, tbl->n/8);
// add key/val to table
for (j = 0; j < sk->h; ++j) {
k = LDSketch_find(sk, key, 0, sk->lgn - 1, j);
// tbl->T[j*tbl->w+k] += val;
dyn_tbl_update(sk->tbl[j * sk->w + k], key, ... | cmpl $0x0, 0x8(%rdi)
jle 0x4ad5
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movl 0x14(%r15), %ecx
decl %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebp, %r8d
callq 0x49ac
movq (%r15), %rcx
movl 0xc(%r15), %edx
imull %ebp, %edx
addl... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_copy(LDSketch_s*, LDSketch_s*) | void LDSketch_copy(LDSketch_t* tbl, LDSketch_t* ret_tbl) {
if (ret_tbl == NULL) {
fprintf(stderr, "ERR: ret_tbl in LDSketch_copy() is NULL\n");
return;
}
// memcpy(ret_tbl->T, tbl->T, tbl->size * sizeof(long long));
for (int i = 0; i < tbl->h * tbl->w; ++i) {
dyn_tbl_copy(tbl->tbl[i], ret_tbl->tbl[i]);
}
/... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x4b21
movq %rdi, %r14
movl 0xc(%rdi), %eax
imull 0x8(%rdi), %eax
testl %eax, %eax
jle 0x4b1b
movq %rsi, %rbx
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
callq 0x3e49
incq %r15
movslq 0x8(%r14), %rax
movslq ... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_write_plaintext(LDSketch_s*, char const*) | void LDSketch_write_plaintext(LDSketch_t* sk, const char* outfile) {
FILE* fp;
int i, j;
// open a file
if ((fp = fopen(outfile, "w")) == NULL) {
fprintf(stderr, "ERR: cannot open %s\n", outfile);
exit(-1);
}
// write to a file (including n and bd???)
fprintf(fp, "Worker: %u, length of key: %d\n", sk->tbl_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8d9f(%rip), %rsi # 0xd968
movq %r15, %rdi
callq 0x32a0
testq %rax, %rax
je 0x4cea
movq %rax, %r14
movl 0x14(%rbx), %ecx
movl 0x20(%rbx), %edx
leaq 0x8670(%rip), %rsi # 0xd25a
movq %rax, %rdi
xor... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_get_heavy_keys(LDSketch_s*, long long, unsigned char*, long long*, int*) | void LDSketch_get_heavy_keys(LDSketch_t* sk, long long thresh,
unsigned char* keys, long long* vals,
int* num_key) {
int max_array_len = 0;
for (int i = 0; i < sk->w * sk->h; ++i) {
if (sk->tbl[i]->max_value >= thresh) {
int len = dyn_tbl_length(sk->tbl[i]);
if (len > max_array_len) {
max_array_len = le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, 0x40(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movl 0x8(%rdi), %eax
imull 0xc(%rdi), %eax
xorl %ebx, %ebx
testl %eax, %eax
jle 0x4d52
xorl %r14d, %r14d
movq (%r15), %rax
movq (%rax,%r14,8... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_up_estimate(LDSketch_s*, unsigned char*) | long long LDSketch_up_estimate(LDSketch_t* sk, unsigned char* key) {
int k = LDSketch_find(sk, key, 0, sk->lgn - 1, 0);
long long ret = dyn_tbl_up_estimate(sk->tbl[k], key);
for (int i = 1; i < sk->h; ++i) {
k = LDSketch_find(sk, key, 0, sk->lgn - 1, i);
int index = i * sk->w + k;
ret = MIN(ret, dyn_tbl_up_est... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x14(%rdi), %ecx
decl %ecx
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x49ac
movq (%r14), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x3c71
movq %rax, %r15
cmpl $0x2, 0x8(%r14)
jl 0x5053
movl $0x1, %ebp
movl 0x14(%r14),... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
LDSketch_low_estimate(LDSketch_s*, unsigned char*) | long long LDSketch_low_estimate(LDSketch_t* sk, unsigned char* key) {
long long ret = 0;
for (int i = 0; i < sk->h; ++i) {
int k = LDSketch_find(sk, key, 0, sk->lgn - 1, i);
int index = i * sk->w + k;
ret = MAX(ret, dyn_tbl_low_estimate(sk->tbl[index], key));
}
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r15d, %r15d
cmpl $0x0, 0x8(%rdi)
jle 0x50ce
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl 0x14(%r14), %ecx
decl %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl %r15d, %r8d
callq 0x49ac
movl 0xc(%r14), %ecx
imull %r15d, %ecx
addl %eax, %ecx
... | /WavingSketch[P]Waving-Sketch/include/LD-Sketch/LDSketch.cpp |
SS_AwareHash_debug | uint64_t SS_AwareHash_debug(unsigned char* data, uint64_t n,
uint64_t hash, uint64_t scale, uint64_t hardener) {
while (n) {
fprintf(stderr, " %lu %lu %lu %u\n", n, hash, scale, *data);
hash *= scale;
hash += *data++;
n--;
fprintf(stderr, " internal %lu\n", hash);
}
return hash ^ hardener;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
testq %rsi, %rsi
je 0x522d
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0xedec(%rip), %rbp # 0x13fd0
movq (%rbp), %rdi
movzbl (%r13), %r9d
leaq 0x7f80(%rip), %rsi # 0xd174
movq %r12, %rdx
movq %... | /WavingSketch[P]Waving-Sketch/include/SpreadSketch/spreadhash.cpp |
DetectorSS::Estimate(int, unsigned char*) | int DetectorSS::Estimate(int bucket, unsigned char* bmp) {
int offs = bucket * ss_.offsets[ss_.c];
int z, tmpoff = 0, base;
double m;
int factor = 1;
for (base = 0; base < ss_.c - 1; base++) {
tmpoff = offs + ss_.offsets[base];
z = countzerobits(bmp, tmpoff, tmpoff + ss_.b);
//TL: if the bitmap is not full
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movslq 0x4(%rdi), %rcx
imull (%rax,%rcx,4), %ebp
cmpq $0x2, %rcx
jl 0x6480
movl $0x1, %r12d
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
movl (%rax,%r13,4), %esi
addl %eb... | /WavingSketch[P]Waving-Sketch/include/SpreadSketch/spreadsketch.cpp |
main | int main(int argc, char *argv[]) {
int result = 0;
int fails = 0;
// Bitdiffs are cases where the expected result and actual result only differ
// by +/- the least significant bit. They are tracked separately from larger
// failures since a bitdiff is most likely the result of a rounding error, and
// spli... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %ebp, %ebp
movl %ebp, 0x10(%rsp)
movl %ebp, 0xc(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movl %ebp, 0x8(%rsp)
movl $0x0, %eax
movl $0x0, %ecx
movl $0x0, %edx
movl $0x0, %r14d
movl $0x0, %r12d
movl $0x0, %r13d
movl $0x0, %eb... | /src/__support/str_to_float_comparison_test.cpp |
argh::parser::is_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | inline bool parser::is_option(std::string const &arg) const {
assert(0 != arg.size());
if (is_number(arg))
return false;
return '-' == arg[0];
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
cmpq $0x0, 0x8(%rsi)
je 0x579f
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x3590
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3210
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movb 0x30(%rsp,%r... | /fzyukio[P]cspade-full/argh.h |
Exttpose::sort_get_l2(int&, std::basic_fstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, bool) | void Exttpose::sort_get_l2(int &l2cnt, fstream &file, ofstream &ofd, vector<unsigned char> &cntary, bool use_seq) {
//write 2-itemsets counts to file
int i, j, k;
int fcnt;
int lit;
int itbuf[3];
int *sortary;
unsigned long filesize = file_size(file);
if (filesize > 0) {
sorta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, 0x40(%rsp)
movq %rdi, %r12
movq %rdx, %rdi
callq 0xaa93
movq %rax, %r13
testq %rax, %rax
je 0x63f6
movq %r14, %rdi
movq %r13, %rsi
callq 0xaae6
movq %rax, %rbp
movq (%r... | /fzyukio[P]cspade-full/exttpose.cc |
Exttpose::process_cust(int, std::basic_fstream<char, std::char_traits<char>>&, std::basic_fstream<char, std::char_traits<char>>&) | void Exttpose::process_cust(int fcnt, fstream &seqfd, fstream &isetfd) {
int j, k;
int ii1, ii2, lit;
for (k = 0; k < fcnt; k++) {
for (j = k; j < fcnt; j++) {
if (args.use_seq && extary[fidx[j]].size() > 0) {
lit = extary[fidx[j]].size() - 1;
if (extary[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
testl %esi, %esi
jle 0x6851
movq %rdi, %r15
addq $0x10, 0x10(%rsp)
leaq 0x5f18(%rip), %rax # 0xc530
movslq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x10, 0x18(%rsp)
movl %esi, %r13d
xorl %e... | /fzyukio[P]cspade-full/exttpose.cc |
Exttpose::Exttpose(Env&, ExttposeArgument&) | Exttpose::Exttpose(Env &env_, ExttposeArgument &args_) : env(env_), args(args_) {
dcb.init(args.input);
itcnt.resize(args.DBASE_MAXITEM);
ocnt.resize(args.DBASE_MAXITEM, -1);
itlen.resize(args.DBASE_MAXITEM);
freqidx.resize(args.DBASE_MAXITEM);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %rbp
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %r14
addq $0x40, %rdi
leaq 0x48(%rbp), %rax
movq %rax, (%rsp)
leaq 0x60(%rbp), %r15
leaq 0x78(%rbp), %r12
leaq 0x90(%rbp), %r13
movl $0x110, %edx ... | /fzyukio[P]cspade-full/exttpose.cc |
exttposeWrapper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Env>&) | result_t exttposeWrapper(const string &s, shared_ptr<Env>& envptr) {
args_t args_ = parse(s);
ExttposeArgument args;
args.parse_args(args_.argc, args_.argv);
if (envptr == nullptr) {
Env env;
return exttposeFunc(env, args);
}
else {
return exttposeFunc(*envptr, args);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x740, %rsp # imm = 0x740
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9ea4
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%... | /fzyukio[P]cspade-full/exttpose.cc |
TransArray::add(int, int, int, int, int) | void add(int fd, int item, int use_seq, int pos, int custid = -1) {
if (use_seq) {
if (theSize + 2 > totSize) {
flushbuf(fd, use_seq, pos);
}
theArray[theSize++] = custid;
} else {
if (theSize + 1 > totSize) {
flushbuf(fd, u... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl 0x20(%rdi), %eax
movslq %eax, %rdx
movq 0x28(%rdi), %rdi
testl %ecx, %ecx
je 0x8bd1
movl %r9d, %ebp
addq $0x2, %rdx
cmpq %rdx, %rdi
jge 0x8bc0
movq %r14, %rdi
movl %ecx, %edx
movl %r8d, %ecx
callq 0x8bfc
movl 0x20(%r14), %eax
leal 0x1(%rax), %ecx
mov... | /fzyukio[P]cspade-full/TransArray.h |
TransArray::flushbuf(int, int, int) | void flushbuf(int fd, int use_seq, int pos = 0) {
lseek(fd, offset[pos] * sizeof(int), SEEK_SET);
int wblk = theSize;
if (wblk > 0) {
auto res = write(fd, (char *) theArray.data(), wblk * sizeof(int));
if (res < wblk * sizeof(int)) {
throw runtime_error("E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %ecx, %r15
movq 0x30(%rdi), %rax
movq (%rax,%r15,8), %rsi
shlq $0x2, %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x3630
movslq 0x20(%rbx), %r12
testq %r12, %r12
jle 0x8c4c
movq (%rbx), %rsi
leaq (,%r12,4), %r14
movl %ebp, %edi
... | /fzyukio[P]cspade-full/TransArray.h |
string2chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | char *string2chars(const string &str) {
int len = str.length();
auto *chars = new char[len + 1];
for (int i = 0; i < str.length(); i++) {
chars[i] = str[i];
}
chars[len] = 0;
return chars;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq %rbx, %r12
shlq $0x20, %r12
movabsq $0x100000000, %rax # imm = 0x100000000
addq %r12, %rax
sarq $0x20, %rax
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r15
testq %rbx, %rbx
je 0x9dbd
movq (%r14), %rsi
... | /fzyukio[P]cspade-full/argv_parser.cc |
ensure_one_newline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string ensure_one_newline(const string &s) {
string str(s);
str.erase(std::remove(str.begin(), str.end(), '\n'), str.end());
return str + "\n";
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5c8a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
leaq 0x7(%rsp), %rdx
m... | /fzyukio[P]cspade-full/argv_parser.cc |
parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | args_t parse(const string &s) {
list<string> argv;
ostringstream token;
bool in_token;
bool in_container;
bool escaped;
char container_start;
char c;
int len;
int i;
string str = ensure_one_newline(s);
container_start = 0;
in_token = false;
in_container = false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x80(%rsp), %rdi
callq 0x3430
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0x9dd5
movq 0x68(... | /fzyukio[P]cspade-full/argv_parser.cc |
args_t::args_t(std::__cxx11::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>) | args_t(std::list<string> args) {
argc = static_cast<int>(args.size());
argv = new char *[argc];
std::list<string>::const_iterator iterator;
int idx = 0;
for (iterator = args.begin(); iterator != args.end(); ++iterator) {
argv[idx] = string2chars((*iterator));
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movl %eax, (%rdi)
shlq $0x20, %rax
movq %rax, %rcx
sarq $0x1d, %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
movq (%rbx), %r15
cmpq %rbx, %r15
je 0xa48c
xorl %r12d, ... | /fzyukio[P]cspade-full/argv_parser.h |
DbaseCtrlBlk::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void DbaseCtrlBlk::init(const string &infilename, int buf_sz) {
fd = open(infilename.c_str(), O_RDONLY | O_BINARY);
if (fd < 0) {
throw runtime_error("ERROR: InvalidFile -- Dbase_Ctrl_Blk()");
}
buf_size = buf_sz;
buf = new int[buf_sz];
cur_buf_pos = 0;
cur_blk_size = 0;
readall... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movq (%rsi), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3270
movl %eax, (%rbx)
testl %eax, %eax
js 0xa6a2
movl %eax, %ebp
movl %r14d, 0x4(%rbx)
movl %r14d, %eax
shlq $0x2, %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %r... | /fzyukio[P]cspade-full/calcdb.cc |
DbaseCtrlBlk::get_next_trans_ext() | void DbaseCtrlBlk::get_next_trans_ext() {
// Need to get more items from file
auto res = cur_blk_size - cur_buf_pos;
if (res > 0) {
// First copy partial transaction to beginning of buffer
memcpy((void *) buf,
(void *) (buf + cur_buf_pos),
res * INT_SIZE);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movslq 0x18(%rdi), %rax
leaq 0x1e0d(%rip), %rcx # 0xc530
movslq (%rcx), %r14
subq %rax, %r15
jne 0xa730
xorl %r15d, %r15d
jmp 0xa744
movq 0x8(%rbx), %rdi
leaq (%rdi,%rax,4), %rsi
movq %r15, %rdx
imulq %r14, %rdx
callq 0x3290
movq %r15, 0x10(%rb... | /fzyukio[P]cspade-full/calcdb.cc |
DbaseCtrlBlk::get_first_blk() | void DbaseCtrlBlk::get_first_blk() {
readall = 0;
lseek(fd, 0, SEEK_SET);
cur_blk_size = (read(fd, (void *) buf, (buf_size * INT_SIZE))) / INT_SIZE;
if (cur_blk_size < 0) {
throw runtime_error("get_first_blk");
}
cur_buf_pos = 0;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x28(%rdi)
movl (%rdi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3630
movl (%rbx), %edi
movq 0x8(%rbx), %rsi
movslq 0x4(%rbx), %rdx
leaq 0x1d8d(%rip), %rax # 0xc530
movslq (%rax), %r14
imulq %r14, %rdx
callq 0x3490
cqto
idivq %r14
movq %rax, 0x10(%rbx... | /fzyukio[P]cspade-full/calcdb.cc |
DbaseCtrlBlk::get_next_trans(int*&, int&, int&, int&) | void DbaseCtrlBlk::get_next_trans(int *&lbuf, int &nitems, int &tid, int &cid) {
if (cur_buf_pos + TRANSOFF >= cur_blk_size ||
cur_buf_pos + buf[cur_buf_pos + TRANSOFF - 1] + TRANSOFF > cur_blk_size) {
if (lseek(fd, 0, SEEK_CUR) == endpos) readall = 1;
if (!readall) {
// Need to ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
leal 0x3(%rax), %ecx
movslq %ecx, %rsi
movq 0x10(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0xa803
movq 0x8(%rbx), %rsi
addl 0x8(%rsi,%rax,4), %ecx
movslq %ecx, %rax
cmpq %r... | /fzyukio[P]cspade-full/calcdb.cc |
list_files(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&) | list<string> list_files(const string &folder, const string &prefix) {
struct dirent *entry;
list<string> retval;
DIR *dir = opendir(folder.c_str());
if (dir == nullptr) {
return retval;
}
bool check_prefix = prefix.length() > 0;
while ((entry = readdir(dir)) != nullptr) {
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rdi
callq 0x34c0
testq %rax, %rax
je 0xacd1
movq %rax, %r15
movq %rbx, (%rsp)
movq 0x8(%r14), %r12
leaq 0x18(%rsp), %rbx
movq %r15... | /fzyukio[P]cspade-full/common.cc |
random_id[abi:cxx11](int) | string random_id(const int len) {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, alphanumlen - 1);
auto *s = new char[len + 1];
int rand_idx;
for (int i = 0; i < len; ++i) {
rand_idx = dis(gen);
s[i] = alphanum[rand_idx];
}
s[len] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2728, %rsp # imm = 0x2728
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
leaq 0x13a0(%rsp), %r15
movq %r15, %rdi
callq 0xae6e
movq %r15, %rdi
callq 0x3460
movl %eax, %eax
movq %rax, 0x18(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl... | /fzyukio[P]cspade-full/common.cc |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_char<char, fmt::v9::appender>(fmt::v9::appender, char, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<char> ... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x5ebe1(%rip), %rcx # 0x7e825
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
char fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_bytes<(fmt::v9::align::type)1, char, fmt::v9::appender>(fmt::v9::appender, fmt::v9::basic_string_view<char>, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(char, fmt::v... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x5e836(%rip), %rcx # 0x7e825
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
_sanitizer::DeadlockDetector<__sanitizer::TwoLevelBitVector<1ul, __sanitizer::BasicBitVector<unsigned long>>>::findPathToLock(__sanitizer::DeadlockDetectorTLS<__sanitizer::TwoLevelBitVector<1ul, __sanitizer::BasicBitVector<unsigned long>>>*, unsigned long, unsigned long*, unsigned long) | uptr findPathToLock(DeadlockDetectorTLS<BV> *dtls, uptr cur_node, uptr *path,
uptr path_size) {
tmp_bv_.copyFrom(dtls->getLocks(current_epoch_));
uptr idx = nodeToIndex(cur_node);
CHECK(!tmp_bv_.getBit(idx));
uptr res = g_.findShortestPath(idx, tmp_bv_, path, path_size);
for (u... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, %rcx
addq $0x418, %rcx # imm = 0x418
movq %rcx, 0x8(%rsp)
movq 0x68(%rsp), %rdi
movq (%rax), %rsi
callq 0xd580
movq 0x8(%rsp), %... | /sanitizer_common/sanitizer_deadlock_detector.h |
_sanitizer::FlagParser::PrintFlagDescriptions() | void FlagParser::PrintFlagDescriptions() {
char buffer[128];
buffer[sizeof(buffer) - 1] = '\0';
Printf("Available flags for %s:\n", SanitizerToolName);
for (int i = 0; i < n_flags_; ++i) {
bool truncated = !(flags_[i].handler->Format(buffer, sizeof(buffer)));
CHECK_EQ(buffer[sizeof(buffer) - 1], '\0');
... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movl $0xaa, %esi
movl $0x80, %edx
callq 0x52b0
movb $0x0, 0xaf(%rsp)
leaq 0x54d51(%rip), %rax # 0x66200
movq (%rax), %rsi
leaq 0x3d3a7(%rip), %rdi # 0x4e860
movb $0x0, %al
callq 0x1b410
movl $0x0, 0x2c(%rsp)
... | /sanitizer_common/sanitizer_flag_parser.cpp |
_sanitizer::ReadBinaryName(char*, unsigned long) | uptr ReadBinaryName(/*out*/ char *buf, uptr buf_len) {
# if SANITIZER_SOLARIS
const char *default_module_name = getexecname();
CHECK_NE(default_module_name, NULL);
return internal_snprintf(buf, buf_len, "%s", default_module_name);
# else
# if SANITIZER_FREEBSD || SANITIZER_NETBSD
# if SANITIZER_FREEBSD
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x38362(%rip), %rax # 0x4ef57
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x15200
movq %rax, 0x18(%rsp)
movl $0xaaaaaaaa, 0x14(%rsp) # imm = 0xAAAAAAAA
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
call... | /sanitizer_common/sanitizer_linux.cpp |
_sanitizer::MapWritableFileToMemory(void*, unsigned long, int, unsigned long long) | void *MapWritableFileToMemory(void *addr, uptr size, fd_t fd, OFF_T offset) {
uptr flags = MAP_SHARED;
if (addr) flags |= MAP_FIXED;
uptr p = internal_mmap(addr, size, PROT_READ | PROT_WRITE, flags, fd, offset);
int mmap_errno = 0;
if (internal_iserror(p, &mmap_errno)) {
Printf("could not map writable fil... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x190b6
movq 0x18(%rsp), %rax
orq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rax
movl %eax, %ecx
movl 0x2c(%rsp), %... | /sanitizer_common/sanitizer_posix.cpp |
_sanitizer::ThreadContextBase::SetFinished() | void ThreadContextBase::SetFinished() {
// ThreadRegistry::FinishThread calls here in ThreadStatusCreated state
// for a thread that never actually started. In that case the thread
// should go to ThreadStatusFinished regardless of whether it was created
// as detached.
if (!detached || status == ThreadStatu... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x74(%rax)
je 0x22344
movq 0x8(%rsp), %rax
cmpl $0x1, 0x70(%rax)
jne 0x22350
movq 0x8(%rsp), %rax
movl $0x3, 0x70(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x18, %rsp
retq
| /sanitizer_common/sanitizer_thread_registry.cpp |
_sanitizer::dl_iterate_phdr_cb(dl_phdr_info*, unsigned long, void*) | static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
DlIteratePhdrData *data = (DlIteratePhdrData *)arg;
if (data->first) {
InternalMmapVector<char> module_name(kMaxPathLength);
data->first = false;
// First module is the binary itself.
ReadBinaryNameCached(module_name.data(),... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x26ffb
movq 0x29f35(%rip), %rax # 0x50ea8
movq %rax, 0x8(%rsp)
movq 0x29f31(%rip), %rax # 0x50eb0
movq %rax, 0x10(%rsp)
movq 0x29f2d(%rip... | /sanitizer_common/sanitizer_linux_libcdep.cpp |
_ubsan::getObjCClassName(unsigned long) | const char *__ubsan::getObjCClassName(ValueHandle Pointer) {
#if SANITIZER_APPLE
// We need to query the ObjC runtime for some information, but do not want
// to introduce a static dependency from the ubsan runtime onto ObjC. Try to
// grab a handle to the ObjC runtime used by the process.
static bool Attempted... | movq %rdi, -0x8(%rsp)
xorl %eax, %eax
retq
nopl (%rax,%rax)
| /ubsan/ubsan_value.cpp |
secp256k1_selftest | void secp256k1_selftest(void) {
if (!secp256k1_selftest_passes()) {
secp256k1_callback_call(&default_error_callback, "self test failed");
}
} | pushq %rbx
subq $0x90, %rsp
movaps 0x2cf7d(%rip), %xmm0 # 0x303e0
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x2cf7e(%rip), %xmm0 # 0x303f0
movaps %xmm0, 0x10(%rbx)
movq $0x0, 0x60(%rbx)
leaq 0x2d507(%rip), %rsi # 0x3098c
movl $0x3f, %edx
movq %rbx, %rdi
callq 0xa97e
movq %rsp, %rsi
movq %rbx, %rdi
cal... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_preallocated_size | size_t secp256k1_context_preallocated_size(unsigned int flags) {
size_t ret = sizeof(secp256k1_context);
/* A return value of 0 is reserved as an indicator for errors when we call this function internally. */
VERIFY_CHECK(ret != 0);
if (EXPECT((flags & SECP256K1_FLAGS_TYPE_MASK) != SECP256K1_FLAGS_TYPE... | subq $0x48, %rsp
cmpb $0x1, %dil
jne 0x353b
leaq 0x10(%rsp), %rax
movq $0x4d430002, (%rax) # imm = 0x4D430002
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
xorl %edx, %edx
rolq $0x3, %rdi
rolq $0xd, %rdi
rolq $0x3d, %rdi
rolq $0x33, %rdi... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_preallocated_create | secp256k1_context* secp256k1_context_preallocated_create(void* prealloc, unsigned int flags) {
size_t prealloc_size;
secp256k1_context* ret;
secp256k1_selftest();
prealloc_size = secp256k1_context_preallocated_size(flags);
if (prealloc_size == 0) {
return NULL;
}
VERIFY_CHECK(preal... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3454
movl %ebp, %edi
callq 0x34db
testq %rax, %rax
je 0x35b0
movups 0x14782b(%rip), %xmm0 # 0x14ada8
movups %xmm0, 0xa8(%rbx)
movups 0x14780d(%rip), %xmm0 # 0x14ad98
movups %xmm0, 0xb8(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6486
movl $0... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_create | secp256k1_context* secp256k1_context_create(unsigned int flags) {
size_t const prealloc_size = secp256k1_context_preallocated_size(flags);
secp256k1_context* ctx = (secp256k1_context*)checked_malloc(&default_error_callback, prealloc_size);
if (EXPECT(secp256k1_context_preallocated_create(ctx, flags) == NULL... | pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
callq 0x34db
movq %rax, %rdi
callq 0x1080
testq %rax, %rax
je 0x35fb
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
callq 0x355d
testq %rax, %rax
je 0x35ef
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
jmp 0x35e5
c... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_preallocated_clone | secp256k1_context* secp256k1_context_preallocated_clone(const secp256k1_context* ctx, void* prealloc) {
secp256k1_context* ret;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(prealloc != NULL);
ARG_CHECK(secp256k1_context_is_proper(ctx));
ret = (secp256k1_context*)prealloc;
*ret = *ctx;
return ret;
} | pushq %rax
movq %rdi, %rax
testq %rsi, %rsi
je 0x361f
cmpl $0x0, (%rax)
je 0x3629
movl $0xd0, %edx
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0x1070
movq %rax, %rdi
callq 0x15ad
jmp 0x3631
movq %rax, %rdi
callq 0x1596
xorl %eax, %eax
popq %rcx
retq
| /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_clone | secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
secp256k1_context* ret;
size_t prealloc_size;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(secp256k1_context_is_proper(ctx));
prealloc_size = secp256k1_context_preallocated_clone_size(ctx);
ret = (secp256k1_context*)checked_mal... | pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x368f
movl $0xd0, %edi
callq 0x1080
testq %rax, %rax
je 0x3663
cmpl $0x0, (%rbx)
je 0x3699
movl $0xd0, %edx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1070
movq 0xc0(%rbx), %rsi
leaq 0x2d35b(%rip), %rdi # 0x309cc
callq *0xb8(%rbx)
movq 0xb0(%rbx), %rsi
leaq 0x2c... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_destroy | void secp256k1_context_destroy(secp256k1_context* ctx) {
ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx));
/* Defined as noop */
if (ctx == NULL) {
return;
}
secp256k1_context_preallocated_destroy(ctx);
free(ctx);
} | pushq %rbx
testq %rdi, %rdi
je 0x372f
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x3727
movq %rbx, %rdi
callq 0x36a3
movq %rbx, %rdi
popq %rbx
jmp 0x1030
movq %rbx, %rdi
callq 0x1609
popq %rbx
retq
| /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_set_illegal_callback | void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
/* We compare pointers instead of checking secp256k1_context_is_proper() here
because setting callbacks is allowed on *copies* of the static context:
it's harmless and ... | leaq 0x147928(%rip), %rax # 0x14b060
cmpq %rdi, (%rax)
je 0x375a
testq %rsi, %rsi
leaq 0x1e(%rip), %rax # 0x3765
cmovneq %rsi, %rax
movq %rax, 0xa8(%rdi)
movq %rdx, 0xb0(%rdi)
retq
pushq %rax
callq 0x1620
addq $0x8, %rsp
retq
| /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_context_set_error_callback | void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (*fun)(const char* message, void* data), const void* data) {
/* We compare pointers instead of checking secp256k1_context_is_proper() here
because setting callbacks is allowed on *copies* of the static context:
it's harmless and ma... | leaq 0x1478d3(%rip), %rax # 0x14b060
cmpq %rdi, (%rax)
je 0x37af
testq %rsi, %rsi
leaq 0x1e(%rip), %rax # 0x37ba
cmovneq %rsi, %rax
movq %rax, 0xb8(%rdi)
movq %rdx, 0xc0(%rdi)
retq
pushq %rax
callq 0x1637
addq $0x8, %rsp
retq
| /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_parse | int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pubkey* pubkey, const unsigned char *input, size_t inputlen) {
secp256k1_ge Q;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkey != NULL);
memset(pubkey, 0, sizeof(*pubkey));
ARG_CHECK(input != NULL);
if (!secp256k1_eckey_pubkey_pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
testq %rsi, %rsi
je 0x4424
movq %rdx, %r14
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsi)
movups %xmm0, 0x20(%rsi)
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
testq %rdx, %rdx
je 0x442b
xorl %ebp,... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_pubkey_save | static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge* ge) {
secp256k1_ge_to_bytes(pubkey->data, ge);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movaps %xmm1, 0x10(%r15)
movq 0x20(%rsi), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
callq 0x1a8f8
movq 0x48(%r12), %rax
movq %rsp, %r14
m... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_serialize | int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned char *output, size_t *outputlen, const secp256k1_pubkey* pubkey, unsigned int flags) {
secp256k1_ge Q;
size_t len;
int ret = 0;
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(outputlen != NULL);
ARG_CHECK(*outputlen >= ((flags & SEC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdx, %rdx
je 0x460e
movl %r8d, %r15d
movq %rdx, %rbx
movq (%rdx), %rdx
xorl %eax, %eax
movl %r8d, %ebp
andl $0x100, %ebp # imm = 0x100
sete %al
shll $0x5, %eax
addq $0x21, %rax
cmpq %rax, %rdx
jb 0x4615
movq %rsi, %r14
... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_eckey_pubkey_serialize | static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned char *pub, size_t *size, int compressed) {
if (secp256k1_ge_is_infinity(elem)) {
return 0;
}
secp256k1_fe_normalize_var(&elem->x);
secp256k1_fe_normalize_var(&elem->y);
secp256k1_fe_get_b32(&pub[1], &elem->x);
if (c... | xorl %eax, %eax
cmpl $0x0, 0x50(%rdi)
je 0x46b7
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0xe4f0
leaq 0x28(%r12), %r15
movq %r15, %rdi
callq 0xe4f0
leaq 0x1(%rbx), %rdi
movq %r12, %rsi
callq 0xe169
testl %ebp, %ebp
je 0x46fe
movq $0... | /fanquake[P]bitcoin/src/secp256k1/src/eckey_impl.h |
secp256k1_ec_pubkey_cmp | int secp256k1_ec_pubkey_cmp(const secp256k1_context* ctx, const secp256k1_pubkey* pubkey0, const secp256k1_pubkey* pubkey1) {
unsigned char out[2][33];
const secp256k1_pubkey* pk[2];
int i;
VERIFY_CHECK(ctx != NULL);
pk[0] = pubkey0; pk[1] = pubkey1;
for (i = 0; i < 2; i++) {
size_t out... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x20(%rsp), %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq $0x21, 0x8(%rsp)
movq 0x10(%rsp,%r12,8), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x102, %r8d # imm = 0x... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
secp256k1_ec_pubkey_sort | int secp256k1_ec_pubkey_sort(const secp256k1_context* ctx, const secp256k1_pubkey **pubkeys, size_t n_pubkeys) {
VERIFY_CHECK(ctx != NULL);
ARG_CHECK(pubkeys != NULL);
/* Suppress wrong warning (fixed in MSVC 19.33) */
#if defined(_MSC_VER) && (_MSC_VER < 1933)
#pragma warning(push)
#pragma war... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x498a
movq %rdx, %r15
movq %rsi, %r14
cmpq $0x2, %rdx
jb 0x48a6
movq %r15, %rax
shrq %rax
movq %rax, 0x8(%rsp)
decq %rax
movq %rax, 0x10(%rsp)
cmpq %rax, 0x8(%rsp)
jbe 0x4898
movq 0x10(%rsp), %r13
lea... | /fanquake[P]bitcoin/src/secp256k1/src/secp256k1.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.