name string | code string | asm string | file string |
|---|---|---|---|
Catch::StringMaker<std::basic_string_view<wchar_t, std::char_traits<wchar_t>>, void>::convert[abi:cxx11](std::basic_string_view<wchar_t, std::char_traits<wchar_t>>) | std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
return StringMaker<std::wstring>::convert(std::wstring(str));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rdx,%rsi,4), %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x63bf0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x297b6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x298e0
movq 0x10(%rsp)... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*) | std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x29a31
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x12540
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x63bf0
movq %rbx, %rdi
movq %r15, %rsi
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StringMaker<bool, void>::convert[abi:cxx11](bool) | std::string StringMaker<bool>::convert(bool b) {
return b ? "true" : "false";
} | pushq %rbx
movq %rdi, %rbx
leaq 0x4dd65(%rip), %rcx # 0x77a02
leaq 0x4dd63(%rip), %rax # 0x77a07
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x42cf6
movq %rbx, %rax
popq %rbx
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Totals::operator+=(Catch::Totals const&) | Totals& Totals::operator += ( Totals const& other ) {
assertions += other.assertions;
testCases += other.testCases;
return *this;
} | movq %rdi, %rax
movdqu 0x8(%rsi), %xmm0
movdqu 0x8(%rdi), %xmm1
paddq %xmm0, %xmm1
movdqu 0x18(%rdi), %xmm0
movdqu 0x28(%rdi), %xmm2
movdqu %xmm1, 0x8(%rdi)
movdqu 0x18(%rsi), %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, 0x18(%rdi)
movdqu 0x28(%rsi), %xmm0
paddq %xmm2, %xmm0
movdqu %xmm0, 0x28(%rdi)
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char) | void hexEscapeChar(std::ostream& os, unsigned char c) {
std::ios_base::fmtflags f(os.flags());
os << "\\x"
<< std::uppercase << std::hex << std::setfill('0') << std::setw(2)
<< static_cast<int>(c);
os.flags(f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r15d
leaq 0x4ea0f(%rip), %rsi # 0x78eaa
movl $0x2, %edx
callq 0x12710
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlWriter::endElement(Catch::XmlFormatting) | XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
m_indent = m_indent.substr(0, m_indent.size() - 2);
if( m_tagIsOpen ) {
m_os << "/>";
m_tagIsOpen = false;
} else {
newlineIfNecessary();
if (shouldIndent(fmt)) {
m_os << m_inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x28(%rdi), %rcx
addq $-0x2, %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x126a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x12780
movq (%r15), %rdi
leaq 0x18(%rsp), %r... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::CompactReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void CompactReporter::noMatchingTestCases( std::string const& spec ) {
stream << "No test cases matched '" << spec << '\'' << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x4cbf0(%rip), %rsi # 0x77ae4
movl $0x17, %edx
movq %r14, %rdi
callq 0x12710
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x12710
leaq 0x7(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x12710
movq %ra... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::CompactReporter::sectionEnded(Catch::SectionStats const&) | void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
double dur = _sectionStats.durationInSeconds;
if ( shouldShowDuration( *m_config, dur ) ) {
stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << std::endl;
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x70(%rsi), %xmm0
movq 0x8(%rdi), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x2ad3c
testb %al, %al
je 0x2b84b
movq 0x18(%r14), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2acbf
movq (%r15), %rsi
movq 0x8(%r15),... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&) | bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
AssertionResult const& result = _assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
// Drop out if result was successful but we're not printing them.
if (!includeRes... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x2c891
movl 0x90(%r12), %eax
testb $0x10, %al
je 0x2c886
movl 0x38(%r12), %ecx
andl $0x8, %ecx
je 0x2c891
xorl %... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::JunitReporter::~JunitReporter() | JunitReporter::~JunitReporter() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x77589(%rip), %rax # 0xa6568
movq %rax, (%rdi)
movq 0x148(%rdi), %rdi
leaq 0x158(%rbx), %rax
cmpq %rax, %rdi
je 0x2f000
movq (%rax), %rsi
incq %rsi
callq 0x12650
movq 0x128(%rbx), %rdi
leaq 0x138(%rbx), %rax
cmpq %rax, %rdi
je 0x2f01e
movq (%rax), %rsi
incq %rsi
callq 0x12650
leaq 0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::JunitReporter::testCaseEnded(Catch::TestCaseStats const&) | void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
stdOutForSuite += testCaseStats.stdOut;
stdErrForSuite += testCaseStats.stdErr;
CumulativeReporterBase::testCaseEnded( testCaseStats );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x128, %rdi # imm = 0x128
movq 0xe8(%rsi), %rsi
movq 0xf0(%rbx), %rdx
callq 0x121b0
leaq 0x148(%r14), %rdi
movq 0x108(%rbx), %rsi
movq 0x110(%rbx), %rdx
callq 0x121b0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::JunitReporter::writeGroup(Catch::CumulativeReporterBase<Catch::JunitReporter>::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase<Catch::JunitReporter>::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase<Catch::JunitReporter>::SectionNode>> const&, double) | void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
TestGroupStats const& stats = groupNode.value;
xml.writeAttribute( "name", stats.groupInfo.name );
xml.writeAttribute( "errors", unexpected... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, 0x90(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x48ac1(%rip), %rsi # 0x77d13
leaq 0x48ac3(%rip), %rdx # 0x77d1c
movq %rsp, %rdi
callq 0x42cf6
leaq 0xd8(%rbx), %r14
leaq 0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::JunitReporter::writeAssertion(Catch::AssertionStats const&) | bool AssertionResult::isOk() const {
return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl 0x90(%rsi), %eax
testb $0x10, %al
je 0x30cdd
movq %rsi, %r14
movl 0x38(%rsi), %ecx
andl $0x8, %ecx
jne 0x30cdd
movq %rdi, %rbx
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movl $0x7, %r8d
leaq... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ListeningReporter::reportInvalidArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ListeningReporter::reportInvalidArguments(std::string const&arg){
for ( auto const& listener : m_listeners ) {
listener->reportInvalidArguments( arg );
}
m_reporter->reportInvalidArguments( arg );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x30f13
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
addq $0x8, %r15
jmp 0x30efc
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ListeningReporter::testCaseStarting(Catch::TestCaseInfo const&) | void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
for ( auto const& listener : m_listeners ) {
listener->testCaseStarting( testInfo );
}
m_reporter->testCaseStarting( testInfo );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x30feb
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
addq $0x8, %r15
jmp 0x30fd4
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ListeningReporter::assertionEnded(Catch::AssertionStats const&) | bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
for( auto const& listener : m_listeners ) {
static_cast<void>( listener->assertionEnded( assertionStats ) );
}
return m_reporter->assertionEnded( assertionStats );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x310c3
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r15
jmp 0x310ac
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ListeningReporter::skipTest(Catch::TestCaseInfo const&) | void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
for ( auto const& listener : m_listeners ) {
listener->skipTest( testInfo );
}
m_reporter->skipTest( testInfo );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x3122b
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x78(%rax)
addq $0x8, %r15
jmp 0x31214
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x78(%rax), %rax
mov... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlReporter::testRunStarting(Catch::TestRunInfo const&) | void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
StreamingReporterBase::testRunStarting( testInfo );
std::string stylesheetRef = getStylesheetRef();
if( !stylesheetRef.empty() )
m_xml.writeStylesheetRef( stylesheetRef );
m_xml.startElement( "Catch" );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
callq 0x49dce
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e2ce
movq %r15, 0x20(%rbx)
movb $0x0, 0x48(%rbx)
m... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlReporter::sectionStarting(Catch::SectionInfo const&) | void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
StreamingReporterBase::sectionStarting( sectionInfo );
if( m_sectionDepth++ > 0 ) {
m_xml.startElement( "Section" )
.writeAttribute( "name", trim( sectionInfo.name ) );
writeSourceInfo( sectionI... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x148, %rdi # imm = 0x148
callq 0x641ec
movl 0x1b8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1b8(%r14)
testl %eax, %eax
jle 0x31cd5
leaq 0x170(%r14), %r15
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) | void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
if( --m_sectionDepth > 0 ) {
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes", sectionStats.assertions.pass... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x148, %rdi # imm = 0x148
movq 0x150(%r15), %rsi
addq $-0x50, %rsi
movq %rsi, 0x150(%r15)
callq 0x49dfa
movl 0x1b8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1b8(%r15)
cmpl $0x2, %eax
jl 0x326ae
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlReporter::testRunEnded(Catch::TestRunStats const&) | void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
StreamingReporterBase::testRunEnded( testRunStats );
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes", testRunStats.totals.assertions.passed )
.writeAttribute( "failures", testRunStats.totals... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x419dc
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x45191(%rip), %rsi # 0x77f77
leaq 0x45198(%rip), %rdx # 0x77f85
leaq 0x8(%rsp), %rdi
callq 0x42cf6
addq $0x170, %rbx # im... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Detail::(anonymous namespace)::StreamBufImpl<Catch::Detail::(anonymous namespace)::OutputDebugWriter, 256ul>::overflow(int) | int overflow( int c ) override {
sync();
if( c != EOF ) {
if( pbase() == epptr() )
m_writer( std::string( 1, static_cast<char>( c ) ) );
else
sputc( static_cast<char>( c ) );
}
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, %ebx
je 0x3a196
movq 0x30(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x3a14e
movq 0x28(%r14), %rcx
cmpq %rax, %rcx
jae 0x3a1a0
movb %bl, (%rcx)
incq 0x28(%r14)
jmp 0x3a196
leaq 0x18(%rsp), %r14
movq %r14, -0... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::(anonymous namespace)::AssertionPrinter::printExpressionWas() | void printExpressionWas() {
if (result.hasExpression()) {
stream << ';';
{
Colour colour(dimColour());
stream << " expression was:";
}
printOriginalExpression();
}
} | pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3a6c8
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xf(%rsp), %rsi
movb $0x3b, (%rsi)
movl $0x1, %edx
callq 0x12710
movb $0x0, 0xe(%rsp)
movl $0x17, %edi
callq 0x1b522
movq (%rbx), %rdi
leaq 0x3e89b(%rip), %rsi # 0x78f4a
movl $0x10, %edx
callq 0x... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>::setFlag(bool) | auto setFlag( bool flag ) -> ParserResult override {
return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movl $0x1, 0xc(%rcx)
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
leaq 0x6d81f(%rip), %rdx # 0xa83e8
movq %rdx, (%rdi)
leaq 0x20(%rdi), %rdx
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_10>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4f13d
movl 0x8(%r15), %eax
testl %eax, %eax
je 0x3b09b
movl %eax, 0x8(%rbx)
leaq 0x6d370(%rip), %r15 # 0xa83e8
movq %... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x12330
xorl %eax, %eax
leaq 0xa0(%rsp), %r12
movq %rax, -0x18(%r12)
leaq 0x6c4cc(%rip), %r13... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x6b7c1(%rip), %rax # 0xa7ed8
movq %rax, (%rdi)
leaq 0x6b837(%rip), %rax # 0xa7f58
movq %rax, 0x8(%rdi)
leaq 0x6b884(%rip), %rax # 0xa7fb0
movq %rax, 0x10(%rdi)
leaq 0x6a389(%rip), %rax # 0xa6ac0
movq %rax, 0x128(%rdi)
addq $0x130, %rdi # imm = 0x130
callq 0x4e... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ReporterRegistrar<Catch::CompactReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x3c4b8
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x12620
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x68f27(%rip), %rcx # 0xa9478
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x68f69(%rip), ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::SummaryColumn::addRow(unsigned long) | SummaryColumn addRow( std::size_t count ) {
ReusableStringStream rss;
rss << count;
std::string row = rss.str();
for (auto& oldRow : rows) {
while (oldRow.size() < row.size())
oldRow = ' ' + oldRow;
while (oldRow.size() > row.size())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x65814(%rip), %rax # 0xa6118
movq %rax, 0x30(%rsp)
callq 0x5f8c8
leaq 0x8(%rax), %rdi
callq 0x3f6ea
movq %rax, %r15
movq %rax, 0x38(%rsp)
callq 0x5f8c8
movq 0x8(%rax), %rax
movq (... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x650fd(%rip), %rax # 0xa6118
movq %rax, (%rsp)
callq 0x5f8c8
leaq 0x8(%rax), %rdi
callq 0x3f6ea
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x5f8c8
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r1... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [4]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x64f45(%rip), %rax # 0xa6118
movq %rax, (%rsp)
callq 0x5f8c8
leaq 0x8(%rax), %rdi
callq 0x3f6ea
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x5f8c8
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [5]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [5]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x64d79(%rip), %rax # 0xa6118
movq %rax, (%rsp)
callq 0x5f8c8
leaq 0x8(%rax), %rdi
callq 0x3f6ea
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x5f8c8
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StreamingReporterBase<Catch::XmlReporter>::StreamingReporterBase(Catch::ReporterConfig const&) | StreamingReporterBase( ReporterConfig const& _config )
: m_config( _config.fullConfig() ),
stream( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = false;
if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
CATCH_ERRO... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x674b2(%rip), %rax # 0xa8aa8
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x41623
movq 0x6896b(%rip), %rcx # 0xa9f80
cmpb $0x0, ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StreamingReporterBase<Catch::XmlReporter>::testRunStarting(Catch::TestRunInfo const&) | void testRunStarting(TestRunInfo const& _testRunInfo) override {
currentTestRunInfo = _testRunInfo;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
callq 0x49dce
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e2ce
movq %r15, 0x20(%r14)
movb $0x0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::ReporterRegistrar<Catch::XmlReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x3c4b8
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x12620
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x67ced(%rip), %rcx # 0xa9740
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x67d2f(%rip), ... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Generators::GeneratorTracker::close() | void close() override {
TrackerBase::close();
// If a generator has a child (it is followed by a section)
// and none of its children have started, then we must wait
// until later to start consuming its values.
// This catches cases where ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x278c4
movq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rsi
cmpq %rsi, %rdi
je 0x4216e
callq 0x4e0dc
cmpq 0x50(%rbx), %rax
je 0x42188
cmpl $0x4, 0x60(%rbx)
jne 0x421fe
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x421e... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::WildcardPattern::~WildcardPattern() | virtual ~WildcardPattern() = default; | movq %rdi, %rax
leaq 0x6404e(%rip), %rcx # 0xa6400
movq %rcx, (%rdi)
movq 0x10(%rdi), %rdi
addq $0x20, %rax
cmpq %rax, %rdi
je 0x423cd
movq (%rax), %rsi
incq %rsi
jmp 0x12650
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StreamingReporterBase<Catch::TestEventListenerBase>::testRunStarting(Catch::TestRunInfo const&) | void testRunStarting(TestRunInfo const& _testRunInfo) override {
currentTestRunInfo = _testRunInfo;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
callq 0x49dce
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e2ce
movq %r15, 0x20(%r14)
movb $0x0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StreamingReporterBase<Catch::TestEventListenerBase>::testRunEnded(Catch::TestRunStats const&) | void testRunEnded(TestRunStats const& /* _testRunStats */) override {
currentTestCaseInfo.reset();
currentGroupInfo.reset();
currentTestRunInfo.reset();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x49d2a
xorl %ebp, %ebp
movb %bpl, 0x140(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x49da2
movb %bpl, 0x88(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x49dce
movb %bpl, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::StreamingReporterBase<Catch::CompactReporter>::testGroupStarting(Catch::GroupInfo const&) | void testGroupStarting(GroupInfo const& _groupInfo) override {
currentGroupInfo = _groupInfo;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rdi
callq 0x49da2
leaq 0x58(%r14), %r15
leaq 0x68(%r14), %rax
movq %rax, 0x58(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e2ce
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x78(%r14)
movq %r15, 0x50(%r14)
m... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::testRunEnded(Catch::TestRunStats const&) | void testRunEnded(TestRunStats const& testRunStats) override {
auto node = std::make_shared<TestRunNode>(testRunStats);
node->children.swap(m_testGroups);
m_testRuns.push_back(node);
testRunEndedCumulative();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x6614c
movq (%r14), %rax
movq 0x80(%rax), %rcx
movups 0x68(%rbx), %xmm0
movups 0x70(%rax), %xmm1
movups %xmm0, 0x70(%rax)
movq 0x78(%rbx), %... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BasicResult<void>::enforceOk() const | void enforceOk() const override {
// Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage
assert( m_type != ResultBase::LogicError );
assert( m_type != ResultBase::RuntimeError );
if( m_type != ResultBase::Ok... | pushq %rax
movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x42fe8
popq %rax
retq
cmpl $0x2, %eax
je 0x43011
cmpl $0x1, %eax
jne 0x43030
leaq 0x350ae(%rip), %rdi # 0x780a7
leaq 0x33f81(%rip), %rsi # 0x76f81
leaq 0x350c1(%rip), %rcx # 0x780c8
movl $0x233d, %edx # imm = 0x233D
callq 0x123e0
leaq 0x350ff(%... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::ParserRefImpl(std::shared_ptr<Catch::clara::detail::BoundRef> const&) | explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {} | leaq 0x6484f(%rip), %rax # 0xa85f0
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x43dd4
movq 0x661ba(%rip), %rcx # 0xa9f80
cmpb $0x0, (%rcx)
je 0x43dd0
incl 0x8(%rax)
jmp 0x43dd4
lock
incl 0x8(%rax)
leaq 0x30(%rdi),... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseState>::BasicResult<Catch::clara::detail::ParseResultType>(Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> const&) | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
leaq 0x640d4(%rip), %rax # 0xa8288
movq %rax, (%rdi)
addq $0x40, %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4e2ce
cmpl $0x0, 0x8(%rbx)
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::TokenStream::loadBuffer() | void loadBuffer() {
m_tokenBuffer.resize( 0 );
// Skip any empty strings
while( it != itEnd && it->empty() )
++it;
if( it != itEnd ) {
auto const &next = *it;
if( isOptPrefix( next[0] ) ) {
auto delimit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x445c8
movq (%r15), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x443a1
movq 0x8(%r14), %rdx
testq %rdx, %rdx
jne 0x442bb
addq $0x20, %r14
movq %r14, (%r15)
jm... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Arg>::ParserRefImpl<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>>>>>(std::vector<std::__cxx11::basic_string<char, std::cha... | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x63b9d(%rip), %rax # 0xa8748
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0x20, %edi
callq 0x12620
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x63bac(%rip), %rcx # 0xa8780
movq %rcx, (%rax)
... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BoundValueRef<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>>>>>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&... | auto setValue( std::string const &arg ) -> ParserResult override {
T temp;
auto result = convertInto( arg, temp );
if( result )
m_ref.push_back( temp );
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x12330
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x63346(%rip), %r13 # 0xa83e8
movq %r13... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::clara::detail::TokenStream const&) const | auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
struct ParserInfo {
ParserBase const* parser = nullptr;
size_t count = 0;
};
const size_t totalParsers = m_options.size() + m_args.size();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2158, %rsp # imm = 0x2158
movq %rcx, 0x70(%rsp)
movq %rdx, 0x88(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x30(%rsi), %rbx
movq 0x38(%rsi), %r15
movq %r15, %rax
subq %rbx, %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEE... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::ResultValueBase<Catch::clara::detail::ParseState>::operator=(Catch::clara::detail::ResultValueBase<Catch::clara::detail::ParseState> const&) | auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
if( m_type == ResultBase::Ok )
m_value.~T();
ResultBase::operator=(other);
if( m_type == ResultBase::Ok )
new( &m_value ) T( other.m_value );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jne 0x45b57
leaq 0x28(%rbx), %rdi
callq 0x432d6
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
jne 0x45b82
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::TextFlow::Columns::iterator::iterator(Catch::clara::TextFlow::Columns const&, Catch::clara::TextFlow::Columns::iterator::EndTag) | iterator(Columns const& columns, EndTag)
: m_columns(columns.m_columns),
m_activeIterators(0) {
m_iterators.reserve(m_columns.size());
for (auto const& col : m_columns)
m_iterators.push_back(col.end());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
leaq 0x8(%rdi), %r14
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAA... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::Opt::getHelpColumns() const | auto getHelpColumns() const -> std::vector<HelpColumns> {
std::ostringstream oss;
bool first = true;
for( auto const &opt : m_optNames ) {
if (first)
first = false;
else
oss << ", ";
oss << opt;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x12860
movq 0x60(%r14), %r13
movq 0x68(%r14), %rbp
cmpq %rbp, %r13
je 0x4787b
movb $0x1, %al
leaq 0x50(%rsp), %r15
leaq 0x2fa4c(%rip), %r12 # 0x77... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Option<Catch::TestRunInfo>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = nullptr;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x49df1
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x49df1
movq (%rax), %rsi
incq %rsi
callq 0x12650
movq $0x0, (%rbx)
popq %rbx
retq
| /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::UnaryExpr<bool>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
os << Catch::Detail::stringify( m_lhs );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movzbl 0xa(%rdi), %edx
leaq 0x2d2ad(%rip), %rax # 0x77a02
leaq 0x2d2ab(%rip), %rsi # 0x77a07
testq %rdx, %rdx
cmovneq %rax, %rsi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
xorq $0x5, %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
void nlohmann::detail::to_json<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>, char [8], 0>(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<cha... | void to_json(BasicJsonType& j, const CompatibleString& s)
{
external_constructor<value_t::string>::construct(j, s);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsi, %rdi
callq 0x122c0
leaq (%rax,%r14), %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x42cf6
movb $0x3, (%rbx)
movl $0x20, %edi
callq 0x12620
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, (... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | static std::string name(const std::string& ename, int id_)
{
return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r14d
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x2ec4f(%rip), %rsi # 0x79816
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x3ec0b
leaq 0x2e3b8(%rip), %rsi # 0x78f93
movq %r15, %rdi
callq 0x12bd0
leaq 0x38(%rsp), %r12
movq %... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::json_ref<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::moved_or_copied() const | value_type moved_or_copied() const
{
if (is_rvalue)
{
return std::move(*value_ref);
}
return *value_ref;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rsi), %r14
cmpb $0x1, 0x18(%rsi)
jne 0x4b498
movb (%r14), %al
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x4a7d8
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %rbx, %rdi
callq 0x4a7d8
jmp 0x4b4a3
movq %rbx, %rdi
movq %r14, %... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_escaped(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | void dump_escaped(const string_t& s, const bool ensure_ascii)
{
uint32_t codepoint;
uint8_t state = UTF8_ACCEPT;
std::size_t bytes = 0; // number of bytes written to string_buffer
for (std::size_t i = 0; i < s.size(); ++i)
{
const auto byte = static_cast<uint8_t>(s[i]);
switch (decode(state, codepoint, byte))
{
case... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
cmpq $0x0, 0x8(%rsi)
je 0x4c86e
movq %rsi, %rbx
movq %rdi, 0x38(%rsp)
leaq 0x5a(%rdi), %rsi
leaq 0x2f63d(%rip), %rdi # 0x7bcb2
movl %edx, %eax
xorb $0x1, %al
movb %al, 0xb(%rsp)
xorl %r13d, %r13d
xorl %r14d,... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
void nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_integer<unsigned long, 0>(unsigned long) | void dump_integer(NumberType x)
{
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
const bool is_negative = (x <= 0) and (x != 0); // see issue #755
std::size_t i = 0;
while (x != 0)
{
// spare 1 byte for '\0'
assert(i < number_buffer.size() - 1);
const auto digit = std::labs(static_cast<lon... | pushq %rax
testq %rsi, %rsi
je 0x4cdfb
movq %rsi, %r8
leaq 0x10(%rdi), %rsi
xorl %ecx, %ecx
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
cmpq $0x3f, %rcx
je 0x4ce0c
movq %r8, %rax
mulq %r9
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r8d, %r10d
subl %eax, %r10d
orb $0x30, %r10b
... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType>::BasicResult(Catch::clara::detail::ResultBase::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BasicResult( ResultBase::Type type, std::string const &message )
: ResultValueBase<T>(type),
m_errorMessage(message)
{
assert( m_type != ResultBase::Ok );
} | pushq %rbx
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
leaq 0x594b4(%rip), %rax # 0xa83e8
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x4e2ce
cmpl $0x0, 0x8(%rbx)
je 0x4ef5a
popq %rbx
retq
leaq 0x29377(%rip), %rdi # 0x782d8... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int&) | inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
if( ss.fail() )
return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
else
return P... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x12470
leaq 0x58(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x12710
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x12af0
movq 0x48(%rsp), %rax
movq -0x18(... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
Catch::Singleton<Catch::StringStreams, Catch::StringStreams, Catch::StringStreams>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x4a5b9(%rip), %rsi # 0xa9f68
callq 0x12320
leaq 0xa8(%rbx), %rdi
callq 0x121e0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5f9d5
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x12650
leaq 0x8(%rbx), %rdi
callq 0x5f9ec
movl $0x1b0, %esi # imm = 0x1B0
movq %r... | /metricq[P]hta/lib/catch/include/catch/catch.hpp |
hta::read_json_from_file(std::filesystem::__cxx11::path const&) | json read_json_from_file(const std::filesystem::path& path)
{
std::ifstream config_file;
config_file.exceptions(std::ios::badbit | std::ios::failbit);
config_file.open(path);
json config;
config_file >> config;
return config;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12700
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x8, %rdi
movl $0x5, 0x1c(%rdi)
movl 0x20(%rdi), %esi
callq 0x12a80
movq (%r14), %rsi
leaq ... | /metricq[P]hta/src/directory.cpp |
nlohmann::operator>>(std::istream&, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&) | friend std::istream& operator>>(std::istream& i, basic_json& j)
{
parser(detail::input_adapter(i)).parse(false, j);
return i;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r15
movq %rdi, %r14
leaq 0x48(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x40(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x67e34
movq (%rbx), %rax
movq 0x8(%rbx), %rbx
movq %rax, 0x10(%rsp)
movq %rbx, 0x18(%r... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const& nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::alloca... | const_reference operator[](T* key) const
{
// at only works for objects
if (JSON_LIKELY(is_object()))
{
assert(m_value.object->find(key) != m_value.object->end());
return m_value.object->find(key)->second;
}
JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpb $0x1, (%rdi)
jne 0x67695
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6a760
movq 0x8(%r14), %rdi
leaq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x67712
leaq 0x8(%rsp), %rsi
callq 0x6a760
addq $0x40, %rax
addq $0x50, %rsp
popq %rbx... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
void hta::throw_exception<hta::MissingMetricConfig, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | [[noreturn]] inline void throw_exception(Args... args)
{
std::stringstream msg;
detail::make_exception<Args...>()(msg, args...);
throw E(msg.str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x12470
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4e2ce
leaq 0x20(%rsp), %rdi
leaq 0x40(%rs... | /metricq[P]hta/include/hta/exception.hpp |
nlohmann::detail::input_stream_adapter::input_stream_adapter(std::istream&) | explicit input_stream_adapter(std::istream& i)
: is(i), sb(*i.rdbuf())
{
// skip byte order mark
std::char_traits<char>::int_type c;
if ((c = get_character()) == 0xEF)
{
if ((c = get_character()) == 0xBB)
{
if ((c = get_character()) == 0xBF)
{
return; // Ignore BOM
}
else if (c != std::char_traits<char>::eof())
{
is.un... | pushq %rbx
movq %rdi, %rbx
leaq 0x41a15(%rip), %rax # 0xa9928
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rdi
movq %rdi, 0x10(%rbx)
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x67fb2
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rdi)
cmpl $-0x1, %eax
... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::scan() | token_type scan()
{
// read next character and ignore whitespace
do
{
get();
}
while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
switch (current)
{
// structural characters
case '[':
return token_type::begin_array;
case ']':
return token_type::end_array;
case '{':
return token_type::begi... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x14b20(%rip), %r14 # 0x7d5e0
movq %rbx, %rdi
callq 0x13556
movl 0x10(%rbx), %eax
cmpl $0x1f, %eax
jle 0x68ae6
cmpl $0x5a, %eax
jg 0x68b23
addl $-0x20, %eax
cmpl $0x1a, %eax
ja 0x68aff
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
leal -0x9(%rax), %ecx
c... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::reset() | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(std::char_traits<char>::to_char_type(current));
} | pushq %rax
movq %rdi, %rax
movq $0x0, 0x40(%rdi)
movq 0x38(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x20, %rdi
movq 0x20(%rax), %rcx
cmpq %rcx, 0x28(%rax)
je 0x692d1
movq %rcx, 0x28(%rax)
movb 0x10(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x594d0
popq %rax
retq
movq %rax, %rdi
callq 0x3e2ff
| /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::next_byte_in_range(std::initializer_list<int>) | bool next_byte_in_range(std::initializer_list<int> ranges)
{
assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
add(current);
for (auto range = ranges.begin(); range != ranges.end(); ++range)
{
get();
if (JSON_LIKELY(*range <= current and current <= *(++range)))
{
add(current);
}
else
{
error_mess... | pushq %rbx
subq $0x10, %rsp
cmpq $0x6, %rdx
ja 0x6935b
movl $0x54, %eax
btq %rdx, %rax
jae 0x6935b
leaq 0xf(%rsp), %rbx
movq %rbx, %rcx
callq 0x1375d
movb (%rbx), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0x14ce8(%rip), %rdi # 0x7e04a
leaq 0x1025c(%rip), %rsi # 0x795c5
leaq 0x14d19(%rip), %rcx ... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::basic_json<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string... | basic_json(CompatibleType && val) noexcept(noexcept(
JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
std::forward<CompatibleType>(val))))
{
JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
assert_invariant();
} | pushq %rbx
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
movb $0x3, (%rdi)
movq %rsi, %rdi
callq 0x4b9d0
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4a7d8
movq %rbx, %rdi
popq %rbx
jmp 0x4a7d8
| /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get_token_string() const | std::string get_token_string() const
{
// escape control characters
std::string result;
for (const auto c : token_string)
{
if ('\x00' <= c and c <= '\x1F')
{
// escape control characters
std::stringstream ss;
ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
<< std::hex << static_cast<int>(c) << ">";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r13
cmpq %r13, %rbp
je 0x696e2
leaq 0x40(%rsp), %r1... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::token_type_name(nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cx... | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::va... | cmpl $0x10, %edi
ja 0x69ef4
movl %edi, %eax
leaq 0x14dec(%rip), %rcx # 0x7ecd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x14597(%rip), %rax # 0x7e492
retq
| /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::parse_error::create(int, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
{
std::string w = exception::name("parse_error", id_) + "parse error" +
(byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +
": " + what_arg;
return parse_error(id_, byte_, w.c_str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x14578(%rip), %rsi # 0x7e4a0
leaq 0x1457c(%rip), %rdx # 0x7e4ab
leaq 0x68(%rsp), %rdi
ca... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const>::set_begin() | void set_begin() noexcept
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
m_it.object_iterator = m_object->m_value.object->begin();
break;
}
case value_t::array:
{
m_it.array_iterator = m_object->m_value.array->begin();
break;
}
case value_t::null:
{
// set to end so begin()==end()... | movq (%rdi), %rax
testq %rax, %rax
je 0x6aa50
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x6aa3e
cmpl $0x2, %ecx
je 0x6aa32
cmpl $0x1, %ecx
jne 0x6aa47
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rdi)
retq
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
retq
movq $0x1, 0x18(%rdi)
retq
movq $0x0... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const>::operator==(nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, ... | bool operator==(const iter_impl& other) const
{
// if objects are not the same, the comparison is undefined
if (JSON_UNLIKELY(m_object != other.m_object))
{
JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
}
assert(m_object != nullptr);
switch (m_object->m_type)
{
case va... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x6ab1a
testq %rax, %rax
je 0x6ab75
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x6aafa
cmpl $0x1, %eax
jne 0x6ab04
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x6ab0c
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jmp 0x6ab0... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const>::operator++() | iter_impl& operator++()
{
assert(m_object != nullptr);
switch (m_object->m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x6ad94
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x6ad84
cmpl $0x1, %eax
jne 0x6ad8b
movq 0x8(%rbx), %rdi
callq 0x12460
movq %rax, 0x8(%rbx)
jmp 0x6ad8f
addq $0x10, 0x10(%rbx)
jmp 0x6ad8f
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0x13b69(%rip), %r... | /metricq[P]hta/lib/json/include/nlohmann/json.hpp |
hta::Metric::aggregate_interval(hta::Clock::time_point, hta::Clock::time_point, std::chrono::duration<long, std::ratio<1l, 1000000000l>>) | Aggregate Metric::aggregate_interval(TimePoint begin, TimePoint end, Duration interval)
{
// We assume that timestamps provided are aligned and ordered
// to ensure that everything pieces together exactly
assert(begin.time_since_epoch().count() % interval.count() == 0);
assert(end.time_since_epoch().cou... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r10
movq %rdx, %rax
cqto
idivq %r8
testq %rdx, %rdx
jne 0x6c1a6
movq %rcx, %rax
cqto
idivq %r8
testq %rdx, %rdx
jne 0x6c1c5
cmpq %r10, %rcx
jl 0x6c1e4
movq %rdi, %rbx
movaps 0x12c95(%rip), %xmm0 # 0x7edb0
movups %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xm... | /metricq[P]hta/src/metric.cpp |
hta::Metric::aggregate(hta::Clock::time_point, hta::Clock::time_point) | Aggregate Metric::aggregate(hta::TimePoint begin, hta::TimePoint end)
{
check_read();
if (begin >= end)
{
throw_exception("invalid request: begin timestamp ", begin, " larger than end timestamp ",
end);
}
// We must cap the end or we use intervals that are not yet com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq %rsi, %rdi
callq 0x6bd50
cmpq %rbx, %r13
jge 0x6c560
movq %rbp, %rdi
callq 0x6bd50
movq (%rbp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpq ... | /metricq[P]hta/src/metric.cpp |
void hta::throw_exception<hta::Exception, char const*, long, char const*, long>(char const*, long, char const*, long) | [[noreturn]] inline void throw_exception(Args... args)
{
std::stringstream msg;
detail::make_exception<Args...>()(msg, args...);
throw E(msg.str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x12470
movq %rsp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
c... | /metricq[P]hta/include/hta/exception.hpp |
hta::detail::make_exception<char const*, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, char const*, hta::Clock::time_point, char const*, hta::Clock::time_point>::operator()(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const*, std::chrono::duration<long, std::ra... | void operator()(std::stringstream& msg, Arg arg, Args... args)
{
msg << arg;
make_exception<Args...>()(msg, args...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rsi, %r13
leaq 0x10(%rsi), %r15
testq %rdx, %rdx
je 0x6ed9f
movq %rdx, %r12
movq %rdx, %rdi
callq 0x122c0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x6edb7
movq (%r15)... | /metricq[P]hta/include/hta/exception.hpp |
hta::Meta::Meta(nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer> const&) | Meta::Meta(const json& config)
{
if (config.count("interval_min"))
{
interval_min = Duration(config["interval_min"]);
}
if (config.count("interval_factor"))
{
interval_factor = config["interval_factor"];
}
if (config.count("interval_max"))
{
interval_max = Duratio... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movabsq $0x2540be400, %rax # imm = 0x2540BE400
movq %rax, (%rdi)
movabsq $0x7009d32da30000, %rax # imm = 0x7009D32DA30000
movq %rax, 0x8(%rdi)
movq $0xa, 0x10(%rdi)
cmpb $0x1, (%rsi)
jne 0x6eee7
movq %rsi, %r14
movq 0x8(%rsi), %rdi
leaq 0x10781(%rip... | /metricq[P]hta/src/meta.cpp |
hta::detail::make_exception<char const*, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, char const*, long>::operator()(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const*, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, char const*, long) | void operator()(std::stringstream& msg, Arg arg, Args... args)
{
msg << arg;
make_exception<Args...>()(msg, args...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %r15
leaq 0x10(%rsi), %r13
testq %rdx, %rdx
je 0x6f4df
movq %rdx, %rbp
movq %rdx, %rdi
callq 0x122c0
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x6f4f8
movq (%r13)... | /metricq[P]hta/include/hta/exception.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeValue>::check_stream(char const*) | void check_stream(const char* message)
{
if (stream_.fail())
{
raise_stream_error(std::string("failed to ") + message);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x28(%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rdi,%rax)
jne 0x704e4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf1b7(%rip), %rsi # 0x7f... | /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::Exception::Exception(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::filesystem::__cxx11::path const&, int) | Exception(const std::string& message, const std::filesystem::path& filename, int error_number)
: hta::Exception(message + ": " + std::string(filename) + ": " + std::strerror(error_number)),
filename_(filename), errno_(error_number)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, 0x4(%rsp)
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4e2ce
leaq 0x9269(%rip... | /metricq[P]hta/src/storage/file/file.hpp |
void hta::throw_exception<hta::Exception, char const*, unsigned long, char const*>(char const*, unsigned long, char const*) | [[noreturn]] inline void throw_exception(Args... args)
{
std::stringstream msg;
detail::make_exception<Args...>()(msg, args...);
throw E(msg.str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x12470
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x70c8a
movl $0x10, %edi
callq 0... | /metricq[P]hta/include/hta/exception.hpp |
hta::detail::make_exception<char const*, unsigned long>::operator()(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const*, unsigned long) | void operator()(std::stringstream& msg, Arg arg, Args... args)
{
msg << arg;
make_exception<Args...>()(msg, args...);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
addq $0x10, %r14
testq %rdx, %rdx
je 0x70c61
movq %rdx, %r15
movq %rdx, %rdi
callq 0x122c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x70c79
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi... | /metricq[P]hta/include/hta/exception.hpp |
void hta::throw_exception<hta::Exception, char const*, std::filesystem::__cxx11::path, char const*, long, char const*, unsigned long>(char const*, std::filesystem::__cxx11::path, char const*, long, char const*, unsigned long) | [[noreturn]] inline void throw_exception(Args... args)
{
std::stringstream msg;
detail::make_exception<Args...>()(msg, args...);
throw E(msg.str());
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r13
leaq 0x50(%rsp), %rdi
callq 0x12470
leaq 0x28(%rsp), %rdi
movq %rbp, %rsi
callq 0x4a6e8
leaq 0x8(%rsp), %rdi
leaq 0x5... | /metricq[P]hta/include/hta/exception.hpp |
hta::detail::make_exception<char const*, std::fpos<__mbstate_t>>::operator()(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const*, std::fpos<__mbstate_t>) | void operator()(std::stringstream& msg, Arg arg, Args... args)
{
msg << arg;
make_exception<Args...>()(msg, args...);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
addq $0x10, %r14
testq %rdx, %rdx
je 0x71115
movq %rdx, %r15
movq %rdx, %rdi
callq 0x122c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x7112d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi... | /metricq[P]hta/include/hta/exception.hpp |
hta::detail::make_exception<char const*, std::filesystem::__cxx11::path, char const*, long, char const*, unsigned long>::operator()(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, char const*, std::filesystem::__cxx11::path, char const*, long, char const*, unsigned long) | void operator()(std::stringstream& msg, Arg arg, Args... args)
{
msg << arg;
make_exception<Args...>()(msg, args...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rsi, %r15
leaq 0x10(%rsi), %r12
testq %rdx, %rdx
je 0x7117c
movq %rdx, %rbp
movq %rdx, %rdi
callq 0x122c0
movq %r12, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x12710
jmp 0x71195
movq ... | /metricq[P]hta/include/hta/exception.hpp |
hta::storage::file::Metric::Metric<hta::storage::file::FileOpenTag::ReadWrite>(hta::storage::file::FileOpenTag::ReadWrite, std::filesystem::__cxx11::path const&, hta::Meta) | Metric(FOT file_open_tag, const std::filesystem::path& path, Meta meta)
: open_mode_(file_open_tag.mode), path_(path),
file_raw_(file_open_tag, path_raw(), Header(Duration(0), meta))
{
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
leaq 0x38683(%rip), %rax # 0xa9c28
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x2, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x4a6e8
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x72a12
leaq 0x80(%rsp), %rax
leaq 0x38(%r14), %rdi
movq (%rax), %rcx
leaq ... | /metricq[P]hta/src/storage/file/metric.hpp |
hta::storage::file::Metric::find_index_before_or_on(hta::Clock::time_point, long) | int64_t Metric::find_index_before_or_on(TimePoint t, int64_t sz)
{
auto [begin, end] = range();
if (begin > t)
{
return -1;
}
if (end <= t)
{
return sz - 1;
}
int64_t index = 0;
auto m = meta();
Duration interval = m.interval_min;
while (true)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdi), %rax
movq %rdi, 0x8(%rsp)
callq *0x60(%rax)
movq $-0x1, %r12
cmpq %rbx, %rax
jg 0x71ecc
cmpq %rbx, %rdx
jle 0x71ec6
movq %r14, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
leaq 0x30(%rsp)... | /metricq[P]hta/src/storage/file/metric.cpp |
hta::storage::file::Metric::find_index_on_or_after_binary(hta::Clock::time_point, long, long, long) | int64_t Metric::find_index_on_or_after_binary(TimePoint t, int64_t left, int64_t right, int64_t sz)
{
// left < right means right != 0
// assumes monotonicity ts(left) < ts(right)
// invariant ts(left) < t <= ts(right)
// right can be size() // out of range, but the pivot can never be
assert(left < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rcx, %rdx
jge 0x7201e
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
addq $0x38, %r13
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x72a78
cmpq %r15, %rax
jge 0x7204f
cmpq %rbx, %r14
je 0x71fda
mo... | /metricq[P]hta/src/storage/file/metric.cpp |
hta::storage::file::Metric::find_index(hta::Clock::time_point, hta::Clock::time_point, hta::IntervalScope) | std::pair<uint64_t, uint64_t> Metric::find_index(TimePoint begin, TimePoint end,
IntervalScope scope)
{
if (begin > end && scope.begin != Scope::infinity && scope.end != Scope::infinity)
{
throw_exception("storage::file::Metric::find_index invalid request... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %r13
movq %rcx, %rbx
shrq $0x20, %rbx
cmpq %rsi, %rdx
jge 0x722dd
cmpl $0x3, %r15d
je 0x722dd
cmpl $0x3, %ebx
jne 0x72439
movq (%r13), %rax
movq %r13, %rdi
callq *0x50(%rax)
test... | /metricq[P]hta/src/storage/file/metric.cpp |
hta::storage::file::Metric::get(hta::Clock::time_point, hta::Clock::time_point, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, hta::IntervalScope) | std::vector<TimeAggregate> Metric::get(TimePoint begin, TimePoint end, Duration interval,
IntervalScope scope)
{
auto sz = static_cast<int64_t>(size(interval));
if (sz == 0)
{
return {};
}
HtaFile* file;
try
{
file = &file_hta(interval)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq (%rsi), %rax
movq %rsi, %rdi
movq %r8, %rsi
callq *0x58(%rax)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x72639
movq %r13, 0x8(%rsp)
movq ... | /metricq[P]hta/src/storage/file/metric.cpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeValue>::read(std::fpos<__mbstate_t>) | value_type read(pos_type pos)
{
stream_.seekg(data_begin_ + static_cast<pos_type>(pos * value_size));
check_stream("seekg for read");
return read<value_type>();
} | pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
shlq $0x4, %rsi
movq 0x240(%rbx), %rdx
addq 0x238(%rbx), %rsi
callq 0x127d0
leaq 0xd5d7(%rip), %rsi # 0x80075
movq %rbx, %rdi
callq 0x704be
movq %rbx, %rdi
popq %rbx
jmp 0x7310c
nop
| /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeValue>::read(std::vector<hta::TimeValue, std::allocator<hta::TimeValue>>&, std::fpos<__mbstate_t>) | void read(std::vector<value_type>& vector, pos_type pos)
{
stream_.seekg(data_begin_ + static_cast<pos_type>(pos * value_size));
check_stream("seekg for vector read");
read(vector);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x28, %rdi
shlq $0x4, %rdx
movq 0x240(%r14), %rax
addq 0x238(%r14), %rdx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x127d0
leaq 0xd563(%rip), %rsi # 0x80131
movq %r14, %rdi
callq 0x704be
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
pop... | /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeAggregate>::read(std::fpos<__mbstate_t>) | value_type read(pos_type pos)
{
stream_.seekg(data_begin_ + static_cast<pos_type>(pos * value_size));
check_stream("seekg for read");
return read<value_type>();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsi), %r15
imulq $0x38, %rdx, %rsi
movq 0x240(%r14), %rdx
addq 0x238(%r14), %rsi
movq %r15, %rdi
callq 0x127d0
leaq 0xd383(%rip), %rsi # 0x80075
movq %r14, %rdi
callq 0x72fca
movq $0x0, (%rbx)
movaps 0xc0a8(%rip), %xmm0 # 0x7edb0
movup... | /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeAggregate>::File(std::filesystem::__cxx11::path const&, std::_Ios_Openmode) | File(const std::filesystem::path& filename, std::ios_base::openmode mode)
: filename_(filename), stream_(filename, mode | std::ios_base::binary)
{
check_stream("open file");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4a6e8
leaq 0x28(%rbx), %r14
orl $0x4, %ebp
movq (%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0x12850
xorps %xmm0, %xmm0
movups %xmm0, 0x238(%rbx)
leaq 0xbd85(%rip), %rsi # 0x7f6a8
movq %rbx, %rdi
ca... | /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeAggregate>::check_size() | void check_size()
{
stream_.seekg(0, std::fstream::end);
check_stream("seekg to end for size");
auto data_end = stream_.tellg();
if (data_end < data_begin_)
{
throw_exception("File with negative data size: ", filename_, ", data_end: ", data_end,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x12870
leaq 0xbb94(%rip), %rsi # 0x7f7d8
movq %r14, %rdi
callq 0x72fca
movq %rbx, %rdi
callq 0x12ac0
movq %rax, %r15
subq 0x238(%r14), %r15
jl 0x73c8f... | /metricq[P]hta/src/storage/file/file.hpp |
hta::storage::file::File<hta::storage::file::Metric::Header, hta::TimeAggregate>::write_preamble(hta::storage::file::Metric::Header const&) | void write_preamble(const HeaderType& header)
{
assert(stream_.tellp() == 0);
stream_.write(magic_bytes.data(), magic_bytes.size());
check_stream("write magic bytes");
write(byte_order_mark);
uint64_t header_size = sizeof(header);
write(header_size);
write(hea... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %r15
movq %r15, %rdi
callq 0x12550
testq %rax, %rax
jne 0x7402e
leaq 0xc4bd(%rip), %rsi # 0x803e0
movl $0x8, %edx
movq %r15, %rdi
callq 0x12800
leaq 0xba66(%rip), %rsi # 0x7f99d
movq %rbx, ... | /metricq[P]hta/src/storage/file/file.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.