name string | code string | asm string | file string |
|---|---|---|---|
Catch::RunContext::handleIncomplete(Catch::AssertionInfo const&) | void RunContext::handleIncomplete(
AssertionInfo const& info
) {
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
AssertionResult ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
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 0x10(%rsp), %r15
movq %r15, ... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Session::Session() | Session::Session() {
static bool alreadyInstantiated = false;
if( alreadyInstantiated ) {
CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x6b8ab(%rip), %rax # 0x8f308
movq %rax, (%rdi)
leaq 0x6e029(%rip), %rax # 0x91a90
movq %rax, 0x8(%rdi)
leaq 0x6d8ce(%rip), %rbp # 0x91340
movq %rbp, 0x10(%rdi)
leaq 0x18(%rdi), %rsi
movq $0x0, 0x18(%rdi)... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::TestCaseInfo::TestCaseInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11:... | TestCaseInfo::TestCaseInfo( std::string const& _name,
std::string const& _className,
std::string const& _description,
std::vector<std::string> const& _tags,
SourceLineInfo const& _lineInfo )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r13
movq %r8, %r15
movq %rcx, %rbp
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4e742
leaq 0x20(%r... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::TestRegistry::registerTest(Catch::TestCase const&) | void TestRegistry::registerTest( TestCase const& testCase ) {
std::string name = testCase.getTestCaseInfo().name;
if( name.empty() ) {
ReusableStringStream rss;
rss << "Anonymous test case " << ++m_unnamedCount;
return registerTest( testCase.withName( rss.str() ) );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x4e742
cmpq $0x0, 0x8(%r15)
je 0x27306
addq $0x8, %rbx
m... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::TestCaseTracking::SectionTracker::SectionTracker(Catch::TestCaseTracking::NameAndLocation const&, Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::ITracker*) | SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
: TrackerBase( nameAndLocation, ctx, parent ),
m_trimmed_name(trim(nameAndLocation.name))
{
if( parent ) {
while( !parent->isSectionTracker() )
parent = &... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x6767b(%rip), %rax # 0x8f3a0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x4e742
movups 0x20(%r15... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*) | std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x29b85
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x12460
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x648d2
movq %rbx, %rdi
movq %r15, %rsi
... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::WildcardPattern::normaliseString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string WildcardPattern::normaliseString( std::string const& str ) const {
return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x1, 0x8(%rsi)
jne 0x2a2b7
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1df4c
jmp 0x2a2d2
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x4e742
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b041
leaq 0x10... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::CompactReporter::assertionEnded(Catch::AssertionStats const&) | bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
AssertionResult const& result = _assertionStats.assertionResult;
bool printInfoMessages = true;
// Drop out if result was successful and we're not printing those
if( !m_config->includeSucces... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x2b21b
movl 0x90(%r15), %eax
testb $0x10, %al
je 0x2b210
movl 0x38(%r15), %ecx
andl $0x8, %ecx
je 0x2b21b
xorl %ebp, %ebp
c... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::ConsoleReporter::printOpenHeader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ConsoleReporter::printOpenHeader(std::string const& _name) {
stream << getLineOfChars<'-'>() << '\n';
{
Colour colourGuard(Colour::Headers);
printHeaderString(_name);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %r15
cmpb $0x0, 0x6519f(%rip) # 0x93f90
jne 0x2ee24
movaps 0x39276(%rip), %xmm0 # 0x68070
movups %xmm0, 0x651ce(%rip) # 0x93fcf
movaps %xmm0, 0x651b8(%rip) # 0x93fc0
movaps %xmm0, 0x651a1(%rip) # 0x93... | /olegtarasov[P]fastText/src/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 $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3b81a(%rip), %rsi # 0x6a6d9
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x12980
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
lea... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::JunitReporter::JunitReporter(Catch::ReporterConfig const&) | JunitReporter::JunitReporter( ReporterConfig const& _config )
: CumulativeReporterBase( _config ),
xml( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x443d4
leaq 0x6056a(%rip), %rax # 0x8f778
movq %rax, (%rbx)
leaq 0xd8(%rbx), %rdi
movq (%r14), %rsi
callq 0x2aa42
xorl %eax, %eax
movq %rax, 0x120(%rbx)
leaq 0x138(%rbx), %rcx
movq %rcx, 0x128(%rbx)
movq %rax, 0x130(%rbx)
movb %al, 0x138(%rbx)
... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::JunitReporter::testRunStarting(Catch::TestRunInfo const&) | void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
CumulativeReporterBase::testRunStarting( runInfo );
xml.startElement( "testsuites" );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3b938(%rip), %rsi # 0x6ac86
leaq 0x3b93b(%rip), %rdx # 0x6ac90
movq %rsp, %r14
movq %r14, %rdi
callq 0x464e0
addq $0xd8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x2ab70
movq (... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::JunitReporter::writeAssertion(Catch::AssertionStats const&) | bool AssertionResult::isOk() const {
return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl 0x90(%rsi), %eax
testb $0x10, %al
je 0x30fa8
movq %rsi, %r14
movl 0x38(%rsi), %ecx
andl $0x8, %ecx
jne 0x30fa8
movq %rdi, %rbx
leaq 0x70(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movl $0x7, %r8d
leaq... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::ListeningReporter::getSupportedVerbosities() | std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
return std::set<Verbosity>{ };
} | movq %rdi, %rax
leaq 0x8(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
retq
| /olegtarasov[P]fastText/src/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x148, %rdi # imm = 0x148
movq 0x150(%r15), %rsi
addq $-0x50, %rsi
movq %rsi, 0x150(%r15)
callq 0x4d80e
movl 0x1b8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1b8(%r15)
cmpl $0x2, %eax
jl 0x329ee
... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::XmlReporter::testRunEnded(Catch::TestRunStats const&) | void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
StreamingReporterBase::testRunEnded( testRunStats );
m_xml.scopedElement( "OverallResults" )
.writeAttribute( "successes", testRunStats.totals.assertions.passed )
.writeAttribute( "failures", testRunStats.totals... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x451ba
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x37dce(%rip), %rsi # 0x6aef4
leaq 0x37dd5(%rip), %rdx # 0x6af02
leaq 0x8(%rsp), %rdi
callq 0x464e0
addq $0x170, %rbx # im... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::~PosixColourImpl() | 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... | movl $0x8, %esi
jmp 0x12570
| /olegtarasov[P]fastText/src/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 0x3d375
movl %esi, %eax
leaq 0x2af7f(%rip), %rcx # 0x68204
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2e5b9(%rip), %rdi # 0x6b84e
jmp 0x3d2f8
leaq 0x2e5f3(%rip), %rdi # 0x6b891
jmp 0x3d2f8
leaq 0x2e5d5(%rip), %rdi # 0x6b87c
jmp 0x3d2f8
le... | /olegtarasov[P]fastText/src/catch.hpp |
(anonymous namespace)::bothOrAll[abi:cxx11](unsigned long) | std::string bothOrAll( std::size_t count ) {
return count == 1 ? std::string() :
count == 2 ? "both " : "all " ;
} | pushq %rbx
movq %rdi, %rbx
cmpq $0x1, %rsi
jne 0x3dd50
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x3dd82
xorl %eax, %eax
cmpq $0x2, %rsi
leaq 0x2e351(%rip), %rcx # 0x6c0ae
leaq 0x2e350(%rip), %rsi # 0x6c0b4
cmoveq %rcx, %rsi
sete %al
leaq 0x10(%rbx), %rcx
movq %rcx, ... | /olegtarasov[P]fastText/src/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x12290
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r12
movq %rbp, -0x18(%r12)
leaq 0x5... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_2>::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x12290
xorl %eax, %eax
leaq 0x88(%rsp), %rbp
movq %rax, -0x18(%rbp)
leaq 0x... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x12290
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r12
movq %rbp, -0x18(%r12)
leaq 0x... | /olegtarasov[P]fastText/src/catch.hpp |
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 0x50b9b(%rip), %rax # 0x910e8
movq %rax, -0x148(%rdi)
leaq 0x50c0d(%rip), %rax # 0x91168
movq %rax, -0x140(%rdi)
leaq 0x50c57(%rip), %rax # 0x911c0
movq %rax, -0x138(%rdi)
leaq 0x4f759(%rip), %rax # 0x8fcd0
movq %rax, -0x20(%rdi)
addq $-0x18, %rdi
callq 0x4e4c0
leaq -0x38... | /olegtarasov[P]fastText/src/catch.hpp |
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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq -0x148(%rdi), %rbx
leaq 0x50ae1(%rip), %rax # 0x910e8
movq %rax, -0x148(%rdi)
leaq 0x50b53(%rip), %rax # 0x91168
movq %rax, -0x140(%rdi)
leaq 0x50b9d(%rip), %rax # 0x911c0
movq %rax, -0x138(%rdi)
leaq 0x4f69f(%rip), %rax # 0x8fcd0
movq %rax, -0x20(%r... | /olegtarasov[P]fastText/src/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 0x503a6(%rip), %rbp # 0x91a90
movq %rbp, 0x8(%rsp)
leaq 0x4fc4a(%rip), %rax # 0x91340
movq %rax, 0x10(%rsp)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsi), %rax
mo... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::AssertionResult::~AssertionResult() | AssertionResult() = delete; | pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x420ec
movq (%rax), %rsi
incq %rsi
callq 0x12570
movq 0x38(%rbx), %rdi
addq $0x48, %rbx
cmpq %rbx, %rdi
je 0x42105
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x12570
popq %rbx
retq
nop
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::StreamingReporterBase<Catch::ConsoleReporter>::testRunEnded(Catch::TestRunStats const&) | void testRunEnded(TestRunStats const& /* _testRunStats */) override {
currentTestCaseInfo.reset();
currentGroupInfo.reset();
currentTestRunInfo.reset();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x4d73e
xorl %ebp, %ebp
movb %bpl, 0x140(%rbx)
leaq 0x50(%rbx), %rdi
callq 0x4d7b6
movb %bpl, 0x88(%rbx)
leaq 0x20(%rbx), %rdi
callq 0x4d7e2
movb %bpl, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::StreamingReporterBase<Catch::ConsoleReporter>::testRunStarting(Catch::TestRunInfo const&) | void testRunStarting(TestRunInfo const& _testRunInfo) override {
currentTestRunInfo = _testRunInfo;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
callq 0x4d7e2
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e742
movq %r15, 0x20(%r14)
movb $0x0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::CumulativeReporterBase<Catch::JunitReporter>::testCaseEnded(Catch::TestCaseStats const&) | void testCaseEnded(TestCaseStats const& testCaseStats) override {
auto node = std::make_shared<TestCaseNode>(testCaseStats);
assert(m_sectionStack.size() == 0);
node->children.push_back(m_rootSection);
m_testCases.push_back(node);
m_rootSection.reset();
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %rbx, %rcx
callq 0x659ac
movq 0xc0(%r14), %rax
cmpq 0xb8(%r14), %rax
jne 0x44703
movl $0x138, %edi # imm = 0x138
addq 0x8(%rsp), %rdi
leaq 0x98(%r1... | /olegtarasov[P]fastText/src/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 0x65f5e
movq (%r14), %rax
movq 0x90(%rax), %rcx
movups 0x50(%rbx), %xmm0
movups 0x80(%rax), %xmm1
movups %xmm0, 0x80(%rax)
movq 0x60(%rbx), %... | /olegtarasov[P]fastText/src/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 0x4ab15(%rip), %rax # 0x8f328
movq %rax, (%rsp)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x5fd32
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r1... | /olegtarasov[P]fastText/src/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 0x4aa39(%rip), %rax # 0x8f328
movq %rax, (%rsp)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, %r15
movq %rax, 0x8(%rsp)
callq 0x5fd32
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %r15
movq %r1... | /olegtarasov[P]fastText/src/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4a95d(%rip), %rax # 0x8f328
movq %rax, (%rsp)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x5fd32
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [1]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [1]) | 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 0x4a877(%rip), %rax # 0x8f328
movq %rax, (%rsp)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x5fd32
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [5]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [5]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
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 0x4a791(%rip), %rax # 0x8f328
movq %rax, (%rsp)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x5fd32
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /olegtarasov[P]fastText/src/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 %rdi, %rbx
leaq 0x4d033(%rip), %rax # 0x91e20
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x44e1a
movq 0x4e18c(%rip), %rcx # 0x92f98
cmpb $0x0, (%rcx)
je 0... | /olegtarasov[P]fastText/src/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 0x4a365(%rip), %rax # 0x8f328
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
callq 0x5fd32
leaq 0x8(%rax), %rdi
callq 0x42f3e
movq %rax, 0x8(%r12)
callq 0x5fd32
movq 0x8(%r12), %rcx
movq 0x8(%rax), %rax
movq (... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::StreamingReporterBase<Catch::XmlReporter>::testRunStarting(Catch::TestRunInfo const&) | void testRunStarting(TestRunInfo const& _testRunInfo) override {
currentTestRunInfo = _testRunInfo;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %rdi
callq 0x4d7e2
leaq 0x28(%r14), %r15
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4e742
movq %r15, 0x20(%r14)
movb $0x0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::clara::detail::ExeName::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto set( std::string const& newName ) -> ParserResult {
auto lastSlash = newName.find_last_of( "\\/" );
auto filename = ( lastSlash == std::string::npos )
? newName
: newName.substr( lastSlash+1 );
*m_name = filename;
if( m_ref )... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22414(%rip), %rsi # 0x6b84b
movl $0x2, %ecx
movq %rdx, %rdi
movq $-0x1, %rdx
callq 0x12b00
cmpq $-0x1, %rax
je 0x4946b
incq %rax
movq %rsp, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x125c0
jmp... | /olegtarasov[P]fastText/src/catch.hpp |
Core::setup() | void Core::setup()
{
if (!_f.setPath("rsrc/amaya_header.txt"))
return;
for (const std::string &s : _f.getContent())
std::cout << s << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb460
movq -0x80(%rbp), %rdx
leaq 0x5c53(%rip), %rsi # 0x1206c
leaq -0x28(%rbp), %rdi
callq 0xb900
jmp 0xc424
movq -0x90(%rbp), ... | /AmayaHena[P]UWU/src/Core.cpp |
Core::dataCheck() | bool Core::dataCheck()
{
if (!_p.checkHeaders(_f.getContent()))
return error("Your UWU(s) aren't good!");
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movq %rsi, %rax
addq $0x60, %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xda50
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xec30
movb %al, -0x5a(%rbp)
jmp 0xc731
... | /AmayaHena[P]UWU/src/Core.cpp |
Core::keysCheck() | bool Core::keysCheck()
{
if (!_p.loadKeys())
return error("Missing keyword_lists.txt in rsrc!", true);
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x60, %rdi
callq 0xeef0
testb $0x1, %al
jne 0xc8b9
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xb460
movq -0x58(%rbp), %rdx
leaq 0x587b(%rip), %rsi # 0x120c8
leaq -0x30(%rbp), %rdi
callq ... | /AmayaHena[P]UWU/src/Core.cpp |
Parsing::File::load() | bool File::load() noexcept
{
parseExt(_path);
_name = parseName(_path);
if (!isFile())
return false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
addq $0x40, %rsi
leaq -0x30(%rbp), %rdi
callq 0xb110
jmp 0xd696
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdc60
jmp 0xd6a5
leaq -0x30(%rbp), %rdi
callq 0xb1c0
movq -0x78(%rbp), %rsi
addq $0x40, %r... | /AmayaHena[P]UWU/src/Parsing/File.cpp |
Parsing::File::rm() const | bool File::rm() const noexcept
{
if (!isFile() || _path.empty())
return false;
if (remove(_path.c_str()) != 0)
return false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xe000
testb $0x1, %al
jne 0xd9ff
jmp 0xda12
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0xb410
testb $0x1, %al
jne 0xda12
jmp 0xda18
movb $0x0, -0x1(%rbp)
jmp 0xda3c
movq -0x18(%rbp), %rdi
addq $0x4... | /AmayaHena[P]UWU/src/Parsing/File.cpp |
Parsing::File::getLength(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const | size_t File::getLength(std::string &s) const
{
size_t p = s.find_last_of("/") + 1;
for (size_t n = p; s[n]; n++)
if (s[n] == '.')
return n - p;
return p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x4356(%rip), %rsi # 0x12231
movq $-0x1, %rdx
callq 0xb270
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0... | /AmayaHena[P]UWU/src/Parsing/File.cpp |
bool duckdb::TryCast::Operation<unsigned char, int>(unsigned char, int&, bool) | static bool TryCastWithOverflowCheck(SRC value, DST &result) {
if (!Value::IsFinite<SRC>(value)) {
return false;
}
if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
if (NumericLimits<SRC>::IsSigned()) {
// signed to unsigned conversion
if (NumericLimits<SRC>::Digits() > NumericLimits<... | movl %edi, (%rsi)
movb $0x1, %al
retq
nop
| /duckdb[P]duckdb/src/include/duckdb/common/operator/numeric_cast.hpp |
bool duckdb::TryCast::Operation<unsigned short, long>(unsigned short, long&, bool) | static bool TryCastWithOverflowCheck(SRC value, DST &result) {
if (!Value::IsFinite<SRC>(value)) {
return false;
}
if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
if (NumericLimits<SRC>::IsSigned()) {
// signed to unsigned conversion
if (NumericLimits<SRC>::Digits() > NumericLimits<... | movl %edi, %eax
movq %rax, (%rsi)
movb $0x1, %al
retq
| /duckdb[P]duckdb/src/include/duckdb/common/operator/numeric_cast.hpp |
bool duckdb::TryCast::Operation<unsigned int, short>(unsigned int, short&, bool) | static bool TryCastWithOverflowCheck(SRC value, DST &result) {
if (!Value::IsFinite<SRC>(value)) {
return false;
}
if (NumericLimits<SRC>::IsSigned() != NumericLimits<DST>::IsSigned()) {
if (NumericLimits<SRC>::IsSigned()) {
// signed to unsigned conversion
if (NumericLimits<SRC>::Digits() > NumericLimits<... | cmpl $0x7fff, %edi # imm = 0x7FFF
ja 0x116210d
movw %di, (%rsi)
cmpl $0x8000, %edi # imm = 0x8000
setb %al
retq
nop
| /duckdb[P]duckdb/src/include/duckdb/common/operator/numeric_cast.hpp |
bool duckdb::StandardNumericToDecimalCast<long, short, duckdb::SignedToDecimalOperator>(long, short&, duckdb::CastParameters&, unsigned char, unsigned char) | bool StandardNumericToDecimalCast(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) {
// check for overflow
DST max_width = UnsafeNumericCast<DST>(NumericHelper::POWERS_OF_TEN[width - scale]);
if (OP::template Operation<SRC, DST>(input, max_width)) {
string error = StringUtil::Forma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rdi, %r15
movl %ecx, %edx
movl %r8d, %eax
subq %rax, %rdx
movq 0x1577ea2(%rip), %rcx # 0x26e5100
movswq (%rcx,%rdx,8), %rdx
cmpq %rdi, %rdx
setg %dil
negq %rdx
cmpq %r15, %rdx
setl %bl
andb %dil, %bl
je 0x11... | /duckdb[P]duckdb/src/common/operator/cast_operators.cpp |
bool duckdb::StandardNumericToDecimalCast<unsigned char, short, duckdb::UnsignedToDecimalOperator>(unsigned char, short&, duckdb::CastParameters&, unsigned char, unsigned char) | bool StandardNumericToDecimalCast(SRC input, DST &result, CastParameters ¶meters, uint8_t width, uint8_t scale) {
// check for overflow
DST max_width = UnsafeNumericCast<DST>(NumericHelper::POWERS_OF_TEN[width - scale]);
if (OP::template Operation<SRC, DST>(input, max_width)) {
string error = StringUtil::Forma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r14d
movq %rdx, %rbx
movl %ecx, %edx
movl %r8d, %eax
subq %rax, %rdx
movq 0x1577adc(%rip), %rcx # 0x26e5100
movswq (%rcx,%rdx,8), %r12
movl %edi, %r13d
cmpq %r13, %r12
jbe 0x116d63d
movl (%rcx,%rax,8), %eax
imull %r13d, %ea... | /duckdb[P]duckdb/src/common/operator/cast_operators.cpp |
void duckdb::ColumnDataCopy<duckdb::uhugeint_t>(duckdb::ColumnDataMetaData&, duckdb::UnifiedVectorFormat const&, duckdb::Vector&, unsigned long, unsigned long) | static void ColumnDataCopy(ColumnDataMetaData &meta_data, const UnifiedVectorFormat &source_data, Vector &source,
idx_t offset, idx_t copy_count) {
TemplatedColumnDataCopy<StandardValueCopy<T>>(meta_data, source_data, source, offset, copy_count);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x20(%rdi), %r13
movq %rax, 0x20(%rsp)
addq $0x48, %rax
movq %rax, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x10... | /duckdb[P]duckdb/src/common/types/column/column_data_collection.cpp |
duckdb::ColumnDataCollection::Verify() | void ColumnDataCollection::Verify() {
#ifdef DEBUG
// verify counts
idx_t total_segment_count = 0;
for (auto &segment : segments) {
segment->Verify();
total_segment_count += segment->count;
}
D_ASSERT(total_segment_count == this->count);
#endif
} | retq
nop
| /duckdb[P]duckdb/src/common/types/column/column_data_collection.cpp |
duckdb::ColumnDataCollectionSegment::ReadVectorInternal(duckdb::ChunkManagementState&, duckdb::VectorDataIndex, duckdb::Vector&) | idx_t ColumnDataCollectionSegment::ReadVectorInternal(ChunkManagementState &state, VectorDataIndex vector_index,
Vector &result) {
auto &vector_type = result.GetType();
auto internal_type = vector_type.InternalType();
auto type_size = GetTypeIdSize(internal_type)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movq %rcx, %r13
movzbl 0x9(%rcx), %edi
callq 0x10fcdb0
movq %rax, 0x8(%rsp)
leaq 0x48(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x10e9fe0
movq %rax, %r15
movq %rbx, 0x30(%rsp)
movq ... | /duckdb[P]duckdb/src/common/types/column/column_data_collection_segment.cpp |
duckdb::ColumnDataCollectionSegment::ReadVector(duckdb::ChunkManagementState&, duckdb::VectorDataIndex, duckdb::Vector&) | idx_t ColumnDataCollectionSegment::ReadVector(ChunkManagementState &state, VectorDataIndex vector_index,
Vector &result) {
auto &vector_type = result.GetType();
auto internal_type = vector_type.InternalType();
auto &vdata = GetVectorData(vector_index);
if (vdata.count =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x28(%rsp)
leaq 0x48(%rdi), %rbp
movq %rdi, 0x20(%rsp)
leaq 0x60(%rdi), %rax
movq %rax, 0x30(%rsp)
xorl %r13d, %r13d
movzbl 0x9(%r12), %r14d
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x10e9fe0
movq ... | /duckdb[P]duckdb/src/common/types/column/column_data_collection_segment.cpp |
duckdb::PartitionedColumnData::FlushAppendState(duckdb::PartitionedColumnDataAppendState&) | void PartitionedColumnData::FlushAppendState(PartitionedColumnDataAppendState &state) {
for (idx_t i = 0; i < state.partition_buffers.size(); i++) {
if (!state.partition_buffers[i]) {
continue;
}
auto &partition_buffer = *state.partition_buffers[i];
if (partition_buffer.size() > 0) {
partitions[i]->Appen... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x130(%rsi), %r15
addq $0x68, %r14
xorl %r12d, %r12d
movq 0x138(%rbx), %rax
subq 0x130(%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0x1198425
movq %r15, %rdi
movq %r12, %rsi
callq 0xff8870
cmpq $0x0, (%rax)
je 0x1198420
movq ... | /duckdb[P]duckdb/src/common/types/column/partitioned_column_data.cpp |
duckdb::PartitionedColumnData::Combine(duckdb::PartitionedColumnData&) | void PartitionedColumnData::Combine(PartitionedColumnData &other) {
// Now combine the state's partitions into this
lock_guard<mutex> guard(lock);
if (partitions.empty()) {
// This is the first merge, we just copy them over
partitions = std::move(other.partitions);
} else {
D_ASSERT(partitions.size() == othe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r13
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x10abd70
leaq 0x68(%r13), %r15
movq 0x68(%r13), %rax
leaq 0x68(%r14), %r12
cmpq 0x70(%r13), %rax
je 0x11984ff
xorl %r13d, %r13d
movq 0x70(%r14), %rax
subq 0x68(%r14),... | /duckdb[P]duckdb/src/common/types/column/partitioned_column_data.cpp |
void duckdb::PartitionedColumnData::BuildPartitionSel<true>(duckdb::PartitionedColumnDataAppendState&, unsigned long) | void PartitionedColumnData::BuildPartitionSel(PartitionedColumnDataAppendState &state, const idx_t append_count) {
using GETTER = TemplatedMapGetter<list_entry_t, fixed>;
auto &partition_entries = state.GetMap<fixed>();
partition_entries.clear();
const auto partition_indices = FlatVector::GetData<idx_t>(state.parti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb8(%rdi), %r15
movq %r15, %rdi
callq 0x108fbe0
movq 0x20(%r14), %r12
movzbl (%r14), %eax
cmpl $0x2, %eax
movq %rbx, 0x10(%rsp)
je 0x1199ccb
testl %eax, %eax
jne 0x1199d80
leaq 0x18(%rsp), %r13
movq ... | /duckdb[P]duckdb/src/common/types/column/partitioned_column_data.cpp |
duckdb::vector<duckdb::ChunkMetaData, true>::AssertIndexInBounds(unsigned long, unsigned long) | static inline void AssertIndexInBounds(idx_t index, idx_t size) {
#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
return;
#else
if (DUCKDB_UNLIKELY(index >= size)) {
throw InternalException("Attempted to access index %ld within vector of size %ld", index, size);
}
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq %rsi, %rdi
jae 0x119d4d6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax, %rbx
leaq 0xd0ebcb(%rip), %rsi # 0x1eac0b9
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rd... | /duckdb[P]duckdb/src/include/duckdb/common/vector.hpp |
void duckdb::Serializer::WriteValue<duckdb::LogicalType>(duckdb::vector<duckdb::LogicalType, true> const&) | void WriteValue(const vector<T> &vec) {
auto count = vec.size();
OnListBegin(count);
for (auto &item : vec) {
WriteValue(item);
}
OnListEnd();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x40(%rcx)
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, %r14
je 0x119e45a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c0930
addq $0x18... | /duckdb[P]duckdb/src/include/duckdb/common/serializer/serializer.hpp |
std::enable_if<is_vector<duckdb::vector<duckdb::LogicalType, true>>::value, duckdb::vector<duckdb::LogicalType, true>>::type duckdb::Deserializer::Read<duckdb::vector<duckdb::LogicalType, true>>() | inline typename std::enable_if<is_vector<T>::value, T>::type Read() {
using ELEMENT_TYPE = typename is_vector<T>::ELEMENT_TYPE;
T vec;
auto size = OnListBegin();
for (idx_t i = 0; i < size; i++) {
vec.push_back(Read<ELEMENT_TYPE>());
}
OnListEnd();
return vec;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x40(%rax)
movq %rax, %r15
movq %rsp, %r12
subq $0x1, %r15
jb 0x119e57b
movq %r12, %rdi
movq %r14, %rsi
callq 0x10de600
movq... | /duckdb[P]duckdb/src/include/duckdb/common/serializer/deserializer.hpp |
duckdb::BaseUUID::FromUHugeint(duckdb::uhugeint_t) | hugeint_t BaseUUID::FromUHugeint(uhugeint_t input) {
hugeint_t result;
result.lower = input.lower;
if (input.upper > uint64_t(NumericLimits<int64_t>::Maximum())) {
result.upper = int64_t(input.upper - uint64_t(NumericLimits<int64_t>::Maximum()) - 1);
} else {
result.upper = int64_t(input.upper) - NumericLimits<... | movq %rsi, %rdx
movq %rdi, %rax
btcq $0x3f, %rdx
retq
| /duckdb[P]duckdb/src/common/types/uuid.cpp |
duckdb::HyperLogLog::Serialize(duckdb::Serializer&) const | void HyperLogLog::Serialize(Serializer &serializer) const {
if (serializer.ShouldSerialize(3)) {
serializer.WriteProperty(100, "type", HLLStorageType::HLL_V2);
serializer.WriteProperty(101, "data", k, sizeof(k));
} else {
auto old = make_uniq<HLLV1>();
old->FromNew(*this);
serializer.WriteProperty(100, "ty... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %rdi
pushq $0x3
popq %rsi
callq 0x108b470
testb %al, %al
je 0x11aacc8
leaq 0x7(%rsp), %rcx
movb $0x2, (%rcx)
leaq 0xd6109d(%rip), %rdx # 0x1f0bd3f
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0x10a1c00
leaq 0xdfebad(%ri... | /duckdb[P]duckdb/src/common/types/hyperloglog.cpp |
duckdb::HyperLogLog::Deserialize(duckdb::Deserializer&) | unique_ptr<HyperLogLog> HyperLogLog::Deserialize(Deserializer &deserializer) {
auto result = make_uniq<HyperLogLog>();
auto storage_type = deserializer.ReadProperty<HLLStorageType>(100, "type");
switch (storage_type) {
case HLLStorageType::HLL_V1: {
auto old = make_uniq<HLLV1>();
deserializer.ReadProperty(101, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1008ab0
leaq 0xd60fbf(%rip), %rdx # 0x1f0bd3f
pushq $0x64
popq %rsi
movq %r14, %rdi
callq 0x10371c0
cmpb $0x1, %al
je 0x11aadbe
movzbl %al, %eax
cmpl $0x2, %eax
jne 0x11aae37
movq %rbx, %rdi
callq 0xfe9180
leaq 0xdfe... | /duckdb[P]duckdb/src/common/types/hyperloglog.cpp |
duckdb::Interval::FromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, duckdb::interval_t&) | bool Interval::FromString(const string &str, interval_t &result) {
string error_message;
return Interval::FromCString(str.c_str(), str.size(), result, &error_message, false);
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq %rsp, %rcx
movq %rax, %rdi
xorl %r8d, %r8d
callq 0xfedd30
movl %eax, %ebx
movq %rsp, %rdi
callq 0x10c92b0
movl %ebx, %eax
addq $0x20, %rsp
popq %rb... | /duckdb[P]duckdb/src/common/types/interval.cpp |
duckdb::Interval::GetMicro(duckdb::interval_t const&) | int64_t Interval::GetMicro(const interval_t &val) {
int64_t micro_month, micro_day, micro_total;
micro_total = val.micros;
if (!TryMultiplyOperator::Operation((int64_t)val.months, MICROS_PER_MONTH, micro_month)) {
throw ConversionException("Could not convert Month to Microseconds");
}
if (!TryMultiplyOperator::O... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rbx
movq %rbx, 0x8(%rsp)
movslq (%rdi), %rdi
movabsq $0x25b7f3d4000, %rsi # imm = 0x25B7F3D4000
leaq 0x38(%rsp), %rdx
callq 0x101afd0
testb %al, %al
je 0x11ab8d9
movslq 0x4(%r14), %rdi
movabsq $0x141dd76000, %rsi # imm = 0x141DD76... | /duckdb[P]duckdb/src/common/types/interval.cpp |
duckdb::Interval::Add(duckdb::dtime_t, duckdb::interval_t, duckdb::date_t&) | dtime_t Interval::Add(dtime_t left, interval_t right, date_t &date) {
int64_t diff = right.micros - ((right.micros / Interval::MICROS_PER_DAY) * Interval::MICROS_PER_DAY);
left += diff;
if (left.micros >= Interval::MICROS_PER_DAY) {
left.micros -= Interval::MICROS_PER_DAY;
date.days++;
} else if (left.micros < ... | movq %rdx, %rax
movabsq $0x141dd75fff, %rsi # imm = 0x141DD75FFF
movabsq $0x141dd76000, %r8 # imm = 0x141DD76000
cqto
idivq %r8
movq %rdx, %rax
addq %rdi, %rax
cmpq %rsi, %rax
jle 0x11ac25a
pushq $0x1
popq %rdx
movabsq $-0x141dd76000, %rsi # imm = 0xFFFFFFEBE228A000
jmp 0x11ac266
testq %rax, %rax
js 0x11ac2... | /duckdb[P]duckdb/src/common/types/interval.cpp |
duckdb::string_t::VerifyCharacters() const | void string_t::VerifyCharacters() const {
auto dataptr = GetData();
(void)dataptr;
D_ASSERT(dataptr);
// verify that the prefix contains the first four characters of the string
for (idx_t i = 0; i < MinValue<idx_t>(PREFIX_LENGTH, GetSize()); i++) {
D_ASSERT(GetPrefix()[i] == dataptr[i]);
}
// verify that for ... | retq
nop
| /duckdb[P]duckdb/src/common/types/string_type.cpp |
duckdb::Timestamp::TryConvertTimestampTZ(char const*, unsigned long, duckdb::timestamp_t&, bool&, duckdb::string_t&, duckdb::optional_ptr<int, true>) | TimestampCastResult Timestamp::TryConvertTimestampTZ(const char *str, idx_t len, timestamp_t &result, bool &has_offset,
string_t &tz, optional_ptr<int32_t> nanos) {
idx_t pos;
date_t date;
dtime_t time;
has_offset = false;
switch (Date::TryConvertDate(str, len, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %rbx
movb $0x0, (%rcx)
leaq 0x8(%rsp), %rdx
leaq 0x14(%rsp), %rcx
movq %rdi, (%rsp)
movq %r13, %r8
xorl %r9d, %r9d
callq 0x10c7590
movl %eax, %ebp
cmpb $0x1, %al
je... | /duckdb[P]duckdb/src/common/types/timestamp.cpp |
duckdb::Timestamp::GetDate(duckdb::timestamp_t) | date_t Timestamp::GetDate(timestamp_t timestamp) {
if (DUCKDB_UNLIKELY(timestamp == timestamp_t::infinity())) {
return date_t::infinity();
}
if (DUCKDB_UNLIKELY(timestamp == timestamp_t::ninfinity())) {
return date_t::ninfinity();
}
return date_t(UnsafeNumericCast<int32_t>((timestamp.value + (timestamp.value <... | movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %rdi
je 0x11ae6f1
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, %rdi
je 0x11ae6f7
movq %rdi, %rcx
shrq $0x3f, %rcx
addq %rcx, %rdi
movabsq $0x141dd76000, %rsi # imm = 0x141DD76000
movq %rdi, %rax
cqto
idivq %rsi
subl ... | /duckdb[P]duckdb/src/common/types/timestamp.cpp |
long duckdb::Cast::Operation<duckdb::string_t, long>(duckdb::string_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x101e6f0
testb %al, %al
je 0x11bf0c9
movq (%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax, %rbx
leaq 0x28(%rsp), ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
void duckdb::IntervalTryAddition<long>(long&, long, long, long) | void IntervalTryAddition(T &target, int64_t input, int64_t multiplier, int64_t fraction = 0) {
int64_t addition;
if (!TryMultiplyOperator::Operation<int64_t, int64_t, int64_t>(input, multiplier, addition)) {
throw OutOfRangeException("interval value is out of range");
}
T addition_base = Cast::Operation<int64_t, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x101afd0
testb %al, %al
je 0x11bf278
movq 0x10(%rsp), %rdi
callq 0x1009bf0
movq (%rbx), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1069ae0
testb %al... | /duckdb[P]duckdb/src/common/types/interval.cpp |
duckdb::LogicalType duckdb::Deserializer::ReadPropertyWithExplicitDefault<duckdb::LogicalType>(unsigned short, char const*, duckdb::LogicalType) | inline T ReadPropertyWithExplicitDefault(const field_id_t field_id, const char *tag, T default_value) {
if (!OnOptionalPropertyBegin(field_id, tag)) {
OnOptionalPropertyEnd(false);
return std::forward<T>(default_value);
}
auto ret = Read<T>();
OnOptionalPropertyEnd(true);
return ret;
} | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
movl %edx, %esi
movq %rcx, %rdx
callq *0x20(%rax)
testb %al, %al
je 0x11c56f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10de600
movq (%r14), %rax
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x28(%rax)
jmp 0x1... | /duckdb[P]duckdb/src/include/duckdb/common/serializer/deserializer.hpp |
duckdb::shared_ptr<duckdb::VectorBuffer, true>::operator=(duckdb::shared_ptr<duckdb::VectorBuffer, true> const&) | shared_ptr<T> &operator=(const shared_ptr &other) noexcept {
if (this == &other) {
return *this;
}
// Create a new shared_ptr using the copy constructor, then swap out the ownership to *this
shared_ptr(other).swap(*this);
return *this;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x11c6143
movq %rsp, %rdi
callq 0x1102c80
leaq 0x8(%rsp), %rdi
movups (%rbx), %xmm0
movaps -0x8(%rdi), %xmm1
movups %xmm1, (%rbx)
movaps %xmm0, -0x8(%rdi)
callq 0x108e8f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /duckdb[P]duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp |
duckdb::shared_ptr<duckdb::VectorBuffer, true>& duckdb::shared_ptr<duckdb::VectorBuffer, true>::operator=<duckdb::VectorStringBuffer, 0>(duckdb::shared_ptr<duckdb::VectorStringBuffer, true>&&) | shared_ptr<T> &operator=(shared_ptr<U> &&other) {
shared_ptr(std::move(other)).swap(*this);
return *this;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movups (%rsi), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, (%rsi)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
movaps %xmm1, -0x8(%rdi)
callq 0x108e8f0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /duckdb[P]duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp |
duckdb::Vector const& duckdb::ListVector::GetEntryInternal<duckdb::Vector const>(duckdb::Vector const&) | T &ListVector::GetEntryInternal(T &vector) {
D_ASSERT(vector.GetType().id() == LogicalTypeId::LIST || vector.GetType().id() == LogicalTypeId::MAP);
if (vector.GetVectorType() == VectorType::DICTIONARY_VECTOR) {
auto &child = DictionaryVector::Child(vector);
return ListVector::GetEntry(child);
}
D_ASSERT(vector.... | pushq %rax
cmpb $0x3, (%rdi)
jne 0x11c683a
callq 0x100d5f0
movq %rax, %rdi
jmp 0x11c682b
addq $0x58, %rdi
callq 0x104e850
leaq 0x30(%rax), %rdi
popq %rax
jmp 0x1017860
nop
| /duckdb[P]duckdb/src/common/types/vector.cpp |
signed char duckdb::Cast::Operation<int, signed char>(int) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0xf(%rsp), %rsi
xorl %edx, %edx
callq 0x1059cd0
testb %al, %al
je 0x11cc667
movb 0xf(%rsp), %al
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax, ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
signed char duckdb::Cast::Operation<long, signed char>(long) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0xf(%rsp), %rsi
xorl %edx, %edx
callq 0x10adf40
testb %al, %al
je 0x11cc85c
movb 0xf(%rsp), %al
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax, ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
signed char duckdb::Cast::Operation<duckdb::uhugeint_t, signed char>(duckdb::uhugeint_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7(%rsp), %rdx
xorl %ecx, %ecx
callq 0x1006570
testb %al, %al
je 0x11ccc5b
movb 0x7(%rsp), %al
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
signed char duckdb::Cast::Operation<duckdb::date_t, signed char>(duckdb::date_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0xf(%rsp), %rsi
xorl %edx, %edx
callq 0x1074410
testb %al, %al
je 0x11cce55
movb 0xf(%rsp), %al
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax, ... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
signed char duckdb::Cast::Operation<float, signed char>(float) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
leaq 0xb(%rsp), %rdi
movss %xmm0, 0xc(%rsp)
xorl %esi, %esi
callq 0x107fd40
testb %al, %al
je 0x11ce5dd
movb 0xb(%rsp), %al
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
short duckdb::Cast::Operation<long, short>(long) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0xe(%rsp), %rsi
xorl %edx, %edx
callq 0x10c6d10
testb %al, %al
je 0x11cfd2d
movzwl 0xe(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %ra... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
unsigned short duckdb::Cast::Operation<duckdb::date_t, unsigned short>(duckdb::date_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0xe(%rsp), %rsi
xorl %edx, %edx
callq 0x104b250
testb %al, %al
je 0x11de3e0
movzwl 0xe(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %ra... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
unsigned int duckdb::Cast::Operation<duckdb::timestamp_t, unsigned int>(duckdb::timestamp_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x1053df0
testb %al, %al
je 0x11e1ad8
movl 0xc(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
unsigned int duckdb::Cast::Operation<duckdb::timestamp_ns_t, unsigned int>(duckdb::timestamp_ns_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x10aa160
testb %al, %al
je 0x11e20ba
movl 0xc(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
unsigned int duckdb::Cast::Operation<unsigned short, unsigned int>(unsigned short) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x10ee5d0
testb %al, %al
je 0x11e269b
movl 0xc(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
unsigned int duckdb::Cast::Operation<double, unsigned int>(double) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
leaq 0x4(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
xorl %esi, %esi
callq 0x106d560
testb %al, %al
je 0x11e2e79
movl 0x4(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
mov... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::uhugeint_t duckdb::Cast::Operation<long, duckdb::uhugeint_t>(long) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
movq %rsp, %rsi
xorl %edx, %edx
callq 0x1057f00
testb %al, %al
je 0x11e7133
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a74... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::uhugeint_t duckdb::Cast::Operation<duckdb::hugeint_t, duckdb::uhugeint_t>(duckdb::hugeint_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x10e72d0
testb %al, %al
je 0x11e7337
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
float duckdb::Cast::Operation<duckdb::timestamp_sec_t, float>(duckdb::timestamp_sec_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x103d1c0
testb %al, %al
je 0x11eaebe
movss 0xc(%rsp), %xmm0
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %ra... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
double duckdb::Cast::Operation<duckdb::dtime_t, double>(duckdb::dtime_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10e9e40
testb %al, %al
je 0x11ed80e
movsd 0x8(%rsp), %xmm0
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %ra... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::date_t duckdb::Cast::Operation<unsigned char, duckdb::date_t>(unsigned char) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x100da40
testb %al, %al
je 0x11f16ef
movl 0xc(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::date_t duckdb::Cast::Operation<float, duckdb::date_t>(float) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
leaq 0xc(%rsp), %rdi
movss %xmm0, 0x8(%rsp)
xorl %esi, %esi
callq 0x103bbf0
testb %al, %al
je 0x11f1ec7
movl 0xc(%rsp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
mov... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::dtime_t duckdb::Cast::Operation<duckdb::hugeint_t, duckdb::dtime_t>(duckdb::hugeint_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x10a2300
testb %al, %al
je 0x11f386b
movq (%rsp), %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %r... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::dtime_t duckdb::Cast::Operation<duckdb::timestamp_t, duckdb::dtime_t>(duckdb::timestamp_t) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10cb960
testb %al, %al
je 0x11f4249
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_ms_t duckdb::Cast::Operation<bool, duckdb::timestamp_ms_t>(bool) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x103c320
testb %al, %al
je 0x11fcd68
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_ms_t duckdb::Cast::Operation<short, duckdb::timestamp_ms_t>(short) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10a7020
testb %al, %al
je 0x11fd154
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_ms_t duckdb::Cast::Operation<long, duckdb::timestamp_ms_t>(long) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x103fe50
testb %al, %al
je 0x11fd53f
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_tz_t duckdb::Cast::Operation<short, duckdb::timestamp_tz_t>(short) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10aed90
testb %al, %al
je 0x1203b7e
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_tz_t duckdb::Cast::Operation<int, duckdb::timestamp_tz_t>(int) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %edi, %ebp
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x1100930
testb %al, %al
je 0x1203d74
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.hpp |
duckdb::timestamp_tz_t duckdb::Cast::Operation<long, duckdb::timestamp_tz_t>(long) | static inline DST Operation(SRC input) {
DST result;
if (!TryCast::Operation(input, result)) {
throw InvalidInputException(CastExceptionText<SRC, DST>(input));
}
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x10e8b50
testb %al, %al
je 0x1203f69
movq 0x8(%rsp), %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x10a7430
movq %rax,... | /duckdb[P]duckdb/src/include/duckdb/common/operator/cast_operators.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.