name string | code string | asm string | file string |
|---|---|---|---|
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[static_cast<size_t>(index)];
} | testl %esi, %esi
js 0x1fff3
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x70
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x1fff3
movl %esi, %eax
imulq $0x70, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
retq
pushq %rax
leaq 0x1e1b2(%rip), %rdi # 0x3e1ad
xorl %eax, %eax
callq 0xa070
callq 0x2264f
n... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::HasNewFatalFailureHelper::HasNewFatalFailureHelper() | HasNewFatalFailureHelper::HasNewFatalFailureHelper()
: has_new_fatal_failure_(false),
original_reporter_(GetUnitTestImpl()->
GetTestPartResultReporterForCurrentThread()) {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x3dd3d(%rip), %rax # 0x5dd60
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x213a0
movq %rax, %rdi
callq 0xdefc
movq %rax, 0x10(%rbx)
callq 0x213a0
leaq 0x90(%rax), %rdi
callq 0x27a26
movq %rbx, (%rax)
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-test-part.cc |
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*) | const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r12, %rsi
callq 0xb8ce
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xa970
leaq 0x90(%rsp), %rsi
movl %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-typed-test.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r14
movl 0x8(%r14), %edi
callq 0xad00
cmpl $-0x1, %eax
jne 0x20562
callq 0xa060
cmpl $0x4, (%rax)
je 0x20474
leaq 0x1d838(%rip), %rsi # 0x3dccf
leaq 0xd8(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xb8ce
leaq 0x1d72c(%rip), %rdx # 0x3dbdc
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::(anonymous namespace)::FailureTest::TestBody() | void TestBody() override {
if (as_error_) {
AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
loc_.line, "") = Message() << error_message_;
} else {
std::cout << error_message_ << std::endl;
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x20a45
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xe756
leaq 0x38(%r14), %rsi
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
callq 0xa550
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0x1f69e(%rip), %r8 # 0x400a8
leaq 0x8(%rsp), %rdi
p... | /havogt[P]cmakels/build_O2/_deps/googletest-src/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::CreateTest() | Test* CreateTest() override { return factory_(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %r15
pushq $0x60
popq %rdi
callq 0xa630
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0xa970
addq $0x48, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2093c
movq %rsp, %rdi
callq 0xad38
movq %rbx, %rax
addq $0x20, %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
testq %r14, %r14
je 0x20bcc
leaq 0x1e21a(%rip), %rsi # 0x3edc1
callq 0xa610
leaq 0x8(%rsp), %rdi
leaq 0x1... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo(c, os);
}
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0xd, %edi
ja 0x211c0
movl %r14d, %eax
leaq 0x1a3dd(%rip), %rcx # 0x3b588
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1bc20(%rip), %rsi # 0x3cddb
jmp 0x2124b
cmpl $0x22, %r14d
je 0x2123b
cmpl $0x5c, %r14d
je 0x21244
cmpl $0x... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa550
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x215b4
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::Message>(testing::Message const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x2a703
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21624
movq (%rdi), %rax
callq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [4]>(char const (&) [4]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char const>(char const* const&) | inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == nullptr) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
addq $0x10, %rdi
testq %rax, %rax
leaq 0x1b597(%rip), %rsi # 0x3cdc3
cmovneq %rax, %rsi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [11]>(char const (&) [11]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [12]>(char const (&) [12]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [2]>(char const (&) [2]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa610
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x218fa
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq %r15, %rdi
movq %r14, %rsi
callq 0x21814
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21964
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<double>(double const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq %r15, %rdi
movq %r14, %rsi
callq 0x28554
movq %rbx, %rdi
movq %rax, %rsi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21aae
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [3]>(char const (&) [3]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa610
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21bfe
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [100]>(char const (&) [100]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa610
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21cde
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa610
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x21d4e
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [65]>(char const (&) [65]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [18]>(char const (&) [18]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [68]>(char const (&) [68]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Test* testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x213a0
addq %r15, %r14
cmpb $0x1, 0x258(%rax)
jne 0x22d47
testb $0x1, %r12b
je 0x22d35
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
p... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r15
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0x1d22c(%rip), %rsi # 0x400a8
cmovneq %rdx, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xb8ce
movl %ebp, 0x28(%r15)
leaq 0x30(%r15)... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h |
int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo const*)) | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
if (predicate(*it))
++count;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
xorl %ebp, %ebp
cmpq 0x8(%r14), %r15
je 0x22f2d
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x22f17
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<long>(long const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq %r15, %rdi
movq %r14, %rsi
callq 0x274bc
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe91a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x231d1
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %r... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char>(char const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsbl (%rsi), %esi
callq 0xa7a0
movq %rbx, %rax
popq %rbx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<int>(int const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq %r15, %rdi
movq %r14, %rsi
callq 0x22990
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe91a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23339
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %r... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.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 f... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x1cc1e(%rip), %rsi # 0x400a8
cmovneq %rbx, %rsi
leaq 0x7(%rsp), %rdx
callq 0xb8ce
cmpq $0x0, 0x8(%r14)
je 0x234c4
leaq 0x1a5a3(%rip), %rsi # 0x3da49
movq %rbx, %rdi
callq 0xa7d0
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %ra... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile() | ~ScopedPrematureExitFile() {
#if !defined GTEST_OS_ESP8266
if (!premature_exit_filepath_.empty()) {
int retval = remove(premature_exit_filepath_.c_str());
if (retval) {
GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
<< premature_exit_filepath_ << "\"... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2367d
movq (%rbx), %rdi
callq 0xac10
testl %eax, %eax
je 0x2367d
movl %eax, %ebp
leaq 0x19182(%rip), %rdx # 0x3c7ac
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x13a2, %ecx # imm = 0x13A2
callq 0x1f26c
movq 0x3b9ad(%rip), %rdi ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::GetRandomSeedFromFlag(int) | inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
const unsigned int raw_seed = (random_seed_flag == 0) ?
static_cast<unsigned int>(GetTimeInMillis()) :
static_cast<unsigned int>(random_seed_flag);
// Normalizes the actual seed to range [1, kMaxRandomSeed] such that
// it's easy to type.
... | movl %edi, %eax
testl %edi, %edi
jne 0x23aab
pushq %rax
callq 0xe610
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::Message::Message(testing::Message const&) | Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0xa630
movq %rax, %r14
movq %rax, %rdi
callq 0xa430
movq %r14, (%rbx)
movq %rsp, %rdi
movq %r15, %rsi
callq 0xe91a
addq $0x10, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa550
movq %rsp, %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
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::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x23eef
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x2a1b1
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x20c50
testb %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
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::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x24015
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x2a242
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x20c50
testb %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::DeathTestImpl(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
: statement_(a_statement),
matcher_(std::move(matcher)),
spawned_(false),
status_(-1),
outcome_(IN_PROGRESS),
read_fd_(-1),
write_fd_(-1) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1b794
leaq 0x39ddc(%rip), %rax # 0x5e040
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq 0x8(%rbx), %rax
movq %rax, 0x18(%r15)
movq 0x10(%rbx), %rax
movq %rax, 0x20(%r15)
andq $0x0, 0x8(%rbx)
leaq 0x3a171(%rip), %rax # 0x5e3f8
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>> cons... | void AddArguments(const ::std::vector<Str>& arguments) {
for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
i != arguments.end();
++i) {
args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r13
leaq 0x8(%rsp), %r15
cmpq 0x8(%rbx), %r13
je 0x2432f
movq 0x8(%r14), %r12
addq $-0x8, %r12
movq (%r13), %rdi
callq 0xac40
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::ExecDeathTest::ExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int) | ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
const char* file, int line)
: ForkingDeathTest(a_statement, std::move(matcher)),
file_(file),
line_(line) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq 0x8(%rdx), %rcx
leaq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
andq $0x0, 0x8(%rdx)
movq %rdi, %r15
leaq 0x3a029(%rip), %rcx # 0x5e3f8
movq %rcx, (%rax)
movq %rax, %rdx
callq 0x1c56c
leaq 0x... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::Message& testing::Message::operator<<<char [52]>(char const (&) [52]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
void testing::internal::PrintCharAndCodeTo<wchar_t>(wchar_t, 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x1b9d8(%rip), %rsi # 0x40377
movq %rbx, %rdi
callq 0xa610
leaq 0x16b1d(%rip), %rsi # 0x3b4cb
movq %rax, %rdi
callq 0xa610
cmpl $0xd, %r14d
ja 0x249d8
movl %r14d, %eax
leaq 0x17d8a(%rip), %rcx # 0x3... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-printers.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~Matcher() | class GTEST_API_ Matcher<std::string>
: public internal::MatcherBase<std::string> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {}
explicit Matcher(const MatcherInterface<std::string>* impl)
: internal::Matche... | pushq %rbx
movq %rdi, %rbx
callq 0x273a4
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xa660
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/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() {}
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<internal::StringView>(impl) {}
explicit Matcher(const MatcherInterface<internal... | pushq %rbx
movq %rdi, %rbx
callq 0x27404
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xa660
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x1ff00
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x251d8
movq (%rdi), %rax
callq... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::internal::MutexBase::Unlock() | void Unlock() {
// Since the lock is being released the owner_ field should no longer be
// considered valid. We don't protect writing to has_owner_ here, as it's
// the caller's responsibility to ensure that the current thread holds the
// mutex when this is called.
has_owner_ = false;
GTEST_CH... | pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0xa4a0
testl %eax, %eax
je 0x253f1
movl %eax, %ebx
leaq 0x18f23(%rip), %rdx # 0x3e2cc
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x67e, %ecx # imm = 0x67E
callq 0x1f26c
movq 0x39c2e(%rip), %rdi # 0x5eff0
leaq 0x18fc9(%rip), %rsi # 0x3e3... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xaaa0
testq %rax, %rax
je 0x25c38
movq %rax, %rdi
callq 0x25cca
movq %rax, %rbx
jmp 0x25ca5
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xa0e0
testl %eax, %eax
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestStart(testing::TestInfo const&) | void OnTestStart(const TestInfo& test_info) override {
SendLn(std::string("event=TestStart&name=") + test_info.name());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x186dc(%rip), %rsi # 0x3e7d4
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xb8ce
movq 0x20(%r14), %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x212cd
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x269ca
l... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) +
"&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x23172
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x26a26
leaq 0x18497(%rip), %rsi # 0x3e816
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x2249c
leaq 0x18499(%rip), %rdx ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x268b8
leaq 0x17c30(%rip), %rdx # 0x3e4a7
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x44a, %ecx # imm = 0x44A
callq 0x1f26c
movq 0x38760(%rip), %rdi # 0x5eff0
leaq 0x17e04(%rip), %rsi ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x269a6
leaq 0x17b42(%rip), %rdx # 0x3e4a7
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x45b, %ecx # imm = 0x45B
callq 0x1f26c
movq 0x38672(%rip), %rdi # 0x5eff0
leaq 0x17d16(%rip), %rsi # 0x3e69b
callq 0xa6... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::operator=(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>&&) | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x26dfe
movq %rsi, %r14
movq %rbx, %rdi
callq 0x26e0a
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*) | static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(::std::wstring(str), os);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x272b5
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x272e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fdf2
leaq 0x8(%rsp), %rdi
callq 0xa0c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x17a97(%rip), %rsi ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-printers.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0xaaa0
testq %rax, %rax
je 0x27a4a
movq %rax, %rdi
callq 0x27adc
movq %rax, %rbx
jmp 0x27ab7
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0xa0e0
testl %eax, %eax
... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsd (%rsi), %xmm0
callq 0xab50
movq %rbx, %rax
popq %rbx
retq
nop
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::internal::FloatingPoint<float>::DistanceBetweenSignAndMagnitudeNumbers(unsigned int const&, unsigned int const&) | static Bits SignAndMagnitudeToBiased(const Bits &sam) {
if (kSignBitMask & sam) {
// sam represents a negative number.
return ~sam + 1;
} else {
// sam represents a positive number.
return kSignBitMask | sam;
}
} | movl (%rdi), %ecx
movl %ecx, %edx
negl %edx
movl $0x80000000, %edi # imm = 0x80000000
movl %ecx, %eax
orl %edi, %eax
testl %ecx, %ecx
cmovsl %edx, %eax
movl (%rsi), %ecx
movl %ecx, %edx
negl %edx
orl %ecx, %edi
testl %ecx, %ecx
cmovsl %edx, %edi
movl %eax, %ecx
subl %edi, %ecx
negl %ecx
subl %edi, %eax
cmovbl %ec... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> 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;
} | movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq (%rdi), %rcx
movq %rcx, %rdx
notq %rdx
testq %rax, %rdx
sete %dl
shlq $0xc, %rcx
setne %cl
testb %cl, %dl
jne 0x2862d
movabsq $0xfffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rdx
movq %rdx, %r8
notq %r8
testq %r8, %rax
sete %al
testq %rcx, %... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [16]>(char const (&) [16]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0xa610
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25270
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x286cc
movq (%rdi), %rax
callq ... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::TestPartResult::TestPartResult(testing::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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0xa8e0
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0xa8e0
addq $0x50, %r14
addq $0x50, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x7e(%rip), %rsi # 0x29ba2
leaq 0xc(%rsp), %rdi
callq 0xab10
testl %eax, %eax
je 0x29b83
movl %eax, %ebx
leaq 0x14791(%rip), %rdx # 0x3e2cc
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x706, %ecx # imm = 0x706
callq 0x1f26c
movq 0x3549c(%rip), %rdi # 0x5eff... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<char*>(char* const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xe756
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a21c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe91a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2a1f3
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %r... | /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char>(char* const&) | inline Message& operator <<(T* const& pointer) { // NOLINT
if (pointer == nullptr) {
*ss_ << "(null)";
} else {
*ss_ << pointer;
}
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdi), %rdi
addq $0x10, %rdi
testq %rax, %rax
leaq 0x12b8f(%rip), %rsi # 0x3cdc3
cmovneq %rax, %rsi
callq 0xa610
movq %rbx, %rax
popq %rbx
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::in... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | movq %rdi, %rax
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, s... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | movq %rdi, %rax
retq
| /havogt[P]cmakels/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
loguru::file_log(void*, loguru::Message const&) | void file_log(void* user_data, const Message& message)
{
#if LOGURU_WITH_FILEABS
FileAbs* file_abs = reinterpret_cast<FileAbs*>(user_data);
if (file_abs->is_reopening) {
return;
}
// It is better checking file change every minute/hour/day,
// instead of doing this every time we log.
// Here check_interv... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %rdx
movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %r8
movq 0x30(%rsi), %r9
leaq 0x15adb(%rip), %rsi # 0x40570
xorl %eax, %eax
callq 0xa9e0
cmpl $0x0, 0x35289(%rip) # 0x5fd2c
je 0x2aaa7
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0xa7c0
| /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::init(int&, char**, char const*) | void init(int& argc, char* argv[], const char* verbosity_flag)
{
CHECK_GT_F(argc, 0, "Expected proper argc/argv");
CHECK_EQ_F(argv[argc], nullptr, "Expected proper argc/argv");
s_argv0_filename = filename(argv[0]);
#ifdef _WIN32
#define getcwd _getcwd
#endif
if (!getcwd(s_current_dir, siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movslq (%rdi), %rax
movl %eax, 0x24(%rsp)
andl $0x0, 0x20(%rsp)
testq %rax, %rax
jle 0x2b2b3
movq %rsi, %rbx
cmpq $0x0, (%rsi,%rax,8)
jne 0x2b344
movq (%rbx), %rdi
callq 0x2abc0
leaq 0x350d1(%r... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::log(int, char const*, unsigned int, char const*, ...) | void log(Verbosity verbosity, const char* file, unsigned line, const char* format, ...)
{
va_list vlist;
va_start(vlist, format);
auto buff = vtextprintf(format, vlist);
log_to_everywhere(1, verbosity, file, line, "", buff.c_str());
va_end(vlist);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
leaq 0x30(%rsp), %rsi
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2b5e6
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::shutdown() | void shutdown()
{
VLOG_F(g_internal_verbosity, "loguru::shutdown()");
remove_all_callbacks();
set_fatal_handler(nullptr);
set_verbosity_to_name_callback(nullptr);
set_name_to_verbosity_callback(nullptr);
} | pushq %rax
movl 0x344fe(%rip), %edi # 0x5fd30
movl 0x344f0(%rip), %eax # 0x5fd28
movl 0x33e9e(%rip), %ecx # 0x5f6dc
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl %ecx, %edi
jg 0x2b861
leaq 0x14609(%rip), %rsi # 0x3fe57
leaq 0x146ee(%rip), %rcx # 0x3ff43
movl $0x25e, %edx # imm = 0x25E
xorl %eax,... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::home_dir() | const char* home_dir()
{
#ifdef _WIN32
auto user_profile = getenv("USERPROFILE");
CHECK_F(user_profile != nullptr, "Missing USERPROFILE");
return user_profile;
#else // _WIN32
auto home = getenv("HOME");
CHECK_F(home != nullptr, "Missing HOME");
return home;
#endif // _WIN32
} | pushq %rax
leaq 0x145ce(%rip), %rdi # 0x3ffa0
callq 0xa820
testq %rax, %rax
je 0x2b9de
popq %rcx
retq
leaq 0x14592(%rip), %rsi # 0x3ff77
leaq 0x1446b(%rip), %rdx # 0x3fe57
leaq 0x145a5(%rip), %r8 # 0x3ff98
xorl %edi, %edi
movl $0x288, %ecx # imm = 0x288
xorl %eax, %eax
callq 0x2b4ad
| /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::get_verbosity_name(int) | const char* get_verbosity_name(Verbosity verbosity)
{
auto name = s_verbosity_to_name_callback
? (*s_verbosity_to_name_callback)(verbosity)
: nullptr;
// Use standard replacements if callback fails:
if (!name)
{
if (verbosity <= Verbosity_FATAL) {
name = "FATL";
} else if (verbosity == Verbo... | pushq %rbx
movl %edi, %ebx
movq 0x34c9f(%rip), %rax # 0x60db8
testq %rax, %rax
je 0x2c127
movl %ebx, %edi
callq *%rax
testq %rax, %rax
jne 0x2c151
cmpl $-0x2, %ebx
jge 0x2c135
leaq 0x14022(%rip), %rax # 0x40155
jmp 0x2c151
addl $0x2, %ebx
cmpl $0x2, %ebx
ja 0x2c14f
movl %ebx, %eax
leaq 0x13b82(%rip), %rcx #... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::remove_callback(char const*) | bool remove_callback(const char* id)
{
std::lock_guard<std::recursive_mutex> lock(s_mutex);
auto it = std::find_if(begin(s_callbacks), end(s_callbacks), [&](const Callback& c) { return c.id == id; });
if (it != s_callbacks.end()) {
if (it->close) { it->close(it->user_data); }
s_callbacks.erase(it);
on_c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
leaq 0x334dd(%rip), %rdi # 0x5f6e0
callq 0x2ed1c
movq 0x33b69(%rip), %rbx # 0x5fd78
movq 0x33b6a(%rip), %rbp # 0x5fd80
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbp, %r12
subq %rbx, ... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
loguru::get_thread_name(char*, unsigned long long, bool) | void get_thread_name(char* buffer, unsigned long long length, bool right_align_hext_id)
{
#ifdef _WIN32
(void)right_align_hext_id;
#endif
CHECK_NE_F(length, 0u, "Zero length buffer in get_thread_name");
CHECK_NOTNULL_F(buffer, "nullptr in get_thread_name");
#if LOGURU_PTHREADS
auto thread = pthread_self();
#... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
andl $0x0, 0xc(%rsp)
testq %rsi, %rsi
je 0x2c483
movq %rdi, %r14
testq %rdi, %rdi
je 0x2c50e
movl %edx, %ebp
movq %rsi, %rbx
callq 0xa560
movq %rax, %r15
callq 0x2c3ad
testq %rax, %rax
je 0x2c435
leaq 0x14151(%rip), %rdx # 0x40565
mo... | /havogt[P]cmakels/lscpp/external/loguru/loguru.cpp |
cursespp::App::InitCurses() | void App::InitCurses() {
initscr();
nonl();
cbreak();
noecho();
keypad(stdscr, TRUE);
refresh();
curs_set(0);
mousemask(ALL_MOUSE_EVENTS, nullptr);
mouseinterval(0);
timeout(IDLE_TIMEOUT_MS);
#ifndef WIN32
set_escdelay(20);
#endif
#ifdef WIN32
PDC_set_function_key(FUNCT... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6d0f0
callq 0x6f740
callq 0x6bb80
callq 0x70c80
movq 0x51468(%rip), %r14 # 0xc2e18
movq (%r14), %rdi
pushq $0x1
popq %rsi
callq 0x6bf10
callq 0x6b770
xorl %edi, %edi
callq 0x6d470
movl $0xfffffff, %edi # imm = 0xFFFFFFF
xorl %esi, %esi
callq 0x6f3c0
xo... | /clangen[P]cursespp/src/App.cpp |
main | int main(int argc, char** argv)
{
app::App a;
try {
a.init();
}
catch (const error::InitError& e) {
std::cerr << "Error while initializing App: "
<< e.what() << std::endl;
return 1;
}
a.mainLoop();
std::cout << "Finished";
re... | pushq %r14
pushq %rbx
subq $0x78, %rsp
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xb91(%rip), %rsi # 0x3004
leaq 0xb91(%rip), %rdx # 0x300b
movq %rsp, %rdi
callq 0x2582
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2618
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x249d
callq 0x2220
leaq 0x20(%rsp), %rdi
c... | /binary132[P]cmake-sdl/src/main.cxx |
mbedtls_cipher_info_from_values | const mbedtls_cipher_info_t *mbedtls_cipher_info_from_values( const mbedtls_cipher_id_t cipher_id,
int key_bitlen,
const mbedtls_cipher_mode_t mode )
{
const mbedtls_cipher_definition_t *def;
for( def = mbedtls_cipher_d... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x175dc(%rip), %rax # 0x20770
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x91f4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_setup | int mbedtls_cipher_setup( mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info )
{
if( NULL == cipher_info || NULL == ctx )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
memset( ctx, 0, sizeof( mbedtls_cipher_context_t ) );
if( NULL == ( ctx->cipher_ctx = cipher_info->base->ctx_a... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x92f0
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x92f9
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x934c
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x40a0
mov... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_setkey | int mbedtls_cipher_setkey( mbedtls_cipher_context_t *ctx, const unsigned char *key,
int key_bitlen, const mbedtls_operation_t operation )
{
if( NULL == ctx || NULL == ctx->cipher_info )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( ( ctx->cipher_info->flags & MBEDTLS_CIPHER_VARIABLE_KEY_LEN ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x9499
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x94a5
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0x9572
movq -0x... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_pkcs_padding | static int get_pkcs_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i, pad_idx;
unsigned char padding_len, bad = 0;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
padding_len = input[input_len - 1];
*data_len = inpu... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x32(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x9f94
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x9fa0
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0xa06a
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %r... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_one_and_zeros_padding | static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i;
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xa0f4
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0xa100
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFFFF9F00
jmp 0xa1d2
movb $-0x1, -0x2b(%rbp)
movq -0x20(%rbp), %... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_write_tag | int mbedtls_cipher_write_tag( mbedtls_cipher_context_t *ctx,
unsigned char *tag, size_t tag_len )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == tag )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
if( MBEDTLS_ENCRYPT != ctx->operation )
return( MBEDTLS_ERR_CIPHER_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xa4bf
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0xa4bf
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0xa4c8
movl $0xffff9f00, -0x4(%rbp) # imm = 0xFF... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_check_tag | int mbedtls_cipher_check_tag( mbedtls_cipher_context_t *ctx,
const unsigned char *tag, size_t tag_len )
{
int ret;
if( NULL == ctx || NULL == ctx->cipher_info ||
MBEDTLS_DECRYPT != ctx->operation )
{
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
}
if( MBEDTLS_M... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xa552
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0xa552
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl 0xc(%rcx), %eax
je 0xa55e
movl $0xffff9f00, -0x... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_crypt | int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
{
int ret;
size_t finish_olen;
if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x9580
movl %eax, -0x3c(%rbp)
cmpl $0x0, %e... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
blowfish_ctx_alloc | static void * blowfish_ctx_alloc( void )
{
mbedtls_blowfish_context *ctx;
ctx = mbedtls_calloc( 1, sizeof( mbedtls_blowfish_context ) );
if( ctx == NULL )
return( NULL );
mbedtls_blowfish_init( ctx );
return( ctx );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x1048, %esi # imm = 0x1048
callq 0x40d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaf3c
movq $0x0, -0x8(%rbp)
jmp 0xaf4d
movq -0x10(%rbp), %rdi
callq 0x13250
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1... | /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
des3_ctx_alloc | static void * des3_ctx_alloc( void )
{
mbedtls_des3_context *des3;
des3 = mbedtls_calloc( 1, sizeof( mbedtls_des3_context ) );
if( des3 == NULL )
return( NULL );
mbedtls_des3_init( des3 );
return( des3 );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x180, %esi # imm = 0x180
callq 0x40d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb46c
movq $0x0, -0x8(%rbp)
jmp 0xb47d
movq -0x10(%rbp), %rdi
callq 0xb5c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10,... | /Dragonchang[P]https_client/mbedtls/library/cipher_wrap.c |
gcm_mult | static void gcm_mult( mbedtls_gcm_context *ctx, const unsigned char x[16],
unsigned char output[16] )
{
int i = 0;
unsigned char lo, hi, rem;
uint64_t zh, zl;
#if defined(MBEDTLS_AESNI_C) && defined(MBEDTLS_HAVE_X86_64)
if( mbedtls_aesni_has_support( MBEDTLS_AESNI_CLMUL ) ) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x2, %edi
callq 0x12850
cmpl $0x0, %eax
je 0xe0c4
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
shrq $0x20, %rax
shrq $0x18, %rax
movb %al, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_gcm_auth_decrypt | int mbedtls_gcm_auth_decrypt( mbedtls_gcm_context *ctx,
size_t length,
const unsigned char *iv,
size_t iv_len,
const unsigned char *add,
size_t add_len,
const unsigned char *tag,
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_aesni_has_support | int mbedtls_aesni_has_support( unsigned int what )
{
static int done = 0;
static unsigned int c = 0;
if( ! done )
{
asm( "movl $1, %%eax \n\t"
"cpuid \n\t"
: "=c" (c)
:
: "eax", "ebx", "edx" );
done = 1;
}
retur... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %edi, -0xc(%rbp)
cmpl $0x0, 0x10b91(%rip) # 0x233f0
jne 0x12878
movl $0x1, %eax
cpuid
movl %ecx, 0x10b86(%rip) # 0x233f4
movl $0x1, 0x10b78(%rip) # 0x233f0
movl 0x10b76(%rip), %eax # 0x233f4
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl ... | /Dragonchang[P]https_client/mbedtls/library/aesni.c |
mbedtls_aesni_crypt_ecb | int mbedtls_aesni_crypt_ecb( mbedtls_aes_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
asm( "movdqu (%3), %%xmm0 \n\t" // load input
"movdqu (%1), %%xmm1 \n\t" // load round key 0
"pxor... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
movdqu (%rsi), %xmm0
movdqu (%rcx), %xmm1
pxor %xmm1... | /Dragonchang[P]https_client/mbedtls/library/aesni.c |
aesni_setkey_enc_128 | static void aesni_setkey_enc_128( unsigned char *rk,
const unsigned char *key )
{
asm( "movdqu (%1), %%xmm0 \n\t" // copy the original key
"movdqu %%xmm0, (%0) \n\t" // as round key 0
"jmp 2f \n\t" // skip aux... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movdqu (%rdx), %xmm0
movdqu %xmm0, (%rcx)
jmp 0x12c5b
pshufd $0xff, %xmm1, %xmm1 # xmm1 = xmm1[3,3,3,3]
pxor %xmm0, %xmm1
pslldq $0x4, %xmm0 # xmm0 = zero,zero,zero,zero,xmm0[0,1,2,3,4,5,... | /Dragonchang[P]https_client/mbedtls/library/aesni.c |
mbedtls_arc4_crypt | int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
unsigned char *output )
{
int x, y, a, b;
size_t i;
unsigned char *m;
x = ctx->x;
y = ctx->y;
m = ctx->m;
for( i = 0; i < length; i++ )
{
x = ( x + 1 ) & 0xFF; a = m[x]... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq $0x0, -... | /Dragonchang[P]https_client/mbedtls/library/arc4.c |
F | static uint32_t F( mbedtls_blowfish_context *ctx, uint32_t x )
{
unsigned short a, b, c, d;
uint32_t y;
d = (unsigned short)(x & 0xFF);
x >>= 8;
c = (unsigned short)(x & 0xFF);
x >>= 8;
b = (unsigned short)(x & 0xFF);
x >>= 8;
a = (unsigned short)(x & 0xFF);
y = ctx->S[0][a] + ctx->S[1][... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movw %ax, -0x14(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movw %ax, -0x12(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0... | /Dragonchang[P]https_client/mbedtls/library/blowfish.c |
camellia_feistel | static void camellia_feistel( const uint32_t x[2], const uint32_t k[2],
uint32_t z[2])
{
uint32_t I0, I1;
I0 = x[0] ^ k[0];
I1 = x[1] ^ k[1];
I0 = ((uint32_t) SBOX1((I0 >> 24) & 0xFF) << 24) |
((uint32_t) SBOX2((I0 >> 16) & 0xFF) << 16) |
((uint32_t) SBOX... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
xorl (%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
xorl 0x4(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_camellia_crypt_ecb | int mbedtls_camellia_crypt_ecb( mbedtls_camellia_context *ctx,
int mode,
const unsigned char input[16],
unsigned char output[16] )
{
int NR;
uint32_t *RK, X[4];
( (void) mode );
NR = ctx->nr;
RK = ctx->rk;
GET_UINT32_BE( X[0], input,... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
mo... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_camellia_crypt_cfb128 | int mbedtls_camellia_crypt_cfb128( mbedtls_camellia_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x154df
jmp 0x1544a
movq -0x18... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_camellia_self_test | int mbedtls_camellia_self_test( int verbose )
{
int i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
unsigned char src[16];
unsigned char dst[16];
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CTR)
size_t offset, len;
unsigned ... | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movl %edi, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x40a0
movl $0x0, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jge 0x158d4
movl -0x10(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
andl $0x1, %eax
movl %... | /Dragonchang[P]https_client/mbedtls/library/camellia.c |
mbedtls_ccm_self_test | int mbedtls_ccm_self_test( int verbose )
{
mbedtls_ccm_context ctx;
unsigned char out[32];
size_t i;
int ret;
mbedtls_ccm_init( &ctx );
if( mbedtls_ccm_setkey( &ctx, MBEDTLS_CIPHER_ID_AES, key, 8 * sizeof key ) != 0 )
{
if( verbose != 0 )
mbedtls_printf( " CCM: setup f... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xb8, %rsp
movl %edi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x15e10
leaq -0x68(%rbp), %rdi
movl $0x2, %esi
leaq 0x60d8(%rip), %rdx # 0x1c910
movl $0x80, %ecx
callq 0x15e40
cmpl $0x0, %eax
je 0x16867
cmpl $0x0, -0x10(%rbp)
je 0x1685b
leaq 0x61fc(%rip), %rdi # 0x1c... | /Dragonchang[P]https_client/mbedtls/library/ccm.c |
do_metric_average_test | static void
_do_metric_average_test(uint32_t decoded) {
struct rfc7181_metric_field metric;
uint32_t encoded;
CHECK_TRUE(!rfc7181_metric_encode(&metric, decoded),
"Metric encoding failed: %u", decoded);
encoded = _get_encoded_value(&metric);
CHECK_TRUE(_metric_table[encoded] > decoded, "encode(%u)=%u,... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq -0x6(%rbp), %rdi
callq 0x1070
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movl -0x4(%rbp), %r8d
movzbl %al, %edi
andl $0x1, %edi
leaq 0x8dc(%rip), %rsi # 0x218c
leaq 0x8ed(%rip), %rcx # 0x21a4
xorl %eax, %eax
movl $0x... | /OLSR[P]OONF/src/tests/rfc5444/test_rfc5444.c |
leveldb::test::Tester::~Tester() | ~Tester() {
if (!ok_) {
fprintf(stderr, "%s:%d:%s\n", fname_, line_, ss_.str().c_str());
exit(1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x4bf2
addq $0x18, %rbx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4290
movq 0x93e7(%rip), %rax # 0xdfe0
movq (%rax), %r15
movq 0x8(%rbx), %r14
movl 0x10(%rbx), %ebp
addq $0x18, %rb... | /CDDSCLab[P]leveldb/util/testharness.h |
leveldb::Arena::AllocateFallback(unsigned long) | char* Arena::AllocateFallback(size_t bytes) {
if (bytes > kBlockSize / 4) {
// Object is more than a quarter of our block size. Allocate it separately
// to avoid wasting too much space in leftover bytes.
char* result = AllocateNewBlock(bytes);
return result;
}
// We waste the remaining space in... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x401, %rsi # imm = 0x401
jb 0x5494
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x54bc
movl $0x1000, %r15d # imm = 0x1000
movl $0x1000, %esi # imm = 0x1000
movq %r14, %rdi
callq 0x54bc
leaq (%rax,%... | /CDDSCLab[P]leveldb/util/arena.cc |
leveldb::(anonymous namespace)::PosixEnv::NewLogger(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, leveldb::Logger**) | Status NewLogger(const std::string& filename, Logger** result) override {
int fd = ::open(filename.c_str(),
O_APPEND | O_WRONLY | O_CREAT | kOpenBaseFlags, 0644);
if (fd < 0) {
*result = nullptr;
return PosixError(filename, errno);
}
std::FILE* fp = ::fdopen(fd, "w");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movl $0x80441, %esi # imm = 0x80441
movl $0x1a4, %edx # imm = 0x1A4
xorl %eax, %eax
callq 0x4280
testl %eax, %eax
js 0x68e1
movl %eax, %ebp
leaq 0x2f8b(%rip), %rsi # 0x9837
m... | /CDDSCLab[P]leveldb/util/env_posix.cc |
leveldb::(anonymous namespace)::PosixWritableFile::Close() | Status Close() override {
Status status = FlushBuffer();
const int close_result = ::close(fd_);
if (close_result < 0 && status.ok()) {
status = PosixError(filename_, errno);
}
fd_ = -1;
return status;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7182
movl 0x10010(%r14), %edi
callq 0x4650
testl %eax, %eax
jns 0x7019
cmpq $0x0, (%rbx)
jne 0x7019
leaq 0x10018(%r14), %r15
callq 0x4050
movl (%rax), %edx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x692f
movq (%rbx), %rax
leaq 0... | /CDDSCLab[P]leveldb/util/env_posix.cc |
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.