name string | code string | asm string | file string |
|---|---|---|---|
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&) | void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) {
m_activeSections.back()->close();
m_activeSec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movdqu 0xf8(%rdi), %xmm0
movdqu 0x50(%rsi), %xmm1
psubq %xmm1, %xmm0
movq %rsp, %rsi
movdqa %xmm0, (%rsi)
movq 0x108(%rdi), %rax
subq 0x60(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x1b482
movl %eax, %ebp
movq 0x1b8(%r... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::handleFatalErrorCondition(Catch::StringRef) | void RunContext::handleFatalErrorCondition( StringRef message ) {
// First notify reporter that bad things happened
m_reporter->fatalErrorEncountered(message);
// Don't rebuild the result -- the stringification itself can cause more fatal errors
// Instead, fake a result data.
A... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rdi, %r14
leaq 0x48(%rsp), %rbx
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%ra... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::handleMessage(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::StringRef const&, Catch::AssertionReaction&) | void RunContext::handleMessage(
AssertionInfo const& info,
ResultWas::OfType resultType,
StringRef const& message,
AssertionReaction& reaction
) {
m_reporter->assertionStarting( info );
m_lastAssertionInfo = info;
AssertionResultData data( re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x30(%r12), %eax
movl %eax, 0x190(%r14)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RunContext::handleUnexpectedInflightException(Catch::AssertionInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::AssertionReaction&) | void RunContext::handleUnexpectedInflightException(
AssertionInfo const& info,
std::string const& message,
AssertionReaction& reaction
) {
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
data.mes... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq 0x18(%rsp), %rax
movq %rax, ... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::SectionInfo::SectionInfo(Catch::SourceLineInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SectionInfo::SectionInfo
( SourceLineInfo const& _lineInfo,
std::string const& _name )
: name( _name ),
lineInfo( _lineInfo )
{} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x11710
leaq 0x30(%r14), %rax
movq %rax, 0x20(%r14)
andq $0x0, 0x28(%r14)
movb $0x0, 0x30(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Session::runInternal() | int Session::runInternal() {
if( m_startupExceptions )
return 1;
if (m_configData.showHelp || m_configData.libIdentify) {
return 0;
}
CATCH_TRY {
config(); // Force config to be constructed
seedRng( *m_config );
if( m_config... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
cmpb $0x0, 0x188(%rdi)
je 0x1cca8
pushq $0x1
popq %rbx
jmp 0x1d28d
movq %rdi, %r14
xorl %ebx, %ebx
cmpb $0x0, 0x6f(%rdi)
jne 0x1d28d
cmpb $0x0, 0x72(%r14)
jne 0x1d28d
movq %r14, %rdi
callq 0x1c6f4
movq 0x178(%r1... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&) | RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
CATCH_TRY {
getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
callq 0x2aab4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x111f0
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %r15, %rsi
callq 0x111f0
addq $0x8, %r14
movq (%r14), %rax
le... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::TagAliasRegistry::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
auto it = m_registry.find( alias );
if( it != m_registry.end() )
return &(it->second);
else
return nullptr;
} | pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x47ada
addq $0x10, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
nop
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::(anonymous namespace)::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
if( startsWith( tag, '.' ) ||
tag == "!hide" )
return TestCaseInfo::IsHidden;
else if( tag == "!throws" )
return TestCaseInfo::Throws;
else if( tag == "!shouldf... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
pushq $0x2
popq %rbp
je 0x1e0c1
movq (%rbx), %rax
cmpb $0x2e, (%rax)
je 0x1e12f
leaq 0x32696(%rip), %rsi # 0x5075e
movq %rbx, %rdi
callq 0x2d2b4
testb %al, %al
jne 0x1e12f
leaq 0x33c7f(%rip), %rsi # 0x51d5a
movq %rbx, %rdi
callq 0x2d2b4
testb... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::setTags(Catch::TestCaseInfo&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>) | void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
std::sort(begin(tags), end(tags));
tags.erase(std::unique(begin(tags), end(tags)), end(tags));
testCaseInfo.lcaseTags.clear();
for( auto const& tag : tags ) {
std::string lcaseTag = toLower( tag );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x48003
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x48742
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ce9c
leaq 0x78(%r14), %r15
movq %r15,... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::sortTests(Catch::IConfig const&, std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&) | std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
switch( config.runOrder() ) {
case RunTests::InDeclarationOrder:
// already in declaration order
break;
case RunTests::InLexicographicalOrder: {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x80(%rax)
cmpl $0x2, %eax
je 0x1e41d
movq %r13, %rdi
movq %r14, %rsi
cmpl $0x1, %eax
jne 0x1e4e0
callq 0x2cfde
movq (%r13), %rdi
movq 0x8(%r13), %r... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::extractClassName[abi:cxx11](Catch::StringRef const&) | std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
std::string className(classOrQualifiedMethodName);
if( startsWith( className, '&' ) )
{
std::size_t lastColons = className.rfind( "::" );
std::size_t penultimateColons = className.rfind( "::", l... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2b2d6
cmpq $0x0, 0x8(%rbx)
je 0x1eab8
movq (%rbx), %rax
cmpb $0x26, (%rax)
jne 0x1eab8
leaq 0x31d5c(%rip), %r14 # 0x507c2
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11860
movq %rax, %r15
leaq -0x1(%rax), %rdx
movq %rbx, %rd... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::TestCaseTracking::SectionTracker::isComplete() const | bool SectionTracker::isComplete() const {
bool complete = true;
if (m_filters.empty()
|| m_filters[0] == ""
|| std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
complete = TrackerBase::isComplete();
}
return complete;... | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
cmpq 0x70(%rbx), %rdi
je 0x1f108
leaq 0x30d86(%rip), %rsi # 0x4fe6b
callq 0x2d2b4
testb %al, %al
jne 0x1f108
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
leaq 0x80(%rbx), %rdx
callq 0x467bc
cmpq 0x70(%rbx), %rax
je 0x1f116
movl 0x60(%rbx), %eax
andl $-0x2, %eax
cmpl $... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::TestSpecParser::processNoneChar(char) | bool TestSpecParser::processNoneChar( char c ) {
switch( c ) {
case ' ':
return true;
case '~':
m_exclusion = true;
return false;
case '[':
startNewMode( Tag );
return false;
case '"':
startNewMode( QuotedNam... | cmpl $0x20, %esi
je 0x1fa20
cmpl $0x22, %esi
je 0x1fa10
cmpl $0x5b, %esi
je 0x1fa18
cmpl $0x7e, %esi
jne 0x1fa23
movb $0x1, 0x8(%rdi)
jmp 0x1fa29
movl $0x2, (%rdi)
jmp 0x1fa29
movl $0x3, (%rdi)
jmp 0x1fa29
movb $0x1, %al
retq
movl $0x1, (%rdi)
xorl %eax, %eax
retq
| /Neargye[P]scope_guard/test/3rdparty/Catch2/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;
}
uns... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x1d558
movq 0x10(%r15), %r15
leaq 0x30877(%rip), %rsi # 0x50929
movq %r15, %rdi
callq 0x11530
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x117d0
movq (%r15), %rax
movq... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long) | std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1d558
movq 0x10(%r14), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x11390
cmpq $0x100, %r15 # imm = 0x100
jb 0x205fe
leaq 0x3035e(%rip), %rsi # 0x50927
movq %r14, %rdi
callq 0x11... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::Totals::operator-(Catch::Totals const&) const | Totals Totals::operator - ( Totals const& other ) const {
Totals diff;
diff.assertions = assertions - other.assertions;
diff.testCases = testCases - other.testCases;
return diff;
} | movq %rdi, %rax
andl $0x0, (%rdi)
movdqu 0x8(%rsi), %xmm0
movdqu 0x8(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x8(%rdi)
movdqu 0x18(%rsi), %xmm0
movdqu 0x18(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x18(%rdi)
movdqu 0x28(%rsi), %xmm0
movdqu 0x28(%rdx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x28(%rdi)
retq
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlWriter::writeAttribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
if( !name.empty() && !attribute.empty() )
m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x21174
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x21174
movq %rsi, %r15
movq 0x40(%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x11640
movq %rax, %rdi
movq %r15, %rsi
callq 0x114e0
leaq 0x2f879(%rip), %rsi # 0x509ad
movq... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlWriter::writeComment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting) | XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
ensureTagClosed();
if (shouldIndent(fmt)) {
m_os << m_indent;
}
m_os << "<!--" << text << "-->";
applyFormatting(fmt);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x21086
testb $0x1, %bl
je 0x2121c
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %rsi
callq 0x114e0
movq 0x40(%r14), %rdi
leaq 0x2f758(%rip), %rsi # 0x5097f
callq 0x11530
movq %rax, %rdi
movq %r15, %rsi
callq 0x114e0
leaq 0x2f746(%rip),... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::ConsoleReporter::lazyPrintRunInfo() | void ConsoleReporter::lazyPrintRunInfo() {
stream << '\n' << getLineOfChars<'~'>() << '\n';
Colour colour(Colour::SecondaryText);
stream << currentTestRunInfo->name
<< " is a Catch v" << libraryVersion() << " host application.\n"
<< "Run with -? for options\n\n";
if (m_config->rngSeed()... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
pushq $0xa
popq %rsi
callq 0x11640
cmpb $0x0, 0x5e76a(%rip) # 0x81f70
jne 0x23839
movaps 0x2a871(%rip), %xmm0 # 0x4e080
movups %xmm0, 0x5e799(%rip) # 0x81faf
movaps %xmm0, 0x5e783(%rip) # 0x81fa0
movaps %xmm0, 0x5e76c(%rip) # 0x81f90... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::ConsoleReporter::printClosedHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ConsoleReporter::printClosedHeader(std::string const& _name) {
printOpenHeader(_name);
stream << getLineOfChars<'.'>() << '\n';
} | pushq %rbx
movq %rdi, %rbx
callq 0x23bc2
movq 0x18(%rbx), %rdi
cmpb $0x0, 0x5e44a(%rip) # 0x81fc0
jne 0x23ba9
movaps 0x2a511(%rip), %xmm0 # 0x4e090
movups %xmm0, 0x5e479(%rip) # 0x81fff
movaps %xmm0, 0x5e463(%rip) # 0x81ff0
movaps %xmm0, 0x5e44c(%rip) # 0x81fe0
movaps %xmm0, 0x5e435(%rip) # 0x81fd0
m... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
std::size_t i = _string.find(": ");
if (i != std::string::npos)
i += 2;
else
i = 0;
stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2ca09(%rip), %rsi # 0x50688
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x119f0
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
movq %rsp, %r12
mov... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::JunitReporter::writeSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CumulativeReporterBase<Catch::JunitReporter>::SectionNode const&) | void JunitReporter::writeSection( std::string const& className,
std::string const& rootName,
SectionNode const& sectionNode ) {
std::string name = trim( sectionNode.stats.sectionInfo.name );
if( !rootName.empty() )
name = rootName + '/' + name... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, 0x50(%rsp)
leaq 0x10(%rcx), %rsi
leaq 0x68(%rsp), %rdi
callq 0x16199
cmpq $0x0, 0x8(%r12)
je 0x24b25
leaq 0x30(%rsp), %rdi
pushq $0x2f
popq %rdx
movq %r12, %rsi
callq 0x2e556
lea... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::ListeningReporter::assertionEnded(Catch::AssertionStats const&) | bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
for( auto const& listener : m_listeners ) {
static_cast<void>( listener->assertionEnded( assertionStats ) );
}
return m_reporter->assertionEnded( assertionStats );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x255b5
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r15
jmp 0x2559e
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
mov... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlReporter::XmlReporter(Catch::ReporterConfig const&) | XmlReporter::XmlReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config ),
m_xml(_config.stream())
{
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e73a
leaq 0x5819e(%rip), %rax # 0x7d8f0
movq %rax, (%rbx)
andq $0x0, 0x168(%rbx)
leaq 0x170(%rbx), %rdi
movq (%r14), %rsi
callq 0x20f36
andl $0x0, 0x1b8(%rbx)
movw $0x101, 0x160(%rbx) # imm = 0x101
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlReporter::assertionEnded(Catch::AssertionStats const&) | bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
AssertionResult const& result = assertionStats.assertionResult;
bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
if( includeResults || result.getResultType() == ResultWas::Warning ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %dl
testb %al, %al
jne 0x25efa
movl 0x90(%rbx), %eax
testb $0x10, %al
je 0x25eef
movl 0x38(%rbx), %ecx
andl $0x8, %ecx
je 0x25efa
cmpl $0... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) | void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
StreamingReporterBase::sectionEnded( sectionStats );
if( --m_sectionDepth > 0 ) {
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes", sectionStats.assertions.pass... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x148, %rdi # imm = 0x148
callq 0x3588c
movl 0x1b8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1b8(%r15)
cmpl $0x2, %eax
jl 0x265db
leaq 0x2a9d5(%rip), %rsi # 0x50e8b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp),... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::use(Catch::Colour::Code) | void use( Colour::Code _colourCode ) override {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32... | pushq %rbx
subq $0x50, %rsp
cmpl $0x17, %esi
ja 0x28e2f
movl %esi, %eax
leaq 0x2545f(%rip), %rcx # 0x4e1a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2897a(%rip), %rdi # 0x516d3
jmp 0x28dbc
leaq 0x289b4(%rip), %rdi # 0x51716
jmp 0x28dbc
leaq 0x28996(%rip), %rdi # 0x51701
jmp 0x28dbc
le... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_7>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x112d0
leaq 0xa8(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x55f0e(%rip), %r12 # 0x7f638
movq %r... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BoundFlagLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_8>::setFlag(bool) | auto setFlag( bool flag ) -> ParserResult override {
return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movl $0x1, 0xc(%rcx)
andq $0x0, 0x8(%rdi)
leaq 0x55d1c(%rip), %rcx # 0x7f638
movq %rcx, (%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
nop
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_6>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x112d0
leaq 0xa0(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x554f0(%rip), %r15 # 0x7f638
movq %r15, -0x20(%rax)
... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_4>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x112d0
leaq 0xa0(%rsp), %rax
andq $0x0, -0x18(%rax)
leaq 0x54f08(%rip), %r15 # 0x7f638
movq %r15, -0x20(%rax)
... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::Arg::Arg<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::allocator<char>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::allocator<char>>>&, std::allocator<char> const... | auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
auto validationResult = validate();
if( !validationResult )
return InternalParseResult( validationResult );
auto remainingTokens = tokens;
auto const &tok... | pushq %rbx
movq %rdi, %rbx
callq 0x30d1c
leaq 0x541f0(%rip), %rax # 0x7f918
movq %rax, (%rbx)
popq %rbx
retq
nop
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::StringStreams::add() | auto add() -> std::size_t {
if( m_unused.empty() ) {
m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
return m_streams.size()-1;
}
else {
auto index = m_unused.back();
m_unused.pop_ba... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
je 0x2ccd1
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x2cd11
movl $0x178, %edi # imm = 0x178
callq 0x11540
movq %rax, %r14
movq %rax, %rdi
callq 0x11700
movq %rsp, %rsi
movq %r14, (%rsi)
movq %... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::SummaryColumn::addRow(unsigned long) | SummaryColumn addRow( std::size_t count ) {
ReusableStringStream rss;
rss << count;
std::string row = rss.str();
for (auto& oldRow : rows) {
while (oldRow.size() < row.size())
oldRow = ' ' + oldRow;
while (oldRow.size() > row.size())
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x1d558
movq 0x10(%rbx), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x113a0
movq %r12, 0x8(%rsp)
addq $0x8, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx,... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [4]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x1d558
movq 0x10(%r15), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x11530
addq $0x8, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x117e0
movq %rsp, %rdx
movq %rbx, %r... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::StreamingReporterBase<Catch::XmlReporter>::StreamingReporterBase(Catch::ReporterConfig const&) | StreamingReporterBase( ReporterConfig const& _config )
: m_config( _config.fullConfig() ),
stream( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = false;
if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
CATCH_ERRO... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x515a4(%rip), %rax # 0x7fcf8
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
addq $0x8, %rsi
movq %r14, %rdi
callq 0x3195c
movq (%r15), %rax
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
xorl %eax, %eax
movb %al, 0x48... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::testRunEnded(Catch::TestRunStats const&) | void testRunEnded(TestRunStats const& testRunStats) override {
auto node = std::make_shared<TestRunNode>(testRunStats);
node->children.swap(m_testGroups);
m_testRuns.push_back(node);
testRunEndedCumulative();
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4d328
movq (%r14), %rdi
addq $0x70, %rdi
leaq 0x68(%rbx), %rsi
callq 0x4d59c
leaq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x4d346
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x90(%rax)
leaq 0x10(%rsp), %rdi
callq 0x2fab8
add... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::TokenStream::loadBuffer() | void loadBuffer() {
m_tokenBuffer.resize( 0 );
// Skip any empty strings
while( it != itEnd && it->empty() )
++it;
if( it != itEnd ) {
auto const &next = *it;
if( isOptPrefix( next[0] ) ) {
auto delimit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30806
movq (%r15), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x3070f
cmpq $0x0, 0x8(%r14)
jne 0x305c3
addq $0x20, %r14
movq %r14, (%r15)
jmp 0x305aa
movq (%... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BoundFlagRef::setFlag(bool) | auto setFlag( bool flag ) -> ParserResult override {
m_ref = flag;
return ParserResult::ok( ParseResultType::Matched );
} | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movb %dl, (%rcx)
andq $0x0, 0x8(%rdi)
leaq 0x4e931(%rip), %rcx # 0x7f638
movq %rcx, (%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
| /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::Parser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::clara::detail::TokenStream const&) const | auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
struct ParserInfo {
ParserBase const* parser = nullptr;
size_t count = 0;
};
const size_t totalParsers = m_options.size() + m_args.size();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2148, %rsp # imm = 0x2148
movq %rcx, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x30(%rsi), %rbx
movq 0x38(%rsi), %r12
movq %r12, %rax
subq %rbx, %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x50(%rsi)... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::TextFlow::Column::iterator::calcLength() | void calcLength() {
assert(m_stringIndex < m_column.m_strings.size());
m_suffix = false;
auto width = m_column.m_width - indent();
m_end = m_pos;
if (line()[m_pos] == '\n') {
++m_end;
}
while (m_end < line().size() && line()[m_end] != '\n')
++m_end;
if (m_end < m_pos + width) {
m_l... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %rcx, 0x8(%rdi)
jae 0x31c6a
movq %rdi, %rbx
movb $0x0, 0x28(%rdi)
movq 0x18(%rax), %r14
callq 0x31c8a
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
mo... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::TextFlow::Columns::iterator::operator++() | auto operator ++() -> iterator& {
for (size_t i = 0; i < m_columns.size(); ++i) {
if (m_iterators[i] != m_columns[i].end())
++m_iterators[i];
}
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
xorl %r12d, %r12d
pushq $0x30
popq %r13
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %rax, %rbp
jae 0x323d8
movq ... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::TextFlow::Columns::iterator::iterator(Catch::clara::TextFlow::Columns const&, Catch::clara::TextFlow::Columns::iterator::EndTag) | iterator(Columns const& columns, EndTag)
: m_columns(columns.m_columns),
m_activeIterators(0) {
m_iterators.reserve(m_columns.size());
for (auto const& col : m_columns)
m_iterators.push_back(col.end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3247a
mo... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
trompeloeil::list_elem<trompeloeil::call_matcher_base<void ()>>::invariant_check() const | void
invariant_check()
const
noexcept
{
#ifdef TROMPELOEIL_SANITY_CHECKS
TROMPELOEIL_ASSERT(next->prev == this);
TROMPELOEIL_ASSERT(prev->next == this);
TROMPELOEIL_ASSERT((next == this) == (prev == this));
TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
TROMPEL... | pushq %rax
movq 0x8(%rdi), %rdx
cmpq %rdi, 0x10(%rdx)
jne 0x35ef5
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rax
cmpq %rdi, %rax
jne 0x35f14
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
xorb %sil, %r8b
jne 0x35f33
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
cmpb %sil, %r8b
jne 0x35e1c
movq 0x8(%rdx), %rsi
cm... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
std::unique_lock<std::recursive_mutex> trompeloeil::get_lock<void>() | unique_lock<std::recursive_mutex> get_lock()
{
// Ugly hack for lifetime of mutex. The statically allocated
// recursive_mutex is intentionally leaked, to ensure that the
// mutex is available and valid even if the last use is from
// the destructor of a global object in a translation unit
// with... | pushq %rbx
movq %rdi, %rbx
movb 0x4becf(%rip), %al # 0x81ec8
testb %al, %al
je 0x36011
movq 0x4bebc(%rip), %rsi # 0x81ec0
movq %rbx, %rdi
callq 0x36076
movq %rbx, %rax
popq %rbx
retq
leaq 0x4beb0(%rip), %rdi # 0x81ec8
callq 0x11920
testl %eax, %eax
je 0x35ffd
xorps %xmm0, %xmm0
movups %xmm0, 0x4be7d(%rip) ... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::list_elem<trompeloeil::condition_base<void ()>>::unlink() | void
unlink()
noexcept
{
invariant_check();
auto n = next;
auto p = prev;
n->prev = p;
p->next = n;
next = this;
prev = this;
invariant_check();
} | pushq %rbx
movq %rdi, %rbx
callq 0x36692
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rcx)
movq %rbx, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x36692
| /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::list_elem<trompeloeil::condition_base<void ()>>::invariant_check() const | void
invariant_check()
const
noexcept
{
#ifdef TROMPELOEIL_SANITY_CHECKS
TROMPELOEIL_ASSERT(next->prev == this);
TROMPELOEIL_ASSERT(prev->next == this);
TROMPELOEIL_ASSERT((next == this) == (prev == this));
TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
TROMPEL... | pushq %rax
movq 0x8(%rdi), %rdx
cmpq %rdi, 0x10(%rdx)
jne 0x3681b
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rax
cmpq %rdi, %rax
jne 0x3683a
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
xorb %sil, %r8b
jne 0x36859
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
cmpb %sil, %r8b
jne 0x36742
movq 0x8(%rdx), %rsi
cm... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::sequence_type::cost(trompeloeil::sequence_matcher const*) const | const
noexcept
{
unsigned sequence_cost = 0U;
for (auto& e : matchers)
{
if (&e == m) return sequence_cost;
if (!e.is_satisfied())
{
return ~0U;
}
++sequence_cost;
}
return ~0U;
} | xorl %ecx, %ecx
pushq $-0x1
popq %rax
movq %rdi, %rdx
movq 0x8(%rdx), %rdx
cmpq %rdi, %rdx
je 0x372c2
cmpq %rsi, %rdx
je 0x372c0
movq 0x38(%rdx), %r8
movq 0x18(%r8), %r9
cmpq 0x8(%r8), %r9
jb 0x372c2
incl %ecx
jmp 0x372a0
movl %ecx, %eax
retq
nop
| /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::list_elem<trompeloeil::sequence_matcher>::invariant_check() const | void
invariant_check()
const
noexcept
{
#ifdef TROMPELOEIL_SANITY_CHECKS
TROMPELOEIL_ASSERT(next->prev == this);
TROMPELOEIL_ASSERT(prev->next == this);
TROMPELOEIL_ASSERT((next == this) == (prev == this));
TROMPELOEIL_ASSERT((prev->next == next) == (next == this));
TROMPEL... | pushq %rax
movq 0x8(%rdi), %rdx
cmpq %rdi, 0x10(%rdx)
jne 0x37477
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rax
cmpq %rdi, %rax
jne 0x37496
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
xorb %sil, %r8b
jne 0x374b5
cmpq %rdi, %rdx
sete %sil
cmpq %rdi, %rcx
sete %r8b
cmpb %sil, %r8b
jne 0x3739e
movq 0x8(%rdx), %rsi
cm... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::return_of<void ()>::type trompeloeil::mock_func<false, void ()>(std::integral_constant<bool, true>, trompeloeil::expectations<false, void ()>&, char const*, char const*) | return_of_t<Sig>
mock_func(std::true_type,
expectations<movable, Sig>& e,
char const *func_name,
char const *sig_name,
P&& ... p)
{
auto lock = get_lock();
call_params_type_t<void(P...)> param_value(std::forward<P>(p)...);
auto i = find(e.active, param_v... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x35fef
leaq 0x6(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x37a5d
testq %rax, %rax
je 0x37994
movq %rax, %r15
movq %rbx, %rdi
callq 0x37c11
movq 0x... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
trompeloeil::trace_agent::~trace_agent() | ~trace_agent()
{
if (t)
{
t->trace(loc.file, loc.line, os.str());
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x37da7
movq (%rbx), %r15
movq 0x8(%rbx), %r12
leaq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x117e0
movq (%r14), %rax
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r... | /Neargye[P]scope_guard/test/3rdparty/Trompeloeil/trompeloeil.hpp |
Catch::BinaryExpr<char const* const&, int const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x37fa0
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x37fb1
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14,... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::convertInto(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&) | inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
std::string srcLC = source;
std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( unsigned char c ) { return static_cast<char>( std::tolower(c) ); } );
if (srcLC == "y" || srcLC == "1" || srcLC == "true... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x11710
movq (%r12), %rdi
movq 0x8(%r12), %rsi
addq %rdi, %rsi
movq %rdi, %rdx
callq 0x3904d
leaq 0x16cf8(%rip), %rsi # 0x4fbc2
movq %rsp, %rdi
callq 0x2d2b4
... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&) | inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
std::stringstream ss;
ss << source;
ss >> target;
if( ss.fail() )
return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
else
return P... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x113e0
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x114e0
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x11370
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5,... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::ParserRefImpl<unsigned int>(unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x4616a(%rip), %rax # 0x7f840
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x3973c
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%rbx)
andq $0x0, -0x8(%rdi)
callq 0x2fab8
leaq 0x20(%rbx),... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::ParserRefImpl<long>(long&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ParserRefImpl( T &ref, std::string const &hint )
: m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
m_hint( hint )
{} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x45f7c(%rip), %rax # 0x7f840
movq %rax, (%rdi)
andl $0x0, 0x8(%rdi)
movq %rsp, %rdi
callq 0x3992a
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, 0x10(%rbx)
andq $0x0, -0x8(%rdi)
callq 0x2fab8
leaq 0x20(%rbx),... | /Neargye[P]scope_guard/test/3rdparty/Catch2/catch.hpp |
stbi_info_from_callbacks | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__info_main(&s,x,y,comp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %r12
movq %rax, -0x18(%r12)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%r12)
movq %rsi, -0x10(%r12)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%r12)
... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__idct_simd(unsigned char*, int, short*) | static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64])
{
// This is constructed to match our regular (generic) integer IDCT exactly.
__m128i row0, row1, row2, row3, row4, row5, row6, row7;
__m128i tmp;
// dot product constant: even elems=x, odd elems=y
#define dct_const(x,y) _mm_setr... | movdqa (%rdx), %xmm2
movdqa 0x10(%rdx), %xmm3
movdqa 0x20(%rdx), %xmm15
movdqa 0x30(%rdx), %xmm10
movdqa 0x40(%rdx), %xmm0
movdqa 0x50(%rdx), %xmm9
movdqa 0x60(%rdx), %xmm1
movdqa 0x70(%rdx), %xmm4
movdqa %xmm15, %xmm12
punpcklwd %xmm1, %xmm12 # xmm12 = xmm12[0],xmm1[0],xmm12[1],xmm1[1],xmm12[2],xmm1[2],xmm12[3],xmm1... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__YCbCr_to_RGB_simd(unsigned char*, unsigned char const*, unsigned char const*, unsigned char const*, int, int) | static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step)
{
int i = 0;
#ifdef STBI_SSE2
// step == 3 is pretty ugly on the final interleave, and i'm not convinced
// it's useful in practice (you wouldn't use it for textures, for example).
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x4, %r9d
setne %al
cmpl $0x8, %r8d
setl %r10b
xorl %r11d, %r11d
orb %al, %r10b
movl %r8d, %eax
jne 0x1a0ad
xorl %r11d, %r11d
movdqa 0x18260(%rip), %xmm0 # 0x32220
movdqa 0x18268(%rip), %xmm1 # 0x32230
movdqa 0x18270(%rip), %xmm2 # 0x32240
movdqa 0x1... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__get_marker(stbi__jpeg*) | static stbi_uc stbi__get_marker(stbi__jpeg *j)
{
stbi_uc x;
if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; }
x = stbi__get8(j->s);
if (x != 0xff) return STBI__MARKER_none;
while (x == 0xff)
x = stbi__get8(j->s); // consume repeated 0xff fill bytes
r... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x4828(%rdi), %al
cmpb $-0x1, %al
je 0x1a346
movb $-0x1, 0x4828(%rbx)
jmp 0x1a43b
movq (%rbx), %r15
movq 0xb8(%r15), %rax
cmpq 0xc0(%r15), %rax
jae 0x1a368
leaq 0x1(%rax), %rcx
movq %rcx, 0xb8(%r15)
movb (%rax), %cl
jmp 0x1a3bc
cmpl $0x0, 0x30(%r15)
je 0x1a390
movq ... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__process_frame_header(stbi__jpeg*, int) | static int stbi__process_frame_header(stbi__jpeg *z, int scan)
{
stbi__context *s = z->s;
int Lf,p,i,q, h_max=1,v_max=1,c;
Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq 0x1b2f0
cmpl $0xa, %eax
ja 0x1ac5d
leaq 0x1841b(%rip), %rax # 0x33073
jmp 0x1b22d
movl %eax, %r15d
movq 0xb8(%r14), %rax
cmpq 0xc0(%r14), %rax
jae 0x1ac7f
leaq 0... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__get16be(stbi__context*) | static int stbi__get16be(stbi__context *s)
{
int z = stbi__get8(s);
return (z << 8) + stbi__get8(s);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xb8(%rdi), %rcx
movq 0xc0(%rdi), %rax
cmpq %rax, %rcx
jae 0x1b31d
leaq 0x1(%rcx), %rdx
movq %rdx, 0xb8(%rbx)
movb (%rcx), %bpl
movq %rdx, %rcx
jmp 0x1b369
cmpl $0x0, 0x30(%rbx)
je 0x1b342
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %r14
movl 0x34(%rbx), %edx
movq %r14, ... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__build_huffman(stbi__huffman*, int*) | static int stbi__build_huffman(stbi__huffman *h, int *count)
{
int i,j,k=0;
unsigned int code;
// build size list for each symbol (from JPEG spec)
for (i=0; i < 16; ++i)
for (j=0; j < count[i]; ++j)
h->size[k++] = (stbi_uc) (i+1);
h->size[k] = 0;
// compute actual symbols (from jpeg sp... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x500(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x0, (%rsi,%rcx,4)
jle 0x1b40e
leal 0x1(%rcx), %edi
movslq %edx, %r8
addq %rax, %r8
xorl %r9d, %r9d
movb %dil, (%r8,%r9)
incq %r9
cmpl (%rsi,%rcx,4), %r9d
jl 0x1b3fe
addl %r9d, %edx
incq %rcx
cmpq $0x10, %rcx
j... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__mad3sizes_valid(int, int, int, int) | static int stbi__mad3sizes_valid(int a, int b, int c, int add)
{
return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) &&
stbi__addsizes_valid(a*b*c, add);
} | xorl %r9d, %r9d
movl %esi, %eax
orl %edi, %eax
js 0x1b5d6
movl %edx, %r8d
testl %esi, %esi
je 0x1b59d
xorl %r9d, %r9d
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %esi
cmpl %edi, %eax
jl 0x1b5d6
imull %edi, %esi
movl %esi, %eax
orl %r8d, %eax
movl $0x0, %r9d
js 0x1b5d6
testl %r8d, %r8d
je 0x1b5c... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__resample_row_v_2(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate two samples vertically for every one in input
int i;
STBI_NOTUSED(hs);
for (i=0; i < w; ++i)
out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2);
return out;
} | movq %rdi, %rax
testl %ecx, %ecx
jle 0x1b708
movl %ecx, %ecx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
leal (%r8,%r8,2), %r8d
movzbl (%rdx,%rdi), %r9d
addl %r9d, %r8d
addl $0x2, %r8d
shrl $0x2, %r8d
movb %r8b, (%rax,%rdi)
incq %rdi
cmpq %rdi, %rcx
jne 0x1b6e3
retq
| /susonthapa[P]3d-chair/src/stb_image.h |
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
} | movq %rdi, %rax
testl %ecx, %ecx
jle 0x1bd03
pushq %rbp
pushq %rbx
movl %r8d, %edx
movl %ecx, %ecx
leal 0xf(%r8), %edi
andl $-0x10, %edi
leaq -0x1(%rdx), %r9
movq %r9, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, -0x18(%rsp)
leaq 0xf(%rax), %r9
xorl %r10d, %r10d
movdqa 0x16962(%rip), %xmm9 ... | /susonthapa[P]3d-chair/src/stb_image.h |
stbi__gif_load_next(stbi__context*, stbi__gif*, int*, int, unsigned char*) | static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back)
{
int dispose;
int first_frame;
int pi;
int pcount;
// on first frame, any non-written pixels get the background colour (non-transparent)
first_frame = 0;
if (g->out == 0) {
if (!s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x1f402
movl 0x4(%r14), %eax
movl 0x30(%r14), %esi
shrl $0x2, %esi
andl $0x7, %esi
imull (%r14), %eax
cmpl $0x3, %esi
movl $0x2, %edx
cmovnel %esi, %edx
testq %rcx,... | /susonthapa[P]3d-chair/src/stb_image.h |
Shader::checkCompileErrors(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void checkCompileErrors(GLuint shader,string type)
{
GLint success;
GLchar infoLog[1024];
if(type != "PROGRAM")
{
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if(!success)
{
glGetShaderInfoLog(shader, 1024, NULL, infoLog);
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp # imm = 0x410
movq %rdx, %rbx
movl %esi, %ebp
leaq 0x11022(%rip), %rsi # 0x33a7f
movq %rdx, %rdi
callq 0xe190
testl %eax, %eax
je 0x22ab7
leaq 0x1ff28(%rip), %rax # 0x42998
leaq 0xc(%rsp), %r14
movl %ebp, %edi
movl $0x8b81, %esi # imm = 0x8... | /susonthapa[P]3d-chair/src/Shader.h |
Cube::setupFrontFace() | void setupFrontFace() {
float frontFace[]={
x,y,z+b,
x+l,y,z+b,
x+l,y+h,z+b,
x+l,y+h,z+b,
x,y,z+b,
x,y+h,z+b
};
arrayCopy(frontFace,positionData,0);
} | movsd 0x480(%rdi), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
movss 0x494(%rdi), %xmm2
addss %xmm1, %xmm2
movsd 0x48c(%rdi), %xmm3
movss 0x488(%rdi), %xmm4
movlhps %xmm0, %xmm4 # xmm4 = xmm4[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm4 # xmm4 = xmm4[2,0],xmm0[2,3]
addp... | /susonthapa[P]3d-chair/src/main.cpp |
Cube::setupLeftFace() | void setupLeftFace() {
float leftFace[]={
x,y,z,
x,y+h,z,
x,y+h,z+b,
x,y,z,
x,y+h,z+b,
x,y,z+b
};
arrayCopy(leftFace,positionData,36);
} | movss 0x480(%rdi), %xmm0
movss %xmm0, 0x90(%rdi)
movss %xmm0, 0x9c(%rdi)
movss %xmm0, 0xa8(%rdi)
movsd 0x484(%rdi), %xmm1
movsd 0x490(%rdi), %xmm2
shufps $0xe1, %xmm2, %xmm2 # xmm2 = xmm2[1,0,2,3]
addps %xmm1, %xmm2
movsd %xmm1, 0x94(%rdi)
movss %xmm2, 0xa0(%rdi)
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 #... | /susonthapa[P]3d-chair/src/main.cpp |
Cube::setupRightFace() | void setupRightFace() {
float rightFace[]={
x+l,y,z+b,
x+l,y,z,
x+l,y+h,z,
x+l,y,z+b,
x+l,y+h,z,
x+l,y+h,z+b
};
arrayCopy(rightFace,positionData,54);
} | movss 0x484(%rdi), %xmm0
movss 0x494(%rdi), %xmm1
addss %xmm0, %xmm1
movss %xmm0, 0xdc(%rdi)
movsd 0x488(%rdi), %xmm2
movss 0x480(%rdi), %xmm3
movss 0x490(%rdi), %xmm4
unpcklps %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
addps %xmm2, %xmm4
movaps %xmm4, %xmm3
shufps $0x55, %xmm4, %xmm3 # xmm3 =... | /susonthapa[P]3d-chair/src/main.cpp |
vfprintf | int vfprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, va_list arg )
{
/* TODO: This function should interpret format as multibyte characters. */
struct _PDCLIB_status_t status;
status.base = 0;
status.flags = 0;
status.n = SIZE_MAX;
status.i = 0;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq $-0x1, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x28(%rsp)
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movq %rdi, 0x40(%rsp)
leaq 0x48(%rdi), ... | /DevSolar[P]pdclib/functions/stdio/vfprintf.c |
PDCLIB_print | const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
{
const char * orig_spec = spec;
if ( *( ++spec ) == '%' )
{
/* %% -> print single '%' */
PUT( *spec );
return ++spec;
}
/* Initializing status structure */
status->flags = 0;
status->... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1(%rdi), %r14
movq %r14, 0x18(%rsp)
cmpb $0x25, 0x1(%rdi)
jne 0x23f6
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jae 0x251e
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0x2516
movl $0x25, %edi
callq 0x36e8
jmp 0x251e
xorl %e... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print.c |
main | int main(int argc, char **argv)
{
char *URL;
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_AL... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x804(%rip), %rsi # 0x32b6
movl $0x6, %edi
callq 0x20a0
cmpl $0x1, %ebp
jg 0x2ad2
callq 0x2493
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, 0x2610(%rip) # 0x50e8
movq %rbx, 0x2611(%rip) # 0x50f0
cmpl $0x2, %ebp
... | /lesstif[P]curl/tests/libtest/first.c |
tutil_tvnow | struct timeval tutil_tvnow(void)
{
/*
** gettimeofday() is not granted to be increased monotonically, due to
** clock drifting and external source time synchronization it can jump
** forward or backward in time.
*/
struct timeval now;
(void)gettimeofday(&now, NULL);
return now;
} | pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2140
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
| /lesstif[P]curl/tests/libtest/testutil.c |
curlx_ultous | unsigned short curlx_ultous(unsigned long ulnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(ulnum <= (unsigned long) CURL_MASK_USHORT);
return (unsigned short)(ulnum & (unsigned long) CURL_MASK_USHORT);
#ifdef __IN... | movq %rdi, %rax
retq
| /lesstif[P]curl/lib/warnless.c |
curlx_uztoul | unsigned long curlx_uztoul(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG);
#ifdef __INTEL_COMPILER
# pragma warni... | movq %rdi, %rax
retq
| /lesstif[P]curl/lib/warnless.c |
curlx_uztoui | unsigned int curlx_uztoui(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_UINT);
return (unsigned int)(uznum & (size_t) CURL_MASK_UINT);
#ifdef __INTEL_COMPILER
# pragma warning(p... | movq %rdi, %rax
retq
| /lesstif[P]curl/lib/warnless.c |
curlx_uztosz | ssize_t curlx_uztosz(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(uznum <= (size_t) CURL_MASK_SSIZE_T);
return (ssize_t)(uznum & (size_t) CURL_MASK_SSIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(po... | movq %rdi, %rax
btrq $0x3f, %rax
retq
| /lesstif[P]curl/lib/warnless.c |
curlx_sotouz | size_t curlx_sotouz(curl_off_t sonum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sonum >= 0);
return (size_t)(sonum & (curl_off_t) CURL_MASK_USIZE_T);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | movq %rdi, %rax
retq
| /lesstif[P]curl/lib/warnless.c |
iu_SetUpSkipTest_x_iutest_x_NotRun_Test::Body() | IUTEST_F(SetUpSkipTest, NotRun)
{
IUTEST_EXPECT_EQ(2, 3);
} | pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
leaq 0x58(%rsp), %rcx
movl $0x2, (%rcx)
movq %rsp, %r8
movl $0x3, (%r8)
leaq 0xd5d9(%rip), %rsi # 0x253b1
leaq 0xd596(%rip), %rdx # 0x25375
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x23fbd
cmpb $0x0, 0x20(%rbx)
jne 0x17e4b
leaq 0x58(%rsp), %rbx
movl $0x... | /srz-zumix[P]iutest/test/skip_tests.cpp |
iutest::AssertionHelper::operator=(iutest::AssertionHelper::Fixed const&) | void operator = (const Fixed& fixed)
{
OnFixed(fixed);
#if IUTEST_HAS_EXCEPTIONS && IUTEST_USE_THROW_ON_ASSERTION_FAILURE
{
IUTEST_PRAGMA_WARN_PUSH()
IUTEST_PRAGMA_WARN_DISABLE_SWITCH_ENUM()
switch( m_part_result.type() )
{
case TestPartResult::kSkip:
... | xorl %edx, %edx
jmp 0x1b0fc
nop
| /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::detail::TestInstance<iu_SkipTest_x_iutest_x_Syntax_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x243bc
movq %rax, 0x8(%rbx)
leaq 0x19150(%rip), %rax # 0x31ab8
movq %rax, (%rbx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x18686
leaq 0x10(%rbx), %r14
leaq 0... | /srz-zumix[P]iutest/include/iutest_core.hpp |
SetUpSkipTest::SetUp() | IUTEST_CXX_OVERRIDE IUTEST_CXX_FINAL
{
IUTEST_SKIP() << "skip in SetUp";
} | pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
leaq 0x38(%rsp), %rbx
movl $0x188, %edx # imm = 0x188
movq %rbx, %rdi
xorl %esi, %esi
callq 0x171a0
movq %rbx, %rdi
callq 0x1aeea
leaq 0xd362(%rip), %rsi # 0x27877
movq %rbx, %rdi
callq 0x2328e
callq 0x1883e
leaq 0xac0f(%rip), %rdx # 0x25138
lea... | /srz-zumix[P]iutest/test/skip_tests.cpp |
int iutest::detail::SumOverList<iutest::TestSuite*, int (iutest::TestSuite::*)() const>(std::vector<iutest::TestSuite*, std::allocator<iutest::TestSuite*>> const&, int (iutest::TestSuite::*)() const) | int SumOverList(const ::std::vector<T>& list, Fn f)
{
int count = 0;
for(typename ::std::vector<T>::const_iterator it = list.begin(), end = list.end(); it != end; ++it)
{
count += ((*it)->*f)();
}
return count;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
xorl %ebp, %ebp
cmpq %r12, %r15
je 0x1ac4c
movq (%r15), %rdi
addq %rbx, %rdi
movq %r14, %rax
testb $0x1, %r14b
je 0x1ac42
movq (%rdi), %rax
movq -0x1(%rax,%r14), %rax
callq *%rax
addl %eax, %ebp... | /srz-zumix[P]iutest/include/internal/../internal/iutest_list.hpp |
iutest::AssertionHelper::OnFixed(iutest::AssertionHelper::Fixed const&, bool) | void OnFixed(const Fixed& fixed, bool isException = false)
{
// OnFixed で throw しないこと！テスト側の例外キャッチにかからなくなる
const ::std::string append_message = fixed.GetString();
if( !append_message.empty() )
{
m_part_result.add_message(" " + append_message);
}
ScopedTrace... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x174e0
cmpq $0x0, 0x8(%r14)
je 0x1b148
leaq 0xc32b(%rip), %rsi # 0x27453
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1b1d2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x175e0
... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::detail::DefaultGlobalTestPartResultReporter::DefaultReportTestPartResult(iutest::TestPartResult const&) | static void DefaultReportTestPartResult(const TestPartResult& test_part_result)
{
TestResult* result = UnitTestImpl::current_test_result();
if( result )
{
result->AddTestPartResult(test_part_result);
}
else
{
iuConsole::output("%s", test_part_r... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x1aff8
testq %rax, %rax
je 0x1b64d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b6fe
jmp 0x1b678
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b6aa
movq (%r14), %rsi
leaq 0xbcbc(%rip), %rdi # 0x27323
xorl %eax, %eax
callq 0x1a802
leaq 0x8(%r... | /srz-zumix[P]iutest/include/internal/iutest_result_reporter.hpp |
void iutest::TestEnv::ParseCommandLine<char>(int*, char**) | static void ParseCommandLine(int* pargc, CharType** argv)
{
if( argv == NULL )
{
return;
}
int argc = *pargc;
for( int i=0; i < argc; )
{
if( ParseCommandLineElem(argv[i]) )
{
--argc;
// 見つかった場合、オプショ... | testq %rsi, %rsi
je 0x1ba78
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %ebp
xorl %r15d, %r15d
movl %r15d, %r15d
cmpl %ebp, %r15d
jge 0x1ba6c
movq (%r14,%r15,8), %rdi
callq 0x1d12e
testb %al, %al
je 0x1ba67
decl %ebp
movslq %ebp, %rax
movq %r15, %rcx
cmpq %rax, %r... | /srz-zumix[P]iutest/include/internal/../internal/../iutest_env.hpp |
iutest::detail::SocketWriter::Write(void const*, unsigned long, unsigned long) | virtual bool Write(const void* buf, size_t size, size_t cnt) IUTEST_CXX_OVERRIDE
{
if( !IsValid() )
{
return false;
}
const int size_ = static_cast<int>(size);
for( size_t i=0; i < cnt; ++i )
{
#ifdef IUTEST_OS_WINDOWS
if( send(m_socket, static... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
cmpl $-0x1, (%rdi,%rax)
je 0x1e649
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r12
incq %rbx
decq %rbx
sete %bpl
je 0x1e64b
movq (%r15), %rax
movq -0x18(%rax), %rax
movl (%r15,%rax), %edi
movq %r14, %rsi
mo... | /srz-zumix[P]iutest/include/listener/../internal/iutest_socket.hpp |
iutest::detail::iuOptionMessage::ShowHelp() | inline void iuOptionMessage::ShowHelp()
{
detail::iuConsole::color_output(detail::iuConsole::cyan,
"--------------------------------------------------\n"
"Name\n"
" iutest - iris unit test framework\n"
"--------------------------------------------------\n"
"Command Line Op... | leaq 0x7221(%rip), %rsi # 0x25b28
pushq $0x6
popq %rdi
xorl %eax, %eax
jmp 0x18304
nop
| /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::detail::iuOptionMessage::ShowFeature() | inline void iuOptionMessage::ShowFeature()
{
#if 0
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_MACRO);
#else
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_ENABLE_MACRO);
IIUT_SHOW_FEATURE_MACROS(IIUT_SHOW_DISABLE_MACRO);
#endif
} | pushq %r14
pushq %rbx
pushq %rax
leaq 0x794c(%rip), %rbx # 0x26287
leaq 0x7955(%rip), %rsi # 0x26297
leaq 0x8218(%rip), %r14 # 0x26b61
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1a802
leaq 0x7954(%rip), %rsi # 0x262b1
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1a802
leaq 0x... | /srz-zumix[P]iutest/include/internal/iutest_option_message.hpp |
iutest::detail::FormatIntWidthN[abi:cxx11](int, int) | inline ::std::string FormatIntWidthN(int value, int digit)
{
char buf[128] = { 0 };
int idx = IUTEST_PP_COUNTOF(buf) - 2;
int x = value;
for( int i=0; i < digit; ++i, --idx )
{
buf[idx] = static_cast<char>(::std::abs(x%10) + '0');
x /= 10;
}
for( ; x; --idx )
{
bu... | pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movabsq $-0x100000000, %rdi # imm = 0xFFFFFFFF00000000
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp... | /srz-zumix[P]iutest/include/internal/iutest_string.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::StreamableToString<int>(int const&) | inline ::std::string StreamableToString(const T& value)
{
return (Message() << value).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1aeea
movq %r15, %rdi
movq %r14, %rsi
callq 0x22dc2
addq $0x18, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x174e0
leaq 0x8(%rsp), %rdi
callq 0x1af96
movq %rbx, %rax
a... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<unsigned long>(unsigned long const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x23212
movq %r14, %rdi
movq %r15, %rsi
callq 0x172d0
movq %rsp, %rdi
callq 0x17618
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x17... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::TestSuite* iutest::detail::FindList<iutest::TestSuite*, iutest::TestSuite::FindOp>(std::vector<iutest::TestSuite*, std::allocator<iutest::TestSuite*>> const&, iutest::TestSuite::FindOp&) | T FindList(const ::std::vector<T>& list, Fn& f)
{
for(typename ::std::vector<T>::const_iterator it = list.begin(), end = list.end(); it != end; ++it)
{
if(f(*it))
{
return *it;
}
}
return NULL;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x239c6
movq (%r15), %rsi
movq %r14, %rdi
callq 0x239d6
testb %al, %al
jne 0x239c3
addq $0x8, %r15
jmp 0x239a9
movq (%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq... | /srz-zumix[P]iutest/include/internal/../internal/iutest_list.hpp |
Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | std::string toString( std::wstring const& value ) {
std::string s;
s.reserve( value.size() );
for(size_t i = 0; i < value.size(); ++i )
s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
return toString( s );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rsi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x33680
cmpq $0x0, 0x8(%r14)
je 0x38079
xorl %r13d, %r13d
movl $0x3f, %e... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3cf5b(%rip), %rax # 0x76d50
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x39e0a
callq 0x333f0
movq %rbx, %rdi
popq %rbx
jmp 0x333f0
nop
| /jh0x[P]cornelich/contrib/catch/catch.hpp |
Catch::TestSpec::TagPattern::~TagPattern() | TestSpec::TagPattern::~TagPattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3cf21(%rip), %rax # 0x77070
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x3a164
callq 0x333f0
movq %rbx, %rdi
popq %rbx
jmp 0x333f0
nop
| /jh0x[P]cornelich/contrib/catch/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... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x17, %esi
ja 0x3a531
movl %esi, %eax
leaq 0x26bda(%rip), %rcx # 0x61098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x27455(%rip), %rdi # 0x61923
jmp 0x3a528
leaq 0x27481(%rip), %rdi # 0x61958
jmp 0x3a528
leaq 0x27471(%rip), %rdi # 0x61951
jmp 0x3a5... | /jh0x[P]cornelich/contrib/catch/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.