name string | code string | asm string | file string |
|---|---|---|---|
testing::AssertionResult& testing::AssertionResult::operator<<<char [17]>(char const (&) [17]) | 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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | 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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::FloatingPointLE<float>(char const*, char const*, float, float) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x388, %rsp # imm = 0x388
movq %rdi, %rbx
movq %rsi, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
ucomiss %xmm0, %xmm1
ja 0x2e151
leaq -0x58(%rbp), %rdi
movss %xmm0, -0x30(%rbp)
movss %xmm0, (%rdi)
leaq -0x54(%rbp), %rsi
movss %xmm... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult testing::internal::FloatingPointLE<double>(char const*, char const*, double, double) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rdi, %rbx
movq %rsi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
ucomisd %xmm0, %xmm1
ja 0x2e421
leaq -0xa8(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
movsd %xmm0, (%rdi)
leaq -0xa0(%rbp), %rsi
movsd %xmm... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [13]>(char const (&) [13]) | 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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.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_DEATH_TEST
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program... | 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 0x2f146
movq %r14, -0x30(%rbp)
leaq 0x10(%r12), %r13
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x28caa
movq %r13, %rdi
movq %r14... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.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 0x2f415
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x2f42d
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x8(%rbx), %rdi
addq $0x18... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-test-part.h |
testing::TestSuite::TestPassed(testing::TestInfo const*) | static bool TestPassed(const TestInfo* test_info) {
return test_info->should_run() && test_info->result()->Passed();
} | cmpb $0x1, 0x80(%rdi)
jne 0x2f47b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x90, %rbx
movq %rbx, %rdi
callq 0x13160
testb %al, %al
je 0x2f47e
xorl %eax, %eax
jmp 0x2f488
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x131a6
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
void testing::internal::HandleExceptionsInMethodIfSupported<testing::TestSuite, void>(testing::TestSuite*, void (testing::TestSuite::*)(), 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xb8c6
movq 0x1e74a(%rip), %rax # 0x4dc00
addq %r15, %r14
cmpb $0x1, 0x258(%rax)
jne 0x2f4e3
testb $0x1, %r12b
je 0x2f4d0
movq (%r14), %rax
movq -0x1(%rax,%r1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movq (%r15), %rsi
callq 0x84b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfac9
testq %rbx, %rbx
je 0x2f67a
movq (%rbx), %rax
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0xf840
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movl (%r15), %esi
callq 0x89f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfac9
testq %rbx, %rbx
je 0x2f6e5
movq (%rbx), %rax
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-message.h |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf088
testl %eax, %eax
jle 0x2f722
xorl %eax, %eax
jmp 0x2f733
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
callq 0x131a6
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0xa940
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 f... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0xaca9(%rip), %r15 # 0x3a4b1
cmovneq %rsi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r15, %rdi
callq 0x8230
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3470e
cmpq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), 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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xb8c6
movq 0x1e36c(%rip), %rax # 0x4dc00
addq %r15, %r14
cmpb $0x1, 0x258(%rax)
jne 0x2f8c1
testb $0x1, %r12b
je 0x2f8ae
movq (%r14), %rax
movq -0x1(%rax,%r1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~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 0x88c0
testq %rax, %rax
je 0x2fb25
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x8690
testl %eax, %eax
je 0x2fb95
movl %eax, %r14d
leaq 0xb895(%rip), %rdx # 0x3b3cf
leaq -0x14(%r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h |
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 0x2fc1f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2fc19
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2fc06
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2fc3d
movq 0x10(%r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::GetNextRandomSeed(int) | inline int GetNextRandomSeed(int seed) {
GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
<< "Invalid random seed " << seed << " - must be in [1, "
<< kMaxRandomSeed << "].";
const int next_seed = seed + 1;
return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax # imm = 0x1869F
jb 0x3005e
leaq 0xb5e6(%rip), %rdx # 0x3b5b2
leaq -0x14(%rbp), %rdi
movl $0x3, %esi
movl $0x96, %ecx
callq 0x2a45a
movq 0x1d002(%rip), %rdi # 0x4cfe8
leaq 0xb9be(... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0x84f0
movq %rax, %r15
movq %rax, %rdi
callq 0x8370
movq %r15, (%rbx)
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0xfac9
addq $0x10, %r15
movq -0x38(%rbp), %rs... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-message.h |
void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*) | void ShuffleRange(internal::Random* random, int begin, int end,
std::vector<E>* v) {
const int size = static_cast<int>(v->size());
GTEST_CHECK_(0 <= begin && begin <= size)
<< "Invalid shuffle range start " << begin << ": must be in range [0, "
<< size << "].";
GTEST_CHECK_(begin <= ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rdi, %r15
movq 0x8(%rcx), %r12
subq (%rcx), %r12
shrq $0x2, %r12
testl %esi, %esi
js 0x301d9
cmpl %r14d, %r12d
jge 0x30271
leaq 0xb3d2(%rip), %rdx # 0x3b5... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
cmpl $0x2, (%rdi)
jl 0x304e7
movq %rdi, %r14
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x1, %r13d
leaq -0x58(%rbp), %r12
movslq %r13d, %r15
movq -0x30(%rbp), %rax
leaq (%ra... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x30(%rbp)
cmpl $0x2, (%rdi)
jl 0x30659
movq %rdi, %r14
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl $0x1, %r13d
leaq -0x58(%rbp), %r12
movslq %r13d, %r15
movq -0x30(%rbp), %rax
leaq (%ra... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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]));
}
#if GTEST_HAS_ABSL
absl::Initi... | 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 0x1d4e8(%rip), %rsi # 0x4dba0
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2d744
movq 0x8(%r15), %rbx
movq (%r15), %r12
movq %r15, %rdi
callq 0x2d6da
cmpq %r12, %rbx
jne 0x3076b
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<wchar_t>(int*, wchar_t**) | 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]));
}
#if GTEST_HAS_ABSL
absl::Initi... | 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 0x1d3e4(%rip), %rsi # 0x4dba0
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x2d744
movq 0x8(%r15), %rbx
movq (%r15), %r12
movq %r15, %rdi
callq 0x2d6da
cmpq %r12, %rbx
jne 0x3086f
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest.cc |
testing::internal::Arguments::Arguments() | Arguments() { args_.push_back(nullptr); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
callq 0x3411a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::Arguments::~Arguments() | ~Arguments() {
for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
++i) {
free(*i);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x30a31
movq (%r14), %rdi
callq 0x86c0
addq $0x8, %r14
cmpq 0x8(%rbx), %r14
jne 0x30a1f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30a49
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8520
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x1bfd5(%rip), %rcx # 0x4ca40
leaq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x1... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
testing::internal::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
: ForkingDeathTest(a_statement, std::move(matcher)) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1bf57(%rip), %rcx # 0x4ca40
leaq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x1bbc9(%rip), %rcx # 0x4c6d8
movq %rcx, (%rax)
movq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.cc |
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 0x9886(%rip), %rsi # 0x3a4b1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8620
leaq 0x8e44(%rip), %rsi # 0x39a80
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
cmpl $0xd, %r14d
ja 0x30c6b
movl %r14d, %e... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
void testing::internal::PrintCharAndCodeTo<signed char>(signed 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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x966c(%rip), %rsi # 0x3a4b1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8620
leaq 0x8c2a(%rip), %rsi # 0x39a80
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8620
cmpl $0xd, %r14d
ja 0x30e85
mov... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-printers.cc |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
leaq 0x1aee5(%rip), %rax # 0x4c320
movq %rax, (%rdi)
cmpl $-0x1, 0x34(%rdi)
jne 0x31456
addq $0x10, %rdi
addq $0xe8, %rsp
popq %rbx
popq %rbp
jmp 0x308a2
leaq -0xe0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x9960(%rip), %rsi # 0x3adc8
leaq 0x996c(%rip), %rd... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-death-test.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 %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x34a44
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x34b00
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [11]>(char const (&) [11]) | 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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult 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 0xf840
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x2b541
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x31b... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | 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 0xf840
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8230
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8620
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x88c0
testq %rax, %rax
je 0x324a6
movq %rax, %rdi
callq 0x3254b
movq %rax, %rbx
jmp 0x32527
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x8100
t... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.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) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x325e2
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xa2b6(%rip), %rax # 0x3c825
cmpq %rax, %rdi
je 0x325c4
cmpb $0x2a, (%rdi)
je 0x32589
leaq 0xa2a5(%rip), %rsi # 0x3c825
callq 0x8810
testl %eax, %eax
j... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x1a291(%rip), %rax # 0x4c9e8
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... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::Start() | void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } | 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 0x9058(%rip), %rsi # 0x3b871
leaq 0x9075(%rip), %rdx # 0x3b895
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x3470e
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x33fe8... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x8f8f(%rip), %rsi # 0x3b896
leaq 0x8f9e(%rip), %rdx # 0x3b8ac
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x3470e
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x33fe8... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int) | void OnTestIterationStart(const UnitTest& /* unit_test */,
int iteration) override {
SendLn("event=TestIterationStart&iteration=" +
StreamableToString(iteration));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %rsi
movl %edx, (%rsi)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x2f6a1
leaq 0x8f20(%rip), %rcx # 0x3b8ad
movl $0x23, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x85f0
leaq -0x20(%rbp), %r14
movq... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestCaseStart(testing::TestSuite const&) | void OnTestCaseStart(const TestCase& test_case) override {
SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x8e48(%rip), %rsi # 0x3b8d1
leaq 0x8e5a(%rip), %rdx # 0x3b8ea
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x3470e
movq 0x8(%r14), %rsi
mo... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x8d5e(%rip), %rsi # 0x3b8eb
leaq 0x8d6c(%rip), %rdx # 0x3b900
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x3470e
movq 0x20(%r14), %rsi
m... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x32c93
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x7814(%rip), %rsi # 0x3a4b1
cmovneq %rax, %rsi
leaq -0x130(%rbp)... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %r15
movq %r15, %rdi
callq 0x13160
testb %al, %al
je 0x33193
xorl %eax, %eax
jmp 0x3319d
movq %r15, %rdi
callq 0x131a6
xorb $0x1, %al
leaq 0x7e5a(%rip), %rcx # 0x3affe... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestSuite const&) | void OnTestCaseEnd(const TestCase& test_case) override {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
"&elapsed_time=" + StreamableToString(test_case.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 0x31dde
leaq 0x7aaf(%rip), %rcx # 0x3affe
leaq 0x877d(%rip), %rsi # 0x3bcd3
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xd8(%rbp), %r12
movq %r12, -0x10(%r12)
l... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" +
FormatBool(unit_test.Passed()) + "&elapsed_time=" +
StreamableToString(unit_test.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 0x40(%rsi), %rdi
callq 0x2f70c
leaq 0x7702(%rip), %rcx # 0x3affe
leaq 0x83d0(%rip), %rsi # 0x3bcd3
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xd8(%rbp), %r12
movq %r12, -0x10(%... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x2f70c
leaq 0x735c(%rip), %rcx # 0x3affe
leaq 0x802a(%rip), %rsi # 0x3bcd3
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x7341(%rip), %rax # 0x... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::~SocketWriter() | ~SocketWriter() override {
if (sockfd_ != -1)
CloseConnection();
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18c22(%rip), %rax # 0x4c9e8
movq %rax, (%rdi)
cmpl $-0x1, 0x8(%rdi)
je 0x33dd7
movq %rbx, %rdi
callq 0x33f5c
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x33def
movq (%rax), %rsi
incq %rsi
callq 0x8520
movq 0x10(%rbx), %rdi
a... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x33ea8
leaq 0x7756(%rip), %rdx # 0x3b5b2
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x44a, %ecx # imm = 0x44A
callq 0x2a45a
movq 0x19172(%rip), %rdi # 0x4cfe8
leaq 0x7935(%r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x33fbe
leaq 0x7640(%rip), %rdx # 0x3b5b2
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x45b, %ecx # imm = 0x45B
callq 0x2a45a
movq 0x1905c(%rip), %rdi # 0x4cfe8
leaq 0x781f(%rip), %rsi # 0x3b7b2
movl $0x2... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SendLn(const std::string& message) { Send(message + "\n"); } | 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)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xa940
leaq 0x6490(%rip), %rsi # 0x3a4b0
movq %r14, %rdi
cal... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.h |
testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag() | ~InternalRunDeathTestFlag() {
if (write_fd_ >= 0)
posix::Close(write_fd_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %edi
testl %edi, %edi
js 0x340c1
callq 0x8b40
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x340de
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rd... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-death-test-internal.h |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>&&) | 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 0x3436c
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34354
cmpq $0x0, 0x18(%rax)
je 0x34354
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x34354
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x343c2
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x343aa
cmpq $0x0, 0x18(%rax)
je 0x343aa
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x343aa
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x34418
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34400
cmpq $0x0, 0x18(%rax)
je 0x34400
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x34400
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::operator=(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<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 0x3446e
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x34456
cmpq $0x0, 0x18(%rax)
je 0x34456
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x34456
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %r... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 0x34626
xorl %edi, %edi
callq 0x8670
movl (%r15), %esi
movl 0x4(%r15), %edi
callq 0x8490
movl 0x4(%r15), %edi
callq 0x8b40
movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF
movq 0x8(%r15), %rdi
... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
testing::internal::CapturedStream::~CapturedStream() | ~CapturedStream() {
remove(filename_.c_str());
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8a60
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x34706
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-port.cc |
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 0x348ae
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
callq 0x8230
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3470e
movq %r15, %rdi
movq ... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-printers.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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3495f
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
callq 0x8430
leaq (%r14,%rax,4), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x349a4
movq (%r15), %rdi
m... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-printers.h |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::~MatcherBase() | ~MatcherBase() override { Destroy(); } | pushq %rbp
movq %rsp, %rbp
leaq 0x18021(%rip), %rax # 0x4ca70
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x34a76
cmpq $0x0, 0x18(%rax)
je 0x34a76
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x34a76
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>> const&>::~MatcherBase() | ~MatcherBase() override { Destroy(); } | pushq %rbp
movq %rsp, %rbp
leaq 0x17ff3(%rip), %rax # 0x4caa0
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x34ad4
cmpq $0x0, 0x18(%rax)
je 0x34ad4
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x34ad4
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::~MatcherBase() | ~MatcherBase() override { Destroy(); } | pushq %rbp
movq %rsp, %rbp
leaq 0x17fc5(%rip), %rax # 0x4cad0
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x34b32
cmpq $0x0, 0x18(%rax)
je 0x34b32
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x34b32
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rbp
retq
movq %rax, %rdi
callq 0x2d7... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> 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 0xf840
movq %r15, %rdi
movq %r14, %rsi
callq 0xf9c0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0xb0d6
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x35cee
movq (%rdi), %rax... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest.h |
testing::internal::GTestFlagSaver::~GTestFlagSaver() | ~GTestFlagSaver() {
GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
GTEST_FLAG(break_on_failure) = break_on_failure_;
GTEST_FLAG(catch_exceptions) = catch_exceptions_;
GTEST_FLAG(color) = color_;
GTEST_FLAG(death_test_style) = death_test_style_;
GTEST_FLAG(death_test_use_fork) = ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x173dc(%rip) # 0x4dad3
movb 0x1(%rdi), %al
movb %al, 0x173d4(%rip) # 0x4dad4
movb 0x2(%rdi), %al
movb %al, 0x173cc(%rip) # 0x4dad5
leaq 0x8(%rdi), %rsi
leaq 0x173c4(%rip), %rdi # 0x4dad8
callq 0x82c0
leaq 0x2... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/src/gtest-internal-inl.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 %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8e(%rip), %rsi # 0x37129
leaq -0x10(%rbp), %rdi
callq 0x8940
testl %eax, %eax
je 0x3710b
movl %eax, %ebx
leaq 0x431e(%rip), %rdx # 0x3b3cf
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x706, %ecx # imm = 0x706
callq 0x2a45a
movq 0x15f1d(%rip)... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::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 %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x78(%rip), %rsi # 0x37129
leaq -0x10(%rbp), %rdi
callq 0x8940
testl %eax, %eax
je 0x37211
movl %eax, %ebx
leaq 0x4218(%rip), %rdx # 0x3b3cf
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x706, %ecx # imm = 0x706
callq 0x2a45a
movq 0x15e17(%rip)... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %r12
movq %r12, %rdi
callq 0xf840
movq (%r14), %r15
movq (%r12), %r14
addq $0x10, %r14
testq %r15, %r15
je 0x37614
movq %r15, %rdi
callq 0x8230
movq %rax, %rdx
jmp 0x37620
movl $0x6,... | /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-message.h |
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq 0x8(%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x377f7
testq %rdx, %rdx
je 0x377fa
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x8540
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.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... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Destroy(testing::internal::SharedPayloadBase*) | static void Destroy(SharedPayloadBase* shared) {
delete static_cast<SharedPayload*>(shared);
} | testq %rdi, %rdi
je 0x3785d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x3784a
movq (%rax), %rsi
incq %rsi
callq 0x8520
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8520
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::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::Match... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq 0x8(%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x37913
testq %rdx, %rdx
je 0x37916
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x8540
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.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 0x3796a
testq %rdx, %rdx
je 0x3796d
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rdi
movq 0x8(%rax), %rsi
callq 0x8540
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_trait... | 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... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
popq %rbp
retq
nop
| /metacall[P]core/build_O1/source/tests/src/google-test-depends/googletest/include/gtest/gtest-matchers.h |
aliyun::BatchCompute::StopJob(aliyun::BatchComputeStopJobRequestType const&, aliyun::BatchComputeStopJobResponseType*, aliyun::BatchComputeErrorInfo*) | int BatchCompute::StopJob(const BatchComputeStopJobRequestType& req,
BatchComputeStopJobResponseType* response,
BatchComputeErrorInfo* error_info) {
std::string str_response;
int status_code;
int ret = 0;
bool parse_success = false;
Json::Value val;
Json::... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc8(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x21910
leaq 0x198(%rsp), %rdi
cal... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun-api-batchcompute/2015-06-30/src/ali_batchcompute_stop_job.cc |
getHttpGmtTime[abi:cxx11]() | std::string getHttpGmtTime() {
time_t t = time(NULL);
char szBuf[128]={0};
strftime(szBuf , 127 , "%a, %d %b %Y %H:%M:%S" , gmtime(&t));
strcat(szBuf, " GMT");
return szBuf;
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x22650
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x70(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movap... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_roa_request.cpp |
AliRoaRequest::CommitRequest() | int AliRoaRequest::CommitRequest() {
std::string gmt_time = getHttpGmtTime();
std::string compose_url = this->method_ + "\n";
if(map_request_headers_.find("Accept") != map_request_headers_.end()) {
compose_url.append(map_request_headers_["Accept"]);
}
compose_url.append("\n");
if(map_request_he... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x21220
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x21860
leaq 0x544f0(%rip)... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/ali_roa_request.cpp |
encode_compute_md5[abi:cxx11](char*, int) | std::string encode_compute_md5(char* buf, int len) {
size_t output_len;
char output[512] = {};
char encoded[512] = {};
mbedtls_md_context_t ctx= {};
const mbedtls_md_info_t* md5_md = mbedtls_md_info_from_type(MBEDTLS_MD_MD5);
mbedtls_md_init_ctx(&ctx, md5_md);
mbedtls_md_update(&ctx, (const unsig... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d00
leaq 0x230(%rsp), %r15
movl $0x200, %edx ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/utils/ali_encode_utils.cpp |
mbedtls_base64_self_test | int mbedtls_base64_self_test( int verbose )
{
size_t len;
const unsigned char *src;
unsigned char buffer[128];
if( verbose != 0 )
mbedtls_printf( " Base64 encoding test: " );
src = base64_test_dec;
if( mbedtls_base64_encode( buffer, sizeof( buffer ), &len, src, 64 ) != 0 ||
... | pushq %rbp
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebx
testl %edi, %edi
je 0x2f708
leaq 0x44178(%rip), %rdi # 0x73879
xorl %eax, %eax
callq 0x21100
leaq 0x440d1(%rip), %rcx # 0x737e0
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x80, %esi
movl $0x40, %r8d
callq 0x22370
testl %eax, %eax
jne 0x2f798
leaq 0x44... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/base64.c |
mbedtls_ctr_drbg_random_with_add | int mbedtls_ctr_drbg_random_with_add( void *p_rng,
unsigned char *output, size_t output_len,
const unsigned char *additional, size_t add_len )
{
int ret = 0;
mbedtls_ctr_drbg_context *ctx = (mbedtls_ctr_drbg_context *) p_rng;
unsigned char add_inpu... | movl $0xffffffca, %eax # imm = 0xFFFFFFCA
cmpq $0x400, %rdx # imm = 0x400
ja 0x2fcd0
movl $0xffffffc8, %eax # imm = 0xFFFFFFC8
cmpq $0x100, %r8 # imm = 0x100
ja 0x2fcd0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
m... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ctr_drbg.c |
entropy_update | static int entropy_update( mbedtls_entropy_context *ctx, unsigned char source_id,
const unsigned char *data, size_t len )
{
unsigned char header[2];
unsigned char tmp[MBEDTLS_ENTROPY_BLOCK_SIZE];
size_t use_len = len;
const unsigned char *p = data;
if( use_len > MBEDTLS_E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x41, %rcx
jb 0x30284
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x22c80
movl $0x40, %r14d
movq %r12, %r15
leaq 0xe(%rsp), %rsi
m... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy.c |
mbedtls_entropy_gather | int mbedtls_entropy_gather( mbedtls_entropy_context *ctx )
{
int ret;
#if defined(MBEDTLS_THREADING_C)
if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
ret = entropy_gather_internal( ctx );
#if defined(MBEDTLS_THREADING_C)
if( mbedtls_mutex_unlock( &ctx->mutex ) !=... | jmp 0x302ba
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/entropy.c |
mbedtls_md_clone | int mbedtls_md_clone( mbedtls_md_context_t *dst,
const mbedtls_md_context_t *src )
{
if( dst == NULL || dst->md_info == NULL ||
src == NULL || src->md_info == NULL ||
dst->md_info != src->md_info )
{
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
dst->md_info->... | movl $0xffffaf00, %eax # imm = 0xFFFFAF00
testq %rdi, %rdi
je 0x30b5f
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %r8b
orb %dl, %r8b
jne 0x30b5f
cmpq (%rsi), %rcx
je 0x30b60
retq
pushq %rax
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
callq *0x48(%rcx)
xorl %eax, %eax
addq $0x8, %rsp
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/md.c |
mbedtls_sha256_starts | void mbedtls_sha256_starts( mbedtls_sha256_context *ctx, int is224 )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
if( is224 == 0 )
{
/* SHA-256 */
ctx->state[0] = 0x6A09E667;
ctx->state[1] = 0xBB67AE85;
ctx->state[2] = 0x3C6EF372;
ctx->state[3] = 0xA54FF53A;
c... | movq $0x0, (%rdi)
testl %esi, %esi
je 0x34769
movaps 0x43082(%rip), %xmm0 # 0x777e0
jne 0x34772
movaps 0x43089(%rip), %xmm1 # 0x777f0
jmp 0x34779
movaps 0x43060(%rip), %xmm0 # 0x777d0
je 0x34760
movaps 0x43087(%rip), %xmm1 # 0x77800
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%rdi)
movl %esi, 0x68(%rdi)
retq... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha256.c |
mbedtls_sha512 | void mbedtls_sha512( const unsigned char *input, size_t ilen,
unsigned char output[64], int is384 )
{
mbedtls_sha512_context ctx;
mbedtls_sha512_init( &ctx );
mbedtls_sha512_starts( &ctx, is384 );
mbedtls_sha512_update( &ctx, input, ilen );
mbedtls_sha512_finish( &ctx, output );
mb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movl $0xd8, %edx
xorl %esi, %esi
callq 0x21d00
testl %ebp, %ebp
je 0x35f77
movaps 0x41bd0(%rip), %xmm0 # 0x77b30
movaps 0x41bd9(%rip), %xmm1 # 0x77b40
movaps... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/sha512.c |
tls1_prf | static int tls1_prf( const unsigned char *secret, size_t slen,
const char *label,
const unsigned char *random, size_t rlen,
unsigned char *dstbuf, size_t dlen )
{
size_t nb, hs;
size_t i, j, k;
const unsigned char *S1, *S2;
unsigned char tmp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
leaq 0x18(%rsp), %rdi
callq 0x230d0
movq %r12, %rdi
callq 0x21970
movq %rax, %r13
addq %r15, %rax
addq $-0x6d, %rax
movl $0xffff8f00, %ec... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c |
ssl_prepare_handshake_record | static int ssl_prepare_handshake_record( mbedtls_ssl_context *ssl )
{
if( ssl->in_msglen < mbedtls_ssl_hs_hdr_len( ssl ) )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "handshake message too short: %d",
ssl->in_msglen ) );
return( MBEDTLS_ERR_SSL_INVALID_RECORD );
}
ssl->in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xe0(%rdi), %r9
movb 0x164(%rax), %al
andb $0x2, %al
shrb %al
movzbl %al, %eax
leaq 0x4(,%rax,8), %rax
cmpq %rax, %r9
jae 0x3adfa
leaq 0x3d427(%rip), %rdx # 0x781fc
leaq 0x3e765(%rip), %r8 ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c |
mbedtls_ssl_pk_alg_from_sig | mbedtls_pk_type_t mbedtls_ssl_pk_alg_from_sig( unsigned char sig )
{
switch( sig )
{
#if defined(MBEDTLS_RSA_C)
case MBEDTLS_SSL_SIG_RSA:
return( MBEDTLS_PK_RSA );
#endif
#if defined(MBEDTLS_ECDSA_C)
case MBEDTLS_SSL_SIG_ECDSA:
return( MBEDTLS_PK_ECDSA );
#endif
d... | xorl %eax, %eax
cmpl $0x3, %edi
sete %al
shll $0x2, %eax
cmpl $0x1, %edi
cmovel %edi, %eax
retq
| /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/ssl_tls.c |
mbedtls_timing_self_test | int mbedtls_timing_self_test( int verbose )
{
unsigned long cycles, ratio;
unsigned long millisecs, secs;
int hardfail;
struct mbedtls_timing_hr_time hires;
uint32_t a, b;
mbedtls_timing_delay_context ctx;
if( verbose != 0 )
mbedtls_printf( " TIMING tests note: will take some time!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edi, 0x4(%rsp)
testl %edi, %edi
je 0x3f1b7
leaq 0x3acb7(%rip), %rdi # 0x79e5b
callq 0x234d0
leaq 0x3ac2a(%rip), %rdi # 0x79dda
xorl %eax, %eax
callq 0x21100
movl $0x1, %ebx
leaq 0x10(%rsp), %r14
movq 0x5ecf8(%rip), %r12 ... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/timing.c |
x509_info_subject_alt_name | static int x509_info_subject_alt_name( char **buf, size_t *size,
const mbedtls_x509_sequence *subject_alt_name )
{
size_t i;
size_t n = *size;
char *p = *buf;
const mbedtls_x509_sequence *cur = subject_alt_name;
const char *sep = "";
size_t sep_len = 0;
... | pushq %r14
pushq %rbx
movq (%rsi), %rcx
movq (%rdi), %rax
testq %rdx, %rdx
je 0x4035d
leaq 0x3fffd(%rip), %r9 # 0x802e3
xorl %r11d, %r11d
leaq 0x39ddf(%rip), %r8 # 0x7a0cf
xorl %r10d, %r10d
movq 0x8(%rdx), %rbx
leaq (%rbx,%r10), %r14
subq %r14, %rcx
jbe 0x4036a
testb $0x1, %r11b
je 0x40328
cmpq $0x1, %r10
adc... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_info_key_usage | static int x509_info_key_usage( char **buf, size_t *size,
unsigned int key_usage )
{
int ret;
size_t n = *size;
char *p = *buf;
const char *sep = "";
KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATIO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq (%rdi), %r12
testb %bpl, %bpl
js 0x405ae
leaq 0x3fd37(%rip), %rcx # 0x802e3
jmp 0x405ed
leaq 0x39b83(%rip), %rdx # 0x7a138
leaq 0x3fd27(%rip), %rcx # 0x802e3
movq %r12, %rdi
movq %r1... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_crt_verify_child | static int x509_crt_verify_child(
mbedtls_x509_crt *child, mbedtls_x509_crt *parent,
mbedtls_x509_crt *trust_ca, mbedtls_x509_crl *ca_crl,
const mbedtls_x509_crt_profile *profile,
int path_cnt, uint32_t *flags,
int (*f_vrfy)(void *, mbedtls... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x20(%rsp)
movq 0xb0(%rsp), %r12
movl $0x0, 0xc(%rsp)
movq %r9, 0x28(%rsp)
cmpl $0x7, %r9d
jle 0x41223
movl $0xffffd900, %eax # imm = 0xFFFFD900
movl $0x8, %ecx
orl %ecx, (%r12)
jmp 0x4145e
movq %r8, %rbp
movq %rsi, %rbx... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
x509_get_dates | static int x509_get_dates( unsigned char **p,
const unsigned char *end,
mbedtls_x509_time *from,
mbedtls_x509_time *to )
{
int ret;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCT... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x30, %ecx
callq 0x22320
testl %eax, %eax
je 0x41603
addl $0xffffdc00, %eax # imm = 0xFFFFDC00
jmp 0x4163b
movq (%rbx), %r15
addq (%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rd... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/mbedtls-2.1.2/library/x509_crt.c |
Json::Reader::addComment(char const*, char const*, Json::CommentPlacement) | void
Reader::addComment( Location begin,
Location end,
CommentPlacement placement )
{
assert( collectComments_ );
if ( placement == commentAfterOnSameLine )
{
assert( lastValue_ != 0 );
lastValue_->setComment( std::string( begin, end ), placement );
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x10a(%rdi)
je 0x43592
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x1, %ecx
jne 0x43523
movq 0xe0(%rdi), %r15
testq %r15, %r15
je 0x435b1
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21830
lea... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_reader.cpp |
Json::Value::asInt64() const | Value::Int64
Value::asInt64() const
{
switch ( type_ )
{
case intValue:
return Int64(value_.int_);
case uintValue:
JSON_ASSERT_MESSAGE(isInt64(), "LargestUInt out of Int64 range");
return Int64(value_.uint_);
case realValue:
JSON_ASSERT_MESSAGE(InRange(value_.real_, minInt64, maxI... | pushq %r14
pushq %rbx
pushq %rax
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x465d8
movq %rdi, %rbx
leaq 0x345ee(%rip), %rcx # 0x7ab40
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rbx, %rdi
callq 0x22030
testb %al, %al
je 0x4659c
movq (%rbx), %rax
jmp 0x46594
movzbl (%rbx), %eax
jmp 0x46594
movsd (%rb... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Json::Value::asDouble() const | double
Value::asDouble() const
{
switch ( type_ )
{
case intValue:
return static_cast<double>( value_.int_ );
case uintValue:
#if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return static_cast<double>( value_.uint_ );
#else // if !defined(JSON_USE_INT64_DOUBLE_CONVERSION)
return integerToD... | pushq %r14
pushq %rbx
pushq %rax
movzbl 0x8(%rdi), %eax
cmpq $0x5, %rax
ja 0x46855
leaq 0x3436d(%rip), %rcx # 0x7ab70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvtsi2sdq (%rdi), %xmm0
jmp 0x4684d
cmpb $0x0, (%rdi)
jne 0x46845
xorpd %xmm0, %xmm0
jmp 0x4684d
movsd (%rdi), %xmm1
unpcklps 0x34437(%rip), %xm... | /aliyun-beta[P]aliyun-openapi-cpp-sdk/aliyun_api_core/third_party/jsoncpp/src/lib_json/json_value.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.