name string | code string | asm string | file string |
|---|---|---|---|
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*) | void setColour( const char* _escapeCode ) {
std::cout << '\033' << _escapeCode;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x1b, (%rsi)
movq 0x3ea1c(%rip), %rdi # 0x78fb0
movl $0x1, %edx
callq 0x334c0
movq %rax, %r14
testq %rbx, %rbx
je 0x3a5be
movq %rbx, %rdi
callq 0x331f0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x334c0
jmp 0x3a5d8
movq (%r14), %... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<float>(float, int) | std::string fpToString( T value, int precision ) {
std::ostringstream oss;
oss << std::setprecision( precision )
<< std::fixed
<< value;
std::string d = oss.str();
std::size_t i = d.find_last_not_of( '0' );
if( i != std::string::npos && i != d.size()-1 ) {
if( d[i] == '.' )
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %esi, %ebp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x33570
movq (%r14), %rax
movq -0x18(%rax), %rcx
movslq %ebp, %rdx
movq %rdx, 0x30(%rsp,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Session::Session() | Session()
: m_cli( makeCommandLineParser() ) {
if( alreadyInstantiated ) {
std::string msg = "Only one instance of Catch::Session can ever be used";
std::cerr << msg << std::endl;
throw std::logic_error( msg );
}
alreadyInstanti... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3fceb
xorl %eax, %eax
movb %al, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
movsd 0x25d34(%rip), %xmm1 # 0x61030
movups %xmm1, 0x84(%rbx)
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rax, 0xa... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Session::~Session() | ~Session() {
Catch::cleanUp();
} | pushq %rbx
movq %rdi, %rbx
callq 0x3560e
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x3b4a5
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x118(%rbx), %rdi
callq 0x3fc54
movq 0xf8(%rbx), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x3b4c9
callq 0x333f0
movq 0xd8(%rbx), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0x3b4e... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::NotImplementedException::~NotImplementedException() | virtual ~NotImplementedException() CATCH_NOEXCEPT {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3b67b(%rip), %rax # 0x76be8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x3b582
callq 0x333f0
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x3b594
callq 0x333f0
movq %rbx, %rdi
popq %rbx
jmp 0x33830
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::TestSpec::NamePattern::matches(Catch::TestCaseInfo const&) const | virtual bool matches( TestCaseInfo const& testCase ) const {
switch( m_wildcard ) {
case NoWildcard:
return m_name == toLower( testCase.name );
case WildcardAtStart:
return endsWith( toLower( testCase.name ), m_name ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rdi), %eax
cmpq $0x3, %rax
ja 0x3b9fd
movq %rdi, %rbx
leaq 0x2575e(%rip), %rcx # 0x61088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x366fc
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x3b9da
testq %rdx, %rdx
... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Config::~Config() | virtual ~Config() {
m_os.rdbuf( std::cout.rdbuf() );
m_stream.release();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3b8b7(%rip), %rax # 0x77358
movq %rax, (%rdi)
leaq 0xd8(%rdi), %r14
movq 0xd8(%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movq 0x3d4f0(%rip), %rax # 0x78fb0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rsi
callq 0x33860
cmpb $0x1,... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CumulativeReporterBase::sectionStarting(Catch::SectionInfo const&) | virtual void sectionStarting( SectionInfo const& sectionInfo ) {
SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
Ptr<SectionNode> node;
if( m_sectionStack.empty() ) {
if( !m_rootSection )
m_rootSection = new SectionNode( incomplete... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x10(%rsp), %rdx
movq %r14, 0x10(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
leaq 0x28(%rsp), %rdi
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x4bbc2
movq %r14, 0x8(%rsp)
movq 0xb0(%rbx), %rax
cmpq %rax, 0xa8(%rbx)
... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CumulativeReporterBase::assertionEnded(Catch::AssertionStats const&) | virtual bool assertionEnded( AssertionStats const& assertionStats ) {
assert( !m_sectionStack.empty() );
SectionNode& sectionNode = *m_sectionStack.back();
sectionNode.assertions.push_back( assertionStats );
return true;
} | pushq %rax
movq 0xb0(%rdi), %rax
cmpq %rax, 0xa8(%rdi)
je 0x3c3a5
movl $0xc0, %edi
addq -0x8(%rax), %rdi
callq 0x4dc86
movb $0x1, %al
popq %rcx
retq
leaq 0x25eec(%rip), %rdi # 0x62298
leaq 0x253ca(%rip), %rsi # 0x6177d
leaq 0x25ef6(%rip), %rcx # 0x622b0
movl $0x1cb4, %edx # imm = 0x1CB4
callq 0x33... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&) | virtual void testRunEnded( TestRunStats const& testRunStats ) {
Ptr<TestRunNode> node = new TestRunNode( testRunStats );
node->children.swap( m_testGroups );
m_testRuns.push_back( node );
testRunEndedCumulative();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0x33440
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x3bf54(%rip), %rax # 0x78648
movq %rax, (%r14)
leaq 0x3a652(%rip), %rax # 0x76d50
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %ra... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::XmlReporter::EndGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Totals const&) | virtual void EndGroup( const std::string&, const Totals& totals ) {
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes", totals.assertions.passed )
.writeAttribute( "failures", totals.assertions.failed )
.writeAttribute( "expectedFailures", to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x257b4(%rip), %rsi # 0x623ee
leaq 0x257bb(%rip), %rdx # 0x623fc
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x53b2e
movq %rbx, (%... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::XmlReporter::EndTestCase(Catch::TestCaseInfo const&, Catch::Totals const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string&, const std::string& ) {
m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess );
m_xml.endElement();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2553e(%rip), %rsi # 0x62427
leaq 0x25544(%rip), %rdx # 0x62434
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x53b2e
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::XmlReporter::Result(Catch::AssertionResult const&) | virtual void Result( const Catch::AssertionResult& assertionResult ) {
if( !m_config.fullConfig()->includeSuccessfulResults() && assertionResult.getResultType() == ResultWas::Ok )
return;
if( assertionResult.hasExpression() ) {
m_xml.startElement( "Expression" )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0x3d31d
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
testb %al, %al
je 0x3d335
movq (%r15), %rax
movq %r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&) | virtual void testGroupStarting( GroupInfo const& groupInfo ) {
suiteTimer.start();
stdOutForSuite.str("");
stdErrForSuite.str("");
unexpectedExceptions = 0;
CumulativeReporterBase::testGroupStarting( groupInfo );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x336c0
imulq $0xf4240, (%r14), %rax # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x108(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2496d(%rip), %rdx # 0x625b4
leaq 0x8(%rsp), %rdi
mov... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&) | virtual void sectionEnded( SectionStats const& _sectionStats ) {
if( _sectionStats.missingAssertions ) {
lazyPrint();
Colour colour( Colour::ResultError );
if( m_sectionStack.size() > 1 )
stream << "\nNo assertions in section";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x90(%rsi)
jne 0x3e06a
movq %rbx, %rdi
callq 0x50198
movb $0x0, 0x7(%rsp)
callq 0x35bdc
movq (%rax), %rcx
movq %rax, %rdi
movl $0x12, %esi
callq *0x10(%rcx)
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
movq 0x18(%rbx), %r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig> const&) const | virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
FactoryMap::const_iterator it = m_factories.find( name );
if( it == m_factories.end() )
return NULL;
return it->second->create( ReporterConfig( config ) );
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x3e62a
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x3e575
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x3e552
movq (%rdi... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ReporterRegistry::registerReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::IReporterFactory*) | void registerReporter( std::string const& name, IReporterFactory* factory ) {
m_factories.insert( std::make_pair( name, factory ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x53a9e
movq %rbx, 0x20(%r15)
movq %r14, %rdi
movq %r15, ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Option<Catch::TestCaseInfo>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3fb4b
movq 0xe0(%r14), %rdi
leaq 0xf0(%r14), %rax
cmpq %rax, %rdi
je 0x3fae9
callq 0x333f0
movq 0xc0(%r14), %rdi
leaq 0xd0(%r14), %rax
cmpq %rax, %rdi
je 0x3fb01
callq 0x333f0
leaq 0x90(%r14), %rdi
callq 0x3f7c6
leaq 0x60(%r14), %r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::~CommandLine() | Arg() {} | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0x40e6e
leaq 0x50(%rbx), %rdi
callq 0x42eb2
movq $0x0, 0x50(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x431ea
leaq 0x8(%rbx), %rdi
callq 0x431c2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x40e97
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::ConfigData::*, std::__cxx11::basic_string<char, std::char_traits<ch... | void bind( M C::* field, std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
m_arg->placeholder = placeholder;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x33440
movq %rax, %r15
leaq 0x3715d(%rip), %rbx # 0x78238
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x33440
movq %rax, %r13
mov... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, int>(void (*)(Catch::ConfigData&, int), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
m_arg->placeholder = placeholder;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movl $0x10, %edi
callq 0x33440
movq %rax, %r15
leaq 0x3714f(%rip), %rbx # 0x78340
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x33440
movq %rax, %r13
mov... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::operator[](Catch::Clara::UnpositionalTag) | ArgBuilder operator[]( UnpositionalTag ) {
if( m_floatingArg.get() )
throw std::logic_error( "Only one unpositional argument can be added" );
m_floatingArg = ArgAutoPtr( new Arg() );
ArgBuilder builder( m_floatingArg.get() );
return builder;
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x414ea
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x33440
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::CommonArgProperties<Catch::ConfigData>::~CommonArgProperties() | CommonArgProperties() {} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x423a6
callq 0x333f0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x423b8
callq 0x333f0
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x423ca
callq 0x333f0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::Detail::convertInto(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&) | inline void convertInto( std::string const& _source, bool& _dest ) {
std::string sourceLC = _source;
std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower );
if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x53a9e
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x4290f
movq ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Session::run() | int run() {
if( m_configData.showHelp )
return 0;
try
{
config(); // Force config to be constructed
Runner runner( m_config );
// Handle list request
if( Option<std::size_t> listed = list( config() ) )
... | pushq %r14
pushq %rbx
subq $0x278, %rsp # imm = 0x278
xorl %ebx, %ebx
cmpb $0x0, 0x7f(%rdi)
jne 0x43659
movq %rdi, %r14
callq 0x4643a
leaq 0x130(%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x46496
movq %r14, %rdi
callq 0x4643a
movq %rax, %rbx
movq $0x0, 0x8(%rsp)
cmpb $0x1, 0x10(%rax)
jne 0x43543
movq %rbx, %rdi... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Tbc::operator<<(std::ostream&, Catch::Tbc::Text const&) | inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
it != itEnd; ++it ) {
if( it != _text.begin() )
_stream << "\n";
_stream << *it;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rsi), %r12
movq 0x48(%rsi), %r13
cmpq %r13, %r12
je 0x43a62
movq %rsi, %r14
leaq 0x1eb81(%rip), %r15 # 0x625b3
cmpq 0x40(%r14), %r12
je 0x43a48
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x334c0
movq (%r12), %rsi
movq 0x8(%... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Tbc::Text::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Tbc::TextAttributes const&) | Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x90(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm0, 0x20(%rd... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Tbc::Text::~Text() | Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
: attr( _attr )
{
std::string wrappableChars = " [({.,/|\\-";
std::size_t indent = _attr.initialIndent != std::string::npos
? _attr.initialIndent
: _attr.indent;
... | pushq %rbx
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x3fc54
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x43fa1
popq %rbx
jmp 0x333f0
popq %rbx
retq
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::Parser::parseIntoTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&) const | void parseIntoTokens( std::string arg, std::vector<Parser::Token>& tokens ) const {
while( !arg.empty() ) {
Parser::Token token( Parser::Token::Positional, arg );
arg = "";
if( token.data[0] == '-' ) {
if( token.data.size() > 1 && token.dat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, 0x80(%rsp)
movq %rdi, 0x78(%rsp)
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x445d7
movq %rsi, %r14
leaq 0x58(%rsp), %r12
leaq 0x68(%rsp), %rbp
leaq 0x18(%rsp), %r13
leaq 0x30(%rsp), %rbx
movl $0x0, 0x50(%rsp)
movq %rbp, 0x58(%r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::populateOptions(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const | std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
std::vector<Parser::Token> unusedTokens;
std::vector<std::string> errors;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
Parser::Token const& token = to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rcx, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, 0x28(%rsp)
movups %xmm0, (%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq (%rdx), %rax
mo... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::populateFixedArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const | std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
std::vector<Parser::Token> unusedTokens;
int position = 1;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
Parser::Token const& token = tokens[i];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x45077
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsi), %rbp
movl $0x1, %ebx
xorl %r14d, ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Runner::Runner(Catch::Ptr<Catch::Config> const&) | Runner( Ptr<Config> const& config )
: m_config( config )
{
openStream();
makeReporter();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, (%rbx)
testq %rdi, %rdi
je 0x464b2
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x33730
xorl %eax, %eax
movq %rax, 0x208(%rbx)
leaq 0x210(%rbx), %r12
leaq 0x218(%rbx), %rcx
movl $0x0, 0x... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::TestSpecParser::visitChar(char) | void visitChar( char c ) {
if( m_mode == None ) {
switch( c ) {
case ' ': return;
case '~': m_exclusion = true; return;
case '[': return startNewMode( Tag, ++m_pos );
case '"': return startNewMode( QuotedName, ++m_pos );
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x46e87
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x46eb8
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x46f15
cmpl $0x2c, %eax
jne 0x46f8c
movq %rbx, %rdi
callq 0x46f96
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4716a... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::RunContext::testGroupStarting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x1a8(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x53a9e
movq %r14, 0x20(%r12)
movq %rbx... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::RunContext::runTest(Catch::TestCase const&) | Totals runTest( TestCase const& testCase ) {
Totals prevTotals = m_totals;
std::string redirectedCout;
std::string redirectedCerr;
TestCaseInfo testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting( testInfo );
m_activeTestCase = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x318, %rsp # imm = 0x318
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movups 0x178(%rsi), %xmm0
movups 0x188(%rsi), %xmm1
movups 0x198(%rsi), %xmm2
movaps %xmm2, 0x60(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x30(... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::RunContext::sectionEnded(Catch::SectionInfo const&, Catch::Counts const&, double) | virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
if( std::uncaught_exception() ) {
m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
return;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x33070
testb %al, %al
je 0x4a7b0
addq $0x250, %rbx # imm = 0x250
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd (%rsp), %xm... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::RunContext::UnfinishedSections::~UnfinishedSections() | UnfinishedSections( SectionInfo const& _info, Counts const& _prevAssertions, double _durationInSeconds )
: info( _info ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
{} | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x4a9d8
callq 0x333f0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4a9ea
callq 0x333f0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4a9fc
popq %rbx
jmp 0x333f0
popq %rbx
retq
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::SectionTracking::TestCaseTracker::enterSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool enterSection( std::string const& name ) {
TrackedSection* child = m_currentSection->acquireChild( name );
if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
return false;
m_currentSection = child;
m_currentSection->ent... | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4b5b2
cmpb $0x0, 0x68(%rbx)
jne 0x4b59a
movq %rax, %rcx
movl 0x20(%rax), %edx
cmpl $0x3, %edx
jne 0x4b59e
xorl %eax, %eax
popq %rbx
retq
movq %rcx, 0x60(%rbx)
movb $0x1, %al
testl %edx, %edx
jne 0x4b59c
movl $0x1, 0x20(%rcx)
jmp 0x4b59c
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
durationInSeconds( _duratio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x2b108(%rip), %rax # 0x76cf0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%r14)
movq (%rsi), %r... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::StreamRedirect::StreamRedirect(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | StreamRedirect( std::ostream& stream, std::string& targetString )
: m_stream( stream ),
m_prevBuf( stream.rdbuf() ),
m_targetString( targetString )
{
stream.rdbuf( m_oss.rdbuf() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x33570
movq %r15, 0x188(%rbx)
movq (%r12), %rax
addq -0x18(%rax),... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::TestCaseStats::TestCaseStats(Catch::TestCaseStats const&) | TestCaseStats( TestCaseStats const& ) = default; | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28b1e(%rip), %rax # 0x76d10
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x36754
movups 0x118(%r15), %xmm0
movups 0x128(%r15), %xmm1
movups 0x138(%r15), %xmm2
movups %xmm2, 0x138(%r14)
movup... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CumulativeReporterBase::Node<Catch::TestRunStats, Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>>>::~Node() | virtual ~Node() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x29de9(%rip), %rax # 0x78648
movq %rax, (%rdi)
addq $0x70, %rdi
callq 0x3b19e
leaq 0x284de(%rip), %rax # 0x76d50
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x4e889
popq %rbx
jmp 0x333f0
popq %rbx
retq
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %r15
leaq 0x12884(%rip), %rsi # 0x61712
movl $0x1, %edx
movq %r15, %rdi
callq 0x334c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x334c0
movq %rax, %r14
leaq 0x13521(%rip), %rsi ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::writeGroup(Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>> const&, double) | void 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd %xmm0, 0x78(%rsp)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x134ed(%rip), %rsi # 0x6248d
leaq 0x134ef(%rip), %rdx # 0x62496
leaq 0x8(%rsp), %rdi
callq 0x53b2e
leaq 0xc0(%rbx), %r14
movq %r14, 0... | /jh0x[P]cornelich/contrib/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 ) {
if( !name.empty() )
stream() << " " << name << "=\"" << attribute << "\"";
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x4f53e
movq %rdx, %r14
movq %rsi, %r15
movq 0x40(%rbx), %r12
leaq 0x12231(%rip), %rsi # 0x61712
movl $0x1, %edx
movq %r12, %rdi
callq 0x334c0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x334c0
movq %rax... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::JunitReporter::writeSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CumulativeReporterBase::SectionNode const&) | void writeSection( std::string const& className,
std::string const& rootName,
SectionNode const& sectionNode ) {
std::string name = trim( sectionNode.stats.sectionInfo.name );
if( !rootName.empty() )
name = rootName + "/" +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x18(%rcx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x3757e
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x4f882
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r1... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::~AssertionPrinter() | AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
: stream( _stream ),
stats( _stats ),
result( _stats.assertionResult ),
colour( Colour::None ),
message( result.getMessage() ),
m... | pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x3b0e8
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x50674
callq 0x333f0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x50686
callq 0x333f0
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x50699
popq %rbx
jmp 0x333f0
popq... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::printClosedHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void printClosedHeader( std::string const& _name ) {
printOpenHeader( _name );
stream << getLineOfChars<'.'>() << "\n";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x50c7a
movq 0x18(%rbx), %rbx
cmpb $0x0, 0x289e1(%rip) # 0x795f0
jne 0x50c42
movaps 0x10458(%rip), %xmm0 # 0x61070
movups %xmm0, 0x28a10(%rip) # 0x7962f
movaps %xmm0, 0x289fa(%rip) # 0x79620
movaps %xmm0, 0x289e3(%rip) # 0x79610
movaps %xmm0, 0x289c... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::printSourceInfo() const | void printSourceInfo() const {
Colour colourGuard( Colour::FileName );
stream << result.getSourceInfo() << ": ";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movb $0x0, 0x7(%rsp)
callq 0x35bdc
movq (%rax), %rcx
movq %rax, %rdi
movl $0x17, %esi
callq *0x10(%rcx)
movq (%r14), %rbx
movq 0x10(%r14), %r15
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::printOriginalExpression() const | void printOriginalExpression() const {
if( result.hasExpression() ) {
Colour colourGuard( Colour::OriginalExpression );
stream << " ";
stream << result.getExpressionInMacro();
stream << "\n";
}
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq $0x0, 0x50(%rax)
je 0x5100f
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
callq 0x35bdc
movq (%rax), %rcx
movq %rax, %rdi
movl $0x5, %esi
callq *0x10(%rcx)
movq (%rbx), %rdi
leaq 0x1104a(%rip), %rsi # 0x61ffb
movl $0x2, %edx
callq 0x334c0
movq (%rbx), %r14
mo... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ConsoleReporter::SummaryColumn::addRow(unsigned long) | SummaryColumn addRow( std::size_t count ) {
std::ostringstream oss;
oss << count;
std::string row = oss.str();
for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
while( it->size() < row.size() )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x33570
movq %r12, %rdi
movq %r15, %rsi
callq 0x332e0
movq %rbx, 0x28(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CompactReporter::AssertionPrinter::printSourceInfo() const | void printSourceInfo() const {
Colour colourGuard( Colour::FileName );
stream << result.getSourceInfo() << ":";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movb $0x0, 0x7(%rsp)
callq 0x35bdc
movq (%rax), %rcx
movq %rax, %rdi
movl $0x17, %esi
callq *0x10(%rcx)
movq (%r14), %rbx
movq 0x10(%r14), %r15
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::CompactReporter::AssertionPrinter::printOriginalExpression() const | void printOriginalExpression() const {
if( result.hasExpression() ) {
stream << " " << result.getExpression();
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
cmpq $0x0, 0x50(%rax)
je 0x52d91
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0xe9c1(%rip), %rsi # 0x61712
movl $0x1, %edx
movq %r14, %rdi
callq 0x334c0
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x35f8e
movq (%rbx), %rsi
movq 0x8(%rbx), ... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::StringMakerBase<true>::convert<char>(char const&) | static std::string convert( T const& _value ) {
std::ostringstream oss;
oss << _value;
return oss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33570
movb (%r14), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x334c0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33690
movq 0x2... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Option<Catch::TagAlias>::reset() | void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = NULL;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x5421c
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x5420b
callq 0x333f0
movq (%r14), %rdi
addq $0x10, %r14
cmpq %r14, %rdi
je 0x5421c
callq 0x333f0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ReporterRegistrar<Catch::CompactReporter>::ReporterFactory::getDescription[abi:cxx11]() const | virtual std::string getDescription() const {
return T::getDescription();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x38, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x337d0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x7345444920726f66, %rdx # imm = 0x7345444920726F66
movq %rdx, 0x30(%rax)
movups 0x... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::LegacyReporterRegistrar<Catch::XmlReporter>::ReporterFactory::getDescription[abi:cxx11]() const | virtual std::string getDescription() const {
return T::getDescription();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x27, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x337d0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x746e656d75636f64, %rdx # imm = 0x746E656D75636F64
movq %rdx, 0x1f(%rax)
movups 0x... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::StdString::StartsWith, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clone() const | virtual Ptr<Matcher<ExpressionT> > clone() const {
return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x30, %edi
callq 0x33440
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x226d8(%rip), %rax # 0x77170
movq %rax, (%r14)
leaq 0x10(%r14), %rdi
leaq 0x20(%r14), %rax
movq %rax, 0x10(%r14)
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
addq %rsi, %rdx
call... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ExpressionLhs<bool>::endExpression() | void endExpression() {
bool value = m_lhs ? true : false;
m_rb
.setLhs( Catch::toString( value ) )
.setResultType( value )
.endExpression();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %r14
movzbl 0x8(%rdi), %ebx
movq %rsp, %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0x3844a
movq %r14, %rdi
movq %r15, %rsi
callq 0x386a2
movq %rax, %rdi
movl %ebx, %esi
callq 0x3868c
movq %rax, %rdi
callq 0x386e4
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::ResultBuilder& Catch::ExpressionLhs<long const&>::captureExpression<(Catch::Internal::Operator)0, long long>(long long const&) | ResultBuilder& captureExpression( RhsT const& rhs ) {
return m_rb
.setResultType( Internal::compare<Op>( m_lhs, rhs ) )
.setLhs( Catch::toString( m_lhs ) )
.setRhs( Catch::toString( rhs ) )
.setOp( Internal::OperatorTraits<Op>::getName() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movq (%rax), %rax
xorl %esi, %esi
cmpq (%rbx), %rax
sete %sil
callq 0x3868c
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x57aa2
movq %r15, %rdi
movq %r14, %rsi
ca... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::StringMakerBase<true>::convert<long long>(long long const&) | static std::string convert( T const& _value ) {
std::ostringstream oss;
oss << _value;
return oss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33570
movq (%r14), %rsi
movq %r15, %rdi
callq 0x33190
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33690
movq 0x20bde(%rip), %rsi # 0x78f98
leaq 0x8(%rsp), %rdi
c... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
cornelich::vanilla_chronicle_settings::cycle_length(int, std::shared_ptr<cornelich::cycle_formatter> const&, bool) | vanilla_chronicle_settings & vanilla_chronicle_settings::cycle_length(const std::int32_t cycle_length, const std::shared_ptr<cycle_formatter> & formatter, bool check)
{
if(check && cycle_length < min_cycle_length())
throw std::invalid_argument(util::streamer() << "Cycle length [ms] can't be less than " << m... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
xorb $0x1, %cl
cmpl $0x36ee80, %esi # imm = 0x36EE80
setge %al
orb %cl, %al
je 0x5876f
movq %rdi, %rbx
movl %esi, 0x24(%rdi)
movq (%rdx), %rax
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
addq $0x8, %rdx
movq %rdx, %rsi
callq 0x58baa
movq %rb... | /jh0x[P]cornelich/cornelich/vanilla_chronicle_settings.cpp |
cornelich::operator<<(std::ostream&, cornelich::vanilla_chronicle_settings const&) | std::ostream & operator<<(std::ostream & os, const vanilla_chronicle_settings & s)
{
os << "- path = " << s.path() << '\n'
<< "- cycle_length = " << s.cycle_length() << '\n'
<< "- entries_per_cycle = " << s.entries_per_cycle() << " [" << std::log2(s.entries_per_cycle()... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaec9(%rip), %rsi # 0x63733
movl $0x1b, %edx
callq 0x334c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x334c0
movb $0xa, %bpl
leaq 0x2(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
m... | /jh0x[P]cornelich/cornelich/vanilla_chronicle_settings.cpp |
cornelich::vanilla_index::find_first_cycle() const | std::int32_t vanilla_index::find_first_cycle() const
{
auto first_cycle = std::numeric_limits<std::int32_t>::max();
boost::system::error_code err;
fs::directory_iterator begin(m_settings.path(), err);
fs::directory_iterator end;
// No directories -> empty
if(begin == end)
return -1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x59f7a
movq (%rbx), %rax
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x53a9e... | /jh0x[P]cornelich/cornelich/vanilla_index.cpp |
cornelich::vanilla_index::find_last_cycle() const | std::int32_t vanilla_index::find_last_cycle() const
{
auto last_cycle = -1;
boost::system::error_code err;
fs::directory_iterator begin(m_settings.path(), err);
fs::directory_iterator end;
// No directories -> empty
if(err || begin == end)
return last_cycle;
// Find the newest dire... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x59f7a
movq (%rbx), %rax
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x53a9e... | /jh0x[P]cornelich/cornelich/vanilla_index.cpp |
TCMallocTest_Versions_Test::TestBody() | TEST(TCMallocTest, Versions) {
auto build_version_string = [] (int major, int minor, const char* patch) -> std::string {
CHECK(patch[0] == 0 || patch[0] == '.'); // patch version needs to start with dot
std::stringstream ss;
ss << "gperftools " << major << "." << minor << patch;
return ss.str();
};
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7640c(%rip), %r8 # 0x87662
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rsi
movl $0x2, %edx
movl $0x10, %ecx
callq 0x11490
leaq -0x61(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xdf50
movq -0x98(%rbp), %rdx
leaq 0x763c8(%rip), %rsi # 0x87653
le... | /alk[P]gperftools/src/tests/tcmalloc_unittest.cc |
TCMallocTest_Ranges_Test::TestBody() | TEST(TCMallocTest, Ranges) {
static const int MB = 1048576;
void* a = malloc(MB);
void* b = malloc(MB);
base::MallocRange::Type releasedType =
TestingPortal::Get()->HaveSystemRelease() ? base::MallocRange::UNMAPPED : base::MallocRange::FREE;
CheckRangeCallback(a, base::MallocRange::INUSE, MB);
CheckRan... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x100000, %edi # imm = 0x100000
callq 0xe118
movq %rax, -0x10(%rbp)
movl $0x100000, %edi # imm = 0x100000
callq 0xe118
movq %rax, -0x18(%rbp)
callq 0x21b80
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movb %al, %dl
movl $0x1, %ea... | /alk[P]gperftools/src/tests/tcmalloc_unittest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x280(%rax)
jne 0x3e6a3
movl $0x8, %edi
callq 0xe100
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
callq 0x62fa0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x280(%rax)
movq -0x10(%rbp), %rax
... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::GetTimeInMillis() | TimeInMillis GetTimeInMillis() {
return std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now() -
std::chrono::system_clock::from_time_t(0))
.count();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xd0a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5c9f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5c9a0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5c970
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, 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>>>>*) | void SplitString(const ::std::string& str, char delimiter,
::std::vector< ::std::string>* dest) {
::std::vector< ::std::string> parsed;
::std::string::size_type pos = 0;
while (::testing::internal::AlwaysTrue()) {
const ::std::string::size_type colon = str.find(delimiter, pos);
if (colon ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5c5e0
movq $0x0, -0x38(%rbp)
callq 0x3e8d0
movb %al, -0x91(%rbp)
jmp 0x3e7a7
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x3e7b6
jmp 0x3e89e
movq -0x8(%rbp), %rdi
mov... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::AlwaysTrue() | bool AlwaysTrue() {
#if GTEST_HAS_EXCEPTIONS
// This condition is always false so AlwaysTrue() never actually throws,
// but it makes the compiler think that it may throw.
if (IsTrue(false)) throw ClassUniqueToAlwaysTrue();
#endif // GTEST_HAS_EXCEPTIONS
return true;
} | pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x3a740
testb $0x1, %al
jne 0x3e8e1
jmp 0x3e8fe
movl $0x1, %edi
callq 0xd3f0
movq %rax, %rdi
leaq 0x8068b(%rip), %rsi # 0xbef80
xorl %eax, %eax
movl %eax, %edx
callq 0xded0
movb $0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::StreamWideCharsToMessage(wchar_t const*, unsigned long, testing::Message*) | static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
Message* msg) {
for (size_t i = 0; i != length;) { // NOLINT
if (wstr[i] != L'\0') {
*msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
while (i != length && wstr[i] != L'\0') ... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x3ec7d
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3ec5b
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
m... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::CreateUnifiedDiff(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::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std... | std::string CreateUnifiedDiff(const std::vector<std::string>& left,
const std::vector<std::string>& right,
size_t context) {
const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
size_t l_i = 0, r_i = 0, edit_i = 0;
std::stringstream s... | pushq %rbp
movq %rsp, %rbp
subq $0x300, %rsp # imm = 0x300
movq %rdi, -0x2b0(%rbp)
movq %rdi, %rax
movq %rax, -0x2a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x3f6f0
movq $0x0, -... | /alk[P]gperftools/vendor/googletest/googletest/src/gtest.cc |
nnad::FeedForwardNN<double>::GetParameters() const | std::vector<T> GetParameters() const
{
// Initialise output vector
std::vector<T> output(_Np + _NpPrep);
// Element counter
int count = 0;
// Number of layers
const int nl = (int) _Arch.size();
// Neural network parameters
for (int l = nl - 1; l > 0; l--)
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0xe0(%rsi), %rax
movslq 0x98(%rsi), %rsi
addq %rax, %rsi
leaq 0x4(%rsp), %rdx
callq 0x35c6
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
leaq 0x118(%r14), %rdx
movq %rdx, 0x... | /rabah-khalek[P]NNAD/inc/NNAD/FeedForwardNN.h |
nnad::FeedForwardNN<double>::Evaluate(std::vector<double, std::allocator<double>> const&) const | std::vector<T> Evaluate(std::vector<T> const& Input) const
{
// Check that the size of the input vector is equal to the number of
// input nodes.
if ((int) Input.size() != _Arch[0])
Error("Evaluate: the number of inputs does not match the number of input nodes.");
// Number of layer... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x3, %rax
movq (%rsi), %rcx
cmpl %eax, (%rcx)
je 0x32d0
leaq 0x50de(%rip), %rsi # 0x837b
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq ... | /rabah-khalek[P]NNAD/inc/NNAD/FeedForwardNN.h |
nnad::Matrix<double>::Matrix(int const&, int const&, int const&) | Matrix(int const& Lines, int const& Columns, int const& RandomSeed = -1):
_Lines(Lines),
_Columns(Columns),
_Matrix(_Lines * _Columns)
{
// Initialise random number generator.
srand(RandomSeed);
// Fill in the matrix with random numbers distributed in [-1:1]
for (int i = 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movl (%rdx), %ecx
movl %ecx, 0x4(%rdi)
leaq 0x8(%rdi), %r14
imull %eax, %ecx
movslq %ecx, %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x35c6
movl (%r15), %edi
callq 0x2140
xorl %r15d, %r15d
pus... | /rabah-khalek[P]NNAD/inc/NNAD/Matrix.h |
nnad::Matrix<double>::Matrix(nnad::Matrix<double> const&, std::function<double (double const&)>) | Matrix(Matrix const& x, std::function<T(T const&)> f):
_Lines(x.GetLines()),
_Columns(x.GetColumns()),
_Matrix(_Lines * _Columns)
{
const std::vector<T> xv = x.GetVector();
for (int i = 0; i < (int) xv.size(); i++)
_Matrix[i] = f(xv[i]);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %ecx
movl %ecx, 0x4(%rdi)
addq $0x8, %rbx
imull %eax, %ecx
movslq %ecx, %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x35c6
addq $0x8, %r15
movq %rsp, %rdi
movq ... | /rabah-khalek[P]NNAD/inc/NNAD/Matrix.h |
binlog::Session::Session() | inline Session::Session()
{
const ClockSync clockSync = systemClockSync();
serializeSizePrefixedTagged(clockSync, _clockSync);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movabsq $-0x1deb08d91ca4244, %rsi # imm = 0xFE214F726E35BDBC
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5e44
... | /erenon[P]binlog/include/binlog/Session.hpp |
binlog::detail::RecoverableVectorOutputStream::write(char const*, long) | RecoverableVectorOutputStream& write(const char* buffer, std::streamsize size)
{
std::uint64_t magic = 0;
if (_vector.capacity() < _vector.size() + std::size_t(size))
{
// vector will reallocate, clear the magic of the old buffer
// to avoid recovering invalid data
magic = clearMagic();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
subq %rax, %rdi
movq %rcx, %r8
subq %rax, %r8
addq %rsi, %r8
cmpq %r8, %rdi
jae 0x62b5
movq (%rax), %r14
movq $0x0, (%rax)
movq 0x8(%rbx), %rsi
addq %rdx, %rcx
movq %rbx, %rdi
ca... | /erenon[P]binlog/include/binlog/detail/VectorOutputStream.hpp |
binlog::Session::createChannel(unsigned long, binlog::WriterProp) | inline std::shared_ptr<Session::Channel> Session::createChannel(std::size_t queueCapacity, WriterProp writerProp)
{
std::lock_guard<std::mutex> lock(_mutex);
_channels.push_back(std::make_shared<Channel>(*this, queueCapacity, std::move(writerProp)));
return _channels.back();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x18(%rsp)
movq %rsi, %rdi
callq 0x2210
testl %eax, %eax
jne 0x66bd
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x18(%rsp), %r8
movq %rbx, %rcx
movq %r15, %r9
callq... | /erenon[P]binlog/include/binlog/Session.hpp |
auto mserialize::cx_strcat<6ul, 1ul>(mserialize::cx_string<6ul> const&&, mserialize::cx_string<1ul> const&&) | constexpr auto cx_strcat(const cx_string<N>&&... strings)
{
char buffer[detail::sum<N...>()+1] = {0};
const char* data[] = {"", strings.data()...};
const std::size_t size[] = {0, strings.size()...};
char* out = buffer;
for (std::size_t i = 1; i <= sizeof...(N); ++i)
{
for (std::size_t s = 0; s < size[i... | leaq -0x40(%rsp), %rax
movq $0x0, (%rax)
movq %rdi, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movq $0x6, -0x30(%rsp)
movq $0x1, -0x28(%rsp)
movl $0x1, %ecx
cmpq $0x0, -0x38(%rsp,%rcx,8)
je 0x6cc0
xorl %edx, %edx
movq -0x18(%rsp,%rcx,8), %rsi
movb (%rsi,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq -0x38(%rsp,%rcx,8), %rdx
... | /erenon[P]binlog/include/mserialize/cx_string.hpp |
auto mserialize::cx_strcat<7ul, 3ul, 1ul, 1ul>(mserialize::cx_string<7ul> const&&, mserialize::cx_string<3ul> const&&, mserialize::cx_string<1ul> const&&, mserialize::cx_string<1ul> const&&) | constexpr auto cx_strcat(const cx_string<N>&&... strings)
{
char buffer[detail::sum<N...>()+1] = {0};
const char* data[] = {"", strings.data()...};
const std::size_t size[] = {0, strings.size()...};
char* out = buffer;
for (std::size_t i = 1; i <= sizeof...(N); ++i)
{
for (std::size_t s = 0; s < size[i... | xorl %r8d, %r8d
leaq -0x68(%rsp), %rax
movq %r8, 0x5(%rax)
movq %r8, (%rax)
movq %rdi, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x8(%rsp)
movq $0x7, -0x50(%rsp)
movq $0x3, -0x48(%rsp)
movl $0x1, %ecx
movq %rcx, -0x40(%rsp)
movq %rcx, -0x38(%rsp)
cmpq $0x0, -0x58(%rsp,%rcx,8)
je 0x6d4c
xorl ... | /erenon[P]binlog/include/mserialize/cx_string.hpp |
auto mserialize::cx_strcat<15ul, 3ul, 1ul, 3ul, 1ul, 3ul, 2ul, 1ul>(mserialize::cx_string<15ul> const&&, mserialize::cx_string<3ul> const&&, mserialize::cx_string<1ul> const&&, mserialize::cx_string<3ul> const&&, mserialize::cx_string<1ul> const&&, mserialize::cx_string<3ul> const&&, mserialize::cx_string<2ul> const&&,... | constexpr auto cx_strcat(const cx_string<N>&&... strings)
{
char buffer[detail::sum<N...>()+1] = {0};
const char* data[] = {"", strings.data()...};
const std::size_t size[] = {0, strings.size()...};
char* out = buffer;
for (std::size_t i = 1; i <= sizeof...(N); ++i)
{
for (std::size_t s = 0; s < size[i... | subq $0x48, %rsp
movq %rdi, %rax
movq 0x60(%rsp), %r10
movaps 0x50(%rsp), %xmm0
xorps %xmm1, %xmm1
leaq 0x20(%rsp), %rdi
movups %xmm1, 0xe(%rdi)
movaps %xmm1, (%rdi)
movq %rsi, -0x28(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x10(%rsp)
movq %r9, -0x8(%rsp)
movaps %xmm0, (%rsp)
movq %r10, 0x10(%rsp)... | /erenon[P]binlog/include/mserialize/cx_string.hpp |
bool binlog::SessionWriter::addEvent<Single>(unsigned long, unsigned long, Single&&) | bool SessionWriter::addEvent(std::uint64_t eventSourceId, std::uint64_t clock, Args&&... args) noexcept
{
// compute size (excludes size field)
std::size_t size = 0;
const std::size_t sizes[] = {sizeof(eventSourceId), sizeof(clock), mserialize::serialized_size(args)...};
for (auto s : sizes) { size += s; }
/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x17, %rax
ja 0x7df6
leaq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x7c9c
cmpq $0x17, %rax
ja 0x7df6
movl $0x18, %esi
movq %rbx, %rdi
callq 0x7b08
movq 0... | /erenon[P]binlog/include/binlog/SessionWriter.hpp |
bool binlog::SessionWriter::addEvent<Getter>(unsigned long, unsigned long, Getter&&) | bool SessionWriter::addEvent(std::uint64_t eventSourceId, std::uint64_t clock, Args&&... args) noexcept
{
// compute size (excludes size field)
std::size_t size = 0;
const std::size_t sizes[] = {sizeof(eventSourceId), sizeof(clock), mserialize::serialized_size(args)...};
for (auto s : sizes) { size += s; }
/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1e, %rax
ja 0x7fbe
movq %r15, %rdi
callq 0x7c9c
cmpq $0x1e, %rax
ja 0x7fbe
movl $0x1f, %esi
movq %rbx, %rdi
callq 0x7b08
movq 0... | /erenon[P]binlog/include/binlog/SessionWriter.hpp |
void mserialize::StructSerializer<Getter, std::integral_constant<int (Getter::*)() const, &Getter::a() const>, std::integral_constant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> (Getter::*)() const, &Getter::b() const>>::serialize<binlog::detail::QueueWriter>(Getter const&, binlog::de... | static void serialize(const T& t, OutputStream& ostream)
{
using swallow = int[];
(void)swallow{1, (serialize_member(t, Members::value, ostream), int{})...};
} | subq $0x28, %rsp
movq 0x8(%rsi), %rax
movl $0x21, (%rax)
movq 0x8(%rsi), %rax
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%rsi)
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movl $0x6f6f66, (%rcx) # imm = 0x6F6F66
movq $0x3, -0x8(%rcx)
movl $0x3, 0x4(%rax)
movq 0x8(%rsi), %rax
leaq 0x4(%rax), %rdx
movq %rdx, 0x8(%rsi)
mov... | /erenon[P]binlog/include/mserialize/StructSerializer.hpp |
bool binlog::SessionWriter::addEvent<Private>(unsigned long, unsigned long, Private&&) | bool SessionWriter::addEvent(std::uint64_t eventSourceId, std::uint64_t clock, Args&&... args) noexcept
{
// compute size (excludes size field)
std::size_t size = 0;
const std::size_t sizes[] = {sizeof(eventSourceId), sizeof(clock), mserialize::serialized_size(args)...};
for (auto s : sizes) { size += s; }
/... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x28(%rdi), %rax
subq 0x20(%rdi), %rax
cmpq $0x1b, %rax
ja 0x81c4
leaq 0x18(%rbx), %r13
movq %r13, %rdi
callq 0x7c9c
cmpq $0x1b, %rax
ja 0x81c4
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x7b08
movq 0... | /erenon[P]binlog/include/binlog/SessionWriter.hpp |
binlog::Session::ConsumeResult binlog::Session::consume<std::ostream>(std::ostream&) | Session::ConsumeResult Session::consume(OutputStream& out)
{
// This lock:
// - Ensures only a single consumer is running at a time
// - Ensures safe read of _channels
// - Ensures safe read of Channel::writerProp (written by setChannelWriterName)
// - Ensures safe read of _sources
// - Ensures no new ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, %rdi
callq 0x2210
testl %eax, %eax
jne 0x884a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
cmpb $0x1, 0x8a(%rbx)
jne 0x8684
movq 0x40(%rbx), %rsi
movq 0... | /erenon[P]binlog/include/binlog/Session.hpp |
unsigned long binlog::serializeSizePrefixedTagged<binlog::WriterProp, binlog::detail::VectorOutputStream>(binlog::WriterProp const&, binlog::detail::VectorOutputStream&) | std::size_t serializeSizePrefixedTagged(const Entry& entry, OutputStream& out)
{
const std::uint64_t tag = Entry::Tag;
const std::uint32_t size = std::uint32_t(mserialize::serialized_size(entry) + sizeof(tag));
mserialize::serialize(size, out);
mserialize::serialize(tag, out);
mserialize::serialize(entry, out... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl 0x10(%rdi), %ebx
addl $0x1c, %ebx
leaq 0x8(%rsp), %rcx
movl %ebx, -0x4(%rcx)
movq 0x8(%rsi), %rsi
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
callq 0x62de
leaq 0x10(%rsp), %rcx
movq $-0x2, -0x8(%rcx)
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rd... | /erenon[P]binlog/include/binlog/Entries.hpp |
void mserialize::StructSerializer<binlog::WriterProp, std::integral_constant<unsigned long binlog::WriterProp::*, &binlog::WriterProp::id>, std::integral_constant<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> binlog::WriterProp::*, &binlog::WriterProp::name>, std::integral_constant<unsi... | static void serialize(const T& t, OutputStream& ostream)
{
using swallow = int[];
(void)swallow{1, (serialize_member(t, Members::value, ostream), int{})...};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x62de
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x89a2
movq 0x28(%r14), %rax
movq %rax, (%r15)... | /erenon[P]binlog/include/mserialize/StructSerializer.hpp |
glfwInputMouseClick | void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
{
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (action == GLFW_RELEASE && window->stickyMouseButtons)
windo... | cmpl $0x7, %esi
ja 0x17dd8
movl %ecx, %eax
andl $-0x31, %ecx
cmpl $0x0, 0x70(%rdi)
cmovnel %eax, %ecx
testl %edx, %edx
je 0x17dba
movl %edx, %eax
jmp 0x17dc2
movb $0x3, %al
cmpl $0x0, 0x6c(%rdi)
je 0x17db6
movl %esi, %r8d
movb %al, 0x78(%rdi,%r8)
movq 0x2f8(%rdi), %rax
testq %rax, %rax
je 0x17dd8
jmpq *%rax
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetJoystickName | GLFWAPI const char* glfwGetJoystickName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x18df7
cmpl $0x10, %edi
jae 0x18e16
leaq 0x39ad9(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x18dd8
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x400(%rax,%rcx)
je 0x18dea
leaq (%rax,%rcx), %r14
addq $0x400, %r14 # imm = 0x... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetJoystickGUID | GLFWAPI const char* glfwGetJoystickGUID(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x18ea7
cmpl $0x10, %edi
jae 0x18ec6
leaq 0x39a2b(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x18e88
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x400(%rax,%rcx)
je 0x18e9a
leaq (%rax,%rcx), %r14
addq $0x400, %r14 # imm = 0x... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x33abf(%rip), %rax # 0x52878
cmpl $0x0, 0x20558(%rax)
je 0x1ee3f
cmpl $0x0, 0x2057c(%rax)
jne 0x1ee3f
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x1feb8(%rax), %rdi
movq 0x1fec8(%rax), %rsi
movq %rax, %r13
callq *0x205d0(%rax)
movq %rax, %r15
mo... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwGetWindowPropertyX11 | unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetW... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rax
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x335ac(%rip), %rcx # 0x52878
movq 0x1feb8(%rcx), %rdi
leaq 0x8(%rsp), %r11
leaq 0x10(%rsp), %rbx
leaq 0x4(%rsp), %r14
leaq 0x18(%rsp), %r15
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFF... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformCreateWindow | int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
Visual* visual;
int depth;
if (ctxconfig->client != GLFW_NO_API)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
cmpl $0x0, (%rdx)
je 0x1f958
movl 0x4(%r15), %eax
cmpl $0x36003, %eax # imm = 0x36003
je 0x1f93b
cmpl $0x36002, %eax # imm = 0x36002
je 0x1f90b
cmpl $0x360... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformDestroyWindow | void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (_glfw.x11.disabledCursorWindow == window)
_glfw.x11.disabledCursorWindow = NULL;
if (window->monitor)
releaseMonitor(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
i... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3276e(%rip), %r14 # 0x52878
cmpq %rdi, 0x203e0(%r14)
jne 0x2011b
andq $0x0, 0x203e0(%r14)
cmpq $0x0, 0x40(%rbx)
je 0x2012a
movq %rbx, %rdi
callq 0x201d4
movq 0x348(%rbx), %rdi
testq %rdi, %rdi
je 0x20143
callq 0x135e0
andq $0x0, 0x348(%rbx)
movq 0x260(%rbx), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowIcon | void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
int count, const GLFWimage* images)
{
if (count)
{
int i, j, longCount = 0;
for (i = 0; i < count; i++)
longCount += 2 + images[i].width * images[i].height;
long* icon = calloc(longCount,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x2042d
movq %rdx, %r14
movl %esi, %r15d
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r15d
movq %r15, %rcx
shlq $0x4, %rcx
xorl %r13d, %r13d
cmpq %rax, %rcx
je 0x20364
movl 0x4(%r14,%rax), %edx
imull (%r14,%rax), %edx
addl %ed... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformGetWindowSize | void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x322a8(%rip), %rax # 0x52878
movq 0x1feb8(%rax), %rax
movq 0x340(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x13810
testq %r14, %r14
je 0x205f5
movl 0x8(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x20600
movl 0xc(%rsp), %eax
... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowSize | void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
{
if (window->monitor)
{
if (window->monitor->window == window)
acquireMonitor(window);
}
else
{
if (!window->resizable)
updateNormalHints(window, width, height);
XResizeWindo... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x2062b
cmpq %r14, 0x18(%rax)
jne 0x20660
movq %r14, %rdi
callq 0x20015
jmp 0x20660
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x0, 0x8(%r14)
jne 0x20642
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x20677
leaq 0x3222f(%rip)... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
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.