name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
Catch::TestCaseInfo::TestCaseInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<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&, Catch::SourceLineInfo const&)
|
TestCaseInfo::TestCaseInfo( std::string const& _name,
std::string const& _className,
std::string const& _description,
std::set<std::string> const& _tags,
SourceLineInfo const& _lineInfo )
: name( _name ),
className( _className ),
description( _description ),
lineInfo( _lineInfo ),
properties( None )
{
setTags( *this, _tags );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
leaq 0x20(%rbx), %r14
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
movq %r14, 0x10(%rsp)
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, (%rsp)
movq %rax, 0x40(%rbx)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %rdi, 0x8(%rsp)
callq 0x4042a
leaq 0x68(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x68(%rbx)
movq %rcx, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
leaq 0x98(%rbx), %rax
movl %ecx, 0x98(%rbx)
movq %rcx, 0xa0(%rbx)
movq %rax, 0xa8(%rbx)
movq %rax, 0xb0(%rbx)
movq %rcx, 0xb8(%rbx)
leaq 0xd0(%rbx), %r14
movq %r14, 0xc0(%rbx)
movq %rcx, 0xc8(%rbx)
movb $0x0, 0xd0(%rbx)
leaq 0xe0(%rbx), %rbp
leaq 0xf0(%rbx), %r15
movq %r15, 0xe0(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x4042a
movq 0x20(%r13), %rax
movq %rax, 0x100(%rbx)
movl $0x0, 0x108(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x427ac
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%rbp), %rdi
cmpq %r15, %rdi
je 0x44195
callq 0x2d360
jmp 0x44195
movq %rax, %r12
leaq 0x60(%rbx), %r13
leaq 0x90(%rbx), %rbp
movq 0xc0(%rbx), %rdi
cmpq %r14, %rdi
je 0x441b1
callq 0x2d360
movq %rbp, %rdi
callq 0x5242a
movq %r13, %rdi
callq 0x5242a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x441d9
callq 0x2d360
jmp 0x441d9
movq %rax, %r12
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x441f2
callq 0x2d360
jmp 0x441f2
movq %rax, %r12
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x44201
callq 0x2d360
movq %r12, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseInfo::TestCaseInfo(Catch::TestCaseInfo const&)
|
TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
: name( other.name ),
className( other.className ),
description( other.description ),
tags( other.tags ),
lcaseTags( other.lcaseTags ),
tagsAsString( other.tagsAsString ),
lineInfo( other.lineInfo ),
properties( other.properties )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
movq %r14, 0x20(%rsp)
callq 0x4042a
movq %r13, 0x10(%rsp)
leaq 0x40(%rbx), %r13
leaq 0x50(%rbx), %rbp
movq %rbp, 0x40(%rbx)
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
movq %r15, 0x18(%rsp)
callq 0x4042a
movq %rbp, (%rsp)
movq %r13, 0x8(%rsp)
leaq 0x60(%rbx), %r13
leaq 0x60(%r12), %rsi
movq %r13, %rdi
callq 0x521d4
movl $0x90, %esi
leaq (%rbx,%rsi), %rbp
addq %r12, %rsi
movq %rbp, %rdi
callq 0x521d4
leaq 0xc0(%rbx), %r14
leaq 0xd0(%rbx), %r15
movq %r15, 0xc0(%rbx)
movq 0xc0(%r12), %rsi
movq 0xc8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
leaq 0xe0(%rbx), %rdi
leaq 0xf0(%rbx), %rax
movq %rax, 0xe0(%rbx)
movq 0xe0(%r12), %rsi
movq 0xe8(%r12), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x100(%r12), %rax
movq %rax, 0x100(%rbx)
movl 0x108(%r12), %eax
movl %eax, 0x108(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x44352
callq 0x2d360
jmp 0x44352
movq %rax, %r12
movq %rbp, %rdi
callq 0x5242a
jmp 0x4435f
movq %rax, %r12
movq %r13, %rdi
callq 0x5242a
jmp 0x4436c
movq %rax, %r12
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x44384
callq 0x2d360
jmp 0x44384
movq %rax, %r12
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4439d
callq 0x2d360
jmp 0x4439d
movq %rax, %r12
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x443ac
callq 0x2d360
movq %r12, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCase::swap(Catch::TestCase&)
|
void TestCase::swap( TestCase& other ) {
test.swap( other.test );
name.swap( other.name );
className.swap( other.className );
description.swap( other.description );
tags.swap( other.tags );
lcaseTags.swap( other.lcaseTags );
tagsAsString.swap( other.tagsAsString );
std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
std::swap( lineInfo, other.lineInfo );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x110(%rdi), %rax
movq 0x110(%rsi), %rcx
movq %rcx, 0x110(%rdi)
movq %rax, 0x110(%rsi)
callq 0x2d2c0
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0x2d2c0
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0x2d2c0
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0x65508
movl $0x90, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x65508
movl $0xc0, %esi
leaq (%r14,%rsi), %rdi
addq %rbx, %rsi
callq 0x2d2c0
movl 0x108(%r14), %eax
movl 0x108(%rbx), %ecx
movl %ecx, 0x108(%r14)
movl %eax, 0x108(%rbx)
movl $0xe0, %r15d
leaq (%r14,%r15), %rdi
addq %rbx, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0xe0(%r14), %rcx
leaq 0xf0(%r14), %rax
cmpq %rax, %rcx
je 0x44565
movq %rcx, 0x8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
jmp 0x4456d
movups (%rax), %xmm0
movups %xmm0, (%r13)
movq 0xe8(%r14), %rcx
leaq 0x8(%rsp), %r12
movq %rcx, 0x8(%r12)
movq %rax, 0xe0(%r14)
movq $0x0, 0xe8(%r14)
movb $0x0, 0xf0(%r14)
movq 0x100(%r14), %rax
movq %rax, 0x20(%r12)
movq %r15, %rsi
callq 0x2d480
movq 0x100(%rbx), %rax
movq %rax, 0x100(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d480
movq 0x20(%r12), %rax
movq %rax, 0x100(%rbx)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x445df
callq 0x2d360
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCase::operator==(Catch::TestCase const&) const
|
T* get() const{ return m_p; }
|
movq 0x110(%rdi), %rax
cmpq 0x110(%rsi), %rax
je 0x4460f
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x4465a
testq %rdx, %rdx
je 0x44637
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x2d3d0
testl %eax, %eax
jne 0x4465a
movq 0x28(%rbx), %rdx
cmpq 0x28(%r14), %rdx
jne 0x4465a
testq %rdx, %rdx
je 0x44664
movq 0x20(%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %al
jmp 0x4465c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
jmp 0x4465c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::operator<<(std::ostream&, Catch::Version const&)
|
std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << "."
<< version.minorVersion << "."
<< version.patchNumber;
if( !version.branchName.empty() ) {
os << "-" << version.branchName
<< "." << version.buildNumber;
}
return os;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x2d270
movq %rax, %r15
leaq 0x25d90(%rip), %r12 # 0x6a496
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2d420
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x2d270
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2d420
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x2d270
cmpq $0x0, 0x18(%r14)
je 0x4478f
leaq 0x25c76(%rip), %rsi # 0x6a3c5
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x2d420
movq %rax, %r15
leaq 0x25d20(%rip), %rsi # 0x6a496
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movl 0x30(%r14), %esi
movq %r15, %rdi
callq 0x2d270
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MessageInfo::MessageInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType)
|
MessageInfo::MessageInfo( std::string const& _macroName,
SourceLineInfo const& _lineInfo,
ResultWas::OfType _type )
: macroName( _macroName ),
lineInfo( _lineInfo ),
type( _type ),
sequence( ++globalCount )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x20(%r14), %rax
movq %rax, 0x40(%rbx)
movl %ebp, 0x48(%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
movl 0x3dcc2(%rip), %eax # 0x824c8
incl %eax
movl %eax, 0x3dcba(%rip) # 0x824c8
movl %eax, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4482c
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ScopedMessage::ScopedMessage(Catch::MessageBuilder const&)
|
ScopedMessage::ScopedMessage( MessageBuilder const& builder )
: m_info( builder.m_info )
{
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
leaq 0x50(%rbx), %r12
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
movl 0x70(%r14), %eax
movl %eax, 0x70(%rbx)
subq $-0x80, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2d5a0
leaq 0x8(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x448e5
callq 0x2d360
callq 0x41964
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x30(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4492b
movq %rax, %r14
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x4491c
callq 0x2d360
jmp 0x4491c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x44936
callq 0x2d360
jmp 0x44936
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a0b8
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ScopedMessage::ScopedMessage(Catch::ScopedMessage const&)
|
ScopedMessage::ScopedMessage( ScopedMessage const& other )
: m_info( other.m_info )
{}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
movl 0x48(%r14), %eax
movl %eax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movl 0x70(%r14), %eax
movl %eax, 0x70(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x449d3
callq 0x2d360
jmp 0x449d3
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x449e0
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ScopedMessage::~ScopedMessage()
|
ScopedMessage::~ScopedMessage() {
getResultCapture().popScopedMessage( m_info );
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x41964
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x38(%rcx)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x44a0f
callq 0x2d360
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x44a21
callq 0x2d360
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x44a33
popq %rbx
jmp 0x2d360
popq %rbx
retq
movq %rax, %rdi
callq 0x3ed5c
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::LegacyReporterAdapter::assertionEnded(Catch::AssertionStats const&)
|
bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
it != itEnd;
++it ) {
if( it->type == ResultWas::Info ) {
ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
rb << it->message;
rb.setResultType( ResultWas::Info );
AssertionResult result = rb.build();
m_legacyReporter->Result( result );
}
}
}
m_legacyReporter->Result( assertionStats.assertionResult );
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x368, %rsp # imm = 0x368
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0xb8(%rsi)
je 0x44bce
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %r15
movq 0xc8(%rax), %rbx
cmpq %rbx, %r15
je 0x44bce
leaq 0x25655(%rip), %r12 # 0x6a1a0
leaq 0xc8(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpl $0x1, 0x48(%r15)
jne 0x44bc5
movq (%r15), %rsi
leaq 0x20(%r15), %rdx
movq %r13, %rdi
movq %r12, %rcx
movl $0x1, %r8d
movq %r12, %r9
callq 0x46766
movq 0x50(%r15), %rsi
movq 0x58(%r15), %rdx
leaq 0x1e8(%rsp), %rdi
callq 0x2d420
movl $0x1, 0x178(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x44c2c
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x80(%rax)
movq %rbp, %rdi
callq 0x43baa
movq %r13, %rdi
callq 0x3ee6e
addq $0x78, %r15
cmpq %rbx, %r15
jne 0x44b58
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movb $0x1, %al
addq $0x368, %rsp # imm = 0x368
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44bfa
movq %rax, %rbx
jmp 0x44c0c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x43baa
leaq 0xc8(%rsp), %rdi
callq 0x3ee6e
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::LegacyReporterAdapter::testCaseEnded(Catch::TestCaseStats const&)
|
T* operator->() const { return m_p; }
|
movq 0x10(%rdi), %rdi
leaq 0x8(%rsi), %rax
leaq 0x118(%rsi), %rdx
leaq 0x148(%rsi), %rcx
leaq 0x168(%rsi), %r8
movq (%rdi), %rsi
movq 0x50(%rsi), %r9
movq %rax, %rsi
jmpq *%r9
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string trim( std::string const& str ) {
static char const* whitespaceChars = "\n\r\t ";
std::string::size_type start = str.find_first_not_of( whitespaceChars );
std::string::size_type end = str.find_last_not_of( whitespaceChars );
return start != std::string::npos ? str.substr( start, 1+end-start ) : "";
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x23fd4(%rip), %r12 # 0x690ee
movl $0x4, %ecx
movq %rsi, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2d610
movq %rax, %r15
movl $0x4, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq $-0x1, %rdx
callq 0x2d5e0
cmpq $-0x1, %r15
je 0x45165
subq %r15, %rax
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x2d3e0
jmp 0x4517e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2502d(%rip), %rdx # 0x6a1a0
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3ef3e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::replaceInPlace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
bool replaced = false;
std::size_t i = str.find( replaceThis );
while( i != std::string::npos ) {
replaced = true;
str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
if( i < str.size()-withThis.size() )
i = str.find( replaceThis, i+withThis.size() );
else
i = std::string::npos;
}
return replaced;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r15
movq (%rsi), %rsi
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rcx
xorl %edx, %edx
callq 0x2d660
movq %rax, 0x8(%rsp)
cmpq $-0x1, %rax
je 0x453a1
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %r13
movq 0x8(%rsp), %r12
movq %rbp, %r14
movq %r13, %rbp
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x2d3e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r13, %rdi
callq 0x2d100
movq %r14, 0x38(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x45225
movq %rdx, 0x38(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x48(%rsp)
jmp 0x4522c
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %rbp, %r13
movq 0x8(%rax), %rdx
movq %rdx, 0x40(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
addq %r12, %rdx
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x2d3e0
movq 0x38(%rsp), %rcx
movl $0xf, %esi
movq %r14, %rbp
cmpq %r14, %rcx
je 0x4527e
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %r8
movq 0x20(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x452ac
movl $0xf, %esi
leaq 0x28(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0x452a7
movq 0x28(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x452bd
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x2d100
jmp 0x452cb
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
movq %r13, 0x58(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x452eb
movq %rdx, 0x58(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x68(%rsp)
jmp 0x452f3
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x60(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %r15, %rdi
leaq 0x58(%rsp), %rsi
callq 0x2d480
movq 0x58(%rsp), %rdi
cmpq %r13, %rdi
je 0x4532c
callq 0x2d360
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x45340
callq 0x2d360
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4534f
callq 0x2d360
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x45366
callq 0x2d360
movq 0x8(%r15), %rcx
movq 0x8(%rbx), %rdx
subq %rdx, %rcx
movq $-0x1, %rax
cmpq %rcx, %r12
jae 0x45394
addq %r12, %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %r15, %rdi
callq 0x2d660
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x451d8
cmpq $-0x1, 0x8(%rsp)
setne %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x453ec
movq %rax, %rbx
jmp 0x453dd
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x453dd
callq 0x2d360
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x453ec
callq 0x2d360
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x45403
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::operator<<(std::ostream&, Catch::pluralise const&)
|
std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
os << pluraliser.m_count << " " << pluraliser.m_label;
if( pluraliser.m_count != 1 )
os << "s";
return os;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x2d270
movq %rax, %r15
leaq 0x23ca7(%rip), %rsi # 0x690f1
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
cmpq $0x1, (%r14)
je 0x45481
leaq 0x2414a(%rip), %rsi # 0x695be
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2d420
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::SourceLineInfo::SourceLineInfo(Catch::SourceLineInfo const&)
|
SourceLineInfo::SourceLineInfo( SourceLineInfo const& other )
: file( other.file ),
line( other.line )
{}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::SourceLineInfo::operator==(Catch::SourceLineInfo const&) const
|
bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
return line == other.line && file == other.file;
}
|
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x45529
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x45529
testq %rdx, %rdx
je 0x4552c
pushq %rax
movq (%rsi), %rsi
movq (%rdi), %rdi
callq 0x2d3d0
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::rngSeed()
|
IContext& getCurrentContext() {
return getCurrentMutableContext();
}
|
pushq %rbx
subq $0x10, %rsp
callq 0x4376b
movq (%rax), %rcx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x455a9
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
jmp 0x455ce
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x455c6
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::throwLogicError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
|
void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
std::ostringstream oss;
oss << locationInfo << ": Internal Catch error: '" << message << "'";
if( alwaysTrue() )
throw std::logic_error( oss.str() );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x42ab1
leaq 0x23aeb(%rip), %rsi # 0x690f3
leaq 0x20(%rsp), %rdi
movl $0x19, %edx
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x20(%rsp), %rdi
callq 0x2d420
leaq 0x243b0(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d5a0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2d530
xorl %ebp, %ebp
movq 0x3c963(%rip), %rsi # 0x81fd0
movq 0x3c944(%rip), %rdx # 0x81fb8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4569a
callq 0x2d360
jmp 0x4569a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x456ac
movq %rbx, %rdi
callq 0x2d2d0
jmp 0x456ac
movq %rax, %r14
movq 0x3c8fd(%rip), %rsi # 0x81fb0
leaq 0x20(%rsp), %rdi
callq 0x2d1d0
leaq 0x90(%rsp), %rdi
callq 0x2d110
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::SectionInfo::SectionInfo(Catch::SourceLineInfo 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&)
|
SectionInfo::SectionInfo
( SourceLineInfo const& _lineInfo,
std::string const& _name,
std::string const& _description )
: name( _name ),
description( _description ),
lineInfo( _lineInfo )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x20(%r14), %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x45763
callq 0x2d360
jmp 0x45763
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x45770
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Section::Section(Catch::SectionInfo const&)
|
Section::Section( SectionInfo const& info )
: m_info( info ),
m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
{
m_timer.start();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3a335(%rip), %rax # 0x7fac8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
leaq 0x28(%r14), %r12
leaq 0x38(%r14), %rbp
movq %rbp, 0x28(%r14)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
leaq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x60(%r15), %rax
movq %rax, 0x68(%r14)
leaq 0x80(%r14), %r12
movq %r12, 0x70(%r14)
xorl %eax, %eax
movq %rax, 0x78(%r14)
movb $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
movq %rax, 0xa0(%r14)
callq 0x41964
leaq 0x90(%r14), %rdx
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
movb %al, 0xa8(%r14)
movq $0x0, 0xb0(%r14)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2d5c0
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
movq %rax, 0xb0(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x45892
callq 0x2d360
jmp 0x45892
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x458ba
callq 0x2d360
jmp 0x458ba
movq %rax, %r15
movq 0x70(%r14), %rdi
cmpq %r12, %rdi
je 0x458b2
callq 0x2d360
movq %rbx, %rdi
callq 0x3ed68
movq %r15, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Section::~Section()
|
Section::~Section() {
if( m_sectionIncluded ) {
SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
if( std::uncaught_exception() )
getResultCapture().sectionEndedEarly( endInfo );
else
getResultCapture().sectionEnded( endInfo );
}
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x458c2
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Detail::rawMemoryToString[abi:cxx11](void const*, unsigned long)
|
std::string rawMemoryToString( const void *object, std::size_t size )
{
// Reverse order for little endian architectures
int i = 0, end = static_cast<int>( size ), inc = 1;
if( Endianness::which() == Endianness::Little ) {
i = end-1;
end = inc = -1;
}
unsigned char const *bytes = static_cast<unsigned char const *>(object);
std::ostringstream os;
os << "0x" << std::setfill('0') << std::hex;
for( ; i != end; i += inc )
os << std::setw(2) << static_cast<unsigned>(bytes[i]);
return os.str();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x2d4b0
leaq 0x236ec(%rip), %rsi # 0x69127
movl $0x2, %edx
movq %r12, %rdi
callq 0x2d420
movq (%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
cmpb $0x0, 0xe1(%r12)
jne 0x45a7d
movq %r12, %rdi
movl $0x20, %esi
callq 0x2d380
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movq %rsp, %r12
movq (%r12), %rax
movq -0x18(%rax), %rax
movl 0x18(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rsp,%rax)
movslq %r15d, %rax
movq %rax, %r15
subq $0x1, %r15
jb 0x45acf
movq (%rsp), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rsp,%rcx)
movzbl -0x1(%r14,%rax), %esi
movq %r12, %rdi
callq 0x2d270
movq %r15, %rax
jmp 0x45aa5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x3c4cd(%rip), %rsi # 0x81fb0
movq %rsp, %rdi
callq 0x2d1d0
leaq 0x70(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x45b09
movq %rax, %rbx
movq 0x3c49d(%rip), %rsi # 0x81fb0
movq %rsp, %rdi
callq 0x2d1d0
leaq 0x70(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string toString( std::string const& value ) {
std::string s = value;
if( getCurrentContext().getConfig()->showInvisibles() ) {
for(size_t i = 0; i < s.size(); ++i ) {
std::string subs;
switch( s[i] ) {
case '\n': subs = "\\n"; break;
case '\t': subs = "\\t"; break;
default: break;
}
if( !subs.empty() ) {
s = s.substr( 0, i ) + subs + s.substr( i+1 );
++i;
}
}
}
return "\"" + s + "\"";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x80(%rsp), %rdi
movq %rax, %rsi
callq 0x4042a
callq 0x4376b
movq (%rax), %rcx
movq %rsp, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %ebp
movq %rbx, 0xa0(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x45b9b
movq (%rdi), %rax
callq *0x18(%rax)
testb %bpl, %bpl
je 0x45dc5
cmpq $0x0, 0x88(%rsp)
je 0x45dc5
leaq 0x10(%rsp), %r15
leaq 0x50(%rsp), %rbp
leaq 0x70(%rsp), %rbx
xorl %r14d, %r14d
leaq 0xa8(%rsp), %r12
leaq 0x80(%rsp), %r13
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq 0x80(%rsp), %rax
movzbl (%rax,%r14), %eax
cmpl $0x9, %eax
je 0x45c07
leaq 0x23511(%rip), %rcx # 0x69111
cmpl $0xa, %eax
je 0x45c0e
jmp 0x45c20
leaq 0x23506(%rip), %rcx # 0x69114
movl $0x2, %r8d
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d580
cmpq $0x0, 0x8(%rsp)
je 0x45da6
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x2d3e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x2d100
movq %rbp, 0x40(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x45c70
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
jmp 0x45c77
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x48(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
incq %r14
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x2d3e0
movq 0x40(%rsp), %rcx
movl $0xf, %esi
cmpq %rbp, %rcx
je 0x45cbd
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rsi, %rax
jbe 0x45ceb
movl $0xf, %esi
leaq 0x30(%rsp), %rdi
cmpq %rdi, 0x20(%rsp)
je 0x45ce6
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x45cfc
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2d100
jmp 0x45d0a
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
movq %rbx, 0x60(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x45d2a
movq %rdx, 0x60(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x70(%rsp)
jmp 0x45d30
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x68(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0x2d480
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0x45d69
callq 0x2d360
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x45d7d
callq 0x2d360
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45d8c
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x45da6
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x45db4
callq 0x2d360
incq %r14
cmpq 0x88(%rsp), %r14
jb 0x45bd5
leaq 0x232b0(%rip), %rsi # 0x6907c
movq %rsp, %rdi
leaq 0x80(%rsp), %rdx
callq 0x49917
leaq 0x23299(%rip), %rsi # 0x6907c
movq %rsp, %rdi
callq 0x2d700
movq 0xa0(%rsp), %rbx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x45e15
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x45e1b
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x45e45
callq 0x2d360
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x45e5f
callq 0x2d360
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45ea6
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x45f0d
jmp 0x45f12
jmp 0x45eae
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x45f12
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x45f12
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %r14
jmp 0x45f12
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x45ed6
callq 0x2d360
jmp 0x45ed6
jmp 0x45f01
movq %rax, %r14
jmp 0x45ee5
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x45ee5
callq 0x2d360
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x45f04
callq 0x2d360
jmp 0x45f04
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x45f12
callq 0x2d360
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x45f2c
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString[abi:cxx11](int)
|
std::string toString( int value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << value << ")";
return oss.str();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2d4b0
movq %r14, %rdi
movl %ebp, %esi
callq 0x2d650
cmpl $0x100, %ebp # imm = 0x100
jl 0x461f5
leaq 0x22f74(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x2d420
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movl %ebp, %esi
callq 0x2d650
leaq 0x22f01(%rip), %rsi # 0x690e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x3bda7(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x3bd7a(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString[abi:cxx11](unsigned long)
|
std::string toString( unsigned long value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << 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 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d270
cmpq $0x100, %r14 # imm = 0x100
jb 0x462d1
leaq 0x22e99(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x2d420
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq %r14, %rsi
callq 0x2d270
leaq 0x22e25(%rip), %rsi # 0x690e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x3bccb(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x3bc9d(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString[abi:cxx11](float)
|
std::string toString( const float value ) {
return fpToString( value, 5 ) + "f";
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x5, %esi
callq 0x4a39d
leaq 0x23431(%rip), %rsi # 0x697a6
movq %r14, %rdi
callq 0x2d700
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4639f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x463a5
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x463cf
callq 0x2d360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x463f0
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString[abi:cxx11](bool)
|
std::string toString( bool value ) {
return value ? "true" : "false";
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x22d27(%rip), %rcx # 0x6912a
leaq 0x22d51(%rip), %rax # 0x6915b
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x3ef3e
movq %rbx, %rax
popq %rbx
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::toString[abi:cxx11](unsigned long long)
|
std::string toString( unsigned long long value ) {
std::ostringstream oss;
oss << value;
if( value > Detail::hexThreshold )
oss << " (0x" << std::hex << 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 0x2d4b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d260
cmpq $0x100, %r14 # imm = 0x100
jb 0x465e2
leaq 0x22b88(%rip), %rsi # 0x69125
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x2d420
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq %r14, %rsi
callq 0x2d260
leaq 0x22b14(%rip), %rsi # 0x690e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x3b9ba(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x3b98c(%rip), %rsi # 0x81fb0
leaq 0x8(%rsp), %rdi
callq 0x2d1d0
leaq 0x78(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestGroupStats::~TestGroupStats()
|
TestGroupStats::~TestGroupStats() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x3773d(%rip), %rax # 0x7fb78
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x48450
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::WildcardPattern::~WildcardPattern()
|
WildcardPattern::~WildcardPattern() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x376f1(%rip), %rax # 0x7fe90
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x487b4
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestSpec::NamePattern::~NamePattern()
|
TestSpec::NamePattern::~NamePattern() {}
|
movq %rdi, %rax
leaq 0x376ec(%rip), %rcx # 0x7feb8
movq %rcx, (%rdi)
leaq 0x376ba(%rip), %rcx # 0x7fe90
movq %rcx, 0x10(%rdi)
movq 0x20(%rdi), %rdi
addq $0x30, %rax
cmpq %rax, %rdi
jne 0x2d360
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestSpec::NamePattern::~NamePattern()
|
TestSpec::NamePattern::~NamePattern() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x376c1(%rip), %rax # 0x7feb8
movq %rax, (%rdi)
leaq 0x3768f(%rip), %rax # 0x7fe90
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x48817
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestSpec::TagPattern::~TagPattern()
|
TestSpec::TagPattern::~TagPattern() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x376a5(%rip), %rax # 0x7fef0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x48860
callq 0x2d360
movq %rbx, %rdi
popq %rbx
jmp 0x2d360
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::(anonymous namespace)::PosixColourImpl::~PosixColourImpl()
|
virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m" );
case Colour::Blue: return setColour( "[0:34m" );
case Colour::Cyan: return setColour( "[0;36m" );
case Colour::Yellow: return setColour( "[0;33m" );
case Colour::Grey: return setColour( "[1;30m" );
case Colour::LightGrey: return setColour( "[0;37m" );
case Colour::BrightRed: return setColour( "[1;31m" );
case Colour::BrightGreen: return setColour( "[1;32m" );
case Colour::BrightWhite: return setColour( "[1;37m" );
case Colour::Bright: throw std::logic_error( "not a colour" );
}
}
|
jmp 0x2d360
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::(anonymous namespace)::PosixColourImpl::use(Catch::Colour::Code)
|
virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m" );
case Colour::Blue: return setColour( "[0:34m" );
case Colour::Cyan: return setColour( "[0;36m" );
case Colour::Yellow: return setColour( "[0;33m" );
case Colour::Grey: return setColour( "[1;30m" );
case Colour::LightGrey: return setColour( "[0;37m" );
case Colour::BrightRed: return setColour( "[1;31m" );
case Colour::BrightGreen: return setColour( "[1;32m" );
case Colour::BrightWhite: return setColour( "[1;37m" );
case Colour::Bright: throw std::logic_error( "not a colour" );
}
}
|
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x17, %esi
ja 0x48d05
movl %esi, %eax
leaq 0x1fb56(%rip), %rcx # 0x687e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20787(%rip), %rdi # 0x69429
jmp 0x48cfc
leaq 0x207b3(%rip), %rdi # 0x6945e
jmp 0x48cfc
leaq 0x207a3(%rip), %rdi # 0x69457
jmp 0x48cfc
leaq 0x207af(%rip), %rdi # 0x6946c
jmp 0x48cfc
leaq 0x20767(%rip), %rdi # 0x6942d
jmp 0x48cfc
leaq 0x2076c(%rip), %rdi # 0x6943b
jmp 0x48cfc
leaq 0x2076a(%rip), %rdi # 0x69442
jmp 0x48cfc
leaq 0x20753(%rip), %rdi # 0x69434
jmp 0x48cfc
leaq 0x2077b(%rip), %rdi # 0x69465
jmp 0x48cfc
leaq 0x20756(%rip), %rdi # 0x69449
jmp 0x48cfc
leaq 0x20754(%rip), %rdi # 0x69450
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x48d52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %rbx
leaq 0x20752(%rip), %rsi # 0x69473
movq %rax, %rdi
callq 0x2d4f0
movq 0x392a0(%rip), %rsi # 0x81fd0
movq 0x39281(%rip), %rdx # 0x81fb8
movq %rbx, %rdi
callq 0x2d640
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d2d0
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*)
|
void setColour( const char* _escapeCode ) {
Catch::cout() << '\033' << _escapeCode;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x1b, (%rsi)
movq 0x39258(%rip), %rdi # 0x81fc0
movl $0x1, %edx
callq 0x2d420
movq %rax, %r14
testq %rbx, %rbx
je 0x48d92
movq %rbx, %rdi
callq 0x2d180
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2d420
jmp 0x48dac
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2d620
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Ptr<Catch::IStreamingReporter>::operator=(Catch::Ptr<Catch::IStreamingReporter> 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 0x48dd0
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x48de1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::RunContext(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter> const&)
|
explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
: m_runInfo( _config->name() ),
m_context( getCurrentMutableContext() ),
m_activeTestCase( CATCH_NULL ),
m_config( _config ),
m_reporter( reporter )
{
m_context.setRunner( this );
m_context.setConfig( m_config );
m_context.setResultCapture( this );
m_reporter->testRunStarting( m_runInfo );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3835a(%rip), %rax # 0x81258
movq %rax, (%rdi)
leaq 0x383c0(%rip), %rax # 0x812c8
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x30(%rax)
leaq 0x10(%rbx), %r14
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4042a
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48f4e
callq 0x2d360
movq %r13, 0x10(%rsp)
callq 0x4376b
movq %rax, 0x30(%rbx)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
leaq 0x80(%rbx), %rcx
movq %rcx, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movb %al, 0x80(%rbx)
movq %rax, 0x90(%rbx)
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movb %al, 0xa8(%rbx)
leaq 0xd0(%rbx), %rcx
movq %rcx, 0xc0(%rbx)
movq %rax, 0xc8(%rbx)
movb %al, 0xd0(%rbx)
leaq 0xf0(%rbx), %rcx
movq %rcx, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
movb %al, 0xf0(%rbx)
movl $0xffffffff, 0x100(%rbx) # imm = 0xFFFFFFFF
movq (%r15), %rdi
movq %rdi, 0x108(%rbx)
testq %rdi, %rdi
je 0x48ffd
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x108(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x110(%rbx)
movq (%r12), %rdi
movq %rdi, 0x140(%rbx)
testq %rdi, %rdi
je 0x49035
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x8(%rbx), %rsi
leaq 0x148(%rbx), %r13
movups %xmm0, 0x148(%rbx)
xorl %eax, %eax
movq %rax, 0x158(%rbx)
leaq 0x160(%rbx), %rbp
leaq 0x170(%rbx), %rcx
movq %rcx, 0x160(%rbx)
movq %rax, 0x168(%rbx)
movb %al, 0x170(%rbx)
leaq 0x190(%rbx), %rcx
movq %rcx, 0x180(%rbx)
movq %rax, 0x188(%rbx)
movb %al, 0x190(%rbx)
movq %rax, 0x1a0(%rbx)
leaq 0x1b8(%rbx), %rcx
movq %rcx, 0x1a8(%rbx)
movq %rax, 0x1b0(%rbx)
movb %al, 0x1b8(%rbx)
leaq 0x1d0(%rbx), %r12
movups %xmm0, 0x1d0(%rbx)
movups %xmm0, 0x1e0(%rbx)
movups %xmm0, 0x1f0(%rbx)
movups %xmm0, 0x200(%rbx)
movl $0x0, 0x210(%rbx)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
jmp 0x491b2
movq %rax, 0x8(%rsp)
jmp 0x491c0
movq %rax, 0x8(%rsp)
jmp 0x491cc
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x491d6
jmp 0x491db
movq %rax, 0x8(%rsp)
jmp 0x491db
movq %rax, 0x8(%rsp)
movq 0x200(%rbx), %rdi
testq %rdi, %rdi
je 0x49177
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0x49188
callq 0x2d360
movq %r12, %rdi
callq 0x4e9c0
movq %rbp, %rdi
callq 0x49d12
movq %r13, %rdi
callq 0x4a870
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x491b2
movq (%rdi), %rax
callq *0x18(%rax)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x491c0
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x43baa
movq (%r14), %rdi
cmpq 0x10(%rsp), %rdi
je 0x491db
callq 0x2d360
movq 0x8(%rsp), %rdi
callq 0x2d690
jmp 0x491e9
jmp 0x491e9
movq %rax, %rdi
callq 0x3ed5c
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
|
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
if( isReservedTag( tag ) ) {
{
Colour colourGuard( Colour::Red );
Catch::cerr()
<< "Tag name [" << tag << "] not allowed.\n"
<< "Tag names starting with non alpha-numeric characters are reserved\n";
}
{
Colour colourGuard( Colour::FileName );
Catch::cerr() << _lineInfo << std::endl;
}
exit(1);
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x49e22
testl %eax, %eax
jne 0x49f4c
cmpq $0x0, 0x8(%r14)
je 0x49f4c
movq (%r14), %rax
movsbl (%rax), %edi
callq 0x2d3c0
testl %eax, %eax
je 0x49f54
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
movl $0x2, %edi
callq 0x437d0
movq 0x3807e(%rip), %rdi # 0x81fe8
leaq 0x1f532(%rip), %rsi # 0x694a3
movl $0xa, %edx
callq 0x2d420
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x3805f(%rip), %rdi # 0x81fe8
callq 0x2d420
movq %rax, %r14
leaq 0x1f516(%rip), %rsi # 0x694ae
movl $0xf, %edx
movq %rax, %rdi
callq 0x2d420
leaq 0x1f512(%rip), %rsi # 0x694be
movl $0x42, %edx
movq %r14, %rdi
callq 0x2d420
leaq 0x7(%rsp), %rdi
callq 0x4383a
movb $0x0, 0x6(%rsp)
movl $0x17, %edi
callq 0x437d0
movq 0x3800f(%rip), %rdi # 0x81fe8
movq %rbx, %rsi
callq 0x42ab1
movq 0x38000(%rip), %rdi # 0x81fe8
callq 0x2d1a0
leaq 0x6(%rsp), %rdi
callq 0x4383a
movl $0x1, %edi
callq 0x2d470
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
jmp 0x4a013
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/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] == '.' )
i++;
d = d.substr( 0, i+1 );
}
return d;
}
|
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 0x2d4b0
movq (%r14), %rax
movq -0x18(%rax), %rax
movslq %ebp, %rcx
movq %rcx, 0x30(%rsp,%rax)
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx # imm = 0xFFFFFEFB
andl 0x40(%rsp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x40(%rsp,%rax)
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
movq %r14, %rdi
callq 0x2d5b0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq %rbx, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x2d290
cmpq $-0x1, %rax
je 0x4a46e
movq 0x8(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
je 0x4a46e
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2e, (%rcx,%rax)
sete %dl
leaq (%rax,%rdx), %rcx
incq %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2d3e0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d480
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4a46e
callq 0x2d360
movq 0x37b3b(%rip), %rsi # 0x81fb0
leaq 0x28(%rsp), %rdi
callq 0x2d1d0
leaq 0x98(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4a4b4
callq 0x2d360
jmp 0x4a4b4
movq %rax, %r14
movq 0x37af5(%rip), %rsi # 0x81fb0
leaq 0x28(%rsp), %rdi
callq 0x2d1d0
leaq 0x98(%rsp), %rdi
callq 0x2d110
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x42d35
movq %rax, %r14
movl $0x10, %edi
callq 0x2d3a0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movl $0x0, 0x8(%rax)
leaq 0x3754f(%rip), %rcx # 0x81c60
movq %rcx, (%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movl $0x1, 0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4a73c
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x4a760
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4a758
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Session::Session()
|
Session()
: m_cli( makeCommandLineParser() ) {
if( alreadyInstantiated ) {
std::string msg = "Only one instance of Catch::Session can ever be used";
Catch::cerr() << msg << std::endl;
throw std::logic_error( msg );
}
alreadyInstantiated = true;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x36bf9(%rip), %rax # 0x81650
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x54884
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x68(%r14)
movl $0x0, 0x87(%r14)
movaps 0x1dceb(%rip), %xmm1 # 0x68770
movups %xmm1, 0x8c(%r14)
xorl %eax, %eax
movq %rax, 0x9c(%r14)
leaq 0xb8(%r14), %rcx
movq %rcx, 0xa8(%r14)
movq %rax, 0xb0(%r14)
movb %al, 0xb8(%r14)
leaq 0xd8(%r14), %rcx
movq %rcx, 0xc8(%r14)
movq %rax, 0xd0(%r14)
movb %al, 0xd8(%r14)
leaq 0xf8(%r14), %rcx
movq %rcx, 0xe8(%r14)
movq %rax, 0xf0(%r14)
movb %al, 0xf8(%r14)
movups %xmm0, 0x108(%r14)
movups %xmm0, 0x118(%r14)
movups %xmm0, 0x128(%r14)
movq %rax, 0x138(%r14)
cmpb $0x1, 0x37962(%rip) # 0x82472
je 0x4ab27
movb $0x1, 0x37959(%rip) # 0x82472
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1e9d7(%rip), %rsi # 0x6950e
leaq 0x1ea04(%rip), %rdx # 0x69542
movq %rsp, %rdi
callq 0x3ef3e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x37492(%rip), %rdi # 0x81fe8
callq 0x2d420
movq %rax, %rdi
callq 0x2d1a0
movl $0x10, %edi
callq 0x2d1b0
movq %rax, %r12
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2d530
movq 0x3744e(%rip), %rsi # 0x81fd0
movq 0x3742f(%rip), %rdx # 0x81fb8
movq %r12, %rdi
callq 0x2d640
movq %rax, %r15
movq %r12, %rdi
callq 0x2d2d0
jmp 0x4aba1
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x4abb4
callq 0x2d360
jmp 0x4abb4
movq %rax, %r15
movq 0x138(%r14), %rdi
testq %rdi, %rdi
je 0x4abc6
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x68(%r14), %r12
subq $-0x80, %r14
movq %r14, %rdi
callq 0x55c70
movq %r12, %rdi
callq 0x55cc6
movq %rbx, %rdi
callq 0x55d0a
movq %r15, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::StdString::Contains::toString[abi:cxx11]() const
|
virtual std::string toString() const {
return "contains: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdx
leaq 0x1ed80(%rip), %rsi # 0x69d6a
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x49917
leaq 0x1e07e(%rip), %rsi # 0x6907c
movq %r15, %rdi
callq 0x2d700
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4b02c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x4b033
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x10(%r14), %eax
cmpl $0x1, %eax
leaq 0x1ecfd(%rip), %rcx # 0x69d56
leaq 0x1f140(%rip), %rsi # 0x6a1a0
cmoveq %rcx, %rsi
leaq 0x13(%rsi), %rdx
cmpl $0x1, %eax
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
cmovneq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x3ef3e
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r15, %rcx
je 0x4b0a3
movq 0x10(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4b0be
movl $0xf, %esi
cmpq %r14, 0x20(%rsp)
je 0x4b0b9
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x4b0cd
movq 0x20(%rsp), %rsi
movq %rsp, %rdi
callq 0x2d100
jmp 0x4b0db
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d400
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x4b0fa
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x4b100
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x4b12b
callq 0x2d360
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4b139
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b14c
callq 0x2d360
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x4b170
callq 0x2d360
jmp 0x4b170
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4b183
callq 0x2d360
jmp 0x4b183
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b196
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseTracking::TrackerBase::name[abi:cxx11]() const
|
virtual std::string name() const CATCH_OVERRIDE {
return m_name;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::JunitReporter::testGroupEnded(Catch::TestGroupStats const&)
|
virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
double suiteTime = suiteTimer.getElapsedSeconds();
CumulativeReporterBase::testGroupEnded( testGroupStats );
writeGroup( *m_testGroups.back(), suiteTime );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2d5c0
imull $0xf4240, (%r15), %eax # imm = 0xF4240
addl 0x8(%r15), %eax
subl 0x110(%r14), %eax
cvtsi2sd %rax, %xmm0
divsd 0x1a5f5(%rip), %xmm0 # 0x68760
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c4ac
movq 0x70(%r14), %rax
movq -0x8(%rax), %rsi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5fed8
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
stream << "No test cases matched '" << spec << "'" << std::endl;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x1bf93(%rip), %rsi # 0x6a14d
movl $0x17, %edx
movq %r14, %rdi
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2d420
movq %rax, %rbx
leaq 0x1b7ff(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d280
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&)
|
virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those
if( !m_config->includeSuccessfulResults() && result.isOk() ) {
if( result.getResultType() != ResultWas::Warning )
return false;
printInfoMessages = false;
}
lazyPrint();
AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
printer.print();
stream << std::endl;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x4e275
movl 0xb8(%r14), %eax
testb $0x10, %al
je 0x4e26a
movl 0x70(%r14), %ecx
andl $0x8, %ecx
je 0x4e275
xorl %ebp, %ebp
cmpl $0x2, %eax
jne 0x4e314
movq %rbx, %rdi
callq 0x611c0
movq 0x18(%rbx), %rsi
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x611fe
movq %r15, %rdi
callq 0x6163e
movq 0x18(%rbx), %rbx
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x4a870
movq -0x20(%rbx), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x4e2eb
callq 0x2d360
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e2fe
callq 0x2d360
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e311
callq 0x2d360
movb $0x1, %bpl
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x616c2
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&)
|
virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
if( _sectionStats.missingAssertions ) {
lazyPrint();
Colour colour( Colour::ResultError );
if( m_sectionStack.size() > 1 )
stream << "\nNo assertions in section";
else
stream << "\nNo assertions in test case";
stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
}
if( m_headerPrinted ) {
if( m_config->showDurations() == ShowDurations::Always )
stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
m_headerPrinted = false;
}
else {
if( m_config->showDurations() == ShowDurations::Always )
stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
}
StreamingReporterBase::sectionEnded( _sectionStats );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x90(%rsi)
jne 0x4e424
movq %rbx, %rdi
callq 0x611c0
movb $0x0, 0x7(%rsp)
movl $0x12, %edi
callq 0x437d0
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
movq 0x18(%rbx), %rdi
sarq $0x3, %rax
movabsq $0x4ec4ec4ec4ec4ec5, %rcx # imm = 0x4EC4EC4EC4EC4EC5
imulq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
setb %al
leaq 0x1bf63(%rip), %rcx # 0x6a302
leaq 0x1bf76(%rip), %rsi # 0x6a31c
cmovaeq %rcx, %rsi
leaq 0x19(,%rax,2), %rdx
callq 0x2d420
movq 0x18(%rbx), %r15
leaq 0x1b61c(%rip), %rsi # 0x699de
movl $0x2, %edx
movq %r15, %rdi
callq 0x2d420
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
movq %rax, %r15
leaq 0x1bf4f(%rip), %rsi # 0x6a338
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
xorl %edi, %edi
callq 0x437d0
movb 0x1c9(%rbx), %bpl
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpb $0x1, %bpl
jne 0x4e4b0
cmpl $0x1, %eax
jne 0x4e4a7
movq 0x18(%rbx), %r15
leaq 0x1bef0(%rip), %rsi # 0x6a33b
movl $0xd, %edx
movq %r15, %rdi
callq 0x2d420
movsd 0x88(%r14), %xmm0
movq %r15, %rdi
callq 0x2d5b0
movq %rax, %r14
leaq 0x1b14b(%rip), %rsi # 0x695be
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r14, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movb $0x0, 0x1c9(%rbx)
jmp 0x4e52c
cmpl $0x1, %eax
jne 0x4e52c
movq 0x18(%rbx), %rdi
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
callq 0x2d420
movq %rax, %r15
leaq 0x1be79(%rip), %rsi # 0x6a349
movl $0xe, %edx
movq %rax, %rdi
callq 0x2d420
movsd 0x88(%r14), %xmm0
movq %r15, %rdi
callq 0x2d5b0
movq %rax, %r14
leaq 0x1b0c6(%rip), %rsi # 0x695be
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r14, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
leaq 0x1b0(%rbx), %rdi
movq 0x1b8(%rbx), %rsi
addq $-0x68, %rsi
movq %rsi, 0x1b8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5e4c2
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0x4383a
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&)
|
virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
if( currentGroupInfo.used ) {
printSummaryDivider();
stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
printTotals( _testGroupStats.totals );
stream << "\n" << std::endl;
}
StreamingReporterBase::testGroupEnded( _testGroupStats );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x4e63c
movq %rsi, %r14
movq %rbx, %rdi
callq 0x622b8
movq 0x18(%rbx), %r15
leaq 0x1bd9b(%rip), %rsi # 0x6a358
movl $0x13, %edx
movq %r15, %rdi
callq 0x2d420
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x2d420
leaq 0x1bd8b(%rip), %rsi # 0x6a36c
movl $0x3, %edx
movq %rax, %rdi
callq 0x2d420
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62332
movq 0x18(%rbx), %r14
leaq 0x1bb97(%rip), %rsi # 0x6a19f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2d420
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r14, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x4e656
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x4e656
callq 0x2d360
movq $0x0, 0x50(%rbx)
movb $0x0, 0x88(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
|
virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
printTotalsDivider( _testRunStats.totals );
printTotals( _testRunStats.totals );
stream << std::endl;
StreamingReporterBase::testRunEnded( _testRunStats );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x63156
movq %r14, %rdi
movq %r15, %rsi
callq 0x62332
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r15, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4bfba
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::CompactReporter::noMatchingTestCases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
virtual void noMatchingTestCases( std::string const& spec ) {
stream << "No test cases matched '" << spec << "'" << std::endl;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x18(%rdi), %r14
leaq 0x1ba6d(%rip), %rsi # 0x6a14d
movl $0x17, %edx
movq %r14, %rdi
callq 0x2d420
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2d420
movq %rax, %rbx
leaq 0x1b2d9(%rip), %rsi # 0x699df
movl $0x1, %edx
movq %rax, %rdi
callq 0x2d420
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2d030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2d280
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::CompactReporter::assertionEnded(Catch::AssertionStats const&)
|
virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those
if( !m_config->includeSuccessfulResults() && result.isOk() ) {
if( result.getResultType() != ResultWas::Warning )
return false;
printInfoMessages = false;
}
AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
printer.print();
stream << std::endl;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x4e780
movl 0xb8(%r15), %eax
testb $0x10, %al
je 0x4e779
movl 0x70(%r15), %ecx
andl $0x8, %ecx
je 0x4e780
xorl %ebp, %ebp
cmpl $0x2, %eax
jne 0x4e7f7
leaq 0x8(%r15), %rax
movq 0x18(%r14), %rcx
leaq 0x20(%rsp), %rbx
movq %rcx, -0x18(%rbx)
movq %r15, -0x10(%rbx)
movq %rax, -0x8(%rbx)
leaq 0xc0(%r15), %rsi
movq %rbx, %rdi
callq 0x4f83a
movq 0xc0(%r15), %rax
movq %rax, 0x18(%rbx)
movb %bpl, 0x20(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x634f8
movq 0x18(%r14), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2d380
movsbl %al, %esi
movq %r14, %rdi
callq 0x2d030
movq %rax, %rdi
callq 0x2d280
movq %rbx, %rdi
callq 0x4a870
movb $0x1, %bpl
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a870
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::assertionEnded(Catch::AssertionResult const&)
|
virtual void assertionEnded( AssertionResult const& result ) {
if( result.getResultType() == ResultWas::Ok ) {
m_totals.assertions.passed++;
}
else if( !result.isOk() ) {
m_totals.assertions.failed++;
}
if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) )
m_messages.clear();
// Reset working state
m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
m_lastResult = result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %rbx
movq %rdi, %r14
movl 0xb0(%rsi), %eax
testl %eax, %eax
je 0x4ea2e
testb $0x10, %al
je 0x4ea37
movl 0x68(%rbx), %ecx
movl $0x118, %eax # imm = 0x118
andl $0x8, %ecx
je 0x4ea33
jmp 0x4ea37
movl $0x110, %eax # imm = 0x110
incq (%r14,%rax)
movq 0x140(%r14), %r12
leaq 0x148(%r14), %r15
leaq 0x110(%r14), %rcx
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4f450
movq (%r12), %rax
movq %r12, %rdi
movq %r13, %rsi
callq *0x58(%rax)
movl %eax, %ebp
leaq 0x310a3(%rip), %rax # 0x7fb18
leaq 0x100(%rsp), %rdi
movq %rax, -0xc0(%rdi)
callq 0x4a870
leaq 0x48(%rsp), %rdi
callq 0x43baa
testb %bpl, %bpl
je 0x4eaa3
movq (%r15), %rsi
movq %r15, %rdi
callq 0x4fe98
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1b6ed(%rip), %rdx # 0x6a1a0
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ef3e
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x1a861(%rip), %rsi # 0x69331
leaq 0x1a886(%rip), %rdx # 0x6935d
movq %rsp, %rdi
callq 0x3ef3e
leaq 0x180(%r14), %r15
movl 0x1c8(%r14), %r8d
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %r15, %rdx
callq 0x43968
leaq 0x160(%r14), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2d480
leaq 0x60(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2d480
movq 0x20(%r12), %rax
movq %rax, 0x1a0(%r14)
leaq 0x1a8(%r14), %rdi
leaq 0x88(%rsp), %r15
movq %r15, %rsi
callq 0x2d480
movl 0x20(%r15), %eax
movl %eax, 0x1c8(%r14)
movq (%r15), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4eb66
callq 0x2d360
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4eb79
callq 0x2d360
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4eb8c
callq 0x2d360
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x4eb9a
callq 0x2d360
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x4eba9
callq 0x2d360
addq $0x50, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f6b0
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ebe0
callq 0x2d360
jmp 0x4ebe0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ec1e
callq 0x2d360
jmp 0x4ec1e
movq %rax, %rbx
jmp 0x4ec1e
movq %rax, %rbx
leaq 0x30f18(%rip), %rax # 0x7fb18
leaq 0x100(%rsp), %rdi
movq %rax, -0xc0(%rdi)
callq 0x4a870
leaq 0x48(%rsp), %rdi
callq 0x43baa
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&)
|
virtual void sectionEnded( SectionEndInfo const& endInfo ) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions( assertions );
if( !m_activeSections.empty() ) {
m_activeSections.back()->close();
m_activeSections.pop_back();
}
m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
m_messages.clear();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movdqu 0x110(%rdi), %xmm0
movdqu 0x68(%r14), %xmm1
psubq %xmm1, %xmm0
movdqa %xmm0, (%rsi)
movq 0x120(%rdi), %rax
subq 0x78(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x50152
movl %eax, %ebp
movq 0x1f0(%rbx), %rax
cmpq %rax, 0x1e8(%rbx)
je 0x4ee22
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
addq $-0x8, 0x1f0(%rbx)
movq 0x140(%rbx), %r15
movsd 0x80(%r14), %xmm0
movzbl %bpl, %ecx
leaq 0x18(%rsp), %r12
movq %rsp, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x501a8
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x60(%rax)
leaq 0x18(%rsp), %rdi
callq 0x482e8
movq 0x148(%rbx), %rsi
addq $0x148, %rbx # imm = 0x148
movq %rbx, %rdi
callq 0x4fe98
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x482e8
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::sectionEndedEarly(Catch::SectionEndInfo const&)
|
virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
if( m_unfinishedSections.empty() )
m_activeSections.back()->fail();
else
m_activeSections.back()->close();
m_activeSections.pop_back();
m_unfinishedSections.push_back( endInfo );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1d0(%rdi), %r15
movq 0x1d0(%rdi), %rax
xorl %ecx, %ecx
cmpq 0x1d8(%rdi), %rax
movq 0x1f0(%rdi), %rax
sete %cl
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax,%rcx,8)
addq $-0x8, 0x1f0(%r14)
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x502a8
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&)
|
AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _totals )
{
if( assertionResult.hasMessage() ) {
// Copy message into messages list.
// !TBD This should have been done earlier, somewhere
MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
builder << assertionResult.getMessage();
builder.m_info.message = builder.m_stream.str();
infoMessages.push_back( builder.m_info );
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x306a8(%rip), %rax # 0x7fb18
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x4f71e
leaq 0xc0(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4f83a
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0xf8(%r15)
movups %xmm1, 0xe8(%r15)
movups %xmm0, 0xd8(%r15)
cmpq $0x0, 0xa0(%r15)
je 0x4f630
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x4042a
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x4042a
movq 0x48(%r15), %rax
leaq 0x8(%rsp), %rdx
movq %rax, 0x20(%rdx)
movl 0xb8(%r15), %ecx
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4f8cc
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f537
callq 0x2d360
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f546
callq 0x2d360
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq 0x98(%r15), %rsi
movq 0xa0(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0xc8(%rsp), %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2d420
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f58d
callq 0x2d360
leaq 0xd0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d5a0
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x2d480
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x4f5c2
callq 0x2d360
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x4f8fc
movq 0x329da(%rip), %rsi # 0x81fb0
movq %r15, %rdi
callq 0x2d1d0
leaq 0x138(%rsp), %rbx
movq %rbx, %rdi
callq 0x2d110
movq -0x98(%rbx), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x4f607
callq 0x2d360
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f61d
callq 0x2d360
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f630
callq 0x2d360
addq $0x240, %rsp # imm = 0x240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4f659
jmp 0x4f659
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f65c
callq 0x2d360
jmp 0x4f65c
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x4f926
jmp 0x4f693
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f67f
callq 0x2d360
jmp 0x4f67f
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x4f693
callq 0x2d360
jmp 0x4f693
movq %rax, %r15
movq %r14, %rdi
callq 0x4a870
movq %rbx, %rdi
callq 0x43baa
movq %r15, %rdi
callq 0x2d690
movq %rax, %r15
jmp 0x4f69b
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::AssertionResult::AssertionResult(Catch::AssertionResult const&)
|
AssertionResult( AssertionResult const& ) = default;
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
movq 0x40(%r14), %rax
movq %rax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
movq %rax, 0x48(%rbx)
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movl 0x68(%r14), %eax
movl %eax, 0x68(%rbx)
leaq 0x70(%rbx), %r15
leaq 0x80(%rbx), %r12
movq %r12, 0x70(%rbx)
movq 0x70(%r14), %rsi
movq 0x78(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4042a
leaq 0x90(%rbx), %rdi
leaq 0xa0(%rbx), %rax
movq %rax, 0x90(%rbx)
movq 0x90(%r14), %rsi
movq 0x98(%r14), %rdx
addq %rsi, %rdx
callq 0x4042a
movl 0xb0(%r14), %eax
movl %eax, 0xb0(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x4f806
callq 0x2d360
jmp 0x4f806
movq %rax, %r14
movq %rbx, %rdi
callq 0x49d12
jmp 0x4f832
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4f825
callq 0x2d360
jmp 0x4f825
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4f832
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MessageBuilder::~MessageBuilder()
|
MessageBuilder( std::string const& macroName,
SourceLineInfo const& lineInfo,
ResultWas::OfType type )
: m_info( macroName, lineInfo, type )
{}
|
pushq %rbx
movq %rdi, %rbx
addq $0x78, %rdi
movq 0x3267b(%rip), %rsi # 0x81fb0
callq 0x2d1d0
leaq 0xe8(%rbx), %rdi
callq 0x2d110
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x4f958
callq 0x2d360
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x4f96a
callq 0x2d360
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4f97c
popq %rbx
jmp 0x2d360
popq %rbx
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
SectionTracker* section = CATCH_NULL;
ITracker& currentTracker = ctx.currentTracker();
if( ITracker* childTracker = currentTracker.findChild( name ) ) {
section = dynamic_cast<SectionTracker*>( childTracker );
assert( section );
}
else {
section = new SectionTracker( name, ctx, ¤tTracker );
currentTracker.addChild( section );
}
if( !ctx.completedCycle() && !section->isComplete() ) {
section->open();
}
return *section;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x4ff2b
leaq 0x30529(%rip), %rsi # 0x80418
leaq 0x305e2(%rip), %rdx # 0x804d8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x2d410
movq %rax, %rbx
testq %rax, %rax
jne 0x4ffa4
leaq 0x1a401(%rip), %rdi # 0x6a314
leaq 0x19247(%rip), %rsi # 0x69161
leaq 0x19457(%rip), %rcx # 0x69378
movl $0x1551, %edx # imm = 0x1551
callq 0x2d250
movl $0x60, %edi
callq 0x2d3a0
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x3013a(%rip), %rax # 0x80080
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x4042a
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x304d8(%rip), %rax # 0x80458
movq %rax, (%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
incl 0x8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4ffa4
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x4ffd6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x4ffd6
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4ffd6
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4fffb
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5000e
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x5000e
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::testForMissingAssertions(Catch::Counts&)
|
std::size_t total() const {
return passed + failed + failedButOk;
}
|
movq 0x8(%rsi), %rax
addq (%rsi), %rax
addq 0x10(%rsi), %rax
jne 0x5018f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x108(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x5018b
movq 0x208(%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x50192
xorl %eax, %eax
jmp 0x5019f
xorl %eax, %eax
retq
incq 0x118(%r14)
incq 0x8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/dillonhuff[P]bsim/test/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( _durationInSeconds ),
missingAssertions( _missingAssertions )
{}
|
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 0x2f96a(%rip), %rax # 0x7fb38
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%r14)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rdi, 0x8(%rsp)
callq 0x4042a
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rbx
movq %rbx, 0x28(%r14)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x4042a
leaq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
addq %rsi, %rdx
callq 0x4042a
movq 0x60(%r12), %rax
movq %rax, 0x68(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x70(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x80(%r14)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x88(%r14)
movb %bpl, 0x90(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x5028d
callq 0x2d360
jmp 0x5028d
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x502a0
callq 0x2d360
movq %r14, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::handleUnfinishedSections()
|
void handleUnfinishedSections() {
// If sections ended prematurely due to an exception we stored their
// infos here so we can tear them down outside the unwind process.
for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
itEnd = m_unfinishedSections.rend();
it != itEnd;
++it )
sectionEnded( *it );
m_unfinishedSections.clear();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1d0(%rdi), %rbx
movq 0x1d0(%rdi), %r12
movq 0x1d8(%rdi), %r15
cmpq %r12, %r15
je 0x508d5
movq %rdi, %r14
addq $-0x88, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
cmpq %r12, %r15
jne 0x508bd
movq (%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x509d0
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::TestCaseStats::TestCaseStats(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&, bool)
|
TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
std::string const& _stdOut,
std::string const& _stdErr,
bool _aborting )
: testInfo( _testInfo ),
totals( _totals ),
stdOut( _stdOut ),
stdErr( _stdErr ),
aborting( _aborting )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %r14
leaq 0x2f24b(%rip), %rax # 0x7fb58
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
callq 0x4420a
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x138(%r14)
movups %xmm1, 0x128(%r14)
movups %xmm0, 0x118(%r14)
leaq 0x148(%r14), %r12
leaq 0x158(%r14), %rbx
movq %rbx, 0x148(%r14)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4042a
leaq 0x168(%r14), %rdi
leaq 0x178(%r14), %rax
movq %rax, 0x168(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x4042a
movb %bpl, 0x188(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x509be
callq 0x2d360
jmp 0x509be
movq %rax, %r14
movq (%rsp), %rdi
callq 0x4a020
movq %r14, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/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 );
default: startNewMode( Name, m_pos ); break;
}
}
if( m_mode == Name ) {
if( c == ',' ) {
addPattern<TestSpec::NamePattern>();
addFilter();
}
else if( c == '[' ) {
if( subString() == "exclude:" )
m_exclusion = true;
else
addPattern<TestSpec::NamePattern>();
startNewMode( Tag, ++m_pos );
}
}
else if( m_mode == QuotedName && c == '"' )
addPattern<TestSpec::NamePattern>();
else if( m_mode == Tag && c == ']' )
addPattern<TestSpec::TagPattern>();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x50cf9
movl (%rbx), %eax
cmpl $0x1, %eax
jne 0x50d2a
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x50d87
cmpl $0x2c, %eax
jne 0x50dfe
movq %rbx, %rdi
callq 0x50e08
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x50fdc
movsbl %sil, %eax
cmpl $0x5a, %eax
jg 0x50d4b
cmpl $0x20, %eax
je 0x50dfe
cmpl $0x22, %eax
jne 0x50dd2
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x2, (%rbx)
jmp 0x50dfa
cmpl $0x2, %eax
setne %cl
cmpb $0x22, %sil
setne %dl
orb %cl, %dl
jne 0x50d62
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x50e08
cmpl $0x5b, %eax
je 0x50de9
cmpl $0x7e, %eax
jne 0x50dd2
movb $0x1, 0x4(%rbx)
jmp 0x50dfe
cmpl $0x3, %eax
setne %al
cmpb $0x5d, %sil
setne %cl
orb %al, %cl
jne 0x50dfe
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5105c
leaq 0x18(%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
subq %rdx, %rcx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2d3e0
leaq 0x1863f(%rip), %rsi # 0x693e7
movq %r14, %rdi
callq 0x2d0f0
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x50dc4
callq 0x2d360
testl %ebp, %ebp
je 0x50de5
movq %rbx, %rdi
callq 0x50e08
jmp 0x50de9
movq 0x10(%rbx), %rax
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x50cc4
movb $0x1, 0x4(%rbx)
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::TestSpecParser::addPattern<Catch::TestSpec::NamePattern>()
|
void addPattern() {
std::string token = subString();
if( startsWith( token, "exclude:" ) ) {
m_exclusion = true;
token = token.substr( 8 );
}
if( !token.empty() ) {
Ptr<TestSpec::Pattern> pattern = new T( token );
if( m_exclusion )
pattern = new TestSpec::ExcludedPattern( pattern );
m_currentFilter.m_patterns.push_back( pattern );
}
m_exclusion = false;
m_mode = None;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x2d3e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x185a9(%rip), %rsi # 0x693e7
leaq 0x185aa(%rip), %rdx # 0x693ef
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x43f5c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x50e6f
callq 0x2d360
testb %bpl, %bpl
je 0x50eb2
movb $0x1, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
movq $-0x1, %rcx
callq 0x2d3e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2d480
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x50eb2
callq 0x2d360
cmpq $0x0, 0x30(%rsp)
je 0x50f49
movl $0x40, %edi
callq 0x2d3a0
movq %rax, %r14
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x516a2
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x1, 0x4(%rbx)
jne 0x50f2b
movl $0x18, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x2f021(%rip), %rax # 0x7ff28
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%r14)
testq %rdi, %rdi
je 0x50f1e
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x51444
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x51480
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x50f49
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x0, 0x4(%rbx)
movl $0x0, (%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50f66
callq 0x2d360
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d360
jmp 0x50fa3
jmp 0x50fb5
jmp 0x50fbd
movq %rax, %rbx
movq %r14, %rdi
jmp 0x50f97
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x50fc0
callq 0x2d360
jmp 0x50fc0
jmp 0x50fbd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x50fc0
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x50fc0
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50fd3
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
void Catch::TestSpecParser::addPattern<Catch::TestSpec::TagPattern>()
|
void addPattern() {
std::string token = subString();
if( startsWith( token, "exclude:" ) ) {
m_exclusion = true;
token = token.substr( 8 );
}
if( !token.empty() ) {
Ptr<TestSpec::Pattern> pattern = new T( token );
if( m_exclusion )
pattern = new TestSpec::ExcludedPattern( pattern );
m_currentFilter.m_patterns.push_back( pattern );
}
m_exclusion = false;
m_mode = None;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x2d3e0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x18355(%rip), %rsi # 0x693e7
leaq 0x18356(%rip), %rdx # 0x693ef
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x43f5c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x510c3
callq 0x2d360
testb %bpl, %bpl
je 0x51106
movb $0x1, 0x4(%rbx)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl $0x8, %edx
movq $-0x1, %rcx
callq 0x2d3e0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2d480
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x51106
callq 0x2d360
cmpq $0x0, 0x30(%rsp)
je 0x511b2
movl $0x30, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x2edc3(%rip), %rax # 0x7fef0
movq %rax, (%r14)
movq %r14, %rdi
addq $0x10, %rdi
leaq 0x28(%rsp), %rsi
callq 0x43fe4
movq %r14, 0x8(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
cmpb $0x1, 0x4(%rbx)
jne 0x51194
movl $0x18, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x2edb8(%rip), %rax # 0x7ff28
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%r14)
testq %rdi, %rdi
je 0x51187
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x51444
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x51480
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x511b2
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x0, 0x4(%rbx)
movl $0x0, (%rbx)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x511cf
callq 0x2d360
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d360
jmp 0x5120c
jmp 0x5121e
jmp 0x51226
movq %rax, %rbx
movq %r14, %rdi
jmp 0x51200
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x51229
callq 0x2d360
jmp 0x51229
jmp 0x51226
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x51229
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x51229
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5123c
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::runCurrentTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
m_reporter->sectionStarting( testCaseSection );
Counts prevAssertions = m_totals.assertions;
double duration = 0;
try {
m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
seedRng( *m_config );
Timer timer;
timer.start();
if( m_reporter->getPreferences().shouldRedirectStdOut ) {
StreamRedirect coutRedir( Catch::cout(), redirectedCout );
StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr );
invokeActiveTestCase();
}
else {
invokeActiveTestCase();
}
duration = timer.getElapsedSeconds();
}
catch( TestFailureException& ) {
// This just means the test was aborted due to failure
}
catch(...) {
makeUnexpectedResultBuilder().useActiveException();
}
m_testCaseTracker->close();
handleUnfinishedSections();
m_messages.clear();
Counts assertions = m_totals.assertions - prevAssertions;
bool missingAssertions = testForMissingAssertions( assertions );
if( testCaseInfo.okToFail() ) {
std::swap( assertions.failedButOk, assertions.failed );
m_totals.assertions.failed -= assertions.failedButOk;
m_totals.assertions.failedButOk += assertions.failedButOk;
}
SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
m_reporter->sectionEnded( testCaseSectionStats );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq 0x38(%rdi), %r14
leaq 0xe0(%r14), %r13
leaq 0x40(%r14), %rcx
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x456d2
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
callq *0x48(%rax)
movupd 0x110(%rbx), %xmm0
movapd %xmm0, 0x30(%rsp)
movq 0x120(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x17999(%rip), %rsi # 0x693f7
leaq 0x1799b(%rip), %rdx # 0x69400
leaq 0xb0(%rsp), %rdi
callq 0x3ef3e
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1871e(%rip), %rdx # 0x6a1a0
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x3ef3e
leaq 0x248(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r13, %rdx
movl $0x1, %r8d
callq 0x43968
leaq 0x160(%rbx), %rdi
leaq 0x248(%rsp), %rsi
callq 0x2d480
leaq 0x180(%rbx), %rdi
leaq 0x268(%rsp), %r13
movq %r13, %rsi
callq 0x2d480
movq 0x20(%r13), %rax
movq %rax, 0x1a0(%rbx)
leaq 0x1a8(%rbx), %rdi
leaq 0x290(%rsp), %r13
movq %r13, %rsi
callq 0x2d480
movl 0x20(%r13), %eax
movl %eax, 0x1c8(%rbx)
movq (%r13), %rdi
leaq 0x2a0(%rsp), %rax
cmpq %rax, %rdi
je 0x51b1f
callq 0x2d360
leaq 0x278(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51b35
callq 0x2d360
leaq 0x258(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51b4b
callq 0x2d360
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x51b5a
callq 0x2d360
movq 0xb0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x51b6c
callq 0x2d360
movq 0x108(%rbx), %rdi
callq 0x45552
leaq 0x248(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x2d5c0
movq (%r13), %rbp
movq 0x8(%r13), %r13
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
je 0x51bf6
movq 0x30416(%rip), %rsi # 0x81fc0
leaq 0x248(%rsp), %rdi
movq %r12, %rdx
callq 0x51f1e
movq 0x30427(%rip), %rsi # 0x81fe8
leaq 0xb0(%rsp), %rdi
movq (%rsp), %rdx
callq 0x51f1e
movq %rbx, %rdi
callq 0x51f9e
leaq 0xb0(%rsp), %rdi
callq 0x52014
leaq 0x248(%rsp), %rdi
callq 0x52014
jmp 0x51bfe
movq %rbx, %rdi
callq 0x51f9e
leaq 0x248(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2d5c0
movl (%r15), %eax
movl 0x8(%r15), %ecx
subl %ebp, %eax
imull $0xf4240, %eax, %eax # imm = 0xF4240
subl %r13d, %ecx
addl %eax, %ecx
cvtsi2sd %rcx, %xmm0
divsd 0x16b2f(%rip), %xmm0 # 0x68760
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movq %rbx, %rdi
callq 0x50898
leaq 0x148(%rbx), %rdi
movq 0x148(%rbx), %rsi
callq 0x4fe98
xorpd %xmm0, %xmm0
leaq 0xb0(%rsp), %rsi
movapd %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movdqu 0x110(%rbx), %xmm0
psubq 0x30(%rsp), %xmm0
movdqa %xmm0, (%rsi)
movq 0x120(%rbx), %rax
subq 0x8(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %rbx, %rdi
callq 0x50152
testb $0xc, 0x108(%r14)
je 0x51cd5
movq 0xb8(%rsp), %rcx
movq 0xc0(%rsp), %rdx
movq %rcx, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
subq %rcx, 0x118(%rbx)
addq %rcx, 0x120(%rbx)
movzbl %al, %ecx
leaq 0x248(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movsd (%rsp), %xmm0
callq 0x501a8
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
leaq 0x248(%rsp), %rsi
callq *0x60(%rax)
leaq 0x248(%rsp), %rdi
callq 0x482e8
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51d2f
callq 0x2d360
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51d42
callq 0x2d360
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51d55
callq 0x2d360
addq $0x4e8, %rsp # imm = 0x4E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r13
movq %rax, %r12
leaq 0xb0(%rsp), %rdi
callq 0x52014
jmp 0x51d82
movq %rdx, %r13
movq %rax, %r12
leaq 0x248(%rsp), %rdi
callq 0x52014
jmp 0x51def
jmp 0x51de9
jmp 0x51de9
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
callq 0x482e8
jmp 0x51e9d
jmp 0x51de9
jmp 0x51e9a
jmp 0x51de9
jmp 0x51e9a
movq %rdx, %r13
movq %rax, %r12
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x51dd5
callq 0x2d360
jmp 0x51dd5
movq %rdx, %r13
movq %rax, %r12
movq 0xb0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x51def
callq 0x2d360
jmp 0x51def
movq %rdx, %r13
movq %rax, %r12
movq %r12, %rdi
callq 0x2d170
cmpl $0x2, %r13d
jne 0x51e10
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x2d600
jmp 0x51c36
leaq 0x180(%rbx), %rdx
movq 0x160(%rbx), %rsi
movq 0x1a8(%rbx), %rcx
movl 0x1c8(%rbx), %r8d
leaq 0x1836d(%rip), %r9 # 0x6a1a0
leaq 0x248(%rsp), %rdi
callq 0x46766
leaq 0x248(%rsp), %rdi
movl $0x1, %esi
callq 0x46a38
leaq 0x248(%rsp), %rdi
callq 0x3ee6e
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
callq 0x2d600
jmp 0x51c36
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
callq 0x3ee6e
jmp 0x51e87
movq %rax, %rbx
callq 0x2d600
jmp 0x51e9d
movq %rax, %rdi
callq 0x3ed5c
jmp 0x51e9a
jmp 0x51e9a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3ed68
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Totals::delta(Catch::Totals const&) const
|
Totals delta( Totals const& prevTotals ) const {
Totals diff = *this - prevTotals;
if( diff.assertions.failed > 0 )
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
else
++diff.testCases.passed;
return diff;
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x5218c
xorl %eax, %eax
cmpq $0x0, 0x10(%rbx)
setne %al
shll $0x4, %eax
addq $0x18, %rax
cmpq $0x0, 0x8(%rbx)
movl $0x20, %ecx
cmoveq %rax, %rcx
incq (%rbx,%rcx)
movq %rbx, %rax
popq %rbx
retq
nop
|
/dillonhuff[P]bsim/test/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 0x2d4b0
movq %r15, 0x188(%rbx)
movq (%r12), %rax
addq -0x18(%rax), %r12
leaq 0x18(%rbx), %rsi
movq %r12, %rdi
callq 0x2d6f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x3002e(%rip), %rsi # 0x81fb0
movq %r14, %rdi
callq 0x2d1d0
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x2d110
movq %r15, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::RunContext::invokeActiveTestCase()
|
void invokeActiveTestCase() {
FatalConditionHandler fatalConditionHandler; // Handle signals
m_activeTestCase->invoke();
fatalConditionHandler.reset();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x3041d(%rip), %r15 # 0x823d0
leaq 0x102(%rip), %r14 # 0x520bc
movl (%r12,%r15), %edi
movq %r14, %rsi
callq 0x2d450
addq $0x10, %r12
cmpq $0x60, %r12
jne 0x51fba
movq 0x38(%rbx), %rax
movq 0x110(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
xorl %ebx, %ebx
movl (%rbx,%r15), %edi
xorl %esi, %esi
callq 0x2d450
addq $0x10, %rbx
cmpq $0x60, %rbx
jne 0x51fe3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
callq 0x2d87d
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::StreamRedirect::~StreamRedirect()
|
~StreamRedirect() {
m_targetString += m_oss.str();
m_stream.rdbuf( m_prevBuf );
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x18(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d5a0
movq 0x188(%r14), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2d100
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52059
callq 0x2d360
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2d6f0
movq 0x2ff3d(%rip), %rsi # 0x81fb0
movq %rbx, %rdi
callq 0x2d1d0
subq $-0x80, %r14
movq %r14, %rdi
callq 0x2d110
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x520a9
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x520ac
callq 0x2d360
jmp 0x520ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d0b0
movq %r14, %rdi
callq 0x2d490
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::FatalConditionHandler::handleSignal(int)
|
static void handleSignal( int sig ) {
for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i )
if( sig == signalDefs[i].id )
fatal( signalDefs[i].name, -sig );
fatal( "<unknown signal>", -sig );
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl $0x8, %eax
leaq 0x302ff(%rip), %rcx # 0x823d0
cmpl %ebx, -0x8(%rax,%rcx)
je 0x52120
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x520d1
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17310(%rip), %rsi # 0x69401
leaq 0x17319(%rip), %rdx # 0x69411
leaq 0x8(%rsp), %rdi
callq 0x3ef3e
callq 0x4376b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
jmp 0x5214f
movq (%rax,%rcx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2d160
callq 0x4376b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *0x50(%rcx)
negl %ebx
movl %ebx, %edi
callq 0x2d470
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x52178
jmp 0x52184
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52184
callq 0x2d360
jmp 0x52184
jmp 0x52181
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Totals::operator-(Catch::Totals const&) const
|
Totals operator - ( Totals const& other ) const {
Totals diff;
diff.assertions = assertions - other.assertions;
diff.testCases = testCases - other.testCases;
return diff;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movdqu (%rsi), %xmm0
movdqu (%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, (%rdi)
movdqu 0x10(%rsi), %xmm0
movdqu 0x10(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu 0x20(%rsi), %xmm0
movdqu 0x20(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig const> const&) const
|
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
FactoryMap::const_iterator it = m_factories.find( name );
if( it == m_factories.end() )
return CATCH_NULL;
return it->second->create( ReporterConfig( config ) );
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x52664
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x5259f
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 0x5257c
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x525a1
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x525a1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x525c9
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x525c1
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry()
|
~ExceptionTranslatorRegistry() {
deleteAll( m_translators );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ed05(%rip), %rax # 0x813e0
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x526ff
movq (%r14), %rdi
testq %rdi, %rdi
je 0x526f9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x526e6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x52712
popq %rbx
popq %r14
popq %r15
jmp 0x2d360
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const
|
virtual std::string translateActiveException() const {
try {
#ifdef __OBJC__
// In Objective-C try objective-c exceptions first
@try {
return tryTranslators();
}
@catch (NSException *exception) {
return Catch::toString( [exception description] );
}
#else
return tryTranslators();
#endif
}
catch( TestFailureException& ) {
throw;
}
catch( std::exception& ex ) {
return ex.what();
}
catch( std::string& msg ) {
return msg;
}
catch( const char* msg ) {
return msg;
}
catch(...) {
return "Unknown exception";
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x52856
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x5, %r14d
je 0x527e1
cmpl $0x4, %r14d
jne 0x52777
callq 0x2d170
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2d160
jmp 0x527d7
cmpl $0x3, %r14d
jne 0x5279d
callq 0x2d170
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
jmp 0x527d7
callq 0x2d170
cmpl $0x2, %r14d
jne 0x527ba
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2d160
jmp 0x527d7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16c4f(%rip), %rsi # 0x69417
leaq 0x16c59(%rip), %rdx # 0x69428
movq %rbx, %rdi
callq 0x3ef3e
callq 0x2d600
jmp 0x52736
callq 0x2d170
callq 0x2d520
movq %rax, %rbx
callq 0x2d600
jmp 0x5281b
movq %rax, %rbx
callq 0x2d600
jmp 0x5281b
movq %rax, %rbx
callq 0x2d600
jmp 0x5281b
movq %rax, %rbx
callq 0x2d600
jmp 0x5281b
movq %rax, %rbx
callq 0x2d600
movq %rbx, %rdi
callq 0x2d690
movq %rax, %rdi
callq 0x3ed5c
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11]() const
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %rbx
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
je 0x52879
movq %rdi, %rbx
movq (%rdx), %rsi
addq $0x8, %rdx
movq (%rsi), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0x2d520
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::ReporterRegistry::registerReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IReporterFactory> const&)
|
void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
m_factories.insert( std::make_pair( name, factory ) );
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x52c9c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52a4e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x529e8
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x529fb
callq 0x2d360
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x52a1e
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Context::getGeneratorsForCurrentTest()
|
IGeneratorsForTest& getGeneratorsForCurrentTest() {
IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
if( !generators ) {
std::string testName = getResultCapture()->getCurrentTestName();
generators = createGeneratorsForTest();
m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
}
return *generators;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
callq 0x531e2
movq %rax, %rbx
testq %rax, %rax
jne 0x531a1
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x40(%rcx)
movl $0x50, %edi
callq 0x2d3a0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x30(%rax)
addq $0x10, %rax
leaq 0x2e380(%rip), %rcx # 0x814b0
movq %rcx, (%rbx)
movl $0x0, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x4042a
leaq 0x28(%rsp), %rsi
movq %rbx, 0x20(%rsi)
addq $0x20, %r14
movq %r14, %rdi
callq 0x532c4
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5318e
callq 0x2d360
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x531a1
callq 0x2d360
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x531c7
callq 0x2d360
jmp 0x531c7
jmp 0x531c4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x531da
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Context::findGeneratorsForCurrentTest()
|
IGeneratorsForTest* findGeneratorsForCurrentTest() {
std::string testName = getResultCapture()->getCurrentTestName();
std::map<std::string, IGeneratorsForTest*>::const_iterator it =
m_generatorsByTestName.find( testName );
return it != m_generatorsByTestName.end()
? it->second
: CATCH_NULL;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x40(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x5325c
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x5321e
movq 0x40(%rax), %rbx
jmp 0x53220
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53233
callq 0x2d360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53254
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Ptr<Catch::IConfig const>::operator=(Catch::Ptr<Catch::IConfig const> 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 0x534a8
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x534b9
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3ed5c
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::GeneratorsForTest::~GeneratorsForTest()
|
~GeneratorsForTest() {
deleteAll( m_generatorsInOrder );
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2dfd5(%rip), %rax # 0x814b0
movq %rax, (%rdi)
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0x534ff
movq (%r14), %rdi
testq %rdi, %rdi
je 0x534f9
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x534e6
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5350d
callq 0x2d360
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x53668
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::GeneratorsForTest::getGeneratorInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
if( it == m_generatorsByName.end() ) {
IGeneratorInfo* info = new GeneratorInfo( size );
m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
m_generatorsInOrder.push_back( info );
return *info;
}
return *it->second;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x536e4
leaq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x53562
movq 0x40(%rax), %rax
jmp 0x535fa
movl $0x18, %edi
callq 0x2d3a0
leaq 0x2df85(%rip), %rcx # 0x814f8
movq %rcx, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x4042a
movq 0x8(%rsp), %rax
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x53772
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x535cb
callq 0x2d360
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x535e4
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x535f5
addq $0x38, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5393e
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x53618
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::GeneratorsForTest::moveNext()
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
setne %bl
je 0x5365f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x5365f
addq $0x8, %r14
cmpq %r15, %r14
setne %bl
je 0x5365f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
testb %al, %al
je 0x53646
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::MatcherImpl<Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, 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 $0x28, %edi
callq 0x2d3a0
movq %rax, %r14
movl $0x0, 0x8(%rax)
leaq 0x2d794(%rip), %rax # 0x81540
movq %rax, (%r14)
leaq 0x10(%r14), %rdi
addq $0x10, %r15
movq %r15, %rsi
callq 0x53fdc
movq %r14, (%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d360
movq %rbx, %rdi
callq 0x2d690
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::Generic::AllOf<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::toString() const
|
virtual std::string toString() const {
std::ostringstream oss;
oss << "( ";
for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
if( i != 0 )
oss << " and ";
oss << m_matchers[i]->toString();
}
oss << " )";
return oss.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x2d4b0
leaq 0x15424(%rip), %rsi # 0x6929f
movl $0x2, %edx
movq %r15, %rdi
callq 0x2d420
movq %rbx, 0x8(%rsp)
movq 0x18(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x53f0a
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
leaq 0x15652(%rip), %r13 # 0x69501
testq %rbx, %rbx
je 0x53ec4
movl $0x5, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2d420
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x2d420
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53ef6
callq 0x2d360
incq %rbx
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x3, %rax
cmpq %rax, %rbx
jb 0x53eaf
leaq 0x151d7(%rip), %rsi # 0x690e8
leaq 0x30(%rsp), %rdi
movl $0x2, %edx
callq 0x2d420
movq 0x8(%rsp), %rbx
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d5a0
movq 0x2e077(%rip), %rsi # 0x81fb0
leaq 0x30(%rsp), %rdi
callq 0x2d1d0
leaq 0xa0(%rsp), %rdi
callq 0x2d110
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53f69
jmp 0x53f69
movq %rax, %rbx
jmp 0x53f80
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x53f80
callq 0x2d360
movq 0x2e029(%rip), %rsi # 0x81fb0
leaq 0x30(%rsp), %rdi
callq 0x2d1d0
leaq 0xa0(%rsp), %rdi
callq 0x2d110
movq %rbx, %rdi
callq 0x2d690
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Matchers::Impl::StdString::CasedString::adjustString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
std::string adjustString( std::string const& str ) const {
return m_caseSensitivity == CaseSensitive::No
? toLower( str )
: str;
}
|
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x5410a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x43fe4
jmp 0x54123
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4042a
movq %rbx, %rax
popq %rbx
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testRunStarting(Catch::TestRunInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54256
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x30(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54241
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testGroupStarting(Catch::GroupInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54286
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54271
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testCaseStarting(Catch::TestCaseInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x542b6
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x542a1
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::sectionStarting(Catch::SectionInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x542e6
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x48(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x542d1
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::assertionStarting(Catch::AssertionInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x54316
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54301
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::assertionEnded(Catch::AssertionStats const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x5434f
movq %rsi, %r14
xorl %ebx, %ebx
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
orb %al, %bl
addq $0x8, %r15
cmpq %r12, %r15
jne 0x54336
jmp 0x54351
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::sectionEnded(Catch::SectionStats const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5438c
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x60(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54377
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testCaseEnded(Catch::TestCaseStats const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x543bc
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x68(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x543a7
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testGroupEnded(Catch::TestGroupStats const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x543ec
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x70(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x543d7
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::testRunEnded(Catch::TestRunStats const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5441c
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x78(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54407
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::MultipleReporters::skipTest(Catch::TestCaseInfo const&)
|
Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes )
: m_data( str, caseSensitivity )
{}
|
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
cmpq %r15, %r14
je 0x5444f
movq %rsi, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x80(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x54437
popq %rbx
popq %r14
popq %r15
retq
nop
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::Option<Catch::TestCaseInfo>::reset()
|
void reset() {
if( nullableValue )
nullableValue->~T();
nullableValue = CATCH_NULL;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x5477b
movq 0xe0(%r14), %rdi
leaq 0xf0(%r14), %rax
cmpq %rax, %rdi
je 0x54719
callq 0x2d360
movq 0xc0(%r14), %rdi
leaq 0xd0(%r14), %rax
cmpq %rax, %rdi
je 0x54731
callq 0x2d360
leaq 0x90(%r14), %rdi
callq 0x5242a
leaq 0x60(%r14), %rdi
callq 0x5242a
movq 0x40(%r14), %rdi
leaq 0x50(%r14), %rax
cmpq %rax, %rdi
je 0x54758
callq 0x2d360
movq 0x20(%r14), %rdi
leaq 0x30(%r14), %rax
cmpq %rax, %rdi
je 0x5476a
callq 0x2d360
movq (%r14), %rdi
addq $0x10, %r14
cmpq %r14, %rdi
je 0x5477b
callq 0x2d360
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Catch::XmlWriter::endElement()
|
XmlWriter& endElement() {
newlineIfNecessary();
m_indent = m_indent.substr( 0, m_indent.size()-2 );
if( m_tagIsOpen ) {
stream() << "/>\n";
m_tagIsOpen = false;
}
else {
stream() << m_indent << "</" << m_tags.back() << ">\n";
}
m_tags.pop_back();
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x1(%rdi)
jne 0x547b5
movq 0x40(%rbx), %rdi
leaq 0x159f8(%rip), %rsi # 0x6a19f
movl $0x1, %edx
callq 0x2d420
movb $0x0, 0x1(%rbx)
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2d3e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2d480
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x547ee
callq 0x2d360
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x5480d
leaq 0x14d09(%rip), %rsi # 0x69507
movl $0x3, %edx
callq 0x2d420
movb $0x0, (%rbx)
jmp 0x54859
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x2d420
movq %rax, %r14
leaq 0x14ce7(%rip), %rsi # 0x6950b
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0x2d420
leaq 0x14cbc(%rip), %rsi # 0x69508
movl $0x2, %edx
movq %rax, %rdi
callq 0x2d420
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x54877
callq 0x2d360
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/dillonhuff[P]bsim/test/catch.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.