name string | code string | asm string | file string |
|---|---|---|---|
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3c85a
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3c871
cmpl $0x2, %ecx
jne 0x3c8b2
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3caf8
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3cb0f
cmpl $0x2, %ecx
jne 0x3cb50
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3dbda
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3dbf1
cmpl $0x2, %ecx
jne 0x3dc32
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<char, fmt::v5::basic_format_specs<char>>::bin_writ... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3dcf4
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3dd10
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3de7e
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3de95
cmpl $0x2, %ecx
jne 0x3ded6
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<char, fmt::v5::basic_format_specs<char>>::num_writ... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3df98
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3dfb4
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::double_writer>(unsigned long, fmt::v5::align_spec const&, fmt::v5:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3e362
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3e379
cmpl $0x2, %ecx
jne 0x3e3ba
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<unsigned long, fmt::v5::basic_format_specs<char>>(unsigned long, fmt::v5::basic_format_specs<char> const&) | void write_int(T value, const Spec &spec) {
internal::handle_int_type_spec(spec.type(),
int_writer<T, Spec>(*this, value, spec));
} | subq $0x28, %rsp
movb 0x14(%rdx), %al
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
andl $0x0, 0x24(%rsp)
movl 0xc(%rdx), %ecx
testb $0x1, %cl
je 0x3e9ef
testb $0x2, %cl
pushq $0x20
popq %rcx
pushq $0x2b
popq %rdx
cmovel %ecx, %edx
movb %dl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
movsbl %al, %edi
leaq 0x8(... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>:... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3f110
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3f12c
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3f324
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3f33b
cmpl $0x2, %ecx
jne 0x3f37c
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
unsigned int fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>::count_digits<3u>() const | unsigned count_digits() const {
unsigned_type n = abs_value;
unsigned num_digits = 0;
do {
++num_digits;
} while ((n >>= BITS) != 0);
return num_digits;
} | movq 0x10(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %rdx
incl %eax
shrq $0x3, %rdx
cmpq $0x7, %rcx
movq %rdx, %rcx
ja 0x3f49d
retq
nop
| /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>:... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3f68e
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3f6aa
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>:... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3f6f6
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3f712
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5:... | void write_int(unsigned num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + num_digits;
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > size) {
pa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %eax
leaq 0x70(%rsp), %r9
movl %esi, %r11d
leaq (%r11,%rcx), %rsi
movb 0x4(%r8), %r10b
movl 0x8(%r8), %ebx
cmpl $0x4, %ebx
jne 0x3f79e
movl (%r8), %eax
cmpq %rax, %rsi
movq %rax, %rbx
cmovaq %rsi, %rbx
xorl %r11d, %r11d
subq %rsi, %rax
cmovaeq %rax... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::write_padded<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std:... | void basic_writer<Range>::write_padded(
std::size_t size, const align_spec &spec, F &&f) {
unsigned width = spec.width();
if (width <= size)
return f(reserve(size));
auto &&it = reserve(width);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - size;
if (spec.align()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl (%rdx), %eax
movq %rax, %r14
subq %rsi, %r14
jbe 0x3f87a
movq %rdx, %r15
movq %rax, %rsi
callq 0x2eb52
movq %rax, 0x8(%rsp)
movb 0x4(%r15), %bpl
movl 0x8(%r15), %ecx
cmpl $0x3, %ecx
je 0x3f891
cmpl $0x2, %ecx
jne 0x3f8d2
movq %... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>:... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3f92c
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3f948
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>:... | void operator()(It &&it) const {
if (prefix.size() != 0)
it = std::copy_n(prefix.data(), prefix.size(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x3f994
movq (%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x2b0f0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x3f9b0
leaq (%r15,%rdx), ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
void fmt::v5::internal::value<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::format_custom_arg<bidfx_public_api::SubscriptionStatus>(void const*, fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>&) | basic_format_args(const format_arg *args, size_type count)
: types_(-static_cast<int64_t>(count)) {
set_data(args);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd 0x625(%rip), %xmm0 # 0x40050
movq %rsp, %rbx
movaps %xmm0, (%rbx)
orl $-0x1, 0x10(%rbx)
movb $0x0, 0x14(%rbx)
andl $0x0, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movq %rsi, %r14
andl $0x0, 0x30(%rbx)
movq %rdi, %r15
andl $0x0, 0x38(%rbx)
movq %rbx, %rdi
callq 0x37b34... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/core.h |
decltype(fp0.out()) fmt::v5::formatter<bidfx_public_api::SubscriptionStatus, char, void>::format<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>(bidfx_public_api::SubscriptionStatus const&, fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::... | auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
basic_memory_buffer<Char> buffer;
internal::format_value(buffer, value);
basic_string_view<Char> str(buffer.data(), buffer.size());
return formatter<basic_string_view<Char>, Char>::format(str, ctx);
} | pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rax
andq $0x0, -0x10(%rax)
leaq 0xf101(%rip), %rcx # 0x4eba0
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
leaq 0x10(%rsp), %rdi
callq 0x3fb01
movups 0x18(%r... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/ostream.h |
void fmt::v5::internal::format_value<char, bidfx_public_api::SubscriptionStatus>(fmt::v5::internal::basic_buffer<char>&, bidfx_public_api::SubscriptionStatus const&) | void format_value(basic_buffer<Char> &buffer, const T &value) {
internal::formatbuf<Char> format_buf(buffer);
std::basic_ostream<Char> output(&format_buf);
output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
output << value;
buffer.resize(buffer.size());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x38596
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2b640
movq 0x48(%rsp), %rax
addq -0x18(%rax), %r15
pushq $0x5
popq %rsi
movq ... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/ostream.h |
void spdlog::logger::log<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(spdlog::source_loc, spdlog::level::level_enum, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void spdlog::logger::log(source_loc source, level::level_enum lvl, const char *fmt, const Args &... args)
{
if (!should_log(lvl))
{
return;
}
try
{
using details::fmt_helper::to_string_view;
fmt::memory_buffer buf;
fmt::format_to(buf, fmt, args...);
de... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, 0x10(%rsp)
movl 0x40(%rdi), %eax
cmpl %ecx, %eax
jg 0x3fe1a
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
leaq 0x90(%rsp), %rax
andq $0x0, -0x10(%rax)
leaq 0xee18(%rip), %rcx ... | /bidfx[P]bidfx-api-cpp/./lib/logging/spdlog/details/logger_impl.h |
fmt::v5::buffer_context<char>::type::iterator fmt::v5::format_to<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 500ul, char>(fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&, char const* const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::a... | inline typename buffer_context<Char>::type::iterator format_to(
basic_memory_buffer<Char, SIZE> &buf, const String &format_str,
const Args & ... args) {
internal::check_format_string<Args...>(format_str);
return vformat_to(
buf, basic_string_view<Char>(format_str),
make_format_args<typename ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq %r15, %rdi
callq 0x36cfe
movups (%rbx), %xmm0
movq %rsp, %r8
movaps %xmm0, (%r8)
pushq $0xb
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2da2b
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq... | /bidfx[P]bidfx-api-cpp/lib/logging/spdlog/fmt/bundled/format.h |
main | int main(void) {
const uint32_t dim = 8;
const uint32_t n_points = 100000;
const uint32_t n_queries = 1000;
float *points = new float[dim * n_points];
GenerateRandomFloat(points, dim * n_points);
const uint32_t M = 16;
const uint32_t ef_search = 256;
const uint32_t ef_construction = 50;
const uint32_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl $0x30d400, %edi # imm = 0x30D400
callq 0x4030
movq %rax, %rbx
movl $0xc3500, %esi # imm = 0xC3500
movq %rax, %rdi
callq 0x4a0e
leaq 0xc0(%rsp), %r14
movq $0x0, 0x8(%r14)
movq $0x8, 0x10(%r1... | /KinglittleQ[P]hnsw/tests/test.cpp |
hnsw::HNSWIndex::HNSWIndex(float*, unsigned int, unsigned int, hnsw::Distance const&, int, int) | HNSWIndex(float *data,
uint32_t n_points,
uint32_t dim,
const Distance &distance,
int M,
int ef_construction)
: points_(data, n_points, dim), distance_(distance) {
top_layer_ = 0;
M_ = M;
maxM_ = M;
maxM0_ = 2 * M;
ml_ = 1 / log(1.0 *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movq %r8, 0x10(%rsp)
movl %ecx, %ebp
movq %rdi, %r15
leaq 0x60e0(%rip), %rax # 0xad28
movq %rax, (%rdi)
leaq 0x30(%rdi), %rbx
leaq 0x48(%rdi), %rax
movq %rax, 0x8(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
vmovupd %ymm0, 0x2c... | /KinglittleQ[P]hnsw/include/hnsw.hpp |
hnsw::HNSWIndex::Insert(unsigned int) | void Insert(index_t q) {
Vertex &vertex = vertices_[q];
assert(vertex.layer == 0 && vertex.neighbors.size() == 0 && "Vertex has already been inserted");
vertex.layer = RandomChoiceLayer();
vertex.neighbors.resize(vertex.layer + 1);
for (auto iter = vertex.neighbors.begin() + 1; iter != vertex.neighb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %esi, %r13d
movq 0x30(%rdi), %r15
movq %r13, 0x10(%rsp)
shlq $0x5, %r13
cmpl $0x0, 0x18(%r15,%r13)
jne 0x5eb9
leaq (%r15,%r13), %rbx
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0x5eb9
movl %esi, %ebp
movq %rdi, %r14
callq 0x5f0c
movl... | /KinglittleQ[P]hnsw/include/hnsw.hpp |
hnsw::HNSWIndex::SelectNeighbors(float const*, hnsw::MaxHeap&, unsigned int) | PointSet SelectNeighbors(const float *q, MaxHeap &candidates, uint32_t M) {
while (candidates.size() > M) {
candidates.pop();
}
PointSet result;
result.reserve(M);
while (!candidates.empty()) {
result.push_back(candidates.top());
candidates.pop();
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movl %r8d, %r15d
movq 0x8(%rcx), %rax
subq (%rcx), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x730f
movq %r14, %rdi
callq 0x6b16
movq 0x8(%r14), %rax
subq (%r14), %rax
jmp 0x72f5
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %... | /KinglittleQ[P]hnsw/include/hnsw.hpp |
glad_gl_has_extension | static int glad_gl_has_extension(int version, const char *exts, unsigned int num_exts_i, char **exts_i, const char *ext) {
if(GLAD_VERSION_MAJOR(version) < 3 || !GLAD_GL_IS_SOME_NEW_VERSION) {
const char *extensions;
const char *loc;
const char *terminator;
extensions = exts;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
cmpl $0x7530, %edi # imm = 0x7530
jge 0x1bd39
movq %rsi, %r14
testq %rsi, %rsi
sete %al
testq %rbx, %rbx
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x1bd67
pushq $0x1
popq %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15510
testq %rax, %rax
j... | /Rodousse[P]SSSGems/third_party/glfw/deps/glad_gl.c |
glfwSplitBPP | void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
{
int delta;
// We assume that by 32 the user really meant 24
if (bpp == 32)
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*red = *green = *blue = bpp / 3;
delta = bpp - (*red * 3);
if (delta >= 1)
... | movq %rdx, %r8
cmpl $0x20, %edi
pushq $0x18
popq %r9
cmovnel %edi, %r9d
pushq $0x3
popq %rdi
movl %r9d, %eax
cltd
idivl %edi
movl %eax, (%rcx)
movl %eax, (%r8)
movl %eax, (%rsi)
imull $-0x3, %eax, %eax
addl %r9d, %eax
testl %eax, %eax
jle 0x1f52f
incl (%r8)
cmpl $0x2, %eax
jne 0x1f52f
incl (%rsi)
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwGetMonitorPhysicalSize | GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (widthMM)
*widthMM = 0;
if (heightMM)
*heightMM = 0;
_GLFW_REQUIRE_INIT();
if (widthMM)
*widthMM = mo... | testq %rdi, %rdi
je 0x1f6c2
testq %rsi, %rsi
je 0x1f68b
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1f693
andl $0x0, (%rdx)
leaq 0x3a396(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x1f6b4
testq %rsi, %rsi
je 0x1f6a9
movl 0x10(%rdi), %eax
movl %eax, (%rsi)
testq %rdx, %rdx
je 0x1f6b3
movl 0x14(%rdi), %eax
movl %eax, (%r... | /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f89b
movq %rsi, %r14
testq %rsi, %rsi
je 0x1f8ba
andl $0x0, (%r14)
leaq 0x3a1d1(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x1f87c
movq %rdi, %rbx
callq 0x1f45c
testl %eax, %eax
je 0x1f88e
movl 0x28(%rbx), %eax
movl %eax, (%r14)
movq 0x20(%rbx), %rbx
jmp 0x1f8... | /Rodousse[P]SSSGems/third_party/glfw/src/monitor.c |
glfwGetPhysicalDevicePresentationSupport | GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
assert(instance != VK_NULL_HANDLE);
assert(device != VK_NULL_HANDLE);
_GLFW_RE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2018b
movq %rsi, %r14
testq %rsi, %rsi
je 0x201aa
leaq 0x3990a(%rip), %r12 # 0x59a30
cmpl $0x0, (%r12)
je 0x20161
movl %edx, %ebx
movq %rdi, %r15
pushq $0x2
popq %rdi
callq 0x1fc9c
testl %eax, %eax
je 0x2017d
cmpq $0x0, 0x1fe80(%r12)
je 0x... | /Rodousse[P]SSSGems/third_party/glfw/src/vulkan.c |
glfwSetWindowTitle | GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(title != NULL);
_GLFW_REQUIRE_INIT();
_glfwPlatformSetWindowTitle(window, title);
} | pushq %rax
testq %rdi, %rdi
je 0x20add
testq %rsi, %rsi
je 0x20afc
leaq 0x38f6d(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x20ace
popq %rax
jmp 0x25ac8
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1c893
leaq 0xf1b1(%rip), %rdi # 0x2fc95
leaq 0x2bbe7(%rip), %rsi ... | /Rodousse[P]SSSGems/third_party/glfw/src/window.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0x20c83
testq %rsi, %rsi
je 0x20c5c
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x20c64
andl $0x0, (%rdx)
leaq 0x38dc5(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x20c75
jmp 0x25e58
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1c893
pushq %rax
leaq 0xf00a(%rip), %... | /Rodousse[P]SSSGems/third_party/glfw/src/window.c |
glfwGetFramebufferSize | GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetFramebufferSize(window, width, height);
... | testq %rdi, %rdi
je 0x20f2a
testq %rsi, %rsi
je 0x20f03
andl $0x0, (%rsi)
testq %rdx, %rdx
je 0x20f0b
andl $0x0, (%rdx)
leaq 0x38b1e(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x20f1c
jmp 0x2608d
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1c893
pushq %rax
leaq 0xed63(%rip), %... | /Rodousse[P]SSSGems/third_party/glfw/src/window.c |
glfwHideWindow | GLFWAPI void glfwHideWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformHideWindow(window);
} | testq %rdi, %rdi
je 0x212dd
leaq 0x38772(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x212cf
cmpq $0x0, 0x40(%rdi)
je 0x265a7
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1c893
pushq %rax
leaq 0xe9b0(%rip), %rdi # 0x2fc95
leaq 0x2b3e6(%rip), %rsi # 0x4c6d2
leaq 0x2... | /Rodousse[P]SSSGems/third_party/glfw/src/window.c |
glfwPlatformTerminate | void _glfwPlatformTerminate(void)
{
if (_glfw.x11.helperWindowHandle)
{
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
_glfw.x11.helperWindowHandle)
{
_glfwPushSelectionToManagerX11();
}
XDestroyWindow(_glfw.x11.display, _glfw.x11.helpe... | pushq %rbx
leaq 0x360dd(%rip), %rbx # 0x59a30
cmpq $0x0, 0x1fee0(%rbx)
je 0x2399c
movq 0x1fec0(%rbx), %rdi
movq 0x20c08(%rbx), %rsi
callq 0x159e0
movq 0x1fee0(%rbx), %rsi
cmpq %rsi, %rax
jne 0x23988
callq 0x24b38
movq 0x1fee0(%rbx), %rsi
movq 0x1fec0(%rbx), %rdi
callq 0x15410
andq $0x0, 0x1fee0(%rbx)
movq 0x1fee8(%... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwPlatformGetVersionString | const char* _glfwPlatformGetVersionString(void)
{
return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared... | leaq 0x29bcb(%rip), %rax # 0x4d697
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_init.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
if (monitor->x11.oldMode == None)
return;
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcIn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x35832(%rip), %r12 # 0x59a30
cmpl $0x0, 0x20c50(%r12)
je 0x242c0
cmpl $0x0, 0x20c74(%r12)
jne 0x242c0
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
je 0x242c0
movq 0x1fec0(%r12), %rdi
movq 0x1fed0(%r12), %rsi
callq *0x20cc8(%r12)
movq %rax, %r14
movq 0x1fec0(%r12... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_monitor.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.displ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x35753(%rip), %rax # 0x59a30
cmpl $0x0, 0x20c50(%rax)
je 0x24370
cmpl $0x0, 0x20c74(%rax)
jne 0x24370
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x1fec0(%rax), %rdi
movq 0x1fed0(%rax), %rsi
movq %rax, %r13
callq *0x20cc8(%rax)
movq %rax, %r15
mo... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_monitor.c |
glfwPlatformGetMonitorWorkarea | void _glfwPlatformGetMonitorWorkarea(_GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height)
{
int areaX = 0, areaY = 0, areaWidth = 0, areaHeight = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
leaq 0x35664(%rip), %r14 # 0x59a30
cmpl $0x0, 0x20c50(%r14)
je 0x2448d
cmpl $0x0, 0x20c74(%r14)
jne 0x2448d
movq %rdi, %rbp
movq %r15, 0x8(%rsp)
movq %r12, %r15
movq %r13... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_monitor.c |
glfwPlatformGetVideoModes | GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
GLFWvidmode* result;
*count = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
andl $0x0, (%rsi)
movq %rdi, %r13
leaq 0x353c4(%rip), %r14 # 0x59a30
cmpl $0x0, 0x20c50(%r14)
je 0x2478e
cmpl $0x0, 0x20c74(%r14)
jne 0x2478e
movq 0x1fec0(%r14), %rdi
movq 0x1fed0(%r14), %rsi
callq *0x20cc8(%r14)
movq... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_monitor.c |
glfwPushSelectionToManagerX11 | void _glfwPushSelectionToManagerX11(void)
{
XConvertSelection(_glfw.x11.display,
_glfw.x11.CLIPBOARD_MANAGER,
_glfw.x11.SAVE_TARGETS,
None,
_glfw.x11.helperWindowHandle,
CurrentTime);
for (;;)
{
... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
leaq 0x34ee5(%rip), %r15 # 0x59a30
movq 0x20c18(%r15), %rsi
movq 0x20c20(%r15), %rdx
movq 0x1fec0(%r15), %rdi
movq 0x1fee0(%r15), %r8
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x15220
leaq 0x67(%rip), %rbx # 0x24bdf
movq %rsp, %r14
movq 0x1fec0(%r15), %rdi
movq %... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
getSelectionString | static const char* getSelectionString(Atom selection)
{
char** selectionString = NULL;
const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
if (selection == _glfw.x11.PRIMARY)
selectionString = &_glfw.x11.primarySelectionS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rsi
leaq 0x317b8(%rip), %rbp # 0x59a30
movq 0x20c30(%rbp), %rax
movq %rax, 0x50(%rsp)
movq $0x1f, 0x58(%rsp)
xorl %ebx, %ebx
cmpq %rdi, 0x20c10(%rbp)
setne %bl
movq 0x1fec0(%rbp), %rdi
movq %rsi,... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformGetRequiredInstanceExtensions | void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
{
if (!_glfw.vk.KHR_surface)
return;
if (!_glfw.vk.KHR_xcb_surface || !_glfw.x11.x11xcb.handle)
{
if (!_glfw.vk.KHR_xlib_surface)
return;
}
extensions[0] = "VK_KHR_surface";
// NOTE: VK_KHR_xcb_surf... | leaq 0x314d6(%rip), %rcx # 0x59a30
cmpl $0x0, 0x1fea0(%rcx)
je 0x28588
movl 0x1fea8(%rcx), %eax
testl %eax, %eax
setne %dl
cmpq $0x0, 0x20da0(%rcx)
setne %sil
testb %sil, %dl
jne 0x28589
cmpl $0x0, 0x1fea4(%rcx)
jne 0x28589
retq
leaq 0x2387c(%rip), %rdx # 0x4be0c
movq %rdx, (%rdi)
cmpq $0x0, 0x20da0(%rcx)
leaq ... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformGetPhysicalDevicePresentationSupport | int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
VisualID visualID = XVisualIDFromVisual(DefaultVisual(_glfw.x11.display,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x31460(%rip), %r13 # 0x59a30
movq 0x1fec0(%r13), %rax
movq 0xe8(%rax), %rax
movslq 0x1fec8(%r13), %rcx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rdi
callq 0x15860
movq %rax, %r15
cmpl $0x0, 0x1fea8(%r13)
movq 0... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwPlatformCreateWindowSurface | VkResult _glfwPlatformCreateWindowSurface(VkInstance instance,
_GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
{
if (_glfw.vk.KHR_xcb_surface && _glfw.x11... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x31366(%rip), %rbp # 0x59a30
cmpl $0x0, 0x1fea8(%rbp)
je 0x2875c
cmpq $0x0, 0x20da0(%rbp)
je 0x2875c
movq 0x1fec0(%rbp), %rdi
callq *0x20da8(%rbp)
testq %rax, %rax... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
translateState | static int translateState(int state)
{
int mods = 0;
if (state & ShiftMask)
mods |= GLFW_MOD_SHIFT;
if (state & ControlMask)
mods |= GLFW_MOD_CONTROL;
if (state & Mod1Mask)
mods |= GLFW_MOD_ALT;
if (state & Mod4Mask)
mods |= GLFW_MOD_SUPER;
if (state & LockMask)
... | movl %edi, %eax
andl $0x1, %eax
movl %edi, %ecx
shrl %ecx
andl $0x6, %ecx
orl %eax, %ecx
movl %edi, %eax
shrl $0x3, %eax
andl $0x8, %eax
orl %ecx, %eax
movl %edi, %ecx
andl $0x2, %ecx
leal (%rax,%rcx,8), %eax
andl $0x10, %edi
leal (%rax,%rdi,2), %eax
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
isSelPropNewValueNotify | static Bool isSelPropNewValueNotify(Display* display, XEvent* event, XPointer pointer)
{
XEvent* notification = (XEvent*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == notification->xselection.requestor &&
... | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x28955
cmpl $0x0, 0x38(%rsi)
je 0x28956
retq
movq 0x20(%rsi), %rcx
cmpq 0x20(%rdx), %rcx
jne 0x28955
movq 0x28(%rsi), %rcx
xorl %eax, %eax
cmpq 0x38(%rdx), %rcx
sete %al
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
convertLatin1toUTF8 | static char* convertLatin1toUTF8(const char* source)
{
size_t size = 1;
const char* sp;
for (sp = source; *sp; sp++)
size += (*sp & 0x80) ? 2 : 1;
char* target = calloc(size, 1);
char* tp = target;
for (sp = source; *sp; sp++)
tp += encodeUTF8(tp, *sp);
return target;... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
movq %rbx, %rax
cmpb $0x0, (%rax)
je 0x28993
setns %cl
movzbl %cl, %ecx
subq %rcx, %rdi
addq $0x2, %rdi
incq %rax
jmp 0x2897c
pushq $0x1
popq %rsi
callq 0x157c0
movq %rax, %r14
movq %rax, %r15
movsbl (%rbx), %esi
testl %esi, %esi
je 0x289b8
movq %r15... | /Rodousse[P]SSSGems/third_party/glfw/src/x11_window.c |
glfwKeySym2Unicode | long _glfwKeySym2Unicode(unsigned int keysym)
{
int min = 0;
int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
int mid;
// First check for Latin-1 characters (1:1 mapping)
if ((keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff))
{
return key... | leal -0x20(%rdi), %eax
cmpl $0x5f, %eax
setae %al
leal -0xa0(%rdi), %ecx
cmpl $0x60, %ecx
setae %cl
testb %cl, %al
jne 0x289e1
movl %edi, %ecx
jmp 0x28a40
movl %edi, %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0x289fa
andl $0xffffff, %edi # imm = 0xFFF... | /Rodousse[P]SSSGems/third_party/glfw/src/xkb_unicode.c |
glfwInitTimerPOSIX | void _glfwInitTimerPOSIX(void)
{
#if defined(CLOCK_MONOTONIC)
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
{
_glfw.timer.posix.monotonic = GLFW_TRUE;
_glfw.timer.posix.frequency = 1000000000;
}
else
#endif
{
_glfw.timer.posix.monotonic = GLFW_FALSE;
... | subq $0x18, %rsp
pushq $0x1
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x15150
xorl %ecx, %ecx
testl %eax, %eax
movl $0x3b9aca00, %eax # imm = 0x3B9ACA00
movl $0xf4240, %edx # imm = 0xF4240
cmoveq %rax, %rdx
sete %cl
leaq 0x30fbf(%rip), %rax # 0x59a30
movl %ecx, 0x1fe60(%rax)
movq %rdx, 0x1fe68(%rax)
addq ... | /Rodousse[P]SSSGems/third_party/glfw/src/posix_time.c |
glfwPlatformCreateTls | GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
{
assert(tls->posix.allocated == GLFW_FALSE);
if (pthread_key_create(&tls->posix.key, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"POSIX: Failed to create context TLS");
return GLFW_FALSE;
}
tls->posix.al... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x28b22
movq %rdi, %r14
addq $0x4, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x154a0
testl %eax, %eax
je 0x28b0e
leaq 0x2669d(%rip), %rsi # 0x4f19d
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
jmp 0x28b18
movl $0x1, (%r14)
pushq $... | /Rodousse[P]SSSGems/third_party/glfw/src/posix_thread.c |
glfwCreateContextGLX | GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
int attribs[40];
GLXFBConfig native = NULL;
GLXContext share = NULL;
if (ctxconfig->share)
share = ctxconfig->share... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
andq $0x0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x29240
movq 0x270(%rax), %r14
jmp 0x29243
xorl %r14d, %r14d
leaq 0x8(%rsp), %rsi
movq %rdx, %rdi
callq 0x295df
testl %eax, %eax
je 0x2930f
cmpl $0x30002... | /Rodousse[P]SSSGems/third_party/glfw/src/glx_context.c |
glfwChooseVisualGLX | GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
GLXFBConfig native;
XVisualInfo* result;
if (!chooseGLXFBCo... | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rdi
movq %rsp, %rsi
callq 0x295df
testl %eax, %eax
je 0x29a5a
leaq 0x30004(%rip), %rax # 0x59a30
movq 0x1fec0(%rax), %rdi
movq (%rsp), %rsi
callq *0x20ec0(%rax)
testq %rax, %rax
je 0x29a6a
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax)... | /Rodousse[P]SSSGems/third_party/glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window... | pushq %rbx
leaq 0x2ff62(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x29ae5
cmpl $0x0, 0x1f8(%rdi)
je 0x29aee
movq 0x278(%rdi), %rbx
jmp 0x29afe
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x29af5
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Rodousse[P]SSSGems/third_party/glfw/src/glx_context.c |
glfwInitEGL | GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_EGL_LIBRARY)
_GLFW_EGL_LIBRARY,
#elif defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#elif defined(__CYGWIN__)
"libEGL-1.so",
#else
"libE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2feed(%rip), %r14 # 0x59a30
cmpq $0x0, 0x20fb0(%r14)
je 0x29b55
pushq $0x1
popq %rbx
jmp 0x29f40
xorl %r15d, %r15d
leaq 0x2d201(%rip), %r12 # 0x56d60
pushq $0x1
popq %rbx
cmpq $0x1, %r15
je 0x29e4d
movq (%r12,%r15,8), %rdi
movl %ebx, %esi
callq 0x155... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0x2fada(%rip), %rbx # 0x59a30
movq 0x20f88(%rbx), %rdi
testq %rdi, %rdi
je 0x29f70
callq *0x20fe0(%rbx)
andq $0x0, 0x20f88(%rbx)
movq 0x20fb0(%rbx), %rdi
testq %rdi, %rdi
je 0x29f89
callq 0x15a50
andq $0x0, 0x20fb0(%rbx)
popq %rbx
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
destroyContextEGL | static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
... | pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f8(%rdi) # imm = 0x30001
je 0x2a826
movq 0x298(%rbx), %rdi
testq %rdi, %rdi
je 0x2a826
callq 0x15a50
andq $0x0, 0x298(%rbx)
movq 0x290(%rbx), %rsi
testq %rsi, %rsi
je 0x2a84e
leaq 0x2f1f7(%rip), %rax # 0x59a30
movq 0x20f88(%rax), %rdi
callq *0x20ff8(%rax)
andq $0x0, 0x... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
glfwGetEGLContext | GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_CONTEXT;
}
return wind... | pushq %rbx
leaq 0x2f0ae(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x2a999
cmpl $0x0, 0x1f8(%rdi)
je 0x2a9a2
movq 0x288(%rdi), %rbx
jmp 0x2a9b2
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2a9a9
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
glfwGetEGLSurface | GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_SURFACE;
}
return wind... | pushq %rbx
leaq 0x2f071(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x2a9d6
cmpl $0x0, 0x1f8(%rdi)
je 0x2a9df
movq 0x290(%rdi), %rbx
jmp 0x2a9ef
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2a9e6
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Rodousse[P]SSSGems/third_party/glfw/src/egl_context.c |
makeContextCurrentOSMesa | static void makeContextCurrentOSMesa(_GLFWwindow* window)
{
if (window)
{
int width, height;
_glfwPlatformGetFramebufferSize(window, &width, &height);
// Check to see if we need to allocate a new buffer
if ((window->context.osmesa.buffer == NULL) ||
(width != window-... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2ae59
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2608d
movq 0x2b0(%rbx), %rsi
testq %rsi, %rsi
je 0x2adfd
movl 0xc(%rsp), %r14d
cmpl 0x2a8(%rbx), %r14d
jne 0x2adfd
movl 0x8(%rsp), %r15d
cmpl 0x2ac(%rbx), %r15d... | /Rodousse[P]SSSGems/third_party/glfw/src/osmesa_context.c |
destroyContextOSMesa | static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window-... | pushq %rbx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x2aec3
leaq 0x2eb7b(%rip), %rax # 0x59a30
callq *0x21050(%rax)
andq $0x0, 0x2a0(%rbx)
movq 0x2b0(%rbx), %rdi
testq %rdi, %rdi
je 0x2aedc
callq 0x153e0
andq $0x0, 0x2a8(%rbx)
popq %rbx
retq
| /Rodousse[P]SSSGems/third_party/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.os... | pushq %rbx
leaq 0x2e998(%rip), %rax # 0x59a30
cmpl $0x0, (%rax)
je 0x2b0af
cmpl $0x0, 0x1f8(%rdi)
je 0x2b0b8
movq 0x2a0(%rdi), %rbx
jmp 0x2b0c8
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2b0bf
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Rodousse[P]SSSGems/third_party/glfw/src/osmesa_context.c |
glfwInitJoysticksLinux | GLFWbool _glfwInitJoysticksLinux(void)
{
const char* dirname = "/dev/input";
_glfw.linjs.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (_glfw.linjs.inotify > 0)
{
// HACK: Register for IN_ATTRIB to get notified when udev is done
// This works well in practice but the true ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
movl $0x80800, %edi # imm = 0x80800
callq 0x155b0
leaq 0x2e93e(%rip), %rbx # 0x59a30
movl %eax, 0x20f38(%rbx)
testl %eax, %eax
jle 0x2b115
leaq 0x25277(%rip), %rsi # 0x5037a
movl %eax, %edi
mov... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
glfwTerminateJoysticksLinux | void _glfwTerminateJoysticksLinux(void)
{
int jid;
for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
_GLFWjoystick* js = _glfw.joysticks + jid;
if (js->present)
closeJoystick(js);
}
regfree(&_glfw.linjs.regex);
if (_glfw.linjs.inotify > 0)
{
if (_glfw... | pushq %r14
pushq %rbx
pushq %rax
movl $0x408, %r14d # imm = 0x408
leaq 0x2e369(%rip), %rbx # 0x59a30
cmpq $0x1fe08, %r14 # imm = 0x1FE08
je 0x2b6e9
cmpl $0x0, (%rbx,%r14)
je 0x2b6e0
leaq (%rbx,%r14), %rdi
callq 0x2b728
addq $0x1fa0, %r14 # imm = 0x1FA0
jmp 0x2b6c7
leaq 0x20f40(%rbx), %r... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
glfwDetectJoystickConnectionLinux | void _glfwDetectJoystickConnectionLinux(void)
{
if (_glfw.linjs.inotify <= 0)
return;
ssize_t offset = 0;
char buffer[16384];
const ssize_t size = read(_glfw.linjs.inotify, buffer, sizeof(buffer));
while (size > offset)
{
regmatch_t match;
const struct inotify_event* e ... | leaq 0x2e2df(%rip), %rax # 0x59a30
movl 0x20f38(%rax), %edi
testl %edi, %edi
jle 0x2b88a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5028, %rsp # imm = 0x5028
leaq 0x1020(%rsp), %rsi
movl $0x4000, %edx # imm = 0x4000
callq 0x15250
movq %rax, 0x10(%rsp)
movl $0x20f40... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
glfwPlatformPollJoystick | int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
{
// Read all queued events (non-blocking)
for (;;)
{
struct input_event e;
errno = 0;
if (read(js->linjs.fd, &e, sizeof(e)) < 0)
{
// Reset the joystick slot if the device was disconnected
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x15640
movq %rax, %r14
movq %rsp, %r15
pushq $0x18
popq %r12
leaq 0x2e17e(%rip), %r13 # 0x59a30
andl $0x0, (%r14)
movl 0x78(%rbx), %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x15250
testq %rax, %rax
js 0x2b94d
... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
pollAbsState | static void pollAbsState(_GLFWjoystick* js)
{
for (int code = 0; code < ABS_CNT; code++)
{
if (js->linjs.absMap[code] < 0)
continue;
struct input_absinfo* info = &js->linjs.absInfo[code];
if (ioctl(js->linjs.fd, EVIOCGABS(code), info) < 0)
continue;
h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x187c, %r12d # imm = 0x187C
movl $0x197c, %r13d # imm = 0x197C
movl $0x80184540, %ebp # imm = 0x80184540
xorl %r14d, %r14d
cmpq $0x197c, %r12 # imm = 0x197C
je 0x2b9d2
cmpl $0x0, (%rbx,%... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
handleAbsEvent | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT,... | movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x2ba1e
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0x2ba5d
js 0x2ba63
movl $0x2, (%rcx,%ra... | /Rodousse[P]SSSGems/third_party/glfw/src/linux_joystick.c |
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_set_types<std::__cxx11::basic_... | locator nosize_unchecked_emplace_at(const arrays_type& arrays_, std::size_t pos0,
std::size_t hash, Args&&... args) {
for (prober pb(pos0);; pb.next(arrays_.groups_size_mask)) {
auto pos = pb.get();
auto pg = arrays_.groups() + pos;
aut... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rsi
movq %rdi, %rax
movq 0x10(%rdx), %rdi
shlq $0x4, %rcx
pxor %xmm0, %xmm0
movdqa (%rdi,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
je 0x95676
addq %rcx, %rdi
movq %rdi, %rcx
bsfl %ebp, %edi
imulq $0x1e0, %rsi, %rsi ... | /MikePopoloski[P]slang/source/../external/boost_unordered.hpp |
slang::SVInt::setAllX() | void SVInt::setAllX() {
// first set low half to zero (for X)
uint32_t words = getNumWords(bitWidth, false);
if (unknownFlag)
memset(pVal, 0, words * WORD_SIZE);
else {
if (!isSingleWord())
delete[] pVal;
unknownFlag = true;
pVal = new uint64_t[words * 2]();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal 0x3f(%rax), %ebp
movl %ebp, %r12d
shrl $0x6, %r12d
cmpb $0x1, 0xd(%rdi)
jne 0xac67e
movq (%rbx), %rdi
leal (,%r12,8), %edx
xorl %esi, %esi
callq 0x37300
jmp 0xac6b6
cmpl $0x41, %eax
jb 0xac690
movq (%rbx), %rdi
testq %rdi, ... | /MikePopoloski[P]slang/source/numeric/SVInt.cpp |
slang::ast::StatementBlockSymbol::fromSyntax(slang::ast::Scope const&, slang::syntax::ForLoopStatementSyntax const&) | StatementBlockSymbol& StatementBlockSymbol::fromSyntax(const Scope& scope,
const ForLoopStatementSyntax& syntax) {
auto [name, loc] = getLabel(syntax, syntax.forKeyword.location());
auto result = createBlock(scope, syntax, name, loc);
// If one entry i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsi), %rdi
callq 0xc6cd6
movq %rbx, 0x10(%rsp)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0xe1c73
movups 0x18(%rcx), %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
movq %r13, %rdi
callq 0xc6c10... | /MikePopoloski[P]slang/source/ast/symbols/BlockSymbols.cpp |
slang::ast::ConstraintBlockSymbol::fromSyntax(slang::ast::Scope const&, slang::syntax::ConstraintDeclarationSyntax const&) | ConstraintBlockSymbol* ConstraintBlockSymbol::fromSyntax(
const Scope& scope, const ConstraintDeclarationSyntax& syntax) {
auto& comp = scope.getCompilation();
if (syntax.name->kind == SyntaxKind::ScopedName) {
// Remember the location in the parent scope where we *would* have inserted this
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0xd0(%rsi), %rdx
cmpl $0x1a1, (%rdx) # imm = 0x1A1
jne 0xe96c8
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xe97a7
movl 0x30(%rax), %r8d
incl %r8d
jmp 0xe97ad
movq 0x8(%rbx), %rax
cmpl $... | /MikePopoloski[P]slang/source/ast/symbols/ClassSymbols.cpp |
slang::ast::ConstraintBlockSymbol::getConstraints() const | const Constraint& ConstraintBlockSymbol::getConstraints() const {
if (constraint)
return *constraint;
auto syntax = getSyntax();
auto scope = getParentScope();
SLANG_ASSERT(syntax && scope);
ASTContext context(*this, LookupLocation::max);
if (syntax->kind == SyntaxKind::ConstraintProto... | movq 0x88(%rdi), %rax
testq %rax, %rax
je 0xe9a7d
retq
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %r12
movq 0x38(%rdi), %rax
leaq 0x40(%rdi), %rcx
leaq 0x295a30(%rip), %rdx # 0x37f4d0
movl 0x8(%rdx), %edx
movq %rcx, 0x38(%rsp)
movl %edx, 0x40(%rsp)
xorps ... | /MikePopoloski[P]slang/source/ast/symbols/ClassSymbols.cpp |
slang::ast::ClassPropertySymbol* slang::BumpAllocator::emplace<slang::ast::ClassPropertySymbol, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation, slang::ast::VariableLifetime&, slang::ast::Visibility&>(std::basic_string_view<char, std::char_traits<char>>&&, slang::SourceLocation&&, slang::ast... | T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq (%rdi), %rax
movq 0x8(%rax), %r15
addq $0x7, %r15
andq $-0x8, %r15
leaq 0x160(%r15), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0xe9f21
movl $0x160, %esi # imm = 0x160
movl $0x8, %edx
callq 0xd7432
m... | /MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h |
slang::ast::VariableSymbol* slang::BumpAllocator::emplace<slang::ast::VariableSymbol, char const (&) [5], slang::SourceLocation&, slang::ast::VariableLifetime>(char const (&) [5], slang::SourceLocation&, slang::ast::VariableLifetime&&) | T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r12
addq $0x7, %r12
andq $-0x8, %r12
leaq 0x158(%r12), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0xea076
movl $0x158, %esi # imm = 0x158
movl $0x8, %edx
callq 0xd7432
movq %rax, %r12
... | /MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h |
slang::SmallVectorBase<slang::ast::Type const*>::copy(slang::BumpAllocator&) const | [[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xea14a
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rdx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%rcx,8), %rdi
cmpq 0x8(%rsi), %rdi
jbe 0xea150
shlq $0x3, %rcx
movl $0x8, %edx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0xd7432
movq 0x8(%rbx), %rcx
jmp 0xea154
xor... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
slang::ast::VariableSymbol* slang::BumpAllocator::emplace<slang::ast::VariableSymbol, char const (&) [5], slang::SourceLocation const&, slang::ast::VariableLifetime>(char const (&) [5], slang::SourceLocation const&, slang::ast::VariableLifetime&&) | T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %r12
addq $0x7, %r12
andq $-0x8, %r12
leaq 0x158(%r12), %rcx
cmpq 0x8(%rdi), %rcx
jbe 0xea432
movl $0x158, %esi # imm = 0x158
movl $0x8, %edx
callq 0xd7432
movq %rax, %r12
... | /MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h |
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, slang::ast::Symbol const*> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_set_types<slang::ast::Symbol const*>, boost::unordered::detail::foa::group15<boost:... | BOOST_NOINLINE locator unchecked_emplace_with_rehash(std::size_t hash, Args&&... args) {
auto new_arrays_ = new_arrays_for_growth();
locator it;
BOOST_TRY {
/* strong exception guarantee -> try insertion before rehash */
it = nosize_unchecked_emplace_at(new_arrays_, posit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r13
movq 0x30(%rsi), %rcx
movabsq $0xc9714fbcda3ac11, %rdx # imm = 0xC9714FBCDA3AC11
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %... | /MikePopoloski[P]slang/source/../external/boost_unordered.hpp |
slang::ConstantValue const** slang::SmallVectorBase<slang::ConstantValue const*>::emplaceRealloc<slang::ConstantValue const*>(slang::ConstantValue const**, slang::ConstantValue const*&&) | typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r15
cmpq %rax, %r15
je 0xeb5ff
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
incq %r15
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), ... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
slang::ast::CoverpointSymbol::checkBins() const | void CoverpointSymbol::checkBins() const {
if (getType().isFloating()) {
auto scope = getParentScope();
SLANG_ASSERT(scope);
if (isImplicit && !name.empty()) {
scope->addDiag(diag::RealCoverpointImplicit, location) << name;
}
else if (membersOfType<CoverageBinSym... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x78, %rdi
callq 0x15ac12
movq %rax, %r14
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0xeef2e
movq %r14, %rdi
callq 0x15f6a6
movq 0x40(%r14), %rax
cmpl $0x9, (%rax)
jne 0xeef7d
movq 0x20(%rbx), %r14
cmpb $0x1, 0xd8(%rbx)
jne 0xeef6f
cmpq $0x0, 0x8(%rbx)
je 0xeef6f
m... | /MikePopoloski[P]slang/source/ast/symbols/CoverSymbols.cpp |
slang::ast::CoverCrossSymbol::CoverCrossSymbol(slang::ast::Compilation&, std::basic_string_view<char, std::char_traits<char>>, slang::SourceLocation, std::span<slang::ast::CoverpointSymbol const* const, 18446744073709551615ul>) | CoverCrossSymbol::CoverCrossSymbol(Compilation& comp, std::string_view name, SourceLocation loc,
std::span<const CoverpointSymbol* const> targets) :
Symbol(SymbolKind::CoverCross, name, loc), Scope(comp, this), targets(targets) {
auto& bit_t = comp.getBitType();
auto& int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, %r14
movl $0x5c, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x0, 0x30(%rdi)
leaq 0x40(%rdi), %rbx
movq %rbx, %... | /MikePopoloski[P]slang/source/ast/symbols/CoverSymbols.cpp |
slang::ast::CoverageBinSymbol::TransRangeList& slang::SmallVectorBase<slang::ast::CoverageBinSymbol::TransRangeList>::emplace_back<slang::syntax::TransRangeSyntax&, slang::ast::Type const&, slang::ast::ASTContext&>(slang::syntax::TransRangeSyntax&, slang::ast::Type const&, slang::ast::ASTContext&) | reference emplace_back(Args&&... args) {
if (len == cap)
return *emplaceRealloc(end(), std::forward<Args>(args)...);
new (end()) T(std::forward<Args>(args)...);
len++;
return back();
} | pushq %rbx
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq (%rax,%rax,4), %rsi
shlq $0x3, %rsi
addq (%rdi), %rsi
cmpq 0x10(%rdi), %rax
jne 0xf0333
movq %rbx, %rdi
popq %rbx
jmp 0xf17e0
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0xee6ea
movq 0x8(%rbx), %... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
slang::SmallVectorBase<std::span<slang::ast::CoverageBinSymbol::TransRangeList const, 18446744073709551615ul>>::copy(slang::BumpAllocator&) const | [[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
... | movq %rsi, %rcx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0xf0460
pushq %rbx
movq %rdi, %rbx
shlq $0x4, %rsi
movq (%rcx), %rdi
movq 0x8(%rdi), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%rsi), %rdx
cmpq 0x8(%rcx), %rdx
jbe 0xf0465
movl $0x8, %edx
movq %rcx, %rdi
callq 0xd7432
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
slang::SmallVectorBase<slang::ast::CoverpointSymbol const*>::copy(slang::BumpAllocator&) const | [[nodiscard]] std::span<T> copy(BumpAllocator& alloc) const {
if (len == 0)
return {};
pointer dest = reinterpret_cast<pointer>(alloc.allocate(len * sizeof(T), alignof(T)));
std::ranges::uninitialized_copy(begin(), end(), dest, dest + len);
return std::span<T>(dest, len);
... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xf06d8
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rdx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq (%rax,%rcx,8), %rdi
cmpq 0x8(%rsi), %rdi
jbe 0xf06de
shlq $0x3, %rcx
movl $0x8, %edx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0xd7432
movq 0x8(%rbx), %rcx
jmp 0xf06e2
xor... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
boost::unordered::detail::foa::table_locator<boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::syntax::SyntaxNode const*>> boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_map_t... | locator nosize_unchecked_emplace_at(const arrays_type& arrays_, std::size_t pos0,
std::size_t hash, Args&&... args) {
for (prober pb(pos0);; pb.next(arrays_.groups_size_mask)) {
auto pos = pb.get();
auto pg = arrays_.groups() + pos;
aut... | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rsi
movq %rdi, %rax
movq 0x10(%rdx), %rdi
shlq $0x4, %rcx
pxor %xmm0, %xmm0
movdqa (%rdi,%rcx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
je 0xf1441
addq %rcx, %rdi
movq %rdi, %rcx
bsfl %ebp, %edi
imulq $0x168, %rsi, %rsi ... | /MikePopoloski[P]slang/source/../external/boost_unordered.hpp |
slang::ast::InstanceArraySymbol::getArrayName() const | const Scope* getParentScope() const { return parentScope; } | movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xf1da6
movq 0x8(%rax), %rax
cmpl $0x31, (%rax)
jne 0xf1da6
pushq %rax
movq %rax, %rdi
callq 0xf1d86
addq $0x8, %rsp
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
retq
nop
| /MikePopoloski[P]slang/source/../include/slang/ast/Symbol.h |
slang::ast::createUninstantiatedParams(slang::syntax::HierarchyInstantiationSyntax const&, slang::ast::ASTContext const&) | static std::span<const Expression* const> createUninstantiatedParams(
const HierarchyInstantiationSyntax& syntax, const ASTContext& context) {
SmallVector<const Expression*> params;
if (syntax.parameters) {
for (auto expr : syntax.parameters->parameters) {
// Empty expressions are just ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x5, -0x8(%rax)
testq %rdi, %rdi
je 0xf4df5
movq %rdi, %r14
movq 0x68(%rdi), %rbp
incq %rbp
cmpq $0x2, %rbp
jb 0xf4df5
shrq %rbp
xorl %r13d, %r13d
... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
(anonymous namespace)::InstanceBuilder::create(slang::syntax::HierarchicalInstanceSyntax const&) | Symbol* create(const HierarchicalInstanceSyntax& syntax) {
createImplicitNets(syntax, context, netType, flags, implicitNetNames, implicitNets);
path.clear();
if (!syntax.decl) {
context.addDiag(diag::InstanceNameRequired, syntax.sourceRange());
return createInstance(syn... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rdx
movq 0xd0(%rdi), %rsi
movq 0x108(%rdi), %r9
movl 0x160(%rdi), %ecx
movq %rbx, %rdi
movq %r14, %r8
callq 0xf93fd
movq $0x0, 0x118(%r14)
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
jne 0xf93dd
movq 0xd0(%r14), %r15
movq %rb... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
slang::ast::(anonymous namespace)::recursePrimArray(slang::ast::Compilation&, slang::ast::PrimitiveSymbol const&, slang::syntax::HierarchicalInstanceSyntax const&, slang::ast::ASTContext const&, __gnu_cxx::__normal_iterator<slang::syntax::VariableDimensionSyntax**, std::span<slang::syntax::VariableDimensionSyntax*, 184... | Symbol* recursePrimArray(Compilation& comp, const PrimitiveSymbol& primitive,
const HierarchicalInstanceSyntax& instance, const ASTContext& context,
DimIterator it, DimIterator end,
std::span<const AttributeInstanceSyntax* const> attributes,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x120(%rsp), %r13
leaq 0x110(%rsp), %rax
cmpq %r9, %r8
je 0xfa06f
movq %r9, %rbp
movq %r8, %rbx
movq %rdi, 0x20(%rsp)
movq 0x18(%r15), %rax
movups 0x18(%rax), %xmm0
movaps %xmm0, 0x50(... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
boost::unordered::detail::foa::table_core<boost::unordered::detail::foa::flat_set_types<std::basic_string_view<char, std::char_traits<char>>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::table_arrays, boost::unordered::detail::foa::plain_size_con... | BOOST_NOINLINE void unchecked_rehash(arrays_type& new_arrays_) {
std::size_t num_destroyed = 0;
BOOST_TRY {
for_all_elements([&, this](element_type* p) {
nosize_transfer_element(p, new_arrays_, num_destroyed);
});
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
leaq 0x8(%rdi), %r15
leaq 0x18(%rsp), %rcx
movq %rdi, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rax, 0x10(%rcx)
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r15, %rdi
callq 0xfc090
movq (%rbx), %rdi
movq %r... | /MikePopoloski[P]slang/source/../external/boost_unordered.hpp |
slang::syntax::SeparatedSyntaxList<slang::syntax::HierarchicalInstanceSyntax>* slang::BumpAllocator::emplace<slang::syntax::SeparatedSyntaxList<slang::syntax::HierarchicalInstanceSyntax>, slang::syntax::SeparatedSyntaxList<slang::syntax::HierarchicalInstanceSyntax> const&>(slang::syntax::SeparatedSyntaxList<slang::synt... | T* emplace(Args&&... args) {
static_assert(std::is_trivially_destructible_v<T>);
return new (allocate(sizeof(T), alignof(T))) T(std::forward<Args>(args)...);
} | pushq %rbx
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rcx), %rax
addq $0x7, %rax
andq $-0x8, %rax
leaq 0x38(%rax), %rdx
cmpq 0x8(%rdi), %rdx
jbe 0xfd494
movl $0x38, %esi
movl $0x8, %edx
callq 0xd7432
jmp 0xfd498
movq %rdx, 0x8(%rcx)
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(... | /MikePopoloski[P]slang/source/../include/slang/util/BumpAllocator.h |
slang::syntax::AttributeInstanceSyntax** slang::SmallVectorBase<slang::syntax::AttributeInstanceSyntax*>::emplaceRealloc<slang::syntax::AttributeInstanceSyntax*>(slang::syntax::AttributeInstanceSyntax**, slang::syntax::AttributeInstanceSyntax*&&) | typename SmallVectorBase<T>::pointer SmallVectorBase<T>::emplaceRealloc(const pointer pos,
Args&&... args) {
if (len == max_size())
detail::throwLengthError();
auto newCap = calculateGrowth(len + 1);
auto offset = static_cast<s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r15
cmpq %rax, %r15
je 0xfd8e5
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
incq %r15
movq 0x10(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
leaq (%rcx,%rcx), ... | /MikePopoloski[P]slang/source/../include/slang/util/SmallVector.h |
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::DefinitionSymbol>(slang::ast::DefinitionSymbol const&) | void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = d... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0xfeb51
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0xfeb51
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
| /MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h |
void slang::ast::ASTVisitor<slang::ast::CheckerMemberVisitor, true, true, false, false>::visitDefault<slang::ast::MultiPortSymbol>(slang::ast::MultiPortSymbol const&) | void visitDefault(const T& t) {
if constexpr (VisitExpressions && HasVisitExprs<T, TDerived>) {
t.visitExprs(DERIVED);
}
else if constexpr (VisitExpressions && std::is_base_of_v<Symbol, T>) {
if (auto declaredType = t.getDeclaredType()) {
if (auto init = d... | pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x200dae
testq %rax, %rax
je 0xfecd9
movq %rax, %rdi
callq 0x15bc4e
testq %rax, %rax
je 0xfecd9
movq %rax, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
jmp 0xfda5e
popq %rbx
retq
nop
| /MikePopoloski[P]slang/source/../include/slang/ast/ASTVisitor.h |
void slang::ast::CheckerMemberVisitor::handle<slang::ast::BlockStatement>(slang::ast::BlockStatement const&) | void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xff583
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %ecx
movl (%rsi), %eax
testl %ecx, %ecx
je 0xff584
decl %eax
cmpl $0x1e, %eax
ja 0xff5d8
leaq 0x... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
void slang::ast::CheckerMemberVisitor::handle<slang::ast::VariableDeclStatement>(slang::ast::VariableDeclStatement const&) | void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xffa06
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %eax
movl (%rsi), %ecx
testl %eax, %eax
je 0xff966
decl %ecx
cmpl $0x1e, %ecx
ja 0xff9b4
leaq 0x279158(%rip), %r... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
void slang::ast::CheckerMemberVisitor::handle<slang::ast::PatternCaseStatement>(slang::ast::PatternCaseStatement const&) | void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x10072b
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %ecx
movl (%rsi), %eax
testl %ecx, %ecx
je 0x10072c
decl %eax
cmpl $0x1e, %eax
ja 0x100780
leaq... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
void slang::ast::ForLoopStatement::visitExprs<slang::ast::CheckerMemberVisitor&>(slang::ast::CheckerMemberVisitor&) const | void visitExprs(TVisitor&& visitor) const {
for (auto init : initializers)
init->visit(visitor);
if (stopExpr)
stopExpr->visit(visitor);
for (auto step : steps)
step->visit(visitor);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r15
testq %r15, %r15
je 0x100b89
movq 0x20(%r14), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq (%r12,%r13), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
addq $0x8, %r13
cmpq %r13, %r15
jne 0x100b71
movq 0x40(%r... | /MikePopoloski[P]slang/source/../include/slang/ast/statements/LoopStatements.h |
void slang::ast::CheckerMemberVisitor::handle<slang::ast::ImmediateAssertionStatement>(slang::ast::ImmediateAssertionStatement const&) | void handle(const T& stmt) {
if (!currBlock)
return;
auto notAllowed = [&] {
auto& diag = body.addDiag(diag::InvalidStmtInChecker, stmt.sourceRange);
diag << SemanticFacts::getProcedureKindStr(currBlock->procedureKind);
};
auto checkTimed = [&] {
... | movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1017b3
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl 0x40(%rax), %ecx
movl (%rsi), %eax
testl %ecx, %ecx
je 0x1017b4
decl %eax
cmpl $0x1e, %eax
ja 0x101808
leaq... | /MikePopoloski[P]slang/source/ast/symbols/InstanceSymbols.cpp |
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.