name string | code string | asm string | file string |
|---|---|---|---|
non-virtual thunk to Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x14c1cd(%rip), %rax # 0x1901e8
movq %rax, -0x148(%rdi)
leaq 0x14c23f(%rip), %rax # 0x190268
movq %rax, -0x140(%rdi)
leaq 0x14c289(%rip), %rax # 0x1902c0
movq %rax, -0x138(%rdi)
leaq 0x14ad8b(%rip), %rax # 0x18edd0
movq %rax, -0x20(%rdi)
addq $-0x18, %rdi
callq 0x50540
leaq -... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::Parser Catch::clara::detail::ComposableParserImpl<Catch::clara::detail::ExeName>::operator|<Catch::clara::detail::Help>(Catch::clara::detail::Help const&) const | auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
return Parser() | static_cast<DerivedT const &>( *this ) | other;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
l... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::Parser Catch::clara::detail::Parser::operator|<Catch::clara::detail::Arg>(Catch::clara::detail::Arg const&) const | auto operator|( T const &other ) const -> Parser {
return Parser( *this ) |= other;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x14b9e6(%rip), %rbp # 0x190b90
movq %rbp, 0x8(%rsp)
leaq 0x14b28a(%rip), %rax # 0x190440
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsi), %rax
... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::AssertionResult::~AssertionResult() | AssertionResult() = delete; | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x45aea
callq 0x20ca0
movq 0x38(%rbx), %rdi
addq $0x48, %rbx
cmpq %rbx, %rdi
je 0x45afd
popq %rbx
jmp 0x20ca0
popq %rbx
retq
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::TextFlow::operator<<(std::ostream&, Catch::clara::TextFlow::Column const&) | inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
bool first = true;
for (auto line : col) {
if (first)
first = false;
else
os << "\n";
os << line;
}
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %rsi, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movb $0x0, 0x28(%r15)
movq %r15, %rdi
callq 0x4c60e
cmpq $0x0, 0x18(%r15)
jne 0x45cc2
incq 0x30(%... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::TextFlow::Column::Column(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit Column(std::string const& text) { m_strings.push_back(text); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x4f, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $-0x1, 0x28(%rdi)
callq 0x467f2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x46830
movq %r14, %rdi
callq 0x... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::TextFlow::operator<<(std::ostream&, Catch::clara::TextFlow::Columns const&) | inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
bool first = true;
for (auto line : cols) {
if (first)
first = false;
else
os << "\n";
os << line;
}
return os;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4ce3e
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x4d198
movb $0x1, %r13b
leaq 0x18(%rsp), %rbp
leaq 0x50(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Matchers::Exception::ExceptionMessageMatcher::ExceptionMessageMatcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ExceptionMessageMatcher(std::string const& message):
m_message(message)
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x148ad1(%rip), %rax # 0x18eab0
movq %rax, (%rdi)
leaq 0x148af7(%rip), %rax # 0x18eae0
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
mov... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Option<Catch::AssertionResult>::operator=(Catch::AssertionResult const&) | Option& operator = ( T const& _value ) {
reset();
nullableValue = new( storage ) T( _value );
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x60a7a
movq 0x30(%r14), %rax
movq %rax, 0x38(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x28(%rbx)
movups %xmm1, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0x40(%rbx), %r15
leaq 0x5... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Generators::GeneratorTracker::acquire(Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::NameAndLocation const&) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
std::shared_ptr<GeneratorTracker> tracker;
ITracker& currentTracker = ctx.currentTracker();
// Under specific circumstances, the generator we want
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
leaq 0x8(%r15), %rdi
callq 0x4d682
testb %al, %al
je 0x462f7
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq (%rax), %rcx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq *0x60(%rcx)
mo... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::AssertionResultData::~AssertionResultData() | AssertionResultData() = delete; | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x46524
callq 0x20ca0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x46536
popq %rbx
jmp 0x20ca0
popq %rbx
retq
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::ParserBase::parse(Catch::clara::detail::Args const&) const | auto parse( Args const &args ) const -> InternalParseResult {
return parse( args.exeName(), TokenStream( args ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x5080a
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
leaq 0x20(%rsp), %rdi
callq 0x4e738
m... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseState>::~BasicResult() | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | pushq %rbx
movq %rdi, %rbx
leaq 0x149f8f(%rip), %rax # 0x1905f8
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x4667e
callq 0x20ca0
leaq 0x149fcb(%rip), %rax # 0x190650
movq %rax, (%rbx)
cmpl $0x0, 0x8(%rbx)
je 0x46690
popq %rbx
retq
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jm... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/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 0x466f1
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x46731
movl $0x178, %edi # imm = 0x178
callq 0x20d30
movq %rax, %r14
movq %rax, %rdi
callq 0x21170
movq %rsp, %rsi
movq %r14, (%rsi)
movq %... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::StringStreams::release(unsigned long) | void release( std::size_t index ) {
m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
m_unused.push_back(index);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
movq (%rax,%rsi,8), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movq 0x30(%rbx), %rax
leaq 0x30(%rbx), %rsi
addq -0x18(%rax), %rsi
callq 0x20600
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x467b0
movq 0x8(%rsp), %rax
movq %rax, (%r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/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 ) {
if (Catch::isnan(value)) {
return "nan";
}
ReusableStringStream rss;
rss << std::setprecision( precision )
<< std::fixed
<< value;
std::string d = rss.str();
std::size_t i = d.find_last_not_of( '0' );
if( i != std::s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
ucomiss %xmm0, %xmm0
jp 0x47024
movl %esi, %ebp
leaq 0x1474f6(%rip), %rax # 0x18e428
movq %rax, 0x8(%rsp)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x618f4
movq 0x8(%rax), %rax
... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<double>(double, int) | std::string fpToString( T value, int precision ) {
if (Catch::isnan(value)) {
return "nan";
}
ReusableStringStream rss;
rss << std::setprecision( precision )
<< std::fixed
<< value;
std::string d = rss.str();
std::size_t i = d.find_last_not_of( '0' );
if( i != std::s... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
ucomisd %xmm0, %xmm0
jp 0x47181
movl %esi, %ebp
leaq 0x147395(%rip), %rax # 0x18e428
movq %rax, 0x8(%rsp)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, %r14
movq %rax, 0x10(%rsp)
callq 0x618f4
movq 0x8(%rax), %rax
mov... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::StreamingReporterBase<Catch::TestEventListenerBase>::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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x149ddf(%rip), %rax # 0x190fc0
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x4720e
movq 0x14ed58(%rip), %rcx # 0x195f58
cmpb $0x0, (%rcx)
je 0x4720a
incl 0x8(%rax... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::StreamingReporterBase<Catch::CompactReporter>::testRunEnded(Catch::TestRunStats const&) | void testRunEnded(TestRunStats const& /* _testRunStats */) override {
currentTestCaseInfo.reset();
currentGroupInfo.reset();
currentTestRunInfo.reset();
} | pushq %rbx
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x501bc
movb $0x0, 0x140(%rbx)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x4747d
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x4747d
callq 0x20ca0
movq $0x0, 0x50(%rbx)
movb $0x0, 0x88(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x474a6
movq (%rax), %rdi
a... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReporterRegistrar<Catch::CompactReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x4393a
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x20d30
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x14a21d(%rip), %rcx # 0x191708
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x14a25f(%rip)... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::StreamingReporterBase<Catch::ConsoleReporter>::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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x14987d(%rip), %rax # 0x190dd8
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x47588
movq 0x14e9de(%rip), %rcx # 0x195f58
cmpb $0x0, (%rcx)
je 0x47584
incl 0x8(%rax... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::TablePrinter::close() | void close() {
if (m_isOpen) {
*this << RowBreak();
m_os << std::endl;
m_isOpen = false;
}
} | cmpb $0x1, 0x19c(%rdi)
jne 0x477a6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x198(%rdi)
jle 0x4776e
movq (%rbx), %rdi
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
callq 0x20f00
movl $0xffffffff, 0x198(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::CumulativeReporterBase(Catch::ReporterConfig const&) | CumulativeReporterBase( ReporterConfig const& _config )
: m_config( _config.fullConfig() ),
stream( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = false;
if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
CATCH_ERR... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x149328(%rip), %rax # 0x190e78
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x47b7d
movq 0x14e3e9(%rip), %rcx # 0x195f58
cmpb $0x0... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::testGroupEnded(Catch::TestGroupStats const&) | void testGroupEnded(TestGroupStats const& testGroupStats) override {
auto node = std::make_shared<TestGroupNode>(testGroupStats);
node->children.swap(m_testCases);
m_testGroups.push_back(node);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x677d0
movq (%r14), %rax
movq 0x90(%rax), %rcx
movups 0x50(%rbx), %xmm0
movups 0x80(%rax), %xmm1
movups %xmm0, 0x80(%rax)
movq 0x60(%rbx), %... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14653b(%rip), %rax # 0x18e428
movq %rax, (%rsp)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x618f4
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
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 0x14646f(%rip), %rax # 0x18e428
movq %rax, (%rsp)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x618f4
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<Catch::StringRef>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x146121(%rip), %rax # 0x18e428
movq %rax, (%rsp)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x618f4
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x4393a
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x20d30
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x149545(%rip), %rcx # 0x191938
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x149587(%rip)... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x148abd(%rip), %rax # 0x190f20
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x48490
movq 0x14dad6(%rip), %rcx # 0x195f58
cmpb $0x0, (%rcx)
je 0x4848c
incl 0x8(%rax... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const* const&) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x145dcf(%rip), %rax # 0x18e428
movq %rsp, %r12
movq %rax, (%r12)
callq 0x618f4
leaq 0x8(%rax), %rdi
callq 0x466d2
movq %rax, 0x8(%r12)
callq 0x618f4
movq 0x8(%r12), %rcx
movq 0x8(%rax), %rax
movq (%rax,... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReporterRegistrar<Catch::XmlReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x4393a
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x20d30
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x14913f(%rip), %rcx # 0x1919d0
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x149181(%rip)... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
int Catch::Session::run<char>(int, char const* const*) | int run(int argc, CharT const * const argv[]) {
if (m_startupExceptions)
return 1;
int returnCode = applyCommandLine(argc, argv);
if (returnCode == 0)
returnCode = run();
return returnCode;
} | pushq %rbx
movl $0x1, %eax
cmpb $0x0, 0x188(%rdi)
jne 0x48909
movq %rdi, %rbx
callq 0x332bc
testl %eax, %eax
je 0x4890b
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x33672
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::sectionStarting(Catch::SectionInfo const&) | void sectionStarting( SectionInfo const& sectionInfo ) override {
SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
std::shared_ptr<SectionNode> node;
if( m_sectionStack.empty() ) {
if( !m_rootSection )
m_rootSection = std::make_shar... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x40(%rsp), %rdi
xorps %xmm0, %xmm0
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2be0a
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0xc0(%rbx), %rax
cmpq ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::ExeName::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&, TokenStream const &tokens ) const -> InternalParseResult override {
return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
leaq 0x20(%rsp), %rbx
movl $0x1, -0x18(%rbx)
movups (%rcx), %xmm0
movups %xmm0, -0x10(%rbx)
leaq 0x10(%rcx), %rsi
movq %rbx, %rdi
callq 0x49c6a
movl $0x0, 0x8(%r14)
leaq 0x146c54(%rip), %rax # 0x190650
movq %rax, (%r14)
movl -0x18(%rbx), %eax
movl %eax, 0x10(%r1... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BasicResult<void>::~BasicResult() | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1469e9(%rip), %rax # 0x190568
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x49b94
callq 0x20ca0
movq %rbx, %rdi
popq %rbx
jmp 0x20ca0
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BasicResult<void>::enforceOk() const | void enforceOk() const override {
// Errors shouldn't reach this point, but if they do
// the actual error message will be in m_errorMessage
assert( m_type != ResultBase::LogicError );
assert( m_type != ResultBase::RuntimeError );
if( m_type != ResultBase::Ok... | cmpl $0x0, 0x8(%rdi)
jne 0x49ba5
retq
pushq %rax
callq 0x20750
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BoundFlagLambda<Catch::clara::detail::Help::Help(bool&)::'lambda'(bool)>::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
movb %dl, (%rcx)
movabsq $0x200000000, %rcx # imm = 0x200000000
movq %rcx, 0x8(%rdi)
leaq 0x145dfe(%rip), %rcx # 0x190758
movq %rcx, (%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
retq
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseState>::BasicResult(Catch::clara::detail::ResultBase::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BasicResult( ResultBase::Type type, std::string const &message )
: ResultValueBase<T>(type),
m_errorMessage(message)
{
assert( m_type != ResultBase::Ok );
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
leaq 0x14523f(%rip), %rax # 0x1905f8
movq %rax, (%rdi)
addq $0x40, %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x5080a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::TextFlow::Column::iterator::operator++() | auto operator ++() -> iterator& {
m_pos += m_len;
if (m_pos < line().size() && line()[m_pos] == '\n')
m_pos += 1;
else
while (m_pos < line().size() && isWhitespace(line()[m_pos]))
++m_pos;
if (m_pos == line().size()) {
m_pos = 0;
++m_stringIndex;
}
if (m_stringIndex < m_column.m_... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
addq 0x18(%rdi), %rax
movq %rax, 0x10(%rdi)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq (%rcx), %rcx
shlq $0x5, %rdx
cmpq 0x8(%rcx,%rdx), %rax
jae 0x4c54d
addq %rdx, %rcx
movq (%rcx), %rcx
cmpb $0xa, (%rcx,%rax)
jne 0x4c54d
incq %rax
movq %rax, 0x10... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::clara::TextFlow::Column::iterator::isBoundary(unsigned long) const | auto isBoundary(size_t at) const -> bool {
assert(at > 0);
assert(at <= line().size());
return at == line().size() ||
(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
isBreakableBefore(line()[at]) ||
isBreakableAfter(line()[at - 1]);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movb $0x1, %bpl
cmpq %rsi, 0x8(%rax,%rcx)
je 0x4c839
movq %rsi, %rbx
movq %rdi, %r14
addq %rcx, %rax
movq (%rax), %rax
movb (%rax,%rsi), %r15b
movb 0x14b00d(%rip), %al # 0x197778
testb %al... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x13e7a7(%rip), %rax # 0x190960
movq %rax, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0x20, %edi
callq 0x20d30
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x13effe(%rip), %rcx # 0x1911e0
movq %rcx, (%rax... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::Singleton<Catch::StringStreams, Catch::StringStreams, Catch::StringStreams>::~Singleton() | static auto getInternal() -> Singleton* {
static Singleton* s_instance = nullptr;
if( !s_instance ) {
s_instance = new Singleton;
addSingleton( s_instance );
}
return s_instance;
} | pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movq 0x1345b5(%rip), %rsi # 0x195f40
callq 0x20700
leaq 0xa8(%rbx), %rdi
callq 0x20400
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x619aa
callq 0x20ca0
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x619f8
nop
| /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::StreamingReporterBase<Catch::CompactReporter>::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 %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x12a7d5(%rip), %rax # 0x190d38
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x66590
movq 0x12f9d6(%rip), %rcx # 0x195f58
cmpb $0x0, (%rcx)
je 0x6658c
incl 0x8(%rax... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReporterRegistrar<Catch::JunitReporter>::ReporterFactory::getDescription[abi:cxx11]() const | std::string getDescription() const override {
return T::getDescription();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x8(%rsp), %r14
movq $0x4e, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x21860
movq %rax, %r15
movq %rax, (%rbx)
movq (%r14), %r14
movq %r14, 0x10(%rbx)
leaq 0xb6a22(%rip), %rsi # 0x11e867
movl $0x4e, %e... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::ReusableStringStream& Catch::ReusableStringStream::operator<<<char const*>(char const* const&) | auto operator << ( T const& value ) -> ReusableStringStream& {
*m_oss << value;
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq (%rsi), %r15
testq %r15, %r15
je 0x6800a
movq %r15, %rdi
callq 0x205c0
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20f00
jmp 0x68022
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::MatchExpr<FlatMap<Point, double, PointCmp>, EqualsRange<FlatMap<Point, double, PointCmp>>>::MatchExpr(FlatMap<Point, double, PointCmp> const&, EqualsRange<FlatMap<Point, double, PointCmp>> const&, Catch::StringRef const&) | MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
: ITransientExpression{ true, matcher.match( arg ) },
m_arg( arg ),
m_matcher( matcher ),
m_matcherString( matcherString )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x18(%rax)
movb $0x1, 0x8(%rbx)
movb %al, 0x9(%rbx)
leaq 0x11e58f(%rip), %rax # 0x192068
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
leaq 0x11a449(%rip), %rax ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
EqualsRange<FlatMap<Point, double, PointCmp>>::match(FlatMap<Point, double, PointCmp> const&) const | virtual bool match(const T& in) const override {
std::ostringstream s;
s << in;
return s.str() == expected_;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x21170
movq %r15, %rdi
movq %r14, %rsi
callq 0x73e91
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21590
movq 0x10(%rsp), %rdx
cmpq 0x38(%rbx), %rdx
jne 0x73e16
t... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
std::ostream& operator<<<Point, double, PointCmp>(std::ostream&, FlatMap<Point, double, PointCmp> const&) | std::ostream& operator<<(std::ostream& out, const FlatMap<Key, Value, Compare>& map) {
out << "{ ";
size_t i = 0;
for (const auto& v : map) {
out << (i++ == 0 ? "" : ", ") << "[" << v.first << "] -> " << v.second;
}
return out << " }";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xae046(%rip), %rsi # 0x121eef
movl $0x2, %edx
callq 0x20f00
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x73f44
xorl %r14d, %r14d
leaq 0xae734(%rip), %r15 # 0x122601
xorl %edx, %edx
s... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>::FlatMap<std::pair<Point, double> const*>(std::pair<Point, double> const*, std::pair<Point, double> const*, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&) const&) | FlatMap(InputIt first, InputIt last, const Compare& comp = Compare()) :
vec_(first, last),
comp_(comp),
valueToKeyComp_(comp),
valueToValueComp_(comp) {
std::stable_sort(vec_.begin(), vec_.end(), valueToValueComp_);
auto newLast = std::unique(vec_.begin(), vec_.end(), [t... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsp, %rcx
callq 0x727be
movq (%r14), %rax
movq %rax, 0x18(%rbx)
movq (%r14), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %r14
movq %r14, 0x28(%rbx)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
cmpq %r15, %r12
je 0x74072
movq %r15, ... | /tdepke2[P]CircuitSim2/src/./FlatMap.h |
FlatMap<Point, double, PointCmp>::operator[](Point const&) | T& operator[](const Key& key) {
auto pos = std::lower_bound(vec_.begin(), vec_.end(), key, valueToKeyComp_);
if (pos == vec_.end() || comp_(key, pos->first)) {
return vec_.emplace(pos, std::piecewise_construct, std::forward_as_tuple(key), std::tuple<>())->second;
} else {
... | subq $0x18, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
testq %rdx, %rdx
jle 0x7462e
shrq $0x3, %rdx
movabsq $-0x5555555555555555, %r8 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %r8
movsd (%rsi), %xmm0
movq %r8, %rdx
shrq %rdx
leaq (%rdx,%rdx,2), %r9
ucomisd (%rax,%r9,8), %xmm0
jbe 0x74626
n... | /tdepke2[P]CircuitSim2/src/./FlatMap.h |
Catch::MatchExpr<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>, EqualsRange<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>>>::MatchExpr(FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, P... | MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
: ITransientExpression{ true, matcher.match( arg ) },
m_arg( arg ),
m_matcher( matcher ),
m_matcherString( matcherString )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x18(%rax)
movb $0x1, 0x8(%rbx)
movb %al, 0x9(%rbx)
leaq 0x11cce1(%rip), %rax # 0x1921a8
movq %rax, (%rbx)
movq %r12, 0x10(%rbx)
leaq 0x118a5b(%rip), %rax ... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::MatchExpr<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>, EqualsRange<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>>>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
auto matcherAsString = m_matcher.toString();
os << Catch::Detail::stringify( m_arg ) << ' ';
if( matcherAsString == Detail::unprintableString )
os << m_matcherString;
else
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2d716
movq 0x10(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x75958
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x20f00
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
EqualsRange<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>>::~EqualsRange() | EqualsRange(const std::string& expected) :
expected_(expected) {
} | pushq %rbx
movq %rdi, %rbx
leaq 0x11cb17(%rip), %rax # 0x1921e8
movq %rax, (%rdi)
leaq 0x11cb3d(%rip), %rax # 0x192218
movq %rax, 0x28(%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x756f1
callq 0x20ca0
movq %rbx, %rdi
callq 0x41294
movq %rbx, %rdi
popq %rbx
jmp 0x20ca0
| /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
EqualsRange<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>>::describe[abi:cxx11]() const | virtual std::string describe() const override {
std::ostringstream s;
s << "\nEquals range:\n" << expected_;
return s.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 0x21170
leaq 0xac7b7(%rip), %rsi # 0x121edf
movl $0xf, %edx
movq %r15, %rdi
callq 0x20f00
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x20... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
EqualsRange<FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>>::match(FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)> const&) const | virtual bool match(const T& in) const override {
std::ostringstream s;
s << in;
return s.str() == expected_;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x21170
movq %r15, %rdi
movq %r14, %rsi
callq 0x7587f
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21590
movq 0x10(%rsp), %rdx
cmpq 0x38(%rbx), %rdx
jne 0x75804
t... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
std::ostream& operator<<<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)>(std::ostream&, FlatMap<Point, double, void testCtorCustomComp<FlatMap>()::'lambda'(Point const&, Point const&)> const&) | std::ostream& operator<<(std::ostream& out, const FlatMap<Key, Value, Compare>& map) {
out << "{ ";
size_t i = 0;
for (const auto& v : map) {
out << (i++ == 0 ? "" : ", ") << "[" << v.first << "] -> " << v.second;
}
return out << " }";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xac658(%rip), %rsi # 0x121eef
movl $0x2, %edx
callq 0x20f00
movq (%r14), %r13
movq 0x8(%r14), %rbp
cmpq %rbp, %r13
je 0x75932
xorl %r14d, %r14d
leaq 0xacd46(%rip), %r15 # 0x122601
xorl %edx, %edx
s... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
void testAccess<std::map>() | void testAccess() {
INFO("Map type is " << typeid(Map<std::string, std::string>).name());
Map<std::string, std::string> myMap;
//std::cout << "empty myMap = " << myMap << "\n";
REQUIRE_THAT(myMap, EqualsRange<decltype(myMap)>(
"{ }"
));
/*try {
std::cout << " item [test_at] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
leaq 0xac2b1(%rip), %rax # 0x121ef2
leaq 0xc8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x4, 0x8(%rsi)
leaq 0xabc7d(%rip), %r13 # 0x1218d8
leaq 0x80(%rsp), %rdx
movq %r13, (%rdx)
movq $0xcb, 0x8(%rdx)
movq %rs... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
void testAccess<FlatMap>() | void testAccess() {
INFO("Map type is " << typeid(Map<std::string, std::string>).name());
Map<std::string, std::string> myMap;
//std::cout << "empty myMap = " << myMap << "\n";
REQUIRE_THAT(myMap, EqualsRange<decltype(myMap)>(
"{ }"
));
/*try {
std::cout << " item [test_at] =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp # imm = 0x278
leaq 0xab1d8(%rip), %rax # 0x121ef2
leaq 0xd0(%rsp), %rsi
movq %rax, (%rsi)
movq $0x4, 0x8(%rsi)
leaq 0xaaba4(%rip), %r13 # 0x1218d8
leaq 0x88(%rsp), %rdx
movq %r13, (%rdx)
movq $0xcb, 0x8(%rdx)
leaq 0x8... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
Catch::MatchExpr<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::pair<std::__cxx11::basi... | void streamReconstructedExpression( std::ostream &os ) const override {
auto matcherAsString = m_matcher.toString();
os << Catch::Detail::stringify( m_arg ) << ' ';
if( matcherAsString == Detail::unprintableString )
os << m_matcherString;
else
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2d716
movq 0x10(%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0x7879e
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x20f00
leaq 0xf(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
EqualsRange<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::pair<std::__cxx11::basic_str... | EqualsRange(const std::string& expected) :
expected_(expected) {
} | pushq %rbx
movq %rdi, %rbx
leaq 0x119e17(%rip), %rax # 0x192328
movq %rax, (%rdi)
leaq 0x119e3d(%rip), %rax # 0x192358
movq %rax, 0x28(%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x78531
callq 0x20ca0
movq %rbx, %rdi
callq 0x41294
movq %rbx, %rdi
popq %rbx
jmp 0x20ca0
| /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
EqualsRange<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::pair<std::__cxx11::basic_str... | virtual std::string describe() const override {
std::ostringstream s;
s << "\nEquals range:\n" << expected_;
return s.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 0x21170
leaq 0xa9977(%rip), %rsi # 0x121edf
movl $0xf, %edx
movq %r15, %rdi
callq 0x20f00
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x20... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
EqualsRange<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::pair<std::__cxx11::basic_str... | virtual bool match(const T& in) const override {
std::ostringstream s;
s << in;
return s.str() == expected_;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x21170
movq %r15, %rdi
movq %r14, %rsi
callq 0x786bf
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21590
movq 0x10(%rsp), %rdx
cmpq 0x38(%rbx), %rdx
jne 0x78644
t... | /tdepke2[P]CircuitSim2/tests/FlatMap.test.cpp |
Catch::BinaryExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [73]>::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 0x3807e
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7e8c6
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14,... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
Catch::BinaryExpr<FlatMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, FlatMap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, float, std::less<std... | 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 0x94aa4
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rsi
leaq 0x8(%rsp), %rdi
callq 0x94aa4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14,... | /tdepke2[P]CircuitSim2/build_O1/_deps/catch2-src/single_include/catch2/catch.hpp |
void FlatMap<double, MyStruct, std::less<double>>::insert<std::pair<double, MyStruct> const*>(std::pair<double, MyStruct> const*, std::pair<double, MyStruct> const*) | void insert(InputIt first, InputIt last) {
if (first == last) {
return;
}
auto insertStart = vec_.insert(vec_.end(), first, last);
std::stable_sort(insertStart, vec_.end(), valueToValueComp_);
std::inplace_merge(vec_.begin(), insertStart, vec_.end(), valueToValueComp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
cmpq %rdx, %rsi
je 0x9c140
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rsi, %r14
subq (%rdi), %r14
callq 0x9c162
addq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x9c113
movq %r15, %rax
subq %r14, %rax
sarq $0x4, %rax
m... | /tdepke2[P]CircuitSim2/src/./FlatMap.h |
char const* fmt::v11::detail::invoke_parse<char const*, char>(fmt::v11::parse_context<char>&) | FMT_CONSTEXPR auto invoke_parse(parse_context<Char>& ctx) -> const Char* {
using mapped_type = remove_cvref_t<mapped_t<T, Char>>;
constexpr bool formattable =
std::is_constructible<formatter<mapped_type, Char>>::value;
if (!formattable) return ctx.begin(); // Error is reported in the value ctor.
using fo... | subq $0x38, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movl $0x8000, (%rdi) # imm = 0x8000
movb $0x20, 0x4(%rdi)
xorl %eax, %eax
movl %eax, 0x5(%rdi)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rcx, 0x8(%rdi... | /tdepke2[P]CircuitSim2/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/base.h |
char const* fmt::v11::detail::invoke_parse<int&, char>(fmt::v11::parse_context<char>&) | FMT_CONSTEXPR auto invoke_parse(parse_context<Char>& ctx) -> const Char* {
using mapped_type = remove_cvref_t<mapped_t<T, Char>>;
constexpr bool formattable =
std::is_constructible<formatter<mapped_type, Char>>::value;
if (!formattable) return ctx.begin(); // Error is reported in the value ctor.
using fo... | subq $0x38, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, 0x20(%rdi)
movl $0x8000, (%rdi) # imm = 0x8000
movb $0x20, 0x4(%rdi)
xorl %eax, %eax
movl %eax, 0x5(%rdi)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq %rcx, 0x8(%rdi... | /tdepke2[P]CircuitSim2/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/base.h |
void spdlog::logger::log_<int>(spdlog::source_loc, spdlog::level::level_enum, fmt::v11::basic_string_view<char>, int&&) | void log_(source_loc loc, level::level_enum lvl, string_view_t fmt, Args &&...args) {
bool log_enabled = should_log(lvl);
bool traceback_enabled = tracer_.enabled();
if (!log_enabled && !traceback_enabled) {
return;
}
SPDLOG_TRY {
memory_buf_t buf;
#ifdef ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r8, %r14
movq %rcx, 0x28(%rsp)
movq %rdx, %r13
movl %esi, %ebp
movl 0x40(%rdi), %ebx
cmpl %esi, %ebx
setg %r12b
movq %rdi, 0x20(%rsp)
addq $0x68, %rdi
callq 0xfc270
movl %eax, %r15d
xorb $0x1, %al
testb %a... | /tdepke2[P]CircuitSim2/build_O1/_deps/spdlog-src/include/spdlog/logger.h |
ghc::filesystem::directory_entry::refresh() | GHC_INLINE void directory_entry::refresh()
{
std::error_code ec;
refresh(ec);
if (ec && (_status.type() == file_type::none || _symlink_status.type() != file_type::symlink)) {
throw filesystem_error(detail::systemErrorText(ec.value()), _path, ec);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movl $0x0, (%r15)
callq 0x20780
movq %rax, 0x8(%r15)
leaq 0x28(%r14), %rbx
leaq 0x30(%r14), %r8
leaq 0x38(%r14), %r9
leaq 0x40(%r14), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi... | /tdepke2[P]CircuitSim2/build_O1/_deps/ghc_filesystem-src/include/ghc/filesystem.hpp |
LodRenderer::removeDecoration(unsigned long, unsigned int, sf::Drawable const*) | void LodRenderer::removeDecoration(ChunkCoords::repr coords, unsigned int tileIndex, const sf::Drawable* drawable) {
auto chunkDeco = decorations_.find(coords);
auto deco = chunkDeco->second.find(tileIndex);
if (deco->second != drawable) {
// Do nothing if there is a different drawable at the select... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rsi, (%rax)
leaq 0xc(%rsp), %r12
movl %edx, (%r12)
addq $0x8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb6d96
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0xb6df4
cmpq %r15, 0x8(%rax... | /tdepke2[P]CircuitSim2/src/LodRenderer.cpp |
sf::RenderTarget::RenderTarget() | RenderTarget::RenderTarget() :
m_defaultView(),
m_view (),
m_cache (),
m_id (0)
{
m_cache.glStatesSet = false;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xdc0a9(%rip), %rax # 0x193730
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xbdb44
leaq 0xb0(%rbx), %rdi
callq 0xbdb44
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rbx)
movups %xmm0, 0x1b8(%rbx)
movups %xmm0, 0x1a8(%rbx)
movups %xmm0, 0x198(%rbx)
movups %xmm0, 0x188(%rbx... | /tdepke2[P]CircuitSim2/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
(anonymous namespace)::RenderTargetImpl::isActive(unsigned long long) | bool isActive(sf::Uint64 id)
{
ContextRenderTargetMap::iterator iter = contextRenderTargetMap.find(sf::Context::getActiveContextId());
if ((iter == contextRenderTargetMap.end()) || (iter->second != id))
return false;
return true;
} | pushq %rbx
movq %rdi, %rbx
callq 0xe6562
movq 0xe02a0(%rip), %rsi # 0x197a70
leaq 0xe0291(%rip), %rcx # 0x197a68
movq %rcx, %rdx
testq %rsi, %rsi
je 0xb77fe
leaq 0xe0282(%rip), %rdx # 0x197a68
xorl %edi, %edi
cmpq %rax, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jn... | /tdepke2[P]CircuitSim2/build_O1/_deps/sfml-src/src/SFML/Graphics/RenderTarget.cpp |
bool fmt::v11::detail::loc_writer<char>::operator()<unsigned int, 0>(unsigned int) | auto operator()(T value) -> bool {
auto arg = make_write_int_arg(value, specs.sign());
write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix,
specs, digit_grouping<Char>(grouping, sep));
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %r15d
movq %rdi, %r12
movq (%rdi), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rdi), %rbx
movl (%rbx), %eax
shrl $0x8, %eax
andl $0xc, %eax
leaq 0x265a2(%rip), %rcx # 0x1391c0
movl (%rax,%rcx), %ebp
leaq 0x10(%rsp), %r14
movq %r1... | /tdepke2[P]CircuitSim2/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v11::basic_appender<char> fmt::v11::detail::write_int<fmt::v11::basic_appender<char>, unsigned long, char>(fmt::v11::basic_appender<char>, unsigned long, unsigned int, fmt::v11::format_specs const&, fmt::v11::detail::digit_grouping<char> const&) | auto write_int(OutputIt out, UInt value, unsigned prefix,
const format_specs& specs, const digit_grouping<Char>& grouping)
-> OutputIt {
static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
int num_digits = 0;
auto buffer = memory_buffer();
switch (specs.type()) {
default: F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %r8, %r15
movq %rcx, %rbx
movq %rsi, %r13
movl %edx, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rbp
movaps %xmm0, -0x20(%rbp)
leaq -0x6cfe9(%rip), %rax # 0xa64e6
movq %rax, -0x8(%rbp)
movq %rbp, -0x2... | /tdepke2[P]CircuitSim2/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
UINT8_Unmarshal | TPM_RC UINT8_Unmarshal(UINT8 *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
if (target == NULL || buffer == NULL || size == NULL)
{
LogError("invalid paramer specified");
result = TPM_RC_INSUFFICIENT;
}
else
{
if ((*size -= 1) < 0)
{
LogError("i... | pushq %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x3ca6
callq 0xd163
movl $0x9a, %ebx
testq %rax, %rax
je 0x3cf4
movq %rax, %r10
leaq 0x17679(%rip), %rsi # 0x1b30d
leaq 0x176d9(%rip), %rdx # 0x1b374
leaq 0x176e2(%rip), %r9 # 0x1b38... | /Azure[P]azure-utpm-c/src/Marshal.c |
UINT8_Marshal | UINT16 UINT8_Marshal(UINT8 *source, BYTE **buffer, INT32 *size)
{
if (buffer != 0)
{
if ((size == 0) || ((*size -= 1) >= 0))
{
UINT8_TO_BYTE_ARRAY(*source, *buffer);
*buffer += 1;
}
//pAssert(size == 0 || (*size >= 0));
}
return (1);
} | testq %rsi, %rsi
je 0x3d17
testq %rdx, %rdx
je 0x3d0d
movl (%rdx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdx)
testl %eax, %eax
jle 0x3d17
movb (%rdi), %al
movq (%rsi), %rcx
movb %al, (%rcx)
incq (%rsi)
movw $0x1, %ax
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
UINT16_Unmarshal | TPM_RC UINT16_Unmarshal(UINT16 *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
if ((*size -= 2) < 0)
{
result = TPM_RC_INSUFFICIENT;
}
else
{
*target = BYTE_ARRAY_TO_UINT16(*buffer);
*buffer += 2;
result = TPM_RC_SUCCESS;
}
return result;
} | movl (%rdx), %ecx
leal -0x2(%rcx), %eax
movl %eax, (%rdx)
movl $0x9a, %eax
cmpl $0x2, %ecx
jl 0x3d50
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x8a8f
movw %ax, (%r14)
addq $0x2, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
UINT32_Unmarshal | TPM_RC UINT32_Unmarshal(UINT32 *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
if ((*size -= 4) < 0)
{
result = TPM_RC_INSUFFICIENT;
}
else
{
*target = BYTE_ARRAY_TO_UINT32(*buffer);
*buffer += 4;
result = TPM_RC_SUCCESS;
}
return result;
} | movl (%rdx), %ecx
leal -0x4(%rcx), %eax
movl %eax, (%rdx)
movl $0x9a, %eax
cmpl $0x4, %ecx
jl 0x3db3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x8a97
movl %eax, (%r14)
addq $0x4, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
UINT64_Marshal | UINT16
UINT64_Marshal(UINT64 *source, BYTE **buffer, INT32 *size)
{
if (buffer != 0)
{
if ((size == 0) || ((*size -= 8) >= 0))
{
UINT64_TO_BYTE_ARRAY(*source, *buffer);
*buffer += 8;
}
//pAssert(size == 0 || (*size >= 0));
}
return (8);
} | testq %rsi, %rsi
je 0x3e40
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x3e30
movl (%rdx), %eax
leal -0x8(%rax), %ecx
movl %ecx, (%rdx)
cmpl $0x8, %eax
jl 0x3e3f
movq (%rdi), %rdi
movq (%rbx), %rsi
callq 0x8a88
addq $0x8, (%rbx)
popq %rbx
movw $0x8, %ax
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPM_CLOCK_ADJUST_Unmarshal | TPM_RC
TPM_CLOCK_ADJUST_Unmarshal(TPM_CLOCK_ADJUST *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = INT8_Unmarshal((INT8 *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch(*target) {
case TPM_CLOCK_COARSE_SLOWER :
case TPM_CLOCK_MEDIUM_SL... | pushq %rbx
movq %rdi, %rbx
callq 0x3c62
testl %eax, %eax
jne 0x3e62
movb (%rbx), %al
addb $0x3, %al
xorl %ecx, %ecx
cmpb $0x7, %al
movl $0x84, %eax
cmovbl %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPM_SU_Unmarshal | TPM_RC
TPM_SU_Unmarshal(TPM_SU *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = UINT16_Unmarshal((UINT16 *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch(*target) {
case TPM_SU_CLEAR :
case TPM_SU_STATE :
break;
defau... | pushq %rbx
movq %rdi, %rbx
callq 0x3d1c
testl %eax, %eax
jne 0x3e9c
xorl %ecx, %ecx
cmpw $0x2, (%rbx)
movl $0x84, %eax
cmovbl %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMA_PERMANENT_Unmarshal | TPM_RC
TPMA_PERMANENT_Unmarshal(TPMA_PERMANENT *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if(*((UINT32 *)target) & (UINT32)0xfffff8f8)
return TPM_RC_RESERVED_BITS;
ret... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x3f60
movl $0xfffff8f8, %ecx # imm = 0xFFFFF8F8
andl (%rbx), %ecx
movl $0xa1, %eax
cmovel %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMA_MEMORY_Unmarshal | TPM_RC
TPMA_MEMORY_Unmarshal(TPMA_MEMORY *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if(*((UINT32 *)target) & (UINT32)0xfffffff8)
return TPM_RC_RESERVED_BITS;
return TP... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x3f9a
xorl %ecx, %ecx
cmpl $0x8, (%rbx)
movl $0xa1, %eax
cmovbl %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMA_MODES_Unmarshal | TPM_RC
TPMA_MODES_Unmarshal(TPMA_MODES *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = UINT32_Unmarshal((UINT32 *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if(*((UINT32 *)target) & (UINT32)0xfffffffe)
return TPM_RC_RESERVED_BITS;
return TPM_... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x3fd7
xorl %ecx, %ecx
cmpl $0x2, (%rbx)
movl $0xa1, %eax
cmovbl %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_DH_OBJECT_Unmarshal | TPM_RC
TPMI_DH_OBJECT_Unmarshal(TPMI_DH_OBJECT *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if (*target == TPM_RH_NULL) {
if(flag)
return TPM_R... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x403e
movl (%r14), %ecx
cmpl $0x40000007, %ecx # imm = 0x40000007
jne 0x4020
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x84, %eax
cmovnel %ecx, %eax
jmp 0x403e
leal 0x7e000000(%rcx), %eax
xorl %edx, %edx
cmpl $0xff000... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_DH_PARENT_Unmarshal | TPM_RC
TPMI_DH_PARENT_Unmarshal(TPMI_DH_PARENT *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_OWNER:
case TPM_RH_PLAT... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x409f
movl (%r14), %eax
leal -0x4000000b(%rax), %ecx
cmpl $0x2, %ecx
jb 0x409d
cmpl $0x40000001, %eax # imm = 0x40000001
je 0x409d
cmpl $0x40000007, %eax # imm = 0x40000007
jne 0x407f
testl %ebx, %ebx
jne 0x4... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_DH_PERSISTENT_Unmarshal | TPM_RC
TPMI_DH_PERSISTENT_Unmarshal(TPMI_DH_PERSISTENT *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if((*target < PERSISTENT_FIRST) || (*target > PERSISTENT_LAST))
retur... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x40ca
movl $0x7e000000, %eax # imm = 0x7E000000
addl (%rbx), %eax
xorl %ecx, %ecx
cmpl $0xff000000, %eax # imm = 0xFF000000
movl $0x84, %eax
cmovael %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_DH_ENTITY_Unmarshal | TPM_RC
TPMI_DH_ENTITY_Unmarshal(TPMI_DH_ENTITY *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_OWNER:
case TPM_RH_ENDO... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x414a
movl (%r14), %ecx
leal -0x4000000a(%rcx), %eax
cmpl $0x3, %eax
jb 0x4148
cmpl $0x40000001, %ecx # imm = 0x40000001
je 0x4148
cmpl $0x40000007, %ecx # imm = 0x40000007
jne 0x4107
testl %ebx, %ebx
jne 0x4... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_SH_AUTH_SESSION_Unmarshal | TPM_RC
TPMI_SH_AUTH_SESSION_Unmarshal(TPMI_SH_AUTH_SESSION *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if (*target == TPM_RS_PW) {
if(flag)
re... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x41cd
movl (%r14), %eax
cmpl $0x40000009, %eax # imm = 0x40000009
jne 0x41b9
xorl %ecx, %ecx
testl %ebx, %ebx
movl $0x84, %eax
cmovnel %ecx, %eax
jmp 0x41cd
andl $0xfeffffc0, %eax # imm = 0xFEFFFFC0
xorl %ecx... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_ENABLES_Unmarshal | TPM_RC
TPMI_RH_ENABLES_Unmarshal(TPMI_RH_ENABLES *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_OWNER:
case TPM_RH_PL... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x42c9
movl (%r14), %ecx
leal -0x4000000b(%rcx), %eax
cmpl $0x3, %eax
jb 0x42c7
cmpl $0x40000001, %ecx # imm = 0x40000001
je 0x42c7
movl $0x84, %eax
cmpl $0x40000007, %ecx # imm = 0x40000007
jne 0x42c9
testl %... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_PLATFORM_Unmarshal | TPM_RC
TPMI_RH_PLATFORM_Unmarshal(TPMI_RH_PLATFORM *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_PLATFORM:
break;
d... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x431a
xorl %ecx, %ecx
cmpl $0x4000000c, (%rbx) # imm = 0x4000000C
movl $0x84, %eax
cmovel %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_OWNER_Unmarshal | TPM_RC
TPMI_RH_OWNER_Unmarshal(TPMI_RH_OWNER *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_OWNER:
break;
... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x434c
movl (%r14), %ecx
cmpl $0x40000001, %ecx # imm = 0x40000001
je 0x434a
movl $0x84, %eax
cmpl $0x40000007, %ecx # imm = 0x40000007
jne 0x434c
testl %ebx, %ebx
je 0x434c
xorl %eax, %eax
addq $0x8, %rsp
pop... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_ENDORSEMENT_Unmarshal | TPM_RC
TPMI_RH_ENDORSEMENT_Unmarshal(TPMI_RH_ENDORSEMENT *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_ENDORSEMENT:
... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d80
testl %eax, %eax
jne 0x4384
movl (%r14), %ecx
cmpl $0x4000000b, %ecx # imm = 0x4000000B
je 0x4382
movl $0x84, %eax
cmpl $0x40000007, %ecx # imm = 0x40000007
jne 0x4384
testl %ebx, %ebx
je 0x4384
xorl %eax, %eax
addq $0x8, %rsp
pop... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_PROVISION_Unmarshal | TPM_RC
TPMI_RH_PROVISION_Unmarshal(TPMI_RH_PROVISION *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_OWNER:
case TPM_RH_PLATFORM:... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x43b4
movl (%rbx), %ecx
xorl %edx, %edx
cmpl $0x4000000c, %ecx # imm = 0x4000000C
movl $0x84, %eax
cmovel %edx, %eax
cmpl $0x40000001, %ecx # imm = 0x40000001
cmovel %edx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_NV_AUTH_Unmarshal | TPM_RC
TPMI_RH_NV_AUTH_Unmarshal(TPMI_RH_NV_AUTH *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_RH_PLATFORM:
case TPM_RH_OWNER:
... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x440b
movl (%rbx), %ecx
cmpl $0x40000001, %ecx # imm = 0x40000001
je 0x4409
cmpl $0x4000000c, %ecx # imm = 0x4000000C
je 0x4409
andl $0xff000000, %ecx # imm = 0xFF000000
movl $0x84, %eax
cmpl $0x1000000, %ecx # imm = 0x1000000
jne 0x... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_RH_NV_INDEX_Unmarshal | TPM_RC
TPMI_RH_NV_INDEX_Unmarshal(TPMI_RH_NV_INDEX *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_HANDLE_Unmarshal((TPM_HANDLE *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
if((*target < NV_INDEX_FIRST) || (*target > NV_INDEX_LAST))
return TPM_RC... | pushq %rbx
movq %rdi, %rbx
callq 0x3d80
testl %eax, %eax
jne 0x444f
movzbl 0x3(%rbx), %eax
shll $0x18, %eax
xorl %ecx, %ecx
cmpl $0x1000000, %eax # imm = 0x1000000
movl $0x84, %eax
cmovel %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_ALG_ASYM_Unmarshal | TPM_RC
TPMI_ALG_ASYM_Unmarshal(TPMI_ALG_ASYM *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
#if ALG_RSA
case TPM_ALG_RSA:
#endif ... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d1c
testl %eax, %eax
jne 0x44bc
movzwl (%r14), %ecx
cmpl $0x1, %ecx
je 0x44ba
cmpl $0x23, %ecx
je 0x44ba
movl $0x81, %eax
cmpl $0x10, %ecx
jne 0x44bc
testl %ebx, %ebx
je 0x44bc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_ALG_SYM_OBJECT_Unmarshal | TPM_RC
TPMI_ALG_SYM_OBJECT_Unmarshal(TPMI_ALG_SYM_OBJECT *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
#if ALG_TDES
case TPM_ALG... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d1c
testl %eax, %eax
jne 0x4531
movzwl (%r14), %ecx
cmpl $0x3, %ecx
je 0x452f
cmpl $0x6, %ecx
je 0x452f
movl $0x96, %eax
cmpl $0x10, %ecx
jne 0x4531
testl %ebx, %ebx
je 0x4531
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_ALG_SIG_SCHEME_Unmarshal | TPM_RC
TPMI_ALG_SIG_SCHEME_Unmarshal(TPMI_ALG_SIG_SCHEME *target, BYTE **buffer, INT32 *size, BOOL flag)
{
TPM_RC result;
result = TPM_ALG_ID_Unmarshal((TPM_ALG_ID *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
#if ALG_ECDAA
case TPM_AL... | pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
callq 0x3d1c
testl %eax, %eax
jne 0x45da
movzwl (%r14), %ecx
movl $0x92, %eax
cmpl $0x1c, %ecx
ja 0x45da
movl $0x15500020, %edx # imm = 0x15500020
btl %ecx, %edx
jae 0x45e2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x10, %ecx
jn... | /Azure[P]azure-utpm-c/src/Marshal.c |
TPMI_ST_COMMAND_TAG_Unmarshal | TPM_RC
TPMI_ST_COMMAND_TAG_Unmarshal(TPMI_ST_COMMAND_TAG *target, BYTE **buffer, INT32 *size)
{
TPM_RC result;
result = TPM_ST_Unmarshal((TPM_ST *)target, buffer, size);
if(result != TPM_RC_SUCCESS)
return result;
switch (*target) {
case TPM_ST_NO_SESSIONS:
case TPM_ST_SESSION... | pushq %rbx
movq %rdi, %rbx
callq 0x3d1c
testl %eax, %eax
jne 0x4641
movzwl (%rbx), %eax
addl $0x7fff, %eax # imm = 0x7FFF
xorl %ecx, %ecx
cmpw $0x2, %ax
pushq $0x1e
popq %rax
cmovbl %ecx, %eax
popq %rbx
retq
| /Azure[P]azure-utpm-c/src/Marshal.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.