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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::bin_writer<3>>>(unsigned long, fmt::v5::align_spec const&, 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 long, fmt::v5::basic_format_specs<char>>::bin_writer<3>>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3c946
jmp 0x3c8d1
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3c8de
jmp 0x3c8d1
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3c895
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3c946
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3c8c5
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c946
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::num_writer>>(unsigned long, fmt::v5::align_spec const&, 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 long, fmt::v5::basic_format_specs<char>>::num_writer>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3cbe4
jmp 0x3cb6f
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3cb7c
jmp 0x3cb6f
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3cb33
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3cbe4
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3cb63
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3cbe4
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<char, fmt::v5::basic_format_specs<char>>::bin_writer<3>>>(unsigned long, fmt::v5::align_spec const&, 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_writer<3>>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3dcc6
jmp 0x3dc51
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3dc5e
jmp 0x3dc51
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3dc15
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3dcc6
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3dc45
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3dcc6
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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_writer<3>>::operator()<char*&>(char*&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3dd2e
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>>::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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<char, fmt::v5::basic_format_specs<char>>::num_writer>>(unsigned long, fmt::v5::align_spec const&, 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_writer>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3df6a
jmp 0x3def5
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3df02
jmp 0x3def5
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3deb9
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3df6a
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3dee9
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3df6a
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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_writer>::operator()<char*&>(char*&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3dfd2
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>>::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::basic_writer<fmt::v5::output_range<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::double_writer&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3e53e
jmp 0x3e3d9
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3e4ee
jmp 0x3e3d9
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3e39d
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3e53e
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3e3cd
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e53e
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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(%rsp), %rsi
callq 0x3ea01
addq $0x28, %rsp
retq
|
/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>>::hex_writer>::operator()<char*>(char*&&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f1b2
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>>::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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>>(unsigned long, fmt::v5::align_spec const&, 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>>::bin_writer<1>>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3f410
jmp 0x3f39b
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3f3a8
jmp 0x3f39b
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3f35f
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3f410
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3f38f
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f410
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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>>::bin_writer<3>>::operator()<char*>(char*&&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f730
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>>::bin_writer<3>>::operator()<char*&>(char*&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f730
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>>::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::basic_format_specs<char>>::num_writer>(unsigned int, fmt::v5::basic_string_view<char>, fmt::v5::basic_format_specs<char> const&, 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>>::num_writer)
|
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) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision() > static_cast<int>(num_digits)) {
size = prefix.size() + static_cast<std::size_t>(spec.precision());
padding = static_cast<std::size_t>(spec.precision()) - num_digits;
fill = '0';
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
}
|
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, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rsi
jmp 0x3f7e2
movslq 0x10(%r8), %r14
leaq (%r14,%rcx), %r15
movq %r14, %r12
subq %r11, %r12
xorl %r11d, %r11d
cmpl %eax, %r14d
cmovgq %r15, %rsi
movzbl %r10b, %eax
pushq $0x30
popq %r10
cmovlel %eax, %r10d
cmovgq %r12, %r11
movl 0x8(%r8), %eax
movl %eax, 0x10(%rsp)
movq (%r8), %rax
movq %rax, 0x8(%rsp)
testl %ebx, %ebx
jne 0x3f7e2
movl $0x2, 0x10(%rsp)
leaq 0x18(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movb %r10b, 0x10(%rax)
movq %r11, 0x18(%rax)
movups (%r9), %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x8(%rsp), %rdx
movq %rax, %rcx
callq 0x3f818
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
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>>::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::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>::num_writer>>(unsigned long, fmt::v5::align_spec const&, 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>>::num_writer>&&)
|
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() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
}
|
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 %rax, %r15
addq %r14, %r15
movzbl %bpl, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x2b1a0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x3f966
jmp 0x3f8f1
callq 0x2eb52
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x3f8fe
jmp 0x3f8f1
movq %r14, %r15
shrq %r15
cmpq $0x2, %r14
jb 0x3f8b5
movq %rax, %r12
addq %r15, %r12
movzbl %bpl, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2b1a0
movq %r12, %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3f966
movq (%r12), %rdi
subq %r15, %r14
jmp 0x3f8e5
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f966
movq (%r15), %rdi
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x2b1a0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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>>::num_writer>::operator()<char*>(char*&&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f9ce
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>>::num_writer>::operator()<char*&>(char*&) const
|
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), %r12
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x2b1a0
movq %r12, %r15
movq %r15, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3f9ce
nop
|
/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
movq %r14, %rdi
movq %rax, %rsi
callq 0x2e17e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3fa7e
movq %rax, 0x18(%r14)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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::basic_buffer<char>>, char>&)
|
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(%rsp), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x384e2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2d976
movq %rbx, %rax
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r14
retq
jmp 0x3faec
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2d976
movq %rbx, %rdi
callq 0x2b370
|
/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 %r15, %rdi
callq 0x2b0d0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x3fba3
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x2eb78
leaq 0x50(%rsp), %rdi
callq 0x2b3c0
movq %rsp, %rdi
callq 0x2b2b0
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x3fb93
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2b3c0
movq %rsp, %rdi
callq 0x2b2b0
movq %rbx, %rdi
callq 0x2b370
|
/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...);
details::log_msg log_msg(source, &name_, lvl, to_string_view(buf));
sink_it_(log_msg);
}
SPDLOG_CATCH_AND_HANDLE
}
|
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 # 0x4eba0
movq %rcx, -0x20(%rax)
movq %rax, -0x18(%rax)
movq $0x1f4, -0x8(%rax) # imm = 0x1F4
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r9, %rdx
callq 0x3fef5
leaq 0x8(%rbx), %rax
movq 0x78(%rsp), %r13
movq 0x80(%rsp), %rbp
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movl %r15d, 0x8(%r12)
callq 0x2b3f0
movq %rax, 0x10(%r12)
callq 0x3757d
movq %rax, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
andq $0x0, 0x30(%r12)
movq %r14, 0x38(%r12)
movl 0xc(%rsp), %eax
movl %eax, 0x40(%r12)
movq %rbp, 0x48(%r12)
movq %r13, 0x50(%r12)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rax)
leaq 0x70(%rsp), %rdi
callq 0x2d976
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fe2e
movq %rdx, %r14
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x2d976
movq %r15, %rdi
callq 0x2b040
cmpl $0x2, %r14d
jne 0x3fe7a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movq %rax, %rsi
callq 0x2d5c2
addq $0x48, %rbx
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x3756a
jmp 0x3fea1
leaq 0x190b(%rip), %rsi # 0x4178c
leaq 0x70(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x2d5c2
addq $0x48, %rbx
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x3756a
leaq 0x70(%rsp), %rdi
callq 0x2b390
callq 0x2b460
jmp 0x3fe1a
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2b390
jmp 0x3fec7
movq %rax, %rbx
callq 0x2b460
jmp 0x3fee5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2b390
jmp 0x3fee0
movq %rax, %rbx
callq 0x2b460
movq %rbx, %rdi
callq 0x2b370
movq %rax, %rdi
callq 0x2d66c
|
/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::allocator<char>> const&)
|
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 buffer_context<Char>::type>(args...));
}
|
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_t K = 100;
hnsw::L2Distance distance(dim);
hnsw::HNSWIndex hnsw_index(points, n_points, dim, distance, M, ef_construction);
hnsw::BruteForceIndex bf_index(points, n_points, dim, distance);
// Test build
auto t0 = std::chrono::steady_clock::now();
hnsw_index.Build();
auto t1 = std::chrono::steady_clock::now();
auto duration = duration_cast<milliseconds>(t1 - t0).count();
cout << "HNSW Build time: " << duration << "ms" << endl;
cout << "Top layer: " << hnsw_index.TopLayer() << endl;
cout << "Distance calculations: " << distance.num << endl;
float *queries = new float[dim * n_queries];
GenerateRandomFloat(queries, dim * n_queries);
hnsw_index.SetEfSearch(ef_search);
std::vector<PointSet> result1(n_queries);
t0 = std::chrono::steady_clock::now();
for (uint32_t i = 0; i < n_queries; i++) {
result1[i] = hnsw_index.Search(K, &queries[i * dim]);
}
t1 = std::chrono::steady_clock::now();
duration = duration_cast<microseconds>(t1 - t0).count();
cout << "HNSW: " << duration / n_queries << " µs/query" << endl;
std::vector<PointSet> result2(n_queries);
t0 = std::chrono::steady_clock::now();
for (uint32_t i = 0; i < n_queries; i++) {
result2[i] = bf_index.Search(K, &queries[i * dim]);
}
t1 = std::chrono::steady_clock::now();
duration = duration_cast<microseconds>(t1 - t0).count();
cout << "BruteForce: " << duration / n_queries << " µs/query" << endl;
cout << "Recall@100: " << ComputeRecall(result2, result1) << endl;
delete points;
delete queries;
return 0;
}
|
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(%r14)
leaq 0x688a(%rip), %rax # 0xacb0
movq %rax, (%r14)
movl $0x32, (%rsp)
leaq 0xd8(%rsp), %rdi
movq %rbx, %rsi
movl $0x186a0, %edx # imm = 0x186A0
movl $0x8, %ecx
movq %r14, %r8
movl $0x10, %r9d
callq 0x4c26
leaq 0x6926(%rip), %rax # 0xad80
leaq 0x80(%rsp), %rdi
movq %rax, -0x8(%rdi)
movl $0x186a0, %edx # imm = 0x186A0
movl $0x8, %ecx
movq %rbx, 0x70(%rsp)
movq %rbx, %rsi
callq 0x51fc
movabsq $0x8000186a0, %rax # imm = 0x8000186A0
movq %rax, 0xb0(%rsp)
movq %r14, 0xb8(%rsp)
callq 0x41c0
movq %rax, %r14
cmpq $0x0, 0x160(%rsp)
je 0x44cd
xorl %r15d, %r15d
leaq 0xd8(%rsp), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x5bce
incl %r15d
cmpq %r15, 0x160(%rsp)
ja 0x44b5
callq 0x41c0
movq %rax, %r15
movq 0x6afc(%rip), %rdi # 0xafd8
leaq 0x3c29(%rip), %rsi # 0x810c
movl $0x11, %edx
callq 0x41b0
subq %r14, %r15
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r15, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0x6ac3(%rip), %rdi # 0xafd8
callq 0x4170
movq %rax, %r14
leaq 0x3bfa(%rip), %rsi # 0x811e
movl $0x2, %edx
movq %rax, %rdi
callq 0x41b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
movq 0x6a79(%rip), %rdi # 0xafd8
leaq 0x3bbb(%rip), %rsi # 0x8121
movl $0xb, %edx
callq 0x41b0
movl 0x104(%rsp), %esi
movq 0x6a5a(%rip), %rdi # 0xafd8
callq 0x4220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
movq 0x6a24(%rip), %rdi # 0xafd8
leaq 0x3b72(%rip), %rsi # 0x812d
movl $0x17, %edx
callq 0x41b0
movq 0xc8(%rsp), %rsi
movq 0x6a04(%rip), %rdi # 0xafd8
callq 0x40d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r14, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
movl $0x7d00, %edi # imm = 0x7D00
callq 0x4030
movq %rax, %r14
movl $0x1f40, %esi # imm = 0x1F40
movq %rax, %rdi
callq 0x4a0e
movl $0x100, 0xf8(%rsp) # imm = 0x100
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movl $0x5dc0, %edi # imm = 0x5DC0
callq 0x4190
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq %rax, %rbx
addq $0x5dc0, %rbx # imm = 0x5DC0
movq %rbx, 0x40(%rsp)
movl $0x5dc0, %edx # imm = 0x5DC0
movq %rax, %rdi
xorl %esi, %esi
callq 0x40b0
movq %rbx, 0x38(%rsp)
movl $0x10, %ebx
callq 0x41c0
movq %rax, %r15
leaq 0x10(%rsp), %r12
leaq 0xd8(%rsp), %r13
movq %r14, %rbp
movq %r12, %rdi
movq %r13, %rsi
movl $0x64, %edx
movq %rbp, %rcx
callq 0x4d8c
movq 0x30(%rsp), %rax
vmovaps 0x10(%rsp), %xmm0
movq -0x10(%rax,%rbx), %rdi
vmovups %xmm0, -0x10(%rax,%rbx)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax,%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x46de
callq 0x4160
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x46ed
callq 0x4160
addq $0x20, %rbp
addq $0x18, %rbx
cmpq $0x5dd0, %rbx # imm = 0x5DD0
jne 0x468f
callq 0x41c0
movq %rax, %r12
movq 0x68cb(%rip), %rdi # 0xafd8
leaq 0x3a31(%rip), %rsi # 0x8145
movl $0x6, %edx
callq 0x41b0
subq %r15, %r12
movq %r12, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0x6892(%rip), %rdi # 0xafd8
callq 0x4170
movq %rax, %r15
leaq 0x39f7(%rip), %rsi # 0x814c
movl $0xa, %edx
movq %rax, %rdi
callq 0x41b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x5dc0, %edi # imm = 0x5DC0
callq 0x4190
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, %rbx
addq $0x5dc0, %rbx # imm = 0x5DC0
movq %rbx, 0x20(%rsp)
movl $0x5dc0, %edx # imm = 0x5DC0
movq %rax, %rdi
xorl %esi, %esi
callq 0x40b0
movq %rbx, 0x18(%rsp)
movl $0x10, %ebx
callq 0x41c0
movq %rax, %r15
leaq 0x50(%rsp), %r12
leaq 0x78(%rsp), %r13
movq %r14, %rbp
movq %r12, %rdi
movq %r13, %rsi
movl $0x64, %edx
movq %rbp, %rcx
callq 0x4e6e
movq 0x10(%rsp), %rax
vmovaps 0x50(%rsp), %xmm0
movq -0x10(%rax,%rbx), %rdi
vmovups %xmm0, -0x10(%rax,%rbx)
movq 0x60(%rsp), %rcx
movq %rcx, (%rax,%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
testq %rdi, %rdi
je 0x483c
callq 0x4160
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x484b
callq 0x4160
addq $0x20, %rbp
addq $0x18, %rbx
cmpq $0x5dd0, %rbx # imm = 0x5DD0
jne 0x47ed
callq 0x41c0
movq %rax, %r12
movq 0x676d(%rip), %rdi # 0xafd8
leaq 0x38e5(%rip), %rsi # 0x8157
movl $0xc, %edx
callq 0x41b0
subq %r15, %r12
movq %r12, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
movq 0x6734(%rip), %rdi # 0xafd8
callq 0x4170
movq %rax, %r15
leaq 0x3899(%rip), %rsi # 0x814c
movl $0xa, %edx
movq %rax, %rdi
callq 0x41b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
movq 0x66ea(%rip), %rdi # 0xafd8
leaq 0x386f(%rip), %rsi # 0x8164
movl $0xc, %edx
callq 0x41b0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4aec
movq 0x66c3(%rip), %rdi # 0xafd8
callq 0x41f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4180
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x40e0
movq 0x70(%rsp), %rdi
callq 0x4160
movq %r14, %rdi
callq 0x4160
leaq 0x10(%rsp), %rdi
callq 0x4fa2
leaq 0x30(%rsp), %rdi
callq 0x4fa2
leaq 0x640f(%rip), %rax # 0xad80
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x4988
callq 0x4160
leaq 0xd8(%rsp), %rdi
callq 0x4ffa
xorl %eax, %eax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49ce
jmp 0x49ba
movq %rax, %rbx
jmp 0x49f9
jmp 0x49ba
jmp 0x49ce
jmp 0x49bf
jmp 0x49ba
movq %rax, %rbx
jmp 0x49db
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4fa2
jmp 0x49d1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4fa2
leaq 0x639e(%rip), %rax # 0xad80
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x49f9
callq 0x4160
leaq 0xd8(%rsp), %rdi
callq 0x4ffa
movq %rbx, %rdi
callq 0x4230
|
/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 * M);
ef_search_ = 0;
ef_construction_ = std::max(ef_construction, M);
dim_ = dim;
vertices_.resize(n_points);
visited_.resize(n_points);
}
|
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(%rdi)
vmovupd %ymm0, 0x48(%rdi)
movq $0x1, 0x68(%rdi)
vxorpd %xmm0, %xmm0, %xmm0
vmovhpd 0x33b6(%rip), %xmm0, %xmm0 # xmm0 = xmm0[0],mem[0]
vmovupd %xmm0, 0x70(%rdi)
addq $0x80, %rdi
movl %edx, %r13d
movl %ecx, %ecx
movq %r13, %rdx
vzeroupper
callq 0x51fc
xorl %r14d, %r14d
movl %r14d, 0xb0(%r15)
movq 0x10(%rsp), %rax
movq %rax, 0xb8(%r15)
movl %r14d, 0x2c(%r15)
movl %r12d, 0x8(%r15)
movl %r12d, 0xc(%r15)
leal (%r12,%r12), %eax
movl %eax, 0x10(%r15)
vcvtsi2sd %r12d, %xmm1, %xmm0
callq 0x4120
vmovsd 0x335e(%rip), %xmm1 # 0x8030
vdivsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, 0x18(%r15)
movl %r14d, 0x20(%r15)
movl 0x50(%rsp), %eax
cmpl %r12d, %eax
cmovgl %eax, %r12d
movl %r12d, 0x24(%r15)
movl %ebp, 0xb4(%r15)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5298
movq 0x8(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x5304
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
movq %rax, %rbx
jmp 0x4d3e
movq %rbx, %r14
movq %rax, %rbx
movq 0x98(%r15), %rdi
testq %rdi, %rdi
je 0x4d3e
callq 0x4160
movq 0x8(%rsp), %rdi
callq 0x545a
movq %r14, %rdi
callq 0x5496
movq %rbx, %rdi
callq 0x4230
|
/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.neighbors.end(); iter++) {
iter->reserve(maxM_);
}
vertex.neighbors[0].reserve(maxM0_);
num_points_ += 1;
if (num_points_ == 1) {
top_layer_ = vertex.layer;
ep_ = q;
return;
}
const float *query = points_[q];
Point ep(ep_, distance_(query, points_[ep_]));
for (layer_t l = top_layer_; l > vertex.layer; l--) {
SearchUpperLayer(query, ep, l);
}
// Search neighbors and connect to them
for (layer_t l = std::min(vertex.layer, top_layer_); l >= 0; l--) {
uint32_t maxM = (l == 0) ? maxM0_ : maxM_;
MaxHeap candidates = SearchLayer(query, ep, ef_construction_, l);
PointSet selected_points =
SelectNeighborsHeuristic(query, candidates.Container(), M_); // next ep
for (const Point &p : selected_points) {
vertices_[p.first].ConnectTo(q, p.second, l);
vertex.ConnectTo(p.first, p.second, l);
// Shrink neighbors
auto &edges = vertices_[p.first].neighbors[l];
if (edges.size() > maxM) {
edges = SelectNeighborsHeuristic(points_[p.first], edges, maxM);
}
}
}
if (vertex.layer > top_layer_) {
top_layer_ = vertex.layer;
ep_ = q;
}
return;
}
|
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 %eax, 0x18(%rbx)
incl %eax
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5f4c
movq (%rbx), %r12
addq $0x18, %r12
cmpq 0x8(%rbx), %r12
je 0x5c41
movl 0xc(%r14), %esi
movq %r12, %rdi
callq 0x5fce
jmp 0x5c29
leaq 0x18(%r15,%r13), %r15
movq (%rbx), %rdi
movl 0x10(%r14), %esi
callq 0x5fce
movl 0xb0(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xb0(%r14)
testl %eax, %eax
je 0x5e9c
movq %rbx, 0x68(%rsp)
movl %ebp, 0x8(%rsp)
movq 0x98(%r14), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rbx
movq 0xb8(%r14), %rdi
movl 0x28(%r14), %ecx
movq (%rax,%rcx,8), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
movl 0x28(%r14), %eax
movl %eax, 0x18(%rsp)
vmovss %xmm0, 0x1c(%rsp)
leaq 0x2c(%r14), %r13
movl 0x2c(%r14), %ebp
movl (%r15), %eax
cmpl %eax, %ebp
jle 0x5cd6
leaq 0x18(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x6068
decl %ebp
movl (%r15), %eax
cmpl %eax, %ebp
jg 0x5cbd
cmpl %eax, (%r13)
movq %r15, 0x40(%rsp)
movq %r15, %rax
movq %r13, 0x38(%rsp)
cmovlq %r13, %rax
movslq (%rax), %r13
testq %r13, %r13
movl 0x8(%rsp), %ebp
js 0x5e8a
leaq 0x10(%r14), %rax
movq %rax, 0x58(%rsp)
leaq 0xc(%r14), %rax
movq %rax, 0x50(%rsp)
movq %r13, %rax
movq %rbx, 0x48(%rsp)
subq $0x1, %rax
movq %rax, 0x60(%rsp)
movq 0x50(%rsp), %rax
cmovbq 0x58(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x24(%r14), %r8d
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
leaq 0x18(%rsp), %rcx
movl %r13d, %r9d
callq 0x6100
movl 0x8(%r14), %r8d
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x635e
movq 0x70(%rsp), %rbx
movq 0x78(%rsp), %r15
cmpq %r15, %rbx
je 0x5e53
movl 0xc(%rsp), %eax
movq %rax, 0x10(%rsp)
leaq (%r13,%r13,2), %r12
movl (%rbx), %edi
shlq $0x5, %rdi
addq 0x30(%r14), %rdi
vmovss 0x4(%rbx), %xmm0
movl %ebp, %esi
movl %r13d, %edx
callq 0x6536
movl (%rbx), %esi
vmovss 0x4(%rbx), %xmm0
movq 0x68(%rsp), %rdi
movl %r13d, %edx
callq 0x6536
movl (%rbx), %eax
movq 0x30(%r14), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rax
movq 0x8(%rax,%r12,8), %rcx
subq (%rax,%r12,8), %rcx
sarq $0x3, %rcx
cmpq 0x10(%rsp), %rcx
jbe 0x5e46
leaq (%rax,%r12,8), %rbp
movl (%rbx), %eax
movq 0x98(%r14), %rcx
movq (%rcx,%rax,8), %rdx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rcx
movl 0xc(%rsp), %r8d
callq 0x635e
vmovaps 0x20(%rsp), %xmm0
movq (%rbp), %rdi
vmovups %xmm0, (%rbp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbp)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rdi, %rdi
je 0x5e33
callq 0x4160
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
movl 0x8(%rsp), %ebp
je 0x5e46
callq 0x4160
addq $0x8, %rbx
cmpq %r15, %rbx
jne 0x5d89
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x5e62
callq 0x4160
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
movq 0x48(%rsp), %rbx
je 0x5e79
callq 0x4160
testq %r13, %r13
movq 0x60(%rsp), %rax
movq %rax, %r13
jg 0x5d15
movq 0x40(%rsp), %rax
movl (%rax), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
jg 0x5e9f
jmp 0x5ea7
movl (%r15), %eax
movl %eax, 0x2c(%r14)
movl %ebp, 0x28(%r14)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25a6(%rip), %rdi # 0x8466
leaq 0x25f7(%rip), %rsi # 0x84be
leaq 0x264b(%rip), %rcx # 0x8519
movl $0x5a, %edx
callq 0x40c0
movq %rax, %rbx
jmp 0x5ef1
jmp 0x5edf
movq %rax, %rbx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x5ef1
callq 0x4160
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x5f03
callq 0x4160
movq %rbx, %rdi
callq 0x4230
nop
|
/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 %rbx, %rdi
movq %r15, %rsi
callq 0x5fce
movq (%r14), %rdx
cmpq 0x8(%r14), %rdx
je 0x735c
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x734a
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x7352
movq %rbx, %rdi
callq 0x6b9c
movq %r14, %rdi
callq 0x6b16
jmp 0x732a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7367
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7377
callq 0x4160
movq %r14, %rdi
callq 0x4230
nop
|
/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;
if(extensions == NULL || ext == NULL) {
return 0;
}
while(1) {
loc = strstr(extensions, ext);
if(loc == NULL) {
return 0;
}
terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) {
return 1;
}
extensions = terminator;
}
} else {
unsigned int index;
for(index = 0; index < num_exts_i; index++) {
const char *e = exts_i[index];
if(strcmp(e, ext) == 0) {
return 1;
}
}
}
return 0;
}
|
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
je 0x1bd67
movq %rax, %r15
movq %rbx, %rdi
callq 0x15400
addq %r15, %rax
cmpq %r14, %r15
je 0x1bd29
cmpb $0x20, -0x1(%r15)
movq %rax, %r14
jne 0x1bcfc
movzbl (%rax), %ecx
movq %rax, %r14
testb $-0x21, %cl
jne 0x1bcfc
movl %r12d, %ebp
jmp 0x1bd67
movq %rcx, %r15
movl %edx, %r14d
xorl %ecx, %ecx
movq %rcx, %r12
cmpq %rcx, %r14
je 0x1bd5e
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x156c0
leaq 0x1(%r12), %rcx
testl %eax, %eax
jne 0x1bd41
xorl %ebp, %ebp
cmpq %r14, %r12
setb %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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)
*green = *green + 1;
if (delta == 2)
*red = *red + 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 = monitor->widthMM;
if (heightMM)
*heightMM = monitor->heightMM;
}
|
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, (%rdx)
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1c893
pushq %rax
leaq 0x2c2bc(%rip), %rdi # 0x4b986
leaq 0x2c227(%rip), %rsi # 0x4b8f8
leaq 0x2c339(%rip), %rcx # 0x4ba11
movl $0x16b, %edx # imm = 0x16B
callq 0x151e0
|
/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 = monitor->modeCount;
return monitor->modes;
}
|
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 0x1f890
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1c893
jmp 0x1f890
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c0e4(%rip), %rdi # 0x4b986
leaq 0x2c04f(%rip), %rsi # 0x4b8f8
leaq 0x2c272(%rip), %rcx # 0x4bb22
movl $0x1ae, %edx # imm = 0x1AE
callq 0x151e0
leaq 0x2bd20(%rip), %rdi # 0x4b5e1
leaq 0x2c030(%rip), %rsi # 0x4b8f8
leaq 0x2c253(%rip), %rcx # 0x4bb22
movl $0x1af, %edx # imm = 0x1AF
callq 0x151e0
|
/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_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return GLFW_FALSE;
if (!_glfw.vk.extensions[0])
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Window surface creation extensions not found");
return GLFW_FALSE;
}
return _glfwPlatformGetPhysicalDevicePresentationSupport(instance,
device,
queuefamily);
}
|
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 0x2016a
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x285b8
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x20176
leaq 0x2c2f1(%rip), %rsi # 0x4c462
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1c893
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c247(%rip), %rdi # 0x4c3d9
leaq 0x2c15d(%rip), %rsi # 0x4c2f6
leaq 0x2c254(%rip), %rcx # 0x4c3f4
movl $0x117, %edx # imm = 0x117
callq 0x151e0
leaq 0x2c298(%rip), %rdi # 0x4c449
leaq 0x2c13e(%rip), %rsi # 0x4c2f6
leaq 0x2c235(%rip), %rcx # 0x4c3f4
movl $0x118, %edx # imm = 0x118
callq 0x151e0
|
/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 # 0x4c6d2
leaq 0x2bd9c(%rip), %rcx # 0x4c88e
movl $0x1ef, %edx # imm = 0x1EF
callq 0x151e0
leaq 0x2bbc1(%rip), %rdi # 0x4c6c4
leaq 0x2bbc8(%rip), %rsi # 0x4c6d2
leaq 0x2bd7d(%rip), %rcx # 0x4c88e
movl $0x1f0, %edx # imm = 0x1F0
callq 0x151e0
|
/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), %rdi # 0x2fc95
leaq 0x2ba40(%rip), %rsi # 0x4c6d2
leaq 0x2bcee(%rip), %rcx # 0x4c987
movl $0x220, %edx # imm = 0x220
callq 0x151e0
|
/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), %rdi # 0x2fc95
leaq 0x2b799(%rip), %rsi # 0x4c6d2
leaq 0x2bb9a(%rip), %rcx # 0x4cada
movl $0x287, %edx # imm = 0x287
callq 0x151e0
|
/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 0x2ba07(%rip), %rcx # 0x4ccfa
movl $0x30d, %edx # imm = 0x30D
callq 0x151e0
|
/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.helperWindowHandle);
_glfw.x11.helperWindowHandle = None;
}
if (_glfw.x11.hiddenCursorHandle)
{
XFreeCursor(_glfw.x11.display, _glfw.x11.hiddenCursorHandle);
_glfw.x11.hiddenCursorHandle = (Cursor) 0;
}
free(_glfw.x11.primarySelectionString);
free(_glfw.x11.clipboardString);
if (_glfw.x11.im)
{
XCloseIM(_glfw.x11.im);
_glfw.x11.im = NULL;
}
if (_glfw.x11.display)
{
XCloseDisplay(_glfw.x11.display);
_glfw.x11.display = NULL;
}
if (_glfw.x11.x11xcb.handle)
{
_glfw_dlclose(_glfw.x11.x11xcb.handle);
_glfw.x11.x11xcb.handle = NULL;
}
if (_glfw.x11.xcursor.handle)
{
_glfw_dlclose(_glfw.x11.xcursor.handle);
_glfw.x11.xcursor.handle = NULL;
}
if (_glfw.x11.randr.handle)
{
_glfw_dlclose(_glfw.x11.randr.handle);
_glfw.x11.randr.handle = NULL;
}
if (_glfw.x11.xinerama.handle)
{
_glfw_dlclose(_glfw.x11.xinerama.handle);
_glfw.x11.xinerama.handle = NULL;
}
if (_glfw.x11.xrender.handle)
{
_glfw_dlclose(_glfw.x11.xrender.handle);
_glfw.x11.xrender.handle = NULL;
}
if (_glfw.x11.vidmode.handle)
{
_glfw_dlclose(_glfw.x11.vidmode.handle);
_glfw.x11.vidmode.handle = NULL;
}
if (_glfw.x11.xi.handle)
{
_glfw_dlclose(_glfw.x11.xi.handle);
_glfw.x11.xi.handle = NULL;
}
// NOTE: These need to be unloaded after XCloseDisplay, as they register
// cleanup callbacks that get called by that function
_glfwTerminateEGL();
_glfwTerminateGLX();
#if defined(__linux__)
_glfwTerminateJoysticksLinux();
#endif
}
|
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(%rbx), %rsi
testq %rsi, %rsi
je 0x239bc
movq 0x1fec0(%rbx), %rdi
callq 0x150a0
andq $0x0, 0x1fee8(%rbx)
movq 0x1ff08(%rbx), %rdi
callq 0x153e0
movq 0x1ff10(%rbx), %rdi
callq 0x153e0
movq 0x1fef8(%rbx), %rdi
testq %rdi, %rdi
je 0x239ed
callq 0x159a0
andq $0x0, 0x1fef8(%rbx)
movq 0x1fec0(%rbx), %rdi
testq %rdi, %rdi
je 0x23a06
callq 0x15420
andq $0x0, 0x1fec0(%rbx)
movq 0x20da0(%rbx), %rdi
testq %rdi, %rdi
je 0x23a1f
callq 0x15a50
andq $0x0, 0x20da0(%rbx)
movq 0x20d50(%rbx), %rdi
testq %rdi, %rdi
je 0x23a38
callq 0x15a50
andq $0x0, 0x20d50(%rbx)
movq 0x20c58(%rbx), %rdi
testq %rdi, %rdi
je 0x23a51
callq 0x15a50
andq $0x0, 0x20c58(%rbx)
movq 0x20d78(%rbx), %rdi
testq %rdi, %rdi
je 0x23a6a
callq 0x15a50
andq $0x0, 0x20d78(%rbx)
movq 0x20e28(%rbx), %rdi
testq %rdi, %rdi
je 0x23a83
callq 0x15a50
andq $0x0, 0x20e28(%rbx)
movq 0x20db8(%rbx), %rdi
testq %rdi, %rdi
je 0x23a9c
callq 0x15a50
andq $0x0, 0x20db8(%rbx)
movq 0x20df0(%rbx), %rdi
testq %rdi, %rdi
je 0x23ab5
callq 0x15a50
andq $0x0, 0x20df0(%rbx)
callq 0x29f4e
callq 0x291ef
popq %rbx
jmp 0x2b6b6
|
/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"
#endif
;
}
|
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);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
monitor->x11.oldMode,
ci->rotation,
ci->outputs,
ci->noutput);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
monitor->x11.oldMode = None;
}
}
|
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), %rdi
movq 0x90(%rbx), %rdx
movq %rax, %rsi
callq *0x20cb0(%r12)
movq %rax, %r15
movq 0x1fec0(%r12), %rdi
movl 0x8(%rax), %r8d
movl 0xc(%rax), %r9d
movq 0x90(%rbx), %rdx
movzwl 0x20(%rax), %eax
movl 0x24(%r15), %r10d
movq %r14, %rsi
xorl %ecx, %ecx
pushq %r10
pushq 0x28(%r15)
pushq %rax
pushq 0x98(%rbx)
callq *0x20ce8(%r12)
addq $0x20, %rsp
movq %r15, %rdi
callq *0x20c80(%r12)
movq %r14, %rdi
callq *0x20c98(%r12)
andq $0x0, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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.display, sr, monitor->x11.crtc);
if (ci)
{
if (xpos)
*xpos = ci->x;
if (ypos)
*ypos = ci->y;
XRRFreeCrtcInfo(ci);
}
XRRFreeScreenResources(sr);
}
}
|
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
movq 0x1fec0(%r13), %rdi
movq 0x90(%r12), %rdx
movq %rax, %rsi
movq %r13, %r12
callq *0x20cb0(%r13)
testq %rax, %rax
je 0x2435b
movq %r12, %rdx
testq %r14, %r14
je 0x24345
movl 0x8(%rax), %ecx
movl %ecx, (%r14)
testq %rbx, %rbx
je 0x2434f
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
movq %rdx, %r12
callq *0x20c80(%rdx)
movq %r15, %rdi
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x20c98(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
areaX = ci->x;
areaY = ci->y;
const XRRModeInfo* mi = getModeInfo(sr, ci->mode);
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
areaWidth = mi->height;
areaHeight = mi->width;
}
else
{
areaWidth = mi->width;
areaHeight = mi->height;
}
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
areaWidth = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
areaHeight = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
}
if (_glfw.x11.NET_WORKAREA && _glfw.x11.NET_CURRENT_DESKTOP)
{
Atom* extents = NULL;
Atom* desktop = NULL;
const unsigned long extentCount =
_glfwGetWindowPropertyX11(_glfw.x11.root,
_glfw.x11.NET_WORKAREA,
XA_CARDINAL,
(unsigned char**) &extents);
if (_glfwGetWindowPropertyX11(_glfw.x11.root,
_glfw.x11.NET_CURRENT_DESKTOP,
XA_CARDINAL,
(unsigned char**) &desktop) > 0)
{
if (extentCount >= 4 && *desktop < extentCount / 4)
{
const int globalX = extents[*desktop * 4 + 0];
const int globalY = extents[*desktop * 4 + 1];
const int globalWidth = extents[*desktop * 4 + 2];
const int globalHeight = extents[*desktop * 4 + 3];
if (areaX < globalX)
{
areaWidth -= globalX - areaX;
areaX = globalX;
}
if (areaY < globalY)
{
areaHeight -= globalY - areaY;
areaY = globalY;
}
if (areaX + areaWidth > globalX + globalWidth)
areaWidth = globalX - areaX + globalWidth;
if (areaY + areaHeight > globalY + globalHeight)
areaHeight = globalY - areaY + globalHeight;
}
}
if (extents)
XFree(extents);
if (desktop)
XFree(desktop);
}
if (xpos)
*xpos = areaX;
if (ypos)
*ypos = areaY;
if (width)
*width = areaWidth;
if (height)
*height = areaHeight;
}
|
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, %r12
movq 0x1fec0(%r14), %rdi
movq 0x1fed0(%r14), %rsi
callq *0x20cc8(%r14)
movq %rax, %r13
movq 0x1fec0(%r14), %rdi
movq 0x90(%rbp), %rdx
movq %rax, %rsi
callq *0x20cb0(%r14)
movq %rax, %rbp
movl 0x8(%rax), %eax
movq %rax, 0x10(%rsp)
movl 0xc(%rbp), %eax
movq %rax, 0x18(%rsp)
movq 0x18(%rbp), %rsi
movq %r13, %rdi
callq 0x24106
movzwl 0x20(%rbp), %esi
pushq $0x8
popq %rcx
pushq $0xc
popq %rdx
cmpl $0x2, %esi
je 0x2445f
cmpl $0x8, %esi
je 0x2445f
pushq $0xc
popq %rcx
pushq $0x8
popq %rdx
movl (%rax,%rdx), %edx
movl %edx, (%rsp)
movl (%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
movq %rbp, %rdi
callq *0x20c80(%r14)
movq %r13, %rdi
callq *0x20c98(%r14)
movq %r12, %r13
movq %r15, %r12
movq 0x8(%rsp), %r15
jmp 0x244c7
movq 0x1fec0(%r14), %rax
movq 0xe8(%rax), %rax
movslq 0x1fec8(%r14), %rcx
shlq $0x7, %rcx
movl 0x18(%rax,%rcx), %edx
movl %edx, (%rsp)
movl 0x1c(%rax,%rcx), %eax
movl %eax, 0x4(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20b70(%r14), %rsi
testq %rsi, %rsi
je 0x2460d
cmpq $0x0, 0x20b78(%r14)
je 0x2460d
movq %r13, 0x20(%rsp)
movq %rbx, 0x8(%rsp)
leaq 0x30(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x28(%rsp), %rbp
andq $0x0, (%rbp)
movq 0x1fed0(%r14), %rdi
pushq $0x6
popq %rbx
movq %rbx, %rdx
callq 0x24a9c
movq %rax, %r13
movq 0x1fed0(%r14), %rdi
movq 0x20b78(%r14), %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x24a9c
testq %rax, %rax
setne %al
cmpq $0x4, %r13
setae %cl
testb %cl, %al
je 0x245e5
movq 0x28(%rsp), %rax
movq (%rax), %rsi
shrq $0x2, %r13
movq 0x30(%rsp), %rdi
cmpq %r13, %rsi
jae 0x245ea
shlq $0x5, %rsi
movl (%rdi,%rsi), %eax
movl 0x8(%rdi,%rsi), %ecx
xorl %r8d, %r8d
movq 0x10(%rsp), %r14
movl %r14d, %r9d
subl %eax, %r9d
cmovgel %r8d, %r9d
movl 0x10(%rdi,%rsi), %r10d
cmovlel %eax, %r14d
addl (%rsp), %r9d
movq 0x18(%rsp), %rbx
movl %ebx, %edx
subl %ecx, %edx
cmovgel %r8d, %edx
movl 0x18(%rdi,%rsi), %esi
cmovlel %ecx, %ebx
addl 0x4(%rsp), %edx
leal (%r9,%r14), %r8d
leal (%r10,%rax), %r11d
movq %r14, 0x10(%rsp)
subl %r14d, %eax
addl %r10d, %eax
cmpl %r11d, %r8d
cmovlel %r9d, %eax
leal (%rdx,%rbx), %r8d
leal (%rsi,%rcx), %r9d
movq %rbx, 0x18(%rsp)
subl %ebx, %ecx
addl %esi, %ecx
cmpl %r9d, %r8d
cmovlel %edx, %ecx
movl %eax, (%rsp)
movl %ecx, 0x4(%rsp)
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r13
jmp 0x245f9
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rbx
movq 0x20(%rsp), %r13
testq %rdi, %rdi
je 0x245fe
callq 0x15070
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2460d
callq 0x15070
testq %r15, %r15
je 0x2461a
movq 0x10(%rsp), %rax
movl %eax, (%r15)
testq %r12, %r12
je 0x24628
movq 0x18(%rsp), %rax
movl %eax, (%r12)
testq %r13, %r13
je 0x24634
movl (%rsp), %eax
movl %eax, (%r13)
testq %rbx, %rbx
je 0x2463f
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
result = calloc(oi->nmode, sizeof(GLFWvidmode));
for (int i = 0; i < oi->nmode; i++)
{
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
if (!modeIsGood(mi))
continue;
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
int j;
for (j = 0; j < *count; j++)
{
if (_glfwCompareVideoModes(result + j, &mode) == 0)
break;
}
// Skip duplicate modes
if (j < *count)
continue;
(*count)++;
result[*count - 1] = mode;
}
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
*count = 1;
result = calloc(1, sizeof(GLFWvidmode));
_glfwPlatformGetVideoMode(monitor, result);
}
return result;
}
|
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 %rax, %r15
movq 0x1fec0(%r14), %rdi
movq 0x90(%r13), %rdx
movq %rax, %rsi
callq *0x20cb0(%r14)
movq %rax, 0x10(%rsp)
movq 0x1fec0(%r14), %rdi
movq 0x88(%r13), %rdx
movq %r15, %rsi
callq *0x20cb8(%r14)
movq %rax, %r13
movl 0x50(%rax), %r12d
movslq %r12d, %rdi
pushq $0x18
popq %rsi
callq 0x157c0
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x20(%rsp), %rbp
movq %r15, 0x18(%rsp)
movslq %r12d, %rax
cmpq %rax, %r14
jge 0x247af
movq 0x58(%r13), %rax
movq (%rax,%r14,8), %rsi
movq %r15, %rdi
callq 0x24106
testb $0x10, 0x48(%rax)
jne 0x24786
movq %rbp, %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x24135
movq 0x8(%rsp), %r12
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x24755
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1f4c0
testl %eax, %eax
je 0x24753
incq %r15
addq $0x18, %r12
jmp 0x24733
movl (%rbx), %eax
cmpl %r15d, %eax
jg 0x2477d
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cltq
imulq $0x18, %rax, %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq %rcx, 0x10(%rdx,%rax)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rdx,%rax)
movl 0x50(%r13), %r12d
movq 0x18(%rsp), %r15
incq %r14
jmp 0x246f9
movl $0x1, (%rbx)
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x157c0
movq %rax, %rbx
movq %r13, %rdi
movq %rax, %rsi
callq 0x23ff7
jmp 0x247d8
movq %r13, %rdi
leaq 0x35277(%rip), %rbx # 0x59a30
callq *0x20c90(%rbx)
movq 0x10(%rsp), %rdi
callq *0x20c80(%rbx)
movq %r15, %rdi
callq *0x20c98(%rbx)
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 (;;)
{
XEvent event;
while (XCheckIfEvent(_glfw.x11.display, &event, isSelectionEvent, NULL))
{
switch (event.type)
{
case SelectionRequest:
handleSelectionRequest(&event);
break;
case SelectionClear:
handleSelectionClear(&event);
break;
case SelectionNotify:
{
if (event.xselection.target == _glfw.x11.SAVE_TARGETS)
{
// This means one of two things; either the selection
// was not owned, which means there is no clipboard
// manager, or the transfer to the clipboard manager has
// completed
// In either case, it means we are done here
return;
}
break;
}
}
}
waitForEvent(NULL);
}
}
|
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 %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x15700
testl %eax, %eax
je 0x24bc9
movl (%rsp), %eax
cmpl $0x1d, %eax
je 0x24bbf
cmpl $0x1f, %eax
je 0x24baf
cmpl $0x1e, %eax
jne 0x24b7b
movq %r14, %rdi
callq 0x24c0e
jmp 0x24b7b
movq 0x30(%rsp), %rax
cmpq 0x20c20(%r15), %rax
jne 0x24b7b
jmp 0x24bd2
movq %r14, %rdi
callq 0x24e92
jmp 0x24b7b
xorl %edi, %edi
callq 0x24ecd
jmp 0x24b7b
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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.primarySelectionString;
else
selectionString = &_glfw.x11.clipboardString;
if (XGetSelectionOwner(_glfw.x11.display, selection) ==
_glfw.x11.helperWindowHandle)
{
// Instead of doing a large number of X round-trips just to put this
// string into a window property and then read it back, just return it
return *selectionString;
}
free(*selectionString);
*selectionString = NULL;
for (size_t i = 0; i < targetCount; i++)
{
char* data;
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XEvent notification, dummy;
XConvertSelection(_glfw.x11.display,
selection,
targets[i],
_glfw.x11.GLFW_SELECTION,
_glfw.x11.helperWindowHandle,
CurrentTime);
while (!XCheckTypedWindowEvent(_glfw.x11.display,
_glfw.x11.helperWindowHandle,
SelectionNotify,
¬ification))
{
waitForEvent(NULL);
}
if (notification.xselection.property == None)
continue;
XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) ¬ification);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (actualType == _glfw.x11.INCR)
{
size_t size = 1;
char* string = NULL;
for (;;)
{
while (!XCheckIfEvent(_glfw.x11.display,
&dummy,
isSelPropNewValueNotify,
(XPointer) ¬ification))
{
waitForEvent(NULL);
}
XFree(data);
XGetWindowProperty(_glfw.x11.display,
notification.xselection.requestor,
notification.xselection.property,
0,
LONG_MAX,
True,
AnyPropertyType,
&actualType,
&actualFormat,
&itemCount,
&bytesAfter,
(unsigned char**) &data);
if (itemCount)
{
size += itemCount;
string = realloc(string, size);
string[size - itemCount - 1] = '\0';
strcat(string, data);
}
if (!itemCount)
{
if (targets[i] == XA_STRING)
{
*selectionString = convertLatin1toUTF8(string);
free(string);
}
else
*selectionString = string;
break;
}
}
}
else if (actualType == targets[i])
{
if (targets[i] == XA_STRING)
*selectionString = convertLatin1toUTF8(data);
else
*selectionString = _glfw_strdup(data);
}
XFree(data);
if (*selectionString)
break;
}
if (!*selectionString)
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"X11: Failed to convert selection to string");
}
return *selectionString;
}
|
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, 0x10(%rsp)
callq 0x159e0
movq %rax, %rcx
movq 0x1ff08(%rbp,%rbx,8), %rax
cmpq 0x1fee0(%rbp), %rcx
je 0x28541
leaq 0x1ff08(,%rbx,8), %r14
movq %rax, %rdi
callq 0x153e0
andq $0x0, (%rbp,%r14)
xorl %eax, %eax
leaq 0x68(%rsp), %r15
leaq 0x662(%rip), %r12 # 0x28948
leaq 0x128(%rsp), %r13
movq 0x10(%rsp), %rbx
movq %r14, 0x20(%rsp)
cmpq $0x2, %rax
je 0x2851f
movq %rax, 0x40(%rsp)
movq 0x50(%rsp,%rax,8), %rdx
movq 0x20c48(%rbp), %rcx
movq 0x1fec0(%rbp), %rdi
movq 0x1fee0(%rbp), %r8
movq %rbx, %rsi
movq %rdx, 0x28(%rsp)
xorl %r9d, %r9d
callq 0x15220
movq 0x1fec0(%rbp), %rdi
movq 0x1fee0(%rbp), %rsi
pushq $0x1f
popq %rdx
movq %r15, %rcx
callq 0x15140
testl %eax, %eax
jne 0x28357
xorl %edi, %edi
callq 0x24ecd
jmp 0x28331
cmpq $0x0, 0xa0(%rsp)
je 0x28512
movq 0x1fec0(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x15700
movq 0x1fec0(%rbp), %rdi
movq 0x88(%rsp), %rsi
movq 0xa0(%rsp), %rdx
xorl %ecx, %ecx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
pushq $0x1
popq %r9
movq %rsp, %rax
pushq %rax
leaq 0x50(%rsp), %rax
pushq %rax
leaq 0x40(%rsp), %rax
pushq %rax
leaq 0x34(%rsp), %rax
pushq %rax
leaq 0x58(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x15240
addq $0x30, %rsp
movq 0x38(%rsp), %rax
cmpq 0x20c00(%rbp), %rax
jne 0x2849b
pushq $0x1
popq %rbx
movq $0x0, 0x8(%rsp)
movq 0x1fec0(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x15700
testl %eax, %eax
jne 0x28409
xorl %edi, %edi
callq 0x24ecd
jmp 0x283e7
movq (%rsp), %rdi
callq 0x15070
movq 0x1fec0(%rbp), %rdi
movq 0x88(%rsp), %rsi
movq 0xa0(%rsp), %rdx
xorl %ecx, %ecx
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
pushq $0x1
popq %r9
movq %rsp, %rax
pushq %rax
leaq 0x50(%rsp), %rax
pushq %rax
leaq 0x40(%rsp), %rax
pushq %rax
leaq 0x34(%rsp), %rax
pushq %rax
leaq 0x58(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x15240
addq $0x30, %rsp
movq 0x30(%rsp), %r14
testq %r14, %r14
je 0x284b6
addq %r14, %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x15950
movq %rax, %rdi
notq %r14
addq %rbx, %rax
movb $0x0, (%r14,%rax)
movq (%rsp), %rsi
movq %rdi, 0x8(%rsp)
callq 0x15520
jmp 0x283e7
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
jne 0x284ff
movq (%rsp), %rdi
cmpq $0x1f, %rcx
jne 0x284f5
callq 0x2896e
jmp 0x284fa
cmpq $0x1f, 0x28(%rsp)
jne 0x284df
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2896e
movq 0x20(%rsp), %r14
movq %rax, (%rbp,%r14)
movq %rbx, %rdi
callq 0x153e0
jmp 0x284ee
movq 0x20(%rsp), %r14
movq 0x8(%rsp), %rax
movq %rax, (%rbp,%r14)
movq 0x10(%rsp), %rbx
jmp 0x284ff
callq 0x1c848
movq %rax, (%rbp,%r14)
movq (%rsp), %rdi
callq 0x15070
movq (%rbp,%r14), %rax
testq %rax, %rax
jne 0x28541
movq 0x40(%rsp), %rax
incq %rax
jmp 0x282f8
movq (%rbp,%r14), %rax
testq %rax, %rax
jne 0x28541
leaq 0x25e8e(%rip), %rsi # 0x4e3be
movl $0x10009, %edi # imm = 0x10009
xorl %eax, %eax
callq 0x1c893
movq (%rbp,%r14), %rax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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_surface is preferred due to some early ICDs exposing but
// not correctly implementing VK_KHR_xlib_surface
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
extensions[1] = "VK_KHR_xcb_surface";
else
extensions[1] = "VK_KHR_xlib_surface";
}
|
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 0x2388d(%rip), %rcx # 0x4be2f
leaq 0x23872(%rip), %rdx # 0x4be1b
cmoveq %rdx, %rcx
testl %eax, %eax
cmoveq %rdx, %rcx
movq %rcx, 0x8(%rdi)
retq
|
/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,
_glfw.x11.screen));
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
{
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
vkGetPhysicalDeviceXcbPresentationSupportKHR =
(PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
if (!vkGetPhysicalDeviceXcbPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
return GLFW_FALSE;
}
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXcbPresentationSupportKHR(device,
queuefamily,
connection,
visualID);
}
else
{
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
vkGetPhysicalDeviceXlibPresentationSupportKHR =
(PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
if (!vkGetPhysicalDeviceXlibPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXlibPresentationSupportKHR(device,
queuefamily,
_glfw.x11.display,
visualID);
}
}
|
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 0x1fe98(%r13), %rax
je 0x28648
cmpq $0x0, 0x20da0(%r13)
je 0x28648
leaq 0x25ab2(%rip), %rsi # 0x4e0ca
movq %r12, %rdi
callq *%rax
testq %rax, %rax
je 0x2867c
movq %rax, %r12
movq 0x1fec0(%r13), %rdi
callq *0x20da8(%r13)
testq %rax, %rax
je 0x2868a
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %r12, %rax
jmp 0x28668
leaq 0x25b09(%rip), %rsi # 0x4e158
movq %r12, %rdi
callq *%rax
testq %rax, %rax
je 0x28673
movq 0x1fec0(%r13), %rdx
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
leaq 0x25b0c(%rip), %rsi # 0x4e186
jmp 0x28683
leaq 0x25a74(%rip), %rsi # 0x4e0f7
movl $0x10006, %edi # imm = 0x10006
jmp 0x28696
leaq 0x25aa0(%rip), %rsi # 0x4e131
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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.x11xcb.handle)
{
VkResult err;
VkXcbSurfaceCreateInfoKHR sci;
PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR;
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
vkCreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXcbSurfaceKHR");
if (!vkCreateXcbSurfaceKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
sci.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
sci.connection = connection;
sci.window = window->x11.handle;
err = vkCreateXcbSurfaceKHR(instance, &sci, allocator, surface);
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to create Vulkan XCB surface: %s",
_glfwGetVulkanResultString(err));
}
return err;
}
else
{
VkResult err;
VkXlibSurfaceCreateInfoKHR sci;
PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR;
vkCreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)
vkGetInstanceProcAddr(instance, "vkCreateXlibSurfaceKHR");
if (!vkCreateXlibSurfaceKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
memset(&sci, 0, sizeof(sci));
sci.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
sci.dpy = _glfw.x11.display;
sci.window = window->x11.handle;
err = vkCreateXlibSurfaceKHR(instance, &sci, allocator, surface);
if (err)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to create Vulkan X11 surface: %s",
_glfwGetVulkanResultString(err));
}
return err;
}
}
|
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
je 0x287d9
movq %rax, %r13
leaq 0x25ac0(%rip), %rsi # 0x4e1c1
movq %r15, %rdi
callq *0x1fe98(%rbp)
testq %rax, %rax
je 0x287e7
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl $0x3b9add88, (%rsi) # imm = 0x3B9ADD88
movq %r13, 0x18(%rsi)
movq 0x348(%r12), %rcx
movq %rcx, 0x20(%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *%rax
testl %eax, %eax
je 0x287cc
movl %eax, %ebx
movl %eax, %edi
callq 0x1febd
leaq 0x25a7d(%rip), %rsi # 0x4e1d7
jmp 0x287bb
leaq 0x25aa1(%rip), %rsi # 0x4e204
movq %r15, %rdi
callq *0x1fe98(%rbp)
testq %rax, %rax
je 0x287d0
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl $0x3b9ad9a0, (%rsi) # imm = 0x3B9AD9A0
movq 0x1fec0(%rbp), %rcx
movq %rcx, 0x18(%rsi)
movq 0x348(%r12), %rcx
movq %rcx, 0x20(%rsi)
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq *%rax
testl %eax, %eax
je 0x287cc
movl %eax, %ebx
movl %eax, %edi
callq 0x1febd
leaq 0x25a60(%rip), %rsi # 0x4e21b
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
callq 0x1c893
jmp 0x287fd
xorl %ebx, %ebx
jmp 0x287fd
leaq 0x259af(%rip), %rsi # 0x4e186
jmp 0x287ee
leaq 0x25951(%rip), %rsi # 0x4e131
movl $0x10008, %edi # imm = 0x10008
jmp 0x287f3
leaq 0x25909(%rip), %rsi # 0x4e0f7
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1c893
pushq $-0x7
popq %rbx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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)
mods |= GLFW_MOD_CAPS_LOCK;
if (state & Mod2Mask)
mods |= GLFW_MOD_NUM_LOCK;
return mods;
}
|
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 &&
event->xproperty.atom == notification->xselection.property;
}
|
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, %rdi
callq 0x2805f
addq %rax, %r15
incq %rbx
jmp 0x289a1
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
|
/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 keysym;
}
// Also check for directly encoded 24-bit UCS characters
if ((keysym & 0xff000000) == 0x01000000)
return keysym & 0x00ffffff;
// Binary search in table
while (max >= min)
{
mid = (min + max) / 2;
if (keysymtab[mid].keysym < keysym)
min = mid + 1;
else if (keysymtab[mid].keysym > keysym)
max = mid - 1;
else
return keysymtab[mid].ucs;
}
// No matching Unicode value found
return -1;
}
|
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 = 0xFFFFFF
movq %rdi, %rcx
jmp 0x28a40
movl $0x33b, %r10d # imm = 0x33B
xorl %r9d, %r9d
pushq $-0x1
popq %rcx
pushq $0x2
popq %r8
leaq 0x259df(%rip), %rsi # 0x4e3f0
cmpl %r9d, %r10d
jl 0x28a40
leal (%r10,%r9), %eax
cltd
idivl %r8d
movslq %eax, %rdx
movzwl (%rsi,%rdx,4), %r11d
cmpl %edi, %r11d
jb 0x28a34
jbe 0x28a3b
decl %eax
movl %eax, %r10d
jmp 0x28a11
incl %eax
movl %eax, %r9d
jmp 0x28a11
movzwl 0x2(%rsi,%rdx,4), %ecx
movq %rcx, %rax
retq
|
/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;
_glfw.timer.posix.frequency = 1000000;
}
}
|
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 $0x18, %rsp
retq
|
/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.allocated = GLFW_TRUE;
return GLFW_TRUE;
}
|
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 $0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x265b7(%rip), %rdi # 0x4f0e0
leaq 0x265d3(%rip), %rsi # 0x4f103
leaq 0x2663a(%rip), %rcx # 0x4f171
pushq $0x2a
popq %rdx
callq 0x151e0
|
/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->context.glx.handle;
if (!chooseGLXFBConfig(fbconfig, &native))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"GLX: Failed to find a suitable GLXFBConfig");
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (!_glfw.glx.ARB_create_context ||
!_glfw.glx.ARB_create_context_profile ||
!_glfw.glx.EXT_create_context_es2_profile)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"GLX: OpenGL ES requested but GLX_EXT_create_context_es2_profile is unavailable");
return GLFW_FALSE;
}
}
if (ctxconfig->forward)
{
if (!_glfw.glx.ARB_create_context)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"GLX: Forward compatibility requested but GLX_ARB_create_context_profile is unavailable");
return GLFW_FALSE;
}
}
if (ctxconfig->profile)
{
if (!_glfw.glx.ARB_create_context ||
!_glfw.glx.ARB_create_context_profile)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"GLX: An OpenGL profile requested but GLX_ARB_create_context_profile is unavailable");
return GLFW_FALSE;
}
}
_glfwGrabErrorHandlerX11();
if (_glfw.glx.ARB_create_context)
{
int index = 0, mask = 0, flags = 0;
if (ctxconfig->client == GLFW_OPENGL_API)
{
if (ctxconfig->forward)
flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
}
else
mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT;
if (ctxconfig->debug)
flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
if (ctxconfig->robustness)
{
if (_glfw.glx.ARB_create_context_robustness)
{
if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
{
setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
GLX_NO_RESET_NOTIFICATION_ARB);
}
else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
{
setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
GLX_LOSE_CONTEXT_ON_RESET_ARB);
}
flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
}
}
if (ctxconfig->release)
{
if (_glfw.glx.ARB_context_flush_control)
{
if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
{
setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
}
else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH)
{
setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB,
GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
}
}
}
if (ctxconfig->noerror)
{
if (_glfw.glx.ARB_create_context_no_error)
setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
}
// NOTE: Only request an explicitly versioned context when necessary, as
// explicitly requesting version 1.0 does not always return the
// highest version supported by the driver
if (ctxconfig->major != 1 || ctxconfig->minor != 0)
{
setAttrib(GLX_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
setAttrib(GLX_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
}
if (mask)
setAttrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask);
if (flags)
setAttrib(GLX_CONTEXT_FLAGS_ARB, flags);
setAttrib(None, None);
window->context.glx.handle =
_glfw.glx.CreateContextAttribsARB(_glfw.x11.display,
native,
share,
True,
attribs);
// HACK: This is a fallback for broken versions of the Mesa
// implementation of GLX_ARB_create_context_profile that fail
// default 1.0 context creation with a GLXBadProfileARB error in
// violation of the extension spec
if (!window->context.glx.handle)
{
if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB &&
ctxconfig->client == GLFW_OPENGL_API &&
ctxconfig->profile == GLFW_OPENGL_ANY_PROFILE &&
ctxconfig->forward == GLFW_FALSE)
{
window->context.glx.handle =
createLegacyContextGLX(window, native, share);
}
}
}
else
{
window->context.glx.handle =
createLegacyContextGLX(window, native, share);
}
_glfwReleaseErrorHandlerX11();
if (!window->context.glx.handle)
{
_glfwInputErrorX11(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context");
return GLFW_FALSE;
}
window->context.glx.window =
glXCreateWindow(_glfw.x11.display, native, window->x11.handle, NULL);
if (!window->context.glx.window)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to create window");
return GLFW_FALSE;
}
window->context.makeCurrent = makeContextCurrentGLX;
window->context.swapBuffers = swapBuffersGLX;
window->context.swapInterval = swapIntervalGLX;
window->context.extensionSupported = extensionSupportedGLX;
window->context.getProcAddress = getProcAddressGLX;
window->context.destroy = destroyContextGLX;
return GLFW_TRUE;
}
|
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, (%r15) # imm = 0x30002
leaq 0x307ca(%rip), %r13 # 0x59a30
movl 0x20f20(%r13), %eax
jne 0x29293
testl %eax, %eax
je 0x29329
cmpl $0x0, 0x20f24(%r13)
je 0x29329
cmpl $0x0, 0x20f2c(%r13)
je 0x29329
cmpl $0x0, 0x10(%r15)
sete %cl
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x29320
cmpl $0x0, 0x1c(%r15)
je 0x292bd
testl %eax, %eax
je 0x2933a
cmpl $0x0, 0x20f24(%r13)
je 0x2933a
callq 0x21b30
cmpl $0x0, 0x20f20(%r13)
je 0x29364
xorl %eax, %eax
cmpl $0x30001, (%r15) # imm = 0x30001
jne 0x29392
xorl %edi, %edi
cmpl $0x0, 0x10(%r15)
setne %dil
addl %edi, %edi
movl 0x1c(%r15), %ecx
cmpl $0x32001, %ecx # imm = 0x32001
je 0x2939b
cmpl $0x32002, %ecx # imm = 0x32002
jne 0x293a2
pushq $0x2
jmp 0x2939d
leaq 0x2636e(%rip), %rsi # 0x4f684
xorl %r14d, %r14d
movl $0x10009, %edi # imm = 0x10009
jmp 0x29349
leaq 0x263d7(%rip), %rsi # 0x4f6fe
jmp 0x29341
leaq 0x2637f(%rip), %rsi # 0x4f6af
xorl %r14d, %r14d
movl $0x10006, %edi # imm = 0x10006
jmp 0x29349
leaq 0x26414(%rip), %rsi # 0x4f755
xorl %r14d, %r14d
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x1c893
movl %r14d, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rsp), %r12
movq 0x1fec0(%r13), %rdi
pushq $0x1
popq %r8
movq %r12, %rsi
movl $0x8014, %edx # imm = 0x8014
movq %r14, %rcx
callq *0x20eb8(%r13)
movq %rax, 0x270(%rbx)
jmp 0x2951c
pushq $0x4
popq %rcx
xorl %edx, %edx
xorl %edi, %edi
jmp 0x293a6
pushq $0x1
popq %rcx
xorl %edx, %edx
jmp 0x293a6
xorl %ecx, %ecx
movb $0x1, %dl
xorl %esi, %esi
cmpl $0x0, 0x14(%r15)
setne %sil
orl %edi, %esi
movl 0x20(%r15), %edi
testl %edi, %edi
je 0x293f5
cmpl $0x0, 0x20f28(%r13)
je 0x293f5
cmpl $0x31001, %edi # imm = 0x31001
je 0x293de
xorl %eax, %eax
cmpl $0x31002, %edi # imm = 0x31002
jne 0x293f2
movl $0x8252, %edi # imm = 0x8252
jmp 0x293e3
movl $0x8261, %edi # imm = 0x8261
pushq $0x2
popq %rax
movl $0x8256, 0x10(%rsp) # imm = 0x8256
movl %edi, 0x14(%rsp)
orl $0x4, %esi
movl 0x24(%r15), %edi
testl %edi, %edi
je 0x29434
cmpl $0x0, 0x20f34(%r13)
je 0x29434
cmpl $0x35002, %edi # imm = 0x35002
je 0x2941e
cmpl $0x35001, %edi # imm = 0x35001
jne 0x29434
movl $0x2098, %edi # imm = 0x2098
jmp 0x29420
xorl %edi, %edi
movl %eax, %r8d
movl $0x2097, 0x10(%rsp,%r8,4) # imm = 0x2097
addl $0x2, %eax
movl %edi, 0x14(%rsp,%r8,4)
cmpl $0x0, 0x18(%r15)
je 0x29459
cmpl $0x0, 0x20f30(%r13)
je 0x29459
movl %eax, %edi
movabsq $0x1000031b3, %r8 # imm = 0x1000031B3
movq %r8, 0x10(%rsp,%rdi,4)
addl $0x2, %eax
movl 0x8(%r15), %r8d
movl 0xc(%r15), %edi
movl %r8d, %r9d
xorl $0x1, %r9d
orl %edi, %r9d
je 0x2948f
movl %eax, %r9d
movl $0x2091, 0x10(%rsp,%r9,4) # imm = 0x2091
movl %r8d, 0x14(%rsp,%r9,4)
movl $0x2092, 0x18(%rsp,%r9,4) # imm = 0x2092
addl $0x4, %eax
movl %edi, 0x1c(%rsp,%r9,4)
testb %dl, %dl
jne 0x294a4
movl %eax, %edx
movl $0x9126, 0x10(%rsp,%rdx,4) # imm = 0x9126
addl $0x2, %eax
movl %ecx, 0x14(%rsp,%rdx,4)
testl %esi, %esi
je 0x294b9
movl %eax, %ecx
movl $0x2094, 0x10(%rsp,%rcx,4) # imm = 0x2094
addl $0x2, %eax
movl %esi, 0x14(%rsp,%rcx,4)
movl %eax, %eax
andq $0x0, 0x10(%rsp,%rax,4)
movq 0x1fec0(%r13), %rdi
movq 0x8(%rsp), %r12
pushq $0x1
popq %rcx
leaq 0x10(%rsp), %r8
movq %r12, %rsi
movq %r14, %rdx
callq *0x20f00(%r13)
movq %rax, 0x270(%rbx)
testq %rax, %rax
jne 0x2951c
movl 0x20e64(%r13), %eax
addl $0xd, %eax
cmpl %eax, 0x1ff00(%r13)
jne 0x2951c
cmpl $0x30001, (%r15) # imm = 0x30001
jne 0x2951c
cmpl $0x0, 0x1c(%r15)
jne 0x2951c
cmpl $0x0, 0x10(%r15)
je 0x29369
callq 0x21b5e
cmpq $0x0, 0x270(%rbx)
je 0x295b5
movq 0x1fec0(%r13), %rdi
movq 0x348(%rbx), %rdx
xorl %r14d, %r14d
movq %r12, %rsi
xorl %ecx, %ecx
callq *0x20ec8(%r13)
movq %rax, 0x278(%rbx)
testq %rax, %rax
je 0x295ce
leaq 0x346(%rip), %rax # 0x298a5
movq %rax, 0x240(%rbx)
leaq 0x3a6(%rip), %rax # 0x29913
movq %rax, 0x248(%rbx)
leaq 0x3b9(%rip), %rax # 0x29934
movq %rax, 0x250(%rbx)
leaq -0x408(%rip), %rax # 0x29181
movq %rax, 0x258(%rbx)
leaq -0x3db(%rip), %rax # 0x291bc
movq %rax, 0x260(%rbx)
leaq 0x411(%rip), %rax # 0x299b6
movq %rax, 0x268(%rbx)
pushq $0x1
popq %r14
jmp 0x29350
leaq 0x261ec(%rip), %rsi # 0x4f7a8
movl $0x10007, %edi # imm = 0x10007
callq 0x21b7c
xorl %r14d, %r14d
jmp 0x29350
leaq 0x261f1(%rip), %rsi # 0x4f7c6
movl $0x10008, %edi # imm = 0x10008
jmp 0x29349
|
/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 (!chooseGLXFBConfig(fbconfig, &native))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"GLX: Failed to find a suitable GLXFBConfig");
return GLFW_FALSE;
}
result = glXGetVisualFromFBConfig(_glfw.x11.display, native);
if (!result)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"GLX: Failed to retrieve Visual for GLXFBConfig");
return GLFW_FALSE;
}
*visual = result->visual;
*depth = result->depth;
XFree(result);
return GLFW_TRUE;
}
|
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), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x15070
pushq $0x1
popq %rbx
jmp 0x29a7f
leaq 0x25c23(%rip), %rsi # 0x4f684
xorl %ebx, %ebx
movl $0x10009, %edi # imm = 0x10009
jmp 0x29a78
leaq 0x25d72(%rip), %rsi # 0x4f7e3
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 0x1c893
movq %rbx, %rax
popq %rbx
retq
|
/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
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.egl.handle = _glfw_dlopen(sonames[i]);
if (_glfw.egl.handle)
break;
}
if (!_glfw.egl.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Library not found");
return GLFW_FALSE;
}
_glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
_glfw.egl.GetConfigAttrib = (PFN_eglGetConfigAttrib)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
_glfw.egl.GetConfigs = (PFN_eglGetConfigs)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
_glfw.egl.GetDisplay = (PFN_eglGetDisplay)
_glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
_glfw.egl.GetError = (PFN_eglGetError)
_glfw_dlsym(_glfw.egl.handle, "eglGetError");
_glfw.egl.Initialize = (PFN_eglInitialize)
_glfw_dlsym(_glfw.egl.handle, "eglInitialize");
_glfw.egl.Terminate = (PFN_eglTerminate)
_glfw_dlsym(_glfw.egl.handle, "eglTerminate");
_glfw.egl.BindAPI = (PFN_eglBindAPI)
_glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
_glfw.egl.CreateContext = (PFN_eglCreateContext)
_glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
_glfw.egl.DestroySurface = (PFN_eglDestroySurface)
_glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
_glfw.egl.DestroyContext = (PFN_eglDestroyContext)
_glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
_glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
_glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
_glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
_glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
_glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
_glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
_glfw.egl.SwapInterval = (PFN_eglSwapInterval)
_glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
_glfw.egl.QueryString = (PFN_eglQueryString)
_glfw_dlsym(_glfw.egl.handle, "eglQueryString");
_glfw.egl.GetProcAddress = (PFN_eglGetProcAddress)
_glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
if (!_glfw.egl.GetConfigAttrib ||
!_glfw.egl.GetConfigs ||
!_glfw.egl.GetDisplay ||
!_glfw.egl.GetError ||
!_glfw.egl.Initialize ||
!_glfw.egl.Terminate ||
!_glfw.egl.BindAPI ||
!_glfw.egl.CreateContext ||
!_glfw.egl.DestroySurface ||
!_glfw.egl.DestroyContext ||
!_glfw.egl.CreateWindowSurface ||
!_glfw.egl.MakeCurrent ||
!_glfw.egl.SwapBuffers ||
!_glfw.egl.SwapInterval ||
!_glfw.egl.QueryString ||
!_glfw.egl.GetProcAddress)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to load required entry points");
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to get EGL display: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to initialize EGL: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.KHR_create_context =
extensionSupportedEGL("EGL_KHR_create_context");
_glfw.egl.KHR_create_context_no_error =
extensionSupportedEGL("EGL_KHR_create_context_no_error");
_glfw.egl.KHR_gl_colorspace =
extensionSupportedEGL("EGL_KHR_gl_colorspace");
_glfw.egl.KHR_get_all_proc_addresses =
extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");
_glfw.egl.KHR_context_flush_control =
extensionSupportedEGL("EGL_KHR_context_flush_control");
return GLFW_TRUE;
}
|
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 0x15550
movq %rax, 0x20fb0(%r14)
incq %r15
testq %rax, %rax
je 0x29b62
movq -0x8(%r12,%r15,8), %rdx
xorl %ecx, %ecx
cmpb $0x6c, (%rdx)
jne 0x29ba1
cmpb $0x69, 0x1(%rdx)
jne 0x29ba1
xorl %ecx, %ecx
cmpb $0x62, 0x2(%rdx)
sete %cl
movl %ecx, 0x20f98(%r14)
leaq 0x25cf6(%rip), %rsi # 0x4f8a5
movq %rax, %rdi
callq 0x15910
movq %rax, 0x20fb8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25cec(%rip), %rsi # 0x4f8b8
callq 0x15910
movq %rax, 0x20fc0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25ce0(%rip), %rsi # 0x4f8c6
callq 0x15910
movq %rax, 0x20fc8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25cd4(%rip), %rsi # 0x4f8d4
callq 0x15910
movq %rax, 0x20fd0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25cc6(%rip), %rsi # 0x4f8e0
callq 0x15910
movq %rax, 0x20fd8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25cba(%rip), %rsi # 0x4f8ee
callq 0x15910
movq %rax, 0x20fe0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25cad(%rip), %rsi # 0x4f8fb
callq 0x15910
movq %rax, 0x20fe8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c9e(%rip), %rsi # 0x4f906
callq 0x15910
movq %rax, 0x20ff0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c95(%rip), %rsi # 0x4f917
callq 0x15910
movq %rax, 0x20ff8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c8d(%rip), %rsi # 0x4f929
callq 0x15910
movq %rax, 0x21000(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c85(%rip), %rsi # 0x4f93b
callq 0x15910
movq %rax, 0x21008(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c82(%rip), %rsi # 0x4f952
callq 0x15910
movq %rax, 0x21010(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c77(%rip), %rsi # 0x4f961
callq 0x15910
movq %rax, 0x21018(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c6c(%rip), %rsi # 0x4f970
callq 0x15910
movq %rax, 0x21020(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c62(%rip), %rsi # 0x4f980
callq 0x15910
movq %rax, 0x21028(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c57(%rip), %rsi # 0x4f98f
callq 0x15910
movq %rax, 0x21030(%r14)
movdqu 0x20fb8(%r14), %xmm7
movdqu 0x20fc8(%r14), %xmm0
movdqu 0x20fd8(%r14), %xmm6
movdqu 0x20fe8(%r14), %xmm8
movdqu 0x21008(%r14), %xmm5
movdqu 0x20ff8(%r14), %xmm4
movdqu 0x21018(%r14), %xmm2
movq %rax, %xmm3
movq 0x21028(%r14), %xmm1
punpcklqdq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0]
pxor %xmm3, %xmm3
pcmpeqd %xmm3, %xmm8
pshufd $0xb1, %xmm8, %xmm9 # xmm9 = xmm8[1,0,3,2]
pand %xmm8, %xmm9
pcmpeqd %xmm3, %xmm6
pshufd $0xb1, %xmm6, %xmm8 # xmm8 = xmm6[1,0,3,2]
pand %xmm6, %xmm8
packssdw %xmm9, %xmm8
movdqa %xmm0, %xmm6
pcmpeqd %xmm3, %xmm6
pshufd $0xb1, %xmm6, %xmm9 # xmm9 = xmm6[1,0,3,2]
pand %xmm6, %xmm9
pcmpeqd %xmm3, %xmm7
pshufd $0xb1, %xmm7, %xmm6 # xmm6 = xmm7[1,0,3,2]
pand %xmm7, %xmm6
packssdw %xmm9, %xmm6
packssdw %xmm8, %xmm6
pcmpeqd %xmm3, %xmm5
pshufd $0xb1, %xmm5, %xmm7 # xmm7 = xmm5[1,0,3,2]
pand %xmm5, %xmm7
pcmpeqd %xmm3, %xmm4
pshufd $0xb1, %xmm4, %xmm5 # xmm5 = xmm4[1,0,3,2]
pand %xmm4, %xmm5
packssdw %xmm7, %xmm5
pcmpeqd %xmm3, %xmm2
pshufd $0xb1, %xmm2, %xmm4 # xmm4 = xmm2[1,0,3,2]
pand %xmm2, %xmm4
pcmpeqd %xmm3, %xmm1
pshufd $0xb1, %xmm1, %xmm2 # xmm2 = xmm1[1,0,3,2]
pand %xmm1, %xmm2
packssdw %xmm2, %xmm4
packssdw %xmm4, %xmm5
packsswb %xmm5, %xmm6
pmovmskb %xmm6, %eax
testl %eax, %eax
je 0x29e67
leaq 0x25b67(%rip), %rsi # 0x4f9a1
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
jmp 0x29f3b
leaq 0x25a3a(%rip), %rsi # 0x4f88e
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1c893
jmp 0x29f40
movq 0x1fec0(%r14), %rdi
movq %xmm0, %rax
callq *%rax
movq %rax, 0x20f88(%r14)
testq %rax, %rax
je 0x29efe
leaq 0x20f90(%r14), %rsi
leaq 0x20f94(%r14), %rdx
movq %rax, %rdi
callq *0x20fd8(%r14)
testl %eax, %eax
je 0x29f15
leaq 0x25b6c(%rip), %rdi # 0x4fa10
callq 0x29faf
movl %eax, 0x20f9c(%r14)
leaq 0x25b70(%rip), %rdi # 0x4fa27
callq 0x29faf
movl %eax, 0x20fa0(%r14)
leaq 0x25b7d(%rip), %rdi # 0x4fa47
callq 0x29faf
movl %eax, 0x20fa4(%r14)
leaq 0x25b80(%rip), %rdi # 0x4fa5d
callq 0x29faf
movl %eax, 0x20fa8(%r14)
leaq 0x25b8c(%rip), %rdi # 0x4fa7c
callq 0x29faf
movl %eax, 0x20fac(%r14)
jmp 0x29f40
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x29f8b
leaq 0x25ab8(%rip), %rsi # 0x4f9cb
jmp 0x29f2a
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x29f8b
leaq 0x25ac4(%rip), %rsi # 0x4f9ee
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x1c893
callq 0x29f4e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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)
{
_glfw_dlclose(window->context.egl.client);
window->context.egl.client = NULL;
}
}
if (window->context.egl.surface)
{
eglDestroySurface(_glfw.egl.display, window->context.egl.surface);
window->context.egl.surface = EGL_NO_SURFACE;
}
if (window->context.egl.handle)
{
eglDestroyContext(_glfw.egl.display, window->context.egl.handle);
window->context.egl.handle = EGL_NO_CONTEXT;
}
}
|
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, 0x290(%rbx)
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x2a876
leaq 0x2f1cf(%rip), %rax # 0x59a30
movq 0x20f88(%rax), %rdi
callq *0x21000(%rax)
andq $0x0, 0x288(%rbx)
popq %rbx
retq
|
/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 window->context.egl.handle;
}
|
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 0x1c893
movq %rbx, %rax
popq %rbx
retq
|
/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 window->context.egl.surface;
}
|
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 0x1c893
movq %rbx, %rax
popq %rbx
retq
|
/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->context.osmesa.width) ||
(height != window->context.osmesa.height))
{
free(window->context.osmesa.buffer);
// Allocate the new buffer (width * height * 8-bit RGBA)
window->context.osmesa.buffer = calloc(4, (size_t) width * height);
window->context.osmesa.width = width;
window->context.osmesa.height = height;
}
if (!OSMesaMakeCurrent(window->context.osmesa.handle,
window->context.osmesa.buffer,
GL_UNSIGNED_BYTE,
width, height))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OSMesa: Failed to make context current");
return;
}
}
_glfwPlatformSetTls(&_glfw.contextSlot, 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
je 0x2ae36
movq %rsi, %rdi
callq 0x153e0
movslq 0xc(%rsp), %r14
movslq 0x8(%rsp), %r15
movq %r15, %rsi
imulq %r14, %rsi
pushq $0x4
popq %rdi
callq 0x157c0
movq %rax, %rsi
movq %rax, 0x2b0(%rbx)
movl %r14d, 0x2a8(%rbx)
movl %r15d, 0x2ac(%rbx)
leaq 0x2ebf3(%rip), %rax # 0x59a30
movq 0x2a0(%rbx), %rdi
movl $0x1401, %edx # imm = 0x1401
movl %r14d, %ecx
movl %r15d, %r8d
callq *0x21058(%rax)
testl %eax, %eax
je 0x2ae6f
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x2c183(%rip), %rdi # 0x56fe8
movq %rbx, %rsi
callq 0x28b81
jmp 0x2ae82
leaq 0x254dd(%rip), %rsi # 0x50353
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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->context.osmesa.width = 0;
window->context.osmesa.height = 0;
}
}
|
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.osmesa.handle;
}
|
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 0x1c893
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
|
/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 way is libudev
_glfw.linjs.watch = inotify_add_watch(_glfw.linjs.inotify,
dirname,
IN_CREATE | IN_ATTRIB | IN_DELETE);
}
// Continue without device connection notifications if inotify fails
if (regcomp(&_glfw.linjs.regex, "^event[0-9]\\+$", 0) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "Linux: Failed to compile regex");
return GLFW_FALSE;
}
int count = 0;
DIR* dir = opendir(dirname);
if (dir)
{
struct dirent* entry;
while ((entry = readdir(dir)))
{
regmatch_t match;
if (regexec(&_glfw.linjs.regex, entry->d_name, 1, &match, 0) != 0)
continue;
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/%s", dirname, entry->d_name);
if (openJoystickDevice(path))
count++;
}
closedir(dir);
}
// Continue with no joysticks if enumeration fails
qsort(_glfw.joysticks, count, sizeof(_GLFWjoystick), compareJoysticks);
return GLFW_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
movl $0x304, %edx # imm = 0x304
callq 0x15850
movl %eax, 0x20f3c(%rbx)
movl $0x20f40, %edi # imm = 0x20F40
addq 0x2bec7(%rip), %rdi # 0x56fe8
leaq 0x2525d(%rip), %rsi # 0x50385
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x15590
testl %eax, %eax
je 0x2b14d
leaq 0x25258(%rip), %rsi # 0x50394
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1c893
jmp 0x2b229
leaq 0x25226(%rip), %rdi # 0x5037a
callq 0x15430
xorl %esi, %esi
testq %rax, %rax
je 0x2b209
movq %rax, %rbx
movl $0x20f40, %r14d # imm = 0x20F40
addq 0x2be74(%rip), %r14 # 0x56fe8
pushq $0x1
popq %r15
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
movq %r14, (%rsp)
movq %rbx, %rdi
callq 0x15480
testq %rax, %rax
je 0x2b1fe
movq %rax, %rbp
addq $0x13, %rbp
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x15290
testl %eax, %eax
jne 0x2b184
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %r14
movl %r13d, %ebx
movq %r12, %r13
movq %r15, %r12
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0x251e3(%rip), %rdx # 0x503b3
leaq 0x251a3(%rip), %rcx # 0x5037a
movq %rbp, %r8
xorl %eax, %eax
callq 0x15100
movq %r15, %rdi
movq %r12, %r15
movq %r13, %r12
movl %ebx, %r13d
movq %r14, %rbx
movq (%rsp), %r14
callq 0x2b23d
addl %eax, %r13d
jmp 0x2b184
movq %rbx, %rdi
callq 0x158a0
movslq %r13d, %rsi
movl $0x408, %edi # imm = 0x408
addq 0x2bdd3(%rip), %rdi # 0x56fe8
leaq 0x48d(%rip), %rcx # 0x2b6a9
movl $0x1fa0, %edx # imm = 0x1FA0
callq 0x15660
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x1018, %rsp # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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.linjs.watch > 0)
inotify_rm_watch(_glfw.linjs.inotify, _glfw.linjs.watch);
close(_glfw.linjs.inotify);
}
}
|
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), %rdi
callq 0x157a0
movl 0x20f38(%rbx), %edi
testl %edi, %edi
jle 0x2b720
movl 0x20f3c(%rbx), %esi
testl %esi, %esi
jle 0x2b714
callq 0x15710
movl 0x20f38(%rbx), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15110
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 = (struct inotify_event*) (buffer + offset);
offset += sizeof(struct inotify_event) + e->len;
if (regexec(&_glfw.linjs.regex, e->name, 1, &match, 0) != 0)
continue;
char path[PATH_MAX];
snprintf(path, sizeof(path), "/dev/input/%s", e->name);
if (e->mask & (IN_CREATE | IN_ATTRIB))
openJoystickDevice(path);
else if (e->mask & IN_DELETE)
{
for (int jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
{
closeJoystick(_glfw.joysticks + jid);
break;
}
}
}
}
}
|
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, %r14d # imm = 0x20F40
addq 0x2b854(%rip), %r14 # 0x56fe8
leaq 0x20(%rsp), %rbx
movl $0x484, %eax # imm = 0x484
addq 0x2b843(%rip), %rax # 0x56fe8
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
cmpq %r15, 0x10(%rsp)
jle 0x2b879
leaq (%rsp,%r15), %r13
addq $0x1030, %r13 # imm = 0x1030
movl -0x4(%r13), %r12d
movq %r14, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
leaq 0x18(%rsp), %rcx
xorl %r8d, %r8d
callq 0x15290
testl %eax, %eax
jne 0x2b86d
leaq (%rsp,%r15), %rbp
addq $0x1020, %rbp # imm = 0x1020
movl $0x1000, %esi # imm = 0x1000
movq %rbx, %rdi
leaq 0x24bba(%rip), %rdx # 0x503b9
movq %r13, %rcx
xorl %eax, %eax
callq 0x15100
movl 0x4(%rbp), %eax
testw $0x104, %ax # imm = 0x104
je 0x2b81c
movq %rbx, %rdi
callq 0x2b23d
jmp 0x2b868
btl $0x9, %eax
jae 0x2b868
movq 0x8(%rsp), %rdi
xorl %r13d, %r13d
addq $-0x1fa0, %r13 # imm = 0xE060
cmpq $-0x219a0, %r13 # imm = 0xFFFDE660
je 0x2b868
leaq 0x1fa0(%rdi), %rbp
leaq 0x20(%rsp), %rsi
callq 0x156c0
movq %rbp, %rdi
testl %eax, %eax
jne 0x2b82a
leaq 0x2e1d7(%rip), %rdi # 0x59a30
subq %r13, %rdi
addq $-0x1b98, %rdi # imm = 0xE468
callq 0x2b728
leaq 0x20(%rsp), %rbx
addq %r12, %r15
addq $0x10, %r15
jmp 0x2b7ad
addq $0x5028, %rsp # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 (errno == ENODEV)
closeJoystick(js);
break;
}
if (e.type == EV_SYN)
{
if (e.code == SYN_DROPPED)
_glfw.linjs.dropped = GLFW_TRUE;
else if (e.code == SYN_REPORT)
{
_glfw.linjs.dropped = GLFW_FALSE;
pollAbsState(js);
}
}
if (_glfw.linjs.dropped)
continue;
if (e.type == EV_KEY)
handleKeyEvent(js, e.code, e.value);
else if (e.type == EV_ABS)
handleAbsEvent(js, e.code, e.value);
}
return js->present;
}
|
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
movzwl 0x10(%rsp), %ebp
testl %ebp, %ebp
je 0x2b90a
cmpl $0x0, 0x20f80(%r13)
jne 0x2b8b2
cmpl $0x3, %ebp
je 0x2b937
cmpl $0x1, %ebp
jne 0x2b8b2
movzwl 0x12(%rsp), %eax
movl 0xc7c(%rbx,%rax,4), %esi
xorl %edx, %edx
cmpl $0x0, 0x14(%rsp)
setne %dl
movq %rbx, %rdi
callq 0x1d083
jmp 0x2b8b2
movzwl 0x12(%rsp), %eax
testl %eax, %eax
je 0x2b925
cmpl $0x3, %eax
jne 0x2b8d6
movl $0x1, 0x20f80(%r13)
jmp 0x2b8b2
andl $0x0, 0x20f80(%r13)
movq %rbx, %rdi
callq 0x2b96c
jmp 0x2b8d6
movzwl 0x12(%rsp), %esi
movl 0x14(%rsp), %edx
movq %rbx, %rdi
callq 0x2b9e1
jmp 0x2b8b2
cmpl $0x13, (%r14)
jne 0x2b95b
movq %rbx, %rdi
callq 0x2b728
movl (%rbx), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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;
handleAbsEvent(js, code, info->value);
}
}
|
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,%r12)
js 0x2b9c5
leaq (%rbx,%r13), %r15
movl 0x78(%rbx), %edi
leaq (%r14,%rbp), %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x15120
testl %eax, %eax
js 0x2b9c5
movl (%r15), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2b9e1
incq %r14
addq $0x4, %r12
addq $0x18, %r13
jmp 0x2b98e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, GLFW_HAT_LEFT_UP, GLFW_HAT_LEFT_DOWN },
{ GLFW_HAT_RIGHT, GLFW_HAT_RIGHT_UP, GLFW_HAT_RIGHT_DOWN },
};
const int hat = (code - ABS_HAT0X) / 2;
const int axis = (code - ABS_HAT0X) % 2;
int* state = js->linjs.hats[hat];
// NOTE: Looking at several input drivers, it seems all hat events use
// -1 for left / up, 0 for centered and 1 for right / down
if (value == 0)
state[axis] = 0;
else if (value < 0)
state[axis] = 1;
else if (value > 0)
state[axis] = 2;
_glfwInputJoystickHat(js, index, stateMap[state[0]][state[1]]);
}
else
{
const struct input_absinfo* info = &js->linjs.absInfo[code];
float normalized = value;
const int range = info->maximum - info->minimum;
if (range)
{
// Normalize to 0.0 -> 1.0
normalized = (normalized - info->minimum) / range;
// Normalize to -1.0 -> 1.0
normalized = normalized * 2.0f - 1.0f;
}
_glfwInputJoystickAxis(js, index, normalized);
}
}
|
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,%rax,4)
jmp 0x2ba6a
cvtsi2ss %edx, %xmm0
imulq $0x18, %rcx, %rax
movl 0x1980(%rdi,%rax), %ecx
movl 0x1984(%rdi,%rax), %eax
subl %ecx, %eax
je 0x1d076
cvtsi2ss %ecx, %xmm1
subss %xmm1, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
addss %xmm0, %xmm0
addss 0x1f608(%rip), %xmm0 # 0x4b060
jmp 0x1d076
andl $0x0, (%rcx,%rax,4)
jmp 0x2ba6a
movl $0x1, (%rcx,%rax,4)
movslq (%rcx), %rax
movslq 0x4(%rcx), %rcx
leaq (%rax,%rax,2), %rax
leaq 0x249e7(%rip), %rdx # 0x50463
addq %rax, %rdx
movsbl (%rcx,%rdx), %edx
jmp 0x1d08e
|
/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_string<char, std::char_traits<char>, std::allocator<char>>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::table_arrays, boost::unordered::detail::foa::plain_size_control, slang::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::nosize_unchecked_emplace_at<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(boost::unordered::detail::foa::table_arrays<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
|
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;
auto mask = pg->match_available();
if (BOOST_LIKELY(mask != 0)) {
auto n = unchecked_countr_zero(mask);
auto p = arrays_.elements() + pos * N + n;
construct_element(p, std::forward<Args>(args)...);
pg->set(n, hash);
BOOST_UNORDERED_ADD_STATS(cstats.insertion, (pb.length()));
return {pg, n, p};
}
else
pg->mark_overflow(hash);
}
}
|
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 # imm = 0x1E0
addq 0x18(%rdx), %rsi
movl %edi, %r10d
shll $0x5, %r10d
leaq (%rsi,%r10), %rdx
addq %rsi, %r10
addq $0x10, %r10
movq %r10, -0x10(%r10)
movq (%r9), %r11
leaq 0x10(%r9), %rsi
cmpq %rsi, %r11
je 0x95633
movq %r11, (%rdx)
movq (%rsi), %r10
movq %r10, 0x10(%rdx)
jmp 0x9563c
movdqu (%rsi), %xmm0
movdqu %xmm0, (%r10)
movq 0x8(%r9), %r10
movq %r10, 0x8(%rdx)
movq %rsi, (%r9)
movq $0x0, 0x8(%r9)
movb $0x0, 0x10(%r9)
movzbl %r8b, %esi
leaq 0x2db0c1(%rip), %r8 # 0x370720
movb (%r8,%rsi,4), %sil
movb %sil, (%rcx,%rdi)
movq %rcx, (%rax)
movl %edi, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
movl %r8d, %ecx
andb $0x7, %cl
movb $0x1, %r10b
shlb %cl, %r10b
movq 0x8(%rdx), %r11
movl $0x1, %ebx
movq %rsi, %rcx
shlq $0x4, %rcx
orb %r10b, 0xf(%rdi,%rcx)
addq %rbx, %rsi
andq %r11, %rsi
movq %rsi, %r14
shlq $0x4, %r14
leaq (%rdi,%r14), %rcx
movdqa (%rdi,%r14), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
incq %rbx
testl %ebp, %ebp
jne 0x955f7
jmp 0x9568b
nop
|
/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]();
}
// now set upper half to ones (for unknown)
for (uint32_t i = words; i < words * 2; i++)
pVal[i] = UINT64_MAX;
clearUnusedBits();
}
|
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, %rdi
je 0xac690
callq 0xe17c5
movb $0x1, 0xd(%rbx)
movl %r12d, %r14d
shll $0x4, %r14d
movq %r14, %rdi
callq 0xe17d9
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x37300
movq %r15, (%rbx)
cmpl $0x40, %ebp
jb 0xac6d2
leal (%r12,%r12), %eax
movq (%rbx), %rcx
movq $-0x1, (%rcx,%r12,8)
incq %r12
cmpq %rax, %r12
jb 0xac6bf
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xabbd4
|
/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 is a variable declaration, they must all be.
// We'll only enter this function if we have variable decls.
auto& comp = scope.getCompilation();
const VariableSymbol* lastVar = nullptr;
for (auto init : syntax.initializers) {
if (init->previewNode)
result->addMembers(*init->previewNode);
auto& var = VariableSymbol::fromSyntax(comp, init->as<ForVariableDeclarationSyntax>(),
lastVar);
lastVar = &var;
result->addMember(var);
}
result->blocks = Statement::createAndAddBlockItems(*result, *syntax.statement,
/* labelHandled */ false);
return *result;
}
|
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
movq %rax, %r12
movq %rdx, %r14
movq %r13, %rdi
callq 0xc6cd6
jmp 0xe1c7d
leaq 0x296172(%rip), %r14 # 0x377dec
xorl %r12d, %r12d
movq $0x0, (%rsp)
movq %r15, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0xe1b6b
movq %rax, %r14
movq 0xa8(%rbx), %rbx
incq %rbx
cmpq $0x2, %rbx
jb 0xe1d24
movq (%r15), %rax
movq %rax, 0x18(%rsp)
shrq %rbx
leaq 0x40(%r14), %r12
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rdi
addq %r15, %rdi
callq 0xa1cb9
movq (%rax), %rbp
movq 0x10(%rbp), %rsi
testq %rsi, %rsi
je 0xe1cf1
movq %r12, %rdi
callq 0x1ececa
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x14d8b4
movq %rax, %r13
movq 0x60(%r14), %rdx
movq %r12, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x1ee400
addq $0x30, %r15
decq %rbx
jne 0xe1cc9
movq %r14, %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rax
movq 0x120(%rax), %rsi
xorl %edx, %edx
callq 0x200348
movq %rax, 0x80(%r14)
movq %rdx, 0x88(%r14)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
// constraint, for later use during lookup.
uint32_t index = 1;
if (auto last = scope.getLastMember())
index = (uint32_t)last->getIndex() + 1;
comp.addOutOfBlockDecl(scope, syntax.name->as<ScopedNameSyntax>(), syntax,
SymbolIndex(index));
return nullptr;
}
if (scope.asSymbol().kind != SymbolKind::ClassType)
scope.addDiag(diag::ConstraintNotInClass, syntax.sourceRange());
auto nameToken = syntax.name->getLastToken();
auto result = comp.emplace<ConstraintBlockSymbol>(comp, nameToken.valueText(),
nameToken.location());
result->setSyntax(syntax);
result->setAttributes(scope, syntax.attributes);
// Static is the only allowed qualifier.
for (auto qual : syntax.qualifiers) {
if (qual.kind == TokenKind::StaticKeyword)
result->flags |= ConstraintBlockFlags::Static;
else if (qual.kind == TokenKind::PureKeyword || qual.kind == TokenKind::ExternKeyword) {
// This is an error, pure and extern declarations can't declare bodies.
scope.addDiag(diag::UnexpectedConstraintBlock, syntax.block->sourceRange())
<< qual.range();
break;
}
}
addSpecifierFlags(syntax.specifiers, result->flags);
if (!result->flags.has(ConstraintBlockFlags::Static) &&
scope.asSymbol().kind == SymbolKind::ClassType) {
result->addThisVar(scope.asSymbol().as<ClassType>());
}
return result;
}
|
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 $0x16, (%rax)
je 0xe96f3
movq %r14, %rdi
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0x200006, %esi # imm = 0x200006
movq %rax, %rdx
callq 0x1ecb9a
movq 0xd0(%r14), %rdx
movq %rdx, %rdi
callq 0xc9284
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movq %rdx, 0x8(%r12)
movq %r12, %rdi
callq 0xc6c10
movq %rsp, %r13
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %r12, %rdi
callq 0xc6cd6
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xea30a
movq %rax, %r15
movq %r14, 0x38(%rax)
movq 0x40(%r14), %rdx
movq 0x48(%r14), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x201620
movq 0x80(%r14), %rax
testq %rax, %rax
je 0xe97f8
movq 0x78(%r14), %rcx
shlq $0x4, %rax
xorl %edx, %edx
movups (%rcx,%rdx), %xmm0
movaps %xmm0, (%rsp)
movzwl (%rsp), %esi
cmpl $0x11c, %esi # imm = 0x11C
je 0xe9794
cmpl $0xa7, %esi
je 0xe97c3
cmpl $0xf8, %esi
jne 0xe979c
jmp 0xe97c3
orb $0x4, 0x80(%r15)
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0xe976e
jmp 0xe97f8
movl $0x1, %r8d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x19a18c
xorl %r15d, %r15d
jmp 0xe986b
movq 0xd8(%r14), %rdi
callq 0xc9084
movq %rdx, %rcx
movq %rbx, %rdi
movl $0xa40007, %esi # imm = 0xA40007
movq %rax, %rdx
callq 0x1ecb9a
movq %rax, %r12
movq %rsp, %rdi
callq 0xc6caa
movq %r12, %rdi
movq %rax, %rsi
callq 0x83dea
movq 0xc8(%r14), %rcx
movb 0x80(%r15), %al
testq %rcx, %rcx
je 0xe9856
movq 0xc0(%r14), %rdx
shlq $0x3, %rcx
xorl %esi, %esi
movq (%rdx,%rsi), %rdi
testb $0x1, 0x2a(%rdi)
jne 0xe984d
movzwl 0x28(%rdi), %edi
cmpl $0xc0, %edi
je 0xe983b
cmpl $0xa8, %edi
jne 0xe9840
movb $-0x80, %dil
jmp 0xe9843
movb $0x20, %dil
jmp 0xe9843
movb $0x40, %dil
orb %dil, %al
movb %al, 0x80(%r15)
addq $0x8, %rsi
cmpq %rsi, %rcx
jne 0xe9818
testb $0x4, %al
jne 0xe986b
movq 0x8(%rbx), %rsi
cmpl $0x16, (%rsi)
jne 0xe986b
movq %r15, %rdi
callq 0xe987c
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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::ConstraintPrototype) {
// The out-of-block definition must be in our parent scope.
auto& parentSym = scope->asSymbol();
auto& outerScope = *parentSym.getParentScope();
auto& comp = outerScope.getCompilation();
auto [declSyntax, index, used] = comp.findOutOfBlockDecl(outerScope, parentSym.name, name);
if (!declSyntax || declSyntax->kind != SyntaxKind::ConstraintDeclaration || name.empty()) {
if (!flags.has(ConstraintBlockFlags::Pure) && !name.empty()) {
DiagCode code = flags.has(ConstraintBlockFlags::ExplicitExtern)
? diag::NoMemberImplFound
: diag::NoConstraintBody;
outerScope.addDiag(code, location) << name;
}
constraint = scope->getCompilation().emplace<InvalidConstraint>(nullptr);
return *constraint;
}
auto& cds = declSyntax->as<ConstraintDeclarationSyntax>();
*used = true;
if (flags.has(ConstraintBlockFlags::Pure)) {
auto& diag = outerScope.addDiag(diag::BodyForPureConstraint, cds.name->sourceRange());
diag.addNote(diag::NoteDeclarationHere, location);
constraint = scope->getCompilation().emplace<InvalidConstraint>(nullptr);
return *constraint;
}
// The method definition must be located after the class definition.
outOfBlockIndex = index;
if (index <= parentSym.getIndex()) {
auto& diag = outerScope.addDiag(diag::MemberDefinitionBeforeClass,
cds.name->getLastToken().location());
diag << name << parentSym.name;
diag.addNote(diag::NoteDeclarationHere, parentSym.location);
}
bool declStatic = false;
for (auto qual : cds.qualifiers) {
if (qual.kind == TokenKind::StaticKeyword) {
declStatic = true;
break;
}
}
if (declStatic != flags.has(ConstraintBlockFlags::Static)) {
auto& diag = outerScope.addDiag(diag::MismatchStaticConstraint,
cds.getFirstToken().location());
diag.addNote(diag::NoteDeclarationHere, location);
}
bitmask<ConstraintBlockFlags> declFlags;
addSpecifierFlags(cds.specifiers, declFlags);
if (declFlags != (flags & (ConstraintBlockFlags::Initial | ConstraintBlockFlags::Extends |
ConstraintBlockFlags::Final))) {
auto& diag = outerScope.addDiag(diag::MismatchConstraintSpecifiers,
cds.name->getLastToken().location());
diag.addNote(diag::NoteDeclarationHere, location);
}
constraint = &Constraint::bind(*cds.block, context);
return *constraint;
}
constraint = &Constraint::bind(*syntax->as<ConstraintDeclarationSyntax>().block, context);
return *constraint;
}
|
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 %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x58(%rsp)
movq $0x0, 0x68(%rsp)
cmpl $0x66, (%rax)
jne 0xe9b64
movq 0x8(%r12), %r13
movq 0x20(%r13), %r14
movq (%r14), %rsi
movq 0x8(%r13), %rcx
movq 0x10(%r13), %r8
movups 0x8(%rbx), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x19a56a
movq 0x10(%r15), %r15
movq 0x8(%rbx), %rax
testq %r15, %r15
je 0xe9b18
cmpl $0x65, (%r15)
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0xe9b7a
movb 0x80(%rbx), %cl
movl %ecx, %edx
andb $0x2, %dl
shrb %dl
testq %rax, %rax
sete %al
orb %dl, %al
jne 0xe9cfc
testb $0x10, %cl
movl $0xf50006, %eax # imm = 0xF50006
movl $0x8b0006, %esi # imm = 0x8B0006
cmovel %eax, %esi
movq 0x18(%rbx), %rdx
movq %r14, %rdi
callq 0x1ecb1e
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x83e5c
jmp 0xe9cfc
movq 0xd8(%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1c20e8
jmp 0xe9d11
movq 0x20(%rsp), %rax
movb $0x1, (%rax)
testb $0x2, 0x80(%rbx)
jne 0xe9ccc
movl 0x28(%rsp), %eax
movl %eax, 0x90(%rbx)
cmpl 0x30(%r13), %eax
ja 0xe9c00
movq 0xd0(%r15), %rdi
callq 0xc9284
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0xc6cd6
movq %r14, %rdi
movl $0x6e0006, %esi # imm = 0x6E0006
movq %rax, %rdx
callq 0x1ecb1e
movq %rax, %r12
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
movq %rax, %rdi
callq 0x83e5c
movq 0x18(%r13), %rdx
movq %r12, %rdi
movl $0x50001, %esi # imm = 0x50001
callq 0x83d66
movq 0x80(%r15), %rax
testq %rax, %rax
je 0xe9c2b
movq 0x78(%r15), %rcx
shlq $0x4, %rax
xorl %edx, %edx
cmpw $0x11c, (%rcx,%rdx) # imm = 0x11C
je 0xe9d7f
addq $0x10, %rdx
cmpq %rdx, %rax
jne 0xe9c16
testb $0x4, 0x80(%rbx)
je 0xe9c6e
movq %r15, %rdi
callq 0xc91c4
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0xc6cd6
movq %r14, %rdi
movl $0x790006, %esi # imm = 0x790006
movq %rax, %rdx
callq 0x1ecb1e
movq 0x18(%rbx), %rdx
movq %rax, %rdi
movl $0x50001, %esi # imm = 0x50001
callq 0x83d66
movq 0xc8(%r15), %rax
testq %rax, %rax
je 0xe9d26
movq 0xc0(%r15), %rcx
shlq $0x3, %rax
xorl %edx, %edx
xorl %edi, %edi
xorl %esi, %esi
movq (%rcx,%rdx), %r8
testb $0x1, 0x2a(%r8)
jne 0xe9cc1
movzwl 0x28(%r8), %edi
cmpl $0xc0, %edi
je 0xe9cb4
cmpl $0xa8, %edi
jne 0xe9cb9
movb $-0x80, %dil
jmp 0xe9cbc
movb $0x20, %dil
jmp 0xe9cbc
movb $0x40, %dil
orb %sil, %dil
movl %edi, %esi
addq $0x8, %rdx
cmpq %rdx, %rax
jne 0xe9c8f
jmp 0xe9d28
movq 0xd0(%r15), %rdi
callq 0xc9084
movq %rdx, %rcx
movq %r14, %rdi
movl $0xd0006, %esi # imm = 0xD0006
movq %rax, %rdx
callq 0x1ecb9a
movq 0x18(%rbx), %rdx
movq %rax, %rdi
movl $0x50001, %esi # imm = 0x50001
callq 0x83d66
movq (%r12), %rdi
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
callq 0xea3b2
movq %rax, 0x88(%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %edi, %edi
movb 0x80(%rbx), %al
andb $-0x20, %al
cmpb %al, %dil
je 0xe9d73
movq 0xd0(%r15), %rdi
callq 0xc9284
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0xc6cd6
movq %r14, %rdi
movl $0x780006, %esi # imm = 0x780006
movq %rax, %rdx
callq 0x1ecb1e
movq 0x18(%rbx), %rdx
movq %rax, %rdi
movl $0x50001, %esi # imm = 0x50001
callq 0x83d66
movq 0xd8(%r15), %rdi
jmp 0xe9b6b
testb $0x4, 0x80(%rbx)
je 0xe9c34
jmp 0xe9c6e
nop
|
/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::VariableLifetime&, slang::ast::Visibility&)
|
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
movq %rax, %r15
jmp 0xe9f25
movq %rcx, 0x8(%rax)
movq (%r13), %rdx
movq 0x8(%r13), %rcx
movq (%r12), %r8
movl (%r14), %r9d
movl (%rbx), %ebx
movq %r15, %rdi
movl $0x3f, %esi
callq 0x14d99c
movl %ebx, 0x158(%r15)
movl $0x0, 0x15c(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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
jmp 0xea07a
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0x37260
movq (%r15), %rcx
movl (%r14), %r8d
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x14d95e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0xea178
movq %rdi, 0x8(%rdx)
testq %rcx, %rcx
jle 0xea177
movq (%rbx), %rdx
leaq 0x1(%rcx), %rsi
xorl %edi, %edi
movq (%rdx,%rdi), %r8
movq %r8, (%rax,%rdi)
decq %rsi
addq $0x8, %rdi
cmpq $0x1, %rsi
ja 0xea162
popq %rbx
movq %rcx, %rdx
retq
|
/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
jmp 0xea436
movq %rcx, 0x8(%rax)
movq %rbx, %rdi
callq 0x37260
movq (%r15), %rcx
movl (%r14), %r8d
movq %r12, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x14d95e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::table_arrays, boost::unordered::detail::foa::plain_size_control, slang::hash<slang::ast::Symbol const*, void>, std::equal_to<slang::ast::Symbol const*>, slang::detail::hashing::StackAllocator<slang::ast::Symbol const*, 32ul, 16ul>>::unchecked_emplace_with_rehash<slang::ast::Symbol const*>(unsigned long, slang::ast::Symbol const*&&)
|
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_, position_for(hash, new_arrays_), hash,
std::forward<Args>(args)...);
}
|
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 %rdx, %rax
shrq $0x5, %rax
addq %rcx, %rax
incq %rax
testq %rax, %rax
js 0xea4b5
cvtsi2ss %rax, %xmm0
jmp 0xea4ca
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x28610e(%rip), %xmm0 # 0x3705e0
callq 0x37330
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x2860f9(%rip), %xmm0 # 0x3705e4
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0xea7a6
xorl %eax, %eax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movq %rax, 0x10(%r14)
movb (%rbp), %cl
movq %r12, %rax
shrq %cl, %rax
movq %rsp, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %rax, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0xea5c4
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movups (%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xea684
incq 0x30(%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x37240
movq (%rbx), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
je 0xea5a7
movq 0x20(%rsp), %rax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rdx
addq $0x96, %rdx
shrq $0x3, %rdx
movq %rsp, %rdi
callq 0xea904
callq 0x378a0
movq %rax, %rbx
callq 0x379f0
movq %rbx, %rdi
callq 0x37b10
movq %rax, %rdi
callq 0x692cb
|
/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<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
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), %rsi
cmpq %r15, %rsi
cmovaq %rsi, %r15
cmpq %rdx, %rcx
cmovaq %rax, %r15
movq %r12, %r14
subq (%rdi), %r14
leaq (,%r15,8), %rdi
callq 0xe17d4
leaq (%rax,%r14), %rcx
movq %rcx, 0x10(%rsp)
movq (%r13), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, (%rax,%r14)
movq (%rbx), %r13
movq 0x8(%rbx), %r14
leaq (,%r14,8), %rbp
addq %r13, %rbp
subq %r12, %rbp
je 0xeb5a9
cmpq %r12, %r13
je 0xeb593
movq %r12, %rdx
subq %r13, %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x374b0
jmp 0xeb5c3
testq %r14, %r14
je 0xeb5c3
leaq (,%r14,8), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
leaq 0x18(%rbx), %rax
cmpq %rax, %r13
je 0xeb5d8
movq %r13, %rdi
callq 0xe17c0
movq 0x8(%rbx), %r14
incq %r14
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
|
/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<CoverageBinSymbol>().empty()) {
if (scope->getCompilation().languageVersion() >= LanguageVersion::v1800_2023)
scope->addDiag(diag::RealCoverpointBins, location);
}
}
}
|
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
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movl $0xb70006, %esi # imm = 0xB70006
callq 0x1ecb1e
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x83e5c
leaq 0x40(%rbx), %rdi
callq 0xf05dc
cmpq %rdx, %rax
je 0xeef85
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rax
cmpl $0x0, 0x48(%rax)
jle 0xeef7d
movq 0x18(%rbx), %rdx
movq %r14, %rdi
movl $0xb50006, %esi # imm = 0xB50006
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ecb1e
|
/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_t = comp.getIntType();
auto& string_t = comp.getStringType();
auto lv = comp.languageVersion();
StructBuilder option(*this, LookupLocation::min);
option.addField("weight"sv, int_t);
option.addField("goal"sv, int_t);
option.addField("comment"sv, string_t);
option.addField("at_least"sv, int_t);
option.addField("cross_num_print_missing"sv, int_t);
if (lv >= LanguageVersion::v1800_2023)
option.addField("cross_retain_auto_bins"sv, bit_t, VariableFlags::ImmutableCoverageOption);
addProperty(*this, "option"sv, VariableLifetime::Automatic, option);
StructBuilder type_option(*this, LookupLocation::min);
type_option.addField("weight"sv, int_t);
type_option.addField("goal"sv, int_t);
type_option.addField("comment"sv, string_t);
addProperty(*this, "type_option"sv, VariableLifetime::Static, type_option);
addBuiltInMethods(*this, false);
}
|
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, %rdi
movq %r14, %rdx
callq 0x1ec9b0
movaps 0x80(%rsp), %xmm0
movups %xmm0, 0x78(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0xa0(%r14)
movq 0x148(%r13), %rax
movq %rax, (%rsp)
movq 0x158(%r13), %r15
movq 0x180(%r13), %r14
movl 0x48(%r13), %r12d
leaq 0x2903e7(%rip), %rbp # 0x37f4e0
movq (%rbp), %rdx
movl 0x8(%rbp), %ecx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x149dd8
leaq 0x289251(%rip), %rdx # 0x378368
movl $0x6, %esi
movq %r13, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x28923e(%rip), %rdx # 0x37836f
movl $0x4, %esi
movq %r13, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x284c51(%rip), %rdx # 0x373d9c
movl $0x7, %esi
movq %r13, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x28920f(%rip), %rdx # 0x378374
movl $0x8, %esi
movq %r13, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x28920b(%rip), %rdx # 0x37838a
movl $0x17, %esi
movq %r13, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
testl %r12d, %r12d
jle 0xef1b7
leaq 0x289204(%rip), %rdx # 0x3783a2
leaq 0x8(%rsp), %rdi
movl $0x16, %esi
movq (%rsp), %rcx
movl $0x4, %r8d
callq 0x149e2c
leaq 0x2b288a(%rip), %rdx # 0x3a1a48
leaq 0x8(%rsp), %r8
movl $0x6, %esi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xec333
movq (%rbp), %rdx
movl 0x8(%rbp), %ecx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x149dd8
leaq 0x289178(%rip), %rdx # 0x378368
movl $0x6, %esi
movq %r12, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x289165(%rip), %rdx # 0x37836f
movl $0x4, %esi
movq %r12, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x284b78(%rip), %rdx # 0x373d9c
movl $0x7, %esi
movq %r12, %rdi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x149e2c
leaq 0x28911e(%rip), %rdx # 0x37835c
movl $0xb, %esi
movq %rbx, %rdi
movl $0x1, %ecx
movq %r12, %r8
callq 0xec333
movq %rbx, %rdi
xorl %esi, %esi
callq 0xec39a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq (%rbx), %rax
popq %rbx
retq
nop
|
/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
je 0xf049a
movq (%rbx), %rcx
shlq $0x4, %rdi
leaq (%rcx,%rdi), %rsi
movq %rax, %rdx
addq %rdi, %rdx
jmp 0xf046f
xorl %eax, %eax
xorl %edx, %edx
retq
movq %rdx, 0x8(%rdi)
movq (%rbx), %rcx
addq %rcx, %rsi
addq $0x10, %rcx
leaq 0x10(%rax), %rdi
movups -0x10(%rcx), %xmm0
movups %xmm0, -0x10(%rdi)
cmpq %rsi, %rcx
je 0xf0494
addq $0x10, %rcx
leaq 0x10(%rdi), %r8
cmpq %rdx, %rdi
movq %r8, %rdi
jne 0xf0477
movq 0x8(%rbx), %rdx
popq %rbx
retq
xorl %edx, %edx
jmp 0xf0498
|
/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
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0xf0706
movq %rdi, 0x8(%rdx)
testq %rcx, %rcx
jle 0xf0705
movq (%rbx), %rdx
leaq 0x1(%rcx), %rsi
xorl %edi, %edi
movq (%rdx,%rdi), %r8
movq %r8, (%rax,%rdi)
decq %rsi
addq $0x8, %rdi
cmpq $0x1, %rsi
ja 0xf06f0
popq %rbx
movq %rcx, %rdx
retq
|
/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_types<std::basic_string_view<char, std::char_traits<char>>, slang::syntax::SyntaxNode const*>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::table_arrays, boost::unordered::detail::foa::plain_size_control, slang::hash<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::syntax::SyntaxNode const*>, 96ul, 16ul>>::nosize_unchecked_emplace_at<std::pair<std::basic_string_view<char, std::char_traits<char>>&&, slang::syntax::SyntaxNode const*&&>>(boost::unordered::detail::foa::table_arrays<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::syntax::SyntaxNode const*>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::pair<std::basic_string_view<char, std::char_traits<char>> const, slang::syntax::SyntaxNode const*>, 96ul, 16ul>> const&, unsigned long, unsigned long, std::pair<std::basic_string_view<char, std::char_traits<char>>&&, slang::syntax::SyntaxNode const*&&>&&)
|
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;
auto mask = pg->match_available();
if (BOOST_LIKELY(mask != 0)) {
auto n = unchecked_countr_zero(mask);
auto p = arrays_.elements() + pos * N + n;
construct_element(p, std::forward<Args>(args)...);
pg->set(n, hash);
BOOST_UNORDERED_ADD_STATS(cstats.insertion, (pb.length()));
return {pg, n, p};
}
else
pg->mark_overflow(hash);
}
}
|
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 # imm = 0x168
addq 0x18(%rdx), %rsi
leaq (%rdi,%rdi,2), %rdx
leaq (%rsi,%rdx,8), %rdx
movq (%r9), %rsi
movups (%rsi), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%r9), %rsi
movq (%rsi), %rsi
movq %rsi, 0x10(%rdx)
movzbl %r8b, %esi
leaq 0x27f2f6(%rip), %r8 # 0x370720
movb (%r8,%rsi,4), %sil
movb %sil, (%rcx,%rdi)
movq %rcx, (%rax)
movl %edi, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
movl %r8d, %ecx
andb $0x7, %cl
movb $0x1, %r10b
shlb %cl, %r10b
movq 0x8(%rdx), %r11
movl $0x1, %ebx
movq %rsi, %rcx
shlq $0x4, %rcx
orb %r10b, 0xf(%rdi,%rcx)
addq %rbx, %rsi
andq %r11, %rsi
movq %rsi, %r14
shlq $0x4, %r14
leaq (%rdi,%r14), %rcx
movdqa (%rdi,%r14), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebp
andl $0x7fff, %ebp # imm = 0x7FFF
incq %rbx
testl %ebp, %ebp
jne 0xf13f5
jmp 0xf1456
|
/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 ignored here.
if (expr->kind == SyntaxKind::OrderedParamAssignment) {
params.push_back(
&Expression::bind(*expr->as<OrderedParamAssignmentSyntax>().expr, context));
}
else if (expr->kind == SyntaxKind::NamedParamAssignment) {
if (auto ex = expr->as<NamedParamAssignmentSyntax>().expr)
params.push_back(&Expression::bind(*ex, context, ASTFlags::AllowDataType));
}
}
}
return params.copy(context.getCompilation());
}
|
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
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq 0x60(%r14), %rdi
addq %r13, %rdi
callq 0xa1cb9
movq (%rax), %rax
movl (%rax), %ecx
cmpl $0x13e, %ecx # imm = 0x13E
je 0xf4dc7
cmpl $0x154, %ecx # imm = 0x154
jne 0xf4dec
movq 0x18(%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1cdde8
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xf1698
jmp 0xf4dec
movq 0x48(%rax), %rdi
testq %rdi, %rdi
je 0xf4dec
movl $0x4, %edx
movq %rbx, %rsi
callq 0x1cdde8
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xf1698
addq $0x30, %r13
decq %rbp
jne 0xf4d87
movq (%rbx), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xf0296
movq %rax, %rbx
movq %rdx, %r14
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xf4e1f
callq 0xe17c0
movq %rbx, %rax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf4e3a
jmp 0xf4e3a
jmp 0xf4e3a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xf4e51
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
nop
|
/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(syntax, nullptr);
}
const HierarchyOverrideNode* overrideNode = nullptr;
if (parentOverrideNode) {
if (auto sit = parentOverrideNode->childNodes.find(overrideSyntax ? *overrideSyntax
: syntax);
sit != parentOverrideNode->childNodes.end()) {
overrideNode = &sit->second;
}
}
auto dims = syntax.decl->dimensions;
return recurse(syntax, overrideNode, dims.begin(), dims.end());
}
|
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 %rbx, %rdi
callq 0xc9084
movq %rdx, %rcx
movq %r15, %rdi
movl $0x4e0006, %esi # imm = 0x4E0006
movq %rax, %rdx
callq 0x160b40
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf981a
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x3c8af
movq (%r15), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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*, 18446744073709551615ul>>, __gnu_cxx::__normal_iterator<slang::syntax::VariableDimensionSyntax**, std::span<slang::syntax::VariableDimensionSyntax*, 18446744073709551615ul>>, std::span<slang::syntax::AttributeInstanceSyntax const* const, 18446744073709551615ul>, slang::SmallVectorBase<unsigned int>&)
|
Symbol* recursePrimArray(Compilation& comp, const PrimitiveSymbol& primitive,
const HierarchicalInstanceSyntax& instance, const ASTContext& context,
DimIterator it, DimIterator end,
std::span<const AttributeInstanceSyntax* const> attributes,
SmallVectorBase<uint32_t>& path) {
if (it == end)
return createPrimInst(comp, *context.scope, primitive, instance, attributes, path);
SLANG_ASSERT(instance.decl);
auto nameToken = instance.decl->name;
auto& dimSyntax = **it;
++it;
// Evaluate the dimensions of the array. If this fails for some reason,
// make up an empty array so that we don't get further errors when
// things try to reference this symbol.
auto dim = context.evalDimension(dimSyntax, /* requireRange */ true, /* isPacked */ false);
if (!dim.isRange())
return &InstanceArraySymbol::createEmpty(comp, nameToken.valueText(), nameToken.location());
ConstantRange range = dim.range;
if (range.width() > comp.getOptions().maxInstanceArray) {
auto& diag = context.addDiag(diag::MaxInstanceArrayExceeded, dimSyntax.sourceRange());
diag << "primitive"sv << comp.getOptions().maxInstanceArray;
return &InstanceArraySymbol::createEmpty(comp, nameToken.valueText(), nameToken.location());
}
SmallVector<const Symbol*> elements;
for (uint32_t i = 0; i < range.width(); i++) {
path.push_back(i);
auto symbol = recursePrimArray(comp, primitive, instance, context, it, end, attributes,
path);
path.pop_back();
symbol->name = "";
elements.push_back(symbol);
}
auto result = comp.emplace<InstanceArraySymbol>(comp, nameToken.valueText(),
nameToken.location(), elements.copy(comp),
range);
for (auto element : elements)
result->addMember(*element);
return result;
}
|
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(%rsp)
movq (%r8), %rdx
leaq 0xb8(%rsp), %rdi
movq %r14, %rsi
movq %rdx, 0x60(%rsp)
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x161282
leaq 0xb8(%rsp), %rax
movl (%rax), %eax
decl %eax
cmpl $0x2, %eax
jae 0xfa08a
movq %r12, 0x68(%rsp)
movq 0xbc(%rsp), %rcx
movl %ecx, %edx
movl %ecx, %eax
movq %rcx, %rsi
shrq $0x20, %rsi
subl %esi, %edx
negl %edx
subl %esi, %eax
cmovlel %edx, %eax
movq %rcx, 0x70(%rsp)
leal 0x1(%rax), %r12d
movq 0x20(%rsp), %rcx
cmpl 0x30(%rcx), %r12d
jbe 0xfa0f6
movq %rcx, %r13
movq 0x60(%rsp), %rdi
callq 0xc9084
movq %rdx, %rcx
movq %r14, %rdi
movl $0x6d0006, %esi # imm = 0x6D0006
movq %rax, %rdx
callq 0x160b40
leaq 0x2982e3(%rip), %rdx # 0x3922df
movl $0x9, %esi
movq %rax, %rdi
callq 0x83e5c
movl 0x30(%r13), %ecx
leaq 0x78(%rsp), %rbx
movq %rcx, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0xeafd0
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0xc6c10
movq %rax, %r15
movq %rdx, %r12
movq %r14, %rdi
callq 0xc6cd6
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x28(%rsp), %r9
movq $0x0, (%r9)
leaq 0x78(%rsp), %rdx
movq %r13, %rdi
movq %r13, %rsi
jmp 0xfa0d9
movq (%r14), %rsi
movq (%rax), %r8
movq 0x8(%rax), %r9
movq %r13, (%rsp)
movq %r12, %rdx
movq %r15, %rcx
callq 0xf9e96
jmp 0xfa0e4
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0xc6c10
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0xc6cd6
leaq 0x78(%rsp), %rdx
movq %r14, (%rdx)
movq %r15, 0x8(%rdx)
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x28(%rsp), %r9
movq $0x0, (%r9)
movq 0x20(%rsp), %rdi
movq %rdi, %rsi
callq 0xfaf86
movq %rax, %rbx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x90(%rsp), %rcx
movq %rcx, -0x18(%rcx)
movq $0x0, -0x10(%rcx)
movq $0x5, -0x8(%rcx)
movl $0x0, 0x40(%rsp)
cmpl $-0x1, %eax
je 0xfa199
addq $0x8, %rbx
movq %r13, %rdi
leaq 0x40(%rsp), %rsi
callq 0xfc842
leaq 0x110(%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %r13, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rbp, %r9
callq 0xf9f1c
movq %rax, 0x30(%rsp)
decq 0x8(%r13)
movq $0x0, 0x8(%rax)
leaq 0x27dc75(%rip), %rcx # 0x377dec
movq %rcx, 0x10(%rax)
leaq 0x78(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfc982
movl 0x40(%rsp), %eax
incl %eax
movl %eax, 0x40(%rsp)
cmpl %r12d, %eax
jb 0xfa123
leaq 0x50(%rsp), %rdi
callq 0xc6c10
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xc6cd6
movq %rax, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
movq 0x20(%rsp), %rbx
movq %rbx, %rsi
callq 0xfc7d0
leaq 0x40(%rsp), %r8
movq %rax, (%r8)
movq %rdx, 0x8(%r8)
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x70(%rsp), %r9
movq %rbx, %rdi
movq %rbx, %rsi
callq 0xfc712
movq %rax, %rbx
movq 0x78(%rsp), %r14
movq 0x80(%rsp), %r12
testq %r12, %r12
je 0xfa23d
movq %rbx, %r15
addq $0x40, %r15
shlq $0x3, %r12
xorl %r13d, %r13d
movq (%r14,%r13), %rsi
movq 0x60(%rbx), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x1ee400
addq $0x8, %r13
cmpq %r13, %r12
jne 0xfa217
movq 0x78(%rsp), %r14
leaq 0x90(%rsp), %rax
cmpq %rax, %r14
je 0xfa0e1
movq %r14, %rdi
callq 0xe17c0
jmp 0xfa0e1
jmp 0xfa265
jmp 0xfa265
jmp 0xfa265
jmp 0xfa265
jmp 0xfa265
movq %rax, %rbx
movq 0x78(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0xfa27f
callq 0xe17c0
movq %rbx, %rdi
callq 0x37b10
nop
|
/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_control, slang::hash<std::basic_string_view<char, std::char_traits<char>>, void>, std::equal_to<std::basic_string_view<char, std::char_traits<char>>>, slang::detail::hashing::StackAllocator<std::basic_string_view<char, std::char_traits<char>>, 128ul, 16ul>>::unchecked_rehash(boost::unordered::detail::foa::table_arrays<std::basic_string_view<char, std::char_traits<char>>, boost::unordered::detail::foa::group15<boost::unordered::detail::foa::plain_integral>, boost::unordered::detail::foa::pow2_size_policy, slang::detail::hashing::StackAllocator<std::basic_string_view<char, std::char_traits<char>>, 128ul, 16ul>>&)
|
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 %r15, %rsi
callq 0xfc044
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
leaq (%rax,%rax,4), %rax
leaq 0xe(%rax,%rax,2), %rax
cmoveq %rcx, %rax
testq %rax, %rax
js 0xfbe8d
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0xfbea7
movq %rax, %rcx
shrq %rcx
movl %eax, %edx
andl $0x1, %edx
orq %rcx, %rdx
xorps %xmm0, %xmm0
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
mulss 0x274731(%rip), %xmm0 # 0x3705e0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x274721(%rip), %xmm0 # 0x3705e4
cvttss2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
cmpq $0x1e, %rax
cmovbq %rax, %rsi
movq %rsi, 0x28(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x37240
cmpq $0x0, 0x8(%rsp)
je 0xfbf04
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfc144
movq (%rbx), %rdi
movq %r14, %rsi
callq 0xfc044
callq 0x378a0
movq %rax, %rbx
callq 0x379f0
movq %rbx, %rdi
callq 0x37b10
movq %rax, %rdi
callq 0x692cb
|
/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::syntax::HierarchicalInstanceSyntax> const&)
|
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(%rax)
movq 0x20(%rbx), %rcx
movq %rcx, 0x20(%rax)
leaq 0x3ca501(%rip), %rcx # 0x4c79b8
movq %rcx, (%rax)
movups 0x28(%rbx), %xmm0
movups %xmm0, 0x28(%rax)
popq %rbx
retq
|
/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<size_type>(pos - begin());
auto newData = (pointer)::operator new(newCap * sizeof(T));
// First construct the new element in the new memory,
// so that we don't corrupt the new element if it relied on
// existing elements we're about to move around.
auto newPos = newData + offset;
new (newPos) T(std::forward<Args>(args)...);
// Now move elements to the new memory.
if (pos == end()) {
std::uninitialized_move(begin(), end(), newData);
}
else {
std::uninitialized_move(begin(), pos, newData);
std::uninitialized_move(pos, end(), newPos + 1);
}
cleanup();
len++;
cap = newCap;
data_ = newData;
return newPos;
}
|
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), %rsi
cmpq %r15, %rsi
cmovaq %rsi, %r15
cmpq %rdx, %rcx
cmovaq %rax, %r15
movq %r12, %r14
subq (%rdi), %r14
leaq (,%r15,8), %rdi
callq 0xe17d4
leaq (%rax,%r14), %rcx
movq %rcx, 0x10(%rsp)
movq (%r13), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, (%rax,%r14)
movq (%rbx), %r13
movq 0x8(%rbx), %r14
leaq (,%r14,8), %rbp
addq %r13, %rbp
subq %r12, %rbp
je 0xfd88f
cmpq %r12, %r13
je 0xfd879
movq %r12, %rdx
subq %r13, %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x374b0
jmp 0xfd8a9
testq %r14, %r14
je 0xfd8a9
leaq (,%r14,8), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x379e0
leaq 0x18(%rbx), %rax
cmpq %rax, %r13
je 0xfd8be
movq %r13, %rdi
callq 0xe17c0
movq 0x8(%rbx), %r14
incq %r14
movq %r14, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdf8d1
|
/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 = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
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 = declaredType->getInitializer())
init->visit(DERIVED);
}
}
if constexpr (VisitStatements && requires { t.visitStmts(DERIVED); }) {
t.visitStmts(DERIVED);
}
if constexpr (std::is_base_of_v<GenericClassDefSymbol, T>) {
for (auto&& spec : t.specializations())
spec.visit(DERIVED);
}
if constexpr (std::is_base_of_v<Scope, T>) {
for (auto& member : t.members())
member.visit(DERIVED);
}
if constexpr (std::is_same_v<InstanceSymbol, T>) {
if constexpr (VisitCanonical) {
const auto& body = t.getCanonicalBody() ? *t.getCanonicalBody() : t.body;
body.visit(DERIVED);
}
else {
t.body.visit(DERIVED);
}
}
if constexpr (std::is_same_v<CheckerInstanceSymbol, T>) {
t.body.visit(DERIVED);
}
}
|
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 = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
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 0x279419(%rip), %rdx # 0x378980
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0xfeff0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpl $0x12, %eax
jle 0xff5c4
leal -0x14(%rax), %ecx
cmpl $0x2, %ecx
jb 0xff57c
cmpl $0x1f, %eax
je 0xff57c
cmpl $0x13, %eax
jne 0xff5e4
movq 0x20(%r14), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0xff5ab
cmpl $0x1, %eax
jne 0xff570
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x180006, %esi # imm = 0x180006
jmp 0xff657
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0xff570
cmpl $0x3, %eax
jne 0xff5e4
cmpl $0x0, 0x30(%r14)
je 0xff570
leaq 0x8(%rsp), %rdi
callq 0xff6b8
jmp 0xff57c
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0xff57c
movq 0x20(%r14), %rax
movl (%rax), %edx
cmpl $0x15, %edx
je 0xff570
cmpl $0xe, %edx
jne 0xff5d8
cmpl $0x5, %ecx
jne 0xff570
cmpb $0x0, 0x50(%rax)
jne 0xff570
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x100006, %esi # imm = 0x100006
callq 0x1ecb9a
jmp 0xff57c
leaq 0x18(%rsp), %rdi
callq 0xff678
testb %al, %al
je 0xff57c
jmp 0xff570
|
/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 = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
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), %rdx # 0x378a78
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x20(%rsi), %rcx
movl (%rcx), %edx
cmpl $0x15, %edx
je 0xff9ff
cmpl $0xe, %edx
jne 0xff9b4
cmpl $0x5, %eax
jne 0xff9ff
cmpb $0x0, 0x50(%rcx)
jne 0xff9ff
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x100006, %esi # imm = 0x100006
jmp 0xff9a7
cmpl $0x1f, %ecx
ja 0xff9c0
movl $0x80300006, %eax # imm = 0x80300006
btl %ecx, %eax
jb 0xff9ff
cmpl $0x3, %ecx
je 0xff9ae
cmpl $0x13, %ecx
jne 0xff9c0
movq 0x20(%rsi), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0xff993
cmpl $0x1, %eax
jne 0xff9ff
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x180006, %esi # imm = 0x180006
callq 0x1ecb9a
jmp 0xff9ff
cmpl $0x0, 0x30(%rsi)
je 0xff9ff
leaq 0x8(%rsp), %rdi
callq 0xffa48
jmp 0xff9ff
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0xff9ff
leaq 0x18(%rsp), %rdi
callq 0xffa08
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
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 0x2786d7(%rip), %rdx # 0x378ddc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1008a6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x100904
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpl $0x12, %eax
jle 0x10076c
leal -0x14(%rax), %ecx
cmpl $0x2, %ecx
jb 0x100724
cmpl $0x1f, %eax
je 0x100724
cmpl $0x13, %eax
jne 0x10078c
movq 0x20(%r14), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0x100753
cmpl $0x1, %eax
jne 0x10070e
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x180006, %esi # imm = 0x180006
jmp 0x1007ff
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x10070e
cmpl $0x3, %eax
jne 0x10078c
cmpl $0x0, 0x30(%r14)
je 0x10070e
leaq 0x8(%rsp), %rdi
callq 0x100860
jmp 0x100724
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0x100724
movq 0x20(%r14), %rax
movl (%rax), %edx
cmpl $0x15, %edx
je 0x10070e
cmpl $0xe, %edx
jne 0x100780
cmpl $0x5, %ecx
jne 0x10070e
cmpb $0x0, 0x50(%rax)
jne 0x10070e
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x100006, %esi # imm = 0x100006
callq 0x1ecb9a
jmp 0x100724
leaq 0x18(%rsp), %rdi
callq 0x100820
testb %al, %al
je 0x100724
jmp 0x10070e
|
/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(%r14), %rdi
testq %rdi, %rdi
je 0x100b9d
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
movq 0x50(%r14), %r15
testq %r15, %r15
je 0x100bc9
movq 0x48(%r14), %r14
shlq $0x3, %r15
xorl %r12d, %r12d
movq (%r14,%r12), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
addq $0x8, %r12
cmpq %r12, %r15
jne 0x100bb1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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 = [&] {
auto& timed = stmt.template as<TimedStatement>();
switch (timed.timing.kind) {
case TimingControlKind::Invalid:
case TimingControlKind::SignalEvent:
case TimingControlKind::EventList:
case TimingControlKind::ImplicitEvent:
return true;
default:
body.addDiag(diag::CheckerTimingControl, timed.sourceRange);
return false;
}
};
if (currBlock->procedureKind == ProceduralBlockKind::Initial) {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
else {
switch (stmt.kind) {
case StatementKind::Empty:
case StatementKind::List:
case StatementKind::Return:
case StatementKind::Continue:
case StatementKind::Break:
case StatementKind::Conditional:
case StatementKind::Case:
case StatementKind::ForLoop:
case StatementKind::RepeatLoop:
case StatementKind::ForeachLoop:
case StatementKind::WhileLoop:
case StatementKind::DoWhileLoop:
case StatementKind::ForeverLoop:
break;
case StatementKind::Timed:
if (!checkTimed())
return;
break;
case StatementKind::ExpressionStatement: {
auto& expr = stmt.template as<ExpressionStatement>().expr;
switch (expr.kind) {
case ExpressionKind::Call:
break;
case ExpressionKind::Assignment:
if (!expr.template as<AssignmentExpression>().isNonBlocking() &&
currBlock->procedureKind == ProceduralBlockKind::AlwaysFF) {
body.addDiag(diag::CheckerBlockingAssign, stmt.sourceRange);
return;
}
break;
default:
return notAllowed();
}
break;
}
case StatementKind::Block:
if (stmt.template as<BlockStatement>().blockKind !=
StatementBlockKind::Sequential) {
return notAllowed();
}
break;
case StatementKind::ImmediateAssertion:
case StatementKind::ConcurrentAssertion:
case StatementKind::ProceduralChecker:
return;
default:
return notAllowed();
}
}
visitDefault(stmt);
}
|
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 0x277a33(%rip), %rdx # 0x3791bc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x20(%r14), %rdi
movq %rdi, %rsi
movq %rbx, %rdx
callq 0xfda5e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10192e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpl $0x12, %eax
jle 0x1017f4
leal -0x14(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1017ac
cmpl $0x1f, %eax
je 0x1017ac
cmpl $0x13, %eax
jne 0x101814
movq 0x20(%r14), %rax
movl (%rax), %eax
cmpl $0x4, %eax
ja 0x1017db
cmpl $0x1, %eax
jne 0x101792
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x180006, %esi # imm = 0x180006
jmp 0x101887
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x101792
cmpl $0x3, %eax
jne 0x101814
cmpl $0x0, 0x30(%r14)
je 0x101792
leaq 0x8(%rsp), %rdi
callq 0x1018e8
jmp 0x1017ac
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x670006, %esi # imm = 0x670006
callq 0x1ecb9a
movq %rax, %r14
movq 0x8(%rbx), %rax
movl 0x40(%rax), %edi
callq 0x1f4288
movq %r14, %rdi
movq %rax, %rsi
callq 0x83e5c
jmp 0x1017ac
movq 0x20(%r14), %rax
movl (%rax), %edx
cmpl $0x15, %edx
je 0x101792
cmpl $0xe, %edx
jne 0x101808
cmpl $0x5, %ecx
jne 0x101792
cmpb $0x0, 0x50(%rax)
jne 0x101792
movq (%rbx), %rdi
addq $0x40, %rdi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x100006, %esi # imm = 0x100006
callq 0x1ecb9a
jmp 0x1017ac
leaq 0x18(%rsp), %rdi
callq 0x1018a8
testb %al, %al
je 0x1017ac
jmp 0x101792
|
/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.