name string | code string | asm string | file string |
|---|---|---|---|
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<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 = internal::copy_str<char_type>(prefix.begin(), prefix.end(), 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 0x10(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x1ce5d
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb9c0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x1ce79
leaq (%r15,%rdx... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::num_writer::operator()<char*&>(char*&) const | void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movl (%rdi), %eax
movslq 0x4(%rdi), %r15
leaq (%rsp,%r15), %rcx
addq $0x3, %rcx
cmpq $0x64, %rax
jb 0x1d011
xorl %esi, %esi
leaq 0x47822(%rip), %rdx # 0x64750
movl $0xaaaaaaab, %r8d # imm = 0xAAAAAAAB
movl %eax, %r9d
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_double<double>(double, fmt::v5::basic_format_specs<char> const&) | void basic_writer<Range>::write_double(T value, const format_specs &spec) {
// Check type.
float_spec_handler handler(static_cast<char>(spec.type));
internal::handle_float_type_spec(handler.type, handler);
char sign = 0;
// Use signbit instead of value < 0 because the latter is always
// false for NaN.
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x11(%rsi), %eax
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
cmpl $0x60, %eax
jg 0x1d0aa
leal -0x41(%rax), %ecx
cmpl $0x6, %ecx
ja 0x1d0c3
leaq 0x43fce(%rip), %rax # 0x610... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::double_writer>(fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffe... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rsi), %r15d
movq 0x10(%rdx), %rax
movq 0x10(%rax), %rbp
movb 0x8(%rdx), %al
cmpb $0x1, %al
sbbq $-0x1, %rbp
movq %r15, %rdx
movq (%rdi), %r12
movq 0x10(%r12), %rbx
movq 0x18(%r12), %rcx
subq %rbp, %rdx
jbe 0x1d37d
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_double<long double>(long double, fmt::v5::basic_format_specs<char> const&) | void basic_writer<Range>::write_double(T value, const format_specs &spec) {
// Check type.
float_spec_handler handler(static_cast<char>(spec.type));
internal::handle_float_type_spec(handler.type, handler);
char sign = 0;
// Use signbit instead of value < 0 because the latter is always
// false for NaN.
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %r14
movq %rdi, %rbx
fldt 0x2e0(%rsp)
movzbl 0x11(%rsi), %eax
movb %al, 0x1e(%rsp)
movb $0x0, 0x1f(%rsp)
cmpl $0x60, %eax
jg 0x1d6af
leal -0x41(%rax), %ecx
cmpl $0x6, %ecx
ja 0x1d6c8
leaq 0x439e9(%rip... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<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
movzbl 0x11(%rdx), %eax
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movzbl 0x10(%rdx), %ecx
testb $0x1, %cl
je 0x1da58
testb $0x2, %cl
movl $0x20, %ecx
movl $0x2b, %edx
cmovel %ecx, %edx
movb %dl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x63, %eax
jg 0x1da6d
cm... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long, fmt::v5::basic_format_specs<char>>::on_dec() | void on_dec() {
int num_digits = internal::count_digits(abs_value);
writer.write_int(num_digits, get_prefix(), spec,
dec_writer{abs_value, num_digits});
} | subq $0x28, %rsp
movq 0x10(%rdi), %r9
movq %r9, %rax
orq $0x1, %rax
bsrq %rax, %rax
xorl $-0x40, %eax
imull $0x4d1, %eax, %esi # imm = 0x4D1
addl $0x13911, %esi # imm = 0x13911
shrl $0xc, %esi
leaq 0x46838(%rip), %rax # 0x64340
cmpq (%rax,%rsi,8), %r9
sbbl $-0x1, %esi
leaq 0x18(%rdi), %rdx
movl 0x1c(%... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::int_writer<long long, fmt::v5::basic_format_specs<wchar_t>>::num_writer>::operator()<wchar_t*>(wchar_t*&&) cons... | FMT_CONSTEXPR size_t size() const { return size_; } | movq 0x10(%rdi), %rcx
movq (%rsi), %rax
testq %rcx, %rcx
jle 0x3172e
movq 0x8(%rdi), %rdx
incq %rcx
movsbl (%rdx), %r8d
movl %r8d, (%rax)
incq %rdx
addq $0x4, %rax
decq %rcx
cmpq $0x1, %rcx
ja 0x31717
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0x31847
leaq (%rax,%r8,4), %rcx
movl 0x18(%rdi), %edx
movabsq $0x3ffffffffffffff... | /scientific-systems[P]fmt/include/fmt/core.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::write_int<unsigned long long, fmt::v5::basic_format_specs<wchar_t>>(unsigned long long, fmt::v5::basic_format_specs<wchar_t> 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
movzbl 0x11(%rdx), %eax
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movzbl 0x10(%rdx), %ecx
testb $0x1, %cl
je 0x31c98
testb $0x2, %cl
movl $0x20, %ecx
movl $0x2b, %edx
cmovel %ecx, %edx
movb %dl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x63, %eax
jg 0x31cad
cm... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::write_int<fmt::v5::basic_format_specs<wchar_t>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<wchar_t>>::dec_writer>... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x70(%rsp), %r9
movl %esi, %r11d
addq %rcx, %r11
movl 0x4(%r8), %r10d
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x31ff9
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<wchar_t>>::num_writer>::operator()<wchar_t*>(wchar_t... | FMT_CONSTEXPR iterator begin() const { return data_; } | movq 0x10(%rdi), %rcx
movq (%rsi), %rax
testq %rcx, %rcx
jle 0x34a52
movq 0x8(%rdi), %rdx
incq %rcx
movsbl (%rdx), %r8d
movl %r8d, (%rax)
incq %rdx
addq $0x4, %rax
decq %rcx
cmpq $0x1, %rcx
ja 0x34a3b
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0x34b6b
leaq (%rax,%r8,4), %rcx
movl 0x18(%rdi), %edx
movabsq $0x3ffffffffffffff... | /scientific-systems[P]fmt/include/fmt/core.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<wchar_t>>::num_writer>::operator()<wchar_t*&>(wchar_... | FMT_CONSTEXPR size_t size() const { return size_; } | movq 0x10(%rdi), %rcx
movq (%rsi), %rax
testq %rcx, %rcx
jle 0x34ba2
movq 0x8(%rdi), %rdx
incq %rcx
movsbl (%rdx), %r8d
movl %r8d, (%rax)
incq %rdx
addq $0x4, %rax
decq %rcx
cmpq $0x1, %rcx
ja 0x34b8b
movq 0x20(%rdi), %r8
testq %r8, %r8
je 0x34cbb
leaq (%rax,%r8,4), %rcx
movl 0x18(%rdi), %edx
movabsq $0x3ffffffffffffff... | /scientific-systems[P]fmt/include/fmt/core.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<wchar_t>>::num_writer::operator()<wchar_t*&>(wchar_t*&) const | void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movq (%rdi), %rdx
movslq 0x8(%rdi), %r15
leaq (%rsp,%r15,4), %rcx
cmpq $0x64, %rdx
jb 0x34dd8
xorl %r8d, %r8d
movabsq $0x28f5c28f5c28f5c3, %r9 # imm = 0x28F5C28F5C28F5C3
leaq 0x2fa4f(%rip), %rsi # 0x64750
movl $0xaaaaaaab... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::char_spec_handler::on_int() | void on_int() {
if (formatter.specs_)
formatter.writer_.write_int(value, *formatter.specs_);
else
formatter.writer_.write(value);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
movq (%rdi), %rdi
movq 0x10(%rdi), %rdx
movl 0x8(%rax), %ebx
testq %rdx, %rdx
je 0x355c0
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35b32
movq (%rdi), %r14
movq 0x10(%r14), %r12
leaq 0x1(%r12), %r15
cmpq %r15, 0x18... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<wchar_t>>>::write_char(wchar_t) | void write_char(char_type value) {
if (specs_)
writer_.write_padded(*specs_, char_writer{value});
else
writer_.write(value);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x35617
leaq 0x4(%rsp), %rdx
movl %ebx, (%rdx)
callq 0x3564c
jmp 0x35640
movq (%rdi), %r14
movq 0x10(%r14), %r12
leaq 0x1(%r12), %r15
cmpq %r15, 0x18(%r14)
jae 0x35634
movq (%r14), %rax
movq %r14, %rdi
movq ... | /scientific-systems[P]fmt/include/fmt/format.h |
testing::internal::ConvertIdentifierNameToWords[abi:cxx11](char const*) | GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name) {
string result;
char prev_char = '\0';
for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
// We don't care about the current locale as the input is
// guaranteed to be a valid C++ identifier name.
const bool starts_new_w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb (%rsi), %r13b
testb %r13b, %r13b
je 0x529f1
movq %rsi, %r14
xorl %ebp, %ebp
movzbl %r13b, %r12d
movl %r12d, %edi
callq 0x... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::GetFailureReporter() | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
// Points to the global failure reporter used by Google Mock. gcc
// guarantees that the following use of failure_reporter is
// thread-safe. We may need to add additional synchronization to
// protect failure_reporter if we port Google Mock to other... | pushq %rbx
movb 0x34f5d(%rip), %al # 0x87980
testb %al, %al
je 0x52a30
movq 0x34f4a(%rip), %rax # 0x87978
popq %rbx
retq
leaq 0x34f49(%rip), %rdi # 0x87980
callq 0xbae0
testl %eax, %eax
je 0x52a27
movl $0x8, %edi
callq 0xb500
leaq 0x3419f(%rip), %rcx # 0x86bf0
movq %rcx, (%rax)
movq %rax, 0x34f1d(%rip)... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::LogIsVisible(testing::internal::LogSeverity) | GTEST_API_ bool LogIsVisible(LogSeverity severity) {
if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
// Always show the log if --gmock_verbose=info.
return true;
} else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
// Always hide it if --gmock_verbose=error.
return false;
} else {
// If --gmock_v... | pushq %rbx
movl %edi, %ebx
leaq 0x34efe(%rip), %rdi # 0x87988
leaq 0x1212c(%rip), %rsi # 0x64bbd
callq 0xb150
testl %eax, %eax
je 0x52abc
leaq 0x34ee7(%rip), %rdi # 0x87988
leaq 0x1211a(%rip), %rsi # 0x64bc2
callq 0xb150
testl %eax, %eax
setne %cl
cmpl $0x1, %ebx
sete %al
andb %cl, %al
jmp 0x52abe
movb ... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::Log(testing::internal::LogSeverity, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | GTEST_API_ void Log(LogSeverity severity,
const string& message,
int stack_frames_to_skip) {
if (!LogIsVisible(severity))
return;
// Ensures that logs from different threads don't interleave.
MutexLock l(&g_log_mutex);
// "using ::std::cout;" doesn't work with Symbi... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movl %edi, %r14d
callq 0x52a80
testb %al, %al
je 0x52bdc
leaq 0x34ec4(%rip), %rdi # 0x879a8
callq 0x1440a
cmpl $0x1, %r14d
jne 0x52b07
movq 0x344ca(%rip), %rdi # 0x86fc0
leaq 0x1418a(%rip), %rsi # 0x66c87
movl $0xf, %edx
callq... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<const internal::string&>::Matcher(const internal::string& s) {
*this = Eq(s);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
leaq 0x33d6a(%rip), %rax # 0x869b8
movq %rax, (%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi),... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::string>::Matcher(const internal::string& s) { *this = Eq(s); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
leaq 0x33b40(%rip), %rax # 0x869d8
movq %rax, (%rdi)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi),... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(char const*) | Matcher<internal::string>::Matcher(const char* s) {
*this = Eq(internal::string(s));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq $0x0, 0x8(%rdi)
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
leaq 0x33a19(%rip), %rax # 0x869d8
movq %rax, (%rdi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb1f0
leaq 0x50(%rsp), %r13
movq %r13, ... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::JoinAsTuple(std::vector<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>>>> const&) | GTEST_API_ string JoinAsTuple(const Strings& fields) {
switch (fields.size()) {
case 0:
return "";
case 1:
return fields[0];
default:
string result = "(" + fields[0];
for (size_t i = 1; i < fields.size(); i++) {
result += ", ";
result += fields[i];
}
res... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq $0x1, %rax
je 0x530f9
testq %rax, %rax
jne 0x53114
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x13098(%rip), %rdx # 0x66181
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x14d... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::FindPairing(testing::internal::MatchMatrix const&, testing::MatchResultListener*) | GTEST_API_ bool FindPairing(const MatchMatrix& matrix,
MatchResultListener* listener) {
ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
size_t max_flow = matches.size();
bool result = (max_flow == matrix.RhsSize());
if (!result) {
if (listener->IsInterested()) {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5338f
movq (%r15), %rdi
movq 0x8(%r15), %rax
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movq 0x8(%rbx), %rdx
movq %rdx, 0x30(%rsp)
cmpq %rd... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::MatchMatrix::NextGraph() | size_t RhsSize() const { return num_matchers_; } | movq (%rdi), %rdx
testq %rdx, %rdx
je 0x536dc
movq 0x8(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x536d2
xorl %edx, %edx
imulq %rax, %rcx
addq 0x10(%rdi), %rcx
cmpb $0x0, (%rdx,%rcx)
sete (%rdx,%rcx)
je 0x536df
incq %rdx
movq 0x8(%rdi), %rcx
cmpq %rcx, %rdx
jb 0x536af
movq (%rdi), %rdx
jmp 0x536d4
xorl %ecx, %ecx... | /scientific-systems[P]fmt/test/gmock/gmock.h |
testing::internal::MatchMatrix::Randomize() | size_t RhsSize() const { return num_matchers_; } | movq (%rdi), %rax
testq %rax, %rax
je 0x5373e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x53728
xorl %r12d, %r12d
imulq %r14, %r15
addq 0x10(%rbx), %r15
callq 0xb130
andb $0x1, %al
movb %al, (%r12,%r15)
incq %r12
movq 0x8(%rbx), %r1... | /scientific-systems[P]fmt/test/gmock/gmock.h |
testing::internal::MatchMatrix::DebugString[abi:cxx11]() const | string MatchMatrix::DebugString() const {
::std::stringstream ss;
const char *sep = "";
for (size_t i = 0; i < LhsSize(); ++i) {
ss << sep;
for (size_t j = 0; j < RhsSize(); ++j) {
ss << HasEdge(i, j);
}
sep = ";";
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xb380
cmpq $0x0, (%r14)
je 0x537cf
leaq 0x12a15(%rip), %r12 # 0x66181
leaq 0x10(%rsp), %r15
xorl %r13d, %r13d
leaq 0x12acd(%rip), %rbp # 0x66248
mov... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(std::ostream*) const | void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
::std::ostream* os) const {
if (matcher_describers_.empty()) {
*os << "isn't empty";
return;
}
if (matcher_describers_.size() == 1) {
*os << "doesn't have " << Elements(1)
<< ", or has " << Elements(1) << " that ";
match... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r15
cmpq %r15, %rax
je 0x53b89
movq %rdi, %r14
subq %rax, %r15
leaq 0x13327(%rip), %rsi # 0x66db3
movl $0xd, %edx
movq %rbx, %rdi
callq 0xb630
cmpq $0x8, %r15
jne 0x53bab
leaq 0x8(%r... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::UnorderedElementsAreMatcherImplBase::VerifyAllElementsAndMatchersAreMatched(std::vector<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>>>> const&, testing::internal::MatchMatri... | bool UnorderedElementsAreMatcherImplBase::
VerifyAllElementsAndMatchersAreMatched(
const ::std::vector<string>& element_printouts,
const MatchMatrix& matrix,
MatchResultListener* listener) const {
bool result = true;
::std::vector<char> element_matched(matrix.LhsSize(), 0);
::std::vector<char> matcher... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x40(%rsp)
movq %rdi, %r15
movq (%rdx), %rsi
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdx
movb %bpl, (%rdx)
leaq 0x28(%rsp), %rdi
movq %rsp, %r12
movq %r12, %rcx
callq 0x5ae40
movq 0x8(%r14), %rsi
movb... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::LogWithLocation(testing::internal::LogSeverity, char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
const char* file, int line,
const string& message) {
::std::ostringstream s;
s << file << ":" << line << ": " << message << ::std::endl;
Log(severity, s.str(), 0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %ebx
leaq 0x20(%rsp), %rdi
callq 0xb7d0
testq %r15, %r15
je 0x54000
movq %r15, %rdi
callq 0xb210
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb630
jmp 0x5401... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::ExpectationBase::ExpectationBase(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ExpectationBase::ExpectationBase(const char* a_file,
int a_line,
const string& a_source_text)
: file_(a_file),
line_(a_line),
source_text_(a_source_text),
cardinality_specified_(false),
cardinality_(Exactly(1)),
call_cou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x32329(%rip), %rax # 0x86468
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movl %edx, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r13
movq %r13, 0x18(%rdi)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
movq %... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::ExpectationBase::~ExpectationBase() | ExpectationBase::~ExpectationBase() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x32231(%rip), %rax # 0x86468
movq %rax, (%rdi)
addq $0xb0, %rdi
callq 0x580e6
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x54257
callq 0xb4c0
leaq 0x50(%rbx), %rdi
callq 0x21a28
leaq 0x40(%rbx), %rdi
callq 0x258ce
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x5427c
popq... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
testing::internal::ExpectationBase::RetireAllPreRequisites() | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
if (is_retired()) {
// We can take this short-cut as we never retire an expectation
// until we have retired all its pre-requisites.
return;
}
for (ExpectationSet::const_iterator it = immediate_prerequisites_.begin();
it != immediate_prerequisite... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33740(%rip), %rdi # 0x879e0
callq 0x204e0
cmpb $0x0, 0x84(%rbx)
jne 0x54302
movq 0x68(%rbx), %r14
addq $0x58, %rbx
cmpq %rbx, %r14
je 0x54302
leaq 0x3371e(%rip), %r15 # 0x879e0
movq 0x20(%r14), %r12
movq %r15, %rdi
callq 0x204e0
cmpb ... | /scientific-systems[P]fmt/test/gmock-gtest-all.cc |
zt_cstr_rany | ssize_t
zt_cstr_rany(const char *s, ssize_t i, ssize_t j, const char *set) {
ssize_t orig;
zt_assert(s);
zt_assert(set);
CONVERT(s, i, j);
zt_assert(i >= 0 && i <= j);
for (orig = i; j >= i; j--) {
if (s[j] != '\0' && strchr(set, s[j])) {
return j - orig;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x30e0
testq %rax, %rax
je 0x4ade
movq %r12, %rcx
sarq $0x3f, %rcx
andq %rax, %rcx
addq %r12, %rcx
leaq -0x1(%rax), %rdx
cmpq %rax, %rcx
cmovgeq %rdx, %rcx
movq %r15, %r12
s... | /zerotao[P]libzt/src/libzt/zt_cstr.c |
atexit_call | static void
_atexit_call(void) {
zt_stack_t * se;
struct zt_atexit_cb * cb;
while(!zt_stack_empty(&cb_stack)) {
se = zt_stack_pop(&cb_stack);
cb = zt_stack_data(se, struct zt_atexit_cb, member);
if(cb && cb->fn) {
cb->fn(cb->data);
zt_free(cb);
... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x5c8a(%rip), %r14 # 0xb1d0
movq 0x5c8b(%rip), %rbx # 0xb1d8
cmpq %r14, %rbx
je 0x5579
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5546
movq 0x18(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
callq 0x... | /zerotao[P]libzt/src/libzt/zt_atexit.c |
Catch::MatchExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
auto matcherAsString = m_matcher.toString();
os << Catch::Detail::stringify( m_arg ) << ' ';
if( matcherAsString == Detail::unprintableString )
os << m_matcherString;
else
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
leaq 0x10(%rsp), %rdi
callq 0x218f4
movq 0x10(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x2c882
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x15840
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x... | /diatomic[P]diy/tests/catch.hpp |
p_test_case_plist_nomem_test() | P_TEST_CASE_BEGIN (plist_nomem_test)
{
p_libsys_init ();
PMemVTable vtable;
vtable.f_free = pmem_free;
vtable.f_malloc = pmem_alloc;
vtable.f_realloc = pmem_realloc;
P_TEST_CHECK (p_mem_set_vtable (&vtable) == TRUE);
P_TEST_CHECK (p_list_append (NULL, PINT_TO_POINTER (10)) == NULL);
P_TEST_CHECK (p_list... | pushq %rbx
subq $0x20, %rsp
andl $0x0, 0x2e6d(%rip) # 0x40ac
callq 0x1060
leaq -0x19(%rip), %rax # 0x1232
leaq 0x8(%rsp), %rdi
movq %rax, 0x10(%rdi)
leaq -0x2f(%rip), %rax # 0x122c
movq %rax, (%rdi)
leaq -0x36(%rip), %rax # 0x122f
movq %rax, 0x8(%rdi)
callq 0x1100
cmpl $0x1, %eax
je 0x1297
leaq 0... | /saprykin[P]plibsys/tests/plist_test.cpp |
p_test_case_plist_general_test() | P_TEST_CASE_BEGIN (plist_general_test)
{
PList *list = NULL;
TestData test_data;
p_libsys_init ();
/* Testing append */
list = p_list_append (list, P_INT_TO_POINTER (32));
list = p_list_append (list, P_INT_TO_POINTER (64));
P_TEST_REQUIRE (list != NULL);
P_TEST_CHECK (p_list_length (list) == 2);
/* Testin... | pushq %r14
pushq %rbx
subq $0x18, %rsp
andl $0x0, 0x2c91(%rip) # 0x40ac
callq 0x1060
pushq $0x20
popq %rsi
xorl %edi, %edi
callq 0x10a0
pushq $0x40
popq %rsi
movq %rax, %rdi
callq 0x10a0
testq %rax, %rax
je 0x1935
movq %rax, %rbx
movq %rax, %rdi
callq 0x1070
cmpq $0x2, %rax
je 0x1473
leaq 0xbae(%rip), %rdi #... | /saprykin[P]plibsys/tests/plist_test.cpp |
foreach_test_func(void*, void*) | static void foreach_test_func (ppointer data, ppointer user_data)
{
if (user_data == NULL)
return;
TestData *test_data = (TestData *) user_data;
if (test_data->index < 0 || test_data->index > 2)
return;
test_data->test_array[test_data->index] = P_POINTER_TO_INT (data);
++test_data->index;
} | testq %rsi, %rsi
je 0x19cf
movl 0xc(%rsi), %eax
cmpq $0x2, %rax
ja 0x19cf
movl %edi, (%rsi,%rax,4)
incl 0xc(%rsi)
retq
| /saprykin[P]plibsys/tests/plist_test.cpp |
main | int main() {
const int n = 10;
int arrA[n] = {5, 7, 3, 4, 8, 1, 2, 9, 0, 6};
int arrB[n];
sort(arrA, 0, n - 1, arrB);
for (int i = 0; i < n; i++) {
printf("%d ", arrB[i]);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0xa, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0xcaf(%rip), %rsi # 0x2010
movl $0x28, %edx
callq 0x1040
movq %rsp, %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x9, %edx
leaq -0x70(%rbp), %rcx
callq 0x1150
movl $0x0, ... | /yahooshiken[P]in-c/H16_merge_sort.c |
testing::internal::SuiteApiResolver<SpinMutexTest_TryLockFail_Test<yamc::spin_ttas::basic_mutex<yamc::backoff::busy>>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x629d4
testb %al, %al
jne 0x60ce3
leaq 0x2b50a(%rip), %rdx # 0x8c13d
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x211, %ecx # imm = 0x211
callq 0x7efc8
movq 0x4e39a(%rip), %rdi # 0xaefe8
leaq 0x2b... | /yohhoy[P]yamc/build_O1/external/include/gtest/internal/gtest-internal.h |
SpinMutexTest_TryLockFail_Test<yamc::posix::spinlock>::TestBody() | TYPED_TEST(SpinMutexTest, TryLockFail)
{
yamc::test::barrier step(2);
TypeParam mtx;
yamc::test::join_thread thd([&]{
EXPECT_NO_THROW(mtx.lock());
step.await(); // b1
step.await(); // b2
EXPECT_NO_THROW(mtx.unlock());
});
{
step.await(); // b1
EXPECT_FALSE(mtx.try_lock());
step.... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl $0x2, %eax
leaq 0x70(%rsp), %rbx
movq %rax, -0x18(%rbx)
movq %rax, -0x10(%rbx)
xorl %r14d, %r14d
movq %r14, -0x8(%rbx)
movq %rbx, %rdi
callq 0x46860
movq %r14, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
leaq 0xc(%rsp), %r14
movq %r14, %rdi... | /yohhoy[P]yamc/tests/spinlock_test.cpp |
testing::internal::UnitTestImpl::skipped_test_count() const | int UnitTestImpl::skipped_test_count() const {
return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xb8(%rdi), %rax
cmpq %rax, 0xc0(%rdi)
je 0x65f78
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax,%r15,8), %rdi
callq 0x65f8a
addl %eax, %r14d
incq %r15
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
... | /yohhoy[P]yamc/build_O1/tests/googletest-prefix/src/googletest/googletest/src/gtest.cc |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<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>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %r15d, %r15d
movsbl %sil, %r12d
leaq -0x48(%rbp), %r13
movq %r14, %rdi
movl %r12d, %esi
movq... | /yohhoy[P]yamc/build_O1/tests/googletest-prefix/src/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d528(%rip), %rax # 0xae780
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x8126d
callq 0x464e0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
addq $0x8, %rsp
cmpq %rbx, %rdi
je 0x81285
popq %rbx
popq %rbp
jmp 0x464e0
... | /yohhoy[P]yamc/build_O1/tests/googletest-prefix/src/googletest/googletest/include/gtest/gtest.h |
doctest::detail::tlssPop() | String tlssPop() {
return g_oss.pop();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1364d
movq %fs:-0x1d0, %rax
cmpq %rax, %fs:-0x1d8
je 0x4b38
movq %fs:0x0, %rcx
leaq -0x1d8(%rcx), %r14
leaq -0x10(%rax), %rcx
movq -0x10(%rax), %r15
movq -0x8(%rax), %r12
movq %rcx, %fs:-0x1d0
leaq 0x18(%r14), %r1... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::toString(long double) | String toString(double long in) { return fpToString(in, 15); } | pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
fldt 0x1f0(%rsp)
fstpt 0x34(%rsp)
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x44c0
movq (%r14), %rax
movq -0x18(%rax), %rcx
movq $0xf, 0x68(%rsp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx # imm = 0xFFFFFEFB
andl 0x78(%rsp,... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::detail::isDebuggerActive() | ~ErrnoGuard() { errno = m_oldErrno; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
callq 0x4050
movq %rax, %rbx
movl (%rax), %ebp
leaq 0x12086(%rip), %rsi # 0x18534
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x4680
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
mo... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::detail::registerExceptionTranslatorImpl(doctest::detail::IExceptionTranslator const*) | void registerExceptionTranslatorImpl(const IExceptionTranslator* et) {
if(std::find(getExceptionTranslators().begin(), getExceptionTranslators().end(), et) ==
getExceptionTranslators().end())
getExceptionTranslators().push_back(et);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rdi, (%rbx)
callq 0x65d1
movq 0x1e423(%rip), %r14 # 0x249b0
callq 0x65d1
movq 0x1e41f(%rip), %rsi # 0x249b8
movq %r14, %rdi
movq %rbx, %rdx
callq 0x15f8e
movq %rax, %rbx
callq 0x65d1
cmpq 0x1e405(%rip), %rbx # 0x249b8
jne 0x65c9
callq 0x65d1
leaq 0x1e3e... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::detail::MessageBuilder::log() | bool MessageBuilder::log() {
if (!logged) {
m_string = tlssPop();
logged = true;
}
DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);
const bool isWarn = m_severity & assertType::is_warn;
// warn is just a message in this context so we don't... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x6e85
movq %rsp, %r14
movq %r14, %rdi
callq 0x4a9b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e84
movq %r14, %rdi
callq 0x4c36
movb $0x1, 0x30(%rbx)
movq 0x1d54c(%rip), %rax # 0x243d8
movq 0x10d0(%rax), %r14
movq 0... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::parseCommaSepArgs(int, char const* const*, char const*, std::vector<doctest::String, std::allocator<doctest::String>>&) | bool parseCommaSepArgs(int argc, const char* const* argv, const char* pattern,
std::vector<String>& res) {
String filtersString;
if(parseOption(argc, argv, pattern, &filtersString)) {
// tokenize with "," as a separator, unless escaped with backslash
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r14
xorl %eax, %eax
leaq 0x18(%rsp), %rbx
movb %al, (%rbx)
movb $0x17, %cl
movb %cl, 0x17(%rbx)
leaq 0x30(%rsp), %r8
movb %al, (%r8)
movb %cl, 0x17(%r8)
movq %rbx, %rcx
callq 0x84e4
movl %eax, %ebp
l... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
doctest::(anonymous namespace)::parseOption(int, char const* const*, char const*, doctest::String*, doctest::String const&) | bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
const String& defaultVal = String()) {
if(value)
*value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
// offset (normally 3 for "dt-") to skip prefix
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
testq %rcx, %rcx
je 0x8506
movq %rbx, %rdi
movq %r8, %rsi
callq 0x4ccc
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xd3a8
testb %al, %al
je 0x8528
movb $0x1, %al
addq $0x... | /igormironchik[P]cfgfile/tests/auto/InputStream/../../../3rdparty/doctest/doctest.h |
file_read_aligned.cold.3 | static Result get_file_size(FILE* f, long* out_size) {
CHECK_MSG(fseek(f, 0, SEEK_END) >= 0, "fseek to end failed.\n");
long size = ftell(f);
CHECK_MSG(size >= 0, "ftell failed.");
CHECK_MSG(fseek(f, 0, SEEK_SET) >= 0, "fseek to beginning failed.\n");
*out_size = size;
return OK;
ON_ERROR_RETURN;
} | pushq %rbx
movq 0x1fd2e(%rip), %rbx # 0x26ff8
movq (%rbx), %rdi
leaq 0x11d3f(%rip), %rsi # 0x19013
leaq 0x11d40(%rip), %rdx # 0x1901b
pushq $0x1e
popq %rcx
xorl %eax, %eax
callq 0x7190
movq (%rbx), %rcx
leaq 0x11ddb(%rip), %rdi # 0x190ca
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
jmp 0x7230
| /binji[P]binjgb/src/common.c |
emulator_new.cold.2 | static Result set_rom_file_data(Emulator* e, const FileData* file_data) {
CHECK_MSG(file_data->size > 0, "File is empty.\n");
CHECK_MSG((file_data->size & (MINIMUM_ROM_SIZE - 1)) == 0,
"File size (%ld) should be a multiple of minimum rom size (%ld).\n",
(long)file_data->size, (long)MINIMUM_R... | pushq %rbx
movq 0x1f955(%rip), %rbx # 0x26ff8
movq (%rbx), %rdi
leaq 0x11966(%rip), %rsi # 0x19013
leaq 0x1493c(%rip), %rdx # 0x1bff0
movl $0x1329, %ecx # imm = 0x1329
xorl %eax, %eax
callq 0x7190
movq (%rbx), %rcx
leaq 0x160b9(%rip), %rdi # 0x1d783
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
po... | /binji[P]binjgb/src/emulator.c |
usage | void usage(int argc, char** argv) {
static const char usage[] =
"usage: %s [options] <in.gb>\n"
" -h,--help help\n"
#ifdef TESTER_DEBUGGER
" -t,--trace trace each instruction\n"
" -l,--log S=N set log level for system S to N\n"
#endif
" -j,--joypad FILE ... | pushq %rax
movq 0x1f549(%rip), %rax # 0x26ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0x16fd4(%rip), %rsi # 0x1ea90
pushq $0x3c
popq %rcx
xorl %eax, %eax
callq 0x7190
xorl %eax, %eax
popq %rcx
jmp 0x742e
| /binji[P]binjgb/src/tester.c |
replace_extension | const char* replace_extension(const char* filename, const char* extension) {
size_t length = strlen(filename) + strlen(extension) + 1; /* +1 for \0. */
char* result = xmalloc(length);
char* last_dot = strrchr(filename, '.');
if (last_dot == NULL) {
snprintf(result, length, "%s%s", filename, extension);
} ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x70c0
movq %rax, %r15
movq %rbx, %rdi
callq 0x70c0
leaq (%r15,%rax), %r12
incq %r12
movq %r12, %rdi
callq 0x71c0
movq %rax, %r15
movq %r14, %rdi
movl $0x2e, %esi
callq 0x7100
testq %rax, %rax
je 0x7e8f
subl %r14d, %eax
leaq 0x... | /binji[P]binjgb/src/common.c |
write_io | static void write_io(Emulator* e, MaskedAddress addr, u8 value) {
HOOK(write_io_asb, addr, get_io_reg_string(addr), value);
switch (addr) {
case IO_JOYP_ADDR:
JOYP.joypad_select = UNPACK(value, JOYP_JOYPAD_SELECT);
do_sgb(e);
check_joyp_intr(e);
break;
case IO_SB_ADDR:
serial_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r13
leaq 0x12e11(%rip), %rcx # 0x1c8ca
movzwl %r15w, %r12d
movq %rcx, %rax
cmpl $0xff, %esi
ja 0x9ad3
leaq 0x1ba01(%rip), %rax # 0x254d0
movq (%rax,%r12,8), %rax
testq %rax, %rax
cmov... | /binji[P]binjgb/src/emulator.c |
emulator_set_builtin_palette | void emulator_set_builtin_palette(Emulator* e, u32 index) {
static const PaletteRGBA pals[][3] = {
#define PAL(b0, b1, b2, b3, o00, o01, o02, o03, o10, o11, o12, o13) \
{{{b0, b1, b2, b3}}, {{o00, o01, o02, o03}}, {{o10, o11, o12, o13}}},
#define PAL3(c0, c1, c2, c3) \
{{{c0, c1, c2, c3}}, {{c0, c1, c2, c3}}, {{c... | cmpl $0x53, %esi
ja 0xb373
movl %esi, %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq 0xec36(%rip), %rcx # 0x19e70
leaq (%rcx,%rax), %rdx
movups (%rax,%rcx), %xmm0
movups %xmm0, 0x82458(%rdi)
xorl %eax, %eax
movl 0x33894(%rdi,%rax,4), %ecx
movl 0x82458(%rdi,%rcx,4), %ecx
movl %ecx, 0x82488(%rdi,%rax,4)
incq %ra... | /binji[P]binjgb/src/emulator.c |
randomize_buffer | static void randomize_buffer(u32* seed, u8* buffer, u32 size) {
while (size >= sizeof(u32)) {
u32 x = random_u32(seed);
memcpy(buffer, &x, sizeof(x));
buffer += sizeof(u32);
size -= sizeof(u32);
}
if (size > 0) {
u32 x = random_u32(seed);
switch (size) {
case 3: *buffer++ = x & 0xff;... | cmpl $0x4, %edx
jb 0xb3a0
movl (%rdi), %eax
movl %eax, %ecx
shll $0xd, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x11, %eax
xorl %ecx, %eax
movl %eax, %ecx
shll $0x5, %ecx
xorl %eax, %ecx
movl %ecx, (%rdi)
movl %ecx, (%rsi)
addq $0x4, %rsi
addl $-0x4, %edx
cmpl $0x3, %edx
ja 0xb379
testl %edx, %edx
je 0xb3bf
movl (%rd... | /binji[P]binjgb/src/emulator.c |
update_bw_palette_rgba | static void update_bw_palette_rgba(Emulator* e, PaletteType type) {
for (int i = 0; i < 4; ++i) {
e->pal[type].color[i] =
e->color_to_rgba[type].color[PPU.pal[type].color[i]];
}
if (type == PALETTE_TYPE_BGP) {
for (int pal = 0; pal < 4; ++pal) {
for (int i = 0; i < 4; ++i) {
e->sgb_p... | movl %esi, %eax
shlq $0x4, %rax
addq %rdi, %rax
addq $0x82458, %rax # imm = 0x82458
xorl %ecx, %ecx
movl -0x4ebc4(%rax,%rcx,4), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0x30(%rax,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0xb46c
testl %esi, %esi
jne 0xb4ca
leaq 0x33464(%rdi), %rax
leaq 0x824b8(%rdi), %rcx
xorl %edx... | /binji[P]binjgb/src/emulator.c |
emulator_write_ext_ram | Result emulator_write_ext_ram(Emulator* e, FileData* file_data) {
if (EXT_RAM.battery_type != BATTERY_TYPE_WITH_BATTERY)
return OK;
CHECK(file_data->size >= EXT_RAM.size);
memcpy(file_data->data, EXT_RAM.data, file_data->size);
return OK;
ON_ERROR_RETURN;
} | xorl %eax, %eax
cmpl $0x1, 0x270d0(%rdi)
jne 0xb91d
movq %rdi, %rcx
movq 0x8(%rsi), %rdx
movl $0x1, %eax
cmpq 0x270c8(%rdi), %rdx
jb 0xb91d
pushq %rax
addq $0x70c8, %rcx # imm = 0x70C8
movq (%rsi), %rdi
movq %rcx, %rsi
callq 0x71b0
xorl %eax, %eax
addq $0x8, %rsp
retq
| /binji[P]binjgb/src/emulator.c |
emulator_add_empty_breakpoint | int emulator_add_empty_breakpoint(void) {
int id;
for (id = 0; id < MAX_BREAKPOINTS; ++id) {
Breakpoint* bp = &s_breakpoints[id];
if (!bp->valid) {
bp->id = id;
bp->addr = bp->bank = 0;
bp->enabled = FALSE;
bp->valid = TRUE;
s_breakpoint_max_id = MAX(id + 1, s_breakpoint_max_id... | movl 0x1adea(%rip), %ecx # 0x27180
movl 0x1b5f4(%rip), %edx # 0x27990
xorl %esi, %esi
leaq 0x1adeb(%rip), %rdi # 0x27190
movb 0x7(%rdi,%rsi,8), %r8b
testb $0x1, %r8b
jne 0xc3ea
leaq (,%rsi,8), %rax
movl %esi, (%rax,%rdi)
movb $0x0, 0x6(%rdi,%rsi,8)
movw $0x0, 0x4(%rdi,%rsi,8)
movl %r8d, %eax
andb $-0x4, %al... | /binji[P]binjgb/src/emulator-debug.c |
emulator_add_breakpoint | int emulator_add_breakpoint(Emulator* e, Address addr, Bool enabled) {
int id = emulator_add_empty_breakpoint();
if (id < 0) {
return id;
}
emulator_set_breakpoint_address(e, id, addr);
emulator_enable_breakpoint(id, enabled);
return id;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
callq 0xc390
movl %eax, %ebp
testl %eax, %eax
js 0xc433
movzwl %r15w, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0xc440
movl %ebp, %edi
movl %ebx, %esi
callq 0xc482
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14... | /binji[P]binjgb/src/emulator-debug.c |
calculate_breakpoint_mask | static void calculate_breakpoint_mask(void) {
s_breakpoint_mask[0] = 0xffffu;
s_breakpoint_mask[1] = 0xffffu;
int id;
for (id = 0; id < s_breakpoint_max_id; ++id) {
Breakpoint* bp = &s_breakpoints[id];
if (!(bp->valid && bp->enabled)) {
continue;
}
s_breakpoint_mask[0] &= ~bp->addr;
s_... | movw $0xffff, %ax # imm = 0xFFFF
movw %ax, 0x281bd22(%rip) # 0x2828200
movw %ax, 0x281bd1d(%rip) # 0x2828202
movslq 0x1ac94(%rip), %rcx # 0x27180
testq %rcx, %rcx
jle 0xc530
xorl %edx, %edx
leaq 0x1ac96(%rip), %rsi # 0x27190
movw $0xffff, %di # imm = 0xFFFF
movb 0x7(%rsi,%rdx,8), %r8... | /binji[P]binjgb/src/emulator-debug.c |
emulator_get_log_system_name | const char* emulator_get_log_system_name(LogSystem system) {
switch (system) {
#define V(SHORT_NAME, name, NAME) \
case LOG_SYSTEM_##NAME: \
return #name;
FOREACH_LOG_SYSTEM(V)
#undef V
default:
return "<unknown log system>";
}
} | cmpl $0x5, %edi
ja 0xc7e7
movl %edi, %eax
leaq 0x1a466(%rip), %rcx # 0x26c48
movq (%rcx,%rax,8), %rax
retq
leaq 0xfb68(%rip), %rax # 0x1c356
retq
| /binji[P]binjgb/src/emulator-debug.c |
ppu_synchronize | static void ppu_synchronize(Emulator* e) {
assert(IS_ALIGNED(PPU.sync_ticks, CPU_TICK));
Ticks aligned_ticks = ALIGN_DOWN(TICKS, CPU_TICK);
if (aligned_ticks > PPU.sync_ticks) {
Ticks delta_ticks = aligned_ticks - PPU.sync_ticks;
if (LCDC.display) {
for (; delta_ticks > 0; delta_ticks -= CPU_TICK) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x33828(%rdi), %rax
testb $0x3, %al
jne 0x11194
movq %rdi, %rbx
movq 0x33bf8(%rdi), %r14
andq $-0x4, %r14
cmpq %rax, %r14
jbe 0x11185
je 0x1117e
cmpl $0x0, 0x33838(%rbx)
je 0x1117e
movq %r14, %r15
negq %r15
leaq 0x4(%rax), %r12
movl... | /binji[P]binjgb/src/emulator.c |
dispatch_interrupt | static void dispatch_interrupt(Emulator* e) {
Bool was_halt = INTR.state >= CPU_STATE_HALT;
if (!(INTR.ime || was_halt)) {
return;
}
INTR.ime = FALSE;
INTR.state = CPU_STATE_NORMAL;
/* Write MSB of PC. */
RSP--; WRITE8(RSP, REG.PC >> 8);
/* Now check which interrupt to raise, after having written... | pushq %rbp
pushq %rbx
pushq %rax
movl 0x2f0e4(%rdi), %ebp
cmpl $0x4, %ebp
setae %al
cmpl $0x0, 0x2f0dc(%rdi)
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x114e7
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x2f0dc(%rdi)
movl %eax, 0x2f0e4(%rdi)
movl 0x30b0(%rdi), %eax
decl %eax
movw %ax, 0x30b0(%rdi)
movzbl 0x30b3(%rdi), %... | /binji[P]binjgb/src/emulator.c |
do_ppu_mode2 | static void do_ppu_mode2(Emulator* e) {
dma_synchronize(e);
if (!LCDC.obj_display || e->config.disable_obj) {
return;
}
int line_obj_count = 0;
int i;
u8 obj_height = s_obj_size_to_height[LCDC.obj_size];
u8 y = PPU.line_y;
for (i = 0; i < OBJ_COUNT; ++i) {
/* Put the visible sprites into line_o... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x12813
cmpl $0x0, 0x33850(%rbx)
je 0x11d60
cmpl $0x0, 0x18(%rbx)
jne 0x11d60
movl 0x3384c(%rbx), %eax
leaq 0x92ca(%rip), %rcx # 0x1af54
movb (%rax,%rcx), %al
movb 0x33a72(%rbx), %cl
leaq 0x2f0e8(%rbx), %rdx
leaq 0x33a74(%rbx), %rsi
leaq ... | /binji[P]binjgb/src/emulator.c |
dma_synchronize | static void dma_synchronize(Emulator* e) {
if (UNLIKELY(DMA.state != DMA_INACTIVE)) {
if (TICKS > DMA.sync_ticks) {
Ticks delta_ticks = TICKS - DMA.sync_ticks;
DMA.sync_ticks = TICKS;
Ticks cpu_tick = e->state.cpu_tick;
for (; delta_ticks > 0; delta_ticks -= cpu_tick) {
if (DMA.ti... | cmpl $0x0, 0x33b58(%rdi)
jne 0x1281d
retq
pushq %rax
leaq 0x33b48(%rdi), %rsi
leaq 0x33b58(%rdi), %rdx
callq 0x77b2
addq $0x8, %rsp
retq
| /binji[P]binjgb/src/emulator.c |
write_vram | static void write_vram(Emulator* e, MaskedAddress addr, u8 value) {
ppu_synchronize(e);
if (UNLIKELY(is_using_vram(e, TRUE))) {
HOOK(write_vram_in_use_ab, addr, value);
return;
}
assert(addr <= ADDR_MASK_8K);
VRAM.data[VRAM.offset + addr] = value;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x10d75
cmpl $0x3, 0x3387c(%rbx)
je 0x13ef2
movzwl %r14w, %eax
cmpl $0x2000, %eax # imm = 0x2000
jae 0x13f05
movzwl 0x70c4(%rbx), %ecx
addq %rax, %rcx
movb %bpl, 0x30c4(%rbx,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
movzwl ... | /binji[P]binjgb/src/emulator.c |
update_square_wave | static void update_square_wave(Channel* channel, u32 total_frames) {
static u8 duty[WAVE_DUTY_COUNT][DUTY_CYCLE_COUNT] =
{[WAVE_DUTY_12_5] = {0, 0, 0, 0, 0, 0, 0, 1},
[WAVE_DUTY_25] = {1, 0, 0, 0, 0, 0, 0, 1},
[WAVE_DUTY_50] = {1, 0, 0, 0, 0, 1, 1, 1},
[WAVE_DUTY_75] = {0, 1, 1, 1, 1, 1, 1,... | testl %esi, %esi
je 0x14671
cmpl $0x0, 0x38(%rdi)
je 0x14671
pushq %rbx
movzbl 0x1d(%rdi), %eax
movl 0x10(%rdi), %edx
movb 0x4(%rdi), %r9b
movl 0x3c(%rdi), %ecx
leaq 0xa199(%rip), %r8 # 0x1e7b0
movl %edx, %r10d
shrl %r10d
cmpl %esi, %r10d
jbe 0x14631
subl %esi, %edx
subl %esi, %edx
movl %edx, 0x10(%rdi)
movl %r9d... | /binji[P]binjgb/src/emulator.c |
trigger_nrx4_envelope | static void trigger_nrx4_envelope(Emulator* e, Envelope* envelope,
Address addr) {
envelope->volume = envelope->initial_volume;
envelope->timer = envelope->period ? envelope->period : ENVELOPE_MAX_PERIOD;
envelope->automatic = TRUE;
/* If the next APU frame will update the enve... | movzbl (%rsi), %r8d
movb %r8b, 0x9(%rsi)
movl 0x8(%rsi), %eax
testb %al, %al
movl $0x8, %ecx
cmovnel %eax, %ecx
movzbl %cl, %eax
movl %eax, 0xc(%rsi)
movl $0x1, 0x10(%rsi)
cmpb $0x6, 0x33814(%rdi)
je 0x14c91
leaq 0x7c64(%rip), %rcx # 0x1c8ca
movzwl %dx, %eax
movq %rcx, %r9
cmpw $0x16, %dx
ja 0x14c7d
leaq 0x11f17(%... | /binji[P]binjgb/src/emulator.c |
write_noise_period | static void write_noise_period(Emulator* e) {
static const u8 s_divisors[NOISE_DIVISOR_COUNT] = {8, 16, 32, 48,
64, 80, 96, 112};
u8 divisor = s_divisors[NOISE.divisor];
assert(NOISE.divisor < NOISE_DIVISOR_COUNT);
NOISE.period = divisor << NOISE.clock_shift... | movzbl 0x33708(%rdi), %eax
cmpq $0x8, %rax
jae 0x14d98
leaq 0x9a2d(%rip), %rcx # 0x1e7a6
movzbl (%rax,%rcx), %edx
movzbl 0x33700(%rdi), %ecx
movl %edx, %r8d
shll %cl, %r8d
movl %r8d, 0x3370c(%rdi)
xorl %eax, %eax
jmp 0x159bb
pushq %rax
leaq 0x8666(%rip), %rdi # 0x1d406
leaq 0x7249(%rip), %rsi # 0x1bff0
l... | /binji[P]binjgb/src/emulator.c |
gb_read_ext_ram | static u8 gb_read_ext_ram(Emulator* e, MaskedAddress addr) {
if (MMAP_STATE.ext_ram_enabled) {
assert(addr <= ADDR_MASK_8K);
return EXT_RAM.data[MMAP_STATE.ext_ram_base | addr];
} else {
HOOK(read_ram_disabled_a, addr);
return INVALID_READ_BYTE;
}
} | pushq %rax
cmpl $0x0, 0x307c(%rdi)
je 0x161ef
movzwl %si, %eax
cmpl $0x2000, %eax # imm = 0x2000
jae 0x16204
movl 0x3078(%rdi), %ecx
orq %rcx, %rax
movb 0x70c8(%rdi,%rax), %al
jmp 0x16202
movzwl %si, %edx
leaq 0x741e(%rip), %rsi # 0x1d617
xorl %eax, %eax
callq 0x168b3
movb $-0x1, %al
popq %rcx
retq
leaq ... | /binji[P]binjgb/src/emulator.c |
gb_write_ext_ram | static void gb_write_ext_ram(Emulator* e, MaskedAddress addr, u8 value) {
if (MMAP_STATE.ext_ram_enabled) {
assert(addr <= ADDR_MASK_8K);
EXT_RAM.data[MMAP_STATE.ext_ram_base | addr] = value;
e->state.ext_ram_updated = TRUE;
} else {
HOOK(write_ram_disabled_ab, addr, value);
}
} | cmpl $0x0, 0x307c(%rdi)
je 0x16251
movzwl %si, %eax
cmpl $0x2000, %eax # imm = 0x2000
jae 0x16267
movl 0x3078(%rdi), %ecx
orq %rcx, %rax
movb %dl, 0x70c8(%rdi,%rax)
movl $0x1, 0x33c18(%rdi)
retq
movzwl %si, %eax
movzbl %dl, %ecx
leaq 0x741d(%rip), %rsi # 0x1d67b
movl %eax, %edx
xorl %eax, %eax
jmp 0x1697... | /binji[P]binjgb/src/emulator.c |
mbc3_read_ext_ram | static u8 mbc3_read_ext_ram(Emulator* e, MaskedAddress addr) {
if (!MMAP_STATE.ext_ram_enabled) {
return INVALID_READ_BYTE;
}
Mbc3* mbc3 = &MMAP_STATE.mbc3;
if (mbc3->rtc_reg <= 3) {
return gb_read_ext_ram(e, addr);
}
if (!mbc3->latched) {
return INVALID_READ_BYTE;
}
u8 result = INVALID_R... | movb $-0x1, %al
cmpl $0x0, 0x307c(%rdi)
je 0x16678
movzbl 0x3098(%rdi), %ecx
cmpl $0x3, %ecx
ja 0x16651
movzwl %si, %esi
jmp 0x161c9
cmpl $0x0, 0x30a0(%rdi)
je 0x16678
addl $-0x8, %ecx
cmpl $0x4, %ecx
ja 0x16678
leaq 0x3797(%rip), %rax # 0x19e00
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0x3080(%rd... | /binji[P]binjgb/src/emulator.c |
mbc3_write_ext_ram | static void mbc3_write_ext_ram(Emulator* e, MaskedAddress addr, u8 value) {
if (!MMAP_STATE.ext_ram_enabled) {
return;
}
Mbc3* mbc3 = &MMAP_STATE.mbc3;
if (mbc3->rtc_reg <= 3) {
gb_write_ext_ram(e, addr, value);
return;
}
if (!mbc3->latched) {
return;
}
switch (mbc3->rtc_reg) {
ca... | cmpl $0x0, 0x307c(%rdi)
je 0x1678f
movzbl 0x3098(%rdi), %eax
cmpl $0x3, %eax
ja 0x166d8
movzwl %si, %esi
movzbl %dl, %edx
jmp 0x16223
cmpl $0x0, 0x30a0(%rdi)
je 0x1678f
addl $-0x8, %eax
cmpl $0x4, %eax
ja 0x1678f
leaq 0x371c(%rip), %rcx # 0x19e14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andb $0x3f, %d... | /binji[P]binjgb/src/emulator.c |
joypad_delete | void joypad_delete(JoypadBuffer* buffer) {
if (!buffer) {
return;
}
JoypadChunk* current = buffer->sentinel.next;
while (current != &buffer->sentinel) {
JoypadChunk* next = current->next;
xfree(current->data);
xfree(current);
current = next;
}
xfree(buffer);
} | testq %rdi, %rdi
je 0x16e78
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq %rdi, %r14
je 0x16e6b
movq (%r14), %rdi
movq 0x18(%r14), %r15
callq 0x7030
movq %r14, %rdi
callq 0x7030
movq %r15, %r14
cmpq %rbx, %r15
jne 0x16e4f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7030
retq
| /binji[P]binjgb/src/joypad.c |
joypad_get_next_state | JoypadStateIter joypad_get_next_state(JoypadStateIter iter) {
size_t index = iter.state - iter.chunk->data;
if (index + 1 < iter.chunk->size) {
++iter.state;
return iter;
}
iter.chunk = iter.chunk->next;
iter.state = iter.chunk->size != 0 ? iter.chunk->data : NULL;
return iter;
} | movq %rdi, %rax
movq %rsi, %rcx
subq (%rdi), %rcx
sarq $0x4, %rcx
incq %rcx
cmpq 0x8(%rdi), %rcx
jae 0x1717b
movq %rsi, %rdx
addq $0x10, %rdx
retq
movq 0x18(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x1718a
movq (%rax), %rdx
retq
xorl %edx, %edx
retq
| /binji[P]binjgb/src/joypad.c |
joypad_init_file_data | void joypad_init_file_data(JoypadBuffer* buffer, FileData* file_data) {
file_data->size = joypad_file_size(buffer);
file_data->data = xmalloc(file_data->size);
} | pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rcx
cmpq %rdi, %rcx
je 0x171ef
movq %rdi, %rax
xorl %edi, %edi
movq 0x8(%rcx), %rdx
movq 0x18(%rcx), %rcx
shlq $0x4, %rdx
addq %rdx, %rdi
cmpq %rax, %rcx
jne 0x171d9
jmp 0x171f1
xorl %edi, %edi
movq %rdi, 0x8(%rbx)
callq 0x71c0
movq %rax, (%rbx)
popq %rbx
retq
| /binji[P]binjgb/src/joypad.c |
insert_heap | void insert_heap(U32Pair* min_heap, u32 index, u32 value, u32 count) {
min_heap[index].value = value;
min_heap[index].count = count;
while (index > 0) {
u32 parent = (index - 1) / 2;
if (min_heap[parent].count <= min_heap[index].count) {
break;
}
swap_pair(&min_heap[parent], &min_heap[index]... | movl %esi, %eax
movl %edx, (%rdi,%rax,8)
movl %ecx, 0x4(%rdi,%rax,8)
testl %esi, %esi
je 0x17c19
leal -0x1(%rsi), %eax
shrl %eax
movl 0x4(%rdi,%rax,8), %ecx
movl %esi, %r8d
movl 0x4(%rdi,%r8,8), %edx
cmpl %edx, %ecx
jbe 0x17c15
movq (%rdi,%rax,8), %rsi
movq (%rdi,%r8,8), %r9
movq %r9, (%rdi,%rax,8)
movq %rsi, (%rdi,%r8... | /binji[P]binjgb/src/tester.c |
mcbsp_qsize | void mcbsp_qsize( mcbsp_nprocs_t * packets,
mcbsp_size_t * total_size )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_qsize: can only be called within SPMD section\n");
if ( packets == NULL || total_size == NULL )
bsp_abort("bsp_qsize: both arguments may not be... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf7b6(%rip), %rax # 0x172d8
testq %rax, %rax
je 0x7b2d
cmpb $0x1, 0x8(%rax)
jne 0x7b3b
leaq 0x974b(%rip), %rdi # 0x1127f
xorl %eax, %eax
callq 0x5e91
testq %r14, %r14
setne %al
testq %rbx, %rbx
setne %cl
testb %cl, %al
jne 0x7b59
leaq 0x97... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
Lesson::Lesson(unsigned long, bool, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char,... | Lesson(size_t lesson_id = 0, bool exist = false, bool doubled = false, bool moveable = false, std::string subject = "" ,std::string room = "", std::string professor = "", std::string time = "") :
lesson_id(lesson_id),
doubled(doubled),
moveable(moveable),
exist(exist),
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %r9, -0x70(%rbp)
movl %r8d, %eax
movq %rsi, %r8
movq -0x70(%rbp), %rsi
movq %r8, -0x68(%rbp)
movq %rdi, %r8
movq -0x68(%rbp), %rdi
movq 0x20(%rbp), %r9
movq %r9, -0x60(%rbp)
movq 0x18(%rbp), %r9
movq %r9, -0x58(%rbp)
movq 0x10(%rbp), %r9
movq %r9, -0x40(%rbp)
movq %r8, -... | /samoyl11[P]Optimize_annealing/lesson.h |
Professor::Professor(std::vector<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>>>>) | Professor(std::vector<std::string> data) {
prep_id = std::stoi(data[0]);
name = data[1];
surname = data[2];
middle_name = data[3];
knowledge = std::stoi(data[4]);
skill = std::stoi(data[5]);
social = std::stoi(data[6]);
loyality = std::stoi(data[7]);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x31370
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0x31370
movq -0x40(%rbp), %rdi
addq $0x48... | /samoyl11[P]Optimize_annealing/prep.h |
get_bool | static bool get_bool(char const *value)
{
return streq(value, "true") ? true
: streq(value, "false") ? false
: atoi(value);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x9f25(%rip), %rsi # 0xf99a
callq 0x46b0
testl %eax, %eax
je 0x5aa0
leaq 0x9f1a(%rip), %rsi # 0xf99f
movq %rbx, %rdi
callq 0x46b0
testl %eax, %eax
je 0x5aa4
movq %rbx, %rdi
callq 0x4780
testl %eax, %eax
setne %al
jmp 0x5aa6
movb $0x1, %al
jmp 0x5aa6
xorl %eax, %eax
popq %rbx
re... | /guzmandrade[P]allegro5/tests/test_driver.c |
get_blend_factor | static int get_blend_factor(char const *value)
{
return streq(value, "ALLEGRO_ZERO") ? ALLEGRO_ZERO
: streq(value, "ALLEGRO_ONE") ? ALLEGRO_ONE
: streq(value, "ALLEGRO_ALPHA") ? ALLEGRO_ALPHA
: streq(value, "ALLEGRO_INVERSE_ALPHA") ? ALLEGRO_INVERSE_ALPHA
: streq(value, "ALLEGRO_SRC_COLOR") ?... | pushq %rbx
movq %rdi, %rbx
leaq 0x5234(%rip), %rsi # 0x126da
callq 0x46b0
testl %eax, %eax
je 0xd577
leaq 0x522d(%rip), %rsi # 0x126e7
movq %rbx, %rdi
callq 0x46b0
testl %eax, %eax
je 0xd57b
leaq 0x5222(%rip), %rsi # 0x126f3
movq %rbx, %rdi
callq 0x46b0
testl %eax, %eax
je 0xd582
leaq 0x5219(%rip), %rsi ... | /guzmandrade[P]allegro5/tests/test_driver.c |
reserve_local_bitmap | static ALLEGRO_BITMAP **reserve_local_bitmap(const char *name, BmpType bmp_type)
{
int i;
for (i = num_global_bitmaps; i < MAX_BITMAPS; i++) {
if (!bitmaps[i].name) {
bitmaps[i].name = al_ustr_new(name);
return &bitmaps[i].bitmap[bmp_type];
}
}
fatal_error("bitmap limit reach... | pushq %r14
pushq %rbx
pushq %rax
movslq 0xabb0(%rip), %rax # 0x18600
cmpq $0x7f, %rax
jg 0xda7a
movl %esi, %ebx
leaq (%rax,%rax,2), %rcx
leaq 0x8add(%rip), %rdx # 0x16540
leaq (%rdx,%rcx,8), %r14
addq $-0x80, %rax
cmpq $0x0, (%r14)
je 0xda88
addq $0x18, %r14
incq %rax
jne 0xda6b
leaq 0x1c02(%rip), %rdi #... | /guzmandrade[P]allegro5/tests/test_driver.c |
fill_lock_region | static void fill_lock_region(LockRegion *lr, float alphafactor, bool blended)
{
int x, y;
float r, g, b, a;
ALLEGRO_COLOR c;
for (y = 0; y < lr->h; y++) {
for (x = 0; x < lr->w; x++) {
/* -1 to make the last pixel use the full color, allows easier
* manual inspection of the test re... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0x8(%rsp)
cmpl $0x0, 0x9512(%rip) # 0x1714c
jle 0xdce2
movl %edi, %ebx
xorl %ebp, %ebp
movl 0x94fe(%rip), %eax # 0x17148
testl %eax, %eax
jle 0xdcd4
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm... | /guzmandrade[P]allegro5/tests/test_driver.c |
get_font_align | static int get_font_align(char const *value)
{
return streq(value, "ALLEGRO_ALIGN_LEFT") ? ALLEGRO_ALIGN_LEFT
: streq(value, "ALLEGRO_ALIGN_CENTRE") ? ALLEGRO_ALIGN_CENTRE
: streq(value, "ALLEGRO_ALIGN_RIGHT") ? ALLEGRO_ALIGN_RIGHT
: streq(value, "ALLEGRO_ALIGN_INTEGER") ? ALLEGRO_ALIGN_INTEGER
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4f5d(%rip), %rsi # 0x12cc1
callq 0x46b0
testl %eax, %eax
je 0xddf6
leaq 0x4f5c(%rip), %rsi # 0x12cd4
movq %rbx, %rdi
callq 0x46b0
testl %eax, %eax
je 0xddfa
leaq 0x4f5e(%rip), %rsi # 0x12ce9
movq %rbx, %rdi
callq 0x46b0
testl %eax, %eax
je 0xde01
le... | /guzmandrade[P]allegro5/tests/test_driver.c |
hash_bitmap | static uint32_t hash_bitmap(ALLEGRO_BITMAP *bmp)
{
ALLEGRO_LOCKED_REGION *lr;
int x, y, w, h;
uint32_t hash;
w = al_get_bitmap_width(bmp);
h = al_get_bitmap_height(bmp);
hash = FNV_OFFSET_BASIS;
lr = al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ABGR_8888_LE,
ALLEGRO_LOCK_READONLY);
for (y =... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x4970
movl %eax, %ebp
movq %rbx, %rdi
callq 0x46f0
movl %eax, %r14d
movq %rbx, %rdi
movl $0x19, %esi
movl $0x1, %edx
callq 0x4300
testl %r14d, %r14d
jle 0xe365
movq (%rax), %rcx
movslq 0xc(%rax), %rax
movl %r14d, %edx
movl %ebp, %esi
addq $0x3, %rcx
movl $0x811c9d... | /guzmandrade[P]allegro5/tests/test_driver.c |
similar_signatures | static bool similar_signatures(char const sig1[SIG_LEN], char const sig2[SIG_LEN])
{
int correct = 0;
int i;
for (i = 0; i < SIG_LEN; i++) {
int q1 = base64_decode(sig1[i]);
int q2 = base64_decode(sig2[i]);
/* A difference of one quantisation level could be because two values
* which... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe523
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0xe523
subl %eax, %ebp
movl %ebp, %eax
negl %eax
cmovsl %ebp, %eax
cmpl $0x1, %eax
ja 0xe512
leaq 0x1(%r15), %rcx
cmpq $0x50, %r15... | /guzmandrade[P]allegro5/tests/test_driver.c |
Curl_base64_decode | CURLcode Curl_base64_decode(const char *src,
unsigned char **outptr, size_t *outlen)
{
size_t srclen = 0;
size_t length = 0;
size_t padding = 0;
size_t i;
size_t numQuantums;
size_t rawlen = 0;
unsigned char *pos;
unsigned char *newstr;
*outptr = NULL;
*outlen = 0;
src... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, (%rdx)
callq 0x9450
movq %rax, %r12
testq %rax, %rax
sete %dl
testb $0x3, %r12b
setne %cl
movl $0x3d, %eax
orb %dl, %cl
jne 0xafe4
xorl %esi, %e... | /devkitPro[P]curl/lib/base64.c |
base64_encode | static CURLcode base64_encode(const char *table64,
struct Curl_easy *data,
const char *inputbuff, size_t insize,
char **outptr, size_t *outlen)
{
CURLcode result;
unsigned char ibuf[3];
unsigned char obuf[4];
int i;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
xorl %eax, %eax
movq %rax, (%rcx)
movq %rax, (%r8)
testq %rdx, %rdx
jne 0xb031
movq %r15, %rdi
callq 0x9450
movq %rax, %r13
leaq (,%r13,4), %rax
movabsq $-0x5... | /devkitPro[P]curl/lib/base64.c |
Curl_printable_address | const char *
Curl_printable_address(const Curl_addrinfo *ai, char *buf, size_t bufsize)
{
const struct sockaddr_in *sa4;
const struct in_addr *ipaddr4;
#ifdef ENABLE_IPV6
const struct sockaddr_in6 *sa6;
const struct in6_addr *ipaddr6;
#endif
switch(ai->ai_family) {
case AF_INET:
sa4 = (const void *... | movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rax
movl 0x4(%rdi), %edi
cmpl $0x2, %edi
je 0xb1dd
cmpl $0xa, %edi
jne 0xb1eb
movl $0x8, %esi
jmp 0xb1e2
movl $0x4, %esi
addq 0x20(%rax), %rsi
jmp 0x2e9d4
xorl %eax, %eax
retq
| /devkitPro[P]curl/lib/hostip.c |
Curl_fetch_addr | struct Curl_dns_entry *
Curl_fetch_addr(struct connectdata *conn,
const char *hostname,
int port)
{
struct Curl_easy *data = conn->data;
struct Curl_dns_entry *dns = NULL;
if(data->share)
Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
dns = fetch_addr(c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
cmpq $0x0, 0xd0(%rbx)
je 0xb2ad
movq %rbx, %rdi
movl $0x3, %esi
movl $0x2, %edx
callq 0x2e2da
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xb2eb
movq %rax, %r14
testq %rax, %rax
je 0xb2c6
i... | /devkitPro[P]curl/lib/hostip.c |
Curl_cache_addr | struct Curl_dns_entry *
Curl_cache_addr(struct Curl_easy *data,
Curl_addrinfo *addr,
const char *hostname,
int port)
{
char entry_id[MAX_HOSTCACHE_LEN];
size_t entry_len;
struct Curl_dns_entry *dns;
struct Curl_dns_entry *dns2;
#ifndef CURL_DISABLE_SHUFFLE_DNS
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
testb $0x4, 0xf66(%rdi)
je 0xb572
xorl %r12d, %r12d
testq %r15, %r15
je 0xb43a
movq %r15, %rax
movq 0x28(%rax), %rax
incl %r12d
testq %rax, %rax
jn... | /devkitPro[P]curl/lib/hostip.c |
Curl_resolv_check | CURLcode Curl_resolv_check(struct connectdata *conn,
struct Curl_dns_entry **dns)
{
#if defined(CURL_DISABLE_DOH) && !defined(CURLRES_ASYNCH)
(void)dns;
#endif
if(conn->data->set.doh)
return Curl_doh_is_resolved(conn, dns);
return Curl_resolver_is_resolved(conn, dns);
} | movq (%rdi), %rax
testb $-0x80, 0xf66(%rax)
je 0x3a29d
jmp 0x44a6a
| /devkitPro[P]curl/lib/hostip.c |
Curl_resolv_timeout | enum resolve_t Curl_resolv_timeout(struct connectdata *conn,
const char *hostname,
int port,
struct Curl_dns_entry **entry,
timediff_t timeoutms)
{
#ifdef USE_ALARM_TIMEOUT
#ifdef ... | movq $0x0, (%rcx)
testq %r8, %r8
js 0xb934
movq %rcx, %rax
movl $0x1, %ecx
movq %rax, %r8
jmp 0xb67f
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /devkitPro[P]curl/lib/hostip.c |
Curl_pgrsResetTransferSizes | void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
{
if(size >= 0) {
data->progress.size_dl = size;
data->progress.flags |= PGRS_DL_SIZE_KNOWN;
}
else {
data->progress.size_dl = 0;
data->progress.flags &= ~PGRS_DL_SIZE_KNOWN;
}
} | xorps %xmm0, %xmm0
movups %xmm0, 0xfa0(%rdi)
andb $-0x61, 0xfcc(%rdi)
retq
| /devkitPro[P]curl/lib/progress.c |
Curl_pgrsSetDownloadSize | void Curl_pgrsSetDownloadSize(struct Curl_easy *data, curl_off_t size)
{
if(size >= 0) {
data->progress.size_dl = size;
data->progress.flags |= PGRS_DL_SIZE_KNOWN;
}
else {
data->progress.size_dl = 0;
data->progress.flags &= ~PGRS_DL_SIZE_KNOWN;
}
} | testq %rsi, %rsi
js 0xc6a4
movq %rsi, 0xfa0(%rdi)
movl 0xfcc(%rdi), %eax
orl $0x40, %eax
jmp 0xc6b8
movq $0x0, 0xfa0(%rdi)
movl 0xfcc(%rdi), %eax
andl $-0x41, %eax
movl %eax, 0xfcc(%rdi)
retq
| /devkitPro[P]curl/lib/progress.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.