name string | code string | asm string | file string |
|---|---|---|---|
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_repor... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x14f655(%rip), %rcx # 0x353c30
movq %rcx, (%rax)
callq 0x2247e0
movq %rax, -0x18(%rbp)
jmp 0x2045e9
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x2046... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x280(%rax)
jne 0x2054b3
movl $0x8, %edi
callq 0x2f710
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
callq 0x22d0b0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x280(%rax)
movq -0x10(%rbp), %r... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::Message::Message() | Message::Message() : ss_(new ::std::stringstream) {
// By default, we want there to be enough precision when printing
// a double to a Message.
*ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movl $0x188, %edi # imm = 0x188
callq 0x2f710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x2f4d0
jmp 0x2055f3
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
c... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTest... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x7491b(%rip), %rsi # 0x282998
xorl %eax, %eax
movl $0x2, %edi
callq 0x20ca60
movq -0x10(%rbp), %rdi
callq 0x20d370
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xf0(%... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream)... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x20f4b0
movq %rax, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x2f4d0
xorl %eax, %eax
leaq -0x1a8(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -... | /greg7mdp[P]parallel-hashmap/build_O0/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 %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x20f4b0
movq %rax, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2f4d0
xorl %eax, %eax
leaq -0x1a0(%rbp), %rcx
cmpq $0x0, %rcx
movq %rax, -0x1d8(%rbp)
je 0x210208... | /greg7mdp[P]parallel-hashmap/build_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x2fb40
movq -0x10(%rbp), %rdi
callq 0x2f4c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2fcc0
jmp 0x21097b
movq -0x10(%rbp), %rdi
callq ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::GetReservedOutputAttributesForElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) {
if (xml_element == "testsuites") {
return ArrayAsVector(kReservedTestSuitesAttributes);
} else if (xml_element == "testsuite") {
return ArrayAsVector(kReservedTestSuiteAttributes);
} else if (xml_e... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x71896(%rip), %rsi # 0x282d6c
callq 0x1eab00
testb $0x1, %al
jne 0x2114e1
jmp 0x2114f6
movq -0x38(%rbp), %rdi
leaq 0x142e64(%rip), %rsi ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonTestCaseForTestResult(std::ostream*, testing::TestResult const&) | void JsonUnitTestResultPrinter::OutputJsonTestCaseForTestResult(
::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a new test case.
*stream << Indent(8) << "{\n";
OutputJsonKey(stream, "testcase", "name", "", Indent(10));
OutputJsonKey(stream, "testcase", "status", "RUN", Ind... | pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp # imm = 0x4F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x410(%rbp)
movl $0x8, %esi
callq 0x2173b0
movq -0x418(%rbp), %rdi
movq -0x410(%rbp), %rsi
callq 0x2f640
movq %rax, -0x408(%... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<char32_t>(char32_t, std::ostream*) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
const char32_t u_c = ToChar32(c);
switch (u_c) {
case L'\0':
*os << "\\0";
break;
case L'\'':
*os << "\\'";
break;
case L'\\':
*os << "\\\\";
break;
case L'\a':
*os << "\\a";
break;
case... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x221470
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x5c, %rax
ja 0x2213d1
movq -0x20(%rbp), %rax
leaq 0x5f0ee(%rip), %rcx # 0x2803e4
movslq (%rcx,%rax,4), %rax
addq %... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest-printers.cc |
testing::internal::ParseGoogleTestFlag(char const*) | static bool ParseGoogleTestFlag(const char* const arg) {
#define GTEST_INTERNAL_PARSE_FLAG(flag_name) \
do { \
auto value = GTEST_FLAG_GET(flag_name); \
if (ParseFlag(arg, #flag_name, &value)) { \
GTEST_FLAG_SET(flag_name, value); \
return true; ... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movb 0x1321f7(%rip), %al # 0x355b8c
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5e3d6(%rip), %rsi # 0x281d7b
leaq -0x11(%rbp), %rdx
callq 0x224610
testb $0x1, %al
jne 0x2239b4
jmp 0x2239c8
movb -0... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [51]>(char const (&) [51]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>&&) | class GTEST_API_ Matcher<const std::string&>
: public internal::MatcherBase<const std::string&> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<const std::string&>(impl) {}
template <typename M, typename = typename std::remove_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x22f5d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.h |
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() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {}
explicit Matcher(const MatcherInterface<std::string>* impl)
: internal... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2399c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::operator=(testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>&&) | class GTEST_API_ Matcher<internal::StringView>
: public internal::MatcherBase<internal::StringView> {
public:
Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<internal::StringView>(impl) {}
explicit Matcher(const MatcherInterface<... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x22f8f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [10]>(char const (&) [10]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [22]>(char const (&) [22]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
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
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movsbl -0x1(%rbp), %edi
callq 0x220e30
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x2f6f0
movq %rax, %rdi
leaq 0x5bf01(%rip), %rsi # 0x28204a
callq 0x2f6f0
movb -0x1... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest-printers.cc |
testing::Message& testing::Message::operator<<<char [35]>(char const (&) [35]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [16]>(char const (&) [16]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.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 almost equal to val2.
const FloatingPoint<RawType> lhs(val1), ... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x3b8(%rbp)
movq %rdi, %rax
movq %rax, -0x3b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss -0x1c(%rbp), %xmm1
movss -0x20(%rbp), %xmm0
ucomiss %xmm1, %xm... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<char [60]>(char const (&) [60]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [18]>(char const (&) [18]) | inline Message& operator<<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the g... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [38]>(char const (&) [38]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo const*)) | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (auto it = c.begin(); it != c.end(); ++it) {
if (predicate(*it)) ++count;
}
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x243610
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x243680
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x243640
testb $0x1, %al
jne 0x229fb... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<char [8]>(char const (&) [8]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x2fda0
testb $0x1, %al
jne 0x22baf7
movq -0x18(%rbp), %rdi
callq 0x2f2b0
movq %rax, %rdi
callq 0x2fea0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x22baf5
leaq 0x563fe(%rip), %rdx # 0x281e80
lea... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.cc |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %edi
callq 0x2fc70
movq %rax, %rdi
callq 0x1f4590
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x2f930
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x22c24e
leaq 0x53416(%rip), %rdx # 0x27... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::internal::posix::FOpen(char const*, char const*) | inline FILE* FOpen(const char* path, const char* mode) {
#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
std::wstring_convert<wchar_codecvt> converter;
std::wstring wide_path = converter.from_bytes(path);
std::wstrin... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f920
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<char [19]>(char const (&) [19]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2fb40
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x22d5a0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x58(%rbp), %rdi... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/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]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x21d7f0
testb $0x1, %al
jne 0x22d8ab
jmp 0x22d8b0
jmp 0x22d94c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jg 0x22d8be
jmp 0x22d94c
leaq 0x128393(%rip), %rdi # 0x355c58
callq 0x50520
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest.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() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {}
explicit Matcher(const MatcherInterface<std::string>* impl)
: internal... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2259d0
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x2f740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x22f5f8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22f62d
movq -0x20(%rbp), %rdi
callq 0x22f640
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::internal::CapturedStream::CapturedStream(int) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
#ifdef GTEST_OS_WINDOWS
char temp_dir_path[MAX_PATH + 1] = {'\0'}; // NOLINT
char temp_file_path[MAX_PATH + 1] = {'\0'}; // NOLINT
::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
const UINT success = ::GetTempFileNameA(temp_d... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %edi
callq 0x2fc90
movq -0x60(%rbp), %rdi
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2fb40
leaq -0x30(%rb... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest-port.cc |
testing::Message& testing::Message::operator<<<testing::TestPartResult>(testing::TestPartResult 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x200a60
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %edi
callq 0x2fc70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2360f0
movq -0x18(%rbp), %rdi
callq 0x2361e0
movq %rax, %rdi
callq 0x2362c0
movq %rax, -0x8(%rbp)
jmp 0x2361c0
movq -0x48(%r... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-port.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
subq $0x110, %rsp # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e410
movq -0x100(%rbp), %rsi
movzbl %al, %edx
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x239... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x1f99b0
testb $0x1, %al
jne 0x238b2c
jmp 0x238b2e
jmp 0x238b9e
leaq 0x4ac9c(%rip), %rdx # 0x2837d1
leaq -0xc(%rbp), %rdi
movq %rdi, -... | /greg7mdp[P]parallel-hashmap/build_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x239559
movq -0x10(%rbp), %rdi
leaq 0x4a734(%rip), %rsi # 0x283c86
callq 0x2f6f0
jmp 0x2395d2
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2f330
m... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-printers.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatc... | 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23aa30
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x23aa70
leaq -0x18(%rbp), %rdi
callq 0x23aa50
movq (%rax), %rax
addq $0x3... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23b380
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x23b3c0
leaq -0x18(%rbp), %rdi
callq 0x23b3a0
movq (%rax), %rax
addq $0x3... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::Message& testing::Message::operator<<<char [106]>(char const (&) [106]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [29]>(char const (&) [29]) | 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x47e50
movq %rax, %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x2f6f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-message.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
subq $0x40, %rsp
leaq -0x4(%rbp), %rdi
leaq -0x53873(%rip), %rsi # 0x1f4590
callq 0x2fcf0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x247e97
leaq 0x377e8(%rip), %rdx # 0x27f604
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x70a, %ecx # imm = 0x70A
... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-port.h |
ConvertBytesToInteger_4(unsigned char*) | DWORD ConvertBytesToInteger_4(LPBYTE ValueAsBytes)
{
DWORD Value = 0;
Value = (Value << 0x08) | ValueAsBytes[0];
Value = (Value << 0x08) | ValueAsBytes[1];
Value = (Value << 0x08) | ValueAsBytes[2];
Value = (Value << 0x08) | ValueAsBytes[3];
return Value;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%r... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/Common.cpp |
CaptureContentKey(unsigned char*, unsigned char*, _CONTENT_KEY**) | LPBYTE CaptureContentKey(LPBYTE pbDataPtr, LPBYTE pbDataEnd, PCONTENT_KEY * PtrCKey)
{
// Is there enough data?
if((pbDataPtr + sizeof(CONTENT_KEY)) > pbDataEnd)
return NULL;
// Give data
PtrCKey[0] = (PCONTENT_KEY)pbDataPtr;
// Return the pointer to data following after the integer
re... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
cmpq -0x18(%rbp), %rax
jbe 0xdc18
movq $0x0, -0x8(%rbp)
jmp 0xdc2f
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/Common.cpp |
CombinePath(char const*, char const*) | TCHAR * CombinePath(const TCHAR * szDirectory, const TCHAR * szSubDir)
{
TCHAR * szFullPath = NULL;
TCHAR * szPathPtr;
size_t nLength1 = 0;
size_t nLength2 = 0;
// Calculate lengths of each part
if(szDirectory != NULL)
{
// Get the length of the directory
nLength1 = _tcslen(... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xdefa
movq -0x8(%rbp), %rdi
callq 0xc470
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jbe 0xdee1
... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/Common.cpp |
FileStream_Prefix(char const*, unsigned int*) | size_t FileStream_Prefix(const TCHAR * szFileName, DWORD * pdwProvider)
{
size_t nPrefixLength1 = 0;
size_t nPrefixLength2 = 0;
DWORD dwProvider = 0;
if(szFileName != NULL)
{
//
// Determine the stream provider
//
if(!_tcsnicmp(szFileName, _T("flat-"), 5))
{... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10030
movq -0x10(%rbp), %rdi
leaq 0x2136f(%rip), %rsi # 0x311fc
movl $0x5, %edx
callq 0xcf70
cmpl $0x0, %eax
jne 0xfeb2
movl -0x2... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
PartStream_Open(char const*, unsigned int) | static TFileStream * PartStream_Open(const TCHAR * szFileName, DWORD dwStreamFlags)
{
TBlockStream * pStream;
// Create new empty stream
pStream = (TBlockStream *)AllocateFileStream(szFileName, sizeof(TBlockStream), dwStreamFlags);
if(pStream == NULL)
return NULL;
// Do we have a master st... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x100, %esi # imm = 0x100
callq 0xfb20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x102d8
movq $0x0, -0x8(%rbp)
jmp 0x1042f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
Block4Stream_Open(char const*, unsigned int) | static TFileStream * Block4Stream_Open(const TCHAR * szFileName, DWORD dwStreamFlags)
{
TBaseProviderData * NewBaseArray = NULL;
ULONGLONG RemainderBlock;
ULONGLONG BlockCount;
ULONGLONG FileSize;
TBlockStream * pStream;
TCHAR * szNameBuff;
size_t nNameLength;
DWORD dwBaseFiles = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0x100, %esi # imm = 0x100
callq 0xfb20
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x10607
movq $0x0, -0x8(%rbp)
jm... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FileStream_Read(TFileStream*, unsigned long long*, void*, unsigned int) | bool FileStream_Read(TFileStream * pStream, ULONGLONG * pByteOffset, void * pvBuffer, DWORD dwBytesToRead)
{
//FILE * fp = fopen("E:\\Loading.txt", "at");
//if(fp != NULL)
//{
// ULONGLONG ByteOffset = (pByteOffset != NULL) ? pByteOffset[0] : 0;
// fprintf(fp, "%-32ws\t%08X\t%08X\n", GetPlainF... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10a73
jmp 0x10a92
leaq 0x207ab(%rip), %rdi # 0x31225
leaq 0x206d6(%rip), %rsi # 0x31157
movl $0xa1c, %edx # imm = 0xA1C
l... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseFile_Replace(TFileStream*, TFileStream*) | static bool BaseFile_Replace(TFileStream * pStream, TFileStream * pNewStream)
{
#ifdef PLATFORM_WINDOWS
// Delete the original stream file. Don't check the result value,
// because if the file doesn't exist, it would fail
DeleteFile(pStream->szFileName);
// Rename the new file to the old stream's file
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rsi
callq 0xc670
cmpl $-0x1, %eax
jne 0x10e12
callq 0xc060
movl (%rax), %edi
callq 0xca30
movb $0x0, -0x1(%rbp)
jmp 0x10e16
movb $0x1, -0x1(%rbp... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FileStream_Close(TFileStream*) | void FileStream_Close(TFileStream * pStream)
{
// Check if the stream structure is allocated at all
if(pStream != NULL)
{
// Free the master stream, if any
if(pStream->pMaster != NULL)
FileStream_Close(pStream->pMaster);
pStream->pMaster = NULL;
// Close the stre... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10fcf
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x10f81
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xcd40
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x10fab
movq -0x8(... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseMap_Init(TFileStream*) | static void BaseMap_Init(TFileStream * pStream)
{
// Supply the file stream functions
pStream->BaseOpen = BaseMap_Open;
pStream->BaseRead = BaseMap_Read;
pStream->BaseGetSize = BaseFile_GetSize; // Reuse BaseFile function
pStream->BaseGetPos = BaseFile_GetPos; // Reuse BaseFile functio... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x49d(%rip), %rcx # 0x11520
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
leaq 0x5be(%rip), %rcx # 0x11650
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
leaq 0x3cf(%rip), %rcx # 0x11470
movq %rcx, 0x68(%rax)
movq -0x8(%rbp), %rax
... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseFile_Read(TFileStream*, unsigned long long*, void*, unsigned int) | static bool BaseFile_Read(
TFileStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1118b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x1119a
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x48(%rbp)
movq -... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseFile_Resize(TFileStream*, unsigned long long) | static bool BaseFile_Resize(TFileStream * pStream, ULONGLONG NewFileSize)
{
#ifdef PLATFORM_WINDOWS
{
LONG FileSizeHi = (LONG)(NewFileSize >> 32);
LONG FileSizeLo;
DWORD dwNewPos;
bool bResult;
// Set the position at the new file size
dwNewPos = SetFilePointer(pStrea... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movl %eax, %edi
movq -0x18(%rbp), %rsi
callq 0xc4c0
cmpl $-0x1, %eax
jne 0x1144d
callq 0xc060
movl (%rax), %edi
callq 0xca30
movb $0x0, -0x1(%rbp)
jmp 0x11460
movq -0x18(%rbp), %rcx
mov... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseMap_Open(TFileStream*, char const*, unsigned int) | static bool BaseMap_Open(TFileStream * pStream, const TCHAR * szFileName, DWORD dwStreamFlags)
{
#ifdef PLATFORM_WINDOWS
ULARGE_INTEGER FileSize;
HANDLE hFile;
HANDLE hMap;
bool bResult = false;
// Keep compiler happy
dwStreamFlags = dwStreamFlags;
// Open the file for read access
hFi... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0xb9(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0xc840
cltq
movq %rax, -0xb8(%rbp)
cmpq $-0x1, -0xb8(%rbp)
je 0x11615
movq -0xb8(%rbp), %rax
movl %eax, %edi
leaq -0xb0(%rbp... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseMap_Close(TFileStream*) | static void BaseMap_Close(TFileStream * pStream)
{
#ifdef PLATFORM_WINDOWS
if(pStream->Base.Map.pbFile != NULL)
UnmapViewOfFile(pStream->Base.Map.pbFile);
#endif
#if defined(PLATFORM_MAC) || defined(PLATFORM_LINUX)
if(pStream->Base.Map.pbFile != NULL)
munmap(pStream->Base.Map.pbFile, (size_t )p... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x11735
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rsi
callq 0xc5e0
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BaseHttp_Read(TFileStream*, unsigned long long*, void*, unsigned int) | static bool BaseHttp_Read(
TFileStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead) ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
mov... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FlatStream_CreateMirror(TBlockStream*) | static bool FlatStream_CreateMirror(TBlockStream * pStream)
{
ULONGLONG MasterSize = 0;
ULONGLONG MirrorSize = 0;
LPBYTE FileBitmap = NULL;
DWORD dwBitmapSize;
DWORD dwBlockCount;
bool bNeedCreateMirrorStream = true;
bool bNeedResizeMirrorStream = true;
// Do we have master function and... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x1, -0x31(%rbp)
movb $0x1, -0x32(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x11835
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x1183e
movb $0x0, -0x1(%rbp)
jmp... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
BlockStream_Read(TBlockStream*, unsigned long long*, void*, unsigned int) | static bool BlockStream_Read(
TBlockStream * pStream, // Pointer to an open stream
ULONGLONG * pByteOffset, // Pointer to file byte offset. If NULL, it reads from the current position
void * pvBuffer, // Pointer to data to be read
DWORD dwBytesToRead... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x64(%rbp)
movb $0x0, -0x6a(%rbp)
movb $0x1, -0x6c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x11bdc
jmp 0x11bfb
le... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FlatStream_BlockCheck(TBlockStream*, unsigned long long) | static bool FlatStream_BlockCheck(
TBlockStream * pStream, // Pointer to an open stream
ULONGLONG BlockOffset)
{
LPBYTE FileBitmap = (LPBYTE)pStream->FileBitmap;
DWORD BlockIndex;
BYTE BitMask;
// Sanity checks
assert((BlockOffset & (pStream->BlockSize - 1)) == 0);
assert... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0xec(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x121ad
jmp 0x121cc
leaq 0x1f... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FlatStream_CheckFile(TBlockStream*) | static DWORD FlatStream_CheckFile(TBlockStream * pStream)
{
LPBYTE FileBitmap = (LPBYTE)pStream->FileBitmap;
DWORD WholeByteCount = (pStream->BlockCount / 8);
DWORD ExtraBitsCount = (pStream->BlockCount & 7);
BYTE ExpectedValue;
// Verify the whole bytes - their value must be 0xFF
for(DWORD i =... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xf0(%rax), %eax
shrl $0x3, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xf0(%rax), %eax
andl $0x7, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
FlatStream_UpdateBitmap(TBlockStream*, unsigned long long, unsigned long long) | static void FlatStream_UpdateBitmap(
TBlockStream * pStream, // Pointer to an open stream
ULONGLONG StartOffset,
ULONGLONG EndOffset)
{
LPBYTE FileBitmap = (LPBYTE)pStream->FileBitmap;
DWORD BlockIndex;
DWORD BlockSize = pStream->BlockSize;
DWORD ByteIndex;
BYTE BitMask;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xec(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %... | /Qartar[P]CascLibPlus/lib/CascLib/src/common/FileStream.cpp |
CascSetFilePointer | DWORD WINAPI CascSetFilePointer(HANDLE hFile, LONG lFilePos, LONG * plFilePosHigh, DWORD dwMoveMethod)
{
TCascFile * hf;
ULONGLONG FilePosition;
ULONGLONG MoveOffset;
DWORD dwFilePosHi;
// If the hFile is not a valid file handle, return an error.
hf = IsValidCascFileHandle(hFile);
if(hf == ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcc60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1e660
movl $0x9, %edi
callq 0xca30
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e76c
m... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascReadFile.cpp |
LoadEncodedFrame(TFileStream*, _CASC_FILE_FRAME*, unsigned char*, unsigned int) | static int LoadEncodedFrame(TFileStream * pStream, PCASC_FILE_FRAME pFrame, LPBYTE pbEncodedFrame, DWORD dwVerifyIntegrity)
{
ULONGLONG FileOffset = pFrame->DataFileOffset;
int nError = ERROR_SUCCESS;
// Load the encoded frame to memory
if(FileStream_Read(pStream, &FileOffset, pbEncodedFrame, pFrame->E... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
leaq... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascReadFile.cpp |
TDiabloRoot::TDiabloRoot() | TDiabloRoot() : TFileTreeRoot(0)
{
memset(RootFolders, 0, sizeof(RootFolders));
pFileIndices = NULL;
pbCoreTocFile = NULL;
pbCoreTocData = NULL;
nFileIndices = 0;
cbCoreTocFile = 0;
// Map for searching a real file extension
pPackagesMap = NULL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
callq 0xcc10
movq -0x10(%rbp), %rdi
movq 0x2174a(%rip), %rax # 0x40fa0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x78, %rdi
xorl %esi, %esi
movl $0x700, %edx # imm = 0x700
callq 0... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_Diablo3.cpp |
TDiabloRoot::ParseDirectory_Phase2() | int ParseDirectory_Phase2()
{
PATH_BUFFER PathBuffer;
char szPathBuffer[MAX_PATH];
// Parse each root subdirectory
for(size_t i = 0; i < DIABLO3_MAX_ROOT_FOLDERS; i++)
{
// Is this root folder loaded?
if(RootFolders[i].pbDirectoryData != NULL)
... | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x430(%rbp)
movq $0x0, -0x428(%rbp)
cmpq $0x20, -0x428(%rbp)
jae 0x2029a
movq -0x430(%rbp), %rax
addq $0x78, %rax
imulq $0x38, -0x428(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x20281
mov... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_Diablo3.cpp |
TRootHandler_MNDX::Search(_TCascSearch*) | LPBYTE Search(TCascSearch * hs)
{
TMndxMarFile * pMarFile = MndxInfo.MarFiles[2];
TMndxSearch * pSearch = NULL;
bool bFindResult = false;
// If the first time, allocate the structure for the search result
if(hs->pRootContext == NULL)
{
// Create the new s... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x438(%rax)
jne 0x21503
movl $0x30, %edi
callq 0xcc40
movq ... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
TMndxSearch::TMndxSearch() | TMndxSearch()
{
szSearchMask = NULL;
cchSearchMask = 0;
szFoundPath = NULL;
cchFoundPath = 0;
FileNameIndex = 0;
pStruct40 = NULL;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
| /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
TSparseArray::GetItemValueAt(unsigned long) | DWORD GetItemValueAt(size_t index)
{
BASEVALS & SetBitsCount = BaseVals[index >> 0x09];
DWORD IntValue;
DWORD BitMask;
//
// Since we don't want to count bits for the entire array,
// there are item value shortcuts every 0x200 items,
// and then every 0x40 it... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
shrq $0x9, %rsi
callq 0xd2e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
shrl $0... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
TFileNameDatabase::GetPathFragmentOffset2(unsigned int&, unsigned int) | DWORD GetPathFragmentOffset2(DWORD & index_hibits, DWORD index_lobits)
{
// If the hi-bits index is invalid, we need to get its starting value
if (index_hibits == CASC_INVALID_INDEX)
{
/*
printf("\n");
for (DWORD i = 0; i < CollisionHiBitsIndexes.TotalItemCount; i++)
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x22f33
movq -0x20(%rbp), %rdi
addq $0xe0, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0xcfb0
movl %eax, %ecx
m... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
TRootHandler_MNDX::FindMndxPackage(char const*) | PMNDX_PACKAGE FindMndxPackage(const char * szFileName)
{
PMNDX_PACKAGE pMatching = NULL;
size_t nMaxLength = 0;
size_t nLength = strlen(szFileName);
// Packages must be loaded
assert(Packages.ItemCount() != 0);
//FILE * fp = fopen("E:\\packages.txt", "wt");
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc470
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x80, %rdi
callq 0xc110
cmpq $0x0, %rax
je 0x244ad
j... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
TFileNameDatabase::SetChildDatabase(TFileNameDatabase*) | int SetChildDatabase(TFileNameDatabase * pNewDB)
{
if(pNewDB != NULL && pChildDB == pNewDB)
return ERROR_INVALID_PARAMETER;
if(pChildDB != NULL)
delete pChildDB;
pChildDB = pNewDB;
return ERROR_SUCCESS;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25dc9
movq -0x20(%rbp), %rax
movq 0x210(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x25dc9
movl $0x16, -0x4(%rbp)
jmp 0x25e1b
movq -0x20(%rbp), %rax
cmpq $0x0, ... | /Qartar[P]CascLibPlus/lib/CascLib/src/CascRootFile_MNDX.cpp |
crc32_little | local unsigned long crc32_little(crc, buf, len)
unsigned long crc;
const unsigned char FAR *buf;
unsigned len;
{
register u4 c;
register const u4 FAR *buf4;
c = (u4)crc;
c = ~c;
while (len && ((ptrdiff_t)buf & 3)) {
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
len--... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x290ec
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $... | /Qartar[P]CascLibPlus/lib/CascLib/src/zlib/crc32.c |
inflate_fast | void ZLIB_INTERNAL inflate_fast(strm, start)
z_streamp strm;
unsigned start; /* inflate()'s starting value for strm->avail_out */
{
struct inflate_state FAR *state;
unsigned char FAR *in; /* local strm->next_in */
unsigned char FAR *last; /* while in < last, enough input available */
uns... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x5, %ecx
mov... | /Qartar[P]CascLibPlus/lib/CascLib/src/zlib/inffast.c |
inflatePrime | int ZEXPORT inflatePrime(strm, bits, value)
z_streamp strm;
int bits;
int value;
{
struct inflate_state FAR *state;
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
state = (struct inflate_state FAR *)strm->state;
if (bits < 0) {
state->hold = 0;
state->bits = 0;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2af10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x2af1c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2afb9
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl ... | /Qartar[P]CascLibPlus/lib/CascLib/src/zlib/inflate.c |
updatewindow | local int updatewindow(strm, out)
z_streamp strm;
unsigned out;
{
struct inflate_state FAR *state;
unsigned copy, dist;
state = (struct inflate_state FAR *)strm->state;
/* if it hasn't been done already, allocate space for the window */
if (state->window == Z_NULL) {
state->window = (unsig... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2d65f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x20(%rbp... | /Qartar[P]CascLibPlus/lib/CascLib/src/zlib/inflate.c |
LDSampler::sample(std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>&, Vec2f_8&) | __m256 LDSampler::sample(std::mt19937 &rng, Vec2f_8 &samples){
if (!has_samples()){
return _mm256_set1_ps(0.f);
}
CACHE_ALIGN float x[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
CACHE_ALIGN float y[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
// Take at most 8 samples per sampling pass since that's how many we can
// fit... | movl 0x4(%rdi), %eax
addl 0x10(%rdi), %eax
vxorps %xmm0, %xmm0, %xmm0
cmpl %eax, 0x18(%rdi)
je 0x9181
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x80, %rsp
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
vmovdqa 0x1555(%rip), %ymm0 # 0xa520
vmovdqa %ymm0, 0x20(%r... | /Twinklebear[P]micro-packet/src/ld_sampler.cpp |
test | int test(char *URL)
{
int res;
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
res = once(URL, TRUE); /* old */
if(!res)
res = once(URL, FALSE); /* new */
curl_global_cleanup();
return res;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x3, %edi
callq 0x1100
testl %eax, %eax
je 0x124f
movq 0x2da9(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xdc3(%rip), %rsi # 0x2004
xorl %eax, %eax
callq 0x10c0
movl $0x7e, %ebp
jmp 0x1273
movq %rbx, %rdi
movl $0x1, %esi
callq 0x127c
movl %eax, %ebp
tes... | /komeilkma[P]curl/tests/libtest/lib554.c |
QtPromisePrivate::PromiseData<std::vector<int, std::allocator<int>>>::notify(QList<std::pair<QPointer<QThread>, std::function<void (std::vector<int, std::allocator<int>> const&)>>> const&) | void notify(const QVector<Handler>& handlers) Q_DECL_OVERRIDE
{
PromiseValue<T> value = m_value;
Q_ASSERT(!value.isNull());
for (const auto& handler : handlers) {
const auto& fn = handler.second;
qtpromise_defer(
[=]() {
fn(value.d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
leaq 0x58(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x27a22
movq 0x8(%r12), %r14
leaq 0x38(%rsp), %r15
imulq $0x30, 0x10(%r12), %rbx
addq $0x10, %r14
leaq 0x18(%rsp), %r12
testq %rbx, %rbx
je 0x278ab
movq %r12, %rdi
movq %r1... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
QtPromisePrivate::PromiseDataBase<std::vector<int, std::allocator<int>>, void (std::vector<int, std::allocator<int>> const&)>::dispatch() | void dispatch()
{
if (isPending()) {
return;
}
// A promise can't be resolved multiple times so once settled, its state can't
// change. When fulfilled, handlers must be called (a single time) and catchers
// ignored indefinitely (or vice-versa when the promise i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0x27f32
testb %al, %al
jne 0x27cbe
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x82f0
movups 0x20(%rbx), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x30(%rbx), %rax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x... | /simonbrunel[P]qtpromise/include/../src/qtpromise/qpromise_p.h |
Catch::registerTestCase(Catch::ITestCase*, char const*, Catch::NameAndDesc const&, Catch::SourceLineInfo const&) | void registerTestCase
( ITestCase* testCase,
char const* classOrQualifiedMethodName,
NameAndDesc const& nameAndDesc,
SourceLineInfo const& lineInfo ) {
getMutableRegistryHub().registerTest
( makeTestCase
( testCase,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0xde5a
movq %rax, %rbx
leaq 0x70(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x145a4
leaq 0x50(%rsp), %rdi
movq %r... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::getMutableRegistryHub() | inline RegistryHub*& getTheRegistryHub() {
static RegistryHub* theRegistryHub = CATCH_NULL;
if( !theRegistryHub )
theRegistryHub = new RegistryHub();
return theRegistryHub;
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x786aa(%rip) # 0x86510
jne 0xdef8
movl $0xd0, %edi
callq 0xa390
movq %rax, %rbx
leaq 0x771a0(%rip), %rax # 0x85020
movq %rax, (%rbx)
leaq 0x771ee(%rip), %rax # 0x85078
movq %rax, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x1e860
leaq 0x77502(%rip), %rax # 0x853a0... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::NotImplementedException::NotImplementedException(Catch::SourceLineInfo const&) | NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
: m_lineInfo( lineInfo ) {
std::ostringstream oss;
oss << lineInfo << ": function ";
oss << "not implemented";
m_what = oss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x753f8(%rip), %rax # 0x83938
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::DebugOutStream::DebugOutStream() | DebugOutStream::DebugOutStream()
: m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
m_os( m_streamBuf.get() )
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x75194(%rip), %rax # 0x83988
movq %rax, (%rdi)
movl $0x148, %edi # imm = 0x148
callq 0xa390
movq %rax, %r14
movq 0x7777d(%rip), %rax # 0x85f88
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x38(%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
mov... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::(anonymous namespace)::platformColourInstance() | IContext& getCurrentContext() {
return getCurrentMutableContext();
} | pushq %r14
pushq %rbx
pushq %rax
callq 0xe8cd
movq (%rax), %rcx
movq %rsp, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe9de
movq (%rdi), %rax
callq *0x80(%rax)
jmp 0xe9e0
xorl %eax, %eax
testl %eax, %eax
jne 0xe9f8
movl $0x1, %edi
callq 0xa630
movl %eax, %ecx
xorl %eax... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::AssertionInfo::AssertionInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::ResultDisposition::Flags) | AssertionInfo::AssertionInfo( std::string const& _macroName,
SourceLineInfo const& _lineInfo,
std::string const& _capturedExpression,
ResultDisposition::Flags _resultDisposition )
: macroName( _macroName ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x32c36
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::AssertionResult::~AssertionResult() | AssertionResult::~AssertionResult() {} | pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
leaq 0xa0(%rbx), %rax
cmpq %rax, %rdi
je 0xed6c
movq (%rax), %rsi
incq %rsi
callq 0xa3b0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0xed87
movq (%rax), %rsi
incq %rsi
callq 0xa3b0
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0xed9f
m... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const | std::string AssertionResult::getExpressionInMacro() const {
if( m_info.macroName.empty() )
return m_info.capturedExpression;
else
return m_info.macroName + "( " + m_info.capturedExpression + " )";
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xeed3
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x32c36
leaq 0x53cd0(%rip), %rsi # 0x62b62
movq %r15,... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const | std::string AssertionResult::getExpandedExpression() const {
return m_resultData.reconstructedExpression;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x70(%rsi), %rax
movq 0x78(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x32c36
movq %rbx, %rax
popq %rbx
retq
nop
| /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::AssertionResult::getSourceInfo() const | SourceLineInfo AssertionResult::getSourceInfo() const {
return m_info.lineInfo;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x32c36
movq 0x40(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::startsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool startsWith( std::string const& s, std::string const& prefix ) {
return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq 0x8(%rdi), %r13
movq 0x8(%rsi), %rbx
cmpq %rbx, %r13
jae 0xf174
xorl %r14d, %r14d
jmp 0xf1b1
movq %rdi, %rsi
xorl %r14d, %r14d
movq %rsp, %r12
movq %r12, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xa3e0
movq 0x8(%r12), %rdx
cm... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::TestCaseInfo::TestCaseInfo(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<char>> const&, std::set<std::__cxx11::ba... | TestCaseInfo::TestCaseInfo( std::string const& _name,
std::string const& _className,
std::string const& _description,
std::set<std::string> const& _tags,
SourceLineInfo const& _lineInfo )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x32c36
leaq 0x20(%r... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::operator<<(std::ostream&, Catch::Version const&) | std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << "."
<< version.minorVersion << "."
<< version.patchNumber;
if( !version.branchName.empty() ) {
os << "-" << version.branchName
<< "." << version.b... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0xa250
movq %rax, %r15
leaq 0x544b5(%rip), %r12 # 0x63e35
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xa410
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0xa250
movq %rax, %r15
movl $0x1, %edx
movq... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
Catch::ScopedMessage::ScopedMessage(Catch::ScopedMessage const&) | ScopedMessage::ScopedMessage( ScopedMessage const& other )
: m_info( other.m_info )
{} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x32c36
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rd... | /technitute[P]AttitudeMathLibrary/test/catch/catch.hpp |
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.