name string | code string | asm string | file string |
|---|---|---|---|
lace_shrink_shared | static int
lace_shrink_shared(WorkerP *w)
{
Worker *wt = w->_public;
TailSplitNA ts; /* Use non-atomic version to emit better code */
ts.v = wt->ts.v; /* Force in 1 memory read */
uint32_t tail = ts.ts.tail;
uint32_t split = ts.ts.split;
if (tail != split) {
uint32_t newsplit = (tail + ... | movq 0x18(%rdi), %rax
movq 0x8(%rax), %rdx
movq %rdx, %rcx
shrq $0x20, %rcx
cmpl %ecx, %edx
je 0x5b30
addl %ecx, %edx
shrl %edx
movl %edx, 0xc(%rax)
mfence
movl 0x8(%rax), %esi
cmpl %ecx, %esi
jne 0x5b3e
movb $0x1, %cl
movb %cl, 0x10(%rax)
movb %cl, 0x2e(%rdi)
movl $0x1, %eax
retq
cmpl %edx, %esi
ja 0x5b52
movl %edx, %... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.h |
lace_steal | lace_steal(WorkerP *self, Task *__dq_head, Worker *victim)
{
if (victim != NULL && !victim->allstolen) {
TailSplitNA ts;
ts.v = victim->ts.v;
if (ts.ts.tail < ts.ts.split) {
TailSplitNA ts_new;
ts_new.v = ts.v;
ts_new.ts.tail++;
if (atomic_comp... | movl $0x2, %eax
testq %rdx, %rdx
je 0x5b6d
cmpb $0x0, 0x10(%rdx)
je 0x5b6e
retq
movq 0x8(%rdx), %rcx
movq %rcx, %r8
shrq $0x20, %r8
cmpl %r8d, %ecx
jae 0x5bd4
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
andq %rcx, %rax
leal 0x1(%rcx), %r8d
orq %rax, %r8
movq %rcx, %rax
lock
cmpxchgq %r8, 0x8(%rdx)
movl $... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.h |
print_example | static void
print_example(MDD example)
{
if (example != lddmc_false) {
uint32_t vec[vector_size];
lddmc_sat_one(example, vec, vector_size);
printf("[");
for (int i=0; i<vector_size; i++) {
if (i>0) printf(",");
printf("%" PRIu32, vec[i]);
}
pr... | testq %rdi, %rdi
je 0x5c82
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsp, %r15
movl 0x1b5d8(%rip), %eax # 0x211d4
movq %rsp, %rbx
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
movslq 0x1b5bc(%rip), %rdx # 0x211d4
movq %rbx, %rsi
callq 0xed20
movl $0... | /trolando[P]sylvan/examples/lddmc.c |
set_save | static void
set_save(FILE* f, set_t set)
{
int k = -1;
fwrite(&k, sizeof(int), 1, f);
size_t dd = lddmc_serialize_add(set->dd);
lddmc_serialize_tofile(f);
fwrite(&dd, sizeof(size_t), 1, f);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22f0
movq (%rbx), %rdi
callq 0xf6e4
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xf9ee
movl $0x8, %esi
mov... | /trolando[P]sylvan/examples/lddmc.c |
print_help | static void
print_help()
{
printf("Usage: lddmc [OPTION...] <model> [<output-bdd>]\n\n");
printf(" -s, --strategy=<bfs|par|sat|chaining>\n");
printf(" Strategy for reachability (default=par)\n");
printf(" -w, --workers=<workers> Number of workers (default=0: autodetect)\... | pushq %rax
leaq 0x1270e(%rip), %rdi # 0x1859b
callq 0x2240
leaq 0x12733(%rip), %rdi # 0x185cc
callq 0x2240
leaq 0x1274f(%rip), %rdi # 0x185f4
callq 0x2240
leaq 0x12788(%rip), %rdi # 0x18639
callq 0x2240
leaq 0x127c3(%rip), %rdi # 0x18680
callq 0x2240
leaq 0x127eb(%rip), %rdi # 0x186b4
callq 0x22... | /trolando[P]sylvan/examples/lddmc.c |
getPeakRSS | size_t
getPeakRSS()
{
#if defined(_WIN32)
PROCESS_MEMORY_COUNTERS info;
GetProcessMemoryInfo( GetCurrentProcess( ), &info, sizeof(info) );
return (size_t)info.PeakWorkingSetSize;
#else
struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage);
#if defined(__APPLE__) && defined(__MACH__)
return (size_t)rusage... | pushq %rbx
subq $0x90, %rsp
movq %rsp, %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x20a0
movq 0x20(%rbx), %rax
shlq $0xa, %rax
addq $0x90, %rsp
popq %rbx
retq
| /trolando[P]sylvan/examples/getrss.c |
getCurrentRSS | size_t
getCurrentRSS()
{
#if defined(__APPLE__) && defined(__MACH__)
/* OSX ------------------------------------------------------ */
struct mach_task_basic_info info;
mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO, (task_info_t)&info,... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rsp)
leaq 0x128b1(%rip), %rdi # 0x187fb
leaq 0x12505(%rip), %rsi # 0x18456
callq 0x2160
testq %rax, %rax
je 0x5f9d
movq %rax, %r14
leaq 0x128a7(%rip), %rsi # 0x1880c
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0... | /trolando[P]sylvan/examples/getrss.c |
getMaxMemory | size_t
getMaxMemory()
{
#if defined(_WIN32)
MEMORYSTATUSEX status;
status.dwLength = sizeof(status);
GlobalMemoryStatusEx(&status);
return status.ullTotalPhys;
#else
long pages = sysconf(_SC_PHYS_PAGES);
long page_size = sysconf(_SC_PAGE_SIZE);
return pages * page_size;
#endif
} | pushq %rbx
movl $0x55, %edi
callq 0x20d0
movq %rax, %rbx
movl $0x1e, %edi
callq 0x20d0
imulq %rbx, %rax
popq %rbx
retq
nopl (%rax)
| /trolando[P]sylvan/examples/getrss.c |
cache_put6 | int
cache_put6(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e, uint64_t f, uint64_t res1, uint64_t res2)
{
const uint64_t hash = cache_hash6(a, b, c, d, e, f);
#if CACHE_MASK
_Atomic(uint64_t) *s_bucket = (_Atomic(uint64_t)*)cache_status + (hash & cache_mask)/2;
cache6_entry_t bucket = (cache6_e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rax
shrq $0x20, %rax
movabsq $-0x340d631b7bdddcdb, %rbx # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %r14 # imm = 0x100000001B3
movq 0x1b109(%rip), %r15 # 0x21218
movabsq $-0x7fffffff80000000, %r11 # imm = 0x8000000080000000
xorl... | /trolando[P]sylvan/src/sylvan_cache.c |
cache_get | int
cache_get(uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
{
const uint64_t hash = cache_hash(a, b, c);
#if CACHE_MASK
_Atomic(uint32_t) *s_bucket = (_Atomic(uint32_t)*)cache_status + (hash & cache_mask);
cache_entry_t bucket = cache_table + (hash & cache_mask);
#else
_Atomic(uint32_t) *s_bucket =... | pushq %rbx
movq %rdi, %rax
shrq $0x20, %rax
movabsq $-0x340d631b7bdddcdb, %r10 # imm = 0xCBF29CE484222325
movq 0x1afe9(%rip), %r9 # 0x21218
movq 0x1afda(%rip), %r8 # 0x21210
xorq %rdi, %rax
xorq %rax, %r10
movabsq $0x100000001b3, %rax # imm = 0x100000001B3
imulq %rax, %r10
xorq %rsi, %r10
imulq %rax, %r10
... | /trolando[P]sylvan/src/sylvan_cache.c |
cache_put | int
cache_put(uint64_t a, uint64_t b, uint64_t c, uint64_t res)
{
const uint64_t hash = cache_hash(a, b, c);
#if CACHE_MASK
_Atomic(uint32_t) *s_bucket = (_Atomic(uint32_t)*)cache_status + (hash & cache_mask);
cache_entry_t bucket = cache_table + (hash & cache_mask);
#else
_Atomic(uint32_t) *s_bucket = ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rax
shrq $0x20, %rax
movabsq $-0x340d631b7bdddcdb, %r9 # imm = 0xCBF29CE484222325
movabsq $0x100000001b3, %r10 # imm = 0x100000001B3
movq 0x1af46(%rip), %r11 # 0x21218
xorl %r8d, %r8d
xorq %rdi, %rax
xorq %rax, %r9
imulq %r10, %r9
xorq %rsi, %r9
imulq %r10, %r9
xorq %... | /trolando[P]sylvan/src/sylvan_cache.c |
cache_create | void
cache_create(size_t _cache_size, size_t _max_size)
{
#if CACHE_MASK
// Cache size must be a power of 2
if (__builtin_popcountll(_cache_size) != 1 || __builtin_popcountll(_max_size) != 1) {
fprintf(stderr, "cache_create: Table size must be a power of 2!\n");
exit(1);
}
#endif
cache_... | pushq %rbx
popcntq %rdi, %rax
cmpl $0x1, %eax
jne 0x6427
popcntq %rsi, %rax
cmpl $0x1, %eax
jne 0x6427
leaq -0x1(%rdi), %rax
movq %rdi, 0x1aead(%rip) # 0x21228
movq %rsi, 0x1aeae(%rip) # 0x21230
movq %rax, 0x1ae8f(%rip) # 0x21218
cmpq %rsi, %rdi
ja 0x642c
shlq $0x5, %rsi
movl $0x3, %edx
movl $0x22, %ecx
mov... | /trolando[P]sylvan/src/sylvan_cache.c |
cache_free | void
cache_free()
{
free_aligned(cache_table, cache_max * sizeof(struct cache_entry));
free_aligned(cache_status, cache_max * sizeof(uint32_t));
} | pushq %rax
movq 0x1adf2(%rip), %rsi # 0x21230
movq 0x1addb(%rip), %rdi # 0x21220
shlq $0x5, %rsi
addq $0x3f, %rsi
andq $-0x40, %rsi
callq 0x20b0
movq 0x1add3(%rip), %rax # 0x21230
movq 0x1adac(%rip), %rdi # 0x21210
leaq 0x3f(,%rax,4), %rsi
andq $-0x40, %rsi
popq %rax
jmp 0x20b0
| /trolando[P]sylvan/src/sylvan_cache.c |
cache_getused | size_t
cache_getused()
{
size_t result = 0;
for (size_t i=0;i<cache_size;i++) {
uint32_t s = cache_status[i];
if (s & 0x80000000) fprintf(stderr, "cache_getuser: cache in use during cache_getused()\n");
if (s) result++;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x1ad68(%rip), %rax # 0x21228
testq %rax, %rax
je 0x651d
movq 0x1ad44(%rip), %rcx # 0x21210
movq 0x1aafd(%rip), %r15 # 0x20fd0
leaq 0x123c6(%rip), %r14 # 0x188a0
xorl %ebx, %ebx
xorl %r12d, %r12d
movl (%rcx,%r12,4), %ebp
testl %ebp, %ebp
js 0x6... | /trolando[P]sylvan/src/sylvan_cache.c |
sylvan_rehash_all_WRAP | VOID_TASK_IMPL_0(sylvan_rehash_all)
{
// clear hash array
llmsset_clear_hashes(nodes);
// rehash marked nodes
if (llmsset_rehash(nodes) != 0) {
fprintf(stderr, "sylvan_gc_rehash error: not all nodes could be rehashed!\n");
exit(1);
}
} | jmp 0x664d
| /trolando[P]sylvan/src/sylvan_common.c |
sylvan_rehash_all_CALL | VOID_TASK_IMPL_0(sylvan_rehash_all)
{
// clear hash array
llmsset_clear_hashes(nodes);
// rehash marked nodes
if (llmsset_rehash(nodes) != 0) {
fprintf(stderr, "sylvan_gc_rehash error: not all nodes could be rehashed!\n");
exit(1);
}
} | pushq %rbx
subq $0x40, %rsp
movq 0x1ac27(%rip), %rax # 0x21280
leaq 0xd5fa(%rip), %rcx # 0x13c5a
movq %rsp, %rbx
movq %rbx, %rdi
movq %rcx, (%rbx)
movq $0x1, 0x8(%rbx)
movq %rax, 0x10(%rbx)
callq 0x16391
leaq 0xd852(%rip), %rcx # 0x13ed3
movq 0x1abf8(%rip), %rax # 0x21280
movq %rcx, (%rbx)
movq $0x1, ... | /trolando[P]sylvan/src/sylvan_common.c |
next_size | size_t
next_size(size_t current_size)
{
#if SYLVAN_SIZE_FIBONACCI
size_t f1=1, f2=1;
for (;;) {
f2 += f1;
if (f2 > current_size) return f2;
f1 += f2;
if (f1 > current_size) return f1;
}
#else
return current_size*2;
#endif
} | leaq (%rdi,%rdi), %rax
retq
| /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_aggressive_resize_CALL | VOID_TASK_IMPL_0(sylvan_gc_aggressive_resize)
{
size_t nodes_size = llmsset_get_size(nodes);
size_t nodes_max = llmsset_get_max_size(nodes);
if (nodes_size < nodes_max) {
size_t new_size = next_size(nodes_size);
if (new_size > nodes_max) new_size = nodes_max;
llmsset_set_size(nodes, ... | pushq %rbx
movq 0x1abbb(%rip), %rax # 0x21280
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
cmpq %rdx, %rcx
jae 0x6703
addq %rcx, %rcx
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
cmpq $0x81, %rcx
jb 0x6703
movq %rcx, 0x30(%rax)
leaq -0x1(%rcx), %rdx
lzcntq %rcx, %rcx
movq %rdx, 0x38(%rax)
addl %ecx, %ecx
movl $0xc0, %edx
subl... | /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_normal_resize_WRAP | VOID_TASK_IMPL_0(sylvan_gc_normal_resize)
{
size_t nodes_size = llmsset_get_size(nodes);
size_t nodes_max = llmsset_get_max_size(nodes);
if (nodes_size < nodes_max) {
size_t marked = llmsset_count_marked(nodes);
if (marked*2 > nodes_size) {
size_t new_size = next_size(nodes_size)... | jmp 0x672f
| /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_normal_resize_CALL | VOID_TASK_IMPL_0(sylvan_gc_normal_resize)
{
size_t nodes_size = llmsset_get_size(nodes);
size_t nodes_max = llmsset_get_max_size(nodes);
if (nodes_size < nodes_max) {
size_t marked = llmsset_count_marked(nodes);
if (marked*2 > nodes_size) {
size_t new_size = next_size(nodes_size)... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x1ab41(%rip), %rax # 0x21280
movq 0x28(%rax), %r15
movq 0x30(%rax), %r14
cmpq %r15, %r14
jae 0x67df
leaq 0xd9c7(%rip), %rcx # 0x1411e
movq %rsp, %rbx
movq %rbx, %rdi
movq %rcx, (%rbx)
movq $0x1, 0x8(%rbx)
movq %rax, 0x10(%rbx)
callq 0x16391
movq 0x10(%rbx... | /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_go_WRAP | VOID_TASK_0(sylvan_gc_go)
{
sylvan_stats_count(SYLVAN_GC_COUNT);
sylvan_timer_start(SYLVAN_GC);
// call pre gc hooks
for (gc_hook_entry_t e = pregc_list; e != NULL; e = e->next) {
WRAP(e->cb);
}
/*
* This simply clears the cache.
* Alternatively, we could implement for exampl... | jmp 0x67ee
| /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_go_CALL | VOID_TASK_0(sylvan_gc_go)
{
sylvan_stats_count(SYLVAN_GC_COUNT);
sylvan_timer_start(SYLVAN_GC);
// call pre gc hooks
for (gc_hook_entry_t e = pregc_list; e != NULL; e = e->next) {
WRAP(e->cb);
}
/*
* This simply clears the cache.
* Alternatively, we could implement for exampl... | pushq %r15
pushq %r14
pushq %rbx
movq 0x1aa46(%rip), %r15 # 0x21240
movq %rsi, %rbx
movq %rdi, %r14
testq %r15, %r15
je 0x6814
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%r15)
movq (%r15), %r15
jmp 0x6800
callq 0x6476
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65ca
movq %r14, %rdi
movq %rbx, %rsi
callq *0x1aa28(%rip) ... | /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_WRAP | VOID_TASK_IMPL_0(sylvan_gc)
{
if (gc_enabled) {
int zero = 0;
if (atomic_compare_exchange_strong(&gc, &zero, 1)) {
NEWFRAME(sylvan_gc_go);
gc = 0;
} else {
/* wait for new frame to appear */
while (atomic_load_explicit(&lace_newframe.t, memory_... | jmp 0x685b
| /trolando[P]sylvan/src/sylvan_common.c |
sylvan_gc_CALL | VOID_TASK_IMPL_0(sylvan_gc)
{
if (gc_enabled) {
int zero = 0;
if (atomic_compare_exchange_strong(&gc, &zero, 1)) {
NEWFRAME(sylvan_gc_go);
gc = 0;
} else {
/* wait for new frame to appear */
while (atomic_load_explicit(&lace_newframe.t, memory_... | pushq %rbx
subq $0x40, %rsp
cmpb $0x0, 0x1a9d1(%rip) # 0x21238
jne 0x689c
movl $0x1, %ecx
xorl %ebx, %ebx
xorl %eax, %eax
lock
cmpxchgl %ecx, 0x1aa0e(%rip) # 0x21288
jne 0x68a2
leaq -0x9a(%rip), %rax # 0x67e9
movq %rsp, %rdi
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
callq 0x17096
xchgl %ebx, 0x1a9ec(%rip) ... | /trolando[P]sylvan/src/sylvan_common.c |
sylvan_set_sizes | void
sylvan_set_sizes(size_t min_tablesize, size_t max_tablesize, size_t min_cachesize, size_t max_cachesize)
{
/* Some sanity checks */
if (min_tablesize > max_tablesize) min_tablesize = max_tablesize;
if (min_cachesize > max_cachesize) min_cachesize = max_cachesize;
if (!is_power_of_two(min_tablesize... | pushq %rax
cmpq %rsi, %rdi
cmovaeq %rsi, %rdi
cmpq %rcx, %rdx
cmovaeq %rcx, %rdx
popcntq %rdi, %rax
cmpl $0x1, %eax
jne 0x691f
popcntq %rsi, %rax
cmpl $0x1, %eax
jne 0x691f
popcntq %rdx, %rax
cmpl $0x1, %eax
jne 0x691f
popcntq %rcx, %rax
cmpl $0x1, %eax
jne 0x691f
movabsq $0x40000000001, %rax # imm = 0x40000000001
c... | /trolando[P]sylvan/src/sylvan_common.c |
refs_count | size_t
refs_count(refs_table_t *tbl)
{
size_t count = 0;
_Atomic(uint64_t) *bucket = tbl->refs_table;
_Atomic(uint64_t) * const end = bucket + tbl->refs_size;
while (bucket != end) {
uint64_t d = atomic_load_explicit(bucket, memory_order_relaxed);
if (d != 0 && d != refs_ts) count++;
... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x12775
movq (%rdi), %rdx
shlq $0x3, %rcx
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi), %r8
testq %r8, %r8
je 0x1276b
cmpq %rdi, %r8
je 0x1276b
incq %rax
addq $0x8, %rsi
cmpq %rsi, %rcx
jne 0x1275a
retq
xorl %eax, ... | /trolando[P]sylvan/src/sylvan_refs.c |
SHA256_End | char *SHA256_End(SHA256_CTX* context, char buffer[SHA256_DIGEST_STRING_LENGTH]) {
sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest;
int i;
/* Sanity check: */
assert(context != (SHA256_CTX*)0);
if (buffer != (char*)0) {
SHA256_Final(digest, context);
for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
*buff... | pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x150dd
movq %rsi, %rbx
movq %rdi, %rsi
testq %rbx, %rbx
je 0x150bc
movq %rsp, %r14
movq %r14, %rdi
callq 0x14afc
vmovdqu (%r14), %ymm2
leaq 0x5301(%rip), %rax # 0x19f3f
vgf2p8affineqb $0x0, 0x5077(%rip){1to4}, %ymm2, %ymm1 # 0x19cc0
vextracti128 $0x1, %ym... | /trolando[P]sylvan/src/sha2.c |
sylvan_init_hash | void
sylvan_init_hash(void)
{
// initialize sylvan_tabhash_table
for (int i=0; i<256*16; i++) sylvan_tabhash_table[i] = CWhash(i);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xb4eb(%rip), %r14 # 0x21330
leaq 0x4264(%rip), %rbp # 0x1a0b0
movl $0xfffffffe, %r13d # imm = 0xFFFFFFFE
movabsq $-0xffffffff, %r15 # imm = 0xFFFFFFFF00000001
xorl %ebx, %ebx
movq %rsp, %r12
leaq 0x40e8(%rip), %... | /trolando[P]sylvan/src/sylvan_hash.c |
lace_barrier | void
lace_barrier()
{
int wait = lace_bar.wait;
if ((int)n_workers == 1+(atomic_fetch_add_explicit(&lace_bar.count, 1, memory_order_relaxed))) {
// we know for sure no other thread can be here
atomic_store_explicit(&lace_bar.count, 0, memory_order_relaxed);
atomic_store_explicit(&lace_ba... | movl $0x1, %esi
movl 0x13292(%rip), %eax # 0x29400
movl 0x131cc(%rip), %edx # 0x29340
movl $0x1, %ecx
lock
xaddl %esi, 0x131ff(%rip) # 0x29380
incl %esi
cmpl %esi, %edx
jne 0x161a1
subl %eax, %ecx
movl $0x0, 0x131ed(%rip) # 0x29380
movl %edx, 0x13227(%rip) # 0x293c0
movl %ecx, 0x13261(%rip) # 0x... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_steal_random_WRAP | VOID_TASK_0(lace_steal_random)
{
YIELD_NEWFRAME();
if (unlikely(atomic_load_explicit(&external_task, memory_order_acquire) != 0)) {
lace_steal_external(__lace_worker, __lace_dq_head);
} else if (n_workers > 1) {
Worker *victim = workers[(__lace_worker->worker + 1 + rng(&__lace_worker->seed,... | jmp 0x165dc
| /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_steal_random_CALL | VOID_TASK_0(lace_steal_random)
{
YIELD_NEWFRAME();
if (unlikely(atomic_load_explicit(&external_task, memory_order_acquire) != 0)) {
lace_steal_external(__lace_worker, __lace_dq_head);
} else if (n_workers > 1) {
Worker *victim = workers[(__lace_worker->worker + 1 + rng(&__lace_worker->seed,... | pushq %r14
pushq %rbx
pushq %rax
movq 0x12f21(%rip), %rax # 0x29508
movq %rsi, %rbx
movq %rdi, %r14
testq %rax, %rax
jne 0x16655
movq 0x12eff(%rip), %rax # 0x294f8
testq %rax, %rax
jne 0x16662
movl 0x12d3c(%rip), %ecx # 0x29340
cmpl $0x2, %ecx
jb 0x1664d
imull $0x41c64e6d, 0x28(%r14), %eax # imm = 0x41C64E6... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_get_pu_count | unsigned int
lace_get_pu_count(void)
{
#ifdef WIN32
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
unsigned int n_pus = sysinfo.dwNumberOfProcessors;
#elif defined(sched_getaffinity)
cpu_set_t cs;
CPU_ZERO(&cs);
sched_getaffinity(0, sizeof(cs), &cs);
unsigned int n_pus = CPU_COUNT(&cs);
#else... | movl $0x54, %edi
jmp 0x20d0
| /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_worker_thread | static void*
lace_worker_thread(void* arg)
{
int worker = (int)(size_t)arg;
// Initialize data structures
lace_init_worker(worker);
// Pin CPU
lace_pin_worker();
// Wait for the first time we are resumed
sem_wait(&suspend_semaphore);
// Signal that we are running
workers_running ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x161b4
leaq 0x12a1d(%rip), %rdi # 0x29470
callq 0x20c0
lock
incl 0x12a05(%rip) # 0x29464
movq %fs:-0x8, %rbx
movq %rbx, %rdi
callq 0x160aa
movzwl 0x2c(%rbx), %r15d
movq %rax, (%rsp)
movl 0x128c1(%rip), %ebp # 0x2... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_steal_external | static inline void
lace_steal_external(WorkerP *self, Task *dq_head)
{
ExtTask *stolen_task = atomic_exchange(&external_task, NULL);
if (stolen_task != 0) {
// execute task
stolen_task->task->thief = self->_public;
atomic_store_explicit(&stolen_task->task->thief, self->_public, memory_o... | pushq %rbx
xorl %ebx, %ebx
xchgq %rbx, 0x123d0(%rip) # 0x294f8
testq %rbx, %rbx
je 0x1715c
movq 0x18(%rdi), %rax
movq (%rbx), %rcx
movq %rax, %rdx
xchgq %rdx, 0x8(%rcx)
movq %rax, 0x8(%rcx)
movq (%rbx), %rdx
callq *(%rdx)
movq (%rbx), %rax
addq $0x8, %rbx
movq %rbx, %rdi
movq $0x2, 0x8(%rax)
popq %rbx
jmp 0x22a0
po... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.c |
lace_steal | lace_steal(WorkerP *self, Task *__dq_head, Worker *victim)
{
if (victim != NULL && !victim->allstolen) {
TailSplitNA ts;
ts.v = victim->ts.v;
if (ts.ts.tail < ts.ts.split) {
TailSplitNA ts_new;
ts_new.v = ts.v;
ts_new.ts.tail++;
if (atomic_comp... | testq %rdx, %rdx
je 0x17169
cmpb $0x0, 0x10(%rdx)
je 0x1716a
retq
movq 0x8(%rdx), %rcx
movq %rcx, %rax
shrq $0x20, %rax
cmpl %eax, %ecx
jae 0x171c8
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
leal 0x1(%rcx), %r8d
andq %rcx, %rax
orq %rax, %r8
movq %rcx, %rax
lock
cmpxchgq %r8, 0x8(%rdx)
jne 0x17169
pushq... | /trolando[P]sylvan/build_O3/_deps/lace-src/src/lace.h |
check_flag | int check_flag(const char *flag, int argc, char *argv[]) {
// For getopt long options
int index = 0;
// The char returned by getopt()
int option;
// Setting the first character to be a plus
// prevents getopt() from reordering the vector,
// setting the second character to be a colon
// prevents getopt() from p... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movb $0x2b, 0x4d(%rsp)
movb $0x3a, 0x4e(%rsp)
movq 0x68(%rsp), %rax
movb (%rax), %al
movb %al, 0x4f(%rsp)
movq 0x282a(%rip), %rax # 0x3fe0
movl $0x0, (%rax)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
call... | /goldsborough[P]ipc-bench/source/common/arguments.c |
void mp::NLW2_NLFeeder_C_Impl::FeedColNames<mp::StringFileWriter>(mp::StringFileWriter&) | void FeedColNames(ColNameWriter& wrt) {
assert(NLF().FeedColNames);
if (NLF().want_col_names_ && wrt) {
std::function<void(const char*)> wrt_c
= [&wrt](const char* name) {
wrt << name;
};
NLF().FeedColNames(NLF().p_user_data_, &wrt_c);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, 0xa0(%rdi)
je 0x7c4c
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x7946
testb %al, %al
je 0x7c4c
leaq 0x8(%rsp), %rsi
andq $0x0, 0x8(%rsi)
movq %r14, (%rsi)
leaq 0x40(%rip), %rax # 0x7c6a
movq %rax, 0x18(%rsi)
leaq 0x3b(%rip), %rax # 0x7c70
movq ... | /ampl[P]mp/nl-writer2/include/api/c/nl-feeder-c-impl.h |
mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::WriteDualInitialGuesses() | void NLWriter2<Params>::WriteObjAdj(
const std::string& namebase) {
WriteStringVec2File(namebase + ".adj",
[this](StringFileWriter& w){
feeder_.FeedObjAdj(w);
});
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rsp), %rbx
movq %rdi, -0x10(%rbx)
leaq 0x68ed(%rip), %rax # 0x19580
movq %rax, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
andl $0x0, 0x20(%rbx)
movq 0x10(%rdi), %rdi
movq %rsp, %rsi
callq 0x134e4
movq %rbx, %rdi
callq 0x92b0
addq $0... | /ampl[P]mp/nl-writer2/include/mp/nl-writer2.hpp |
mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::SingleSparseVecWrtFactory<int, double>::MakeVectorWriter(unsigned long) | SparseVectorWriter<Index, Value> MakeVectorWriter(size_t nnz) {
assert(0 == nInst_++);
if (fmt_)
nlw_.apr(nlw_.nm, fmt_, (int)nnz);
else if (hdr_prn_)
hdr_prn_(nnz);
else {
assert(0);
}
return {nlw_, nnz};
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x13428
movq (%r15), %rdi
leaq 0x138(%rdi), %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0xddfa
jmp 0x1343a
cmpq $0x0, 0x20(%r15)
je 0x1343a
leaq 0x10(%r15), %rdi
movl %ebx, %esi
callq 0x5d20
movq (%r... | /ampl[P]mp/nl-writer2/include/mp/nl-writer2.h |
void mp::NLFeeder_Easy::FeedColumnSizes<mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::ColSizeWriter>(mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::ColSizeWriter&) | void FeedColumnSizes(ColSizeWriter& csw) {
if (WantColumnSizes())
for (int i=0; i < header_.num_vars-1; ++i)
csw.Write(col_sizes_[VPermInv(i)]);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x1b8(%r14), %rax
decq %rax
cmpq %rax, %r15
jge 0x13894
movq 0x160(%r14), %rax
movq 0x1a0(%r14), %rcx
movslq 0x4(%rax,%r15,8), %rax
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
callq 0x1389a
incq %r15
jmp 0x13862
popq %rbx
popq %r14
p... | /ampl[P]mp/nl-writer2/src/nl-solver.cc |
mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::ColSizeWriter::Write(int) | void Write(int s) {
switch(kind_) {
case 1:
sum_ += s;
nlw_.apr(nlw_.nm, "%z\n", sum_);
break;
case 2:
nlw_.apr(nlw_.nm, "%d\n", s);
break;
default:
assert(0 && "why am I here?");
}
++nWrt_;
} | pushq %rbx
movl %esi, %ecx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
je 0x138d2
cmpl $0x1, %eax
jne 0x138ea
movslq %ecx, %rcx
addq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x138(%rdi), %rsi
leaq 0x5d20(%rip), %rdx # 0x195e9
xorl %eax, %eax
callq 0xddfa
jmp 0x138ea
movq (%rbx), %rdi
... | /ampl[P]mp/nl-writer2/include/mp/nl-writer2.h |
void mp::NLFeeder_Easy::FeedLinearConExpr<mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::SingleSparseVecWrtFactory<int, double>>(int, mp::NLWriter2<mp::NLWriter2Params<mp::TextFormatter, mp::NLFeeder_Easy>>::SingleSparseVecWrtFactory<int, double>&) | void FeedLinearConExpr(int i, ConLinearExprWriterFactory& svw) {
auto A = NLME().GetA();
assert(!A.num_nz_ || NLW2_MatrixFormatRowwise == A.format_);
assert(NLME().NumRows() == A.num_colrow_);
auto start = A.start_[i];
auto end = (i < A.num_colrow_-1) ? A.start_[i+1] : A.num_nz_;
if (start!=end)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %eax
leaq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdi
movslq %esi, %rsi
leaq (%rdi,%rsi,8), %rdi
addq $0x8, %rdi
decl %eax
cmpl %esi, %eax
cmovgq %rdi, %rcx
movq -0x8(%rdi), %r15
movq (%rcx), %r12
movq %r12, %... | /ampl[P]mp/nl-writer2/src/nl-solver.cc |
mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::WriteUnusedVarNames(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void NLWriter2<Params>::WriteUnusedVarNames(
const std::string& namebase) {
maxLen_UnvName_ =
WriteStringVec2File(namebase + ".unv",
[this](StringFileWriter& w){
feeder_.FeedUnusedVarNames(w);
});
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x5552(%rip), %rdx # 0x19469
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x754a
leaq 0x8(%rsp), %rdx
andq $0x0, 0x8(%rdx)
movq %rbx, (%rdx)
leaq 0x558(%rip), %rax # 0x14490
movq %rax, 0x18(%rdx)
leaq 0x54f(%rip), %rax # 0x14492
movq %rax, 0x10... | /ampl[P]mp/nl-writer2/include/mp/nl-writer2.hpp |
mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::WriteVarBounds() | void NLWriter2<Params>::WriteVarBounds() {
apr(nm, "b\t#%d bounds (on variables)\n",
(int)Hdr().num_vars);
VarBndWriter vbw(*this);
Feeder().FeedVarBounds(vbw);
assert((int)Hdr().num_vars == vbw.GetNWritten());
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x130(%rdi), %rsi
movl 0x10(%rdi), %ecx
leaq 0x4b93(%rip), %rdx # 0x19502
xorl %eax, %eax
callq 0xe20e
movq %rsp, %rsi
movq %rbx, (%rsi)
andl $0x0, 0x8(%rsi)
movq 0x8(%rbx), %rdi
callq 0x1502e
addq $0x10, %rsp
popq %rbx
retq
nop
| /ampl[P]mp/nl-writer2/include/mp/nl-writer2.hpp |
mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::WriteColumnSizes() | void NLWriter2<Params>::WriteColumnSizes() {
switch(Feeder().WantColumnSizes()) {
case 1:
apr(nm,
#ifdef NL_LIB2_ORIG_HDR
"k%d\t#intermediate Jacobian column lengths\n",
#else
"k%d\t#intermediate Jacobian column lengths (cumulative)\n",
#endif
Hdr().num_vars + Hdr().num_rand_vars - 1);
{... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x130(%rdi), %rsi
movl 0x10(%rdi), %eax
movl 0x28(%rdi), %ecx
addl %eax, %ecx
decl %ecx
leaq 0x49a1(%rip), %rdx # 0x195b1
xorl %eax, %eax
callq 0xe20e
movq %rsp, %rsi
movq %rbx, (%rsi)
movl $0x1, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
movq 0x8(%rbx), ... | /ampl[P]mp/nl-writer2/include/mp/nl-writer2.hpp |
void mp::NLFeeder_Easy::FeedVarBounds<mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::VarBndWriter>(mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::VarBndWriter&) | void FeedVarBounds(VarBoundsWriter& vbw) {
auto vars = NLME().ColData();
for (int i = 0; i < header_.num_vars; i++)
vbw.WriteLbUb(vars.lower_[VPermInv(i)],
vars.upper_[VPermInv(i)]);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
xorl %r13d, %r13d
movslq 0x1b8(%r14), %rax
cmpq %rax, %r13
jge 0x15079
movq 0x160(%r14), %rax
movslq 0x4(%rax,%r13,8), %rax
movsd (%r15,%rax,8), %xmm0
movsd (%r12,%rax,8), %xmm1
movq %rbx, ... | /ampl[P]mp/nl-writer2/src/nl-solver.cc |
void mp::NLFeeder_Easy::FeedObjExpression<mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::ExprArgWriter>(int, mp::NLWriter2<mp::NLWriter2Params<mp::BinaryFormatter, mp::NLFeeder_Easy>>::ExprArgWriter&) | NLW2_SparseMatrix_C Hessian() const { return Q_; } | movq 0xa0(%rdi), %rcx
movsd 0x80(%rdi), %xmm0
testq %rcx, %rcx
je 0x154ab
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %rbp
movq 0xb0(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0xb8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp... | /ampl[P]mp/nl-writer2/include/mp/nl-model.h |
mp::SOLReader2<mp::SOLHandler_Easy>::sufheadcheck(mp::SufRead*) | int SOLReader2<SOLHandler>::sufheadcheck(SufRead* sr) {
int n;
n = (int)sr->h.n;
if (sr->h.kind < 0 || sr->h.kind > 15 || n < 0 || sr->h.namelen < 2
|| sr->h.tablen < 0)
return 1;
i = (int)sr->h.kind & 3;
if (sr->h.tablen
&& (sr->tablines > sr->h.tablen + 1 || sr->tablines < 1))
return 1;
sr-... | pushq %rbx
movq %rsi, %rbx
movl 0x8(%rsi), %esi
pushq $0x1
popq %rax
testl %esi, %esi
js 0x17b7d
cmpl $0xf, %esi
ja 0x17b7d
cmpl $0x0, 0xc(%rbx)
js 0x17b7d
movl 0x10(%rbx), %ecx
cmpl $0x2, %ecx
jl 0x17b7d
movl 0x14(%rbx), %edx
testl %edx, %edx
js 0x17b7d
andl $0x3, %esi
movl %esi, 0x410(%rdi)
testl %edx, %edx
je 0x17b4... | /ampl[P]mp/nl-writer2/include/mp/sol-reader2.hpp |
bool mp::SOLReader2<mp::SOLHandler_Easy>::CheckReader<mp::SuffixReader<double>>(mp::SuffixReader<double> const&, NLW2_SOLReadResultCode&) | bool CheckReader(const Reader& rd, NLW2_SOLReadResultCode& rr) {
if (NLW2_SOLRead_Early_EOF == rd.ReadResult())
return (rr=ReportEarlyEof(), false);
if (NLW2_SOLRead_Bad_Line == rd.ReadResult())
return (rr=ReportBadLine(rd.ErrorMessage()), false);
if (rd.Size()) { // unfinished
serro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%rsi), %eax
cmpl $0x4, %eax
je 0x17ba5
cmpl $0x2, %eax
jne 0x17bb6
movq %r14, %rdi
callq 0x16d56
jmp 0x17bf6
addq $0x18, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x16d94
jmp 0x17bf6
cmpl $0x0, 0xc(%r15)
je 0x17bd8
leaq 0x1bab(%... | /ampl[P]mp/nl-writer2/include/mp/sol-reader2.h |
bool mp::SOLReader2<mp::SOLHandler_Easy>::CheckReader<mp::SuffixReader<int>>(mp::SuffixReader<int> const&, NLW2_SOLReadResultCode&) | bool CheckReader(const Reader& rd, NLW2_SOLReadResultCode& rr) {
if (NLW2_SOLRead_Early_EOF == rd.ReadResult())
return (rr=ReportEarlyEof(), false);
if (NLW2_SOLRead_Bad_Line == rd.ReadResult())
return (rr=ReportBadLine(rd.ErrorMessage()), false);
if (rd.Size()) { // unfinished
serro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x10(%rsi), %eax
cmpl $0x4, %eax
je 0x17c29
cmpl $0x2, %eax
jne 0x17c3a
movq %r14, %rdi
callq 0x16d56
jmp 0x17c7a
addq $0x18, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x16d94
jmp 0x17c7a
cmpl $0x0, 0xc(%r15)
je 0x17c5c
leaq 0x1b27(%... | /ampl[P]mp/nl-writer2/include/mp/sol-reader2.h |
Process::getEnvironmentVariables() | Map<String, String> Process::getEnvironmentVariables()
{
#ifdef _WIN32
Map<String, String> result;
LPTCH environmentStrings = GetEnvironmentStrings();
if (!environmentStrings)
return result;
struct Guard
{
LPTCH _environmentStrings;
~Guard() { FreeEnvironmentStrings(_environmentStrings); }
} gua... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x7530(%rip), %rbp # 0xb4d8
movq %rbp, 0x20(%rdi)
movq %rbp, 0x48(%rdi)
movq $0x0, 0x70(%rdi)
movups %xmm0... | /craflin[P]libnstd/src/Process.cpp |
wrap_new_MersenneEngine4__SWIG_0 | SWIGEXPORT SwigClassWrapper _wrap_new_MersenneEngine4__SWIG_0() {
SwigClassWrapper fresult ;
std::mt19937 *result = 0 ;
result = (std::mt19937 *)new std::mt19937();
fresult.cptr = (void*)result;
fresult.cmemflags = SWIG_MEM_RVALUE | (1 ? SWIG_MEM_OWN : 0);
return fresult;
} | pushq %rax
movl $0x1388, %edi # imm = 0x1388
callq 0x4200
movq $0x1571, (%rax) # imm = 0x1571
movl $0x1, %ecx
movl $0x1571, %edx # imm = 0x1571
movq %rdx, %rsi
shrq $0x1e, %rsi
xorl %edx, %esi
imull $0x6c078965, %esi, %edx # imm = 0x6C078965
addl %ecx, %edx
movq %rdx, (%rax,%rcx,8)
incq %rcx... | /swig-fortran[P]flibcpp/src/flc_randomFORTRAN_wrap.cxx |
wrap_new_MersenneEngine4__SWIG_1 | SWIGEXPORT SwigClassWrapper _wrap_new_MersenneEngine4__SWIG_1(int32_t const *farg1) {
SwigClassWrapper fresult ;
std::mt19937::result_type arg1 ;
std::mt19937 *result = 0 ;
arg1 = (std::mt19937::result_type)(*farg1);
result = (std::mt19937 *)new std::mt19937(arg1);
fresult.cptr = (void*)result;
fresult... | pushq %rbx
movl (%rdi), %ebx
movl $0x1388, %edi # imm = 0x1388
callq 0x4200
movq %rbx, (%rax)
movl $0x1, %ecx
movq %rbx, %rdx
shrq $0x1e, %rdx
xorl %ebx, %edx
imull $0x6c078965, %edx, %ebx # imm = 0x6C078965
addl %ecx, %ebx
movq %rbx, (%rax,%rcx,8)
incq %rcx
cmpq $0x270, %rcx # imm = 0x270
jne 0x4b... | /swig-fortran[P]flibcpp/src/flc_randomFORTRAN_wrap.cxx |
wrap_MersenneEngine4_seed | SWIGEXPORT void _wrap_MersenneEngine4_seed(SwigClassWrapper *farg1, int32_t const *farg2) {
std::mt19937 *arg1 = (std::mt19937 *) 0 ;
std::mt19937::result_type arg2 ;
SWIG_check_nonnull(farg1->cptr, "std::mt19937 *", "MersenneEngine4", "std::mt19937::seed(std::mt19937::result_type)", return );
arg1 = (std::m... | movq (%rdi), %rax
testq %rax, %rax
je 0x4ba6
movl (%rsi), %ecx
movq %rcx, (%rax)
movl $0x1, %edx
movq %rcx, %rsi
shrq $0x1e, %rsi
xorl %ecx, %esi
imull $0x6c078965, %esi, %ecx # imm = 0x6C078965
addl %edx, %ecx
movq %rcx, (%rax,%rdx,8)
incq %rdx
cmpq $0x270, %rdx # imm = 0x270
jne 0x4b79
movq $0x270, 0x1380(... | /swig-fortran[P]flibcpp/src/flc_randomFORTRAN_wrap.cxx |
wrap_MersenneEngine4_next | SWIGEXPORT int32_t _wrap_MersenneEngine4_next(SwigClassWrapper *farg1) {
int32_t fresult ;
std::mt19937 *arg1 = (std::mt19937 *) 0 ;
std::mt19937::result_type result;
SWIG_check_nonnull(farg1->cptr, "std::mt19937 *", "MersenneEngine4", "std::mt19937::operator ()()", return 0);
arg1 = (std::mt19937 *)farg1-... | pushq %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4bf6
callq 0x41a0
jmp 0x4c10
leaq 0x2572(%rip), %rdi # 0x716f
leaq 0x24fa(%rip), %rdx # 0x70fe
movl $0xfffffff3, %esi # imm = 0xFFFFFFF3
callq 0x43c0
xorl %eax, %eax
popq %rcx
retq
| /swig-fortran[P]flibcpp/src/flc_randomFORTRAN_wrap.cxx |
wrap_new_MersenneEngine8__SWIG_0 | SWIGEXPORT SwigClassWrapper _wrap_new_MersenneEngine8__SWIG_0() {
SwigClassWrapper fresult ;
std::mt19937_64 *result = 0 ;
result = (std::mt19937_64 *)new std::mt19937_64();
fresult.cptr = (void*)result;
fresult.cmemflags = SWIG_MEM_RVALUE | (1 ? SWIG_MEM_OWN : 0);
return fresult;
} | pushq %rax
movl $0x9c8, %edi # imm = 0x9C8
callq 0x4200
movq $0x1571, (%rax) # imm = 0x1571
movl $0x1, %ecx
movl $0x1571, %edi # imm = 0x1571
movabsq $0x5851f42d4c957f2d, %rdx # imm = 0x5851F42D4C957F2D
movq %rdi, %rsi
shrq $0x3e, %rsi
xorq %rdi, %rsi
imulq %rdx, %rsi
addq %rcx, %rsi
movq %... | /swig-fortran[P]flibcpp/src/flc_randomFORTRAN_wrap.cxx |
SUNLinSolSetup_Band | int SUNLinSolSetup_Band(SUNLinearSolver S, SUNMatrix A)
{
SUNFunctionBegin(S->sunctx);
sunrealtype** A_cols;
sunindextype* pivots;
SUNAssert(A, SUN_ERR_ARG_CORRUPT);
SUNAssert(SUNMatGetID(A) == SUNMATRIX_BAND, SUN_ERR_ARG_WRONGTYPE);
/* access data pointers (return with failure on NULL) */
A_cols = NULL... | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x40(%rax), %rdi
movq (%rbx), %rcx
movq 0x8(%rcx), %r9
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq 0x28(%rax), %r8
callq 0x1090
movq (%rbx), %rcx
movq %rax, 0x10(%rcx)
xorl %ecx, %ecx
testq %rax, %rax
movl $0x328, %eax # imm = 0x328
... | /opencor[P]sundials/src/sunlinsol/band/sunlinsol_band.c |
ZydisBuildInstruction | static ZyanStatus ZydisBuildInstruction(ZydisEncoderInstructionMatch *match,
ZydisEncoderInstruction *instruction)
{
ZYAN_MEMSET(instruction, 0, sizeof(ZydisEncoderInstruction));
instruction->attributes = match->attributes;
instruction->encoding = match->definition->encoding;
instruction->opcode_map... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xe080
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movw 0x6(%rax), %ax
andw $0x7, %ax... | /zyantific[P]zydis/src/Encoder.c |
ZyanAbsI64 | ZYAN_INLINE ZyanU64 ZyanAbsI64(ZyanI64 x)
{
// INT_MIN special case. Can't use the value directly because GCC thinks
// it's too big for an INT64 literal, however is perfectly happy to accept
// this expression. This is also hit INT64_MIN is defined in `stdint.h`.
if (x == (-0x7fffffffffffffff - 1))
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x10(%rbp)
jne 0x25e28
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x8(%rbp)
jmp 0x25e4b
cmpq $0x0, -0x10(%rbp)
jge 0x25e3b
xorl %eax, %eax
subq -0x10(%rbp), %rax
mov... | /zyantific[P]zydis/dependencies/zycore/include/Zycore/Format.h |
testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x2c2a(%rip), %rsi # 0x790b0
movq %rsi, %rdi
callq 0x79040
movq %rax, -0x18(%rbp)
leaq 0x2c27(%rip), %rsi # 0x790c0
movq %rsi, %rdi
callq 0x79040
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /yohhoy[P]yamc/build_O0/external/include/gtest/internal/gtest-internal.h |
yamc::barrier<yamc::detail::default_barrier_completion>::arrive_and_wait() | void arrive_and_wait()
{
// equivalent to wait(arrive())
std::unique_lock<decltype(mtx_)> lk(mtx_);
assert(0 < counter_);
auto arrival_phase = phase_;
counter_ -= 1;
if (counter_ == 0) {
phase_completion_step(false);
}
while (phase_ <= arrival_phase) {
cv_.wait(lk);
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x48, %rsi
leaq -0x18(%rbp), %rdi
callq 0x79730
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
jge 0x7701f
jmp 0x7703e
leaq 0x5209d(%rip), %rdi # 0xc90c3
leaq 0x51d4c(%rip), %rsi # 0... | /yohhoy[P]yamc/include/yamc_barrier.hpp |
fmt::v9::detail::float_specs fmt::v9::detail::parse_float_type_spec<fmt::v9::detail::error_handler, char>(fmt::v9::basic_format_specs<char> const&, fmt::v9::detail::error_handler&&) | FMT_CONSTEXPR auto parse_float_type_spec(const basic_format_specs<Char>& specs,
ErrorHandler&& eh = {})
-> float_specs {
auto result = float_specs();
result.showpoint = specs.alt;
result.locale = specs.localized;
switch (specs.type) {
case presentation_type::none:
... | movzbl 0x8(%rdi), %edx
cmpq $0xe, %rdx
ja 0x21a38
movzwl 0x9(%rdi), %eax
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x1, %ecx
movl %ecx, %esi
shll $0x13, %esi
shll $0x9, %eax
andl $0x20000, %eax # imm = 0x20000
orl %esi, %eax
leaq 0x577fc(%rip), %rsi # 0x791d4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%r... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h |
std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode) | SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %edx, (%r14)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x17940
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37aa4
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h |
std::shared_ptr<spdlog::logger> spdlog::stderr_color_st<spdlog::async_factory_impl<(spdlog::async_overflow_policy)0>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, spdlog::color_mode) | SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name, color_mode mode)
{
return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movl %edx, (%r14)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x17940
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37cb6
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/sinks/stdout_color_sinks-inl.h |
spdlog::details::mpmc_blocking_queue<spdlog::details::async_msg>::dequeue_for(spdlog::details::async_msg&, std::chrono::duration<long, std::ratio<1l, 1000l>>) | bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
{
{
std::unique_lock<std::mutex> lock(queue_mutex_);
if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
{
return false;
}
popp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %rdx, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3ae40
leaq 0x28(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3afe0
movl %eax, %ebp
testb %al... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/details/mpmc_blocking_q.h |
fmt::v9::detail::format_error_code(fmt::v9::detail::buffer<char>&, int, fmt::v9::basic_string_view<char>) | FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
string_view message) noexcept {
// Report error code making sure that the output fits into
// inline_buffer_size to avoid dynamic memory allocation and potential
// bad_alloc.
out.try_resize(0);
static c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
xorl %esi, %esi
callq 0x1e264
movl %ebp, %eax
negl %eax
cmovsl %ebp, %eax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leaq 0x42076(%rip), %rdx # 0x7d1f0
addq (%rdx,%rcx,8), %rax
shrq $0x20... | /njoy[P]ENDFtk/build_O2/_deps/spdlog-src/include/spdlog/fmt/bundled/format-inl.h |
Protocol::MQTT::V5::Property<Protocol::MQTT::Common::VBInt>::dump(Bstrlib::String&, int) | void dump(MQTTString & out, const int indent = 0)
{
out += MQTTStringPrintf("%*sType %s\n", indent, "", PrivateRegistry::getPropertyName(type));
value.dump(out, indent + 2);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x8(%rdi), %eax
cmpq $0x2a, %rax
ja 0x8b25
movabsq $0x16811f4f1, %rcx # imm = 0x16811F4F1
btq %rax, %rcx
jb 0x8b25
leaq 0xcc4c(%rip), %rcx # 0x15760
movzbl (%rax,%rcx), %eax
leaq 0x167e1(%rip), ... | /X-Ryl669[P]eMQTT5/lib/include/Protocol/MQTT/MQTT.hpp |
Protocol::MQTT::V5::TypedProperty<(Protocol::MQTT::V5::PropertyType)17, unsigned int>::allocateProp() | static PropertyBase * allocateProp() { return new Property<T>(type, T(), true) ; } | pushq %rax
movl $0x38, %edi
callq 0x5210
leaq 0x28(%rax), %rcx
movb $0x11, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x1, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x16ad6(%rip), %rcx # 0x1f748
movq %rcx, (%rax)
leaq 0x16b3c(%rip), %rcx # 0x1f7b8
movq %rcx, 0x28(%rax)
movl $0x0, 0x30(%rax)
popq %rcx
retq
nop
| /X-Ryl669[P]eMQTT5/lib/include/Protocol/MQTT/MQTT.hpp |
Protocol::MQTT::V5::Property<Protocol::MQTT::Common::DynamicStringPair>::acceptVisitor(Protocol::MQTT::V5::VisitorVariant&) const | bool acceptVisitor(VisitorVariant & visitor) const
{
if (!PropertyBase::acceptVisitor(visitor)) return false;
DynamicStringPairView * view = visitor.as<DynamicStringPairView>();
if (!view) return false;
view->key = value.key... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x77e0
movzbl 0x8(%r14), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x77fe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /X-Ryl669[P]eMQTT5/lib/include/Protocol/MQTT/MQTT.hpp |
Protocol::MQTT::V5::Property<Protocol::MQTT::Common::DynamicStringPair>::~Property() | struct Property<DynamicStringPair> Final : public PropertyBase
{
/** The property value, depends on the type */
DynamicStringPair value;
/** This give the size required for serializing this property header in bytes */
uint32 getSize() const ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3d(%rdi), %rdi
callq 0x52b0
xorl %ebp, %ebp
movw %bp, 0x3b(%rbx)
movq 0x2b(%rbx), %rdi
callq 0x52b0
movw %bp, 0x29(%rbx)
movl $0x48, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5220
nop
| /X-Ryl669[P]eMQTT5/lib/include/Protocol/MQTT/MQTT.hpp |
Bstrlib::String::String() | String::String()
{
slen = 0; mlen = 8;
data = (unsigned char*)malloc(mlen);
if (!data)
{
mlen = 0;
bstringThrow("Failure in default constructor");
}
else data[0] = '\0';
} | pushq %rbx
movq %rdi, %rbx
movq $0x8, (%rdi)
movl $0x8, %edi
callq 0x52f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xa87f
movb $0x0, (%rax)
popq %rbx
retq
movq %rbx, %rdi
callq 0x5460
jmp 0xa87d
nop
| /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::String(char, int) | String::String(char c, int len)
{
slen = mlen = 0; data = 0;
if (len >= 0)
{
mlen = len + 1;
slen = len;
data = (uint8 * ) malloc(mlen);
}
if (!data)
{
mlen = slen = 0;
bstringThrow("Failure in repeat(char) c... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
testl %edx, %edx
js 0xa94f
leal 0x1(%rdx), %edi
movl %edi, (%rbx)
movl %edx, 0x4(%rbx)
callq 0x52f0
movq %rax, 0x8(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa97d
movslq 0x4(%rbx), %rdx
testq %rdx, %rdx
jle 0x... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::operator+=(float) | const String& String::operator +=(const float c)
{
#ifndef HasFloatParsing
char buffer[15] = { 0 };
ftoa(c, buffer, 6);
return *this += buffer;
#else
return *this += String::Print("%lg", c);
#endif
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
leaq 0xae26(%rip), %rsi # 0x162f9
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movb $0x1, %al
callq 0xb78e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xafb6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xb505
callq 0x52b0
movq $0x0, 0x10(%rsp)
movq %rbx,... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::parseInt(int, int*) const | int64 String::parseInt(int base, int * endPos) const
{
const char * text = (const char*)data;
if (!slen) { if (endPos) *endPos = 0; return 0; }
bool negative = text[0] == '-';
text += (int)negative;
const char baseText[] = "0123456789abcdef", BASEText[] = "0123456789ABCDEF";
... | cmpl $0x0, 0x4(%rdi)
je 0xba11
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdx, 0x10(%rsp)
movq 0x8(%rdi), %rdx
movb (%rdx), %cl
xorl %eax, %eax
movb %cl, 0x7(%rsp)
cmpb $0x2d, %cl
sete %al
movq %rdx, 0x8(%rsp)
addq %rdx, %rax
movaps 0xabd6(%rip), %xmm0 #... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::Find(char const*, int) const | int String::Find(const char * b, int pos) const
{
int i, j;
if (NULL == b) return BSTR_ERR;
if ((unsigned int) pos > (unsigned int) slen)
return BSTR_ERR;
if ('\0' == b[0]) return pos;
if (pos == slen) return BSTR_ERR;
i = pos;
... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0xc1f5
movslq 0x4(%rdi), %rcx
cmpl %edx, %ecx
jb 0xc1f5
cmpb $0x0, (%rsi)
je 0xc1f3
cmpl %edx, %ecx
je 0xc1f5
movslq %edx, %rdx
movq 0x8(%rdi), %rdi
addq %rdx, %rdi
xorl %r8d, %r8d
leaq (%rdx,%r8), %r9
cmpq %rcx, %r9
jge 0xc1f5
movb (%rsi,%r8), %r9b
cm... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::caselessFind(char const*, int) const | int String::caselessFind(const char * b, int pos) const
{
struct tagbstring t;
if (NULL == b) return BSTR_ERR;
if ((unsigned int) pos > (unsigned int) slen) return BSTR_ERR;
if ('\0' == b[0]) return pos;
if (pos == slen) return BSTR_ERR;
bt... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0xc264
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movl 0x4(%rdi), %ecx
cmpl %edx, %ecx
jb 0xc25b
cmpb $0x0, (%rsi)
je 0xc259
cmpl %ebx, %ecx
je 0xc25b
movq %rsp, %r15
movq %rsi, 0x8(%r15)
movq %rsi, %rdi
callq 0x5... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Bstrlib::String::splitWhenNoMore(Bstrlib::String const&) | const String String::splitWhenNoMore(const String & set)
{
int pos = invFindAnyChar(set);
String ret = midString(0, pos == -1 ? slen : pos);
if (BSTR_ERR == bdelete(this, 0, ret.slen)) bstringThrow("Failure in remove");
return ret;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1272b
cmpl $-0x1, %eax
jne 0xd635
movl 0x4(%r14), %eax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %eax, %ecx
callq 0xc5d2
movl 0x4(%rbx), %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x11c8e
cmpl $-0x1, %eax... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrwrap.cpp |
Threading::Event::_Reset() volatile | bool Threading::Event::_Reset() volatile
{
#ifndef _POSIX
unsigned portLONG ulVar = 0;
// Instant wait of the state but only one value in the queue
portBASE_TYPE result = xQueueReceive(xQueue, &ulVar, 0);
// Don't care of the state of the queue
return true;
#else
bool isOkay = false;
//... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5360
movl %eax, %ebp
testl %eax, %eax
jne 0xde6e
movb $0x0, 0x29(%rbx)
leaq 0x30(%rbx), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x5170
testl %ebp, %ebp
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /X-Ryl669[P]eMQTT5/tests/ClassPath/src/Lock.cpp |
bstricmp | int bstricmp (const bstring b0, const bstring b1) {
int i, v, n;
if (bdata (b0) == NULL || b0->slen < 0 ||
bdata (b1) == NULL || b1->slen < 0) return SHRT_MIN;
if ((n = b0->slen) > b1->slen) n = b1->slen;
else if (b0->slen == b1->slen && b0->data == b1->data) return 0;
for (i = 0; i < n; i ++) {
... | movl $0xffff8000, %eax # imm = 0xFFFF8000
testq %rdi, %rdi
je 0x11915
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x11907
movl 0x4(%rdi), %edi
testl %edi, %edi
sets %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x11907
movq 0x8(%rsi)... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bltrimws | int bltrimws (bstring b) {
int i, len;
if (b == NULL || b->data == NULL || b->mlen < b->slen ||
b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
for (len = b->slen, i = 0; i < len; i++) {
if (!wspace (b->data[i])) {
return bdelete (b, 0, i);
}
}
b->data[0] = (unsigned char) '\0';
b->slen =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x11c6e
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x11c6e
movl (%rbx), %ecx
testl %ecx, %ecx
jle 0x11c6e
movl 0x4(%rbx), %r12d
cmpl %r12d, %ecx
jl 0x11c6e
testl %r12d, %r12d
js 0x11c... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bdelete | int bdelete (bstring b, int pos, int len) {
/* Clamp to left side of bstring */
if (pos < 0) {
len += pos;
pos = 0;
}
if (len < 0 || b == NULL || b->data == NULL || b->slen < 0 ||
b->mlen < b->slen || b->mlen <= 0)
return BSTR_ERR;
if (len > 0 && pos < b->slen) {
if (pos + len >= b->slen... | pushq %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
cmovsl %esi, %r14d
addl %edx, %r14d
sets %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jne 0x11d1f
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x11d1f
movl 0x4(... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
brtrimws | int brtrimws (bstring b) {
int i;
if (b == NULL || b->data == NULL || b->mlen < b->slen ||
b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
for (i = b->slen - 1; i >= 0; i--) {
if (!wspace (b->data[i])) {
if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
b->slen = i + 1;
return 0;
}
... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x11d9e
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x11d96
movl (%rbx), %ebp
testl %ebp, %ebp
jle 0x11d96
movl 0x4(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x11d96
testl %ecx, %ecx
js 0x11d96
t... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
btrimws | int btrimws (bstring b) {
int i, j;
if (b == NULL || b->data == NULL || b->mlen < b->slen ||
b->slen < 0 || b->mlen <= 0) return BSTR_ERR;
for (i = b->slen - 1; i >= 0; i--) {
if (!wspace (b->data[i])) {
if (b->mlen > i) b->data[i+1] = (unsigned char) '\0';
b->slen = i + 1;
for (j = 0; wsp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x11e4f
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x11e4f
movl (%rbx), %ebp
testl %ebp, %ebp
jle 0x11e4f
movl 0x4(%rbx), %ecx
cmpl %ecx, %ebp
jl 0x11e4f
testl %ecx, %ecx
js 0x11e4f
t... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
biseq | int biseq (const bstring b0, const bstring b1) {
if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
b0->slen < 0 || b1->slen < 0) return BSTR_ERR;
if (b0->slen != b1->slen) return 0;
if (b0->data == b1->data || b0->slen == 0) return 1;
return !memcmp (b0->data, b1->data, b0->slen);
} | movq %rsi, %rcx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %sil
orb %al, %sil
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jne 0x11ed8
movq %rdi, %rdx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x11ed8
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x11ed8
movslq 0x4(%rdx), %rdx
testq %rdx, %rdx
js 0x11ed8
movl 0x4(%rc... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bisstemeqblk | int bisstemeqblk (const bstring b0, const void * blk, int len) {
int i;
if (bdata (b0) == NULL || b0->slen < 0 || NULL == blk || len < 0)
return BSTR_ERR;
if (b0->slen < len) return 0;
if (b0->data == (const unsigned char *) blk || len == 0) return 1;
for (i = 0; i < len; i ++) {
if (b0->data[i] != (... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x11f38
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x11f38
movl 0x4(%rdi), %edi
testq %rsi, %rsi
sete %r8b
movl %edi, %r9d
orl %edx, %r9d
sets %r9b
orb %r8b, %r9b
jne 0x11f38
xorl %eax, %eax
cmpl %edx, %edi
jl 0x11f38
cmpq %rsi, %rcx
sete %dil
testl %edx... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
biseqcstrcaseless | int biseqcstrcaseless (const bstring b, const char * s) {
int i;
if (b == NULL || s == NULL || b->data == NULL || b->slen < 0) return BSTR_ERR;
for (i=0; i < b->slen; i++) {
if (s[i] == '\0' ||
(b->data[i] != (unsigned char) s[i] &&
downcase (b->data[i]) != (unsigned char) downcase (s[i])))
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jne 0x1203e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x12030
movl 0x4(%rdi), %r15d
testl %r15d, %r15d
js 0x12030
movq %rsi, %rbx
t... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bstrcmp | int bstrcmp (const bstring b0, const bstring b1) {
int i, v, n;
if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
n = b0->slen; if (n > b1->slen) n = b1->slen;
if (b0->slen == b1->slen && (b0->data == b1->data || b0->slen == 0))
return ... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffff8000, %eax # imm = 0xFFFF8000
jne 0x120c4
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x120c4
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x120c4
movl 0x4(%rdi), %edi
testl %edi, %edi
js 0x120c4
movl 0x4(%rsi), %esi
testl %esi, %esi
js 0x120c4... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bstrncmp | int bstrncmp (const bstring b0, const bstring b1, int n) {
int i, v, m;
if (b0 == NULL || b1 == NULL || b0->data == NULL || b1->data == NULL ||
b0->slen < 0 || b1->slen < 0) return SHRT_MIN;
m = n;
if (m > b0->slen) m = b0->slen;
if (m > b1->slen) m = b1->slen;
if (b0->data != b1->data) {
for (i = ... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffff8000, %eax # imm = 0xFFFF8000
jne 0x1216a
movq 0x8(%rdi), %r8
testq %r8, %r8
je 0x1216a
movq 0x8(%rsi), %r9
testq %r9, %r9
je 0x1216a
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
js 0x1216a
movl 0x4(%rsi), %esi
testl %esi, %esi
js 0x1216a
pushq... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bmidstr | bstring bmidstr (const bstring b, int left, int len) {
if (b == NULL || b->slen < 0 || b->data == NULL) return NULL;
if (left < 0) {
len += left;
left = 0;
}
if (len > b->slen - left) len = b->slen - left;
if (len <= 0) return bfromcstr ("");
return blk2bstr (b->data + left, len);
} | testq %rdi, %rdi
je 0x121ad
movl %esi, %eax
movl 0x4(%rdi), %esi
testl %esi, %esi
js 0x121ad
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x121ad
xorl %r8d, %r8d
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
cmovsl %eax, %r8d
addl %edx, %r8d
subl %ecx, %esi
cmpl %esi, %r8d
cmovll %r8d, %esi
testl %esi, %esi
jle 0x121b... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
binstr | int binstr (const bstring b1, int pos, const bstring b2) {
int j, i, l, ll;
unsigned char * d0, * d1;
if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
if (b1->slen == pos) return (b2->slen == 0)?pos:BSTR_ERR;
if (b1->slen < pos || pos... | testq %rdi, %rdi
je 0x12207
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x12207
movl 0x4(%rdi), %edi
testl %edi, %edi
sets %al
testq %rdx, %rdx
sete %r8b
orb %al, %r8b
jne 0x12207
movq 0x8(%rdx), %r8
testq %r8, %r8
je 0x12207
movl 0x4(%rdx), %edx
testl %edx, %edx
js 0x12207
cmpl %esi, %edi
jne 0x121fb
xorl %eax, %eax
negl... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
binstrrcaseless | int binstrrcaseless (const bstring b1, int pos, const bstring b2) {
int j, i, l;
unsigned char * d0, * d1;
if (b1 == NULL || b1->data == NULL || b1->slen < 0 ||
b2 == NULL || b2->data == NULL || b2->slen < 0) return BSTR_ERR;
if (b1->slen == pos && b2->slen == 0) return pos;
if (b1->slen < pos || pos < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x1253b
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1253b
movl %esi, %ebx
movl 0x4(%rdi), %eax
testl %eax, %eax
sets %cl
testq %rdx, %rdx
sete %sil
orb %cl, %sil
jne 0x12... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
binchr | int binchr (const bstring b0, int pos, const bstring b1) {
struct charField chrs;
if (pos < 0 || b0 == NULL || b0->data == NULL ||
b0->slen <= pos) return BSTR_ERR;
if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
return binchrCF (b0->data, b0->slen, pos, &chrs);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jne 0x12637
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x12637
movl %esi, %ebp
movl 0x4(%rdi), %r15d
cmpl %esi, %r15d
jle 0x12637
leaq 0x8(%rsp), %r... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bninchrr | int bninchrr (const bstring b0, int pos, const bstring b1) {
struct charField chrs;
if (pos < 0 || b0 == NULL || b0->data == NULL ||
b0->slen < pos) return BSTR_ERR;
if (pos == b0->slen) pos--;
if (buildCharField (&chrs, b1) < 0) return BSTR_ERR;
invertCharField (&chrs);
return binchrrCF (b0->data, po... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jne 0x1283d
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x1283d
movl %esi, %r14d
cmpl %esi, 0x4(%rdi)
jl 0x1283d
sete %bpl
leaq 0x8(%rsp), %rdi
movq ... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bsetstr | int bsetstr (bstring b0, int pos, const bstring b1, unsigned char fill) {
int i, d, newlen;
ptrdiff_t pd;
bstring aux = b1;
if (pos < 0 || b0 == NULL || b0->slen < 0 || NULL == b0->data ||
b0->mlen < b0->slen || b0->mlen <= 0) return BSTR_ERR;
if (b1 != NULL && (b1->slen < 0 || b1->data == NULL)) return... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
jne 0x1289a
movq %rdx, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %edx
testl %edx, %edx
js 0x1289a
movq 0x8(%rbx)... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bassigngets | int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator) {
int c, d, e;
if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
d = 0;
e = b->mlen - 2;
while ((c = getcPtr (parm)) >= 0) {
if (d > e) {
b->slen = d;
... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x13535
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ebx
testl %ebx, %ebx
jle 0x13527
movq %rsi, %r12
testq %rsi, %rsi
je 0x13527
cmpl %ebx, 0x4(%r14)
ja 0x13527
movq %rdx, %r15
addl $-0x2, ... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bgetsa | int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator) {
int c, d, e;
if (b == NULL || b->mlen <= 0 || b->slen < 0 || b->mlen < b->slen ||
b->mlen <= 0 || getcPtr == NULL) return BSTR_ERR;
d = b->slen;
e = b->mlen - 2;
while ((c = getcPtr (parm)) >= 0) {
if (d > e) {
b->slen = d;... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x135f2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %ebx
testl %ebx, %ebx
jle 0x135e4
movq %rdx, %r15
movq %rsi, %r12
movl 0x4(%r14), %r13d
cmpl %ebx, %r13d
seta %sil
testq %r12, %r12
sete %... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bsopen | struct bStream * bsopen (bNread readPtr, void * parm) {
struct bStream * s;
if (readPtr == NULL) return NULL;
s = (struct bStream *) bstr__alloc (sizeof (struct bStream));
if (s == NULL) return NULL;
s->parm = parm;
s->buff = bfromcstr ("");
s->readFnPtr = readPtr;
s->maxBuffSz = BS_BUFF_SZ;
s->isEOF... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1369f
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x52f0
testq %rax, %rax
je 0x1369f
movq %rax, %rbx
movq %r15, 0x8(%rax)
leaq 0x3095(%rip), %rdi # 0x16718
callq 0x10f22
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
movabsq $0x40000000000, %rax # imm =... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bsreadlnsa | int bsreadlnsa (bstring r, struct bStream * s, const bstring term) {
int i, l, ret, rlo;
unsigned char * b;
struct tagbstring x;
struct charField cf;
if (s == NULL || s->buff == NULL || r == NULL || term == NULL ||
term->data == NULL || r->mlen <= 0 || r->slen < 0 ||
r->mlen < r->slen) return BSTR_E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x13944
movq %rdx, %r12
testq %rdx, %rdx
je 0x13944
movq %rdi, %r14
testq %rdi, %rdi
je 0x13944
movq %rsi, %r15
movq (%rsi), %r13
testq %r13, %r13
je 0x13944
movq 0x8(%r... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bsplitscb | int bsplitscb (const bstring str, const bstring splitStr, int pos,
int (* cb) (void * parm, int ofs, int len), void * parm) {
struct charField chrs;
int i, p, ret;
if (cb == NULL || str == NULL || pos < 0 || pos > str->slen
|| splitStr == NULL || splitStr->slen < 0) return BSTR_ERR;
if (splitStr->slen == ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %edx, %edx
js 0x142c9
movq %rdi, %r15
testq %rdi, %rdi
je 0x142c9
movq %rcx, %rbx
testq %rcx, %rcx
je 0x142c9
movl %edx, %ebp
movl 0x4(%r15), %edx
cmpl %ebp, %edx
setl %cl
testq %rsi, %rsi
sete ... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.c |
bscb | static int bscb (void * parm, int ofs, int len) {
struct genBstrList * g = (struct genBstrList *)parm;
if (g->bl->qty >= g->mlen) {
int mlen = g->mlen * 2;
struct bstrList * tbl;
while (g->bl->qty >= mlen) mlen += mlen;
tbl = (struct bstrList *) bstr__realloc (g->bl, BLE_SZ + sizeof (bstring) * mlen);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
movl 0x10(%rbx), %r15d
cmpl %r15d, %eax
jl 0x1439a
addl %r15d, %r15d
cmpl %r15d, %eax
jge 0x14375
movslq %r15d, %rax
leaq 0x8(,%rax,8), %rsi
callq 0x53e0
testq %rax, %rax
je 0x1... | /X-Ryl669[P]eMQTT5/tests/ClassPath/src/bstrlib.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.