name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::MarkAsIgnored::MarkAsIgnored(char const*) | MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
GetIgnoredParameterizedTestSuites()->insert(test_suite);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
callq 0x176be
movl $0x130, %r14d # imm = 0x130
addq 0x3bae8(%rip), %r14 # 0x537d8
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3061e
movq %r14, %rdi
movq %r15, %rsi
callq 0... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations() | void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
const auto& ignored = *GetIgnoredParameterizedTestSuites();
for (const auto& testcase : suites_) {
if (testcase.second.instantiated) continue;
if (ignored.find(testcase.first) != ignored.end()) continue;
std::string message =
"... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %r15
callq 0x176be
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x18d4a
movq 0x3afd0(%rip), %rax # 0x537d8
leaq 0x130(%rax), %rcx
movq %rcx, -0x138(%rbp)
addq $0x138, %... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::UnitTestFilter::UnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit UnitTestFilter(const std::string& filter) {
// By design "" filter matches "" string.
std::vector<std::string> all_patterns;
SplitString(filter, ':', &all_patterns);
const auto exact_match_patterns_begin = std::partition(
all_patterns.begin(), all_patterns.end(), &IsGlobPattern);
g... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0x18(%rdi), %r14
leaq 0x48(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq $0x1, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movl $0x3f8000... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::UnitTestFilter::MatchesName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool MatchesName(const std::string& name) const {
return exact_match_patterns_.count(name) > 0 ||
std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
[&name](const std::string& pattern) {
return PatternMatchesString(
name,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x18, %rdi
callq 0x35b20
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x19d86
movq (%r15), %rbx
movq 0x8(%r15), %rcx
movq %r14, -0x38(%rbp)
movq %rcx, %r12
subq %rbx, %r12
movq... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestOptions::FilterMatchesTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
const std::string& test_name) {
// Split --gtest_filter at '-', if there is one, to separate into
// positive filter and negative filter portions
return PositiveAndNegativeUnitTestFilter(GTEST_FLAG_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
callq 0x19e20
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1a2ec
movl %eax, %ebx
leaq -0x68(%rbp), %r14
leaq -0x50(%rbp), %rdi
callq 0x35a9e
movq %r14, %rdi
call... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_repor... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x378a2(%rip), %rax # 0x51e10
movq %rax, (%rdi)
callq 0x176be
movq 0x3925b(%rip), %rdi # 0x537d8
cmpl $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rbx
jne 0x1a591
movq %rbx, %rsi
callq 0x1a522
jmp 0x1a5a0
addq $0x90, %rdi
callq 0x39610
movq %rbx, (%rax)... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::DefaultGlobalTestPartResultReporter::ReportTestPartResult(testing::TestPartResult const&) | void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
const TestPartResult& result) {
unit_test_->current_test_result()->AddTestPartResult(result);
unit_test_->listeners()->repeater()->OnTestPartResult(result);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x170(%rax), %rdi
testq %rdi, %rdi
je 0x1aa5c
addq $0x90, %rdi
jmp 0x1aa7a
movq 0x168(%rax), %rdi
testq %rdi, %rdi
je 0x1aa71
addq $0x88, %rdi
jmp 0x1aa7a
addq $0x178, %rax # imm = 0x178
movq %rax, %rdi... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestSuite::failed_test_count() const | int TestSuite::failed_test_count() const {
return CountIf(test_info_list_, TestFailed);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0x1ae4f
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%r15), %rdi
cmpb $0x1, 0x80(%rdi)
movl $0x0, %eax
jne 0x1ae40
addq $0x90, %rdi
callq 0x1e7fc
movzbl %al, %eax
addl %eax, %r14d
addq $0x8, %r15
cmpq 0x38(%... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x210(%rdi)
jne 0x1b194
movl $0x8, %edi
callq 0x84a0
leaq 0x37336(%rip), %rcx # 0x524c0
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
movq 0x210(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator<<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %r12
testq %r12, %r12
je 0x1b433
movq (%rsi), %r13
xorl %r15d, %r15d
leaq -0x48(%rbp), %r14
cmpl $0x0, (%r13,%r15,4)
je 0x1b40f
leaq (,%r15,4), %rsi
addq %r13, %rsi
movl %r12d, %edx
subl %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*) | std::string StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
std::string result;
result.reserve(static_cast<size_t>(2 * (end - start)));
for (const char* ch = start; ch != end; ++ch) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x18, %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x88c0
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*) | void PushLine(char edit, const char* line) {
switch (edit) {
case ' ':
++common_;
FlushEdits();
hunk_.push_back(std::make_pair(' ', line));
break;
case '-':
++removes_;
hunk_removes_.push_back(std::make_pair('-', line));
break;
case '+':
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x1c198
cmpl $0x2b, %r15d
je 0x1c186
cmpl $0x20, %r15d
jne 0x1c1cc
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x2e9b2
movl $0x38, %r13d
movl $0x28, %r12d
jmp 0x1c1... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(bool, char const*, char const*, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::__cxx11::basic_string<wch... | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
const char* needle_expr,
const char* haystack_expr,
const StringType& needle,
const StringType& haystack) {
if (IsSubstringPred... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, %r13
movl %esi, %r12d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq 0x8(%r8), %rcx
movq %r9, %rdi
xorl %edx, %edx
callq 0x8970
cmpq $-0x1, %rax
setne %al
xorb... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::String::FormatHexUInt32[abi:cxx11](unsigned int) | std::string String::FormatHexUInt32(uint32_t value) {
std::stringstream ss;
ss << std::hex << std::uppercase << value;
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x8340
leaq -0x188(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl -0x170(%rbp,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, -0x170(%rbp,%rcx)
mo... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTRNE(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
const char* s2_expression, const wchar_t* s1,
const wchar_t* s2) {
if (!String::WideCStringEquals(s1, s2)) {
return AssertionSuccess();
}
return AssertionFailure()
<< "Expected: ("... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x30(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1dc89
testq %r8, %r8
je 0x1dd83
movq %rcx, %rdi
movq %r8, %rsi
callq 0x86c0
testl %eax, %e... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::String::FormatByte[abi:cxx11](unsigned char) | std::string String::FormatByte(unsigned char value) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
<< static_cast<unsigned int>(value);
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1a0(%rbp), %r15
movq %r15, %rdi
callq 0x8340
movq 0x10(%r15), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %r15
addq $-0x190, %r15 # imm = 0xFE70
cmpb $0x0, 0xe1(%r1... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestResult::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | void TestResult::RecordProperty(const std::string& xml_element,
const TestProperty& test_property) {
if (!ValidateTestProperty(xml_element, test_property)) {
return;
}
internal::MutexLock lock(&test_properties_mutex_);
const std::vector<TestProperty>::iterator property_with_m... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1e320
testb %al, %al
je 0x1e2a9
movq %rbx, %rdi
callq 0x35d68
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r12
movq (%r14), %rsi
leaq -0x50(%rbp), %rdi
le... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestResult::ValidateTestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::TestProperty const&) | bool TestResult::ValidateTestProperty(const std::string& xml_element,
const TestProperty& test_property) {
return ValidateTestPropertyName(test_property.key(),
GetReservedAttributesForElement(xml_element));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0x31(%rbp), %rdx
callq 0x3061e
leaq 0x20bf7(%rip), %rsi # 0x3ef48
movq %rbx, %rdi
callq 0x8170
testl %eax, %eax
je 0x1e406
leaq 0x20ac7(%rip), %rsi # ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestResult::Clear() | void TestResult::Clear() {
test_part_results_.clear();
test_properties_.clear();
death_test_count_ = 0;
elapsed_time_ = 0;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x38(%rbx), %rsi
callq 0x39f52
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x3a4b0
movl $0x0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestResult::Skipped() const | bool TestResult::Skipped() const {
return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1e7fc
testb %al, %al
je 0x1e7cc
xorl %eax, %eax
jmp 0x1e7f4
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x1e7f4
xorl %esi, %esi
cmpl $0x3, (%rcx)
sete %sil
addl %esi, %eax
addq $0x70, %rcx
cmpq %rdx, %rcx
jne 0x1... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::GoogleTestFailureException::GoogleTestFailureException(testing::TestPartResult const&) | GoogleTestFailureException::GoogleTestFailureException(
const TestPartResult& failure)
: ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x1eef9
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x8a30
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eec2
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x84d0
leaq 0x3390f(%rip),... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::PrintTestPartResultToString[abi:cxx11](testing::TestPartResult const&) | static std::string PrintTestPartResultToString(
const TestPartResult& test_part_result) {
return (Message() << internal::FormatFileLocation(
test_part_result.file_name(),
test_part_result.line_number())
<< " "
<< TestPar... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1b1fc
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x1ef26
movq 0x8(%r15), %rsi
movl 0x28(%r15), %edx
leaq -0x50(%rbp), %rdi
callq 0x14fa4
movq -0x30(%rbp), %r14... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::Test::HasFatalFailure() | bool Test::HasFatalFailure() {
return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
} | pushq %rbp
movq %rsp, %rbp
callq 0x176be
movq 0x34670(%rip), %rcx # 0x537d8
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x1f17c
addq $0x90, %rax
jmp 0x1f19a
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x1f190
addq $0x88, %rax
jmp 0x1f19a
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::Test::HasNonfatalFailure() | bool Test::HasNonfatalFailure() {
return internal::GetUnitTestImpl()
->current_test_result()
->HasNonfatalFailure();
} | pushq %rbp
movq %rsp, %rbp
callq 0x176be
movq 0x345ba(%rip), %rcx # 0x537d8
movq 0x170(%rcx), %rax
testq %rax, %rax
je 0x1f232
addq $0x90, %rax
jmp 0x1f250
movq 0x168(%rcx), %rax
testq %rax, %rax
je 0x1f246
addq $0x88, %rax
jmp 0x1f250
addq $0x178, %rcx # imm = 0x178
movq %rcx, %rax
movq 0x38(%rax), %rcx... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestInfo::~TestInfo() | TestInfo::~TestInfo() { delete factory_; } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
testq %rdi, %rdi
je 0x1f4b0
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x90(%rbx), %r14
leaq 0xe0(%rbx), %rdi
callq 0x325c0
leaq 0xc8(%rbx), %rdi
callq 0x325fe
movq %r14, %rdi
callq 0x3263c
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cm... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation) | void ReportInvalidTestSuiteType(const char* test_suite_name,
CodeLocation code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class.... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1b1fc
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x1f200(%rip), %rsi # 0x3e92f
movl $0x25, %edx
movq %r15, %rdi
callq 0x85a0
testq %r12, %r12
je 0x... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestInfo::Skip() | void TestInfo::Skip() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test event listeners that a test is about to start.
re... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x1fc7c
movq %rdi, %rbx
callq 0x176be
movq 0x33c1f(%rip), %r15 # 0x537d8
movq %rbx, 0x170(%r15)
callq 0x176be
movq 0x33c0c(%rip), %rax # 0x537d8
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestSuite::TestSuite(char const*, char const*, void (*)(), void (*)()) | TestSuite::TestSuite(const char* a_name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc)
: name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
set_up_tc_(set_up_tc),
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x32209(%rip), %rax # 0x51ec8
movq %rax, (%rdi)
addq $0x8, %rdi
leaq -0x29(%rbp), %rdx
callq 0x3061e
testq %r12, %r12
je 0x1fd02
movl $0x20, %edi
callq 0x8... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestSuite::~TestSuite() | TestSuite::~TestSuite() {
// Deletes every Test in the collection.
ForEach(test_info_list_, internal::Delete<TestInfo>);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x320e1(%rip), %rax # 0x51ec8
movq %rax, (%rdi)
movq 0x30(%rdi), %r15
movq 0x38(%rdi), %r12
cmpq %r12, %r15
je 0x1fe1a
movq (%r15), %r14
testq %r14, %r14
je 0x1fe14
movq %r14, %rdi
callq 0x1f494
movl $0x110, %esi ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestSuite::GetMutableTestInfo(int) | TestInfo* TestSuite::GetMutableTestInfo(int i) {
const int index = GetElementOr(test_indices_, i, -1);
return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
} | pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x1ff2f
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x1ff2f
movl %esi, %eax
movl (%rcx,%rax,4), %eax
testl %eax, %eax
js 0x1ff3f
movl %eax, %eax
movq 0x30(%rdi), %rcx
movq (... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestSuite::Skip() | void TestSuite::Skip() {
if (!should_run_) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Call both legacy and the new API
repeater->OnTestSuiteStart(*this);
//... | cmpb $0x1, 0x70(%rdi)
jne 0x203f4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x176be
movq 0x3349c(%rip), %r15 # 0x537d8
movq %rbx, 0x168(%r15)
callq 0x176be
movq 0x33489(%rip), %rax # 0x537d8
movq 0x1f8(%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG_GET(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
std::string f = GTEST_FLAG_GET(filter);
const char* const filter = f.c_str();
// Prints the filt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x32f75(%rip) # 0x53720
je 0x207bf
incl %edx
leaq 0x1e364(%rip), %rdi # 0x3eb1a
movl %edx, %esi
xorl %eax, %eax
callq 0x8080
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x32f02(%rip), %rsi # 0x536d... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
static const bool in_color_mode =
#if GTEST_HAS_FILE_SYSTEM
ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
#else
false;
#endif // GTEST_HAS_FILE_SYSTEM
const bool use_color = in_colo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq -0xf0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x20a28
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
m... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env, const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromEnvOrDie(shard_ind... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %edx, %edx
jne 0x20b9f
movq %rsi, %r14
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x20f96
movl %eax, %ebx
movq %r14, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x20f96
movl %eax, %r14d
andl %ebx, %eax
cmpl $-0x... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::FormatCountableNoun[abi:cxx11](int, char const*, char const*) | static std::string FormatCountableNoun(int count, const char* singular_form,
const char* plural_form) {
return internal::StreamableToString(count) + " " +
(count == 1 ? singular_form : plural_form);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x24(%rbp), %rax
movl %esi, (%rax)
leaq -0x68(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3074a
leaq 0x1d2b3(%rip), %rsi # 0x3e4c5
movq %r12, %rdi
callq 0x8a40
leaq -... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x213ef
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdi
callq 0x213f0
movq 0x31b9a(%rip), %rax # 0x52f80
movq (%rax), %rdi
popq %rbp
jmp 0x85f0
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG_GET(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s (%s ms total)\n\n", ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x32137(%rip) # 0x53719
jne 0x216ae
movq %rsi, %rbx
movq 0x30(%rsi), %rax
movq 0x38(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x2160c
movq (%rax), %rdx
movzbl 0x80(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x215f5
lea... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::UnitTest::GetTestSuite(int) const | inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
: v[static_cast<size_t>(i)];
} | testl %esi, %esi
js 0x2197c
pushq %rbp
movq %rsp, %rbp
movq 0x40(%rdi), %rax
movq 0xd0(%rax), %rcx
movq 0xd8(%rax), %rdx
subq %rcx, %rdx
shrq $0x2, %rdx
cmpl %esi, %edx
jle 0x21978
movl %esi, %edx
cmpl $0x0, (%rcx,%rdx,4)
js 0x21978
movq 0xb8(%rax), %rax
movq (%rax,%rdx,8), %rax
jmp 0x2197a
xorl %eax, %eax
popq %rbp
re... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::BriefUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void BriefUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this ... | cmpl $0x0, (%rsi)
je 0x21f41
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdi
callq 0x213f0
movq 0x31048(%rip), %rax # 0x52f80
movq (%rax), %rdi
popq %rbp
jmp 0x85f0
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::Release(testing::TestEventListener*) | TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
for (size_t i = 0; i < listeners_.size(); ++i) {
if (listeners_[i] == listener) {
listeners_.erase(listeners_.begin() + static_cast<int>(i));
return listener;
}
}
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
je 0x22393
movq %rsi, %rbx
sarq $0x3, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movabsq $0x100000000, %rsi # imm = 0x100000000
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rbx, (%rdi,%r8... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::OnTestIterationEnd(testing::UnitTest const&, int) | void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
int iteration) {
if (forwarding_enabled_) {
for (size_t i = listeners_.size(); i > 0; i--) {
listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
}
}
} | cmpb $0x1, 0x8(%rdi)
jne 0x22899
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movq 0x18(%rdi), %r12
subq 0x10(%rdi), %r12
je 0x22891
movl %edx, %ebx
movq %rsi, %r14
sarq $0x3, %r12
movq 0x10(%r15), %rax
movq -0x8(%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestsList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::PrintXmlTestsList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
int total_tests = 0;
for (auto test_suite : test_s... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bc92(%rip), %rsi # 0x3ef48
leaq 0x1bc95(%rip), %rdx # 0x3ef52
leaq -0x90(%rbp), %rdi
callq 0x380d6
leaq 0x1bc83(%rip), %rsi ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))
output.push_back(*it);
re... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x88a0
cmpq $0x0, 0x8(%r14)
je 0x237ad
movq (%r14), %r12
movl $0x2600, %r13d ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss.sss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rsi, %r14
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
movq %rsi, %rax
imulq %rcx
movq %rdx, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r15
addq %rax,... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcas... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x192f5(%rip), %rsi # 0x3ee74
leaq 0x192f6(%rip), %rdx # 0x3ee7c
leaq -0x90(%rbp), %rdi
callq 0x380d6
cmpb $0x0, 0... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&) | void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
OutputJsonKey(stream, kTestsuites, "tests", unit_test.rep... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x17fea(%rip), %rsi # 0x3ef48
leaq 0x17fed(%rip), %rdx # 0x3ef52
leaq -0xb0(%rbp), %rdi
callq 0x380d6
leaq -0x60(%rbp), %rax
movq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.push_back('%');
result.append(String::FormatByt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x8200
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x88a0
mova... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::OsStackTraceGetter::CurrentStackTrace[abi:cxx11](int, int) | GTEST_LOCK_EXCLUDED_(mutex_) {
#ifdef GTEST_HAS_ABSL
std::string result;
if (max_depth <= 0) {
return result;
}
max_depth = std::min(max_depth, kMaxStackTraceDepth);
std::vector<void*> raw_stack(max_depth);
// Skips the frames requested by the caller, plus this function.
const int raw_stack_size =
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x138d1(%rip), %rdx # 0x3ec78
movq %rdx, %rsi
callq 0x380d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::UnitTest::Failed() const | bool UnitTest::Failed() const { return impl()->Failed(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rbx
movq %rbx, %rdi
callq 0x1ab88
testl %eax, %eax
jle 0x2b601
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e7fc
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != nullptr) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_tes... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq $0x0, 0x170(%rdi)
je 0x2b74b
leaq 0x1374a(%rip), %rcx # 0x3ee74
leaq -0x38(%rbp), %rdi
movl $0x8, %r8d
xorl %esi, %e... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag) return true;
// Repeats the call ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x27eed(%rip), %rsi # 0x53778
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0x30b18
movq (%r14), %r15
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x30884
movb $0x1, %r14b
cmpb $0x0, 0x27df9(%rip) ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::UnitTest::current_test_case() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x35d68
movq 0x40(%rbx), %rax
movq 0x168(%rax), %rbx
movq %r14, %rdi
callq 0x35e0e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x30b01
nop
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::UnitTest::PopGTestTrace() | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
impl_->gtest_trace_stack().pop_back();
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x35d68
movl $0x248, %edi # imm = 0x248
addq 0x40(%r14), %rdi
callq 0x36520
movq 0x8(%rax), %rcx
leaq -0x30(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x20(%rcx), %rdi
addq $-0x10, %rcx
cmpq %rcx, %rdi
je ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
#if GTEST_HAS_FILE_SYSTEM
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x190ba
leaq 0x1014f(%rip), %rsi # 0x3c78c
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x2c6d8
leaq 0x12b61(%rip), %rsi # 0x3f1b5
leaq -0x58(%rbp), %rdi
callq 0x8170
tes... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x218(%rdi)
je 0x2c9be
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x218(%rdi)
leaq 0x238(%rdi), %r14
callq 0x128cb
movq %r14, %rdi
movq %rax, %rsi
callq 0x38060
cmpq $0x0, 0x238(%rbx)
je 0x2c9fb
movq 0x1f8(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x1f972
mo... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test suites.
ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
// Shuffles the non-death test suites.
ShuffleRange(random(), last_death_test_suite_ + 1,
static_cast<int>(test_suites_.size()), &test_suite_indices... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x220(%rdi), %rbx
movl 0x164(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x33d56
movl 0x164(%r14), %esi
incl %esi
movq 0xc0(%r14), %rdx
subq 0xb8(%r14), %rdx
shrq $0x3, %rdx
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ParseFlag(char const*, char const*, int*) | bool ParseFlag(const char* str, const char* flag_name, int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag_name, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
return ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
xorl %r13d, %r13d
xorl %edx, %edx
callq 0x2d845
testq %rax, %rax
je 0x2d81a
movq %rax, %r15
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1b1fc
movq (%rbx), %rbx
leaq 0x10(%rbx), %r13
leaq 0x11c... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ParseGoogleTestFlagsOnly(int*, char**) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
#ifdef GTEST_HAS_ABSL
if (*argc <= 0) return;
std::vector<char*> positional_args;
std::vector<absl::UnrecognizedFlag> unrecognized_flags;
absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
absl::flat_hash_set<absl::string_view... | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x33f68
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::InitGoogleTest() | void InitGoogleTest() {
// Since Arduino doesn't have a command line, fake out the argc/argv arguments
int argc = 1;
const auto arg0 = "dummy";
char* argv0 = const_cast<char*>(arg0);
char** argv = &argv0;
#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, ar... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdi
movl $0x1, (%rdi)
leaq 0x119e3(%rip), %rax # 0x3f431
leaq -0x10(%rbp), %rsi
movq %rax, (%rsi)
callq 0x34276
addq $0x10, %rsp
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
return GetDirFromEnv({"TEST_TMPDIR... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x119c4(%rip), %rax # 0x3f437
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x119bb(%rip), %rax # 0x3f43c
movq %rax, 0x8(%rsi)
leaq 0x119b7(%rip), %rcx # 0x3f443
movl $0x2, %edx
callq 0x2daa0
movq %rbx, %rax
addq $0x18, %rsp
popq %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::IsGlobPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool IsGlobPattern(const std::string& pattern) {
return std::any_of(pattern.begin(), pattern.end(),
[](const char c) { return c == '?' || c == '*'; });
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
leaq (%rdx,%rsi), %rax
movq %rsi, %rdi
sarq $0x2, %rdi
testq %rdi, %rdi
jle 0x2e878
andq $-0x4, %rsi
addq %rdx, %rsi
incq %rdi
addq $0x3, %rdx
movq %rdx, %rcx
movzbl -0x3(%rcx), %edx
cmpl $0x2a, %edx
je 0x2e8b5
cmpl $0x3f, %edx
je 0x2e8b5
movzbl -0x2(%rc... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::FailureTest(testing::internal::CodeLocation const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) | explicit FailureTest(const CodeLocation& loc, std::string error_message,
bool as_error)
: loc_(loc),
error_message_(std::move(error_message)),
as_error_(as_error) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1e8d6
leaq 0x239c5(%rip), %rax # 0x52680
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xb... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x23758(%rip), %rax # 0x526d8
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x2ef9b
movq (%rax), %rsi
incq %rsi
callq 0x84d0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2efb3
movq (%rax), %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::CreateTest() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x84a0
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0xbfc8
addq $0x48, %r14
leaq -0x38(%rbp), %rdx
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h |
testing::internal::ParseGoogleTestFlag(char const*) | static bool ParseGoogleTestFlag(const char* const arg) {
#define GTEST_INTERNAL_PARSE_FLAG(flag_name) \
do { \
auto value = GTEST_FLAG_GET(flag_name); \
if (ParseFlag(arg, #flag_name, &value)) { \
GTEST_FLAG_SET(flag_name, value); \
return true; ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0x23aa0(%rip), %al # 0x536ab
leaq -0x40(%rbp), %rdx
movb %al, (%rdx)
leaq 0xe369(%rip), %rsi # 0x3df81
callq 0x304b4
testb %al, %al
je 0x2fc2c
movb -0x40(%rbp), %al
movb %al, 0x23a81(%rip) # 0x536... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ParseFlag(char const*, char const*, bool*) | static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag_name, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Converts the string value to a bool.
*valu... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0x1, %edx
callq 0x2d845
testq %rax, %rax
je 0x304e3
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x304e1
cmpl $0x66, %edx
je 0x304e1
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x1b1fc
movq (%r15), %rdi
addq $0x10, %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x85a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x35cca
movq -0x20(%rbp), %rdi
t... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h |
void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in whic... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0xe071(%rip), %rsi # 0x3ec78
movq %rbx, %rdi
xorl %edx, %edx
callq 0x85a0
leaq 0xd635(%rip), %rsi # 0x3e24d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85a0
cmpl $0xd, %r14d
ja 0x30c47
movl %r14d, %e... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-printers.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [7]>(char const (&) [7]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x1b1fc
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x1b1fc
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [29]>(char const (&) [29]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x1b1fc
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85a0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h |
testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) {
#if GTEST_HAS_FILE_SYSTEM
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test progra... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x32d70
movq %r14, -0x30(%rbp)
leaq 0x10(%r12), %r13
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x12b7e
movq %r13, %rdi
movq %r14... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdi, %r14
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0xbcf0(%rip), %r13 # 0x3ec78
cmovneq %rdx, %r13
leaq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x8... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-test-part.h |
testing::TestPartResult::~TestPartResult() | class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure, // Failed and the test s... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x3303f
movq (%rax), %rsi
incq %rsi
callq 0x84d0
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x33057
movq (%rax), %rsi
incq %rsi
callq 0x84d0
movq 0x8(%rbx), %rdi
addq $0x18... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-test-part.h |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ab88
testl %eax, %eax
jle 0x332e2
xorl %eax, %eax
jmp 0x332f3
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
callq 0x1e7fc
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::TestProperty::TestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestProperty(const std::string& a_key, const std::string& a_value)
: key_(a_key), value_(a_value) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xbfc8
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(
premature_exit_filepath ? premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the file with a single "0... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xb8b3(%rip), %rax # 0x3ec78
cmoveq %rax, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x8200
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x380d6
cmpq $0x0, 0x8(%rbx)
je 0x3... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry() | ~ParameterizedTestSuiteRegistry() {
for (auto& test_suite_info : test_suite_infos_) {
delete test_suite_info;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x337d1
movq (%r14), %rdi
testq %rdi, %rdi
je 0x337cb
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x337b8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x337ef
movq 0x10(%r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x8840
testq %rax, %rax
je 0x3381d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x8610
testl %eax, %eax
je 0x3388d
movl %eax, %r14d
leaq 0xc0fb(%rip), %rdx # 0x3f92d
leaq -0x14(%r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x2, (%rdi)
jl 0x34075
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rax
movq %rax, -0x70(%rbp)
movl $0x1, %r13d
movslq %r13d,... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x1f4e4(%rip), %rsi # 0x53778
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x30b18
movq (%r15), %rbx
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0x30884
cmpq %r12, %rbx
jne 0x34347
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher() | class GTEST_API_ Matcher<const internal::StringView&>
: public internal::MatcherBase<const internal::StringView&> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<const internal::StringView&>(impl) {}
template <typename... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3846a
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x84d0
nop
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::~Matcher() | class GTEST_API_ Matcher<internal::StringView>
: public internal::MatcherBase<internal::StringView> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<internal::StringView>(impl) {}
explicit Matcher(const MatcherInterface<... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x384c8
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x84d0
nop
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x34d66
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34d4e
cmpq $0x0, 0x18(%rax)
je 0x34d4e
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x34d4e
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %r... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(nullptr);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
if (file == nullptr) {
GT... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x34fca
xorl %edi, %edi
callq 0x85f0
movl (%r15), %esi
movl 0x4(%r15), %edi
callq 0x8460
movl 0x4(%r15), %edi
callq 0x8a60
movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF
movq 0x8(%r15), %rdi
... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-port.cc |
testing::internal::MutexBase::Lock() | void Lock() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
owner_ = pthread_self();
has_owner_ = true;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x87f0
testl %eax, %eax
je 0x35de4
movl %eax, %r14d
leaq 0x9ba4(%rip), %rdx # 0x3f92d
leaq -0x14(%rbp), %rdi
movl $0x3, %esi
movl $0x672, %ecx # imm = 0x672
callq 0x15452
movq 0x1d245(%rip), %rdi # 0x52fe8
leaq 0... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h |
testing::TestSuite::Passed() const | bool Failed() const {
return failed_test_count() > 0 || ad_hoc_test_result().Failed();
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ae06
testl %eax, %eax
jle 0x35eb6
xorl %eax, %eax
jmp 0x35ec7
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x1e7fc
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
static_assert(std::is_base_of<Base, Derived>::value,
"target type not derived from source type");
#if GTEST_HAS_RTTI
GTEST_CHECK_(base == nullptr || dynamic_cast<Derived*>(base) != nullptr);
#endif
return static_cast<Derived*>(base);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x36655
leaq 0x1c3ac(%rip), %rsi # 0x529b0
leaq 0x1c3b5(%rip), %rdx # 0x529c0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8590
testq %rax, %rax
jne 0x36655
leaq 0x930c(%rip), %rdx # 0x3f92d
leaq -0xc(%rbp), %rdi
movl $0x3, %es... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::SocketWriter::SocketWriter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SocketWriter(const std::string& host, const std::string& port)
: sockfd_(-1), host_name_(host), port_num_(port) {
MakeConnection();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rdi, %r14
leaq 0x1c361(%rip), %rax # 0x52aa0
movq %rax, (%rdi)
movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x10(%rdi)
m... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestProgramStart(testing::UnitTest const&) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {
SendLn("event=TestProgramStart");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x9501(%rip), %rsi # 0x3fdf0
leaq 0x9510(%rip), %rdx # 0x3fe06
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x380d6
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x37fd0... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) override {
const char* file_name = test_part_result.file_name();
if (file_name == nullptr) file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x36c7b
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x7ff3(%rip), %rsi # 0x3ec78
cmovneq %rax, %rsi
leaq -0x130(%rbp)... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestSuiteEnd(testing::TestSuite const&) | void OnTestSuiteEnd(const TestSuite& test_suite) override {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_suite.Passed()) +
"&elapsed_time=" + StreamableToString(test_suite.elapsed_time()) +
"ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x35ea0
leaq 0x66d3(%rip), %rcx # 0x3dc0a
leaq 0x81c0(%rip), %rsi # 0x3f6fe
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xd8(%rbp), %r12
movq %r12, -0x10(%r12)
l... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&) | void OnTestProgramEnd(const UnitTest& unit_test) override {
// Note that Google Test current only report elapsed time for each
// test iteration, not for the entire test program.
SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
// Notify the streaming server to stop.
socket_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x332cc
leaq 0x5f80(%rip), %rcx # 0x3dc0a
leaq 0x7a6d(%rip), %rsi # 0x3f6fe
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5f65(%rip), %rax # 0x... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/src/gtest-internal-inl.h |
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*) | static void Print(const char* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(std::string(str), os);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x38276
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
callq 0x8200
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x380d6
movq %r15, %rdi
movq ... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-printers.h |
decltype(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::MatcherBase<std::basic_s... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq (%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x3894c
testq %rdx, %rdx
je 0x3894f
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rdi
movq 0x8(%rax), %rsi
callq 0x84f0
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
| /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-matchers.h |
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | bool AlmostEquals(const FloatingPoint& rhs) const {
// The IEEE standard says that any comparison operation involving
// a NAN must return false.
if (is_nan() || rhs.is_nan()) return false;
return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <=
kMaxUlps;
} | pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0x39cdb
movl (%rsi), %ecx
movl %ecx, %edx
notl %edx
testl $0x7f800000, %edx # imm = 0x7F800000
sete %dl
testl... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/internal/gtest-internal.h |
testing::AssertionResult& testing::AssertionResult::operator<<<wchar_t const*>(wchar_t const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x1b1fc
movq (%r14), %rsi
movq %r15, %rdi
callq 0x1b24c
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x35cca
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x39e68
movq (%rdi),... | /rkimball[P]tinytcp/build_O1/test/gtest/src/gtest/googletest/include/gtest/gtest-assertion-result.h |
parse_bios_version | static void parse_bios_version(uint16_t offset)
{
/*
* offset + 0 (8 bits): Micro version
* offset + 1 (8 bits): Minor version
* offset + 2 (8 bits): Chip version
* offset + 3 (8 bits): Major version
*/
major_version = bios->data[offset + 3];
chip_version = bios->data[offset + 2];
if(card_codename <=... | movq 0xe95dc(%rip), %rax # 0x157070
movq (%rax), %rax
movl %edi, %edi
movzbl 0x3(%rax,%rdi), %ecx
movb %cl, 0xe9600(%rip) # 0x1570a4
movzbl 0x2(%rax,%rdi), %esi
movb %sil, 0xe95f7(%rip) # 0x1570a7
movl 0xe956a(%rip), %edx # 0x157020
testl %edx, %edx
jne 0x6dac2
movl %esi, 0xe9560(%rip) # 0x157020
m... | /polachok[P]envytools/nvbios/nvbios.c |
atomcmd | struct matches *atomcmd APROTO {
if (!ctx->reverse) {
struct expr *expr = makeex(EXPR_ID);
expr->str = v;
expr->special = 1;
ADDARRAY(ctx->atoms, expr);
return NULL;
} else {
return matchid(ctx, spos, v);
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdi, %rbx
cmpl $0x0, 0x48(%rdi)
je 0x6e4aa
movq %rbx, %rdi
movl %r8d, %esi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6e3cf
pushq $0x1
popq %rdi
callq 0x6e333
movq %rax, %r14
movq %r15, 0x8(%rax)
movl $0x1, 0x44(%rax)
movl 0x70(%rbx), %ecx
movl 0x74(%rbx),... | /polachok[P]envytools/envydis/core.c |
setsbf | int setsbf (struct match *res, int pos, int len, ull num) {
if (!len)
return 1;
int idx = pos / 0x40;
pos %= 0x40;
ull m = ((1ull << len) - 1) << pos;
ull a = (num << pos) & m;
if ((a & m & res->m[idx]) == (res->a[idx] & m & res->m[idx])) {
res->a[idx] |= a;
res->m[idx] |= m;
} else {
return 0;
}
if (p... | movl $0x1, %r10d
testl %edx, %edx
je 0x6e638
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r8
movl %edx, %r9d
movabsq $-0x1, %r11
movl %r9d, %ecx
shlq %cl, %r11
movl $0x40, %ecx
movl %esi, %eax
cltd
idivl %ecx
movl %edx, %ecx
notq %r11
movq %r11, %rsi
shlq %cl, %rsi
andq %r11, %r8
movq %r8, %rbx
shlq %cl, %rb... | /polachok[P]envytools/envydis/core.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.