name string | code string | asm string | file string |
|---|---|---|---|
bitset_container_select | bool bitset_container_select(const bitset_container_t *container, uint32_t *start_rank, uint32_t rank, uint32_t *element) {
int card = bitset_container_cardinality(container);
if(rank >= *start_rank + card) {
*start_rank += card;
return false;
}
const uint64_t *words = container->words;
... | movl (%rsi), %r9d
movl (%rdi), %eax
addl %r9d, %eax
cmpl %edx, %eax
jbe 0x98f1
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r8
xorl %edi, %edi
movabsq $0x5555555555555555, %r10 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r11 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, ... | /RoaringBitmap[P]CRoaring/src/containers/bitset.c |
bitset_container_minimum | uint16_t bitset_container_minimum(const bitset_container_t *container) {
for (int32_t i = 0; i < BITSET_CONTAINER_SIZE_IN_WORDS; ++i ) {
uint64_t w = container->words[i];
if (w != 0) {
int r = roaring_trailing_zeroes(w);
return r + i * 64;
}
}
return UINT16_MAX;
} | movq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq $-0x10000, %rcx # imm = 0xFFFF0000
je 0x9930
movq (%rax), %rdx
testq %rdx, %rdx
jne 0x9935
addq $-0x40, %rcx
addq $0x8, %rax
jmp 0x9915
movw $0xffff, %ax # imm = 0xFFFF
retq
bsfq %rdx, %rax
subl %ecx, %eax
retq
| /RoaringBitmap[P]CRoaring/src/containers/bitset.c |
bitset_container_get_index | inline bool bitset_container_get(const bitset_container_t *bitset,
uint16_t pos) {
const uint64_t word = bitset->words[pos >> 6];
return (word >> (pos & 63)) & 1;
} | movq 0x8(%rdi), %rcx
movl %esi, %r11d
shrl $0x6, %r11d
movq (%rcx,%r11,8), %rax
btq %rsi, %rax
jae 0x9c5f
pushq %r15
pushq %r14
pushq %rbx
andl $0x3f, %esi
xorl %ebx, %ebx
movabsq $0x5555555555555555, %r10 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r9 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f,... | /RoaringBitmap[P]CRoaring/include/roaring/containers/bitset.h |
bitset_container_from_array | bitset_container_t *bitset_container_from_array(const array_container_t *ac) {
bitset_container_t *ans = bitset_container_create();
int limit = array_container_cardinality(ac);
for (int i = 0; i < limit; ++i) bitset_container_set(ans, ac->array[i]);
return ans;
} | pushq %rbx
movq %rdi, %rbx
callq 0x34ce
movl (%rbx), %edx
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
cmpq %rsi, %rdx
je 0x9ceb
movq 0x8(%rbx), %rcx
movq 0x8(%rax), %rdi
movzwl (%rcx,%rsi,2), %ecx
movl %ecx, %r8d
shrl $0x6, %r8d
movq (%rdi,%r8,8), %r9
movq %r9, %r10
btsq %rcx, %r10
xorq %r10, %r9
shrq %cl, %r9
... | /RoaringBitmap[P]CRoaring/src/containers/convert.c |
bitset_container_from_run | bitset_container_t *bitset_container_from_run(const run_container_t *arr) {
int card = run_container_cardinality(arr);
bitset_container_t *answer = bitset_container_create();
for (int rlepos = 0; rlepos < arr->n_runs; ++rlepos) {
rle16_t vl = arr->runs[rlepos];
bitset_set_lenrange(answer->wo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb25b
movl %eax, %ebp
xorl %r15d, %r15d
callq 0x34ce
movq %rax, %r14
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x9d2e
movq 0x8(%rbx), %rax
movzwl (%rax,%r15,4), %esi
movzwl 0x2(%rax,%r15,4), %edx
movq 0x8(%r14), %rdi
callq 0x9d3f
incq %r15
jmp ... | /RoaringBitmap[P]CRoaring/src/containers/convert.c |
bitset_set_lenrange | static inline void bitset_set_lenrange(uint64_t *words, uint32_t start,
uint32_t lenminusone) {
uint32_t firstword = start / 64;
uint32_t endword = (start + lenminusone) / 64;
if (firstword == endword) {
words[firstword] |= ((~UINT64_C(0)) >> ((63 - lenminusone... | movl %esi, %r8d
shrl $0x6, %r8d
leal (%rdx,%rsi), %eax
movl %eax, %ecx
shrl $0x6, %ecx
cmpl %ecx, %r8d
jne 0x9d6a
movb $0x3f, %cl
subb %dl, %cl
pushq $-0x1
popq %rax
shrq %cl, %rax
movl %esi, %ecx
shlq %cl, %rax
movl %r8d, %ecx
orq %rax, (%rdi,%rcx,8)
retq
movl %ecx, %edx
movq (%rdi,%rdx,8), %r9
pushq $-0x1
popq %r10
m... | /RoaringBitmap[P]CRoaring/include/roaring/bitset_util.h |
array_container_from_bitset | array_container_t *array_container_from_bitset(const bitset_container_t *bits) {
array_container_t *result =
array_container_create_given_capacity(bits->cardinality);
result->cardinality = bits->cardinality;
#if CROARING_IS_X64
#if CROARING_COMPILER_SUPPORTS_AVX512
if (croaring_hardware_support() & ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %edi
callq 0x29ea
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
callq 0xbc68
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rdx
testb $0x2, %al
jne 0x9e35
movl $0x400, %esi # imm = 0x400
xorl %ecx, %ecx
callq 0xdf27
jmp 0x9e45
movslq (%r14), %rcx
mov... | /RoaringBitmap[P]CRoaring/src/containers/convert.c |
run_container_from_array | run_container_t *run_container_from_array(const array_container_t *c) {
int32_t n_runs = array_container_number_of_runs(c);
run_container_t *answer = run_container_create_given_capacity(n_runs);
int prev = -2;
int run_start = -1;
int32_t card = c->cardinality;
if (card == 0) return answer;
f... | pushq %rbx
movq %rdi, %rbx
callq 0x32e9
movl %eax, %edi
callq 0xa749
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x9eda
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
pushq $-0x2
popq %rsi
pushq $-0x1
popq %rdi
cmpq %rdx, %rcx
je 0x9ec3
movq 0x8(%rbx), %r9
movzwl (%r9,%rdx,2), %r8d
leal 0x1(%rsi), %r10d
cmpl %r8d, %r10d... | /RoaringBitmap[P]CRoaring/src/containers/convert.c |
run_container_create_given_capacity | run_container_t *run_container_create_given_capacity(int32_t size) {
run_container_t *run;
/* Allocate the run container itself. */
if ((run = (run_container_t *)roaring_malloc(sizeof(run_container_t))) ==
NULL) {
return NULL;
}
if (size <= 0) { // we don't want to rely on malloc(0)... | pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0x10
popq %rdi
callq 0xbc19
testq %rax, %rax
je 0xa77e
movq %rax, %rbx
testl %ebp, %ebp
jle 0xa782
movl %ebp, %edi
shlq $0x2, %rdi
callq 0xbc19
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0xa787
movq %rbx, %rdi
callq 0xbc31
xorl %ebx, %ebx
jmp 0xa78d
andq $0x0, 0x8(... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_offset | void run_container_offset(const run_container_t *c, container_t **loc,
container_t **hic, uint16_t offset) {
run_container_t *lo = NULL, *hi = NULL;
bool split;
int lo_cap, hi_cap;
int top, pivot;
top = (1 << 16) - offset;
pivot = run_container_index_equalorlarger(c, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movl $0x10000, %ebx # imm = 0x10000
subl %ecx, %ebx
movzwl %bx, %esi
callq 0xa592
movl %eax, %r13d
cmpl $-0x1, %eax
je 0xa86d
movq 0x8(%r14), %rax
movl %... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_union | void run_container_union(const run_container_t *src_1,
const run_container_t *src_2, run_container_t *dst) {
// TODO: this could be a lot more efficient
// we start out with inexpensive checks
const bool if1 = run_container_is_full(src_1);
const bool if2 = run_container_is_full... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa5df
movl %eax, %ebp
movq %r15, %rdi
callq 0xa5df
movl %ebp, %ecx
orb %al, %cl
testb $0x1, %cl
je 0xaaa7
testb %bpl, %bpl
je 0xaa8a
movq %r14, %rdi
jmp 0xaa91
testb $0x1, %al
je 0xa... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_append | static inline void run_container_append(run_container_t *run, rle16_t vl,
rle16_t *previousrl) {
const uint32_t previousend = previousrl->value + previousrl->length;
if (vl.value > previousend + 1) { // we add a new one
run->runs[run->n_runs] = vl;
run->n... | movl %esi, %eax
shrl $0x10, %eax
movzwl (%rdx), %ecx
movzwl 0x2(%rdx), %r9d
movzwl %si, %r8d
leal (%r9,%rcx), %r10d
incl %r10d
cmpl %r10d, %r8d
jbe 0xabe1
movq 0x8(%rdi), %rcx
movslq (%rdi), %r8
movw %si, (%rcx,%r8,4)
movw %ax, 0x2(%rcx,%r8,4)
leal 0x1(%r8), %ecx
movl %ecx, (%rdi)
movw %si, (%rdx)
movw %ax, 0x2(%rdx)
r... | /RoaringBitmap[P]CRoaring/include/roaring/containers/run.h |
run_container_smart_append_exclusive | void run_container_smart_append_exclusive(run_container_t *src,
const uint16_t start,
const uint16_t length) {
int old_end;
rle16_t *last_run = src->n_runs ? src->runs + (src->n_runs - 1) : NULL;
rle16_t *appended_last_run =... | pushq %rbx
movslq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
je 0xae77
leaq (%rax,%rcx,4), %rax
movzwl %si, %ebx
movzwl -0x4(%rax), %r11d
movzwl -0x2(%rax), %r10d
leal (%r10,%r11), %r8d
leal (%r10,%r11), %r9d
incl %r9d
cmpl %ebx, %r9d
jae 0xae84
movw %si, (%rax)
movw %dx, 0x2(%rax)
incl %ecx
movl %ecx, (%rdi)
p... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_intersection | void run_container_intersection(const run_container_t *src_1,
const run_container_t *src_2,
run_container_t *dst) {
const bool if1 = run_container_is_full(src_1);
const bool if2 = run_container_is_full(src_2);
if (if1 || if2) {
if (if1)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xa5df
movl %eax, %ebp
movq %r14, %rdi
callq 0xa5df
orb %bpl, %al
testb $0x1, %al
je 0xaf52
testb %bpl, %bpl
cmovneq %r14, %r15
movq %r15, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_intersection_cardinality | int run_container_intersection_cardinality(const run_container_t *src_1,
const run_container_t *src_2) {
const bool if1 = run_container_is_full(src_1);
const bool if2 = run_container_is_full(src_2);
if (if1 || if2) {
if (if1) {
return run_contai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa5df
movl %eax, %ebp
movq %rbx, %rdi
callq 0xa5df
orb %bpl, %al
testb $0x1, %al
je 0xb113
testb %bpl, %bpl
cmovneq %rbx, %r14
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb25b
movq 0x8(%r14), %rcx
m... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
run_container_rank | int run_container_rank(const run_container_t *container, uint16_t x) {
int sum = 0;
uint32_t x32 = x;
for (int i = 0; i < container->n_runs; i++) {
uint32_t startpoint = container->runs[i].value;
uint32_t length = container->runs[i].length;
uint32_t endpoint = length + startpoint;
... | movl (%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0xb8cf
movq 0x8(%rdi), %r9
movzwl (%r9,%rdx,4), %r8d
movzwl 0x2(%r9,%rdx,4), %r9d
leal (%r9,%r8), %r10d
cmpl %esi, %r10d
jae 0xb8c0
addl %r9d, %eax
incl %eax
incq %rdx
jmp 0xb899
cmpw %si, %r8w
ja 0xb8cf
addl %eax, ... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
avx2_run_container_to_uint32_array | ALLOW_UNALIGNED
int _avx2_run_container_to_uint32_array(void *vout, const run_container_t *cont,
uint32_t base) {
int outpos = 0;
uint32_t *out = (uint32_t *)vout;
for (int i = 0; i < cont->n_runs; ++i) {
uint32_t run_start = base + cont->runs[i].value;
... | pushq %rbx
xorl %ecx, %ecx
vpmovsxbd 0x3c71(%rip), %ymm0 # 0xf664
movl $0x8, %r8d
vpbroadcastd 0x3c5e(%rip), %ymm1 # 0xf660
xorl %eax, %eax
movslq (%rsi), %r9
cmpq %r9, %rcx
jge 0xba88
movq 0x8(%rsi), %r10
movzwl (%r10,%rcx,4), %r9d
addl %edx, %r9d
movzwl 0x2(%r10,%rcx,4), %r10d
cltq
cmpl $0x7, %r10d
ja 0xba3b
incl %r1... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
avx512_run_container_cardinality | static inline int _avx512_run_container_cardinality(
const run_container_t *run) {
const int32_t n_runs = run->n_runs;
const rle16_t *runs = run->runs;
/* by initializing with n_runs, we omit counting the +1 for each pair. */
int sum = n_runs;
int32_t k = 0;
const int32_t step = sizeof(__m5... | movl (%rdi), %ecx
movq 0x8(%rdi), %rdx
cmpl $0x11, %ecx
jl 0xbac1
movl %ecx, %esi
andl $0x7ffffff0, %esi # imm = 0x7FFFFFF0
vpxor %xmm0, %xmm0, %xmm0
pushq $0x10
popq %rax
cmpq %rcx, %rax
ja 0xbac7
vpsrld $0x10, -0x40(%rdx,%rax,4), %zmm1
vpaddd %zmm0, %zmm1, %zmm0
addq $0x10, %rax
jmp 0xbaa7
xorl %esi, %esi
movl ... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
avx2_run_container_cardinality | ALLOW_UNALIGNED
int run_container_cardinality(const run_container_t *run) {
const int32_t n_runs = run->n_runs;
const rle16_t *runs = run->runs;
/* by initializing with n_runs, we omit counting the +1 for each pair. */
int sum = n_runs;
for (int k = 0; k < n_runs; ++k) {
sum += runs[k].leng... | movl (%rdi), %ecx
movq 0x8(%rdi), %rdx
cmpl $0x9, %ecx
jl 0xbb43
movl %ecx, %esi
andl $0x7ffffff8, %esi # imm = 0x7FFFFFF8
vpxor %xmm0, %xmm0, %xmm0
pushq $0x8
popq %rax
movq %rdx, %rdi
cmpq %rcx, %rax
ja 0xbb49
vlddqu (%rdi), %ymm1
vpsrld $0x10, %ymm1, %ymm1
vpaddd %ymm0, %ymm1, %ymm0
addq $0x20, %rdi
addq $0x8,... | /RoaringBitmap[P]CRoaring/src/containers/run.c |
roaring_bitmap_aligned_malloc | static void* roaring_bitmap_aligned_malloc(size_t alignment, size_t size) {
void* p;
#ifdef _MSC_VER
p = _aligned_malloc(size, alignment);
#elif defined(__MINGW32__) || defined(__MINGW64__)
p = __mingw_aligned_malloc(size, alignment);
#else
// somehow, if this is used before including "x86intrin.h", it ... | pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x10f0
testl %eax, %eax
jne 0xbc5f
movq (%rsp), %rax
jmp 0xbc61
xorl %eax, %eax
popq %rcx
retq
| /RoaringBitmap[P]CRoaring/src/memory.c |
roaring_bitmap_aligned_free | static void roaring_bitmap_aligned_free(void* memblock) {
#ifdef _MSC_VER
_aligned_free(memblock);
#elif defined(__MINGW32__) || defined(__MINGW64__)
__mingw_aligned_free(memblock);
#else
free(memblock);
#endif
} | jmp 0x1030
| /RoaringBitmap[P]CRoaring/src/memory.c |
croaring_hardware_support | int croaring_hardware_support(void) {
static
#if CROARING_ATOMIC_IMPL == CROARING_ATOMIC_IMPL_C
_Atomic
#endif
int support = 0xFFFFFFF;
if (support == 0xFFFFFFF) {
bool has_avx2 = (croaring_detect_supported_architectures() &
CROARING_AVX2) == CROARING_AVX2;
... | movl 0xd45e(%rip), %eax # 0x190cc
cmpl $0xfffffff, %eax # imm = 0xFFFFFFF
jne 0xbc9f
pushq %rbx
callq 0xbca6
movl %eax, %ebx
callq 0xbca6
notl %eax
xorl %ecx, %ecx
testl %eax, 0xd43c(%rip) # 0x190c8
sete %cl
shrl $0x2, %ebx
andl $0x1, %ebx
leal (%rbx,%rcx,2), %eax
xchgl %eax, 0xd42e(%rip) # 0x190c... | /RoaringBitmap[P]CRoaring/src/isadetection.c |
intersect_vector16_cardinality | int32_t intersect_vector16_cardinality(const uint16_t *__restrict__ A,
size_t s_a,
const uint16_t *__restrict__ B,
size_t s_b) {
size_t count = 0;
size_t i_a = 0, i_b = 0;
const int vectorlen... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r8
movq %rsi, %rbx
andq $-0x8, %rbx
setne %al
movq %rcx, %r14
andq $-0x8, %r14
setne %dl
testb %dl, %al
jne 0xc182
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %r9d, %r9d
jmp 0xc255
vlddqu (%rdi), %xmm1
vlddqu (%r8), %xmm2
xorl %r10d, %r10d
movl $0x8, %eax
xorl %r11d, %r11d
xorl... | /RoaringBitmap[P]CRoaring/src/array_util.c |
difference_vector16 | int32_t difference_vector16(const uint16_t *__restrict__ A, size_t s_a,
const uint16_t *__restrict__ B, size_t s_b,
uint16_t *C) {
// we handle the degenerate case
if (s_a == 0) return 0;
if (s_b == 0) {
if (A != C) memcpy(C, A, sizeof(uint16_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rsi, %rsi
je 0xc2ce
movq %rsi, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0xc2d5
movq %rdx, %r13
movq %rcx, %r12
cmpw $0x0, (%r15)
movzwl (%rdx), %eax
je 0xc2f0
xorl %r14d, %r14d
testw %ax, %ax
jne 0xc318
addq $0x2, %r13
decq %r12
j... | /RoaringBitmap[P]CRoaring/src/array_util.c |
intersect_skewed_uint16_cardinality | int32_t intersect_skewed_uint16_cardinality(const uint16_t *small,
size_t size_s,
const uint16_t *large,
size_t size_l) {
size_t pos = 0, idx_l = 0, idx_s = 0;
if (0 == size_s) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
testq %rsi, %rsi
je 0xc8dd
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movzwl (%rdi), %r14d
xorl %eax, %eax
xorl %esi, %esi
xorl %ebp, %ebp
movq %rdx, %rcx
movzwl (%rcx), %ecx
incq %rbp
cmpw %r14w, %cx
jb 0xc87e... | /RoaringBitmap[P]CRoaring/src/array_util.c |
advanceUntil | static inline int32_t advanceUntil(const uint16_t *array, int32_t pos,
int32_t length, uint16_t min) {
int32_t lower = pos + 1;
if ((lower >= length) || (array[lower] >= min)) {
return lower;
}
int32_t spansize = 1;
while ((lower + spansize < length) && ... | incl %esi
cmpl %edx, %esi
jge 0xc924
movl %edx, %eax
movslq %esi, %rdx
cmpw %cx, (%rdi,%rdx,2)
jae 0xc924
pushq $0x1
popq %rdx
leal (%rdx,%rsi), %r8d
cmpl %eax, %r8d
jge 0xc927
movslq %r8d, %r9
movzwl (%rdi,%r9,2), %r9d
cmpw %cx, %r9w
jae 0xc934
addl %edx, %edx
jmp 0xc909
movl %esi, %eax
retq
leal -0x1(%rax), %r8d
movs... | /RoaringBitmap[P]CRoaring/include/roaring/array_util.h |
intersect_uint16_cardinality | int32_t intersect_uint16_cardinality(const uint16_t *A, const size_t lenA,
const uint16_t *B, const size_t lenB) {
int32_t answer = 0;
if (lenA == 0 || lenB == 0) return 0;
const uint16_t *endA = A + lenA;
const uint16_t *endB = B + lenB;
while (1) {
whi... | testq %rsi, %rsi
sete %r8b
testq %rcx, %rcx
sete %r9b
xorl %eax, %eax
orb %r8b, %r9b
je 0xca61
retq
leaq (%rdi,%rsi,2), %rsi
leaq (%rdx,%rcx,2), %rcx
xorl %eax, %eax
movzwl (%rdx), %r8d
movzwl (%rdi), %r9d
cmpw %r8w, %r9w
jb 0xca90
movzwl (%rdx), %r8d
cmpw %r8w, %r9w
jbe 0xca8e
addq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xca7... | /RoaringBitmap[P]CRoaring/src/array_util.c |
intersect_uint16_nonempty | bool intersect_uint16_nonempty(const uint16_t *A, const size_t lenA,
const uint16_t *B, const size_t lenB) {
if (lenA == 0 || lenB == 0) return 0;
const uint16_t *endA = A + lenA;
const uint16_t *endB = B + lenB;
while (1) {
while (*A < *B) {
SKIP_FIRST_CO... | testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r8b
orb %al, %r8b
je 0xcac6
xorl %eax, %eax
retq
leaq (%rdi,%rsi,2), %rax
leaq (%rdx,%rcx,2), %rcx
movzwl (%rdx), %esi
movzwl (%rdi), %r8d
cmpw %si, %r8w
jb 0xcaf1
movzwl (%rdx), %esi
cmpw %si, %r8w
jbe 0xcaef
addq $0x2, %rdx
cmpq %rcx, %rdx
jne 0xcadb
jmp 0xcac3
je 0xca... | /RoaringBitmap[P]CRoaring/src/array_util.c |
intersection_uint32 | size_t intersection_uint32(const uint32_t *A, const size_t lenA,
const uint32_t *B, const size_t lenB,
uint32_t *out) {
const uint32_t *initout = out;
if (lenA == 0 || lenB == 0) return 0;
const uint32_t *endA = A + lenA;
const uint32_t *endB = B + l... | testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
je 0xcb14
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
movq %r8, %rax
movl (%rdx), %r9d
movl (%rdi), %r10d
cmpl %r9d, %r10d
jb 0xcb3f
movl (%rdx), %r9d
cmpl %r9d, %r10d
jbe 0xcb3d
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0xcb2a
jmp ... | /RoaringBitmap[P]CRoaring/src/array_util.c |
intersection_uint32_card | size_t intersection_uint32_card(const uint32_t *A, const size_t lenA,
const uint32_t *B, const size_t lenB) {
if (lenA == 0 || lenB == 0) return 0;
size_t card = 0;
const uint32_t *endA = A + lenA;
const uint32_t *endB = B + lenB;
while (1) {
while (*A < *B) ... | testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r8b
orb %al, %r8b
je 0xcb80
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
xorl %eax, %eax
movl (%rdx), %r8d
movl (%rdi), %r9d
cmpl %r8d, %r9d
jb 0xcbaa
movl (%rdx), %r8d
cmpl %r8d, %r9d
jbe 0xcba8
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0xcb95
jmp 0x... | /RoaringBitmap[P]CRoaring/src/array_util.c |
difference_uint16 | int difference_uint16(const uint16_t *a1, int length1, const uint16_t *a2,
int length2, uint16_t *a_out) {
int out_card = 0;
int k1 = 0, k2 = 0;
if (length1 == 0) return 0;
if (length2 == 0) {
if (a1 != a_out) memcpy(a_out, a1, sizeof(uint16_t) * length1);
return le... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
je 0xcd45
movq %rdi, %rsi
testl %ecx, %ecx
je 0xcd6d
movzwl (%rdx), %edi
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %eax, %eax
movq %rsi, %r10
movzwl (%r10), %r10d
leal 0x1(%rax), %r9d
movslq %r9d, %r9
leaq (%rdx,%r9,2), %r9
movl %ebp, ... | /RoaringBitmap[P]CRoaring/src/array_util.c |
xor_uint16 | int32_t xor_uint16(const uint16_t *array_1, int32_t card_1,
const uint16_t *array_2, int32_t card_2, uint16_t *out) {
int32_t pos1 = 0, pos2 = 0, pos_out = 0;
while (pos1 < card_1 && pos2 < card_2) {
const uint16_t v1 = array_1[pos1];
const uint16_t v2 = array_2[pos2];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
xorl %r11d, %r11d
xorl %r9d, %r9d
movl %r11d, %eax
movslq %r11d, %r10
leaq (%rdx,%r10,2), %r14
movl %r9d, %r10d
movslq %r9d, %r9
leaq (%rdi,%r9,2), %r15
xorl %r9d, %r9d
leal (%rax,%r9), %ebp
leal (%r10,%r9), %r12d
movl %ebx, %r11d
cmpl %esi, %r12d
j... | /RoaringBitmap[P]CRoaring/src/array_util.c |
union_vector16 | CROARING_TARGET_AVX2
// a one-pass SSE union algorithm
// This function may not be safe if array1 == output or array2 == output.
uint32_t union_vector16(const uint16_t *__restrict__ array1, uint32_t length1,
const uint16_t *__restrict__ array2, uint32_t length2,
uint16_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbp
cmpl $0x8, %esi
setae %al
cmpl $0x8, %ecx
setae %cl
testb %cl, %al
jne 0xcebd
movl %r13d, %esi
movl %r12d, %ecx
movq %rbp, %rdi
movq %r14, %rdx
movq %r15, %... | /RoaringBitmap[P]CRoaring/src/array_util.c |
store_unique | CROARING_TARGET_AVX2
// write vector new, while omitting repeated values assuming that previously
// written vector was "old"
static inline int store_unique(__m128i old, __m128i newval, uint16_t *output) {
__m128i vecTmp = _mm_alignr_epi8(newval, old, 16 - 2);
// lots of high latency instructions follow (optimi... | vpalignr $0xe, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[14,15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
vpcmpeqw %xmm1, %xmm0, %xmm0
vpxor %xmm2, %xmm2, %xmm2
vpacksswb %xmm2, %xmm0, %xmm0
vpmovmskb %xmm0, %ecx
popcntl %ecx, %edx
pushq $0x8
popq %rax
subl %edx, %eax
shll $0x4, %ecx
leaq 0xbe42(%rip), %rdx # 0x190e0
vlddqu (... | /RoaringBitmap[P]CRoaring/src/array_util.c |
xor_vector16 | CROARING_TARGET_AVX2
// a one-pass SSE xor algorithm
uint32_t xor_vector16(const uint16_t *__restrict__ array1, uint32_t length1,
const uint16_t *__restrict__ array2, uint32_t length2,
uint16_t *__restrict__ output) {
if ((length1 < 8) || (length2 < 8)) {
return x... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r15
movl %ecx, %r13d
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbp
cmpl $0x8, %esi
setae %al
cmpl $0x8, %ecx
setae %cl
testb %cl, %al
jne 0xd333
movq %rbp, %rdi
movl %r14d, %esi
movq %r12, %rdx
movl %r13d, %ecx
movq %r15, %... | /RoaringBitmap[P]CRoaring/src/array_util.c |
store_unique_xor | static inline int store_unique_xor(__m128i old, __m128i newval,
uint16_t *output) {
__m128i vecTmp1 = _mm_alignr_epi8(newval, old, 16 - 4);
__m128i vecTmp2 = _mm_alignr_epi8(newval, old, 16 - 2);
__m128i equalleft = _mm_cmpeq_epi16(vecTmp2, vecTmp1);
__m128i equalright... | vpalignr $0xc, %xmm0, %xmm1, %xmm2 # xmm2 = xmm0[12,13,14,15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11]
vpalignr $0xe, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[14,15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
vpcmpeqw %xmm2, %xmm0, %xmm2
vpcmpeqw %xmm1, %xmm0, %xmm1
vpor %xmm1, %xmm2, %xmm1
vpxor %xmm2, %xmm2, %xmm2
vpacksswb %xmm2, %xmm1,... | /RoaringBitmap[P]CRoaring/src/array_util.c |
unique_xor | CROARING_UNTARGET_AVX2
// working in-place, this function overwrites the repeated values
// could be avoided? Warning: assumes len > 0
static inline uint32_t unique_xor(uint16_t *out, uint32_t len) {
uint32_t pos = 1;
for (uint32_t i = 1; i < len; ++i) {
if (out[i] != out[i - 1]) {
out[pos+... | movl %esi, %ecx
pushq $0x1
popq %rax
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jae 0xd6f9
movzwl (%rdi,%rdx,2), %esi
cmpw -0x2(%rdi,%rdx,2), %si
jne 0xd6ea
decl %eax
jmp 0xd6f4
movl %eax, %r8d
incl %eax
movw %si, (%rdi,%r8,2)
incq %rdx
jmp 0xd6d6
retq
| /RoaringBitmap[P]CRoaring/src/array_util.c |
union_uint32 | size_t union_uint32(const uint32_t *set_1, size_t size_1, const uint32_t *set_2,
size_t size_2, uint32_t *buffer) {
size_t pos = 0, idx_1 = 0, idx_2 = 0;
if (0 == size_2) {
memmove(buffer, set_1, size_1 * sizeof(uint32_t));
return size_1;
}
if (0 == size_1) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
testq %rcx, %rcx
je 0xd79b
movq %rcx, %r14
testq %rbx, %rbx
je 0xd7ad
movl (%rdx), %edi
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r15d, %r15d
movl (%rsi,%rax,4), %r9d
incq %r15
cmpl %edi, %r9d
jb 0xd74b
jbe 0xd75a
movl %edi, -0x4(%r8,%r15,4)
leaq 0x1(%rcx), %... | /RoaringBitmap[P]CRoaring/src/array_util.c |
union_uint32_card | size_t union_uint32_card(const uint32_t *set_1, size_t size_1,
const uint32_t *set_2, size_t size_2) {
size_t pos = 0, idx_1 = 0, idx_2 = 0;
if (0 == size_2) {
return size_1;
}
if (0 == size_1) {
return size_2;
}
uint32_t val_1 = set_1[idx_1], val_2 = s... | movq %rsi, %rax
testq %rcx, %rcx
je 0xd862
testq %rax, %rax
je 0xd85f
pushq %rbx
movl (%rdx), %r10d
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %esi, %esi
movl (%rdi,%r8,4), %r11d
incq %rsi
cmpl %r10d, %r11d
jb 0xd82d
jbe 0xd837
leaq 0x1(%r9), %rbx
cmpq %rcx, %rbx
jae 0xd852
movl (%rdx,%rbx,4), %r10d
incq %rsi
movq %rbx, %r9
... | /RoaringBitmap[P]CRoaring/src/array_util.c |
memequals | bool memequals(const void *s1, const void *s2, size_t n) {
if (n == 0) {
return true;
}
#if CROARING_IS_X64
int support = croaring_hardware_support();
#if CROARING_COMPILER_SUPPORTS_AVX512
if (support & ROARING_SUPPORTS_AVX512) {
return _avx512_memequals(s1, s2, n);
} else
#endif //... | pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0xd92e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xbc68
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
testb $0x2, %al
jne 0xd936
testb $0x1, %al
jne 0xd93d
callq 0x10d0
testl %eax, %eax
sete %al
jmp 0xd930
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
re... | /RoaringBitmap[P]CRoaring/src/array_util.c |
avx2_memequals | CROARING_TARGET_AVX2
static inline bool _avx2_memequals(const void *s1, const void *s2, size_t n) {
const uint8_t *ptr1 = (const uint8_t *)s1;
const uint8_t *ptr2 = (const uint8_t *)s2;
const uint8_t *end1 = ptr1 + n;
const uint8_t *end8 = ptr1 + n / 8 * 8;
const uint8_t *end32 = ptr1 + n / 32 * 32;... | leaq (%rdi,%rdx), %rcx
movq %rdx, %rax
andq $-0x8, %rax
addq %rdi, %rax
andq $-0x20, %rdx
addq %rdi, %rdx
cmpq %rdx, %rdi
jae 0xda28
vmovdqu (%rdi), %ymm0
vpxor (%rsi), %ymm0, %ymm0
addq $0x20, %rdi
addq $0x20, %rsi
vptest %ymm0, %ymm0
je 0xd9f3
xorl %eax, %eax
vzeroupper
retq
movq (%rdi), %rdx
addq $0x8, %rdi
leaq 0x8... | /RoaringBitmap[P]CRoaring/src/array_util.c |
bitset_extract_setbits_avx512 | size_t bitset_extract_setbits_avx512(const uint64_t *words, size_t length,
uint32_t *vout, size_t outcapacity,
uint32_t base) {
uint32_t *out = (uint32_t *)vout;
uint32_t *initout = out;
uint32_t *safeout = out + outcapacity;
__m5... | leaq (%rdx,%rcx,4), %rcx
vmovdqa64 0x35c2(%rip), %zmm0 # 0x11080
xorl %r9d, %r9d
movq %rdx, %rax
cmpq %rsi, %r9
jae 0xdb96
leaq 0x100(%rax), %r10
cmpq %rcx, %r10
jae 0xdb96
movq (%rdi,%r9,8), %r10
popcntq %r10, %r11
kmovq %r10, %k1
vpcompressb %zmm0, %zmm1 {%k1} {z}
vpbroadcastd %r8d, %zmm2
vpmovsxbd %xmm1, %zmm3
vextr... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_extract_setbits_avx512_uint16 | size_t bitset_extract_setbits_avx512_uint16(const uint64_t *array,
size_t length, uint16_t *vout,
size_t capacity, uint16_t base) {
uint16_t *out = (uint16_t *)vout;
uint16_t *initout = out;
uint16_t *safeout = vout + ca... | leaq (%rdx,%rcx,2), %rcx
vmovdqa64 0x34cc(%rip), %zmm0 # 0x11080
xorl %r9d, %r9d
movq %rdx, %rax
cmpq %rsi, %r9
jae 0xdc57
leaq 0x80(%rax), %r10
cmpq %rcx, %r10
jae 0xdc57
movq (%rdi,%r9,8), %r10
popcntq %r10, %r11
kmovq %r10, %k1
vpcompressb %zmm0, %zmm1 {%k1} {z}
vpbroadcastw %r8d, %zmm2
vpmovsxbw %ymm1, %zmm3
vextra... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_extract_setbits | size_t bitset_extract_setbits(const uint64_t *words, size_t length,
uint32_t *out, uint32_t base) {
int outpos = 0;
for (size_t i = 0; i < length; ++i) {
uint64_t w = words[i];
while (w != 0) {
int r =
roaring_trailing_zeroes(w); // on x... | xorl %r8d, %r8d
xorl %r9d, %r9d
movslq %r9d, %rax
cmpq %rsi, %r8
je 0xddc3
movq (%rdi,%r8,8), %r10
leaq (%rdx,%rax,4), %rax
testq %r10, %r10
je 0xddbb
bsfq %r10, %r11
addl %ecx, %r11d
movl %r11d, (%rax)
leaq -0x1(%r10), %r11
andq %r11, %r10
incl %r9d
addq $0x4, %rax
jmp 0xdd9c
addl $0x40, %ecx
incq %r8
jmp 0xdd8c
retq
| /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_extract_intersection_setbits_uint16 | size_t bitset_extract_intersection_setbits_uint16(
const uint64_t *__restrict__ words1, const uint64_t *__restrict__ words2,
size_t length, uint16_t *out, uint16_t base) {
int outpos = 0;
for (size_t i = 0; i < length; ++i) {
uint64_t w = words1[i] & words2[i];
while (w != 0) {
... | pushq %rbx
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq %r9d, %rax
cmpq %rdx, %r10
je 0xde07
movq (%rsi,%r10,8), %r11
andq (%rdi,%r10,8), %r11
leaq (%rcx,%rax,2), %rax
testq %r11, %r11
je 0xddfe
bsfq %r11, %rbx
addl %r8d, %ebx
movw %bx, (%rax)
leaq -0x1(%r11), %rbx
andq %rbx, %r11
incl %r9d
addq $0x2, %rax
jmp 0xdddf
addl ... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_extract_setbits_sse_uint16 | CROARING_TARGET_AVX2
size_t bitset_extract_setbits_sse_uint16(const uint64_t *words, size_t length,
uint16_t *out, size_t outcapacity,
uint16_t base) {
uint16_t *initout = out;
__m128i baseVec = _mm_set1_epi16(base - 1);
__m12... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, -0x10(%rsp)
movl %r8d, %eax
decl %eax
vmovd %eax, %xmm0
vpbroadcastw %xmm0, %xmm0
leaq (%rdx,%rcx,2), %r12
xorl %r9d, %r9d
vpbroadcastw 0x320e(%rip), %xmm1 # 0x11044
movl $0x4, %r8d
leaq 0x537d(%rip), %r11 # 0x131c0
vpbroadcastw 0x31f4(%ri... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_extract_setbits_uint16 | size_t bitset_extract_setbits_uint16(const uint64_t *words, size_t length,
uint16_t *out, uint16_t base) {
int outpos = 0;
for (size_t i = 0; i < length; ++i) {
uint64_t w = words[i];
while (w != 0) {
int r = roaring_trailing_zeroes(w);
... | xorl %r8d, %r8d
xorl %r9d, %r9d
movslq %r8d, %rax
cmpq %rsi, %r9
je 0xdf65
movq (%rdi,%r9,8), %r10
leaq (%rdx,%rax,2), %rax
testq %r10, %r10
je 0xdf5d
bsfq %r10, %r11
addl %ecx, %r11d
movw %r11w, (%rax)
leaq -0x1(%r10), %r11
andq %r11, %r10
incl %r8d
addq $0x2, %rax
jmp 0xdf3d
addl $0x40, %ecx
incq %r9
jmp 0xdf2d
retq
| /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_set_list_withcard | uint64_t bitset_set_list_withcard(uint64_t *words, uint64_t card,
const uint16_t *list, uint64_t length) {
if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) {
return _asm_bitset_set_list_withcard(words, card, list, length);
} else {
return _scalar_bitset_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xbc68
testb $0x1, %al
jne 0xe040
addq %r12, %r12
xorl %eax, %eax
cmpq %rax, %r12
je 0xe06e
movzwl (%r14,%rax), %ecx
movl %ecx, %edx
shrl $0x6, %edx
movq (%r15,%rdx,8), %rsi
movq %rsi, %rdi
btsq ... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_set_list | void bitset_set_list(uint64_t *words, const uint16_t *list, uint64_t length) {
if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) {
_asm_bitset_set_list(words, list, length);
} else {
_scalar_bitset_set_list(words, list, length);
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xbc68
testb $0x1, %al
jne 0xe0bf
addq %rbx, %rbx
xorl %eax, %eax
pushq $0x1
popq %rdx
cmpq %rax, %rbx
je 0xe159
movzwl (%r14,%rax), %ecx
movl %ecx, %esi
shrl $0x6, %esi
movq %rdx, %rdi
shlq %cl, %rdi
orq %rdi, (%r15,%rsi,8)
addq $0x... | /RoaringBitmap[P]CRoaring/src/bitset_util.c |
bitset_flip_list | void bitset_flip_list(uint64_t *words, const uint16_t *list, uint64_t length) {
uint64_t offset, load, newload, pos, index;
const uint16_t *end = list + length;
while (list != end) {
pos = *list;
offset = pos >> 6;
index = pos % 64;
load = words[offset];
newload = loa... | addq %rdx, %rdx
xorl %eax, %eax
pushq $0x1
popq %r8
cmpq %rax, %rdx
je 0xe1cb
movzwl (%rsi,%rax), %ecx
movl %ecx, %r9d
shrl $0x6, %r9d
movq %r8, %r10
shlq %cl, %r10
xorq %r10, (%rdi,%r9,8)
addq $0x2, %rax
jmp 0xe1ab
retq
| /RoaringBitmap[P]CRoaring/src/bitset_util.c |
container_free | void container_free(container_t *c, uint8_t type) {
switch (type) {
case BITSET_CONTAINER_TYPE:
bitset_container_free(CAST_bitset(c));
break;
case ARRAY_CONTAINER_TYPE:
array_container_free(CAST_array(c));
break;
case RUN_CONTAINER_TYPE:
... | decl %esi
leaq 0x5feb(%rip), %rax # 0x141c0
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
jmp 0x361b
jmp 0xa96c
jmp 0xe1f2
jmp 0x2ca6
| /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_printf_as_uint32_array | static inline const container_t *container_unwrap_shared(
const container_t *candidate_shared_container, uint8_t *type) {
if (*type == SHARED_CONTAINER_TYPE) {
*type = const_CAST_shared(candidate_shared_container)->typecode;
assert(*type != SHARED_CONTAINER_TYPE);
return const_CAST_share... | cmpl $0x4, %esi
jne 0xe24a
movb 0x8(%rdi), %sil
movq (%rdi), %rdi
cmpb $0x3, %sil
je 0xe264
movzbl %sil, %eax
movl %edx, %esi
cmpl $0x2, %eax
jne 0x9437
jmp 0x31fd
movl %edx, %esi
jmp 0xb50e
| /RoaringBitmap[P]CRoaring/include/roaring/containers/containers.h |
get_copy_of_container | container_t *get_copy_of_container(container_t *c, uint8_t *typecode,
bool copy_on_write) {
if (copy_on_write) {
shared_container_t *shared_container;
if (*typecode == SHARED_CONTAINER_TYPE) {
shared_container = CAST_shared(c);
croaring_refc... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %al
testl %edx, %edx
je 0xe306
cmpb $0x4, %al
jne 0xe325
lock
incl 0xc(%rbx)
jmp 0xe34c
cmpb $0x4, %al
jne 0xe313
movb 0x8(%rbx), %al
movb %al, (%r14)
movq (%rbx), %rbx
movzbl %al, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp ... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_clone | container_t *container_clone(const container_t *c, uint8_t typecode) {
// We do not want to allow cloning of shared containers.
// c = container_unwrap_shared(c, &typecode);
switch (typecode) {
case BITSET_CONTAINER_TYPE:
return bitset_container_clone(const_CAST_bitset(c));
case ... | decl %esi
leaq 0x5e70(%rip), %rax # 0x141d0
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
jmp 0x3637
jmp 0xa7de
xorl %eax, %eax
retq
jmp 0x2a85
| /RoaringBitmap[P]CRoaring/src/containers/containers.c |
shared_container_extract_copy | container_t *shared_container_extract_copy(shared_container_t *sc,
uint8_t *typecode) {
assert(sc->typecode != SHARED_CONTAINER_TYPE);
*typecode = sc->typecode;
container_t *answer;
if (croaring_refcount_dec(&sc->counter)) {
answer = sc->container;
... | movb 0x8(%rdi), %al
movb %al, (%rsi)
lock
decl 0xc(%rdi)
jne 0xe398
pushq %rbx
movq (%rdi), %rbx
andq $0x0, (%rdi)
callq 0xbc31
movq %rbx, %rax
popq %rbx
retq
movq (%rdi), %rdi
movzbl (%rsi), %esi
jmp 0xe357
| /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_init_iterator | roaring_container_iterator_t container_init_iterator(const container_t *c,
uint8_t typecode,
uint16_t *value) {
switch (typecode) {
case BITSET_CONTAINER_TYPE: {
const bitset_container_t *bc... | movq 0x8(%rdi), %rax
cmpl $0x3, %esi
je 0xe3b1
cmpl $0x2, %esi
jne 0xe3b8
movzwl (%rax), %esi
xorl %eax, %eax
jmp 0xe3d5
xorl %esi, %esi
pushq $-0x40
popq %rcx
movl %esi, %edi
movq (%rax,%rdi,8), %rdi
incl %esi
addl $0x40, %ecx
testq %rdi, %rdi
je 0xe3bd
bsfq %rdi, %rsi
addl %ecx, %esi
movl %esi, %eax
movw %si, (%rdx)
... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_init_iterator_last | roaring_container_iterator_t container_init_iterator_last(const container_t *c,
uint8_t typecode,
uint16_t *value) {
switch (typecode) {
case BITSET_CONTAINER_TYPE: {
const bitset_... | cmpl $0x3, %esi
je 0xe3f4
cmpl $0x2, %esi
jne 0xe40b
movslq (%rdi), %rax
movq 0x8(%rdi), %rcx
movzwl -0x2(%rcx,%rax,2), %ecx
decq %rax
jmp 0xe434
movslq (%rdi), %rsi
leaq -0x1(%rsi), %rax
movq 0x8(%rdi), %rdi
movzwl -0x2(%rdi,%rsi,4), %ecx
addw -0x4(%rdi,%rsi,4), %cx
jmp 0xe434
movq 0x8(%rdi), %rax
movl $0x3ff, %esi ... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_iterator_next | bool container_iterator_next(const container_t *c, uint8_t typecode,
roaring_container_iterator_t *it,
uint16_t *value) {
switch (typecode) {
case BITSET_CONTAINER_TYPE: {
const bitset_container_t *bc = const_CAST_bitset(c);
i... | movq %rcx, %r8
movq %rdx, %r9
cmpl $0x3, %esi
je 0xe467
cmpl $0x2, %esi
jne 0xe493
movslq (%r9), %rax
leal 0x1(%rax), %ecx
movl %ecx, (%r9)
cmpl (%rdi), %ecx
jge 0xe50d
movq 0x8(%rdi), %rcx
movzwl 0x2(%rcx,%rax,2), %eax
jmp 0xe506
movzwl (%r8), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0xe50d
movq 0x8(%rdi), ... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_iterator_prev | bool container_iterator_prev(const container_t *c, uint8_t typecode,
roaring_container_iterator_t *it,
uint16_t *value) {
switch (typecode) {
case BITSET_CONTAINER_TYPE: {
if (--it->index < 0) {
return false;
}... | movq %rcx, %r8
cmpl $0x3, %esi
je 0xe53b
cmpl $0x2, %esi
jne 0xe56f
movl (%rdx), %ecx
leal -0x1(%rcx), %eax
movl %eax, (%rdx)
testl %ecx, %ecx
jle 0xe5b0
movq 0x8(%rdi), %rcx
movl %eax, %eax
movzwl (%rcx,%rax,2), %eax
jmp 0xe5c0
movzwl (%r8), %esi
testw %si, %si
je 0xe5b0
decl %esi
movw %si, (%r8)
movq 0x8(%rdi), %rcx
... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_iterator_lower_bound | bool container_iterator_lower_bound(const container_t *c, uint8_t typecode,
roaring_container_iterator_t *it,
uint16_t *value_out, uint16_t val) {
if (val > container_maximum(c, typecode)) {
return false;
}
switch (typecode) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %r12
movl %r13d, %eax
cmpl $0x4, %esi
jne 0xe5f2
movb 0x8(%r12), %al
movq (%r12), %rdi
cmpb $0x3, %al
je 0xe611
movzbl %al, %eax
cmpl $0x2, %eax
jne 0xe629
movslq (%rd... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_iterator_read_into_uint32 | bool container_iterator_read_into_uint32(const container_t *c, uint8_t typecode,
roaring_container_iterator_t *it,
uint32_t high16, uint32_t *buf,
uint32_t count, uint32_t *consumed,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rsp), %r14
andl $0x0, (%r14)
testl %r9d, %r9d
je 0xe848
movl %ecx, %r10d
movq %rdx, %r11
movq 0x30(%rsp), %rbx
cmpb $0x1, %sil
je 0xe72a
movzbl %sil, %eax
cmpl $0x2, %eax
jne 0xe7c5
movl (%rdi), %eax
subl (%r11), %eax
cmpl %r9d, %eax
cmovael %r9d, %eax
xorl %ecx, %... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
container_iterator_read_into_uint64 | bool container_iterator_read_into_uint64(const container_t *c, uint8_t typecode,
roaring_container_iterator_t *it,
uint64_t high48, uint64_t *buf,
uint32_t count, uint32_t *consumed,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rsp), %r14
andl $0x0, (%r14)
testl %r9d, %r9d
je 0xe9f7
movq %rcx, %r10
movq %rdx, %r11
movq 0x38(%rsp), %rbx
cmpb $0x1, %sil
je 0xe8d7
movzbl %sil, %eax
cmpl $0x2, %eax
jne 0xe971
movl (%rdi), %eax
movl (%r11), %ecx
subl %ecx, %eax
cmpl %r9d, %eax
cmova... | /RoaringBitmap[P]CRoaring/src/containers/containers.c |
is_complete(char const*, char const*, unsigned long, int*) | static const char *is_complete(const char *buf, const char *buf_end, size_t last_len, int *ret)
{
int ret_cnt = 0;
buf = last_len < 3 ? buf : buf + last_len - 3;
while (1) {
CHECK_EOF();
if (*buf == '\015') {
++buf;
CHECK_EOF();
EXPECT_CHAR('\012');
... | cmpq $0x3, %rdx
leaq -0x3(%rdi,%rdx), %r9
cmovbq %rdi, %r9
xorl %r8d, %r8d
pushq $-0x2
popq %rdx
pushq $-0x1
popq %rdi
cmpq %rsi, %r9
je 0x7808
movzbl (%r9), %r11d
leaq 0x1(%r9), %rax
cmpl $0xa, %r11d
je 0x77f3
xorl %r10d, %r10d
cmpl $0xd, %r11d
jne 0x77f9
cmpq %rsi, %rax
je 0x7808
cmpb $0xa, (%rax)
jne 0x7806
addq $0x... | /mattn[P]clask/clask/../clask/picohttpparser.c |
phr_parse_response | int phr_parse_response(const char *buf_start, size_t len, int *minor_version, int *status, const char **msg, size_t *msg_len,
struct phr_header *headers, size_t *num_headers, size_t last_len)
{
const char *buf = buf_start, *buf_end = buf + len;
size_t max_headers = *num_headers;
int r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r14
movq 0x58(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
orl $-0x1, (%rdx)
movq %rdi, %rbx
andl $0x0, (%rbp)
movq 0x60(%rsp), %rdx
andq $0x0, (%r8)
addq %... | /mattn[P]clask/clask/../clask/picohttpparser.c |
parse_headers(char const*, char const*, phr_header*, unsigned long*, unsigned long, int*) | static const char *parse_headers(const char *buf, const char *buf_end, struct phr_header *headers, size_t *num_headers,
size_t max_headers, int *ret)
{
for (;; ++*num_headers) {
CHECK_EOF();
if (*buf == '\015') {
++buf;
EXPECT_CHAR('\012');
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rax
leaq 0x105f3(%rip), %rbp # 0x1801c
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
xorps %xmm0, %xmm0
cmpq %r15, %rax
je 0x7b92
movzbl (%rax), %esi
cmpl $0xa, %esi
je 0x7b78
cmpl $0xd, %esi... | /mattn[P]clask/clask/../clask/picohttpparser.c |
main | int main(int argc, char* argv[]) {
argparse::ArgumentParser program("file", CLASK_VERSION);
program.add_argument("-dir")
.default_value("./public")
.help("public directory")
.metavar("PUBLIC_DIR")
.nargs(1);
program.add_argument("-addr")
.default_value("0.0.0.0:8080")
.help("se... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x5e0, %rsp # imm = 0x5E0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1088b(%rip), %rsi # 0x18689
leaq 0xf0(%rsp), %rdi
leaq 0x2f8(%rsp), %rdx
callq 0x88b6
leaq 0x10874(%rip), %rsi # 0x1868e
leaq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x88b6
movq 0x1d165(%rip),... | /mattn[P]clask/example/file/main.cxx |
clask::server_t::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void server_t::run(const std::string& addr) {
auto pos = addr.find_last_of(':');
if (pos == std::string::npos) {
throw std::runtime_error("invalid host:port");
}
auto host = addr.substr(0, pos);
auto port = std::stoi(addr.substr(pos + 1));
_run(host, port);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x6930
cmpq $-0x1, %rax
je 0x9024
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x6590
incq %r15
leaq 0x8(%rsp), %r... | /mattn[P]clask/clask/../clask/core.hpp |
argparse::Argument::is_positional(std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | static bool is_positional(std::string_view name,
std::string_view prefix_chars) {
auto first = lookahead(name);
if (first == eof) {
return true;
} else if (prefix_chars.find(static_cast<char>(first)) !=
std::string_view::npos) {
name.remove_prefix(1);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, (%rsp)
movq %rcx, 0x8(%rsp)
movb $0x1, %bl
testq %rdi, %rdi
je 0x9cc9
movq %rsi, %r14
movq %rdi, %r15
movsbl (%rsi), %esi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x9cd6
cmpq $-0x1, %rax
je 0x9cc9
decq %r15
je 0x9cc9
incq %r14
movq %r15, %rdi
movq %r14, %rsi
cal... | /mattn[P]clask/example/file/./argparse/argparse.hpp |
argparse::Argument::throw_required_arg_no_value_provided_error() const | void throw_required_arg_no_value_provided_error() const {
std::stringstream stream;
stream << m_used_name << ": no value provided.";
throw std::runtime_error(stream.str());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x63e0
leaq 0x38(%rsp), %rdi
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rsi
callq 0x65f0
leaq 0x9662(%rip), %rsi # 0x18aa7
movq %rax, %rdi
callq 0x6550
pushq $0x10
popq %rdi
callq 0x62a0
movq %rax, ... | /mattn[P]clask/example/file/./argparse/argparse.hpp |
clask::url_encode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | inline std::string url_encode(const std::string &value, bool escape_slash = true) {
std::ostringstream os;
os.fill('0');
os << std::hex;
for (char c : value) {
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
os << c;
continue;
}
if (!escape_slash && c == '/') {
os... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, 0x4(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x66a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
callq 0x62e0
movq %rbx, 0x8(%rsp)
movb $0x30, 0xe0... | /mattn[P]clask/clask/../clask/core.hpp |
argparse::Argument::Argument<1ul, 0ul>(std::basic_string_view<char, std::char_traits<char>>, std::array<std::basic_string_view<char, std::char_traits<char>>, 1ul>&&, std::integer_sequence<unsigned long, 0ul>) | explicit Argument(std::string_view prefix_chars,
std::array<std::string_view, N> &&a,
std::index_sequence<I...> /*unused*/)
: m_accepts_optional_like_value(false),
m_is_optional((is_optional(a[I], prefix_chars) || ...)),
m_is_required(false), m_is_repeatable... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %rsi, %r12
xorl %eax, %eax
movb... | /mattn[P]clask/example/file/./argparse/argparse.hpp |
argparse::ArgumentParser::operator[](std::basic_string_view<char, std::char_traits<char>>) const | Argument &operator[](std::string_view arg_name) const {
auto it = m_argument_map.find(arg_name);
if (it != m_argument_map.end()) {
return *(it->second);
}
if (!is_valid_prefix_char(arg_name.front())) {
std::string name(arg_name);
const auto legal_prefix_char = get_any_valid_prefix_char... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r15
leaq 0x40(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x100(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xd8b6
movq %rax, %rbx
leaq 0x108(%r15), %rax
cmpq %rax, %rbx
je 0x17119
movq 0x30(%rbx), %rbx
addq $0x10, %rb... | /mattn[P]clask/example/file/./argparse/argparse.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> argparse::Argument::get<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() const | T get() const {
if (!m_values.empty()) {
if constexpr (details::IsContainer<T>) {
return any_cast_container<T>(m_values);
} else {
return std::any_cast<T>(m_values.front());
}
}
if (m_default_value.has_value()) {
return std::any_cast<T>(m_default_value);
}
if ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x118(%rsi), %rsi
cmpq 0x120(%r14), %rsi
jne 0x1731c
cmpq $0x0, 0x68(%r14)
je 0x17330
addq $0x68, %r14
movq %r14, %rsi
movq %rbx, %rdi
callq 0x173fd
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq... | /mattn[P]clask/example/file/./argparse/argparse.hpp |
Shared_Multi_Field_constructors::test_method() | BOOST_AUTO_TEST_CASE(Shared_Multi_Field_constructors) {
#ifdef PM_GMP_FOUND
Shared_multi_field_element::initialize(5, 13);
test_multi_field_constructors<Shared_multi_field_element>();
#endif
Shared_multi_field_element_with_small_characteristics<>::initialize(5, 13);
test_multi_field_constructors<Shared_multi_fi... | pushq %rax
movl $0x5, %edi
movl $0xd, %esi
callq 0x231ea
popq %rax
jmp 0x2341c
| /GUDHI[P]gudhi-devel/src/Persistence_matrix/test/test_persistence_matrix_field.cpp |
cmyk_ycck_convert | METHODDEF(void)
cmyk_ycck_convert(j_compress_ptr cinfo, JSAMPARRAY input_buf,
JSAMPIMAGE output_buf, JDIMENSION output_row, int num_rows)
{
my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
register int r, g, b;
register JLONG *ctab = cconvert->rgb_ycc_tab;
register JSAMPROW inptr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, -0xc(%rsp)
movq %rdx, -0x8(%rsp)
testl %r8d, %r8d
jle 0x7b1d
movq 0x1d8(%rdi), %rax
movq 0x10(%rax), %rax
movl 0x30(%rdi), %ecx
movl $0xff, %r9d
testq %rcx, %rcx
je 0x7b04
movl -0xc(%rsp), %r14d
movq -0x8(%rsp), %rdx
movq (%rdx), %r10
movq 0x8... | /rui314[P]libjpeg-turbo/jccolor.c |
jinit_forward_dct | GLOBAL(void)
jinit_forward_dct(j_compress_ptr cinfo)
{
my_fdct_ptr fdct;
int i;
fdct = (my_fdct_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
sizeof(my_fdct_controller));
cinfo->fdct = (struct jpeg_forward_dct *)fdct;
fdct->pub.start_pass = start_pass_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movl $0x90, %edx
movl $0x1, %esi
callq *(%rax)
movq %rax, %rbx
movq %rax, 0x1e8(%r14)
leaq 0x17d(%rip), %rax # 0x7cce
movq %rax, (%rbx)
movl 0x114(%r14), %eax
cmpl $0x2, %eax
je 0x7ba3
cmpl $0x1, %eax
je 0x7b86
testl %eax, %eax
jne 0x7bc0
leaq ... | /rui314[P]libjpeg-turbo/jcdctmgr.c |
jinit_inverse_dct | GLOBAL(void)
jinit_inverse_dct(j_decompress_ptr cinfo)
{
my_idct_ptr idct;
int ci;
jpeg_component_info *compptr;
idct = (my_idct_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
sizeof(my_idct_controller));
cinfo->idct = (struct jpeg_inverse_dct *)idct;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x80, %edx
movl $0x1, %esi
callq *(%rax)
movq %rax, %r14
movq %rax, 0x258(%rbx)
leaq 0x61(%rip), %rax # 0x21ec1
movq %rax, (%r14)
cmpl $0x0, 0x38(%rbx)
jle 0x21eb5
movq 0x130(%rbx), %r15
addq $0x58, %r15
xorl %r12d,... | /rui314[P]libjpeg-turbo/jddctmgr.c |
start_pass_huff_decoder | METHODDEF(void)
start_pass_huff_decoder(j_decompress_ptr cinfo)
{
huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
int ci, blkn, dctbl, actbl;
d_derived_tbl **pdtbl;
jpeg_component_info *compptr;
/* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
* This ought to be an ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x250(%rdi), %r15
cmpl $0x0, 0x20c(%rdi)
jne 0x227c3
cmpl $0x3f, 0x210(%rbx)
jne 0x227c3
cmpl $0x0, 0x214(%rbx)
jne 0x227c3
cmpl $0x0, 0x218(%rbx)
je 0x227d8
movq (%rbx), %rax
movl $0x7a, 0x28(%rax)
movq %rbx, %rdi
movl $0... | /rui314[P]libjpeg-turbo/jdhuff.c |
consume_markers | METHODDEF(int)
consume_markers(j_decompress_ptr cinfo)
{
my_inputctl_ptr inputctl = (my_inputctl_ptr)cinfo->inputctl;
int val;
if (inputctl->pub.eoi_reached) /* After hitting EOI, read no further */
return JPEG_REACHED_EOI;
val = (*cinfo->marker->read_markers) (cinfo);
switch (val) {
case JPEG_REACHE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x240(%rdi), %r15
movl $0x2, %ebx
cmpl $0x0, 0x24(%r15)
je 0x23d5b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq 0x248(%rdi), %rax
callq *0x8(%rax)
movl %eax, %ebx
cm... | /rui314[P]libjpeg-turbo/jdinput.c |
start_input_pass | METHODDEF(void)
start_input_pass(j_decompress_ptr cinfo)
{
per_scan_setup(cinfo);
latch_quant_tables(cinfo);
(*cinfo->entropy->start_pass) (cinfo);
(*cinfo->coef->start_input_pass) (cinfo);
cinfo->inputctl->consume_input = cinfo->coef->consume_data;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1b0(%rdi), %eax
cmpl $0x1, %eax
jne 0x240ea
movq 0x1b8(%rbx), %rcx
movl 0x1c(%rcx), %eax
movl %eax, 0x1d8(%rbx)
movl 0x20(%rcx), %eax
movl %eax, 0x1dc(%rbx)
movabsq $0x100000001, %rdx # imm = 0x100000001
movq %rdx, ... | /rui314[P]libjpeg-turbo/jdinput.c |
jinit_d_main_controller | GLOBAL(void)
jinit_d_main_controller(j_decompress_ptr cinfo, boolean need_full_buffer)
{
my_main_ptr main_ptr;
int ci, rgroup, ngroups;
jpeg_component_info *compptr;
main_ptr = (my_main_ptr)
(*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
sizeof(my_main_control... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl $0x88, %edx
movl $0x1, %esi
callq *(%rax)
movq %rax, %r14
movq %rax, 0x228(%rbx)
leaq 0x166(%rip), %rax # 0x2446a
movq %rax, (%r14)
testl %ebp, %ebp
je 0x2431a
movq (%rbx), ... | /rui314[P]libjpeg-turbo/jdmainct.c |
process_data_context_main | METHODDEF(void)
process_data_context_main(j_decompress_ptr cinfo, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
{
my_main_ptr main_ptr = (my_main_ptr)cinfo->main;
/* Read input data if we haven't filled the main buffer yet */
if (!main_ptr->buffer_full) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x228(%rdi), %r12
cmpl $0x0, 0x60(%r12)
jne 0x246d0
movq 0x230(%rbx), %rax
movslq 0x78(%r12), %rcx
movq 0x68(%r12,%rcx,8), %rsi
movq %rbx, %rdi
callq *0x18(%rax)
testl ... | /rui314[P]libjpeg-turbo/jdmainct.c |
process_restart | LOCAL(boolean)
process_restart(j_decompress_ptr cinfo)
{
phuff_entropy_ptr entropy = (phuff_entropy_ptr)cinfo->entropy;
int ci;
/* Throw away any unused bits remaining in bit buffer; */
/* include any full bytes in next_marker's count of discarded bytes */
cinfo->marker->discarded_bytes += entropy->bitstate.... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x248(%rdi), %rax
movq 0x250(%rdi), %r14
movl 0x20(%r14), %ecx
leal 0x7(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x3, %edx
addl %edx, 0x24(%rax)
movl $0x0, 0x20(%r14)
callq *0x10(%rax)
testl %eax, %eax
je 0x2aa48
cmpl $0x0, 0x1b0(%rbx)
jle 0x2aa1e
xorl ... | /rui314[P]libjpeg-turbo/jdphuff.c |
post_process_prepass | METHODDEF(void)
post_process_prepass(j_decompress_ptr cinfo, JSAMPIMAGE input_buf,
JDIMENSION *in_row_group_ctr,
JDIMENSION in_row_groups_avail, JSAMPARRAY output_buf,
JDIMENSION *out_row_ctr, JDIMENSION out_rows_avail)
{
my_post_ptr post = (my_post_ptr)c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %ecx, %r9d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x238(%rdi), %rbp
leaq 0x28(%rbp), %r12
cmpl $0x0, 0x28(%rbp)
jne 0x2ac7d
movq 0x8(%r14), %rax
movq 0x10(%rbp), %rsi
movl 0x24(%rbp), %edx
movl 0x2... | /rui314[P]libjpeg-turbo/jdpostct.c |
jinit_upsampler | GLOBAL(void)
jinit_upsampler(j_decompress_ptr cinfo)
{
my_upsample_ptr upsample;
int ci;
jpeg_component_info *compptr;
boolean need_buffer, do_fancy;
int h_in_group, v_in_group, h_out_group, v_out_group;
if (!cinfo->master->jinit_upsampler_no_alloc) {
upsample = (my_upsample_ptr)
(*cinfo->mem->al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x220(%rdi), %rax
cmpl $0x0, 0x6c(%rax)
je 0x2addf
movq 0x260(%rbx), %r14
jmp 0x2ae19
movq 0x8(%rbx), %rax
movl $0x100, %edx # imm = 0x100
movq %rbx, %rdi
movl $0x1, %esi
callq *(%rax)
movq %rax, %r14
movq... | /rui314[P]libjpeg-turbo/jdsample.c |
h2v1_fancy_upsample | METHODDEF(void)
h2v1_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
{
JSAMPARRAY output_data = *output_data_ptr;
register JSAMPROW inptr, outptr;
register int invalue;
register JDIMENSION colctr;
int inrow;
for (i... | cmpl $0x0, 0x19c(%rdi)
jle 0x2b2a0
pushq %rbx
movq (%rcx), %rax
xorl %ecx, %ecx
movq (%rdx,%rcx,8), %r8
movq (%rax,%rcx,8), %r10
leaq 0x1(%r8), %r9
movzbl (%r8), %r11d
movb %r11b, (%r10)
leal (%r11,%r11,2), %r11d
movzbl 0x1(%r8), %r8d
addl %r11d, %r8d
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, 0x1(%r10)
movl 0x28(%rsi)... | /rui314[P]libjpeg-turbo/jdsample.c |
h1v2_fancy_upsample | METHODDEF(void)
h1v2_fancy_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
{
JSAMPARRAY output_data = *output_data_ptr;
JSAMPROW inptr0, inptr1, outptr;
#if BITS_IN_JSAMPLE == 8
int thiscolsum, bias;
#else
JLONG thiscolsum, b... | cmpl $0x0, 0x19c(%rdi)
jle 0x2b39b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rcx), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
leaq (%rdx,%rcx,8), %r9
movslq %r8d, %r8
xorl %r10d, %r10d
cmpl $0x1, %r10d
movw $0x2, %r11w
sbbw $0x0, %r11w
cmpl $0x0, 0x28(%rsi)
je 0x2b376
xorl %r14d, %r14d
testl %r... | /rui314[P]libjpeg-turbo/jdsample.c |
h2v2_upsample | METHODDEF(void)
h2v2_upsample(j_decompress_ptr cinfo, jpeg_component_info *compptr,
JSAMPARRAY input_data, JSAMPARRAY *output_data_ptr)
{
JSAMPARRAY output_data = *output_data_ptr;
register JSAMPROW inptr, outptr;
register JSAMPLE invalue;
JSAMPROW outend;
int inrow, outrow;
inrow = outrow = ... | cmpl $0x0, 0x19c(%rdi)
jle 0x2b56e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rcx), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movl 0x88(%r14), %eax
testq %rax, %rax
je 0x2b534
movq (%r15,%r12,8), %rcx
addq %rcx, %rax
movq (%rbx,%r13,8), %rdx
xorl %esi, %esi
movb (%rdx,%... | /rui314[P]libjpeg-turbo/jdsample.c |
jpeg_read_coefficients | GLOBAL(jvirt_barray_ptr *)
jpeg_read_coefficients(j_decompress_ptr cinfo)
{
if (cinfo->global_state == DSTATE_READY) {
/* First call: initialize active modules */
transdecode_master_selection(cinfo);
cinfo->global_state = DSTATE_RDCOEFS;
}
if (cinfo->global_state == DSTATE_RDCOEFS) {
/* Absorb who... | pushq %rbx
movq %rdi, %rbx
cmpl $0xca, 0x24(%rdi)
jne 0x2b744
movl $0x1, 0x58(%rbx)
cmpl $0x0, 0x13c(%rbx)
je 0x2b6a3
movq %rbx, %rdi
callq 0x5090
jmp 0x2b6be
cmpl $0x0, 0x138(%rbx)
je 0x2b6b6
movq %rbx, %rdi
callq 0x51e0
jmp 0x2b6be
movq %rbx, %rdi
callq 0x50b0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5050
movq 0x8(%rb... | /rui314[P]libjpeg-turbo/jdtrans.c |
jpeg_fdct_float | GLOBAL(void)
jpeg_fdct_float(FAST_FLOAT *data)
{
FAST_FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
FAST_FLOAT tmp10, tmp11, tmp12, tmp13;
FAST_FLOAT z1, z2, z3, z4, z5, z11, z13;
FAST_FLOAT *dataptr;
int ctr;
/* Pass 1: process rows. */
dataptr = data;
for (ctr = DCTSIZE - 1; ctr >= 0; ctr--)... | xorl %eax, %eax
movaps 0x4170b(%rip), %xmm0 # 0x6d0c0
movups 0x50(%rdi,%rax), %xmm6
movups 0x70(%rdi,%rax), %xmm10
movups (%rdi,%rax), %xmm12
movups 0x10(%rdi,%rax), %xmm11
movups 0x20(%rdi,%rax), %xmm5
movups 0x30(%rdi,%rax), %xmm9
movups 0x40(%rdi,%rax), %xmm13
movups 0x60(%rdi,%rax), %xmm14
movaps %xmm14, %xmm7
m... | /rui314[P]libjpeg-turbo/jfdctflt.c |
jpeg_fdct_islow | GLOBAL(void)
jpeg_fdct_islow(DCTELEM *data)
{
JLONG tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
JLONG tmp10, tmp11, tmp12, tmp13;
JLONG z1, z2, z3, z4, z5;
DCTELEM *dataptr;
int ctr;
SHIFT_TEMPS
/* Pass 1: process rows. */
/* Note results are scaled up by sqrt(8) compared to a true DCT; */
/* fur... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
xorl %eax, %eax
movswl (%rdi,%rax), %ecx
movswl 0xe(%rdi,%rax), %edx
leal (%rdx,%rcx), %r10d
subl %edx, %ecx
movswl 0x2(%rdi,%rax), %edx
movswl 0xc(%rdi,%rax), %esi
leal (%rsi,%rdx), %r9d
subl %esi, %edx
movswl 0x4(%rdi,%rax), %esi
m... | /rui314[P]libjpeg-turbo/jfdctint.c |
glfwInputMonitor | void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement)
{
if (action == GLFW_CONNECTED)
{
_glfw.monitorCount++;
_glfw.monitors =
realloc(_glfw.monitors, sizeof(_GLFWmonitor*) * _glfw.monitorCount);
if (placement == _GLFW_INSERT_FIRST)
{
m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x40001, %esi # imm = 0x40001
je 0x1098d
cmpl $0x40002, %ebp # imm = 0x40002
jne 0x10a22
leaq 0x3cf06(%rip), %rax # 0x4d7d8
movq 0x408(%rax), %r14
testq %r14, %r14
je 0x1094d
le... | /wjakob[P]glfw/src/monitor.c |
inja::InjaError::InjaError(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&) | explicit InjaError(const std::string& type, const std::string& message)
: std::runtime_error("[inja.exception." + type + "] " + message), type(type), message(message), location({0, 0}) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x283b5(%rip), %rsi # 0x320ce
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x9e34
leaq 0x2e0c4(%rip), %rdx # 0x37df4
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x9b4b
leaq 0x28(%rsp),... | /pantor[P]inja/include/inja/exceptions.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocato... | static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
InputAdapterType adapter,
detail::parser_callback_t<basic_json>cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false
)
{
return ::nlohmann::... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x18(%rax), %rdi
movq %rdi, 0x18(%rsp)
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x9f22
movups (%rax), %xmm1
addq $0x10, %rax
movaps %xmm1, (%rsp)
movq %rdi, 0x10(%rsp)
mo... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::json_... | json_value(value_t t)
{
switch (t)
{
case value_t::object:
{
object = create<object_t>();
break;
}
case value_t::array:
{
array = create<array_t>()... | pushq %rbx
movq %rdi, %rbx
cmpl $0x8, %esi
ja 0xa47d
movl %esi, %eax
leaq 0x26b90(%rip), %rcx # 0x31004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andq $0x0, (%rbx)
jmp 0xa4ac
callq 0xa4ae
jmp 0xa4a9
movb $0x0, (%rbx)
jmp 0xa4ac
callq 0xa502
jmp 0xa4a9
leaq 0x2bdcd(%rip), %rdi # 0x3626a
callq 0xa544
... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movb %dl, 0x20(%rdi)
orl $-0x1, 0x24(%rdi)
xorl %eax, %eax
movb %al, 0x28(%rdi)
leaq 0x70(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq ... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | pushq %rax
movq %rdi, %rax
andq $0x0, 0x68(%rdi)
movq 0x60(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x48, %rdi
movq 0x48(%rax), %rcx
cmpq %rcx, 0x50(%rax)
je 0xba78
movq %rcx, 0x50(%rax)
movb 0x24(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0xb8ee
popq %rax
retq
movq %rax, %rdi
callq 0x7a5d
nop
| /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x24(%rdi)
jne 0xbb1b
movq %rdi, %rbx
movaps 0x25612(%rip), %xmm0 # 0x310c0
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
pushq $-0x1
popq %r12
xorl %ebp, %ebp
cmpq $0x10, %r15
je 0xbaff
movl (%rsp,%r15), %r14d
movq %rbx, %rdi
callq 0xb734
... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
{
JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_HEDLEY_LIKELY... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x6, %rdx
ja 0xbbdf
movq %rdx, %rbx
pushq $0x54
popq %rax
btq %rdx, %rax
jae 0xbbdf
movq %rsi, %r15
movq %rdi, %r14
movsbl 0x24(%rdi), %esi
leaq 0x60(%rdi), %r12
movq %r12, %rdi
callq 0x6320
shlq $0x2, %rbx
testq %rbx, %rbx
je 0xbbcd
movq %r14, %rdi
callq 0xb... | /pantor[P]inja/third_party/include/nlohmann/json.hpp |
inja::Renderer::visit(inja::ExtendsStatementNode const&) | void visit(const ExtendsStatementNode& node) {
const auto included_template_it = template_storage.find(node.file);
if (included_template_it != template_storage.end()) {
const Template* parent_template = &included_template_it->second;
render_to(*output_stream, *parent_template, *data_input, &addition... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x10(%rsi), %r15
movq %r15, %rsi
callq 0x228ba
movq 0x10(%rbx), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x16a1e
addq $0x40, %rax
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rsi
leaq 0x70(%rbx), %r8
movq %... | /pantor[P]inja/include/inja/renderer.hpp |
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.