name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::ColoredPrintf(testing::internal::(anonymous namespace)::GTestColor, char const*, ...) | static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
static const bool in_color_mode =
// We don't condition this on GTEST_HAS_FILE_SYSTEM because we still need
// to be able to detect terminal I/O regardless.
ShouldUseColor(posix::IsATTY(posix:... | pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2447f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ShouldShard(char const*, char const*, bool) | bool ShouldShard(const char* total_shards_env, const char* shard_index_env,
bool in_subprocess_for_death_test) {
if (in_subprocess_for_death_test) {
return false;
}
const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
const int32_t shard_index = Int32FromEnvOrDie(shard_ind... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
testl %edx, %edx
jne 0x245d1
movq %rsi, %r14
pushq $-0x1
popq %rbp
movl %ebp, %esi
callq 0x248d0
movl %eax, %ebx
movq %r14, %rdi
movl %ebp, %esi
callq 0x248d0
movl %eax, %ebp
andl %ebx, %eax
cmpl $-0x1, %eax
je 0x245d1
cmpl $-0x1, %ebx
setne %al
cmpl $-0x1, %ebp
sete %c... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == nullptr) {
return default_val;
}
int32_t result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILUR... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, 0x18(%rsp)
callq 0x96c0
testq %rax, %rax
je 0x24945
movq %rax, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2021a
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x19a8e(%rip), %rsi # 0x3e395
callq 0x9510
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp),... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_para... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2018c
leaq 0x18113(%rip), %rdx # 0x3cb24
leaq 0x18526(%rip), %rcx # 0x3cf3e
movq %rsp, %rdi
movl %eax, %esi
callq 0x24aa9
leaq 0x19177(%rip), %rsi # 0x3dba0
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x24421
movq (%rsp), %rsi
movq 0x8(%rbx)... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
switch (result.type()) {
// If the test part succeeded, we don't need to do anything.
case TestPartResult::kSuccess:
return;
default:
// Print failure message from the assertion
// (e.g. expected this... | cmpl $0x0, (%rsi)
je 0x24bda
pushq %rax
movq %rsi, %rdi
callq 0x24bdb
movq 0x36377(%rip), %rax # 0x5af48
movq (%rax), %rdi
popq %rax
jmp 0x9660
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrintTestPartResult(testing::TestPartResult const&) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
const std::string& result = PrintTestPartResultToString(test_part_result);
printf("%s\n", result.c_str());
fflush(stdout);
// If the test program runs in Visual Studio or a debugger, the
// following statements add the test part result ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x231bd
movq (%rbx), %rdi
callq 0x9970
movq 0x3634b(%rip), %rax # 0x5af48
movq (%rax), %rdi
callq 0x9660
movq %rbx, %rdi
callq 0x9bb8
addq $0x20, %rsp
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Passed()) {
ColoredPrintf(GTestColor::kGreen, "[ OK ] ");
} else if (test_info.result()->Skipped()) {
ColoredPrintf(GTestColor::kGreen, "[ SKIPPED ] ");
} else {
ColoredPrintf(GTestColor::kRed, "[ ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %r14
movq %r14, %rdi
callq 0x3165a
testb %al, %al
je 0x24c3a
leaq 0x18fae(%rip), %rsi # 0x3dbe6
jmp 0x24c4d
movq %r14, %rdi
callq 0x22c30
testb %al, %al
je 0x24c51
leaq 0x18fa7(%rip), %rsi # 0x3dbf4
pushq $0x2
jmp 0x24c5a
leaq 0x18faa(%rip)... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseEnd(testing::TestSuite const&) | void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
if (!GTEST_FLAG_GET(print_time)) return;
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(GTestColor::kGreen, "[----------] ");
printf("%s from %s (%s ms total)\n\n", ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x36a39(%rip) # 0x5b7c1
jne 0x24e23
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x2018c
leaq 0x17d84(%rip), %rdx # 0x3cb24
leaq 0x18197(%rip), %rcx # 0x3cf3e
leaq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x24aa9
leaq 0x18de6(%rip), %rsi # 0x3dba0
push... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestEnd(testing::TestInfo const&) | void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
if (test_info.result()->Failed()) {
ColoredPrintf(GTestColor::kRed, "[ FAILED ] ");
PrintTestName(test_info.test_suite_name(), test_info.name());
PrintFullTestCommentIfPresent(test_info);
if (GTEST_FLAG_GET(print_time)) {
... | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x22c66
testb %al, %al
je 0x25470
leaq 0x18807(%rip), %rsi # 0x3dc02
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x24421
movq (%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x316e2
movq %rbx, %rdi
callq 0x24cdf
cmpb $0x1, 0x363a1(%rip) # 0x5b7c1
j... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::BriefUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x186f3(%rip), %rsi # 0x3db7d
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x24421
movq %rbx, %rdi
callq 0x2499c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x2497f
movq (%r14), %r14
movq %rbx, %rdi
callq 0x249c2
leaq 0x2... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::TestEventRepeater::Release(testing::TestEventListener*) | TestEventListener* TestEventRepeater::Release(TestEventListener* listener) {
for (size_t i = 0; i < listeners_.size(); ++i) {
if (listeners_[i] == listener) {
listeners_.erase(listeners_.begin() + static_cast<int>(i));
return listener;
}
}
return nullptr;
} | pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
addq $0x10, %rdi
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rax
subq %rsi, %rax
sarq $0x3, %rax
xorl %ecx, %ecx
movabsq $0x100000000, %rdx # imm = 0x100000000
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x256e8
cmpq %rbx, (%rsi,%r8,8)
je 0x256ec
incq %r8
addq %rdx, %rcx
jmp 0x256d5
xo... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::OpenFileForWriting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static FILE* OpenFileForWriting(const std::string& output_file) {
FILE* fileout = nullptr;
FilePath output_file_path(output_file);
FilePath output_dir(output_file_path.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
fileout = posix::FOpen(output_file.c_str(), "w");
}
if (fileout == ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9830
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x2f3a4
leaq 0x50(%rsp), %rdi
callq 0x9bb8
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x1b90c
leaq 0x10(%rsp), %rdi
call... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream*, testing::UnitTest const&) | void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
*stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
*stream << "<" << kTestsuites;
OutputXmlAttribute(stream, ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x181a9(%rip), %rsi # 0x3dee6
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x9200
leaq 0x1819e(%rip), %rsi # 0x3def1
movq %rbx, %rdi
callq 0x9510
leaq 0x181dc(%rip), %rsi # 0x3df3e
movq %rbx, %rdi
callq 0x9510
leaq 0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::ListTestsMatchingFilter(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
const std::vector<TestSuite*>& test_suites) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlTestsList(&stream, test_suites);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
fclose(xmlout);
} | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x25c15
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x93a0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x26214
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x203de
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
call... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(const std::string& str,
bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2021a
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rax), %r12
xorl %r13d, %r13d
leaq 0x28(%rsp), %rbx
cmpq 0x8(%r15), %r13
jae... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(static_cast<unsigned char>(*it)))
output.push_back(*it);
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x9980
movq (%r14), %rax
movl $0x2600, %ebp # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
c... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss.sss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %r15
pushq %r14
pushq %rbx
subq $0x280, %rsp # imm = 0x280
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rdx, %r14
leaq 0x228(%rsp), %rsi
movq %rax, %rdi
callq 0x26b6a
testb %al, %al
je 0x269e7
movl $0x76c, %eax # imm = 0x76C
addl 0x23c(%rsp... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != nullptr) {
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x17196(%rip), %rsi # 0x3dd2e
callq 0x9510
leaq 0x1717d(%rip), %r15 # 0x3dd21
leaq 0x1717a(%rip), %r12 # 0x3dd25
movq %r14, %rdi
movq %r15, %rsi
callq 0x9110
testq %rax, %rax
je 0x26be3
movq %rax, %r13
movq %rax, %rd... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlAttribute(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloc... | void XmlUnitTestResultPrinter::OutputXmlAttribute(
std::ostream* stream, const std::string& element_name,
const std::string& name, const std::string& value) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST_CHECK_(std::find(allowed_names.begi... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x26d6c
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x37415
cmpq 0x30(%rsp), %rax
jne 0x26cbc
leaq 0x163e7(%rip), %rdx ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "testcas... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16465(%rip), %rsi # 0x3de12
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9200
cmpb $0x0, 0x83(%r15)
jne 0x27dc4
leaq 0x1643c(%rip), %rsi # 0x3de0d
movq %rbx, %rdi
callq 0x9510
leaq 0x12e4c(%... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestProperties(std::ostream*, testing::TestResult const&) | void XmlUnitTestResultPrinter::OutputXmlTestProperties(
std::ostream* stream, const TestResult& result) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
if (result.test_property_count() <= 0) {
return;
}
*stream << " <" << kProperties << ">\n";
for (in... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x160ba(%rip), %rsi # 0x3df22
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x9200
leaq 0x160af(%rip), %rsi # 0x3df2d
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x9200
movq 0x... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream*, testing::TestSuite const&) | void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
*stream << " <" << kTestsuite;
OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
OutputXmlAttribute... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15d2a(%rip), %rsi # 0x3ddcd
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9200
leaq 0x15e83(%rip), %rsi # 0x3df3c
movq %rbx, %rdi
callq 0x9510
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x94b0
leaq 0x12757(... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void JsonUnitTestResultPrinter::OutputJsonKey(std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x26d6c
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0x37415
cmpq 0x38(%rsp),... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::TestPropertiesAsJson(testing::TestResult const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
const TestResult& result, const std::string& indent) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n"
<< indent << "\"" ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq %rsp, %rdi
callq 0x2021a
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %r12
movq 0x58(%r15), %rax
subq 0x50(%r15), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x2a03b... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
const TestResult& result) {
const std::string kIndent = Indent(10);
{
int failures = 0;
for (int i = 0; i < result.total_part_count(); ++i) {
const TestPartResult& part = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x29abc
xorl %ebp, %ebp
leaq 0x78(%rsp), %r15
xorl %ebx, %ebx
movq 0x40(%r14), %rax
subq 0x38(%r14), %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
cmpl %... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
const char* test_suite_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestsuite = "t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x138c8(%rip), %rsi # 0x3de12
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x9200
leaq 0x48(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x29abc
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
callq 0x29abc
le... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestSuite(std::ostream*, testing::TestSuite const&) | void JsonUnitTestResultPrinter::PrintJsonTestSuite(
std::ostream* stream, const TestSuite& test_suite) {
const std::string kTestsuite = "testsuite";
const std::string kIndent = Indent(6);
*stream << Indent(4) << "{\n";
OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
OutputJsonKey(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x132db(%rip), %rsi # 0x3ddcd
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x9200
leaq 0x58(%rsp), %rdi
pushq $0x6
popq %rsi
callq 0x29abc
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x2... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::StreamingListener::UrlEncode[abi:cxx11](char const*) | std::string StreamingListener::UrlEncode(const char* str) {
std::string result;
result.reserve(strlen(str) + 1);
for (char ch = *str; ch != '\0'; ch = *++str) {
switch (ch) {
case '%':
case '=':
case '&':
case '\n':
result.push_back('%');
result.append(String::FormatByt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x9220
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x9980
movabsq $0x2000006000000400, %r12 # imm = 0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultResultPrinter(testing::TestEventListener*) | void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
if (default_result_printer_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_result_printer_);
default_result_printer_ = listener;
if (listener != n... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
je 0x2b4db
movq %rdi, %r14
callq 0x2b478
testq %rax, %rax
je 0x2b4c0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x8(%r14)
testq %rbx, %rbx
je 0x2b4db
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != nullp... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x2b525
movq %rdi, %r14
callq 0x2b478
testq %rax, %rax
je 0x2b50a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x2b525
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RecordProperty(testing::TestProperty const&) | void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
std::string xml_element;
TestResult* test_result; // TestResult appropriate for property recording.
if (current_test_info_ != nullptr) {
xml_element = "testcase";
test_result = &(current_test_info_->result_);
} else if (current_tes... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
cmpq $0x0, 0x1e0(%rdi)
je 0x2b62f
leaq 0x127fb(%rip), %rsi # 0x3de12
leaq 0x8(%rsp), %rdi
callq 0x9b40
movl $0x90, %edi
addq 0x1e0(%r14), %rdi
jmp 0x2b673
cmpq ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
#ifdef GTEST_HAS_DEATH_TEST
const bool in_death_test_child_process =
!GTEST_FLAG_GET(internal_run_death_test).empty();
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test crea... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x30040(%rip) # 0x5b6f8
je 0x2b6be
xorl %esi, %esi
jmp 0x2b6cd
leaq 0x12a50(%rip), %rdi # 0x3e115
callq 0x96c0
movq %rax, %rsi
movq %rsp, %rdi
callq 0x3188c
movq 0x40(%rbx), %rdi
movb 0x30076(%rip), %al # 0x5b755
movb %al, 0x2c8(%rdi)
leaq 0x36(%rip), ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::RunAllTests() | bool UnitTestImpl::RunAllTests() {
// True if and only if Google Test is initialized before RUN_ALL_TESTS() is
// called.
const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
// Do not run any test if the --help flag was specified.
if (g_help_flag) return true;
// Repeats the call ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x2c742
movb $0x1, %r15b
cmpb $0x0, 0x3000f(%rip) # 0x5b751
jne 0x2bb69
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2c50e
callq 0x2c76f
movq 0x2a8(%rbx), %r14
xorl %edx, %edx
testq %r14, %r14
setne %dl
leaq 0xffa3(%... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnitTestImpl(testing::UnitTest*) | UnitTestImpl::UnitTestImpl(UnitTest* parent)
: parent_(parent),
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
default_global_test_part_result_reporter_(this),
default_per_thread_test_part_result_reporter_(this),
GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r12
leaq 0x2e4c6(%rip), %rax # 0x5a250
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x2f428
leaq 0x30(%r12), %rax
leaq 0x2e1ef(%rip), %rcx # 0x59f98
movq %rcx, 0x30(%r12)
movq %r1... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::~UnitTestImpl() | UnitTestImpl::~UnitTestImpl() {
// Deletes every TestSuite.
ForEach(test_suites_, internal::Delete<TestSuite>);
// Deletes every Environment.
ForEach(environments_, internal::Delete<Environment>);
delete os_stack_trace_getter_;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2e14b(%rip), %rax # 0x5a250
movq %rax, (%rdi)
leaq 0xb8(%rdi), %r14
leaq 0xec(%rip), %rsi # 0x2c202
movq %r14, %rdi
callq 0x31cdb
leaq 0xa0(%rbx), %r15
leaq 0xe2(%rip), %rsi # 0x2c20e
movq %r15, %rdi
callq 0x31ced
movq 0x280(%rbx), %rdi
testq %rd... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ParseGoogleTestFlagsOnly(int*, char**) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
#ifdef GTEST_HAS_ABSL_FLAGS
if (*argc <= 0) return;
std::vector<char*> positional_args;
std::vector<absl::UnrecognizedFlag> unrecognized_flags;
absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
absl::flat_hash_set<absl::strin... | jmp 0x32177
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TempDir[abi:cxx11]() | std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
#elif defined(GTEST_OS_LINUX_ANDROID)
return GetDirFromEnv({"TEST_TMPDIR... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x11331(%rip), %rax # 0x3e3e6
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x11329(%rip), %rax # 0x3e3eb
movq %rax, 0x8(%rsi)
leaq 0x11325(%rip), %rcx # 0x3e3f2
pushq $0x2
popq %rdx
callq 0x2d0de
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | Test* CreateTest() override { return factory_(); } | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %r15
pushq $0x60
popq %rdi
callq 0x9530
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x9830
addq $0x28, %r14
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dad4
movq %rsp, %rdi
callq 0x9bb8
movq %rbx, %rax
addq $0x20, %... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest.h |
bool testing::internal::ParseFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ParseFlag(const char* str, const char* flag_name, String* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag_name, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Sets *value to the value of the flag.
*... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x2cf76
movq %rax, %r14
testq %rax, %rax
je 0x2ebb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9b40
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) || SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
} | pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0xf6de(%rip), %rdi # 0x3e3dd
callq 0x2ce9a
testb %al, %al
jne 0x2ed2e
leaq 0xf6cf(%rip), %rdi # 0x3e3de
movq %rsp, %rsi
callq 0x2ce9a
testb %al, %al
jne 0x2ed2e
leaq 0xf236(%rip), %rdi # 0x3df58
movq %rsp, %rsi
callq 0x2ce9a
testb %al, %al
je 0x2ed41
leaq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::PrintColorEncoded(char const*) | static void PrintColorEncoded(const char* str) {
GTestColor color = GTestColor::kDefault; // The current color.
// Conceptually, we split the string into segments divided by escape
// sequences. Then we print one segment at a time. At the end of
// each iteration, the str pointer advances to the beginning o... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0xcece(%rip), %r15 # 0x3bc50
pushq $0x40
popq %rbx
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq %r15, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0x91f0
testq %rax, %rax
je 0x2ee2c
movq %rax, %r13
leaq 0x18(%rsp), %rax
movq %rax, 0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ParseFlag(char const*, char const*, bool*) | static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag_name, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Converts the string value to a bool.
*valu... | pushq %rbx
movq %rdx, %rbx
pushq $0x1
popq %rdx
callq 0x2cf76
testq %rax, %rax
je 0x2ee8b
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x2ee89
cmpl $0x66, %edx
je 0x2ee89
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x94b0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2eedc
movq (%rdi), %rax
callq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | 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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [20]>(char const (&) [20]) | 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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
int testing::internal::CountIf<std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>>, bool (*)(testing::TestSuite const*)>(std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&, bool (*)(testing::TestSuite 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 (auto it = c.begin(); it != c.end(); ++it) {
if (predicate(*it)) ++count;
}
return 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 0x2fc29
movq (%r15), %rdi
callq *%rbx
movzbl %al, %eax
addl %eax, %ebp
addq $0x8, %r15
jmp 0x2fc13
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [5]>(char const (&) [5]) | 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 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x9510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ffb2
movq (%rdi), %rax
callq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.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 0x2021a
movq %r15, %rdi
movq %r14, %rsi
callq 0x36c92
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3001c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [9]>(char const (&) [9]) | 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 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x9510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3008c
movq (%rdi), %rax
callq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | 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 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x9510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3040c
movq (%rdi), %rax
callq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [39]>(char const (&) [39]) | 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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [62]>(char const (&) [62]) | 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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [63]>(char const (&) [63]) | 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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), 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. I... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x2ef74
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x30fad
testb $0x1, %r12b
je 0x30f9b
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
p... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x9510
movq %rbx, %rax
popq %rbx
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-message.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
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 0xc8d0(%rip), %rsi # 0x3dc34
cmovneq %rdx, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x9200
movl %ebp, 0x28(%r15)
leaq 0x30(%r15)... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-test-part.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 g... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsbl (%rsi), %esi
callq 0x9640
movq %rbx, %rax
popq %rbx
retq
| /todo-group[P]lattice/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 file with a single "0... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xc396(%rip), %rax # 0x3dc34
cmoveq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x9200
cmpq $0x0, 0x8(%rbx)
je 0x318d8
movq (%rbx), %rdi
leaq 0xc9f1(%rip), %rsi # 0x3e2ae
callq 0x9670
movq %rax, %rbx
pushq $0x30
popq %rdi
movq %rax, %rsi
callq 0x9700... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile() | ~ScopedPrematureExitFile() {
#ifndef 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_ << "\" with... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x31a8f
movq (%rbx), %rdi
callq 0x9a90
testl %eax, %eax
je 0x31a8f
movl %eax, %ebp
leaq 0xb5f5(%rip), %rdx # 0x3d031
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
movl $0x13ef, %ecx # imm = 0x13EF
callq 0x1c88a
movq 0x29593(%rip), %rdi ... | /todo-group[P]lattice/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
... | movl %edi, %eax
testl %edi, %edi
jne 0x31e27
pushq %rax
callq 0x201da
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.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 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x1d992
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x33a00
movq (%rdi), %rax
call... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | 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 0x2021a
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x9510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33a98
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x33a70
movq (%rdi), %rax
callq... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-assertion-result.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 0x3165a
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x352dc
leaq 0xa1f5(%rip), %rsi # 0x3ee2a
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x2f1b7
leaq 0xa1f7(%rip), %rdx ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.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 0x35489
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x9ac0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d884
leaq 0x8(%rsp), %rdi
callq 0x90c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x9a89(%rip), %rsi ... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-printers.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 0x9780
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x30(%r14), %rdi
leaq 0x30(%rbx), %rsi
callq 0x9780
addq $0x50, %r14
addq $0x50, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/gtest-test-part.h |
testing::internal::FloatingPoint<double>::DistanceBetweenSignAndMagnitudeNumbers(unsigned long const&, unsigned long 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;
}
} | movq (%rdi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rax
btsq $0x3f, %rax
testq %rcx, %rcx
cmovsq %rdx, %rax
movq (%rsi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rsi
btsq $0x3f, %rsi
testq %rcx, %rcx
cmovsq %rdx, %rsi
movq %rax, %rcx
subq %rsi, %rcx
negq %rcx
subq %rsi, %rax
cmovbq %rcx, %rax
retq
nop
| /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::GTestFlagSaver::~GTestFlagSaver() | ~GTestFlagSaver() {
GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
GTEST_FLAG_SET(break_on_failure, break_on_failure_);
GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
GTEST_FLAG_SET(color, color_);
GTEST_FLAG_SET(death_test_style, death_test_style_);
GTEST_FLAG_SET(deat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movb (%rdi), %al
movb %al, 0x241ed(%rip) # 0x5b753
movb 0x1(%rdi), %al
movb %al, 0x241e5(%rip) # 0x5b754
movb 0x2(%rdi), %al
movb %al, 0x241dd(%rip) # 0x5b755
leaq 0x8(%rdi), %rsi
leaq 0x241d5(%rip), %rdi # 0... | /todo-group[P]lattice/build_O2/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
void phosg::expect_raises_fn<std::exception>(char const*, unsigned long, std::function<void ()>) | void expect_raises_fn<std::exception>(const char* file, uint64_t line, std::function<void()> fn) {
try {
fn();
expect_generic(false, "expected exception, but none raised", file, line);
} catch (const std::exception& e) {
return;
} catch (...) {
// TODO: It'd be nice to show SOMETHING about the thr... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x7674
leaq 0xee1e(%rip), %rsi # 0x16438
xorl %edi, %edi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x759a
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %rdi
callq 0x5130
cmpl $0x2, %r15d
je 0x7652
leaq 0xee17(%rip), ... | /fuzziqersoftware[P]phosg/src/UnitTest.cc |
phosg::escape_quotes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string escape_quotes(const string& s) {
string ret;
for (size_t x = 0; x < s.size(); x++) {
char ch = s[x];
if (ch == '\"') {
ret += "\\\"";
} else if (ch < 0x20 || ch > 0x7E) {
ret += string_printf("\\x%02X", static_cast<uint8_t>(ch));
} else {
ret += ch;
}
}
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xf0cf(%rip), %r15 # 0x169b8
leaq 0xf0cb(%rip), %r12 # 0x169bb
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
cmpq 0x... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::escape_url(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | string escape_url(const string& s, bool escape_slash) {
string ret;
for (char ch : s) {
if (isalnum(ch) || (ch == '-') || (ch == '_') || (ch == '.') ||
(ch == '~') || (ch == '=') || (ch == '&') || (!escape_slash && (ch == '/'))) {
ret += ch;
} else {
ret += string_printf("%%%02hhX", ch);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r13
movq 0x8(%rsi), %r14
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x7c20
movsbl (%r13,%rbp), %r12d
movl %r12d... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::LogLevel phosg::enum_for_name<phosg::LogLevel>(char const*) | LogLevel enum_for_name<LogLevel>(const char* name) {
if (!strcmp(name, "USE_DEFAULT")) {
return LogLevel::USE_DEFAULT;
} else if (!strcmp(name, "DEBUG")) {
return LogLevel::DEBUG;
} else if (!strcmp(name, "INFO")) {
return LogLevel::INFO;
} else if (!strcmp(name, "WARNING")) {
return LogLevel::W... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xeb5f(%rip), %rsi # 0x169fb
callq 0x54d0
testl %eax, %eax
je 0x7f08
leaq 0xeb5b(%rip), %rsi # 0x16a07
movq %rbx, %rdi
callq 0x54d0
testl %eax, %eax
je 0x7f0c
leaq 0xeb4e(%rip), %rsi # 0x16a0d
movq %rbx, %rdi
callq 0x54d0
testl %eax, %eax
je 0x7f10
le... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::print_log_prefix(_IO_FILE*, phosg::LogLevel) | void print_log_prefix(FILE* stream, LogLevel level) {
char time_buffer[32];
time_t now_secs = time(nullptr);
struct tm now_tm;
localtime_r(&now_secs, &now_tm);
strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%d %H:%M:%S", &now_tm);
char level_char = log_level_chars.at(static_cast<int>(level));
fprintf(s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x5300
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x51b0
leaq 0xea4a(%rip), %rdx # 0x16a56
leaq 0x10(%rsp), %r15
pushq $0x20
popq %rsi
movq %r15, %rdi
movq %r14... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::format_data(std::function<void (void const*, unsigned long)>, iovec const*, unsigned long, unsigned long, iovec const*, unsigned long, unsigned long) | void format_data(
function<void(const void*, size_t)> write_data,
const struct iovec* iovs,
size_t num_iovs,
uint64_t start_address,
const struct iovec* prev_iovs,
size_t num_prev_iovs,
uint64_t flags) {
if (num_iovs == 0) {
return;
}
size_t total_size = 0;
for (size_t x = 0; x ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, 0xd8(%rsp)
testq %rdx, %rdx
je 0x9eb3
movq %rcx, %r10
movq %rdi, %rbx
movq 0x210(%rsp), %rdi
movq 0xd8(%rsp), %rax
addq $0x8, %rax
xorl %r11d, %r11d
movq %rdx, %rcx
subq $0x1, %rcx
jb 0x8e30
addq (%ra... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::print_data(_IO_FILE*, std::vector<iovec, std::allocator<iovec>> const&, unsigned long, std::vector<iovec, std::allocator<iovec>> const*, unsigned long) | void print_data(
FILE* stream,
const vector<struct iovec>& iovs,
uint64_t start_address,
const vector<struct iovec>* prev_iovs,
uint64_t flags) {
if (prev_iovs) {
print_data(stream, iovs.data(), iovs.size(), start_address,
prev_iovs->data(), prev_iovs->size(), flags);
} else {
pr... | pushq %rax
movq %rcx, %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq (%rsi), %rsi
movq 0x8(%rdx), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
testq %rax, %rax
je 0xa19a
movq (%rax), %r10
movq 0x8(%rax), %r9
subq %r10, %r9
sarq $0x4, %r9
movq %r8, (%rsp)
movq %r10, %r8
jmp 0xa1a4
movq %r8, (%rsp)
xorl %r8d, %r8d
xorl %r9d, %r9d
cal... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::format_data[abi:cxx11](iovec const*, unsigned long, unsigned long, iovec const*, unsigned long, unsigned long) | string format_data(
const struct iovec* iovs,
size_t num_iovs,
uint64_t start_address,
const struct iovec* prev_iovs,
size_t num_prev_iovs,
uint64_t flags) {
StringWriter w;
// StringWriter::write is overloaded, so we have to static_cast here to
// specify which variant should be used
au... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, %r12
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movq %rdx, %r13
movq %rsi, %rbp
leaq 0xd2(%rip), %rax # 0xa318
leaq 0x50(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::format_data[abi:cxx11](void const*, unsigned long, unsigned long, void const*, unsigned long) | string format_data(const void* data, uint64_t size, uint64_t start_address, const void* prev, uint64_t flags) {
iovec iov;
iov.iov_base = const_cast<void*>(data);
iov.iov_len = size;
if (prev) {
iovec prev_iov;
prev_iov.iov_base = const_cast<void*>(prev);
prev_iov.iov_len = size;
return format_d... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
testq %r8, %r8
je 0xa3b0
leaq 0x20(%rsp), %rax
movq %r8, (%rax)
movq %rdx, 0x8(%rax)
movq %r9, (%rsp)
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %r8
movq %rdx, %r9
jmp 0xa3c5
movq %r9, (%rsp)
leaq 0x10(%rs... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::StringReader::sub(unsigned long, unsigned long) const | StringReader StringReader::sub(size_t offset, size_t size) const {
if (offset >= this->length) {
return StringReader();
}
if (offset + size > this->length) {
return StringReader(
reinterpret_cast<const char*>(this->data) + offset,
this->length - offset);
}
return StringReader(reinterpr... | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rdi
movq %rdi, %rax
subq %rdx, %rax
jbe 0xb638
leaq (%rcx,%rdx), %r8
addq 0x18(%rsi), %rdx
cmpq %rdi, %r8
jbe 0xb642
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
jmp 0xb64b
movq %rbx, %rdi
callq 0xb380
jmp 0xb652
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, ... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::StringReader::subx_bits(unsigned long) const | BitReader StringReader::subx_bits(size_t offset) const {
if (offset > this->length) {
throw out_of_range("sub-reader begins beyond end of data");
}
return BitReader(
reinterpret_cast<const char*>(this->data) + offset,
(this->length - offset) * 8);
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rsi), %rax
subq %rdx, %rax
jb 0xb7ec
movq %rdi, %rbx
addq 0x18(%rsi), %rdx
shlq $0x3, %rax
movq %rdx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xb0da
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x5180
movq %rax, %rbx
leaq 0xb527(%rip... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::StringReader::get_line[abi:cxx11](bool) | bool StringReader::eof() const {
return (this->offset >= this->length);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x28(%rsi), %rax
cmpq 0x20(%rsi), %rax
jae 0xbbae
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rbx), %rsi
addq 0x28(%r14), %rsi
cmpq 0x20(%r14), %rsi
jae 0xbb4f
movq %r1... | /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::count_zeroes(void const*, unsigned long, unsigned long) | size_t count_zeroes(const void* vdata, size_t size, size_t stride) {
const uint8_t* data = reinterpret_cast<const uint8_t*>(vdata);
size_t zero_count = 0;
for (size_t z = 0; z < size; z += stride) {
if (data[z] == 0) {
zero_count++;
}
}
return zero_count;
} | xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rsi, %rcx
jae 0xbccb
cmpb $0x1, (%rdi,%rcx)
adcq $0x0, %rax
addq %rdx, %rcx
jmp 0xbcb9
retq
| /fuzziqersoftware[P]phosg/src/Strings.cc |
phosg::load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string load_file(const string& filename) {
scoped_fd fd(filename, O_RDONLY);
ssize_t file_size = fstat(fd).st_size;
string data(file_size, 0);
ssize_t bytes_read = ::read(fd, data.data(), data.size());
if (bytes_read != file_size) {
if (errno == 0) {
throw runtime_error(string_printf("can\'t read f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
movl $0x1ed, %ecx # imm = 0x1ED
callq 0xee80
movl (%r14), %esi
leaq 0x78(%rsp), %rdi
callq 0xea7b
movq 0xa8(%rsp), ... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::fopen_binary_raw(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&) | static FILE* fopen_binary_raw(const string& filename, const string& mode) {
string new_mode = mode;
if (new_mode.find('b') == string::npos) {
new_mode += 'b';
}
FILE* f = fopen(filename.c_str(), new_mode.c_str());
if (!f) {
throw cannot_open_file(filename);
}
return f;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6efa
pushq $0x62
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc216
cmpq $-0x1, %rax
jne 0x1001f
leaq 0x8(%rsp), %rdi
pushq $0x62
popq %rsi
callq 0xbf16
movq (%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x5410
testq %rax,... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::fdopen_binary_raw(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static FILE* fdopen_binary_raw(int fd, const string& mode) {
string new_mode = mode;
if (new_mode.find('b') == string::npos) {
new_mode += 'b';
}
FILE* f = fdopen(fd, new_mode.c_str());
if (!f) {
throw cannot_open_file(fd);
}
return f;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6efa
pushq $0x62
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc216
cmpq $-0x1, %rax
jne 0x100f5
leaq 0x8(%rsp), %rdi
pushq $0x62
popq %rsi
callq 0xbf16
movq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x53b0
testq %rax, %... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::fopen_shared(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&, _IO_FILE*) | shared_ptr<FILE> fopen_shared(const string& filename, const string& mode, FILE* dash_file) {
if (dash_file && (filename == "-")) {
return shared_ptr<FILE>(dash_file, [](FILE*) {});
}
return shared_ptr<FILE>(fopen_binary_raw(filename, mode), fclose_raw);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rcx, %rcx
je 0x10211
movq %rcx, %r14
leaq 0x70c1(%rip), %rsi # 0x1727d
movq %r12, %rdi
callq 0x66f1
testb %al, %al
je 0x10211
movq %r14, (%rbx)
andq $0x0, 0x8(%rbx)
pushq $0x18
popq %rdi
callq 0x5340... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::rename(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&) | void rename(const std::string& old_filename, const std::string& new_filename) {
if (::rename(old_filename.c_str(), new_filename.c_str()) != 0) {
throw runtime_error("can\'t rename file " + old_filename + " to " + new_filename + ": " + string_for_error(errno));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x51f0
testl %eax, %eax
jne 0x102b7
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5180
movq %rax, %rbx
leaq 0x6fb9(%rip), %rsi # 0x172... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::unlink(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void unlink(const string& filename, bool recursive) {
if (recursive) {
if (isdir(filename)) {
for (const string& item : list_directory(filename)) {
unlink(filename + "/" + item, true);
}
if ((::rmdir(filename.c_str()) != 0) && (errno != ENOENT)) {
throw runtime_error("can\'t dele... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x10482
movq %rbx, %rdi
callq 0xeb71
testb %al, %al
je 0x10482
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0xdf69
leaq 0x70(%rsp), %r13
leaq 0x6e64(%rip), %r14 # 0x17295
movq %rsp, %r15
leaq 0x20(... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::make_fd_nonblocking(int) | void make_fd_nonblocking(int fd) {
int flags = fcntl(fd, F_GETFL, 0);
if (flags < 0) {
throw runtime_error("can\'t get socket flags: " + string_for_error(errno));
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
throw runtime_error("can\'t set socket flags: " + string_for_error(errno));
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edi, %ebx
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x51e0
testl %eax, %eax
js 0x1069b
orl $0x800, %eax # imm = 0x800
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x51e0
testl %eax, %eax
js 0x106f3
addq $0x... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::pipe() | pair<int, int> pipe() {
int fds[2];
if (::pipe(fds)) {
throw runtime_error("pipe failed: " + string_for_error(errno));
}
return make_pair(fds[0], fds[1]);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x8(%rsp), %rdi
callq 0x54c0
testl %eax, %eax
jne 0x107aa
movq 0x8(%rsp), %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x5180
movq %rax, %rbx
callq 0x5030
movl (%rax), %esi
leaq 0x10(%rsp), %rdi
callq 0x8b46
leaq 0x6b27(%rip)... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::Poll::add(int, short) | void Poll::add(int fd, short events) {
auto pred = [](const struct pollfd& x, const struct pollfd& y) {
return x.fd < y.fd;
};
struct pollfd pfd;
pfd.fd = fd;
pfd.events = events;
auto insert_it = upper_bound(this->poll_fds.begin(), this->poll_fds.end(),
pfd, pred);
if (insert_it != this->poll_... | pushq %rax
movl %esi, %eax
movl %esi, (%rsp)
movw %dx, 0x4(%rsp)
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
movq %rcx, %r8
subq %rsi, %r8
sarq $0x3, %r8
testq %r8, %r8
jle 0x10887
movq %r8, %r9
shrq %r9
movq %r9, %r10
notq %r10
addq %r8, %r10
leaq (%rsi,%r9,8), %r8
addq $0x8, %r8
cmpl %eax, -0x8(%r8)
cmovleq %r8, %rsi
cmov... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::Poll::remove(int, bool) | void Poll::remove(int fd, bool close_fd) {
auto pred = [](const struct pollfd& x, const struct pollfd& y) {
return x.fd < y.fd;
};
struct pollfd pfd;
pfd.fd = fd;
auto erase_it = lower_bound(this->poll_fds.begin(), this->poll_fds.end(),
pfd, pred);
if (erase_it != this->poll_fds.end() && erase_it... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x108e4
movq %rcx, %rdx
shrq %rdx
movq %rdx, %r8
notq %r8
addq %rcx, %r8
leaq (%rsi,%rdx,8), %rcx
addq $0x8, %rcx
cmpl %ebx, -0x8(%rcx)
cmovlq %rcx... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
phosg::Poll::poll(int) | unordered_map<int, short> Poll::poll(int timeout_ms) {
if (::poll(this->poll_fds.data(), this->poll_fds.size(), timeout_ms) < 0) {
if (errno == EINTR) {
return unordered_map<int, short>();
}
throw runtime_error("poll failed: " + string_for_error(errno));
}
unordered_map<int, short> ret;
for (... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
callq 0x55a0
testl %eax, %eax
js 0x1098c
leaq 0x30(%rbx), %rax
movq %rax, (%rbx)
movq $0x1, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movl $0x3f... | /fuzziqersoftware[P]phosg/src/Filesystem.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> phosg::join<std::deque<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>>>>>(std::deque<std::__cxx11::basic_string<cha... | std::string join(const ItemContainerT& items) {
std::string ret;
for (const auto& item : items) {
ret += item;
}
return ret;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x10(%rsi), %r14
movq 0x20(%rsi), %r13
movq 0x28(%rsi), %r15
movq 0x30(%rsi), %r12
cmpq %r12, %r14
je 0x10d96
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc714
addq $... | /fuzziqersoftware[P]phosg/src/Strings.hh |
phosg::name_for_pid[abi:cxx11](int) | string name_for_pid(pid_t pid) {
string command = string_printf("ps -ax -c -o pid -o command | grep ^\\ *%u\\ | sed s/[0-9]*\\ //g", pid);
auto f = popen_unique(command.c_str(), "r");
string name;
int ch;
while ((ch = fgetc(f.get())) != EOF) {
if (ch >= 0x20 && ch < 0x7F) {
name += ch;
}
}
... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %edx
movq %rdi, %rbx
leaq 0x479f(%rip), %rsi # 0x17580
leaq 0x58(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x7985
movq (%r14), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x64ea
leaq 0x3bc3(%rip), %rsi # 0x169cc
leaq 0x18(%rsp), %rdi
leaq 0x6... | /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::pid_for_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | pid_t pid_for_name(const string& name, bool search_commands, bool exclude_self) {
string lower_name = tolower(name);
pid_t self_pid = exclude_self ? getpid() : 0;
pid_t pid = 0;
for (const auto& it : list_processes(search_commands)) {
string lower_it_name = tolower(it.second);
if (!strstr(lower_it_nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rsi
movq %rsp, %rdi
callq 0x7774
xorl %ebx, %ebx
testl %r14d, %r14d
je 0x12f05
callq 0x5560
movl %eax, %ebx
movzbl %bpl, %esi
leaq 0x40(%rsp), %rdi
callq 0x1302e
xorl %ebp, %ebp
leaq 0x50(%rsp), %r15
leaq 0x20(%rsp... | /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::start_time_for_pid(int, bool) | uint64_t start_time_for_pid(pid_t pid, bool allow_zombie) {
#ifdef PHOSG_MACOS
(void)allow_zombie;
struct proc_taskallinfo ti;
int ret = proc_pidinfo(pid, PROC_PIDTASKALLINFO, 0, &ti, sizeof(ti));
if (ret <= 0) {
if (errno == ESRCH) {
return 0;
}
throw runtime_error("can\'t get start time for... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movl %esi, %ebp
movl %edi, %ebx
leaq 0x42cc(%rip), %rsi # 0x17670
movq %rsp, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x7985
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xe9b5
movq %rsp, %rdi
callq 0x6526
imulq $0x3b9aca00, 0x78(%rsp), %r14 # imm = 0x3B9ACA00
add... | /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::getpid_cached() | pid_t getpid_cached() {
if (!cached_this_process_pid) {
maybe_add_atfork_handler();
cached_this_process_pid = getpid();
}
return cached_this_process_pid;
} | movl 0x1001a(%rip), %eax # 0x23448
testl %eax, %eax
je 0x13433
retq
pushq %rax
cmpb $0x0, 0x1001d(%rip) # 0x23458
jne 0x13454
leaq 0x14eb(%rip), %rdx # 0x1492f
xorl %edi, %edi
xorl %esi, %esi
callq 0x15ec0
movb $0x1, 0x10004(%rip) # 0x23458
callq 0x5560
movl %eax, 0xffe9(%rip) # 0x23448
addq $0x8,... | /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::Subprocess::Subprocess(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> ... | Subprocess::Subprocess(const vector<string>& cmd, int stdin_fd, int stdout_fd,
int stderr_fd, const string* cwd, const unordered_map<string, string>* env)
: stdin_write_fd(-1),
stdout_read_fd(-1),
stderr_read_fd(-1),
child_pid(0),
exit_status(-1) {
set<int> parent_fds_to_close;
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r15
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movaps 0x40bc(%rip), %xmm0 # 0x17570
movups %xmm0, (%rdi)
orl $-0x1, 0x14(%rdi)
leaq 0x90(%rsp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r9, %r1... | /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::Subprocess::operator=(phosg::Subprocess&&) | Subprocess& Subprocess::operator=(Subprocess&& other) {
this->stdin_write_fd = other.stdin_write_fd;
this->stdout_read_fd = other.stdout_read_fd;
this->stderr_read_fd = other.stderr_read_fd;
this->child_pid = other.child_pid;
this->terminated = other.terminated;
this->exit_status = other.exit_status;
othe... | movq %rdi, %rax
movdqu (%rsi), %xmm0
movdqu %xmm0, (%rdi)
movb 0x10(%rsi), %cl
movb %cl, 0x10(%rdi)
movl 0x14(%rsi), %ecx
movl %ecx, 0x14(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rsi)
retq
| /fuzziqersoftware[P]phosg/src/Process.cc |
phosg::Subprocess::wait(bool) | int Subprocess::wait(bool poll) {
if (this->exit_status >= 0) {
return this->exit_status;
}
for (;;) {
int ret = waitpid(this->child_pid, &this->exit_status, poll ? WNOHANG : 0);
if (ret == -1) {
if (errno != EINTR) {
throw runtime_error("waitpid failed: " + string_for_error(errno));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0x14(%rdi), %eax
testl %eax, %eax
jns 0x13968
movq %rdi, %rbx
leaq 0x14(%rdi), %r14
movzbl %sil, %ebp
movl 0xc(%rbx), %edi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5280
cmpl $-0x1, %eax
jne 0x13957
callq 0x5030
cmpl $0x4, (%rax)
je 0x138e2
movq %rax, %r15... | /fuzziqersoftware[P]phosg/src/Process.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.