name string | code string | asm string | file string |
|---|---|---|---|
Catch::makeCommandLineParser() | inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
using namespace Clara;
CommandLine<ConfigData> cli;
cli.bindProcessName( &ConfigData::processName );
cli["-?"]["-h"]["--help"]
.describe( "display usage information" )
.bind( &ConfigData::showHelp ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x8, %edi
callq 0x2d3a0
leaq 0x2cdef(%rip), %rcx # 0x81698
movq %rcx, (%rax)
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0x28(%rbx), %rcx
movl $0x0, 0x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConfigData::~ConfigData() | ConfigData()
: listTests( false ),
listTags( false ),
listReporters( false ),
listTestNamesOnly( false ),
showSuccessfulTests( false ),
shouldDebugBreak( false ),
noThrow( false ),
showHelp( false ),
showInvisibles... | pushq %rbx
movq %rdi, %rbx
addq $0xa0, %rdi
callq 0x48df4
leaq 0x88(%rbx), %rdi
callq 0x48df4
movq 0x68(%rbx), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x55c9e
callq 0x2d360
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x55cb0
callq 0x2d360
movq 0x28(%rbx), %rdi
addq $0x38, %rbx
cmpq %rbx, %rdi
j... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::~CommandLine() | Arg() {} | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rsi
testq %rsi, %rsi
je 0x55d20
leaq 0x50(%rbx), %rdi
callq 0x57f40
movq $0x0, 0x50(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x5805c
leaq 0x8(%rbx), %rdi
callq 0x58034
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x55d49
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::bindProcessName<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::*) | void bindProcessName( M C::* field ) {
m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b97f(%rip), %r13 # 0x81700
movq %r13, (%rax)
movq %r15, 0x8(%rax)
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r12
movq %r13, (%rax)
movq %r15, 0x8(%rax)
movq (%r14), %rdi
test... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | OptBuilder operator[]( std::string const& optName ) {
m_options.push_back( Arg() );
addOptName( m_options.back(), optName );
OptBuilder builder( &m_options.back() );
return builder;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x8(%rsi), %rdi
xorl %eax, %eax
leaq 0x28(%rsp), %r13
movq %rax, -0x18(%r13)
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData>(bool Catch::ConfigData::*) | void bind( bool C::* field ) {
m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b839(%rip), %r13 # 0x81758
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r15), %r12
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq... | /dillonhuff[P]bsim/test/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 0x2d3a0
movq %rax, %r15
leaq 0x2b761(%rip), %rbx # 0x81700
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
mov... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(void (*)(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), std::__cxx11::basic_string<ch... | 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 0x2d3a0
movq %rax, %r15
leaq 0x2b77d(%rip), %rbx # 0x817b0
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
mov... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData>(void (*)(Catch::ConfigData&)) | void bind( void (* unaryFunction)( C& ) ) {
m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %rbx
leaq 0x2b73b(%rip), %r13 # 0x81808
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq (%r15), %r12
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r15
movq %r13, (%rax)
movq %r14, 0x8(%rax)
movq... | /dillonhuff[P]bsim/test/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 0x2d3a0
movq %rax, %r15
leaq 0x2b70b(%rip), %rbx # 0x81860
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
mov... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::addWarning(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void addWarning( ConfigData& config, std::string const& _warning ) {
if( _warning == "NoAssertions" )
config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
else
throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x13813(%rip), %rsi # 0x69a42
movq %r14, %rdi
callq 0x2d0f0
testl %eax, %eax
jne 0x5624a
orb $0x1, 0x18(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx... | /dillonhuff[P]bsim/test/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.reset( new Arg() );
ArgBuilder builder( m_floatingArg.get() );
return builder;
} | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x563ba
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x2d3a0
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)... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::CommandLine<Catch::ConfigData>::ArgBuilder::bind<Catch::ConfigData, bool>(void (*)(Catch::ConfigData&, bool), 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 0x2d3a0
movq %rax, %r15
leaq 0x2b483(%rip), %rbx # 0x818b8
movq %rbx, (%rax)
movq %r12, 0x8(%rax)
movq (%r14), %rbp
movl $0x10, %edi
callq 0x2d3a0
movq %rax, %r13
mov... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::setOrder(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void setOrder( ConfigData& config, std::string const& order ) {
if( startsWith( "declared", order ) )
config.runOrder = RunTests::InDeclarationOrder;
else if( startsWith( "lexical", order ) )
config.runOrder = RunTests::InLexicographicalOrder;
else if( startsWith( ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x132e9(%rip), %rsi # 0x69ab2
leaq 0x132ea(%rip), %rdx # 0x69aba
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x43f5c
movl %eax, %ebp
mo... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommonArgProperties<Catch::ConfigData>::CommonArgProperties(Catch::Clara::CommonArgProperties<Catch::ConfigData> const&) | CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x5749b
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x5749d
xorl %eax, %eax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r13
movq %r13, 0x8(%rbx)
movq 0x8(%r15), %rs... | /dillonhuff[P]bsim/test/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 0x5755e
callq 0x2d360
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x57570
callq 0x2d360
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x57582
callq 0x2d360
movq (%rbx), %rdi
testq %rdi, %rdi
je 0... | /dillonhuff[P]bsim/test/catch.hpp |
void Catch::Clara::Detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&) | void convertInto( std::string const& _source, T& _dest ) {
std::stringstream ss;
ss << _source;
ss >> _dest;
if( ss.fail() )
throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
callq 0x2d2a0
leaq 0x50(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2d420
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x2d210
movq 0x40(%rsp), %rax
movq -0x18(%rax)... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Session::applyCommandLine(int, char const* const*, Catch::Session::OnUnusedOptions::DoWhat) | int applyCommandLine( int argc, char const* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
try {
m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
m_unusedTokens = m_cli.parseInto( argc, argv, m_conf... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %rax
movl %esi, %edx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpl $0x1, %ecx
sete 0x64(%rdi)
leaq 0x80(%rdi), %r8
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x584e8
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Session::run() | int run() {
if( m_configData.showHelp )
return 0;
try
{
config(); // Force config to be constructed
seedRng( *m_config );
if( m_configData.filenamesAsTags )
applyFilenamesAsTags( *m_config );
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorl %eax, %eax
cmpb $0x0, 0x87(%rdi)
jne 0x58472
movq %rdi, %r14
callq 0x5b0fe
movq 0x138(%r14), %rdi
callq 0x45552
leaq 0x138(%r14), %rbx
cmpb $0x1, 0x8a(%r14)
jne 0x58397
movq (%rbx), %rdi
callq 0x4257f
movq %r14, %rdi
callq 0x5b0fe
movq %rax, %r14
movq $0x0, (%rsp)
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const* const*, Catch::ConfigData&) const | std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
std::string processName = argv[0];
std::size_t lastSlash = processName.find_last_of( "/\\" );
if( lastSlash != std::string::npos )
processName = processName.substr( la... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0x2d160
leaq 0x1161b(%rip), %rsi # 0x69b39
movl $0x2, %ecx
movq %r13, %rdi
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Session::showHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void showHelp( std::string const& processName ) {
Catch::cout() << "\nCatch v" << libraryVersion << "\n";
m_cli.usage( Catch::cout(), processName );
Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2995c(%rip), %rbx # 0x81fc0
leaq 0x1154f(%rip), %rsi # 0x69bba
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2d420
leaq 0x29e11(%rip), %rsi # 0x82490
movq %rbx, %rdi
callq 0x446e7
leaq 0x11b11(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r... | /dillonhuff[P]bsim/test/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 0x58740
movq %rsi, %r14
leaq 0x11a8f(%rip), %r15 # 0x6a19f
cmpq 0x40(%r14), %r12
je 0x58726
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d420
movq (%r12), %rsi
movq 0x8(%... | /dillonhuff[P]bsim/test/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... | /dillonhuff[P]bsim/test/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 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x58c7f
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/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 0x59d3b
movq %rdx, %r15
movq %rsi, %r12
leaq 0x28(%rsi), %rbp
movl $0x1, %ebx
xorl %r14d, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::populateFloatingArgs(std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>> const&, Catch::ConfigData&) const | std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
if( !m_floatingArg.get() )
return tokens;
std::vector<Parser::Token> unusedTokens;
for( std::size_t i = 0; i < tokens.size(); ++i ) {
P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x59df8
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x59e03
xorl %r13d, %r13d
movabsq $-0x33... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::Arg::commands[abi:cxx11]() const | std::string commands() const {
std::ostringstream oss;
bool first = true;
std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
for(; it != itEnd; ++it ) {
if( first )
first ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0x2d4b0
movq 0x68(%r12), %rbx
movq 0x70(%r12), %r14
cmpq %r14, %rbx
je 0x59f4c
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movb $0x1, %bpl
leaq 0x104d2(%rip... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Tbc::Text::spliceLine(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long) | void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
_remainder = _remainder.substr( _pos );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x40(%rsp), %rdi
movl $0x20, %edx
callq 0x2d440
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2d3e0
movq 0x40(%rsp), %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::argSynopsis(std::ostream&) const | void argSynopsis( std::ostream& os ) const {
for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
if( i > 1 )
os << " ";
typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
if( it != m_positionalArgs.end() )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x58(%rdi)
jle 0x5a596
leaq 0x28(%r14), %r12
movl $0x1, %r15d
leaq 0xef56(%rip), %r13 # 0x69410
cmpl $0x2, %r15d
jb 0x5a4d4
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xec22(%rip), %rsi # 0x690f1
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Clara::CommandLine<Catch::ConfigData>::optUsage(std::ostream&, unsigned long, unsigned long) const | void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
std::size_t maxWidth = 0;
for( it = itBegin; it != itEnd; ++it )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0x28(%rsp)
movq %rdx, 0x40(%rsp)
movq %rsi, %r15
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %r14
movq %r14, 0x30(%rsp)
je 0x5a6dd
leaq 0xe0(%rsp), %r13
xorl %r12d, %r1... | /dillonhuff[P]bsim/test/catch.hpp |
Tbc::Text::Text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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... | /dillonhuff[P]bsim/test/catch.hpp |
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 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x5af47
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Tbc::Text::spliceLine(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long) | void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
_remainder = _remainder.substr( _pos );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x40(%rsp), %rdi
movl $0x20, %edx
callq 0x2d440
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2d3e0
movq 0x40(%rsp), %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Config::Config(Catch::ConfigData const&) | Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
if( !data.testsOrTags.empty() ) {
TestSpecParser parser( ITagAliasRegistry::get() );
for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
pars... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
leaq 0x250f9(%rip), %rax # 0x80278
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x5b38e
movq %r14, %rdi
callq 0x5b4b2
movq %rax, 0xc8(%r14)
xorps %xmm0, %xmm0
movu... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Ptr<Catch::Config>::operator=(Catch::Config*) | Ptr& operator = ( T* p ){
Ptr temp( p );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5b36a
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5b37b
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
ca... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConfigData::ConfigData(Catch::ConfigData const&) | ConfigData()
: listTests( false ),
listTags( false ),
listReporters( false ),
listTestNamesOnly( false ),
showSuccessfulTests( false ),
shouldDebugBreak( false ),
noThrow( false ),
showHelp( false ),
showInvisibles... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x28, %rdi
leaq 0x38(%r12), %rax
movq %rax, 0x8(%rsp)
movq %rax... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::listTests(Catch::Config const&) | inline std::size_t listTests( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( config.testSpec().hasFilters() )
Catch::cout() << "Matching test cases:\n";
else {
Catch::cout() << "All available test cases:\n";
testSpec = TestSpecParser( ITa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %r13
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x50a00
movq (%r13), %rax
movq %r13, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5b636
movq ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::listTestsNamesOnly(Catch::Config const&) | inline std::size_t listTestsNamesOnly( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( !config.testSpec().hasFilters() )
testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
std::size_t matchedTests = 0;
std::vector<TestCase> matc... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x50a00
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x5bd52
callq 0x48044
leaq 0x68(%rsp), %r12
movq %r12, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::listTags(Catch::Config const&) | inline std::size_t listTags( Config const& config ) {
TestSpec testSpec = config.testSpec();
if( config.testSpec().hasFilters() )
Catch::cout() << "Tags for matching test cases:\n";
else {
Catch::cout() << "All available tags:\n";
testSpec = TestSpecParser( IT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0xa0(%rsp), %rdi
movq %rax, %rsi
callq 0x50a00
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x5bea7
movq ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::listReporters(Catch::Config const&) | virtual void invoke() const {
C obj;
(obj.*m_method)();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x25881(%rip), %rdi # 0x81fc0
leaq 0xd5f0(%rip), %rsi # 0x69d36
movl $0x15, %edx
callq 0x2d420
callq 0x41b5a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq 0x18(... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TagInfo::all[abi:cxx11]() const | std::string all() const {
std::string out;
for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
it != itEnd;
++it )
out += "[" + *it + "]";
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x5caf4
leaq 0x10(%rsp), %r12
leaq 0x28(%rs... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::TestCaseTracking::TrackerBase::TrackerHasName::operator()(Catch::Ptr<Catch::TestCaseTracking::ITracker> const&) | bool operator ()( Ptr<ITracker> const& tracker ) {
return tracker->name() == m_name;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x20(%rax)
movq 0x8(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5d3c8
testq %rdx, %rdx
je 0x5d3cc
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %bl
jmp 0x5d3ce
x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Option<Catch::TestRunInfo>::operator=(Catch::TestRunInfo const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5e0c8
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x5e0c8
callq 0x2d360
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r15
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Option<Catch::GroupInfo>::operator=(Catch::GroupInfo const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x5e11e
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x5e11e
callq 0x2d360
movq $0x0, (%rbx)
leaq 0x8(%rbx), %r15
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Ptr<Catch::CumulativeReporterBase::SectionNode>::operator=(Catch::CumulativeReporterBase::SectionNode*) | Ptr& operator = ( T* p ){
Ptr temp( p );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5e56c
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5e57d
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
ca... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Ptr<Catch::CumulativeReporterBase::SectionNode>::operator=(Catch::Ptr<Catch::CumulativeReporterBase::SectionNode> const&) | Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x5e5a8
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x5e5b9
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionStats const&) | SectionStats( SectionStats const& ) = default; | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x21522(%rip), %rax # 0x7fb38
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
l... | /dillonhuff[P]bsim/test/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 0x20b98(%rip), %rax # 0x7fb58
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x4420a
movups 0x118(%r15), %xmm0
movups 0x128(%r15), %xmm1
movups 0x138(%r15), %xmm2
movups %xmm2, 0x138(%r14)
movup... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::CumulativeReporterBase::Node<Catch::TestGroupStats, Catch::CumulativeReporterBase::Node<Catch::TestCaseStats, Catch::CumulativeReporterBase::SectionNode>>::~Node() | virtual ~Node() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x22683(%rip), %rax # 0x819f0
movq %rax, (%rdi)
addq $0x80, %rdi
callq 0x4a94e
leaq 0x207f5(%rip), %rax # 0x7fb78
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x5f39a
popq %rbx
jmp 0x2d360
popq %rbx
retq
| /dillonhuff[P]bsim/test/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 0x2240b(%rip), %rax # 0x81a38
movq %rax, (%rdi)
addq $0x70, %rdi
callq 0x4a926
leaq 0x20558(%rip), %rax # 0x7fb98
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x5f657
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | XmlWriter& startElement( std::string const& name ) {
ensureTagClosed();
newlineIfNecessary();
stream() << m_indent << "<" << name;
m_tags.push_back( name );
m_indent += " ";
m_tagIsOpen = true;
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x5f8d9
movq 0x40(%rbx), %rdi
leaq 0x9c3c(%rip), %rsi # 0x69508
movl $0x2, %edx
callq 0x2d420
movb $0x0, (%rbx)
cmpb $0x1, 0x1(%rbx)
jne 0x5f8f8
movq 0x40(%rbx), %rdi
leaq 0xa8b5(%rip), %rsi # 0x6a19f
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlWriter::writeAttribute(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&) | XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
if( !name.empty() && !attribute.empty() )
stream() << " " << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << "\"";
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5fa1c
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x5fa1c
movq %rsi, %r15
movq 0x40(%rbx), %r12
leaq 0x975c(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r12, %rdi
callq 0x2d420
movq (%r15), %rsi
movq 0x8(%r15), %rdx
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlEncode::encodeTo(std::ostream&) const | void encodeTo( std::ostream& os ) const {
// Apostrophe escaping not necessary if we always use " to write attributes
// (see: http://www.w3.org/TR/xml/#syntax)
for( std::size_t i = 0; i < m_str.size(); ++ i ) {
char c = m_str[i];
switch( c ) {
... | cmpq $0x0, 0x8(%rdi)
je 0x5fbb3
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0xa534(%rip), %r13 # 0x69f9e
leaq 0xa528(%rip), %r12 # 0x69f99
movq (%r14), %rcx
movb (%rcx,%r15), %al
movzbl %al, %edx
cmpl $0x3b, %edx
jg 0x5fa9... | /dillonhuff[P]bsim/test/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 0x950b(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %r15, %rdi
callq 0x2d420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
movq %rax, %r14
leaq 0xa38a(%rip), %rsi ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq (%r15), %rsi
movq %r12, %rdi
callq 0x2d270
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
m... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | XmlWriter& writeText( std::string const& text, bool indent = true ) {
if( !text.empty() ){
bool tagWasOpen = m_tagIsOpen;
ensureTagClosed();
if( tagWasOpen && indent )
stream() << m_indent;
stream() << XmlEncode( text );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x5fdd7
movl %edx, %ebp
movq %rsi, %r14
movb (%rbx), %r15b
cmpb $0x1, %r15b
jne 0x5fd72
movq 0x40(%rbx), %rdi
leaq 0x97a3(%rip), %rsi # 0x69508
movl $0x2, %edx
callq 0x2d420
movb $0x0, (%rbx)
andb %bpl, ... | /dillonhuff[P]bsim/test/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 0xa177(%rip), %rsi # 0x6a07b
leaq 0xa179(%rip), %rdx # 0x6a084
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0xc8(%rbx), %r14
movq %r14, 0... | /dillonhuff[P]bsim/test/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 ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movl (%r15), %esi
movq %r12, %rdi
callq 0x2d270
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movq %rsp, %rdx
movq %r14, %rdi
m... | /dillonhuff[P]bsim/test/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 ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq %r15, %rdi
callq 0x2d180
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
cal... | /dillonhuff[P]bsim/test/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 0x45105
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x6084c
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r1... | /dillonhuff[P]bsim/test/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 ) {
std::ostringstream oss;
oss << attribute;
return writeAttribute( name, oss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x2d4b0
movq %r15, %rdi
callq 0x2d180
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2d420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
cal... | /dillonhuff[P]bsim/test/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 $0x1c8, %rsp # imm = 0x1C8
movl 0xb8(%rsi), %eax
testb $0x10, %al
je 0x610fc
movq %rsi, %r14
movl 0x70(%rsi), %ecx
andl $0x8, %ecx
jne 0x610fc
movq %rdi, %rbx
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::lazyPrint() | void lazyPrint() {
if( !currentTestRunInfo.used )
lazyPrintRunInfo();
if( !currentGroupInfo.used )
lazyPrintGroupInfo();
if( !m_headerPrinted ) {
printTestCaseAndSectionHeader();
m_headerPrinted = true;
}
... | pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x48(%rdi)
jne 0x611d2
movq %rbx, %rdi
callq 0x6170c
cmpb $0x0, 0x88(%rbx)
jne 0x611e3
movq %rbx, %rdi
callq 0x6188c
cmpb $0x0, 0x1c9(%rbx)
jne 0x611fb
movq %rbx, %rdi
callq 0x61908
movb $0x1, 0x1c9(%rbx)
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::AssertionPrinter(std::ostream&, Catch::AssertionStats const&, bool) | AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
: stream( _stream ),
stats( _stats ),
result( _stats.assertionResult ),
colour( Colour::None ),
message( result.getMessage() ),
m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rdx, %rbp
movq %rdi, %r12
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x8(%rdx), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x18(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rs... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::print() const | void print() const {
printSourceInfo();
if( stats.totals.assertions.total() > 0 ) {
if( result.isOk() )
stream << "\n";
printResultType();
printOriginalExpression();
printReconstructed... | pushq %rbx
movq %rdi, %rbx
callq 0x61de6
movq 0x8(%rbx), %rax
movq 0xe0(%rax), %rcx
addq 0xd8(%rax), %rcx
addq 0xe8(%rax), %rcx
jne 0x61678
movq (%rbx), %rdi
leaq 0x8b33(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
jmp 0x616b9
movq 0x10(%rbx), %rax
testb $0x10, 0xb0(%rax)
je 0x6168d
movl 0x68(%rax), %eax
an... | /dillonhuff[P]bsim/test/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 0x4a870
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x616e4
callq 0x2d360
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x616f6
callq 0x2d360
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x61709
popq %rbx
jmp 0x2d360
popq... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::lazyPrintRunInfo() | void lazyPrintRunInfo() {
stream << "\n" << getLineOfChars<'~'>() << "\n";
Colour colour( Colour::SecondaryText );
stream << currentTestRunInfo->name
<< " is a Catch v" << libraryVersion << " host application.\n"
<< "Run with -? for options\... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8a7c(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
cmpb $0x0, 0x20e19(%rip) # 0x82550
jne 0x6176a
movaps 0x7050(%rip), %xmm0 # 0x68790
movups %xmm0, 0x20e48(%rip) # 0x8258f
movaps %xmm0, ... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::lazyPrintGroupInfo() | T* operator->() { return nullableValue; } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x50(%rdi), %rdx
cmpq $0x0, 0x8(%rdx)
je 0x618e1
cmpq $0x2, 0x28(%rdx)
jb 0x618e1
movq %rdi, %rbx
leaq 0x8909(%rip), %rsi # 0x6a1b8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x49917
movq %rbx, %rdi
movq %r14, %rsi
callq 0x61b9a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printTestCaseAndSectionHeader() | Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x1b0(%rdi), %rax
cmpq 0x1b8(%rdi), %rax
je 0x61b36
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
callq 0x61c1c
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rcx
cmpq $0x2,... | /dillonhuff[P]bsim/test/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 0x61c1c
movq 0x18(%rbx), %rbx
cmpb $0x0, 0x20a3f(%rip) # 0x825f0
jne 0x61be4
movaps 0x6bf6(%rip), %xmm0 # 0x687b0
movups %xmm0, 0x20a6e(%rip) # 0x8262f
movaps %xmm0, 0x20a58(%rip) # 0x82620
movaps %xmm0, 0x20a41(%rip) # 0x82610
movaps %xmm0, 0x20a2... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printOpenHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void printOpenHeader( std::string const& _name ) {
stream << getLineOfChars<'-'>() << "\n";
{
Colour colourGuard( Colour::Headers );
printHeaderString( _name );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
cmpb $0x0, 0x2096b(%rip) # 0x825a0
jne 0x61c68
movaps 0x6b62(%rip), %xmm0 # 0x687a0
movups %xmm0, 0x2099a(%rip) # 0x825df
movaps %xmm0, 0x20984(%rip) # 0x825d0
movaps %xmm0, 0x2096d(%rip) # 0x82... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
std::size_t i = _string.find( ": " );
if( i != std::string::npos )
i+=2;
else
i = 0;
stream << Text( _string, TextAttributes()
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7dab(%rip), %rsi # 0x69aac
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2d660
leaq 0x2(%rax), %rcx
cmpq $-0x1, %rax
cmoveq %r12, %rcx
movq 0x18(%rbx), %rbx
leaq 0x58(%rsp... | /dillonhuff[P]bsim/test/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 0x61f93
movq %rdi, %rbx
movb $0x0, 0x7(%rsp)
movl $0x5, %edi
callq 0x437d0
movq (%rbx), %rdi
leaq 0x7cfc(%rip), %rsi # 0x69c34
movl $0x2, %edx
callq 0x2d420
movq (%rbx), %r14
movq 0x10(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x43c... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::printReconstructedExpression() const | void printReconstructedExpression() const {
if( result.hasExpandedExpression() ) {
stream << "with expansion:\n";
Colour colourGuard( Colour::ReconstructedExpression );
stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0x43e00
testb %al, %al
je 0x62101
movq (%r14), %rdi
leaq 0x82f1(%rip), %rsi # 0x6a2f1
movl $0x10, %edx
callq 0x2d420
movb $0x0, 0x7(%rsp)
movl $0x6, %edi
callq 0x437d0
movq (%r14), %rbx
movq 0x10(%r1... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::AssertionPrinter::printMessage() const | void printMessage() const {
if( !messageLabel.empty() )
stream << messageLabel << ":" << "\n";
for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
it != itEnd;
++it ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rdx
testq %rdx, %rdx
je 0x621a8
movq (%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x2d420
movq %rax, %r14
leaq 0x728e(%rip), %rsi # 0x69415
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x8004(%rip... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printSummaryDivider() | void printSummaryDivider() {
stream << getLineOfChars<'-'>() << "\n";
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rbx
cmpb $0x0, 0x202d9(%rip) # 0x825a0
jne 0x622fa
movaps 0x64d0(%rip), %xmm0 # 0x687a0
movups %xmm0, 0x20308(%rip) # 0x825df
movaps %xmm0, 0x202f2(%rip) # 0x825d0
movaps %xmm0, 0x202db(%rip) # 0x825c0
movaps %xmm0, 0x202c4(%rip) # 0x825b0
movaps %x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printTotals(Catch::Totals const&) | void printTotals( Totals const& totals ) {
if( totals.testCases.total() == 0 ) {
stream << Colour( Colour::Warning ) << "No tests ran\n";
}
else if( totals.assertions.total() > 0 && totals.assertions.allPassed() ) {
stream << Colour( Colour::ResultSucc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x20(%rsi), %rax
addq 0x18(%rsi), %rax
addq 0x28(%rsi), %rax
jne 0x62387
movq 0x18(%rbx), %rbx
movb $0x0, 0x20(%rsp)
movl $0x6, %edi
callq 0x437d0
leaq 0x8002(%rip), %rsi # 0x6a370
movl $0xd, %edx
movq %rbx, %rd... | /dillonhuff[P]bsim/test/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 0x2d4b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2d270
movq %rbx, 0x28(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::SummaryColumn::~SummaryColumn() | SummaryColumn( std::string const& _label, Colour::Code _colour )
: label( _label ),
colour( _colour )
{} | pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x48df4
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x62cd5
popq %rbx
jmp 0x2d360
popq %rbx
retq
nop
| /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printSummaryRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::ConsoleReporter::SummaryColumn, std::allocator<Catch::ConsoleReporter::SummaryColumn>> const&, unsigned long) | void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
std::string value = it->rows[row];
if( it->label.empty() ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %r15
movq (%rdx), %r12
cmpq 0x8(%rdx), %r12
je 0x62e74
movq %rcx, %rbx
movq %rdx, %r14
shlq $0x5, %rbx
leaq 0x10(%rsp), %r13
movq 0x28(%r12), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax,%r... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ConsoleReporter::printTotalsDivider(Catch::Totals const&) | void printTotalsDivider( Totals const& totals ) {
if( totals.testCases.total() > 0 ) {
std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbp
movq 0x18(%rsi), %r9
movq 0x20(%rsi), %r10
addq %r9, %r10
addq 0x28(%rsi), %r10
je 0x6325c
movq %rsi, %r14
movq 0x20(%rsi), %r8
movq 0x28(%rsi), %r11
movq %r8, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rcx
movq %rcx, %rax... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::CompactReporter::AssertionPrinter::print() | void print() {
printSourceInfo();
itMessage = messages.begin();
switch( result.getResultType() ) {
case ResultWas::Ok:
printResultType( Colour::ResultSuccess, passedString() );
printOriginalExpression()... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
callq 0x63be4
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
movq %rax, 0x30(%rbx)
movl 0xb0(%rcx), %eax
cmpl $0x11, %eax
jg 0x635b3
leal 0x1(%rax), %edx
cmpl $0x3, %edx
ja 0x6367f
leaq 0x59ea(%rip), %rax # 0x68f24
movslq (%ra... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistrar<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 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x746e656d75636f64, %rdx # imm = 0x746E656D75636F64
movq %rdx, 0x1f(%rax)
movups 0x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterFactory::getDescription[abi:cxx11]() const | virtual std::string getDescription() const {
return T::getDescription();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq $0x4e, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, %r15
movq %rax, (%rbx)
movq (%r14), %r14
movq %r14, 0x10(%rbx)
leaq 0x4878(%rip), %rsi # 0x6a4db
movl $0x4e, %ed... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::JunitReporter::JunitReporter(Catch::ReporterConfig const&) | JunitReporter( ReporterConfig const& _config )
: CumulativeReporterBase( _config ),
xml( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = true;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
leaq 0x19f49(%rip), %rax # 0x7fbe8
movq %rax, (%rdi)
movq 0x8(%rsi), %rdi
movq %rdi, 0x10(%rbx)
testq %rdi, %rdi
je 0x65cb5
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rax
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
xorl %r1... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::ReporterRegistrar<Catch::ConsoleReporter>::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 $0x2b, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movups 0x4736(%rip), %xmm0 # 0x6a545
movups %xmm0, 0x1b(%rax)
movups 0x4720(%rip), %xmm0... | /dillonhuff[P]bsim/test/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 0x2d6a0
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x7345444920726f66, %rdx # imm = 0x7345444920726F66
movq %rdx, 0x30(%rax)
movups 0x... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::StdString::Contains, 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 $0x38, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x1a014(%rip), %rax # 0x7ffa8
movq %rax, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%r15), %rs... | /dillonhuff[P]bsim/test/catch.hpp |
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::StdString::EndsWith, 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 $0x38, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x19fb8(%rip), %rax # 0x80038
movq %rax, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x28(%r14), %rax
movq %rax, 0x18(%r14)
movq 0x18(%r15), %rs... | /dillonhuff[P]bsim/test/catch.hpp |
run_tests | static void test_encode(void) {
nonce_override(nonce);
uint8_t key[paseto_v2_LOCAL_KEYBYTES];
assert(paseto_v2_local_load_key_base64(key, "gHgVofOGvySsqUnTsAJusgGCJbWFiiqYN1pWzuQGjxw") == true);
const uint8_t message[] = "test";
char *enc = paseto_v2_local_encrypt(message, 4, key, NULL, 0);
if (... | pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0x4ae3(%rip), %rdi # 0x6160
callq 0x15b1
leaq 0x1b40(%rip), %rsi # 0x31c9
leaq 0x40(%rsp), %rdi
callq 0x11d0
testb %al, %al
je 0x1a10
leaq 0x20(%rsp), %rdi
movb $0x0, 0x4(%rdi)
movl $0x74736574, (%rdi) # imm = 0x74736574
leaq 0x40(%rsp), %rdx
movl $0x4, %esi
xor... | /authenticvision[P]libpaseto/test/test.c |
GLOBAL__sub_I_BasicBlock.cpp | BasicBlock::const_iterator BasicBlock::getFirstInsertionPt() const {
const Instruction *FirstNonPHI = getFirstNonPHI();
if (!FirstNonPHI)
return end();
const_iterator InsertPt = FirstNonPHI->getIterator();
if (InsertPt->isEHPad()) ++InsertPt;
// Set the head-inclusive bit to indicate that this iterator i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x345401(%rip), %rax # 0x399b26
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq $0x8c, 0x8(%r14)
movb $0x1, %al
leaq 0xc(%rsp), %r13
movb %al, (%r13)
leaq 0x10(%rsp), %r15
movq %r13, (%r15)
leaq 0x4dbc19(%rip), %r12 # 0x530368
le... | /IR/BasicBlock.cpp |
llvm::DenseMapBase<llvm::DenseMap<void const*, clang::ento::CheckerBase*, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, clang::ento::CheckerBase*>>, void const*, clang::ento::CheckerBase*, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, clang::ento::Checke... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5628a
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x56280
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x5631c
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0... | /llvm/ADT/DenseMap.h |
clang::ento::CheckerContext::generateSink(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::ExplodedNode*, clang::ProgramPointTag const*) | ExplodedNode *generateSink(ProgramStateRef State, ExplodedNode *Pred,
const ProgramPointTag *Tag = nullptr) {
return addTransitionImpl(State ? State : getState(), true, Pred, Tag);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq $0x38, %rax
cmpq $0x0, (%rsi)
cmovneq %rsi, %rax
movq %rdx, %r15
movq (%rax), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x56b0a
callq 0x2784c7
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx... | /clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h |
llvm::raw_ostream::copy_to_buffer(char const*, unsigned long) | void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
// Handle short strings specially, memcpy isn't very good at very short
// strings.
switch (Size) {
case 4: OutBufCur[3] = Ptr[3]; [[fallthrough]];
case 3: OutBufCur[2] = Ptr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpq $0x4, %rdx
ja 0x583c8
leaq 0x2c9fef(%rip), %rax # 0x32237c
movslq (%rax,%rbx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb 0x3(%rsi), %al
movq 0x20(%r14), %rcx
movb %al, 0x3(%rcx)
movb 0x2(%rsi), %al
movq 0x20(%r14), %rcx
movb %al, 0x2(%rcx)
movb 0x1(%... | /Support/raw_ostream.cpp |
llvm::raw_fd_ostream::write_impl(char const*, unsigned long) | void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
if (TiedStream)
TiedStream->flush();
assert(FD >= 0 && "File already closed.");
pos += Size;
#if defined(_WIN32)
// If this is a Windows console device, try re-encoding from UTF-8 to UTF-16
// and using WriteConsoleW. If that fails, fall ba... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x5899f
movq 0x10(%rdi), %rsi
movq 0x20(%rdi), %rdx
subq %rsi, %rdx
je 0x5899f
movq %rsi, 0x20(%rdi)
movq (%rdi), %rax
callq *0x48(%rax)
addq %rbx, 0x58(%r15)
movl $0x40000000... | /Support/raw_ostream.cpp |
llvm::raw_fd_ostream::preferred_buffer_size() const | size_t raw_fd_ostream::preferred_buffer_size() const {
#if defined(_WIN32)
// Disable buffering for console devices. Console output is re-encoded from
// UTF-8 to UTF-16 on Windows, and buffering it would require us to split the
// buffer on a valid UTF-8 codepoint boundary. Terminal buffering is disabled
// be... | pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %edi
movq %rsp, %rsi
callq 0x3c280
testl %eax, %eax
je 0x58ad4
xorl %eax, %eax
jmp 0x58af6
movl $0xf000, %eax # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x2000, %eax # imm = 0x2000
jne 0x58af1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(... | /Support/raw_ostream.cpp |
llvm::hashing::detail::hash_state::mix(char const*) | void mix(const char *s) {
h0 = llvm::rotr<uint64_t>(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
h1 = llvm::rotr<uint64_t>(h1 + h4 + fetch64(s + 48), 42) * k1;
h0 ^= h6;
h1 += h3 + fetch64(s + 40);
h2 = llvm::rotr<uint64_t>(h2 + h5, 33) * k1;
h3 = h4 * k1;
h4 = h0 + h5;
mix_32_bytes(s, h3, h... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x18(%rbx), %r8
movq (%rbx), %rax
addq %rdi, %rax
leaq 0x18(%rbx), %rsi
addq %r8, %rax
addq 0x8(%r14), %rax
rolq $0x1b, %rax
movabsq $-0x4b6d499041670d8d, %rcx # imm = 0xB492B66FBE98F273
imulq %rcx, %rax
mov... | /llvm/ADT/Hashing.h |
llvm::cl::basic_parser_impl::getOptionWidth(llvm::cl::Option const&) const | size_t basic_parser_impl::getOptionWidth(const Option &O) const {
size_t Len = argPlusPrefixesSize(O.ArgStr);
auto ValName = getValueName();
if (!ValName.empty()) {
size_t FormattingLen = 3;
if (O.getMiscFlags() & PositionalEatsArgs)
FormattingLen = 6;
Len += getValueStr(O, ValName).size() + For... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x18(%rsi), %rax
leaq 0x7(%rax), %rcx
cmpq $0x1, %rax
movl $0x7, %ebx
cmovneq %rcx, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testq %rdx, %rdx
je 0x5c7eb
movb 0xb(%r14), %al
andb $0x4, %al
shrb $0x2, %al
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
addq %rbx, %rax
movq ... | /Support/CommandLine.cpp |
llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
addq $0xd0, %rdi
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x5c5f6
movl %eax, %ebp
testb %al, %al
jne 0x5cd27
leaq 0x80(%r... | /llvm/Support/CommandLine.h |
llvm::cl::parser<unsigned long>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, unsigned long&) | bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg,
unsigned long &Value) {
if (Arg.getAsInteger(0, Value))
return O.error("'" + Arg + "' value invalid for ulong argument!");
return false;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rsi, %r14
leaq 0x8(%rsp), %rcx
movq %r8, %rdi
movq %r9, %rsi
xorl %edx, %edx
callq 0x65d05
movl %eax, %ebx
testb %al, %al
je 0x5dbb0
leaq 0x30(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0x2c533f(%rip), %rcx... | /Support/CommandLine.cpp |
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.