name string | code string | asm string | file string |
|---|---|---|---|
SocketInternals::Close() | bool SocketInternals::Close()
{
if (SocketFD != INVALID_SOCKET) {
#ifdef _MSC_VER
if (closesocket(SocketFD) != 0) {
outStr << "Close: failed to close socket, Error: " << WSAGetLastError() <<std::endl;
return false;
}
WSACleanup();
#else
if (close(SocketFD) != ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $-0x1, 0x8(%rax)
je 0x25cd2
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x68d0
cmpl $0x0, %eax
je 0x25cc7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
leaq 0x5ad5(%rip), %rsi # 0x2b76e
callq 0x64... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
SocketInternals::Open(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&, unsigned short) | bool SocketInternals::Open(const std::string &host, const std::string &multicast, unsigned short port)
{
#ifdef _MSC_VER
WSADATA wsaData;
int retval = WSAStartup(WINSOCKVERSION, &wsaData);
if (retval != 0) {
outStr << "WSAStartup failed with error code " << retval << std::endl;
return false;... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movw %cx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movw $0x2, 0x34(%rax)
movzwl -0x22(%rbp), %edi
callq 0x6080
movw %ax, %cx
movq -0x88(%rbp), %rax
movw %cx, 0x36(%rax)
movq -0... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
EthUdpPort::IP_String[abi:cxx11](unsigned int) | std::string EthUdpPort::IP_String(uint32_t IPaddr)
{
char IPstr[INET_ADDRSTRLEN];
#ifdef _MSC_VER
// Windows does not provide inet_ntop prior to Vista, so we use inet_ntoa.
strncpy(IPstr, inet_ntoa(*reinterpret_cast<const struct in_addr *>(&IPaddr)), INET_ADDRSTRLEN);
#else
inet_ntop(AF_INET, reinterpre... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %edi
leaq -0xc(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movl $0x10, %ecx
callq 0x64b0
leaq -0x21(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x67... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
SocketInternals::SetMulticastIP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool SocketInternals::SetMulticastIP(const std::string &multicast)
{
unsigned long s_addr_new = EthUdpPort::IP_ULong(multicast);
unsigned long first_byte = s_addr_new & 0x000000ff;
if ((first_byte >= 224) && (first_byte <= 239)) {
ServerAddrBroadcast.sin_addr.s_addr = s_addr_new;
return true... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x260b0
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x28(%rbp)
cmpq $0xe0, -0x28(%rbp)
jb 0x261ca
cmpq $0xef... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
SocketInternals::Send(unsigned char const*, unsigned long, SocketInternals::EthDestType, unsigned char) | int SocketInternals::Send(const unsigned char *bufsend, size_t msglen, EthDestType destType, unsigned char ip_offset)
{
int retval;
if (destType == DEST_BROADCAST) {
retval = sendto(SocketFD, reinterpret_cast<const char *>(bufsend), msglen, 0,
reinterpret_cast<struct sockaddr *>(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x24(%rbp)
jne 0x26234
movq -0x38(%rbp), %r8
movl 0x8(%r8), %edi
movq -0x18(%rbp), %rsi
m... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
SocketInternals::FlushRecv() | int SocketInternals::FlushRecv(void)
{
unsigned char buffer[FW_QRESPONSE_SIZE];
int numFlushed = 0;
// If the packet is larger than FW_QRESPONSE_SIZE, the excess bytes will be discarded.
while (Recv(buffer, FW_QRESPONSE_SIZE, 0.0) > 0)
numFlushed++;
return numFlushed;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x14, %edx
xorps %xmm0, %xmm0
callq 0x26350
cmpl $0x0, %eax
jle 0x268b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
EthUdpPort::EthUdpPort(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, std::ostream&, bool (*)(EthBasePort&, unsigned char, std::ostream&)) | EthUdpPort::EthUdpPort(int portNum, const std::string &serverIP, bool forceFwBridge, std::ostream &debugStream, EthCallbackType cb):
EthBasePort(portNum, forceFwBridge, debugStream, cb),
ServerIP(serverIP),
MulticastIP(ETH_UDP_MULTICAST_DEFAULT_IP),
UDP_port(1394)
{
sockPtr = new SocketInternals(deb... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
mo... | /jhu-cisst[P]mechatronics-software/lib/code/EthUdpPort.cpp |
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
| /lucaderi[P]CRoaring/src/memory.c |
roaring_bitmap_lazy_or_inplace | void roaring_bitmap_lazy_or_inplace(roaring_bitmap_t *x1,
const roaring_bitmap_t *x2,
const bool bitsetconversion) {
uint8_t result_type = 0;
int length1 = x1->high_low_container.size;
const int length2 = x2->high_low_container.size;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movb $0x0, 0xb(%rsp)
movl (%rsi), %ecx
testl %ecx, %ecx
je 0x5ea3
movq %rsi, %rbx
movl (%rdi), %eax
testl %eax, %eax
je 0x5eb2
movl %edx, 0x34(%rsp)
movq %rax, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x10(%rdi), %rax
movzwl (%rax), %eax
mo... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_rank | uint64_t roaring_bitmap_rank(const roaring_bitmap_t *bm, uint32_t x) {
uint64_t size = 0;
uint32_t xhigh = x >> 16;
for (int i = 0; i < bm->high_low_container.size; i++) {
uint32_t key = bm->high_low_container.keys[i];
if (xhigh > key) {
size +=
container_get_card... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jle 0xa752
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movl %esi, %ebp
shrl $0x10, %ebp
xorl %r12d, %r12d
xorl %ebx, %ebx
movq 0x10(%r14), %rax
movzwl (%rax,%r12,2), %r13d
cmpl %r13d, %ebp
jbe 0xa68e
movq 0x8(%r14), %rax
movq 0x18(%... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_rank_many | void roaring_bitmap_rank_many(const roaring_bitmap_t *bm, const uint32_t *begin,
const uint32_t *end, uint64_t *ans) {
uint64_t size = 0;
int i = 0;
const uint32_t *iter = begin;
while (i < bm->high_low_container.size && iter != end) {
uint32_t x = *iter;
u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
cmpl $0x0, (%rdi)
setle %al
cmpq %rdx, %rsi
sete %cl
orb %al, %cl
jne 0xa990
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r8
xorl %r12d, %r12d
xorl %r9d, %r9d
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl (%r15), %ecx
mo... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_get_index | int64_t roaring_bitmap_get_index(const roaring_bitmap_t *bm, uint32_t x) {
int64_t index = 0;
const uint16_t xhigh = x >> 16;
int32_t high_idx = ra_get_index(&bm->high_low_container, xhigh);
if (high_idx < 0) return -1;
for (int i = 0; i < bm->high_low_container.size; i++) {
uint32_t key = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %esi, %ebp
shrl $0x10, %ebp
movslq (%rdi), %rax
testq %rax, %rax
je 0xa9cc
movq 0x10(%r14), %rcx
cmpw %bp, -0x2(%rcx,%rax,2)
jne 0xab11
decl %eax
testl %eax, %eax
js 0xab08
cmpl $0x0, (%r14)
jle 0xab59
movl %esi, 0xc... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_minimum | uint32_t roaring_bitmap_minimum(const roaring_bitmap_t *bm) {
if (bm->high_low_container.size > 0) {
container_t *c = bm->high_low_container.containers[0];
uint8_t type = bm->high_low_container.typecodes[0];
uint32_t key = bm->high_low_container.keys[0];
uint32_t lowvalue = container... | pushq %rbx
cmpl $0x0, (%rdi)
jle 0xabbc
movq %rdi, %rax
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq (%rdx), %rdi
movq 0x18(%rax), %rax
movb (%rax), %al
cmpb $0x4, %al
jne 0xab9f
movb 0x8(%rdi), %al
movq (%rdi), %rdi
movzwl (%rcx), %ebx
cmpb $0x3, %al
je 0xabae
movzbl %al, %eax
cmpl $0x2, %eax
jne 0xabc3
cmpl $0x0, ... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_maximum | uint32_t roaring_bitmap_maximum(const roaring_bitmap_t *bm) {
if (bm->high_low_container.size > 0) {
container_t *container =
bm->high_low_container.containers[bm->high_low_container.size - 1];
uint8_t typecode =
bm->high_low_container.typecodes[bm->high_low_container.size - ... | pushq %rbx
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0xac24
movq %rdi, %rax
decl %ecx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
movq (%rsi,%rcx,8), %rdi
movq 0x18(%rax), %rax
movb (%rax,%rcx), %al
cmpb $0x4, %al
jne 0xac01
movb 0x8(%rdi), %al
movq (%rdi), %rdi
movzwl (%rdx,%rcx,2), %ebx
cmpb $0x3, %al
je 0xac28
movzbl %a... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_select | bool roaring_bitmap_select(const roaring_bitmap_t *bm, uint32_t rank,
uint32_t *element) {
container_t *container;
uint8_t typecode;
uint16_t key;
uint32_t start_rank = 0;
int i = 0;
bool valid = false;
while (!valid && i < bm->high_low_container.size) {
co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x0, 0xc(%rsp)
cmpl $0x0, (%rdi)
jle 0xacfb
movl %esi, %ebp
xorl %r12d, %r12d
leaq 0xc(%rsp), %r15
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq (%rax,%r12,8), %rdi
movb (%rcx,%r12), %al
cmpb $0x4, %al
jne 0x... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_intersect | bool roaring_bitmap_intersect(const roaring_bitmap_t *x1,
const roaring_bitmap_t *x2) {
const int length1 = x1->high_low_container.size,
length2 = x2->high_low_container.size;
uint64_t answer = 0;
int pos1 = 0, pos2 = 0;
while (pos1 < length1 && pos2 < length... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %r10d
movl (%rsi), %r11d
xorl %r15d, %r15d
movl $0xffff, %r12d # imm = 0xFFFF
xorl %r13d, %r13d
movq %rsi, (%rsp)
cmpl %r10d, %r13d
setl %al
cmpl %r11d, %r15d
setl %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0... | /lucaderi[P]CRoaring/src/roaring.c |
roaring_bitmap_contains | inline int32_t ra_get_index(const roaring_array_t *ra, uint16_t x) {
if ((ra->size == 0) || ra->keys[ra->size - 1] == x) return ra->size - 1;
return binarySearch(ra->keys, (int32_t)ra->size, x);
} | movslq (%rdi), %rax
testq %rax, %rax
je 0xb417
movl %esi, %ecx
shrl $0x10, %ecx
movq 0x10(%rdi), %rdx
cmpw %cx, -0x2(%rdx,%rax,2)
jne 0xb441
decl %eax
testl %eax, %eax
js 0xb43e
movq 0x8(%rdi), %rcx
movq 0x18(%rdi), %rdx
movl $0xffff, %r8d # imm = 0xFFFF
andl %r8d, %eax
movzbl (%rdx,%rax), %edx
movq (%rcx,%ra... | /lucaderi[P]CRoaring/include/roaring/roaring_array.h |
ra_append_copy_range | void ra_append_copy_range(roaring_array_t *ra, const roaring_array_t *sa,
int32_t start_index, int32_t end_index,
bool copy_on_write) {
extend_array(ra, end_index - start_index);
for (int32_t i = start_index; i < end_index; ++i) {
const int32_t pos = r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, 0x4(%rsp)
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, %esi
subl %edx, %esi
callq 0xc6d0
subl %ebp, %ebx
movq %rbx, 0x10(%rsp)
jle 0xc91e
movslq %ebp, %r13
leaq (,%r13,2), %rax
movq %rax, 0x8(%rsp... | /lucaderi[P]CRoaring/src/roaring_array.c |
ra_append_move_range | void ra_append_move_range(roaring_array_t *ra, roaring_array_t *sa,
int32_t start_index, int32_t end_index) {
extend_array(ra, end_index - start_index);
for (int32_t i = start_index; i < end_index; ++i) {
const int32_t pos = ra->size;
ra->keys[pos] = sa->keys[i];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %ecx, %esi
subl %edx, %esi
callq 0xc6d0
cmpl %r15d, %ebp
jle 0xca1a
movslq %r15d, %rax
movslq %ebp, %rcx
movslq (%r14), %rdx
movq 0x10(%rbx), %rsi
movzwl (%rsi,%rax,2), %esi
movq 0x10(%r14), %rdi... | /lucaderi[P]CRoaring/src/roaring_array.c |
ra_insert_new_key_value_at | void ra_insert_new_key_value_at(roaring_array_t *ra, int32_t i, uint16_t key,
container_t *c, uint8_t typecode) {
extend_array(ra, 1);
// May be an optimization opportunity with DIY memmove
memmove(&(ra->keys[i + 1]), &(ra->keys[i]),
sizeof(uint16_t) * (ra->size -... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl $0x1, %esi
callq 0xc6d0
movq 0x10(%r14), %rax
movslq %r12d, %r12
leaq (%rax,%r12,2), %rdi
addq $0x2, %rdi
leaq (%rax,%r12,2), %rsi
movslq (%r14), %rdx
subq %r12, %rdx
addq %rdx, %... | /lucaderi[P]CRoaring/src/roaring_array.c |
union_uint16 | size_t union_uint16(const uint16_t *set_1, size_t size_1, const uint16_t *set_2,
size_t size_2, uint16_t *buffer) {
size_t pos = 0, idx_1 = 0, idx_2 = 0;
if (0 == size_2) {
memmove(buffer, set_1, size_1 * sizeof(uint16_t));
return size_1;
}
if (0 == size_1) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
testq %rcx, %rcx
je 0xec87
movq %rcx, %r14
testq %rbx, %rbx
je 0xec95
movzwl (%rdx), %edi
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r15d, %r15d
movzwl (%rsi,%rax,2), %r9d
incq %r15
cmpw %di, %r9w
jb 0xec38
jbe 0xec48
movw %di, -0x2(%r8,%r15,2)
leaq 0x1(%rcx),... | /lucaderi[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 0xf9f6
testq %rax, %rax
je 0xf9f3
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 0xf9c1
jbe 0xf9cb
leaq 0x1(%r9), %rbx
cmpq %rcx, %rbx
jae 0xf9e6
movl (%rdx,%rbx,4), %r10d
incq %rsi
movq %rbx, %r9
... | /lucaderi[P]CRoaring/src/array_util.c |
fast_union_uint16 | size_t fast_union_uint16(const uint16_t *set_1, size_t size_1,
const uint16_t *set_2, size_t size_2,
uint16_t *buffer) {
#if CROARING_IS_X64
if (croaring_hardware_support() & ROARING_SUPPORTS_AVX2) {
// compute union with smallest array first
if (siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
callq 0x20570
testb $0x1, %al
jne 0xfa3d
cmpq %r14, %r15
jae 0xfa50
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
jmp 0xfa5c
cmpq %r14, %r15
jae 0xfa6d
movq %r13, %rdi
... | /lucaderi[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 0xfbc5
vmovdqu (%rdi), %ymm0
vpxor (%rsi), %ymm0, %ymm0
addq $0x20, %rdi
addq $0x20, %rsi
vptest %ymm0, %ymm0
je 0xfb90
xorl %eax, %eax
vzeroupper
retq
movq (%rdi), %rdx
addq $0x8, %rdi
leaq 0x8... | /lucaderi[P]CRoaring/src/array_util.c |
avx512_array_container_to_uint32_array | int avx512_array_container_to_uint32_array(void *vout, const uint16_t *array,
size_t cardinality, uint32_t base) {
int outpos = 0;
uint32_t *out = (uint32_t *)vout;
size_t i = 0;
for (; i + sizeof(__m256i) / sizeof(uint16_t) <= cardinality;
i += sizeof... | cmpq $0x10, %rdx
jae 0xfbfc
xorl %r8d, %r8d
xorl %eax, %eax
jmp 0xfc42
vpbroadcastd %ecx, %zmm0
xorl %eax, %eax
movabsq $0x1000000000, %r9 # imm = 0x1000000000
xorl %r8d, %r8d
movq %r8, %r10
vpmovzxwd (%rsi,%r8,2), %zmm1
vpaddd %zmm1, %zmm0, %zmm1
movq %rax, %r8
sarq $0x1e, %r8
vmovdqu64 %zmm1, (%rdi,%r8)
leaq 0x1... | /lucaderi[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... | pushq %rbx
leaq (%rdx,%rcx,4), %r9
testq %rsi, %rsi
sete %al
cmpq $0x41, %rcx
setl %cl
orb %al, %cl
jne 0xfd3e
vmovdqa64 0x133ec(%rip), %zmm0 # 0x23080
xorl %ecx, %ecx
movl %r8d, %r10d
movq %rdx, %r11
movq (%rdi,%rcx,8), %rax
popcntq %rax, %rbx
kmovq %rax, %k1
vpcompressb %zmm0, %zmm1 {%k1} {z}
vpbroadcastd %r10d, %zmm... | /lucaderi[P]CRoaring/src/bitset_util.c |
bitset_extract_setbits_avx2 | CROARING_TARGET_AVX2
size_t bitset_extract_setbits_avx2(const uint64_t *words, size_t length,
uint32_t *out, size_t outcapacity,
uint32_t base) {
uint32_t *initout = out;
__m256i baseVec = _mm256_set1_epi32(base - 1);
__m256i incVec = _mm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq (%rdx,%rcx,4), %r9
testq %rsi, %rsi
sete %al
cmpq $0x40, %rcx
setl %cl
orb %al, %cl
jne 0xff58
leal -0x1(%r8), %eax
vmovd %eax, %xmm0
vpbroadcastd %xmm0, %ymm0
vpbroadcastd 0x1314a(%rip), %ymm1 # 0x23008
xorl %r15d, %r15d
leaq 0x131f8(%rip), %r10 ... | /lucaderi[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... | testq %rdx, %rdx
je 0x10431
addq %rdx, %rdx
xorl %eax, %eax
movzwl (%rsi,%rax), %ecx
movl %ecx, %r8d
movl $0x1, %r9d
shlq %cl, %r9
shrl $0x6, %r8d
xorq %r9, (%rdi,%r8,8)
addq $0x2, %rax
cmpq %rax, %rdx
jne 0x10410
retq
nop
| /lucaderi[P]CRoaring/src/bitset_util.c |
bitset_print | inline void bitset_print(const bitset_t *b) {
printf("{");
for (size_t i = 0; bitset_next_set_bit(b, &i); i++) {
printf("%zu, ", i);
}
printf("}");
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x7b, %edi
callq 0x1040
leaq 0x15da3(%rip), %r14 # 0x261f0
xorl %r15d, %r15d
movq %r15, %rax
shrq $0x6, %rax
movq 0x8(%rbx), %rdx
cmpq %rdx, %rax
jae 0x104a8
movq (%rbx), %rsi
movq (%rsi,%rax,8), %rdi
movl %r15d, %ecx
shrq %cl, %rdi
testq %rdi, %rdi
je 0x1047b
... | /lucaderi[P]CRoaring/include/roaring/bitset/bitset.h |
bitset_set_to_value | inline void bitset_set_to_value(bitset_t *bitset, size_t i, bool flag) {
size_t shiftedi = i / 64;
uint64_t mask = ((uint64_t)1) << (i % 64);
uint64_t dynmask = ((uint64_t)flag) << (i % 64);
if (shiftedi >= bitset->arraysize) {
if (!bitset_grow(bitset, shiftedi + 1)) {
return;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movl $0x1, %r14d
shlq %cl, %r14
movl %edx, %r15d
shlq %cl, %r15
movq %rsi, %r12
shrq $0x6, %r12
cmpq 0x8(%rdi), %r12
jb 0x1062e
leaq 0x1(%r12), %rsi
movq %rbx, %rdi
callq 0x10e15
testb %al, %al
je 0x1063f
movq (%rbx), %rax
notq %r14
... | /lucaderi[P]CRoaring/include/roaring/bitset/bitset.h |
bitset_create | bitset_t *bitset_create(void) {
bitset_t *bitset = NULL;
/* Allocate the bitset itself. */
if ((bitset = (bitset_t *)roaring_malloc(sizeof(bitset_t))) == NULL) {
return NULL;
}
bitset->array = NULL;
bitset->arraysize = 0;
bitset->capacity = 0;
return bitset;
} | pushq %rax
movl $0x18, %edi
callq 0x2369
testq %rax, %rax
je 0x1073c
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
popq %rcx
retq
xorl %eax, %eax
popq %rcx
retq
| /lucaderi[P]CRoaring/src/bitset.c |
bitset_resize | bool bitset_resize(bitset_t *bitset, size_t newarraysize, bool padwithzeroes) {
if (newarraysize > SIZE_MAX / 64) {
return false;
}
size_t smallest =
newarraysize < bitset->arraysize ? newarraysize : bitset->arraysize;
if (bitset->capacity < newarraysize) {
uint64_t *newarray;
... | movq %rsi, %rax
shrq $0x3a, %rax
je 0x1093f
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rax
cmpq %rsi, %r12
movq %rsi, %r15
cmovbq %r12, %r15
cmpq %rsi, %rax
jae 0x10998
cmpq $0x1... | /lucaderi[P]CRoaring/src/bitset.c |
bitset_contains_all | bool bitset_contains_all(const bitset_t *CBITSET_RESTRICT b1,
const bitset_t *CBITSET_RESTRICT b2) {
size_t min_size = b1->arraysize;
if (b1->arraysize > b2->arraysize) {
min_size = b2->arraysize;
}
for (size_t k = 0; k < min_size; k++) {
if ((b1->array[k] & b2->... | movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdx
movq %rcx, %rax
cmovbq %rdx, %rax
testq %rax, %rax
je 0x10fa2
movq (%rdi), %rdi
movq (%rsi), %r8
xorl %r9d, %r9d
movq (%rdi,%r9,8), %r10
notq %r10
testq %r10, (%r8,%r9,8)
jne 0x10fb3
incq %r9
cmpq %r9, %rax
jne 0x10f8d
movb $0x1, %al
cmpq %rdx, %rcx
jbe 0x10fb5
... | /lucaderi[P]CRoaring/src/bitset.c |
bitset_union_count | size_t bitset_union_count(const bitset_t *CBITSET_RESTRICT b1,
const bitset_t *CBITSET_RESTRICT b2) {
size_t answer = 0;
size_t minlength =
b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
size_t k = 0;
for (; k + 3 < minlength; k += 4) {
answer +=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
cmpq %rdx, %rcx
movq %rdx, %r9
cmovbq %rcx, %r9
cmpq $0x4, %r9
jb 0x110de
movq (%rdi), %r10
movq (%rsi), %r11
xorl %ebx, %ebx
movdqa 0x151b7(%rip), %xmm0 # 0x261c0
movdqa 0x151bf(%rip), %xmm1 # 0x261d0
movd... | /lucaderi[P]CRoaring/src/bitset.c |
bitset_inplace_intersection | void bitset_inplace_intersection(bitset_t *CBITSET_RESTRICT b1,
const bitset_t *CBITSET_RESTRICT b2) {
size_t minlength =
b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
size_t k = 0;
for (; k < minlength; ++k) {
b1->array[k] &= b2->array[k];
... | movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rcx
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
testq %rcx, %rcx
je 0x11436
movq (%rsi), %rsi
movq (%rdi), %r8
xorl %eax, %eax
movq (%rsi,%rax,8), %r9
andq %r9, (%r8,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x11424
jmp 0x11438
xorl %eax, %eax
subq %rax, %rdx
jbe 0x11452
shlq $0x3, %rax
addq (%r... | /lucaderi[P]CRoaring/src/bitset.c |
bitset_inplace_symmetric_difference | bool bitset_inplace_symmetric_difference(bitset_t *CBITSET_RESTRICT b1,
const bitset_t *CBITSET_RESTRICT b2) {
size_t minlength =
b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
size_t k = 0;
for (; k < minlength; ++k) {
b1->array[k] ^=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x8(%rsi), %rsi
cmpq %rsi, %rbx
movq %rsi, %rax
cmovbq %rbx, %rax
testq %rax, %rax
je 0x1163f
movq (%r14), %rcx
movq (%r15), %rdx
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
xorq %r8, (%rdx,%rdi,8)
incq %rdi
cmp... | /lucaderi[P]CRoaring/src/bitset.c |
bitset_symmetric_difference_count | size_t bitset_symmetric_difference_count(const bitset_t *CBITSET_RESTRICT b1,
const bitset_t *CBITSET_RESTRICT b2) {
size_t minlength =
b1->arraysize < b2->arraysize ? b1->arraysize : b2->arraysize;
size_t k = 0;
size_t answer = 0;
for (; k < minlength; +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %r8
cmpq %r8, %rdx
movq %r8, %rcx
cmovbq %rdx, %rcx
testq %rcx, %rcx
je 0x1171e
movq (%rdi), %r9
movq (%rsi), %r10
xorl %eax, %eax
movabsq $0x5555555555555555, %r11 # imm = 0x5555555555555555
movabsq $0x33333333333333... | /lucaderi[P]CRoaring/src/bitset.c |
array_container_rank_many | inline uint32_t array_container_rank_many(const array_container_t *arr,
uint64_t start_rank,
const uint32_t *begin,
const uint32_t *end, uint64_t *ans) {
const uint16_t high = (uint16_t)((*b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, -0x8(%rsp)
movq %rdi, -0x10(%rsp)
movq %rdx, %r9
movq %rdx, -0x18(%rsp)
cmpq %rcx, %rdx
je 0x11a41
movq -0x18(%rsp), %r9
movl (%r9), %edi
xorl %r11d, %r11d
movl (%r9), %ebp
movl %ebp, %ebx
xorl %edi, %ebx
cmpl $0x10000, %ebx # imm = 0... | /lucaderi[P]CRoaring/include/roaring/containers/array.h |
array_container_contains | inline bool array_container_contains(const array_container_t *arr,
uint16_t pos) {
// return binarySearch(arr->array, arr->cardinality, pos) >= 0;
// binary search with fallback to linear search for short ranges
int32_t low = 0;
const uint16_t *carr = (const uint1... | movq 0x8(%rdi), %rax
movl (%rdi), %ecx
decl %ecx
xorl %edx, %edx
leal 0x10(%rdx), %edi
cmpl %edi, %ecx
jl 0x11af2
leal (%rdx,%rcx), %edi
movl %edi, %r8d
shrl %r8d
andl $-0x2, %edi
leal 0x1(%r8), %r9d
decl %r8d
cmpw %si, (%rax,%rdi)
cmovbel %ecx, %r8d
cmovbl %ecx, %r8d
cmovael %edx, %r9d
movl %r8d, %ecx
movl %r9d, %edx
... | /lucaderi[P]CRoaring/include/roaring/containers/array.h |
array_container_create_range | array_container_t *array_container_create_range(uint32_t min, uint32_t max) {
array_container_t *answer =
array_container_create_given_capacity(max - min + 1);
if (answer == NULL) return answer;
answer->cardinality = 0;
for (uint32_t k = min; k < max; k++) {
answer->array[answer->cardina... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl %esi, %edi
subl %ebp, %edi
incl %edi
callq 0x11b2b
testq %rax, %rax
je 0x11bdf
movl $0x0, (%rax)
cmpl %ebp, %ebx
jbe 0x11bdf
movslq (%rax), %rcx
movq %rcx, %rdx
addq %rcx, %rdx
addq 0x8(%rax), %rdx
movw %bp, (%rdx)
incl %ebp
addq $0x2, %rdx
incl %ecx... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_clone | ALLOW_UNALIGNED
array_container_t *array_container_clone(const array_container_t *src) {
array_container_t *newcontainer =
array_container_create_given_capacity(src->capacity);
if (newcontainer == NULL) return NULL;
newcontainer->cardinality = src->cardinality;
memcpy(newcontainer->array, src-... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x4(%rdi), %edi
callq 0x11b2b
testq %rax, %rax
je 0x11c17
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
addq %rdx, %rdx
callq 0x1140
jmp 0x11c19
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq ... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_offset | void array_container_offset(const array_container_t *c, container_t **loc,
container_t **hic, uint16_t offset) {
array_container_t *lo = NULL, *hi = NULL;
int top, lo_cap, hi_cap;
top = (1 << 16) - offset;
lo_cap = count_less(c->array, c->cardinality, top);
if (loc && l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl (%rdi), %r11d
testl %r11d, %r11d
je 0x11c8d
movl %ecx, %eax
negl %eax
movq 0x8(%r14), %r10
decl %r11d
xorl %ebx, %ebx
cmpl %r11d, %ebx
jg 0x11c91
leal (%rbx,%r11), %r9d
movl %r9d, %r8d
shrl %r8d
andl $-0x2, %r9d
movz... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_add_from_range | void array_container_add_from_range(array_container_t *arr, uint32_t min,
uint32_t max, uint16_t step) {
for (uint32_t value = min; value < max; value += step) {
array_container_append(arr, value);
}
} | cmpl %edx, %esi
jae 0x120f4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movzwl %cx, %r15d
movl 0x4(%r14), %esi
cmpl %esi, (%r14)
jne 0x120d2
incl %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x11fbf
movq 0x8(%r14), %rax
movslq (%r14), %rcx
leal 0x1(%rcx), %edx
mo... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_andnot | void array_container_andnot(const array_container_t *array_1,
const array_container_t *array_2,
array_container_t *out) {
if (out->capacity < array_1->cardinality)
array_container_grow(out, array_1->cardinality, false);
#if CROARING_IS_X64
if ((cro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %esi
cmpl %esi, 0x4(%rdx)
jge 0x12163
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11fbf
callq 0x20570
movq 0x8(%r15), %rdi
movslq (%r15), %rsi
cmpq %r14, %rbx
je 0x12190
cmpq %r15, %rbx
je 0x12190
andl $0x1, %eax
je 0x12190
movq 0... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_intersection | void array_container_intersection(const array_container_t *array1,
const array_container_t *array2,
array_container_t *out) {
int32_t card_1 = array1->cardinality, card_2 = array2->cardinality,
min_card = minimum_int32(card_1, card_2);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
movslq (%rdi), %r15
movslq (%rsi), %r14
cmpl %r14d, %r15d
movl %r14d, %esi
cmovll %r15d, %esi
cmpl %esi, 0x4(%rdx)
jge 0x1222c
addl $0x8, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11fbf
movl %r15d, %eax
shll $0x6, ... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_intersection_cardinality | int array_container_intersection_cardinality(const array_container_t *array1,
const array_container_t *array2) {
int32_t card_1 = array1->cardinality, card_2 = array2->cardinality;
const int threshold = 64; // subject to tuning
if (card_1 * threshold < card_2) {... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movslq (%rdi), %r14
movslq (%rsi), %rbx
movl %r14d, %eax
shll $0x6, %eax
cmpl %ebx, %eax
jge 0x122d4
movq 0x8(%r12), %rdi
movq 0x8(%r15), %rdx
movq %r14, %rsi
movq %rbx, %rcx
jmp 0x122ed
movl %ebx, %eax
shll $0x6, %eax
cmpl %r14d, %e... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_intersect | bool array_container_intersect(const array_container_t *array1,
const array_container_t *array2) {
int32_t card_1 = array1->cardinality, card_2 = array2->cardinality;
const int threshold = 64; // subject to tuning
if (card_1 * threshold < card_2) {
return intersect_sk... | movslq (%rdi), %rax
movslq (%rsi), %rcx
movl %eax, %edx
shll $0x6, %edx
cmpl %ecx, %edx
jge 0x12350
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rdx
movq %rax, %rsi
jmp 0xe920
movl %ecx, %edx
shll $0x6, %edx
cmpl %eax, %edx
jge 0x1236f
movq 0x8(%rsi), %rsi
movq 0x8(%rdi), %rdx
movq %rsi, %rdi
movq %rcx, %rsi
movq %rax, %rcx
j... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_to_uint32_array | ALLOW_UNALIGNED
int array_container_to_uint32_array(void *vout, const array_container_t *cont,
uint32_t base) {
#if CROARING_IS_X64
int support = croaring_hardware_support();
#if CROARING_COMPILER_SUPPORTS_AVX512
if (support & ROARING_SUPPORTS_AVX512) {
return avx512_... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x20570
testb $0x2, %al
jne 0x12448
testb $0x1, %al
jne 0x1245e
cmpl $0x0, (%r15)
je 0x12474
xorl %eax, %eax
movq 0x8(%r15), %rcx
movzwl (%rcx,%rax,2), %ecx
addl %ebx, %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
movslq (%r15), %rcx
cmpq ... | /lucaderi[P]CRoaring/src/containers/array.c |
array_container_read | int32_t array_container_read(int32_t cardinality, array_container_t *container,
const char *buf) {
if (container->capacity < cardinality) {
array_container_grow(container, cardinality, false);
}
container->cardinality = cardinality;
memcpy(container->array, buf, cont... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpl %edi, 0x4(%rsi)
jge 0x126c7
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x11fbf
movl %ebp, (%rbx)
movq 0x8(%rbx), %rdi
movslq %ebp, %rdx
addq %rdx, %rdx
movq %r14, %rsi
callq 0x1140
movl (%rbx), %eax
addl %eax, %eax
popq %rb... | /lucaderi[P]CRoaring/src/containers/array.c |
bitset_container_create | bitset_container_t *bitset_container_create(void) {
bitset_container_t *bitset =
(bitset_container_t *)roaring_malloc(sizeof(bitset_container_t));
if (!bitset) {
return NULL;
}
size_t align_size = 32;
#if CROARING_IS_X64
int support = croaring_hardware_support();
if (support & ... | pushq %rbx
movl $0x10, %edi
callq 0x2369
testq %rax, %rax
je 0x12885
movq %rax, %rbx
callq 0x20570
andl $0x2, %eax
shll $0x4, %eax
leaq 0x20(%rax), %rdi
movl $0x2000, %esi # imm = 0x2000
callq 0x2387
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1287d
movl $0x2000, %edx # imm = 0x2000
movq %rax, %rdi
x... | /lucaderi[P]CRoaring/src/containers/bitset.c |
bitset_container_offset | void bitset_container_offset(const bitset_container_t *c, container_t **loc,
container_t **hic, uint16_t offset) {
bitset_container_t *bc = NULL;
uint64_t val;
uint16_t b, i, end;
b = offset >> 6;
i = offset % 64;
end = 1024 - b;
if (loc != NULL) {
bc =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movl %ecx, %ebp
shrl $0x6, %ebp
movl %ecx, %r12d
andl $0x3f, %r12d
movl $0x400, %r15d # imm = 0x400
subl %ebp, %r15d
testq %rsi, %rsi
je 0x12ca2
movq %rsi, %r13
callq 0... | /lucaderi[P]CRoaring/src/containers/bitset.c |
bitset_container_compute_cardinality | int bitset_container_compute_cardinality(const bitset_container_t *bitset) {
int support = croaring_hardware_support();
#if CROARING_COMPILER_SUPPORTS_AVX512
if (support & ROARING_SUPPORTS_AVX512) {
return (int)avx512_vpopcount(
(const __m512i *)bitset->words,
BITSET_CONTAINER_SI... | pushq %rbx
movq %rdi, %rbx
callq 0x20570
testb $0x2, %al
jne 0x12f90
movq 0x8(%rbx), %rdi
testb $0x1, %al
jne 0x12f9b
pxor %xmm0, %xmm0
xorl %eax, %eax
movdqa 0x133b2(%rip), %xmm1 # 0x261c0
movdqa 0x133ba(%rip), %xmm2 # 0x261d0
movdqa 0x133c2(%rip), %xmm3 # 0x261e0
pxor %xmm5, %xmm5
movq 0x20(%rdi,%rax), %xmm4... | /lucaderi[P]CRoaring/src/containers/bitset.c |
bitset_container_set_range | void bitset_container_set_range(bitset_container_t *bitset, uint32_t begin,
uint32_t end) {
bitset_set_range(bitset->words, begin, end);
bitset->cardinality =
bitset_container_compute_cardinality(bitset); // could be smarter
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl %edx, %esi
je 0x13025
movl %edx, %r14d
movq 0x8(%rbx), %r15
movl %esi, %eax
shrl $0x6, %eax
movq $-0x1, %rdx
movl %esi, %ecx
shlq %cl, %rdx
leal -0x1(%r14), %ebp
shrl $0x6, %ebp
movl %ebp, %ecx
subl %eax, %ecx
jne 0x12fe5
negb %r14b
movl %r14d,... | /lucaderi[P]CRoaring/src/containers/bitset.c |
bitset_container_intersect | bool bitset_container_intersect(const bitset_container_t *src_1,
const bitset_container_t *src_2) {
// could vectorize, but this is probably already quite fast in practice
const uint64_t *__restrict__ words_1 = src_1->words;
const uint64_t *__restrict__ words_2 = src_2->words... | movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rdx
movq (%rdx), %rsi
movb $0x1, %al
testq %rsi, (%rcx)
je 0x1304d
retq
xorl %esi, %esi
movq %rsi, %rax
cmpq $0x3ff, %rsi # imm = 0x3FF
je 0x1306b
movq 0x8(%rdx,%rax,8), %rdi
leaq 0x1(%rax), %rsi
testq %rdi, 0x8(%rcx,%rax,8)
je 0x1304f
cmpq $0x3ff, %rax # imm ... | /lucaderi[P]CRoaring/src/containers/bitset.c |
avx512_vpopcount | static inline uint64_t avx512_vpopcount(const __m512i *data,
const uint64_t size) {
const uint64_t limit = size - size % 4;
__m512i total = _mm512_setzero_si512();
uint64_t i = 0;
for (; i < limit; i += 4) {
VPOPCNT_AND_ADD(data + i, 0, total);
VP... | addq $0xc0, %rdi
vpxor %xmm0, %xmm0, %xmm0
movq $-0x4, %rax
vpopcntq -0xc0(%rdi), %zmm1
vpaddq %zmm0, %zmm1, %zmm0
vpopcntq -0x80(%rdi), %zmm1
vpopcntq -0x40(%rdi), %zmm2
vpaddq %zmm2, %zmm1, %zmm1
vpaddq %zmm1, %zmm0, %zmm0
vpopcntq (%rdi), %zmm1
vpaddq %zmm1, %zmm0, %zmm0
addq $0x4, %rax
addq $0x100, %rdi ... | /lucaderi[P]CRoaring/include/roaring/bitset_util.h |
avx2_harley_seal_popcount256 | static uint64_t avx2_harley_seal_popcount256(const __m256i *data,
const uint64_t size) {
__m256i total = _mm256_setzero_si256();
__m256i ones = _mm256_setzero_si256();
__m256i twos = _mm256_setzero_si256();
__m256i fours = _mm256_setzero_si256();
_... | vpxor %xmm3, %xmm3, %xmm3
movq $-0x10, %rax
vpbroadcastb 0x13208(%rip), %ymm0 # 0x26310
vbroadcasti128 0x131df(%rip), %ymm2 # ymm2 = mem[0,1,0,1]
vbroadcasti128 0x131e6(%rip), %ymm1 # ymm1 = mem[0,1,0,1]
vxorpd %xmm6, %xmm6, %xmm6
vxorpd %xmm7, %xmm7, %xmm7
vxorpd %xmm5, %xmm5, %xmm5
vxorpd %xmm4, %xmm4, %xmm4
vlddqu (... | /lucaderi[P]CRoaring/include/roaring/bitset_util.h |
bitset_container_equals | ALLOW_UNALIGNED
bool bitset_container_equals(const bitset_container_t *container1, const bitset_container_t *container2) {
if((container1->cardinality != BITSET_UNKNOWN_CARDINALITY) && (container2->cardinality != BITSET_UNKNOWN_CARDINALITY)) {
if(container1->cardinality != container2->cardinality) {
return ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
cmpl $-0x1, %ecx
je 0x19154
movl (%rbx), %eax
cmpl $-0x1, %eax
je 0x19154
cmpl %eax, %ecx
jne 0x19189
movb $0x1, %al
cmpl $0x10000, %ecx # imm = 0x10000
je 0x1918b
callq 0x20570
testb $0x2, %al
jne 0x1917a
testb $0x1, %al
jne 0x... | /lucaderi[P]CRoaring/src/containers/bitset.c |
avx512_bitset_container_equals | static inline bool _avx512_bitset_container_equals(const bitset_container_t *container1, const bitset_container_t *container2) {
const __m512i *ptr1 = (const __m512i*)container1->words;
const __m512i *ptr2 = (const __m512i*)container2->words;
for (size_t i = 0; i < BITSET_CONTAINER_SIZE_IN_WORDS*sizeof(uint64_t)/... | movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
vmovdqu64 (%rax), %zmm0
vpcmpneqd (%rcx), %zmm0, %k0
kortestw %k0, %k0
je 0x191c3
xorl %eax, %eax
vzeroupper
retq
movl $0x40, %edx
xorl %edi, %edi
movq %rdi, %rsi
cmpq $0x7f, %rdi
je 0x191f0
vmovdqu64 (%rax,%rdx), %zmm0
vpcmpneqd (%rcx,%rdx), %zmm0, %k0
addq $0x40, %rdx
leaq 0x... | /lucaderi[P]CRoaring/src/containers/bitset.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 0x1982d
movb 0x8(%rdi), %sil
movq (%rdi), %rdi
cmpb $0x3, %sil
je 0x19847
movzbl %sil, %eax
movl %edx, %esi
cmpl $0x2, %eax
jne 0x18dee
jmp 0x124f5
movl %edx, %esi
jmp 0x1fde2
| /lucaderi[P]CRoaring/include/roaring/containers/containers.h |
container_internal_validate | bool container_internal_validate(const container_t *container, uint8_t typecode,
const char **reason) {
if (container == NULL) {
*reason = "container is NULL";
return false;
}
// Not using container_unwrap_shared because it asserts if shared containers
//... | testq %rdi, %rdi
je 0x19870
cmpb $0x4, %sil
jne 0x198a6
movl 0xc(%rdi), %eax
testl %eax, %eax
je 0x19879
movb 0x8(%rdi), %al
cmpb $0x4, %al
jne 0x19882
leaq 0xcbb7(%rip), %rax # 0x26425
jmp 0x19893
leaq 0xcb79(%rip), %rax # 0x263f0
jmp 0x198d9
leaq 0xcb82(%rip), %rax # 0x26402
jmp 0x19893
movq (%rdi), %r... | /lucaderi[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 0xca70(%rip), %rax # 0x263c8
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
jmp 0x12b80
jmp 0x1ebc5
xorl %eax, %eax
retq
jmp 0x11be6
| /lucaderi[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 0x199f1
cmpl $0x2, %esi
jne 0x19a08
movslq (%rdi), %rax
movq 0x8(%rdi), %rcx
movzwl -0x2(%rcx,%rax,2), %ecx
decq %rax
jmp 0x19a31
movslq (%rdi), %rsi
leaq -0x1(%rsi), %rax
movq 0x8(%rdi), %rdi
movzwl -0x2(%rdi,%rsi,4), %ecx
addw -0x4(%rdi,%rsi,4), %cx
jmp 0x19a31
movq 0x8(%rdi), %rax
movl $0x3ff, %es... | /lucaderi[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 %r13
pushq %r12
pushq %rbx
movq %rdi, -0x8(%rsp)
movq 0x38(%rsp), %rbx
movl $0x0, (%rbx)
testl %r9d, %r9d
je 0x1a10f
movq %rcx, %r10
cmpb $0x1, %sil
je 0x1a116
movzbl %sil, %eax
cmpl $0x2, %eax
jne 0x1a1d5
movq -0x8(%rsp), %rax
movl (%rax), %esi
movl (%rdx), %eax
movl %esi, %ecx
s... | /lucaderi[P]CRoaring/src/containers/containers.c |
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 0x11b2b
movq %rax, %rbx
movl (%r14), %eax
movl %eax, (%rbx)
callq 0x20570
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rdx
testb $0x2, %al
jne 0x1a53c
movl $0x400, %esi # imm = 0x400
xorl %ecx, %ecx
callq 0x10173
jmp 0x1a54c
movslq (%r14), %rc... | /lucaderi[P]CRoaring/src/containers/convert.c |
convert_run_optimize | container_t *convert_run_optimize(container_t *c, uint8_t typecode_original,
uint8_t *typecode_after) {
if (typecode_original == RUN_CONTAINER_TYPE) {
container_t *newc =
convert_run_to_efficient_container(CAST_run(c), typecode_after);
if (newc != c) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x1a99e
movl %esi, %ebp
movq %rbx, %rdi
cmpl $0x3, %esi
jne 0x1aa23
movq %r14, %rsi
callq 0x1a787
movq %rax, %r15
cmpq %rbx, %rax
je 0x1ab9b
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x197ac
jmp... | /lucaderi[P]CRoaring/src/containers/convert.c |
array_bitset_container_intersection | void array_bitset_container_intersection(const array_container_t *src_1,
const bitset_container_t *src_2,
array_container_t *dst) {
if (dst->capacity < src_1->cardinality) {
array_container_grow(dst, src_1->cardinality, false)... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %esi
cmpl %esi, 0x4(%rdx)
jge 0x1af4b
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11fbf
movslq (%r15), %rax
testq %rax, %rax
jle 0x1af8d
movq 0x8(%r15), %rcx
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rdi
xorl %r8d, %r8d
xorl %esi, %es... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
array_bitset_container_intersect | bool array_bitset_container_intersect(const array_container_t *src_1,
const bitset_container_t *src_2) {
const int32_t origcard = src_1->cardinality;
for (int i = 0; i < origcard; ++i) {
uint16_t key = src_1->array[i];
if (bitset_container_contains(src_2, ke... | movslq (%rdi), %rcx
testq %rcx, %rcx
setg %al
jle 0x1aff5
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
movzwl (%rdx), %edi
movl %edi, %r8d
shrl $0x6, %r8d
movq (%rsi,%r8,8), %r8
btq %rdi, %r8
jae 0x1aff6
retq
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rcx
je 0x1b01c
movzwl (%rdx,%rax,2), %r8d
movl %r8d, %edi
shrl $0x6, %... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
run_bitset_container_intersection_cardinality | int run_bitset_container_intersection_cardinality(
const run_container_t *src_1, const bitset_container_t *src_2) {
if (run_container_is_full(src_1)) {
return bitset_container_cardinality(src_2);
}
int answer = 0;
for (int32_t rlepos = 0; rlepos < src_1->n_runs; ++rlepos) {
rle16_t r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r8
movl (%rdi), %eax
movq %rax, -0x8(%rsp)
cmpq $0x1, %rax
jne 0x1b755
cmpw $0x0, (%r8)
jne 0x1b755
cmpw $-0x1, 0x2(%r8)
je 0x1b8de
cmpl $0x0, -0x8(%rsp)
jle 0x1b8da
movq 0x8(%rsi), %r9
xorl %r10d, %r10d
movabsq $0x5555555555555555, %r11... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
bitset_bitset_container_intersection | bool bitset_bitset_container_intersection(const bitset_container_t *src_1,
const bitset_container_t *src_2,
container_t **dst) {
const int newCardinality = bitset_container_and_justcard(src_1, src_2);
if (newCardinality > DEFAUL... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x15a6e
movl %eax, %ebx
cmpl $0x1001, %eax # imm = 0x1001
jl 0x1bb89
callq 0x12831
movq %rax, (%r12)
testq %rax, %rax
je 0x1bbb4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x15814
movq (%r12... | /lucaderi[P]CRoaring/src/containers/mixed_intersection.c |
array_run_container_union | void array_run_container_union(const array_container_t *src_1,
const run_container_t *src_2,
run_container_t *dst) {
if (run_container_is_full(src_2)) {
run_container_copy(src_2, dst);
return;
}
// TODO: see whether the "2*" is sp... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %esi
cmpl $0x1, %esi
jne 0x1bf05
movq 0x8(%r14), %rax
cmpw $0x0, (%rax)
jne 0x1bf05
cmpw $-0x1, 0x2(%rax)
je 0x1c130
addl (%r15), %esi
addl %esi, %esi
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq... | /lucaderi[P]CRoaring/src/containers/mixed_union.c |
array_run_container_inplace_union | void array_run_container_inplace_union(const array_container_t *src_1,
run_container_t *src_2) {
if (run_container_is_full(src_2)) {
return;
}
const int32_t maxoutput = src_1->cardinality + src_2->n_runs;
const int32_t neededcapacity = maxoutput + src_2->n_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %rax
cmpq $0x1, %rax
jne 0x1c171
movq 0x8(%rbx), %rcx
cmpw $0x0, (%rcx)
jne 0x1c171
cmpw $-0x1, 0x2(%rcx)
je 0x1c3a9
movslq (%r14), %r15
addq %rax, %r15
leal (%r15,%rax), %esi
cmpl %esi, 0x4(%rbx)
jge 0x1c18d
movq %rbx... | /lucaderi[P]CRoaring/src/containers/mixed_union.c |
array_container_equal_bitset | bool array_container_equal_bitset(const array_container_t* container1,
const bitset_container_t* container2) {
if (container2->cardinality != BITSET_UNKNOWN_CARDINALITY) {
if (container2->cardinality != container1->cardinality) {
return false;
}
}
... | movl (%rsi), %eax
cmpl $-0x1, %eax
je 0x1c6cb
cmpl (%rdi), %eax
jne 0x1c74c
pushq %rbx
movq 0x8(%rsi), %rax
xorl %edx, %edx
xorl %esi, %esi
xorl %ecx, %ecx
movq (%rax,%rdx,8), %r10
movl %edx, %r8d
shll $0x6, %r8d
movq %r10, %r9
testq %r10, %r10
je 0x1c71b
cmpl (%rdi), %ecx
jge 0x1c710
bsfq %r9, %r10
orl %r8d, %r10d
mov... | /lucaderi[P]CRoaring/src/containers/mixed_equal.c |
run_container_equals_array | bool run_container_equals_array(const run_container_t* container1,
const array_container_t* container2) {
if (run_container_cardinality(container1) != container2->cardinality)
return false;
int32_t pos = 0;
for (int i = 0; i < container1->n_runs; ++i) {
const ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1fa90
cmpl (%rbx), %eax
jne 0x1c7be
movslq (%r14), %rcx
testq %rcx, %rcx
setle %al
jle 0x1c7c0
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
movzwl (%rax,%rsi,4), %r8d
movslq %edi, %r9
cmpw %r8w, (%rdx,%r9,2)
jne 0x1c7a... | /lucaderi[P]CRoaring/src/containers/mixed_equal.c |
array_container_is_subset_bitset | bool array_container_is_subset_bitset(const array_container_t* container1,
const bitset_container_t* container2) {
if (container2->cardinality != BITSET_UNKNOWN_CARDINALITY) {
if (container2->cardinality < container1->cardinality) {
return false;
}
... | movl (%rsi), %eax
cmpl $-0x1, %eax
je 0x1c8ea
cmpl (%rdi), %eax
jge 0x1c8ea
xorl %eax, %eax
retq
movslq (%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x1c8e9
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
movzwl (%rdx), %edi
movl %edi, %r8d
shrl $0x6, %r8d
movq (%rsi,%r8,8), %r8
btq %rdi, %r8
jae 0x1c8e9
movl $0x1, %edi
movq ... | /lucaderi[P]CRoaring/src/containers/mixed_subset.c |
run_container_is_subset_array | bool run_container_is_subset_array(const run_container_t* container1,
const array_container_t* container2) {
if (run_container_cardinality(container1) > container2->cardinality)
return false;
int32_t start_pos = -1, stop_pos = -1;
for (int i = 0; i < container1->n_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1fa90
movl (%rbx), %ecx
cmpl %ecx, %eax
jle 0x1c961
xorl %eax, %eax
jmp 0x1cb02
movslq (%r14), %rdx
testq %rdx, %rdx
setle %al
jle 0x1cb02
movq 0x8(%r14), %rsi
movq 0x8(%rbx), %rdi
leal -0x1(%rcx), %r8d
... | /lucaderi[P]CRoaring/src/containers/mixed_subset.c |
array_array_container_lazy_xor | bool array_array_container_lazy_xor(const array_container_t *src_1,
const array_container_t *src_2,
container_t **dst) {
int totalCardinality = src_1->cardinality + src_2->cardinality;
//
// We assume that operations involving bitset co... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %ebx
addl (%rdi), %ebx
cmpl $0x400, %ebx # imm = 0x400
jle 0x1daad
movq %r15, %rdi
callq 0x1a334
movq %rax, (%r12)
testq %rax, %rax
je 0x1dacb
movq %rax, %r15
movq 0x8(%rax), %rdi
movq 0x8(%r14... | /lucaderi[P]CRoaring/src/containers/mixed_xor.c |
array_bitset_container_andnot | void array_bitset_container_andnot(const array_container_t *src_1,
const bitset_container_t *src_2,
array_container_t *dst) {
// follows Java implementation as of June 2016
if (dst->capacity < src_1->cardinality) {
array_container_gro... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %esi
cmpl %esi, 0x4(%rdx)
jge 0x1dc7b
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11fbf
movslq (%r15), %rax
testq %rax, %rax
jle 0x1dcbd
movq 0x8(%r15), %rcx
movq 0x8(%rbx), %rdx
movq 0x8(%r14), %rdi
xorl %r8d, %r8d
xorl %esi, %es... | /lucaderi[P]CRoaring/src/containers/mixed_andnot.c |
absl::Substitute[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>, absl::substitute_internal::Arg const&, absl::substitute_internal::Arg const&, absl::substitute_internal::Arg const&) | ABSL_MUST_USE_RESULT inline std::string Substitute(
absl::string_view format, const substitute_internal::Arg& a0,
const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
std::string result;
SubstituteAndAppend(&result, format, a0, a1, a2);
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movups (%rcx), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups (%r8), %xmm0
movaps %xmm0, 0x10(%rcx)
movups (%r9), %xmm0
movaps %xmm0, 0x20(%rcx)
movl $0x3, %r8d
callq 0... | /google[P]bloaty/third_party/abseil-cpp/absl/strings/substitute.h |
bloaty::Rollup::CreateDiffModeRollupOutput(bloaty::Rollup*, bloaty::Options const&, bloaty::RollupOutput*) const | void CreateDiffModeRollupOutput(Rollup* base, const Options& options,
RollupOutput* output) const {
RollupRow* row = &output->toplevel_row_;
row->size.vm = vm_total_;
row->size.file = file_total_;
row->filtered_size.vm = filtered_vm_total_;
row->filtered_size.file =... | movq %rcx, %rax
movq %rdx, %rcx
movq %rsi, %rdx
movdqu (%rdi), %xmm0
movdqu %xmm0, 0x38(%rax)
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x48(%rax)
movdqa 0x1bcbd2(%rip), %xmm1 # 0x2446e0
movdqu %xmm1, 0x68(%rax)
testq %rsi, %rsi
je 0x87b25
movdqu (%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x38(%rax)
movb $0x1, 0xc0(... | /google[P]bloaty/src/bloaty.cc |
google::protobuf::internal::InternalMetadataWithArenaBase<google::protobuf::UnknownFieldSet, google::protobuf::internal::InternalMetadataWithArena>::~InternalMetadataWithArenaBase() | ~InternalMetadataWithArenaBase() {
if (have_unknown_fields() && arena() == NULL) {
delete PtrValue<Container>();
}
ptr_ = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testb $0x1, %r14b
je 0x93684
movq %r14, %rax
andq $-0x2, %rax
cmpq $0x0, 0x18(%rax)
jne 0x93684
andq $-0x2, %r14
je 0x93684
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x93663
movq %r14, %rdi
callq 0x1b1fea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x93677
mo... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/metadata_lite.h |
google::protobuf::io::EpsCopyOutputStream::WriteStringMaybeAliased(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char*) | uint8* WriteStringMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
std::ptrdiff_t size = s.size();
if (PROTOBUF_PREDICT_FALSE(
size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
return WriteStringMaybeAliasedOutline(num, s, ptr);
}
ptr = UnsafeVarint((num << ... | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x8(%rdx), %r14
cmpq $0x7f, %r14
jg 0x9376e
movq (%rdi), %rcx
leal (,%rsi,8), %eax
movl $0x1, %r8d
cmpl $0x80, %eax
jb 0x936f1
movl $0x2, %r8d
cmpl $0x4000, %eax # imm = 0x4000
jb 0x936f1
movl $0x3, %r8d
cmpl $0x200000, %eax # imm = 0x200000
jb 0x9... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream.h |
google::protobuf::internal::InternalMetadataWithArenaBase<google::protobuf::UnknownFieldSet, google::protobuf::internal::InternalMetadataWithArena>::mutable_unknown_fields_slow() | PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
Arena* my_arena = arena();
Container* container = Arena::Create<Container>(my_arena);
// Two-step assignment works around a bug in clang's static analyzer:
// https://bugs.llvm.org/show_bug.cgi?id=34198.
ptr_ = container;
ptr_ = reinterpret_ca... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testb $0x1, %r14b
jne 0x938f8
testq %r14, %r14
je 0x938ce
cmpq $0x0, 0x70(%r14)
jne 0x93902
leaq 0x59(%rip), %rdx # 0x93918
movl $0x20, %esi
movq %r14, %rdi
callq 0x6ec6c
jmp 0x938d8
movl $0x20, %edi
callq 0x6df30
xorps %xmm0, %xmm0
movups %xmm0,... | /google[P]bloaty/third_party/protobuf/src/google/protobuf/metadata_lite.h |
bloaty::(anonymous namespace)::ElfFile::GetRegion(unsigned long, unsigned long) const | string_view GetRegion(uint64_t start, uint64_t n) const {
return StrictSubstr(data_, start, n);
} | pushq %rax
movq %rdx, %rax
movq %rsi, %rdx
movq %rax, %rsi
addq %rdx, %rsi
jb 0x94e61
movq 0x8(%rdi), %rcx
cmpq %rcx, %rsi
ja 0x94e72
movq %rcx, %rsi
subq %rdx, %rsi
jb 0x94e83
cmpq %rax, %rsi
cmovbq %rsi, %rax
addq 0x10(%rdi), %rdx
popq %rcx
retq
leaq 0x1b28cc(%rip), %rdi # 0x247734
movl $0x4b, %esi
callq 0x9ed94
l... | /google[P]bloaty/src/elf.cc |
bloaty::wasm::WebAssemblyObjectFile::GetBuildId[abi:cxx11]() const | std::string GetBuildId() const override {
// Use the sourceMappingURL as the build ID to be able to match to the
// source map.
std::string id;
FindSection(file_data().data(), "sourceMappingURL",
[&id](Section& section) {
uint32_t size = ReadVarUInt32(§ion.contents... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq 0x28(%rax), %r14
movq 0x30(%rax), %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a873d(%rip), %rsi # 0x248de4... | /google[P]bloaty/src/webassembly.cc |
char const* __cxxabiv1::(anonymous namespace)::parse_block_invoke<__cxxabiv1::(anonymous namespace)::Db>(char const*, char const*, __cxxabiv1::(anonymous namespace)::Db&) | const char*
parse_block_invoke(const char* first, const char* last, C& db)
{
if (last - first >= 13)
{
const char test[] = "_block_invoke";
const char* t = first;
for (int i = 0; i < 13; ++i, ++t)
{
if (*t != test[i])
return first;
}
if... | movq %rdi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
cmpq $0xd, %rcx
jl 0xa24ce
pushq %rbx
leaq 0xd(%rax), %rbx
xorl %ecx, %ecx
leaq 0x1a741d(%rip), %rdi # 0x249873
movb (%rax,%rcx), %r8b
cmpb (%rcx,%rdi), %r8b
jne 0xa24cd
incq %rcx
cmpq $0xd, %rcx
jne 0xa2456
cmpq %rsi, %rbx
je 0xa24a6
cmpb $0x5f, (%rbx)
jne 0xa248b
lea... | /google[P]bloaty/third_party/demumble/third_party/libcxxabi/cxa_demangle.cpp |
re2::RE2::ReverseProgramSize() const | int RE2::ReverseProgramSize() const {
if (prog_ == NULL)
return -1;
Prog* prog = ReverseProg();
if (prog == NULL)
return -1;
return prog->size();
} | pushq %rbx
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpq $0x0, 0x70(%rdi)
je 0xb9306
callq 0xb912c
testq %rax, %rax
je 0xb9306
movl 0x10(%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
| /google[P]bloaty/third_party/re2/re2/re2.cc |
re2::RE2::NamedCapturingGroups[abi:cxx11]() const | const std::map<std::string, int>& RE2::NamedCapturingGroups() const {
std::call_once(named_groups_once_, [](const RE2* re) {
if (re->suffix_regexp_ != NULL)
re->named_groups_ = re->suffix_regexp_->NamedCaptures();
if (re->named_groups_ == NULL)
re->named_groups_ = empty_named_groups;
}, this);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0xcc, %rdi
leaq 0x8(%rsp), %rax
movq %rbx, (%rax)
leaq 0x7(%rsp), %rcx
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq 0x4c9b57(%rip), %r14 # 0x582f88
movq %rdx, %fs:(%r14)
movq 0x4c9b74(%rip), %r15 # 0x582fb0
leaq 0x256b(%r... | /google[P]bloaty/third_party/re2/re2/re2.cc |
re2::Compiler::CachedRuneByteSuffix(unsigned char, unsigned char, bool, int) | int Compiler::CachedRuneByteSuffix(uint8_t lo, uint8_t hi, bool foldcase,
int next) {
uint64_t key = MakeRuneCacheKey(lo, hi, foldcase, next);
std::unordered_map<uint64_t, int>::const_iterator it = rune_cache_.find(key);
if (it != rune_cache_.end())
return it->second;
int ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r9d
movslq %r8d, %rax
shlq $0x11, %rax
movl %esi, %edx
shll $0x9, %edx
orq %rax, %rdx
movl %r9d, %eax
leaq (%rdx,%rax,2), %rax
movl %ecx, %r10d
orq %rax, %r10
movq %r10, 0x8(%rsp)
movq 0x50(%rdi), %rbx
movq 0x58(%rdi), %r14
xorl %r12d, ... | /google[P]bloaty/third_party/re2/re2/compile.cc |
re2::Compiler::IsCachedRuneByteSuffix(int) | T& operator[](int pos) const {
return ptr_[pos];
} | movslq %esi, %rax
movq 0x38(%rdi), %rcx
movq 0x50(%rdi), %r9
movzbl 0x4(%rcx,%rax,8), %edx
movzbl 0x5(%rcx,%rax,8), %esi
movzwl 0x6(%rcx,%rax,8), %r8d
andl $0x1, %r8d
movl (%rcx,%rax,8), %eax
shrl $0x4, %eax
shlq $0x11, %rax
shll $0x9, %edx
orq %rax, %rdx
leaq (%rdx,%rsi,2), %rcx
orq %r8, %rcx
movq 0x58(%rdi), %r8
xorl... | /google[P]bloaty/third_party/re2/util/pod_array.h |
re2::DFA::AnalyzeSearch(re2::DFA::SearchParams*) | bool DFA::AnalyzeSearch(SearchParams* params) {
const StringPiece& text = params->text;
const StringPiece& context = params->context;
// Sanity check: make sure that text lies within context.
if (text.begin() < context.begin() || text.end() > context.end()) {
LOG(DFATAL) << "context does not contain text";... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
cmpq %rcx, %rax
jb 0xc515f
movq 0x8(%rbx), %rdx
addq %rax, %rdx
movq 0x18(%rbx), %rsi
addq %rcx, %rsi
cmpq %rsi, %rdx
jbe 0xc51a2
leaq 0x185d1d(%rip), %rsi # 0x24ae83
leaq 0x... | /google[P]bloaty/third_party/re2/re2/dfa.cc |
re2::Regexp::ParseState::DoConcatenation() | void Regexp::ParseState::DoConcatenation() {
Regexp* r1 = stacktop_;
if (r1 == NULL || IsMarker(r1->op())) {
// empty concatenation is special case
Regexp* re = new Regexp(kRegexpEmptyMatch, flags_);
PushRegexp(re);
}
DoCollapse(kRegexpConcat);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xcab9f
cmpb $0x16, (%rax)
jb 0xcabc6
movl $0x28, %edi
callq 0x6df30
movq %rax, %r14
movl (%rbx), %edx
movq %rax, %rdi
movl $0x2, %esi
callq 0xbbfb0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca154
movq %rbx, %rdi
movl $0x5, %esi
ad... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::DoRightParen() | bool Regexp::ParseState::DoRightParen() {
// Finish the current concatenation and alternation.
DoAlternation();
// The stack should be: LeftParen regexp
// Remove the LeftParen, leaving the regexp,
// parenthesized.
Regexp* r1;
Regexp* r2;
if ((r1 = stacktop_) == NULL ||
(r2 = r1->down_) == NULL ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xcac94
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0xcac4a
movq 0x10(%r15), %r14
testq %r14, %r14
je 0xcac4a
cmpb $0x16, (%r14)
jne 0xcac4a
movq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movzwl 0x2(%r14), %eax
movl %eax, (%rbx)
cmpl $0x0, 0x18(%r14)
jle 0xcac64
movb $0... | /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::DoAlternation() | void Regexp::ParseState::DoAlternation() {
DoVerticalBar();
// Now stack top is kVerticalBar.
Regexp* r1 = stacktop_;
stacktop_ = r1->down_;
r1->Decref();
DoCollapse(kRegexpAlternate);
} | pushq %rbx
movq %rdi, %rbx
callq 0xcaada
movq 0x20(%rbx), %rdi
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rbx)
callq 0xbc232
movq %rbx, %rdi
movl $0x6, %esi
popq %rbx
jmp 0xcb9d6
| /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::Regexp::ParseState::DoFinish() | Regexp* Regexp::ParseState::DoFinish() {
DoAlternation();
Regexp* re = stacktop_;
if (re != NULL && re->down_ != NULL) {
status_->set_code(kRegexpMissingParen);
status_->set_error_arg(whole_regexp_);
return NULL;
}
stacktop_ = NULL;
return FinishRegexp(re);
} | pushq %rbx
movq %rdi, %rbx
callq 0xcac94
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0xcaceb
cmpq $0x0, 0x10(%rsi)
je 0xcaceb
movq 0x18(%rbx), %rax
movl $0x6, (%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
popq %rbx
retq
movq $0x0, 0x20(%rbx)
popq %rbx
jmp 0xca0fe
nop
| /google[P]bloaty/third_party/re2/re2/parse.cc |
re2::ByteMapBuilder::Mark(int, int) | void ByteMapBuilder::Mark(int lo, int hi) {
DCHECK_GE(lo, 0);
DCHECK_GE(hi, 0);
DCHECK_LE(lo, 255);
DCHECK_LE(hi, 255);
DCHECK_LE(lo, hi);
// Ignore any [0-255] ranges. They cause us to recolor every range, which
// has no effect on the eventual result and is therefore a waste of time.
if (lo == 0 && h... | pushq %rax
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
xorl $0xff, %edx
orl %esi, %edx
je 0xce720
addq $0x440, %rdi # imm = 0x440
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
callq 0xcfd96
popq %rax
retq
| /google[P]bloaty/third_party/re2/re2/prog.cc |
cs_open | CAPSTONE_API cs_open(cs_arch arch, cs_mode mode, csh *handle)
{
cs_err err;
struct cs_struct *ud;
if (!cs_mem_malloc || !cs_mem_calloc || !cs_mem_realloc || !cs_mem_free || !cs_vsnprintf)
// Error: before cs_open(), dynamic memory management must be initialized
// with cs_option(CS_OPT_MEM)
return CS_ERR_MEMSE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x4b08f1(%rip), %rax # 0x5838e0
movq %rax, %xmm0
movq 0x4b08dc(%rip), %xmm1 # 0x5838d8
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq 0x4b08e8(%rip), %xmm0 # 0x5838f0
movq 0x4b08d8(%rip), %xmm2 # 0x5838e8
punpcklqdq %xm... | /google[P]bloaty/third_party/capstone/cs.c |
cs_close | CAPSTONE_API cs_close(csh *handle)
{
struct cs_struct *ud;
struct insn_mnem *next, *tmp;
if (*handle == 0)
// invalid handle
return CS_ERR_CSH;
ud = (struct cs_struct *)(*handle);
if (ud->printer_info)
cs_mem_free(ud->printer_info);
// free the linked list of customized mnemonic
tmp = ud->mnem_list;
w... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0xd3156
movq %rdi, %rbx
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0xd310b
callq *0x4b07e5(%rip) # 0x5838f0
movq 0xb0(%r14), %rdi
testq %rdi, %rdi
je 0xd3129
movq 0x28(%rdi), %r15
callq *0x4b07cf(%rip) # 0x5838f0... | /google[P]bloaty/third_party/capstone/cs.c |
DecodeArmMOVTWInstruction | static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = 0;
imm |= (fieldFromInstruction_4(I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
callq 0xd43b8
movl $0x3, %r15d
cmpl $0xdc, %eax
jne 0xe2adc
movq %r14, %rdi
movl %r12d, %esi
callq 0xe1cf2
movl %eax, %r15d
movb $0x1, %al
cmpl $0x3, %r15d
je 0xe2ad6
cmpl $0x1, %r15... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeSTRPreImm | static DecodeStatus DecodeSTRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0x10, %eax
andl $0xf, %eax
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
movl %eax, %edx
shll $0xd, %edx
orl %ecx, %edx
movl ... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.c |
DecodeSORegMemOperand | static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc ShOp;
unsigned shift;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0x5, %eax
andl $0x3, %eax
leaq 0x18602b(%rip), %rcx # 0x268fac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4000, %eax # imm = 0x4000
jmp 0xe2fa6
movl $0x2000,... | /google[P]bloaty/third_party/capstone/arch/ARM/ARMDisassembler.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.