name string | code string | asm string | file string |
|---|---|---|---|
llvm::EnumEntry<unsigned char> const* llvm::SmallVectorTemplateCommon<llvm::EnumEntry<unsigned char>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::EnumEntry<unsigned char>, true>>(llvm::SmallVectorTemplateBase<llvm::EnumEntry<unsigned char>, true>*, llvm::EnumEntry<unsigned char> const&, ... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x1455a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,4), %rcx
cmpq %rbx, %rax
setbe %sil
... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<llvm::codeview::CodeViewRecordIO::RecordLimit, true>::push_back(llvm::codeview::CodeViewRecordIO::RecordLimit) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1460a6
movq (%r14), %rax
movl 0x8(%r14), %ecx
leaq (%rcx,%rcx,2), %rcx
movq %r15, (%rax,%rcx,4)
movb %bl, 0x8(%rax,%rcx,4)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x1... | /llvm/ADT/SmallVector.h |
freeset | static void
freeset(struct parse *p, cset *cs)
{
size_t i;
cset *top = &p->g->sets[p->g->ncsets];
size_t css = (size_t)p->g->csetsize;
for (i = 0; i < css; i++)
CHsub(cs, i);
if (cs == top-1) /* recover only the easy case */
p->g->ncsets--;
} | movq 0x38(%rdi), %rcx
movslq 0x14(%rcx), %rax
shlq $0x5, %rax
addq 0x18(%rcx), %rax
movslq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x149c18
xorl %edx, %edx
xorl %r8d, %r8d
movb 0x8(%rsi), %r9b
notb %r9b
movq (%rsi), %r10
movzbl %r8b, %r11d
andb %r9b, (%r10,%r11)
addb %dl, 0x9(%rsi)
incq %r8
decb %dl
cmpq %r8, %rcx
jne 0x1... | /Support/regcomp.c |
enlarge | static void
enlarge(struct parse *p, sopno size)
{
sop *sp;
if (p->ssize >= size)
return;
if ((uintptr_t)size > SIZE_MAX / sizeof(sop)) {
SETERROR(REG_ESPACE);
return;
}
sp = (sop *)realloc(p->strip, size*sizeof(sop));
if (sp == NULL) {
SETERROR(REG_ESPACE);
return;
}
p->strip = sp;
p->ssize = siz... | cmpq %rsi, 0x20(%rdi)
jge 0x149e53
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x3d, %rax
jne 0x149e31
movq 0x18(%rbx), %rdi
leaq (,%r14,8), %rsi
callq 0x260a0
testq %rax, %rax
je 0x149e31
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
jmp 0x149e4c
cmpl $0x0, 0x10(%rbx)
jne 0x149... | /Support/regcomp.c |
llvm::itaniumDemangle(std::basic_string_view<char, std::char_traits<char>>, bool) | void printWithPendingNewline(T V) {
print(V);
if (wantsNewline(V))
PendingNewline = true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1378, %rsp # imm = 0x1378
testq %rdi, %rdi
je 0x14a31e
movl %edx, %ebp
addq %rsi, %rdi
leaq 0x58(%rsp), %rbx
movq %rsi, -0x28(%rbx)
movq %rdi, -0x20(%rbx)
movq %rbx, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
leaq 0x158(%rsp), %rax
movq %rax, -... | /Demangle/ItaniumDemangle.cpp |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ArraySubscriptExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::Node*&, llvm::i... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x14ce40
movq (%r15), %rcx
movq (%r14), %rdx
movzwl (%rbx), %esi
movb $0x37, 0x8(%rax)
movzwl 0x9(%rax), %edi
andl $0x3f, %esi
andl $0xfffff000, %edi # imm = 0xFFFFF00... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::ConversionExpr, llvm::itanium_demangle::Node*&, llvm::itanium_demangle::NodeArray&, llvm::i... | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
addq $0x330, %rdi # imm = 0x330
movl $0x28, %esi
callq 0x14ce40
movq (%r15), %rcx
movups (%r14), %xmm0
movzwl (%rbx), %edx
movb $0x44, 0x8(%rax)
movzwl 0x9(%rax), %esi
andl $0x3f, %edx
andl $0xfffff000, %esi # imm = 0xFFFF... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::parseTemplateParamDecl(llvm::itanium_demangle::PODSmallVector<llvm::itanium_demangle::Node*, 8ul>*) | Node *AbstractManglingParser<Derived, Alloc>::parseTemplateParamDecl(
TemplateParamList *Params) {
auto InventTemplateParamName = [&](TemplateParamKind Kind) {
unsigned Index = NumSyntheticTemplateParameters[(int)Kind]++;
Node *N = make<SyntheticTemplateParamName>(Kind, Index);
if (N && Params)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
cmpq $0x2, %rdx
jb 0x152285
cmpw $0x7954, (%rcx) # imm = 0x7954
je 0x152346
movq (%rbx), %rcx
movq %rax, %rdx
subq %rcx, %rdx
... | /llvm/Demangle/ItaniumDemangle.h |
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [11]>(char const (&) [11]) | Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
movl $0x20, %esi
callq 0x14ce40
movq %rax, %r14
movq %rbx, %rdi
callq 0x26280
movb $0x8, 0x8(%r14)
movzwl 0x9(%r14), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(%r... | /llvm/Demangle/ItaniumDemangle.h |
testing::internal::UnitTestImpl::failed_test_count() const | int UnitTestImpl::failed_test_count() const {
return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xb8(%rdi), %rax
cmpq %rax, 0xc0(%rdi)
je 0xf13c
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq (%rax,%r15,8), %rdi
callq 0xf14e
addl %eax, %r14d
incq %r15
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cm... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CalculateOptimalEdits(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&) | std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
const std::vector<size_t>& right) {
std::vector<std::vector<double> > costs(
left.size() + 1, std::vector<double>(right.size() + 1));
std::vector<std::vector<EditType> > best_move(
le... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
sarq $0x3, %rsi
incq %rsi
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x24520
subq %r14... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
const char* rhs_expression, const char* lhs,
const char* rhs) {
if (String::CStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailure(lhs_expression, rhs_expression, PrintTo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
testq %r8, %r8
sete %al
testq %rcx, %rcx
je 0x1107d
testq %r8, %r8
je 0x1108b
movq %rcx, %rdi
movq %r8, %rsi
callq 0x77b0
testl %eax, %eax
sete %al
te... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::AssertionResult testing::(anonymous namespace)::IsSubstringImpl<wchar_t const*>(bool, char const*, char const*, wchar_t const* const&, wchar_t const* const&) | AssertionResult IsSubstringImpl(bool expected_to_be_substring,
const char* needle_expr,
const char* haystack_expr,
const StringType& needle,
const StringType& haystack) {
if (IsSubstringPred... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r14
movq %r8, %r12
movl %esi, %r15d
movq %rdi, %rbx
movq %rdx, -0x50(%rbp)
movq %rcx, -0x48(%rbp)
movq (%r8), %rsi
movq (%r9), %rdi
testq %rsi, %rsi
setne %al
testq %rdi, %rdi
setne %cl
testb %cl, %al
jne 0x117... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::CodePointToUtf8[abi:cxx11](unsigned int) | std::string CodePointToUtf8(uint32_t code_point) {
if (code_point > kMaxCodePoint4) {
return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
}
char str[5]; // Big enough for the largest valid code point.
if (code_point <= kMaxCodePoint1) {
str[1] = '\0';
str[0] = static_cast<cha... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi # imm = 0x200000
jb 0x11d4a
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x11ede
leaq 0x272d8(%rip), %rcx # 0x38fec
movl $0x13, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x75d0
leaq -0x20(... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::String::FormatIntWidthN[abi:cxx11](int, int) | std::string String::FormatIntWidthN(int value, int width) {
std::stringstream ss;
ss << std::setfill('0') << std::setw(width) << value;
return ss.str();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x1a8(%rbp), %r12
movq %r12, %rdi
callq 0x73a0
movq 0x10(%r12), %rax
movq -0x18(%rax), %rax
leaq (%rax,%rbp), %r12
addq $-0x198, %r12 # imm ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TestResult::GetTestPartResult(int) const | const TestPartResult& TestResult::GetTestPartResult(int i) const {
if (i < 0 || i >= total_part_count()) internal::posix::Abort();
return test_part_results_.at(static_cast<size_t>(i));
} | pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x12704
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x12704
movl %esi, %esi
movq 0x40(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $0x6db6db6db6db6db7, %rdx # imm = ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::Test::Run() | void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful and ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x13048
testb %al, %al
je 0x1371d
callq 0xba6c
movq 0x39141(%rip), %r14 # 0x4c770
cmpq $0x0, 0x280(%r14)
jne 0x13654
movl $0x8, %edi
callq 0x72c0
leaq 0x37e76(%rip), %rcx # 0x4b4c0
movq %rcx, (%rax)
movq %rax, 0x280(%r14)
movq 0x280(%r14), %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::Test::IsSkipped() | bool Test::IsSkipped() {
return internal::GetUnitTestImpl()->current_test_result()->Skipped();
} | pushq %rbp
movq %rsp, %rbp
callq 0xba6c
movq 0x38fd2(%rip), %rax # 0x4c770
movq 0x1e0(%rax), %rdi
testq %rdi, %rdi
je 0x137b3
addq $0x90, %rdi
jmp 0x137d1
movq 0x1d8(%rax), %rdi
testq %rdi, %rdi
je 0x137c8
addq $0x88, %rdi
jmp 0x137d1
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, %rdi
popq %rbp
jmp 0x12d98
... | /alk[P]gperftools/vendor/googletest/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x209fd(%rip), %rsi # 0x396ea
movl $0x9, %edx
callq 0x75f0
leaq 0x209df(%rip), %r14 # 0x396dd
leaq 0x209dc(%rip), %r12 # 0x396e1
movq %r15, %rdi
movq %r14, %rsi
callq 0x7100
movq... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '\\':
case '"':
case '/':
m << '\\' << ch;
break;
case '\b':
m << "\\b";
break;... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf63c
cmpq $0x0, 0x8(%r14)
je 0x1be73
movq -0x30(%rbp), %r15
addq $0x10, %r15
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
movq %r15, -0x58(%rbp)
movq %r15, %... | /alk[P]gperftools/vendor/googletest/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x1a6b3(%rip), %rsi # 0x39789
leaq 0x1a6b5(%rip), %rdx # 0x39792
leaq -0xb0(%rbp), %rdi
callq 0xb53c
leaq -0x60(%rbp), %rax
movq %... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::SocketWriter::MakeConnection() | void StreamingListener::SocketWriter::MakeConnection() {
GTEST_CHECK_(sockfd_ == -1)
<< "MakeConnection() can't be called when there is already a connection.";
addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses.
hints.ai_socktype = S... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
je 0x1fc47
leaq 0x18e08(%rip), %rdx # 0x38a03
leaq -0x60(%rbp), %rdi
movl $0x3, %esi
movl $0x1369, %ecx # imm = 0x1369
callq 0xa438
movq 0x2c3db(%rip), %rdi # 0x4bff0
leaq 0x19dd2(%rip), ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x288(%rdi)
je 0x214dc
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x288(%rdi)
leaq 0x2a8(%rdi), %r14
callq 0x32e0a
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a542
cmpq $0x0, 0x2a8(%rbx)
je 0x21519
movq 0x268(%rbx), %rax
movb $0x0, 0x8(%rax)
movq %rbx, %rdi
callq 0x13fd6
mo... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::GetTestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void (*)(), void (*)()) | TestSuite* UnitTestImpl::GetTestSuite(
const std::string& test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
// During initialization, all TestInfos for a given suite are added in
// sequence. To optimize this case, see if the... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r12
movq %rcx, -0x58(%rbp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
cmpq %rax, 0xb8(%rdi)
je 0x215c3
movq -0x8(%rax), %r15
movq 0x10(%r15), %rdx
cmpq 0x8(%r14), %rdx
jne 0x215c3
tes... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnshuffleTests() | void UnitTestImpl::UnshuffleTests() {
for (size_t i = 0; i < test_suites_.size(); i++) {
// Unshuffles the tests in each test suite.
test_suites_[i]->UnshuffleTests();
// Resets the index of each test suite.
test_suite_indices_[i] = static_cast<int>(i);
}
} | movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x22005
sarq $0x3, %rcx
movq 0x108(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movdqa 0x15a00(%rip), %xmm0 # 0x37940
movdqa 0x15a08(%rip), %xmm1 # 0x37950
pcmpeqd %xmm2, %xmm2
movdqa 0x15a1c(%rip), %xmm3 # 0x37970
movq (%rax,%rsi,8)... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::PrintOnOneLine(char const*, int) | static void PrintOnOneLine(const char* str, int max_length) {
if (str != nullptr) {
for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) {
printf("...");
break;
}
if (*str == '\n') {
printf("\\n");
i += 2;
} else {
printf("%c", *str);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2206d
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x2206d
incq %rbx
leaq 0x1790a(%rip), %r14 # 0x3993d
xorl %r15d, %r15d
cmpl $0xfa, %r15d
jae 0x22078
cmpb $0xa, %al
jne 0x22054
movq %r14, %rdi
xorl %eax, %eax
callq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::SrcDir[abi:cxx11]() | std::string SrcDir() {
#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
return GTEST_CUSTOM_SRCDIR_FUNCTION_();
#elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
'\\');
#elif defined(GTEST_OS_LINUX_ANDR... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x17810(%rip), %rax # 0x39dae
movq %rax, -0x38(%rbp)
leaq 0x2a167(%rip), %rsi # 0x4c710
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0xb164
movq (%r14), %rax
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
mov... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::ScopedTrace::PushTrace(char const*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
internal::TraceInfo trace;
trace.file = file;
trace.line = line;
trace.message.swap(message);
UnitTest::GetInstance()->PushGTestTrace(trace);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq %rsi, -0x20(%r14)
movl %edx, -0x18(%r14)
movq %rcx, %rsi
callq 0x73c0
callq 0xba6c
leaq 0x29fd1(%rip), %rdi # 0x4c730
leaq -0x40(%rbp), ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::FlushEdits() | void FlushEdits() {
hunk_.splice(hunk_.end(), hunk_removes_);
hunk_.splice(hunk_.end(), hunk_adds_);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x58(%rdi), %rdx
movq 0x58(%rdi), %rsi
cmpq %rdx, %rsi
je 0x22991
movq %r14, %rdi
callq 0x7260
movq 0x68(%rbx), %rax
addq %rax, 0x38(%rbx)
movq $0x0, 0x68(%rbx)
leaq 0x40(%rbx), %rdx
movq 0x40(%rbx), %rsi
cmpq %rdx, %rsi
je 0x22... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::~FactoryImpl() | explicit FactoryImpl(Factory f) : factory_(std::move(f)) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x288f0(%rip), %rax # 0x4b6d8
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x22e03
movq (%rax), %rsi
incq %rsi
callq 0x70b0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x22e1b
movq (%rax), %r... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest.h |
testing::TestInfo* testing::RegisterTest<testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::TypeParameterizedTestSuiteRegistry::CheckForInstantiations()::$_0)::FactoryImpl::CreateTest() | Test* CreateTest() override { return factory_(); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x60, %edi
callq 0x72c0
movq %rax, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x9a62
addq $0x48, %r14
leaq -0x38(%rbp), %rdx
... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest.h |
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0xf63c
movq (%r15), %r15
addq $0x10, %r15
testq %r12, %r12
je 0x22f4f
leaq 0x1758a(%rip), %rsi # 0x3a4a8
movl $0x20, %edx
movq %r15, %r... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb 0x28bd0(%rip), %al # 0x4c643
leaq -0x40(%rbp), %rdx
movb %al, (%rdx)
leaq 0x14e7e(%rip), %rsi # 0x388fe
callq 0x2431d
testb %al, %al
je 0x23a94
movb -0x40(%rbp), %al
movb %al, 0x28bb1(%rip) # 0x4c6... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static void LoadFlagsFromFile(const std::string& path) {
FILE* flagfile = posix::FOpen(path.c_str(), "r");
if (!flagfile) {
GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG_GET(flagfile)
<< "\"";
}
std::string contents(ReadEntireFile(flagfile));
posix::FClose(flagfile);
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rdi
leaq 0x1592d(%rip), %rsi # 0x39944
callq 0x7640
movq %rax, %rbx
testq %rax, %rax
jne 0x2408d
leaq 0x149d8(%rip), %rdx # 0x38a03
leaq -0x50(%rbp), %rdi
movl $0x3, %esi
movl $0x1a08, %ecx # imm = 0x1A08
callq 0xa438
movq... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::FilePath::FilePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
Normalize();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rcx
leaq 0x10(%rsi), %rax
cmpq %rax, %rcx
je 0x244d0
movq %rcx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x244d7
movups (%rax), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rsi)... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-filepath.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [6]>(char const (&) [6]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf63c
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x7200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x75f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [29]>(char const (&) [29]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf63c
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x7200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x75f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::Test* testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testing::Test* (testing::internal::TestFactoryBase::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. I... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0xba6c
movq 0x26831(%rip), %rax # 0x4c770
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x25f6c
testb $0x1, %r12b
je 0x25f59
movq (%r14), %rax
movq -0x1(%rax,%r1... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, %r12d
movq %rdi, %r14
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0x13514(%rip), %r13 # 0x395d2
cmovneq %rdx, %r13
leaq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x8... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-test-part.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
std::string flagfile_value;
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseFlag;
bool remove_flag = false;
if (ParseGo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x2, (%rdi)
jl 0x27194
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r13d
leaq -0x68(%rbp), %r15
movslq %r13d, %rax
leaq (%rbx,%rax... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#ifdef GTEST_HAS_ABSL
absl::In... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x254e4(%rip), %rsi # 0x4c710
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0xb164
movq (%r15), %rbx
movq 0x8(%r15), %r12
movq %r15, %rdi
callq 0xb1f8
cmpq %r12, %rbx
jne 0x272df
cm... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf63c
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x3690b
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x96bc
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x27f... | /alk[P]gperftools/vendor/googletest/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 %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf63c
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x7200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x75f0
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
c... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-assertion-result.h |
testing::internal::MutexBase::Lock() | void Lock() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
owner_ = pthread_self();
has_owner_ = true;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7810
testl %eax, %eax
je 0x2810a
movl %eax, %r14d
leaq 0x11d88(%rip), %rdx # 0x39e37
leaq -0x14(%rbp), %rdi
movl $0x3, %esi
movl $0x69a, %ecx # imm = 0x69A
callq 0xa438
movq 0x23f27(%rip), %rdi # 0x4bff0
leaq 0x... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::MutexBase::Unlock() | void Unlock() {
// Since the lock is being released the owner_ field should no longer be
// considered valid. We don't protect writing to has_owner_ here, as it's
// the caller's responsibility to ensure that the current thread holds the
// mutex when this is called.
has_owner_ = false;
GTEST_CH... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x0, 0x28(%rdi)
callq 0x7400
testl %eax, %eax
je 0x281aa
movl %eax, %ebx
leaq 0x11ce7(%rip), %rdx # 0x39e37
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x6a6, %ecx # imm = 0x6A6
callq 0xa438
movq 0x23e86(%rip), %rdi # 0x4bff0
leaq 0x11d7e(%rip), ... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::TestSuite::Passed() const | bool Failed() const {
return failed_test_count() > 0 || ad_hoc_test_result().Failed();
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf14e
testl %eax, %eax
jle 0x281dc
xorl %eax, %eax
jmp 0x281ed
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x12dde
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x7860
testq %rax, %rax
je 0x28830
movq %rax, %rdi
callq 0x288d5
movq %rax, %rbx
jmp 0x288b1
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x70f0
t... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
static_assert(std::is_base_of<Base, Derived>::value,
"target type not derived from source type");
#if GTEST_HAS_RTTI
GTEST_CHECK_(base == nullptr || dynamic_cast<Derived*>(base) != nullptr);
#endif
return static_cast<Derived*>(base);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2893b
leaq 0x22ea6(%rip), %rsi # 0x4b790
leaq 0x22eaf(%rip), %rdx # 0x4b7a0
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x75e0
testq %rax, %rax
jne 0x2893b
leaq 0x11530(%rip), %rdx # 0x39e37
leaq -0xc(%rbp), %rdi
movl $0x3, %es... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestProgramStart(testing::UnitTest const&) | void OnTestProgramStart(const UnitTest& /* unit_test */) override {
SendLn("event=TestProgramStart");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x114f2(%rip), %rsi # 0x3a2c3
leaq 0x11501(%rip), %rdx # 0x3a2d9
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xb53c
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2a4b2
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int) | void OnTestIterationStart(const UnitTest& /* unit_test */,
int iteration) override {
SendLn("event=TestIterationStart&iteration=" +
StreamableToString(iteration));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq -0x34(%rbp), %rsi
movl %edx, (%rsi)
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0xb0ec
leaq 0x11483(%rip), %rcx # 0x3a2da
movl $0x23, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x75d0
leaq -0x20(%rbp), %r14
movq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestSuiteStart(testing::TestSuite const&) | void OnTestSuiteStart(const TestSuite& test_suite) override {
SendLn(std::string("event=TestCaseStart&name=") + test_suite.name());
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x113ab(%rip), %rsi # 0x3a2fe
leaq 0x113bd(%rip), %rdx # 0x3a317
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0xb53c
movq 0x8(%r14), %rsi
mov... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestStart(testing::TestInfo const&) | void OnTestStart(const TestInfo& test_info) override {
SendLn(std::string("event=TestStart&name=") + test_info.name());
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x112c1(%rip), %rsi # 0x3a318
leaq 0x112cf(%rip), %rdx # 0x3a32d
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0xb53c
movq 0x20(%r14), %rsi
mo... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) override {
const char* file_name = test_part_result.file_name();
if (file_name == nullptr) file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x2915d
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x1046b(%rip), %rsi # 0x395d2
cmovneq %rax, %rsi
leaq -0x130(%rbp)... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) override {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) + "&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %r15
movq %r15, %rdi
callq 0x12d98
testb %al, %al
je 0x2965d
xorl %eax, %eax
jmp 0x29667
movq %r15, %rdi
callq 0x12dde
xorb $0x1, %al
leaq 0x11b46(%rip), %rcx # 0x3b1b4... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestSuiteEnd(testing::TestSuite const&) | void OnTestSuiteEnd(const TestSuite& test_suite) override {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_suite.Passed()) +
"&elapsed_time=" + StreamableToString(test_suite.elapsed_time()) +
"ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x281c6
leaq 0x1179b(%rip), %rcx # 0x3b1b4
leaq 0x11b99(%rip), %rsi # 0x3b5b9
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xd8(%rbp), %r12
movq %r12, -0x10(%r12)
l... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) +
"&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) +
"ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x263f6
leaq 0x113ee(%rip), %rcx # 0x3b1b4
leaq 0x117ec(%rip), %rsi # 0x3b5b9
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xd8(%rbp), %r12
movq %r12, -0x10(%... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&) | void OnTestProgramEnd(const UnitTest& unit_test) override {
// Note that Google Test current only report elapsed time for each
// test iteration, not for the entire test program.
SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
// Notify the streaming server to stop.
socket_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x263f6
leaq 0x11048(%rip), %rcx # 0x3b1b4
leaq 0x11446(%rip), %rsi # 0x3b5b9
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1102d(%rip), %rax # 0x... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::~SocketWriter() | ~SocketWriter() override {
if (sockfd_ != -1) CloseConnection();
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x215f0(%rip), %rax # 0x4b880
movq %rax, (%rdi)
cmpl $-0x1, 0x8(%rdi)
je 0x2a2a1
movq %rbx, %rdi
callq 0x2a426
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x2a2b9
movq (%rax), %rsi
incq %rsi
callq 0x70b0
movq 0x10(%rbx), %rdi
a... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x2a372
leaq 0xfcad(%rip), %rdx # 0x39fd3
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x451, %ecx # imm = 0x451
callq 0xa438
movq 0x21cb0(%rip), %rdi # 0x4bff0
leaq 0xfe98(%ri... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() override {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x2a488
leaq 0xfb97(%rip), %rdx # 0x39fd3
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x461, %ecx # imm = 0x461
callq 0xa438
movq 0x21b9a(%rip), %rdi # 0x4bff0
leaq 0xfd82(%rip), %rsi # 0x3a1df
movl $0x20... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::AbstractSocketWriter::SendLn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SendLn(const std::string& message) { Send(message + "\n"); } | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x9a62
leaq 0xf0e7(%rip), %rsi # 0x395d1
movq %r14, %rdi
cal... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::InternalRunDeathTestFlag::~InternalRunDeathTestFlag() | ~InternalRunDeathTestFlag() {
if (write_fd_ >= 0) posix::Close(write_fd_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %edi
testl %edi, %edi
js 0x2a58b
callq 0x7ab0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2a5a8
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x70b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rd... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h |
testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*) | static void Print(const char* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(std::string(str), os);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2a620
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
callq 0x7200
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb53c
movq %r15, %rdi
movq %... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8e(%rip), %rsi # 0x2cdcb
leaq -0x10(%rbp), %rdi
callq 0x78d0
testl %eax, %eax
je 0x2cdad
movl %eax, %ebx
leaq 0xd0e4(%rip), %rdx # 0x39e37
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x72e, %ecx # imm = 0x72E
callq 0xa438
movq 0x1f283(%rip),... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x5e(%rip), %rsi # 0x2cdcb
leaq -0x10(%rbp), %rdi
callq 0x78d0
testl %eax, %eax
je 0x2ce99
movl %eax, %ebx
leaq 0xcff8(%rip), %rdx # 0x39e37
leaq -0xc(%rbp), %rdi
movl $0x3, %esi
movl $0x72e, %ecx # imm = 0x72E
callq 0xa438
movq 0x1f197(%rip),... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ForkingDeathTest::Wait() | int ForkingDeathTest::Wait() {
if (!spawned()) return 0;
ReadAndInterpretStatusByte();
int status_value;
GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
set_status(status_value);
return status_value;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x28(%rdi)
jne 0x2ee2b
movq %rdi, %rbx
callq 0x2d8ea
leaq -0x2c(%rbp), %r14
movl 0x3c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7430
cmpl $-0x1, %eax
je 0x2ed... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::~MatcherBase() | ~MatcherBase() override { Destroy(); } | pushq %rbp
movq %rsp, %rbp
leaq 0x183db(%rip), %rax # 0x4bc88
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x338d4
cmpq $0x0, 0x18(%rax)
je 0x338d4
movq 0x10(%rdi), %rax
lock
decl (%rax)
jne 0x338d4
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
callq *0x18(%rax)
popq %rbp
retq
movq %rax, %rdi
callq 0x8f1... | /alk[P]gperftools/vendor/googletest/googletest/include/gtest/gtest-matchers.h |
testing::internal::NoExecDeathTest::NoExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
: ForkingDeathTest(a_statement, std::move(matcher)) {} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18185(%rip), %rcx # 0x4bc88
leaq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x8(%rdx)
leaq 0x180df(%rip), %rcx # 0x4bc08
movq %rcx, (%rax)
movq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x17dec(%rip), %rax # 0x4ba70
movq %rax, (%rdi)
xorl %edi, %edi
cmpl $-0x1, 0x34(%rbx)
sete %dil
callq 0xb88e
testb %al, %al
je 0x33cb8
callq 0xf638
testb %al, %al
je 0x33c87
addq $0x10, %rbx
movq %rbx, %rdi
addq $0xe8, %rsp
popq %rbx
popq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::FileOrDirectoryExists() const | bool FilePath::FileOrDirectoryExists() const {
#ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode;
return attributes != kInvalidFileAttributes;
#else
posix::StatStruct file_stat{};
return posix::Stat(... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq -0xa0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x72e0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x74a0
testl %eax, %eax
sete %al
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| /alk[P]gperftools/vendor/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::CreateDirectoriesRecursively() const | bool FilePath::CreateDirectoriesRecursively() const {
if (!this->IsDirectory()) {
return false;
}
if (pathname_.empty() || this->DirectoryExists()) {
return true;
}
const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
return parent.CreateDirectoriesRecursively() && this->Cr... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x353ca
movq %rdi, %rbx
sete %cl
movq (%rdi), %rdx
cmpb $0x2f, -0x1(%rdx,%rax)
sete %r14b
setne %al
orb %cl, %al
jne 0x353f1
leaq -0xc0(%rbp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x72e0
mov... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-filepath.cc |
testing::internal::PrintTo(char32_t, std::ostream*) | void PrintTo(char32_t c, ::std::ostream* os) {
*os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
<< static_cast<uint32_t>(c);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsi,%rax)
leaq 0x62fd(%rip), %rsi # 0x3b8d0
movl $0x2, %edx
movq %rbx, %rdi
callq 0x75f0
movq... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(unsigned __int128, std::ostream*) | void PrintTo(__uint128_t v, ::std::ostream* os) {
if (v == 0) {
*os << "0";
return;
}
// Buffer large enough for ceil(log10(2^128))==39 and the null terminator
char buf[40];
char* p = buf + sizeof(buf);
// Some configurations have a __uint128_t, but no support for built in
// division. Do manual... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %rax
orq %rsi, %rax
je 0x3571f
leaq -0x19(%rbp), %r14
movb $0x0, (%r14)
je 0x356fe
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movabsq $0x1999999999999999, %r10 # imm = 0x1999999999999999
movabsq $0x... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char const*, std::ostream*) | void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x358f8
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7410
leaq 0x6056(%rip), %rsi # 0x3b927
movl $0xd, %edx
movq %rax, %rdi
callq 0x75f0
movq %r14, %rdi
callq 0x7200
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(char32_t const*, std::ostream*) | void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x359cf
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7410
leaq 0x5f87(%rip), %rsi # 0x3b927
movl $0xd, %edx
movq %rax, %rdi
callq 0x75f0
movq $-0x1, %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
leaq 0x1(%rsi), %rsi
jne 0x359b4
movq... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintTo(wchar_t const*, std::ostream*) | void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x35a32
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7410
leaq 0x5f1c(%rip), %rsi # 0x3b927
movl $0xd, %edx
movq %rax, %rdi
callq 0x75f0
movq %r14, %rdi
callq 0x7460
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq ... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintStringTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::ostream*) | void PrintStringTo(const ::std::string& s, ostream* os) {
if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
if (GTEST_FLAG_GET(print_utf8)) {
ConditionalPrintAsText(s.data(), s.size(), os);
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x35c9a
testl %eax, %eax
je 0x35c51
leaq 0x16c33(%rip), %rax # 0x4c6b2
cmpb $0x1, (%rax)
jne 0x35c51
movq %rbx, -0x30(%rbp)
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo(c, os);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x36140
cmpl $0xd, %r14d
ja 0x361c7
movl %r14d, %eax
leaq 0x576a(%rip), %rcx # 0x3b898
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2ec2(%rip), %rsi # 0x39000
jmp 0x361aa... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-printers.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os << internal::FormatFileLocation(result.file_name(),
result.line_number())
<< " "
<< (result.type() == TestPartResult::kSuccess ? "Success"
: result.t... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x3692b
movq 0x8(%r14), %rsi
movl 0x28(%r14), %edx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x9f8b
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x75f... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-test-part.cc |
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[static_cast<size_t>(index)];
} | testl %esi, %esi
js 0x36a9a
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x36a9a
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x4ec2(%rip), %rdi # 0x3b967
xorl %eax, %eax
c... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest-test-part.cc |
testing::internal::HasNewFatalFailureHelper::HasNewFatalFailureHelper() | HasNewFatalFailureHelper::HasNewFatalFailureHelper()
: has_new_fatal_failure_(false),
original_reporter_(
GetUnitTestImpl()->GetTestPartResultReporterForCurrentThread()) {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1524c(%rip), %rax # 0x4bd20
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0xba6c
movq 0x40(%rax), %rdi
callq 0xe8f8
movq %rax, 0x10(%rbx)
callq 0xba6c
movq 0x40(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe90e
| /alk[P]gperftools/vendor/googletest/googletest/src/gtest-test-part.cc |
ya_getopt_internal(int, char* const*, char const*, option const*, int*, int) | static int ya_getopt_internal(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex, int long_only)
{
static int start, end;
if (ya_optopt == '?') {
ya_optopt = 0;
}
if (posixly_correct == -1) {
check_gnu_extension(optstring);
}
if... | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
cmpl $0x3f, 0x243f8(%rip) # 0x2a2a0
jne 0x5eb4
movl $0x0, 0x243ec(%rip) # 0x2a2a0
cmpl $-0x1, 0x243e9(%rip) # 0x2a2a4
jne 0x5ec7
movq 0x50(%rsp), %rdi
callq 0x633... | /sp-nitech[P]SPTK/third_party/GETOPT/ya_getopt.cc |
check_gnu_extension(char const*) | static void check_gnu_extension(const char *optstring)
{
if (optstring[0] == '+' || getenv("POSIXLY_CORRECT") != NULL) {
posixly_correct = 1;
} else {
posixly_correct = 0;
}
if (optstring[0] == '-') {
handle_nonopt_argv = 1;
} else {
handle_nonopt_argv = 0;
}
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x6353
leaq 0x1923b(%rip), %rdi # 0x1f583
callq 0x3300
cmpq $0x0, %rax
je 0x635f
movl $0x1, 0x23f47(%rip) # 0x2a2a4
jmp 0x6369
movl $0x0, 0x23f3b(%rip) # 0x2a2a4
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne ... | /sp-nitech[P]SPTK/third_party/GETOPT/ya_getopt.cc |
sptk::MelCepstrumPowerNormalization::MelCepstrumPowerNormalization(int, int, double) | MelCepstrumPowerNormalization::MelCepstrumPowerNormalization(
int num_order, int impulse_response_length, double alpha)
: frequency_transform_(num_order, impulse_response_length - 1, -alpha),
cepstrum_to_autocorrelation_(impulse_response_length - 1, 0,
impulse_response_l... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x231b0(%rip), %rax # 0x29c08
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x8(%rsp)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
decl %edx
movaps 0x18bfb(%rip),... | /sp-nitech[P]SPTK/src/conversion/mel_cepstrum_power_normalization.cc |
sptk::FrequencyTransform::Run(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>*, sptk::FrequencyTransform::Buffer*) const | bool FrequencyTransform::Run(const std::vector<double>& minimum_phase_sequence,
std::vector<double>* warped_sequence,
FrequencyTransform::Buffer* buffer) const {
// Check inputs.
const int input_length(num_input_order_ + 1);
if (!is_valid_ ||
minimum... | subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rcx, 0xc0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xbc(%rsp)
testb $0x1, 0x18(%rax)
je 0x79a9
movq 0xd0(%rsp), %rdi
callq 0x6df0
movslq 0xbc(%rsp), %rcx
cmpq %rcx, %rax
jne 0... | /sp-nitech[P]SPTK/src/math/frequency_transform.cc |
sptk::ReadStream(sptk::Matrix*, std::istream*) | bool ReadStream(sptk::Matrix* matrix_to_read, std::istream* input_stream) {
if (NULL == matrix_to_read || 0 == matrix_to_read->GetNumRow() ||
0 == matrix_to_read->GetNumColumn() || NULL == input_stream ||
input_stream->eof()) {
return false;
}
const int type_byte(sizeof((*matrix_to_read)[0][0]));... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
je 0x7f6b
movq 0x28(%rsp), %rdi
callq 0xfd00
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7f6b
movq 0x28(%rsp), %rdi
callq 0xfd10
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7f6b
xorl %eax, %eax
cmpq 0x20... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::WriteStream(sptk::Matrix const&, std::ostream*) | bool WriteStream(const sptk::Matrix& matrix_to_write,
std::ostream* output_stream) {
if (0 == matrix_to_write.GetNumRow() || 0 == matrix_to_write.GetNumColumn() ||
NULL == output_stream) {
return false;
}
output_stream->write(reinterpret_cast<const char*>(&(matrix_to_write[0][0])),
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xfd00
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x823b
movq 0x28(%rsp), %rdi
callq 0xfd10
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x823b
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x8242
movb $0x0, 0x37(%rsp)
jm... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int, int, 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&, std::ostrea... | bool WriteStream(int write_point, int write_size,
const std::vector<std::string>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_si... | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
cmpl $0x0, 0x60(%rsp)
jl 0x8412
cmpl $0x0, 0x5c(%rsp)
jle 0x8412
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0x841c
movb $0x0, 0x67(%rsp)
jmp 0x8526
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
mov... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::SnPrintf<sptk::int24_t>(sptk::int24_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, char*) | bool SnPrintf(int24_t data, const std::string& print_format,
std::size_t buffer_size, char* buffer) {
if (print_format.empty() || 0 == buffer_size || NULL == buffer) {
return false;
}
return (std::snprintf(buffer, buffer_size, print_format.c_str(),
static_cast<int>(data)... | subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3410
testb $0x1, %al
jne 0x857d
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
je 0x857d
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
jne 0x8584
movb $0x0, 0x47(%rsp)
jmp 0x85d4
m... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<short>(short*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x9e67
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x9e67
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3490
testb $0x1, %al
jne 0x9e67
jmp 0x9e6e
movb $0x0, 0x27(%rsp)
jmp 0x9ecc
movl $0x2, 0xc(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<sptk::int24_t>(sptk::int24_t*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x9f17
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x9f17
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3490
testb $0x1, %al
jne 0x9f17
jmp 0x9f1e
movb $0x0, 0x27(%rsp)
jmp 0x9f7c
movl $0x3, 0xc(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<int>(int*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0x9fc7
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x9fc7
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3490
testb $0x1, %al
jne 0x9fc7
jmp 0x9fce
movb $0x0, 0x27(%rsp)
jmp 0xa02c
movl $0x4, 0xc(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<float>(float*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0xa497
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0xa497
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3490
testb $0x1, %al
jne 0xa497
jmp 0xa49e
movb $0x0, 0x27(%rsp)
jmp 0xa4fc
movl $0x4, 0xc(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<float>(int, int, std::vector<float, std::allocator<float>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | subq $0x68, %rsp
movl %edi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
cmpl $0x0, 0x60(%rsp)
jl 0xf292
cmpl $0x0, 0x5c(%rsp)
jle 0xf292
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0xf29c
movb $0x0, 0x67(%rsp)
jmp 0xf39e
movl 0x60(%rsp), %eax
addl 0x5c(%rsp), %eax
mov... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Matrix::Transpose(sptk::Matrix*) const | bool Matrix::Transpose(Matrix* transposed_matrix) const {
if (NULL == transposed_matrix || this == transposed_matrix) {
return false;
}
if (transposed_matrix->num_row_ != num_column_ ||
transposed_matrix->num_column_ != num_row_) {
transposed_matrix->Resize(num_column_, num_row_);
}
for (int i... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
je 0x1a54d
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x1a557
movb $0x0, 0x37(%rsp)
jmp 0x1a630
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0xc(%r... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::Matrix::GetDeterminant(double*) const | bool Matrix::GetDeterminant(double* determinant) const {
if (num_row_ != num_column_ || num_row_ <= 0 || NULL == determinant) {
return false;
}
const int num_dimension(num_row_);
if (1 == num_dimension) {
*determinant = index_[0][0];
return true;
}
const int num_order(num_dimension - 1);
Mat... | subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0x1a7f3
movq 0x20(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x1a7f3
xorl %eax, %eax
cmpq 0xa0(%rsp), %rax
jne 0x1a800
movb $0x0, 0xb7(%rsp)
jmp 0x1aa6b
movq 0x20(%rsp), %rax
... | /sp-nitech[P]SPTK/src/math/matrix.cc |
sptk::RealValuedFastFourierTransform::RealValuedFastFourierTransform(int, int) | RealValuedFastFourierTransform::RealValuedFastFourierTransform(int num_order,
int fft_length)
: num_order_(num_order),
fft_length_(fft_length),
half_fft_length_(fft_length_ / 2),
fast_fourier_transform_(half_fft_length_),
is_vali... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xd856(%rip), %rcx # 0x29c58
addq $0x10, %rcx
movq %rcx, (%rax)
movl 0x4c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x48(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
movl $0x2, %... | /sp-nitech[P]SPTK/src/math/real_valued_fast_fourier_transform.cc |
sptk::RealValuedFastFourierTransform::Run(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>*, std::vector<double, std::allocator<double>>*, sptk::RealValuedFastFourierTransform::Buffer*) const | bool RealValuedFastFourierTransform::Run(
const std::vector<double>& real_part_input,
std::vector<double>* real_part_output,
std::vector<double>* imag_part_output,
RealValuedFastFourierTransform::Buffer* buffer) const {
// Check inputs.
const int input_length(num_order_ + 1);
if (!is_valid_ ||
... | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rcx, 0xd0(%rsp)
movq %r8, 0xc8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc4(%rsp)
testb $0x1, 0x48(%rax)
je 0x1c64d
movq 0xe0(%rsp), %rdi
callq 0x6df0
movslq 0xc4(%rsp), %rc... | /sp-nitech[P]SPTK/src/math/real_valued_fast_fourier_transform.cc |
sptk::SymmetricMatrix::SymmetricMatrix(int) | SymmetricMatrix::SymmetricMatrix(int num_dimension)
: num_dimension_(num_dimension < 0 ? 0 : num_dimension) {
data_.resize(num_dimension_ * (num_dimension_ + 1) / 2);
index_.resize(num_dimension_);
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xcd8a(%rip), %rcx # 0x29d48
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x4c(%rsp)
jge 0x1cfdd
xorl %eax, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1cfe5
movl 0x4c(%rsp), %e... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::SymmetricMatrix(sptk::SymmetricMatrix const&) | SymmetricMatrix::SymmetricMatrix(const SymmetricMatrix& matrix)
: num_dimension_(matrix.num_dimension_),
data_(matrix.data_),
index_(num_dimension_) {
for (int i(0), j(0); i < num_dimension_; ++i, j += i) {
index_[i] = &data_[j];
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0xcc49(%rip), %rax # 0x29d58
movq %rax, (%rdi)
movq 0x58(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
movq 0x58(%rsp), %rsi
addq $0x10, %rsi
callq 0x1ab40
mo... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.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.