idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
10,700 | std::_Tuple_impl<1ul, std::default_delete<duckdb::LogicalOperator>>::_M_head(std::_Tuple_impl<1ul, std::default_delete<duckdb::LogicalOperator>>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x235b0
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,701 | std::_Head_base<1ul, std::default_delete<duckdb::LogicalOperator>, true>::_M_head(std::_Head_base<1ul, std::default_delete<duckdb::LogicalOperator>, true>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,702 | std::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>>::~unique_ptr() | ~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
get_deleter()(std::move(__ptr));
__ptr = pointer();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x241f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30ab0
movq (%rsp), %rdi
callq 0x24940
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x22970
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,703 | std::unique_ptr<duckdb::LogicalOperator, std::default_delete<duckdb::LogicalOperator>>::get_deleter() | deleter_type&
get_deleter() noexcept
{ return _M_t._M_deleter(); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23b90
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,704 | std::unique_ptr<duckdb::LogicalColumnDataGet, std::default_delete<duckdb::LogicalColumnDataGet>>::~unique_ptr() | ~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
get_deleter()(std::move(__ptr));
__ptr = pointer();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x24ad0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30b24
movq (%rsp), %rdi
callq 0x24a00
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x23750
jmp 0x30b22
jmp 0x30b24
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,705 | std::default_delete<duckdb::LogicalColumnDataGet>::operator()(duckdb::LogicalColumnDataGet*) const | void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x30b67
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,706 | std::unique_ptr<duckdb::ColumnDataCollection, std::default_delete<duckdb::ColumnDataCollection>>::~unique_ptr() | ~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
get_deleter()(std::move(__ptr));
__ptr = pointer();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x220a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x30bb4
movq (%rsp), %rdi
callq 0x23bd0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x23af0
jmp 0x30bb2
jmp 0x30bb4
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,707 | std::unique_ptr<duckdb::ColumnDataCollection, std::default_delete<duckdb::ColumnDataCollection>>::get_deleter() | deleter_type&
get_deleter() noexcept
{ return _M_t._M_deleter(); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x24e00
movq %rax, 0x8(%rsp)
jmp 0x30bea
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,708 | std::default_delete<duckdb::ColumnDataCollection>::operator()(duckdb::ColumnDataCollection*) const | void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x30c2f
movq (%rsp), %rdi
callq 0x22530
movq (%rsp), %rdi
callq 0x23880
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,709 | std::__uniq_ptr_impl<duckdb::ColumnDataCollection, std::default_delete<duckdb::ColumnDataCollection>>::_M_deleter() | _Dp& _M_deleter() { return std::get<1>(_M_t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x224a0
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,710 | std::tuple_element<1ul, std::tuple<duckdb::ColumnDataCollection*, std::default_delete<duckdb::ColumnDataCollection>>>::type& std::get<1ul, duckdb::ColumnDataCollection*, std::default_delete<duckdb::ColumnDataCollection>>(std::tuple<duckdb::ColumnDataCollection*, std::default_delete<duckdb::ColumnDataCollection>>&) | constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22460
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,711 | std::default_delete<duckdb::ColumnDataCollection>& std::__get_helper<1ul, std::default_delete<duckdb::ColumnDataCollection>>(std::_Tuple_impl<1ul, std::default_delete<duckdb::ColumnDataCollection>>&) | constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24f60
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,712 | std::_Tuple_impl<1ul, std::default_delete<duckdb::ColumnDataCollection>>::_M_head(std::_Tuple_impl<1ul, std::default_delete<duckdb::ColumnDataCollection>>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x25390
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,713 | std::_Head_base<1ul, std::default_delete<duckdb::ColumnDataCollection>, true>::_M_head(std::_Head_base<1ul, std::default_delete<duckdb::ColumnDataCollection>, true>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,714 | duckdb::shared_ptr<duckdb::OptimizerExtensionInfo, true>::~shared_ptr() | ~shared_ptr() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24f90
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp |
10,715 | std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2>::~__shared_ptr() | ~__shared_ptr() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x23a80
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,716 | std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count() | ~__shared_count() noexcept
{
if (_M_pi != nullptr)
_M_pi->_M_release();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
je 0x30cf6
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23500
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,717 | std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release() | void
_M_release() noexcept
{
// Be race-detector-friendly. For more info see bits/c++config.
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
_M_dispose();
// There must be a memory barrier between dispose() and destroy()
// to ensure that the effects of dispose() are observed in the
// thread that runs destroy().
// See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
if (_Mutex_base<_Lp>::_S_need_barriers)
{
__atomic_thread_fence (__ATOMIC_ACQ_REL);
}
// Be race-detector-friendly. For more info see bits/c++config.
_GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
-1) == 1)
{
_GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
_M_destroy();
}
}
} | subq $0x98, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movq 0xa2a2(%rip), %rax # 0x3afd0
cmpb $0x0, (%rax)
je 0x30d67
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %ecx
movq 0x50(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x48(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x30d9a
movq 0x38(%rsp), %rcx
movl 0x34(%rsp), %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movq 0x78(%rsp), %rcx
movl 0x74(%rsp), %eax
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
jne 0x30e79
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0xa1f9(%rip), %rax # 0x3afd0
cmpb $0x0, (%rax)
je 0x30e10
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x58(%rsp)
movl 0x5c(%rsp), %ecx
movq 0x60(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x58(%rsp), %eax
movl %eax, 0x30(%rsp)
jmp 0x30e5b
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
movq 0x90(%rsp), %rcx
movl 0x8c(%rsp), %eax
movl %eax, 0x88(%rsp)
movl 0x88(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
jne 0x30e77
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x30e79
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,718 | void std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::emplace_back<duckdb::OptimizerExtension>(duckdb::OptimizerExtension&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x30ed8
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x18(%rsp), %rdx
callq 0x230b0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x8(%rax)
jmp 0x30efb
movq 0x8(%rsp), %rdi
callq 0x24930
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
callq 0x23110
addq $0x28, %rsp
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
10,719 | void std::allocator_traits<std::allocator<duckdb::OptimizerExtension>>::construct<duckdb::OptimizerExtension, duckdb::OptimizerExtension>(std::allocator<duckdb::OptimizerExtension>&, duckdb::OptimizerExtension*, duckdb::OptimizerExtension&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x241c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,720 | void std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_realloc_insert<duckdb::OptimizerExtension>(__gnu_cxx::__normal_iterator<duckdb::OptimizerExtension*, std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>>, duckdb::OptimizerExtension&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | subq $0xc8, %rsp
movq %rsi, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x60(%rsp)
leaq 0x11d4(%rip), %rdx # 0x32137
movl $0x1, %esi
callq 0x22420
movq 0x60(%rsp), %rdi
movq %rax, 0xa8(%rsp)
movq (%rdi), %rax
movq %rax, 0xa0(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x98(%rsp)
callq 0x24260
movq %rax, 0x88(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x22c60
movq 0x60(%rsp), %rdi
movq %rax, 0x90(%rsp)
movq 0xa8(%rsp), %rsi
callq 0x231f0
movq 0x60(%rsp), %rdi
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rsi
movq 0x90(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq 0xb0(%rsp), %rdx
callq 0x230b0
jmp 0x3100d
movq $0x0, 0x78(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x25000
movq 0x60(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0x23470
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %rax, %rcx
callq 0x24360
movq %rax, 0x58(%rsp)
jmp 0x3106d
movq 0x58(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x78(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x25000
movq 0x60(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x23470
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rax, %rcx
callq 0x24360
movq %rax, 0x38(%rsp)
jmp 0x310d9
movq 0x38(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x311a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
movq 0x70(%rsp), %rdi
callq 0x228c0
cmpq $0x0, 0x78(%rsp)
jne 0x3112b
movq 0x60(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x90(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x23700
jmp 0x31177
movq 0x60(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x23470
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x22860
jmp 0x31160
jmp 0x31177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
callq 0x24b80
jmp 0x3119d
movq 0x60(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x25110
jmp 0x31193
callq 0x246c0
jmp 0x31249
jmp 0x31237
movq 0x60(%rsp), %rdi
movq 0xa0(%rsp), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x23470
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x22860
movq 0x60(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0x10(%rdi), %rdx
movq 0xa0(%rsp), %rax
subq %rax, %rdx
sarq $0x5, %rdx
callq 0x25110
movq 0x60(%rsp), %rax
movq 0x80(%rsp), %rcx
movq %rcx, (%rax)
movq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x80(%rsp), %rcx
movq 0xa8(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0xc8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x24f70
movq %rax, %rdi
callq 0x279b0
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
10,721 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x10(%rsp), %rdi
callq 0x242c0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,722 | void __gnu_cxx::new_allocator<duckdb::OptimizerExtension>::construct<duckdb::OptimizerExtension, duckdb::OptimizerExtension>(duckdb::OptimizerExtension*, duckdb::OptimizerExtension&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x232b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,723 | std::shared_ptr<duckdb::OptimizerExtensionInfo>::shared_ptr(std::shared_ptr<duckdb::OptimizerExtensionInfo>&&) | shared_ptr(shared_ptr&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x22a80
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
10,724 | std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2>&&) | __shared_ptr(__shared_ptr&& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount()
{
_M_refcount._M_swap(__r._M_refcount);
__r._M_ptr = nullptr;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x23080
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x25120
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,725 | std::__shared_count<(__gnu_cxx::_Lock_policy)2>::_M_swap(std::__shared_count<(__gnu_cxx::_Lock_policy)2>&) | void
_M_swap(__shared_count& __r) noexcept
{
_Sp_counted_base<_Lp>* __tmp = __r._M_pi;
__r._M_pi = _M_pi;
_M_pi = __tmp;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x18(%rsp)
movq (%rax), %rdx
movq -0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,726 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x24090
movq 0x20(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x24b30
movq %rax, %rcx
movq 0x28(%rsp), %rax
subq %rcx, %rax
cmpq 0x48(%rsp), %rax
jae 0x3142d
movq 0x40(%rsp), %rdi
callq 0x22c50
movq 0x20(%rsp), %rdi
callq 0x24b30
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x24b30
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x24370
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq (%rcx), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x24b30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x314ac
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x24090
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x314bc
movq 0x20(%rsp), %rdi
callq 0x24090
movq %rax, (%rsp)
jmp 0x314c5
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
addq $0x58, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,727 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x242c0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,728 | std::_Vector_base<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x31576
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x23f10
movq %rax, 0x8(%rsp)
jmp 0x3157f
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x3157f
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,729 | duckdb::OptimizerExtension* std::__uninitialized_move_if_noexcept_a<duckdb::OptimizerExtension*, duckdb::OptimizerExtension*, std::allocator<duckdb::OptimizerExtension>>(duckdb::OptimizerExtension*, duckdb::OptimizerExtension*, duckdb::OptimizerExtension*, std::allocator<duckdb::OptimizerExtension>&) | inline _ForwardIterator
__uninitialized_move_if_noexcept_a(_InputIterator __first,
_InputIterator __last,
_ForwardIterator __result,
_Allocator& __alloc)
{
return std::__uninitialized_copy_a
(_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x238c0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x238c0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x24f50
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,730 | std::_Vector_base<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,731 | void std::allocator_traits<std::allocator<duckdb::OptimizerExtension>>::destroy<duckdb::OptimizerExtension>(std::allocator<duckdb::OptimizerExtension>&, duckdb::OptimizerExtension*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x23810
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,732 | void std::_Destroy<duckdb::OptimizerExtension*, duckdb::OptimizerExtension>(duckdb::OptimizerExtension*, duckdb::OptimizerExtension*, std::allocator<duckdb::OptimizerExtension>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x23460
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,733 | std::_Vector_base<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_deallocate(duckdb::OptimizerExtension*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x31699
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x233b0
addq $0x28, %rsp
retq
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,734 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24050
movq %rax, %rdi
callq 0x22e10
popq %rcx
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,735 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x5, %rax
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,736 | std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_S_max_size(std::allocator<duckdb::OptimizerExtension> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movabsq $0x3ffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFF
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x24020
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x232e0
movq (%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,737 | std::_Vector_base<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
10,738 | std::allocator_traits<std::allocator<duckdb::OptimizerExtension>>::max_size(std::allocator<duckdb::OptimizerExtension> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x250f0
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,739 | _gnu_cxx::new_allocator<duckdb::OptimizerExtension>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23dc0
popq %rcx
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,740 | _gnu_cxx::__normal_iterator<duckdb::OptimizerExtension*, std::vector<duckdb::OptimizerExtension, std::allocator<duckdb::OptimizerExtension>>>::__normal_iterator(duckdb::OptimizerExtension* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
10,741 | std::allocator_traits<std::allocator<duckdb::OptimizerExtension>>::allocate(std::allocator<duckdb::OptimizerExtension>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x24d20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,742 | _gnu_cxx::new_allocator<duckdb::OptimizerExtension>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x23dc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x317ff
movabsq $0x7ffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x317fa
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x5, %rdi
callq 0x23a00
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,743 | duckdb::OptimizerExtension* std::__uninitialized_copy_a<duckdb::OptimizerExtension const*, duckdb::OptimizerExtension*, duckdb::OptimizerExtension>(duckdb::OptimizerExtension const*, duckdb::OptimizerExtension const*, duckdb::OptimizerExtension*, std::allocator<duckdb::OptimizerExtension>&) | inline _ForwardIterator
__uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, allocator<_Tp>&)
{ return std::uninitialized_copy(__first, __last, __result); } | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x24a80
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,744 | duckdb::OptimizerExtension const* std::__make_move_if_noexcept_iterator<duckdb::OptimizerExtension, duckdb::OptimizerExtension const*>(duckdb::OptimizerExtension*) | inline _GLIBCXX17_CONSTEXPR _ReturnType
__make_move_if_noexcept_iterator(_Tp* __i)
{ return _ReturnType(__i); } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
10,745 | duckdb::OptimizerExtension* std::uninitialized_copy<duckdb::OptimizerExtension const*, duckdb::OptimizerExtension*>(duckdb::OptimizerExtension const*, duckdb::OptimizerExtension const*, duckdb::OptimizerExtension*) | inline _ForwardIterator
uninitialized_copy(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType1;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
#if __cplusplus < 201103L
const bool __assignable = true;
#else
// Trivial types can have deleted copy constructor, but the std::copy
// optimization that uses memmove would happily "copy" them anyway.
static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
"result type must be constructible from value type of input range");
typedef typename iterator_traits<_InputIterator>::reference _RefType1;
typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
// Trivial types can have deleted assignment, so using std::copy
// would be ill-formed. Require assignability before using std::copy:
const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
#endif
return std::__uninitialized_copy<__is_trivial(_ValueType1)
&& __is_trivial(_ValueType2)
&& __assignable>::
__uninit_copy(__first, __last, __result);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x1, 0xf(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x237c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
10,746 | void std::_Destroy<duckdb::OptimizerExtension*>(duckdb::OptimizerExtension*, duckdb::OptimizerExtension*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25590
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,747 | duckdb::shared_ptr<duckdb::OptimizerExtensionInfo, true>::shared_ptr(duckdb::shared_ptr<duckdb::OptimizerExtensionInfo, true> const&) | shared_ptr(const shared_ptr &other) : internal(other.internal) { // NOLINT: not marked as explicit
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x24760
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | lnkuiper[P]duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp |
10,748 | std::shared_ptr<duckdb::OptimizerExtensionInfo>::shared_ptr(std::shared_ptr<duckdb::OptimizerExtensionInfo> const&) | shared_ptr(const shared_ptr&) noexcept = default; | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x24a70
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
10,749 | std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<duckdb::OptimizerExtensionInfo, (__gnu_cxx::_Lock_policy)2> const&) | __shared_ptr(const __shared_ptr&) noexcept = default; | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x24650
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,750 | std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&) | __shared_count(const __shared_count& __r) noexcept
: _M_pi(__r._M_pi)
{
if (_M_pi != nullptr)
_M_pi->_M_add_ref_copy();
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x31ae8
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x235c0
jmp 0x31ae6
jmp 0x31ae8
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x279b0
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,751 | std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_add_ref_copy() | void
_M_add_ref_copy()
{ __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } | movq %rdi, -0x40(%rsp)
movq -0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rsp)
movl $0x1, -0x34(%rsp)
movq 0x94ae(%rip), %rax # 0x3afd0
cmpb $0x0, (%rax)
je 0x31b48
movq -0x30(%rsp), %rcx
movl -0x34(%rsp), %eax
movq %rcx, -0x20(%rsp)
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %ecx
movq -0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x31b73
movq -0x30(%rsp), %rcx
movl -0x34(%rsp), %eax
movq %rcx, -0x8(%rsp)
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rcx
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
lock
xaddl %eax, (%rcx)
movl %eax, -0x14(%rsp)
retq
nopw %cs:(%rax,%rax)
nop
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
10,752 | void std::_Destroy_aux<false>::__destroy<duckdb::OptimizerExtension*>(duckdb::OptimizerExtension*, duckdb::OptimizerExtension*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x31bb4
movq 0x10(%rsp), %rdi
callq 0x22580
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
jmp 0x31b8e
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,753 | void std::_Destroy<duckdb::OptimizerExtension>(duckdb::OptimizerExtension*) | _GLIBCXX14_CONSTEXPR inline void
_Destroy(_Tp* __pointer)
{
#if __cplusplus > 201703L
std::destroy_at(__pointer);
#else
__pointer->~_Tp();
#endif
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24300
popq %rax
retq
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
10,754 | void __gnu_cxx::new_allocator<duckdb::OptimizerExtension>::destroy<duckdb::OptimizerExtension>(duckdb::OptimizerExtension*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x24300
addq $0x18, %rsp
retq
nopl (%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
10,755 | std::allocator_traits<std::allocator<duckdb::OptimizerExtension>>::deallocate(std::allocator<duckdb::OptimizerExtension>&, duckdb::OptimizerExtension*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x23ba0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| lnkuiper[P]duckdb[P]build_O0[P]test[P]extension[P]loadable_extension_optimizer_demo.duckdb_extension.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
10,756 | main | int main(int, char const *[])
{
return UnitTest::RunAllTests();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x5dab0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/Main.cpp |
10,757 | (anonymous namespace)::TestReportAssertThrowsAssertException::TestReportAssertThrowsAssertException() | TEST(ReportAssertThrowsAssertException)
{
bool caught = false;
try
{
ReportAssert("", "", 0);
}
catch(AssertException const&)
{
caught = true;
}
CHECK (true == caught);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45d1d(%rip), %rsi # 0x60004
leaq 0x45d38(%rip), %rcx # 0x60026
movl $0x9, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x6872c(%rip), %rcx # 0x82a30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,758 | (anonymous namespace)::TestReportAssertThrowsAssertException::~TestReportAssertThrowsAssertException() | TEST(ReportAssertThrowsAssertException)
{
bool caught = false;
try
{
ReportAssert("", "", 0);
}
catch(AssertException const&)
{
caught = true;
}
CHECK (true == caught);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,759 | (anonymous namespace)::TestReportAssertSetsCorrectInfoInException::TestReportAssertSetsCorrectInfoInException() | TEST(ReportAssertSetsCorrectInfoInException)
{
const int lineNumber = 12345;
const char* description = "description";
const char* filename = "filename";
try
{
ReportAssert(description, filename, lineNumber);
}
catch(AssertException const& e)
{
CHECK_EQUAL(description, e.what());
CHECK_EQUAL(filename, e.Filename());
CHECK_EQUAL(lineNumber, e.LineNumber());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45d70(%rip), %rsi # 0x600d7
leaq 0x45cb8(%rip), %rcx # 0x60026
movl $0x19, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x686ec(%rip), %rcx # 0x82a70
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,760 | (anonymous namespace)::TestReportAssertSetsCorrectInfoInException::~TestReportAssertSetsCorrectInfoInException() | TEST(ReportAssertSetsCorrectInfoInException)
{
const int lineNumber = 12345;
const char* description = "description";
const char* filename = "filename";
try
{
ReportAssert(description, filename, lineNumber);
}
catch(AssertException const& e)
{
CHECK_EQUAL(description, e.what());
CHECK_EQUAL(filename, e.Filename());
CHECK_EQUAL(lineNumber, e.LineNumber());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,761 | (anonymous namespace)::TestReportAssertThrowsAssertException::~TestReportAssertThrowsAssertException() | TEST(ReportAssertThrowsAssertException)
{
bool caught = false;
try
{
ReportAssert("", "", 0);
}
catch(AssertException const&)
{
caught = true;
}
CHECK (true == caught);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1a320
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,762 | (anonymous namespace)::TestReportAssertThrowsAssertException::RunImpl() const | TEST(ReportAssertThrowsAssertException)
{
bool caught = false;
try
{
ReportAssert("", "", 0);
}
catch(AssertException const&)
{
caught = true;
}
CHECK (true == caught);
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq 0x4fa4e(%rip), %rsi # 0x69e58
xorl %edx, %edx
movq %rsi, %rdi
callq 0x5d240
jmp 0x1a416
jmp 0x1a44a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1a55f
movq -0x18(%rbp), %rdi
callq 0x150d0
movq %rax, -0x28(%rbp)
movb $0x1, -0x9(%rbp)
callq 0x153e0
jmp 0x1a44c
movzbl -0x9(%rbp), %edi
andl $0x1, %edi
callq 0x1a9e0
movb %al, -0x69(%rbp)
jmp 0x1a45d
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x1a548
jmp 0x1a46a
callq 0x5b060
movq %rax, -0x78(%rbp)
jmp 0x1a475
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x5b070
movq %rax, -0x80(%rbp)
jmp 0x1a48e
movq -0x80(%rbp), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
movl $0x16, %edx
callq 0x5d7c0
jmp 0x1a4a5
movq -0x88(%rbp), %rdi
leaq 0x45be8(%rip), %rdx # 0x6009b
leaq -0x48(%rbp), %rsi
callq 0x5d9a0
jmp 0x1a4be
jmp 0x1a548
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x90(%rbp)
jmp 0x1a4e6
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
callq 0x5b070
movq %rax, -0x98(%rbp)
jmp 0x1a505
movq -0x98(%rbp), %rax
movq (%rax), %rsi
leaq -0x68(%rbp), %rdi
movl $0x16, %edx
callq 0x5d7c0
jmp 0x1a51f
movq -0xa0(%rbp), %rdi
leaq 0x45b7d(%rip), %rdx # 0x600aa
leaq -0x68(%rbp), %rsi
callq 0x5d9a0
jmp 0x1a538
callq 0x153e0
jmp 0x1a53f
addq $0xa0, %rsp
popq %rbp
retq
jmp 0x1a53d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x153e0
jmp 0x1a55d
jmp 0x1a55f
movq -0x18(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,763 | (anonymous namespace)::TestReportAssertSetsCorrectInfoInException::~TestReportAssertSetsCorrectInfoInException() | TEST(ReportAssertSetsCorrectInfoInException)
{
const int lineNumber = 12345;
const char* description = "description";
const char* filename = "filename";
try
{
ReportAssert(description, filename, lineNumber);
}
catch(AssertException const& e)
{
CHECK_EQUAL(description, e.what());
CHECK_EQUAL(filename, e.Filename());
CHECK_EQUAL(lineNumber, e.LineNumber());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1a3a0
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,764 | (anonymous namespace)::TestReportAssertSetsCorrectInfoInException::RunImpl() const | TEST(ReportAssertSetsCorrectInfoInException)
{
const int lineNumber = 12345;
const char* description = "description";
const char* filename = "filename";
try
{
ReportAssert(description, filename, lineNumber);
}
catch(AssertException const& e)
{
CHECK_EQUAL(description, e.what());
CHECK_EQUAL(filename, e.Filename());
CHECK_EQUAL(lineNumber, e.LineNumber());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movl $0x3039, -0xc(%rbp) # imm = 0x3039
leaq 0x45b41(%rip), %rax # 0x600fe
movq %rax, -0x18(%rbp)
leaq 0x45b42(%rip), %rax # 0x6010a
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x3039, %edx # imm = 0x3039
callq 0x5d240
jmp 0x1a5e0
jmp 0x1a98d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1a9b4
movq -0x28(%rbp), %rdi
callq 0x150d0
movq %rax, -0x38(%rbp)
callq 0x5b060
movq %rax, -0x108(%rbp)
jmp 0x1a61c
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x118(%rbp)
callq 0x5b070
movq %rax, -0x110(%rbp)
jmp 0x1a65a
movq -0x110(%rbp), %rax
movq (%rax), %rsi
leaq -0x58(%rbp), %rdi
movl $0x25, %edx
callq 0x5d7c0
jmp 0x1a674
movq -0x118(%rbp), %rdx
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
leaq -0x58(%rbp), %rcx
callq 0x5ae20
jmp 0x1a694
jmp 0x1a714
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x130(%rbp)
jmp 0x1a6b9
movq -0x130(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x140(%rbp)
callq 0x5b070
movq %rax, -0x138(%rbp)
jmp 0x1a6d8
movq -0x138(%rbp), %rax
movq (%rax), %rsi
leaq -0x78(%rbp), %rdi
movl $0x25, %edx
callq 0x5d7c0
jmp 0x1a6f2
movq -0x140(%rbp), %rdi
leaq 0x45a13(%rip), %rdx # 0x60113
leaq -0x78(%rbp), %rsi
callq 0x5d9a0
jmp 0x1a70b
callq 0x153e0
jmp 0x1a712
jmp 0x1a714
jmp 0x1a716
jmp 0x1a718
jmp 0x1a71a
callq 0x5b060
movq %rax, -0x148(%rbp)
jmp 0x1a728
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x160(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x150(%rbp)
jmp 0x1a756
callq 0x5b070
movq %rax, -0x168(%rbp)
jmp 0x1a764
movq -0x168(%rbp), %rax
movq (%rax), %rsi
leaq -0x98(%rbp), %rdi
movl $0x26, %edx
callq 0x5d7c0
jmp 0x1a781
movq -0x150(%rbp), %rdx
movq -0x158(%rbp), %rsi
movq -0x160(%rbp), %rdi
leaq -0x98(%rbp), %rcx
callq 0x5ae20
jmp 0x1a7a4
jmp 0x1a856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x153e0
jmp 0x1a7cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1a9ab
jmp 0x1a9ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x170(%rbp)
jmp 0x1a7f5
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x180(%rbp)
callq 0x5b070
movq %rax, -0x178(%rbp)
jmp 0x1a814
movq -0x178(%rbp), %rax
movq (%rax), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x26, %edx
callq 0x5d7c0
jmp 0x1a831
movq -0x180(%rbp), %rdi
leaq 0x4590e(%rip), %rdx # 0x6014d
leaq -0xb8(%rbp), %rsi
callq 0x5d9a0
jmp 0x1a84d
callq 0x153e0
jmp 0x1a854
jmp 0x1a856
jmp 0x1a858
jmp 0x1a85a
jmp 0x1a85c
callq 0x5b060
movq %rax, -0x188(%rbp)
jmp 0x1a86a
movq -0x188(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x18c(%rbp)
jmp 0x1a88c
movl -0x18c(%rbp), %eax
movl %eax, -0xbc(%rbp)
callq 0x5b070
movq %rax, -0x1a0(%rbp)
jmp 0x1a8a6
movq -0x1a0(%rbp), %rax
movq (%rax), %rsi
leaq -0xe0(%rbp), %rdi
movl $0x27, %edx
callq 0x5d7c0
jmp 0x1a8c3
movq -0x198(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0xbc(%rbp), %rdx
leaq -0xe0(%rbp), %rcx
callq 0x1aa10
jmp 0x1a8e3
jmp 0x1a984
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x153e0
jmp 0x1a8fb
jmp 0x1a9ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x1a8(%rbp)
jmp 0x1a923
movq -0x1a8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b8(%rbp)
callq 0x5b070
movq %rax, -0x1b0(%rbp)
jmp 0x1a942
movq -0x1b0(%rbp), %rax
movq (%rax), %rsi
leaq -0x100(%rbp), %rdi
movl $0x27, %edx
callq 0x5d7c0
jmp 0x1a95f
movq -0x1b8(%rbp), %rdi
leaq 0x4581b(%rip), %rdx # 0x60188
leaq -0x100(%rbp), %rsi
callq 0x5d9a0
jmp 0x1a97b
callq 0x153e0
jmp 0x1a982
jmp 0x1a984
jmp 0x1a986
jmp 0x1a988
callq 0x153e0
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x153e0
jmp 0x1a9a9
jmp 0x1a9ab
callq 0x153e0
jmp 0x1a9b2
jmp 0x1a9b4
movq -0x28(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestAssertHandler.cpp |
10,765 | UnitTestSuite::GetSuiteName() | inline char const* GetSuiteName ()
{
return "DefaultSuite";
} | pushq %rbp
movq %rsp, %rbp
leaq 0x4cd51(%rip), %rax # 0x6772c
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../TestSuite.h |
10,766 | bool UnitTest::Check<bool>(bool) | bool Check(Value const value)
{
return !!value; // doing double negative to avoid silly VS warnings
} | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
10,767 | void UnitTest::CheckEqual<int, int>(UnitTest::TestResults&, int const&, int const&, UnitTest::TestDetails const&) | void CheckEqual(TestResults& results, Expected const& expected, Actual const& actual, TestDetails const& details)
{
if (!(expected == actual))
{
UnitTest::MemoryOutStream stream;
stream << "Expected " << expected << " but was " << actual;
results.OnTestFailure(details, stream.GetText());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x1ab2c
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1ab50
movq -0x1d8(%rbp), %rdi
leaq 0x45769(%rip), %rsi # 0x601c7
callq 0x15250
movq %rax, -0x1d0(%rbp)
jmp 0x1aa6c
movq -0x1d0(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x15410
movq %rax, -0x1e0(%rbp)
jmp 0x1aa87
movq -0x1e0(%rbp), %rdi
leaq 0x4573c(%rip), %rsi # 0x601d1
callq 0x15250
movq %rax, -0x1e8(%rbp)
jmp 0x1aaa3
movq -0x1e8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x15410
jmp 0x1aab7
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x1f0(%rbp)
jmp 0x1aae2
movq -0x1f0(%rbp), %rdx
movq -0x1f8(%rbp), %rsi
movq -0x200(%rbp), %rdi
callq 0x5d9a0
jmp 0x1aafe
leaq -0x1b8(%rbp), %rdi
callq 0x1abe0
jmp 0x1ab2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1abe0
jmp 0x1ab35
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../Checks.h |
10,768 | UnitTest::MemoryOutStream::MemoryOutStream() | MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x90, %rdi
callq 0x150c0
movq -0x20(%rbp), %rdi
leaq 0x67f8d(%rip), %rsi # 0x82b08
callq 0x15450
jmp 0x1ab82
movq -0x20(%rbp), %rdi
leaq 0x67f23(%rip), %rax # 0x82ab0
addq $0x18, %rax
movq %rax, (%rdi)
leaq 0x67f15(%rip), %rax # 0x82ab0
addq $0x40, %rax
movq %rax, 0x90(%rdi)
addq $0x70, %rdi
callq 0x15360
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
addq $0x90, %rdi
callq 0x15460
movq -0x10(%rbp), %rdi
callq 0x15420
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,769 | UnitTest::MemoryOutStream::~MemoryOutStream() | ~MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x67f05(%rip), %rsi # 0x82b00
callq 0x1ac90
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0x15460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,770 | UnitTest::MemoryOutStream::~MemoryOutStream() | ~MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1abe0
movq -0x10(%rbp), %rdi
movl $0x198, %esi # imm = 0x198
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,771 | virtual thunk to UnitTest::MemoryOutStream::~MemoryOutStream() | MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
popq %rbp
jmp 0x1abe0
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,772 | virtual thunk to UnitTest::MemoryOutStream::~MemoryOutStream() | MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
popq %rbp
jmp 0x1ac20
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,773 | UnitTest::MemoryOutStream::~MemoryOutStream() | ~MemoryOutStream() {} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rcx
movq %rcx, (%rdi)
movq 0x28(%rax), %rcx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq %rcx, (%rdi,%rax)
addq $0x70, %rdi
callq 0x15150
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rsi
callq 0x15130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/../MemoryOutStream.h |
10,774 | (anonymous namespace)::TestCheckSucceedsOnTrue::TestCheckSucceedsOnTrue() | TEST(CheckSucceedsOnTrue)
{
bool failure = true;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(true);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(!failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45556(%rip), %rsi # 0x6026d
leaq 0x45563(%rip), %rcx # 0x60281
movl $0xa, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67ebc(%rip), %rcx # 0x82bf0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,775 | (anonymous namespace)::TestCheckSucceedsOnTrue::~TestCheckSucceedsOnTrue() | TEST(CheckSucceedsOnTrue)
{
bool failure = true;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(true);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(!failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,776 | (anonymous namespace)::TestCheckFailsOnFalse::TestCheckFailsOnFalse() | TEST(CheckFailsOnFalse)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(false);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x455b0(%rip), %rsi # 0x60347
leaq 0x454e3(%rip), %rcx # 0x60281
movl $0x1a, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67e7c(%rip), %rcx # 0x82c30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,777 | (anonymous namespace)::TestCheckFailsOnFalse::~TestCheckFailsOnFalse() | TEST(CheckFailsOnFalse)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(false);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,778 | (anonymous namespace)::TestFailureReportsCorrectTestName::TestFailureReportsCorrectTestName() | TEST(FailureReportsCorrectTestName)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(false);
}
CHECK_EQUAL(m_details.testName, reporter.lastFailedTest);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45592(%rip), %rsi # 0x603a9
leaq 0x45463(%rip), %rcx # 0x60281
movl $0x28, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67e3c(%rip), %rcx # 0x82c70
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,779 | (anonymous namespace)::TestFailureReportsCorrectTestName::~TestFailureReportsCorrectTestName() | TEST(FailureReportsCorrectTestName)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(false);
}
CHECK_EQUAL(m_details.testName, reporter.lastFailedTest);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,780 | (anonymous namespace)::TestCheckFailureIncludesCheckContents::TestCheckFailureIncludesCheckContents() | TEST(CheckFailureIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
const bool yaddayadda = false;
CHECK(yaddayadda);
}
CHECK(strstr(reporter.lastFailedMessage, "yaddayadda"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45580(%rip), %rsi # 0x60417
leaq 0x453e3(%rip), %rcx # 0x60281
movl $0x34, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67dfc(%rip), %rcx # 0x82cb0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,781 | (anonymous namespace)::TestCheckFailureIncludesCheckContents::~TestCheckFailureIncludesCheckContents() | TEST(CheckFailureIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
const bool yaddayadda = false;
CHECK(yaddayadda);
}
CHECK(strstr(reporter.lastFailedMessage, "yaddayadda"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,782 | (anonymous namespace)::TestCheckFailsOnException::TestCheckFailsOnException() | TEST(CheckFailsOnException)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(ThrowingFunction() == 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x455d6(%rip), %rsi # 0x604ed
leaq 0x45363(%rip), %rcx # 0x60281
movl $0x46, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67dbc(%rip), %rcx # 0x82cf0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,783 | (anonymous namespace)::TestCheckFailsOnException::~TestCheckFailsOnException() | TEST(CheckFailsOnException)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(ThrowingFunction() == 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,784 | (anonymous namespace)::TestCheckFailureBecauseOfExceptionIncludesCheckContents::TestCheckFailureBecauseOfExceptionIncludesCheckContents() | TEST(CheckFailureBecauseOfExceptionIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(ThrowingFunction() == 1);
}
CHECK(strstr(reporter.lastFailedMessage, "ThrowingFunction() == 1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x455be(%rip), %rsi # 0x60555
leaq 0x452e3(%rip), %rcx # 0x60281
movl $0x54, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67d7c(%rip), %rcx # 0x82d30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,785 | (anonymous namespace)::TestCheckFailureBecauseOfExceptionIncludesCheckContents::~TestCheckFailureBecauseOfExceptionIncludesCheckContents() | TEST(CheckFailureBecauseOfExceptionIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK(ThrowingFunction() == 1);
}
CHECK(strstr(reporter.lastFailedMessage, "ThrowingFunction() == 1"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,786 | (anonymous namespace)::TestCheckEqualSucceedsOnEqual::TestCheckEqualSucceedsOnEqual() | TEST(CheckEqualSucceedsOnEqual)
{
bool failure = true;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(!failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x4560c(%rip), %rsi # 0x60623
leaq 0x45263(%rip), %rcx # 0x60281
movl $0x60, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67d3c(%rip), %rcx # 0x82d70
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,787 | (anonymous namespace)::TestCheckEqualSucceedsOnEqual::~TestCheckEqualSucceedsOnEqual() | TEST(CheckEqualSucceedsOnEqual)
{
bool failure = true;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(!failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,788 | (anonymous namespace)::TestCheckEqualFailsOnNotEqual::TestCheckEqualFailsOnNotEqual() | TEST(CheckEqualFailsOnNotEqual)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, 2);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x455cf(%rip), %rsi # 0x60666
leaq 0x451e3(%rip), %rcx # 0x60281
movl $0x6e, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67cfc(%rip), %rcx # 0x82db0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,789 | (anonymous namespace)::TestCheckEqualFailsOnNotEqual::~TestCheckEqualFailsOnNotEqual() | TEST(CheckEqualFailsOnNotEqual)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, 2);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,790 | (anonymous namespace)::TestCheckEqualFailsOnException::TestCheckEqualFailsOnException() | TEST(CheckEqualFailsOnException)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(ThrowingFunction(), 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45592(%rip), %rsi # 0x606a9
leaq 0x45163(%rip), %rcx # 0x60281
movl $0x7c, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67cbc(%rip), %rcx # 0x82df0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,791 | (anonymous namespace)::TestCheckEqualFailsOnException::~TestCheckEqualFailsOnException() | TEST(CheckEqualFailsOnException)
{
bool failure = false;
{
RecordingReporter reporter;
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(ThrowingFunction(), 1);
failure = (testResults.GetFailureCount() > 0);
}
CHECK(failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,792 | (anonymous namespace)::TestCheckEqualFailureContainsCorrectDetails::TestCheckEqualFailureContainsCorrectDetails() | TEST(CheckEqualFailureContainsCorrectDetails)
{
int line = 0;
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
UnitTest::TestDetails const testDetails("testName", "suiteName", "filename", -1);
ScopedCurrentTest scopedResults(testResults, &testDetails);
CHECK_EQUAL(1, 123); line = __LINE__;
}
CHECK_EQUAL("testName", reporter.lastFailedTest);
CHECK_EQUAL("suiteName", reporter.lastFailedSuite);
CHECK_EQUAL("filename", reporter.lastFailedFile);
CHECK_EQUAL(line, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45567(%rip), %rsi # 0x606fe
leaq 0x450e3(%rip), %rcx # 0x60281
movl $0x8a, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67c7c(%rip), %rcx # 0x82e30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,793 | (anonymous namespace)::TestCheckEqualFailureContainsCorrectDetails::~TestCheckEqualFailureContainsCorrectDetails() | TEST(CheckEqualFailureContainsCorrectDetails)
{
int line = 0;
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
UnitTest::TestDetails const testDetails("testName", "suiteName", "filename", -1);
ScopedCurrentTest scopedResults(testResults, &testDetails);
CHECK_EQUAL(1, 123); line = __LINE__;
}
CHECK_EQUAL("testName", reporter.lastFailedTest);
CHECK_EQUAL("suiteName", reporter.lastFailedSuite);
CHECK_EQUAL("filename", reporter.lastFailedFile);
CHECK_EQUAL(line, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,794 | (anonymous namespace)::TestCheckEqualFailureBecauseOfExceptionContainsCorrectDetails::TestCheckEqualFailureBecauseOfExceptionContainsCorrectDetails() | TEST(CheckEqualFailureBecauseOfExceptionContainsCorrectDetails)
{
int line = 0;
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
UnitTest::TestDetails const testDetails("testName", "suiteName", "filename", -1);
ScopedCurrentTest scopedResults(testResults, &testDetails);
CHECK_EQUAL(ThrowingFunction(), 123); line = __LINE__;
}
CHECK_EQUAL("testName", reporter.lastFailedTest);
CHECK_EQUAL("suiteName", reporter.lastFailedSuite);
CHECK_EQUAL("filename", reporter.lastFailedFile);
CHECK_EQUAL(line, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x45669(%rip), %rsi # 0x60880
leaq 0x45063(%rip), %rcx # 0x60281
movl $0x9c, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67c3c(%rip), %rcx # 0x82e70
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,795 | (anonymous namespace)::TestCheckEqualFailureBecauseOfExceptionContainsCorrectDetails::~TestCheckEqualFailureBecauseOfExceptionContainsCorrectDetails() | TEST(CheckEqualFailureBecauseOfExceptionContainsCorrectDetails)
{
int line = 0;
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
UnitTest::TestDetails const testDetails("testName", "suiteName", "filename", -1);
ScopedCurrentTest scopedResults(testResults, &testDetails);
CHECK_EQUAL(ThrowingFunction(), 123); line = __LINE__;
}
CHECK_EQUAL("testName", reporter.lastFailedTest);
CHECK_EQUAL("suiteName", reporter.lastFailedSuite);
CHECK_EQUAL("filename", reporter.lastFailedFile);
CHECK_EQUAL(line, reporter.lastFailedLine);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,796 | (anonymous namespace)::TestCheckEqualFailureBecauseOfExceptionIncludesCheckContents::TestCheckEqualFailureBecauseOfExceptionIncludesCheckContents() | TEST(CheckEqualFailureBecauseOfExceptionIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(ThrowingFunction(), 123);
}
CHECK(strstr(reporter.lastFailedMessage, "ThrowingFunction()"));
CHECK(strstr(reporter.lastFailedMessage, "123"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x4565f(%rip), %rsi # 0x608f6
leaq 0x44fe3(%rip), %rcx # 0x60281
movl $0xae, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67bfc(%rip), %rcx # 0x82eb0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,797 | (anonymous namespace)::TestCheckEqualFailureBecauseOfExceptionIncludesCheckContents::~TestCheckEqualFailureBecauseOfExceptionIncludesCheckContents() | TEST(CheckEqualFailureBecauseOfExceptionIncludesCheckContents)
{
RecordingReporter reporter;
{
UnitTest::TestResults testResults(&reporter);
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(ThrowingFunction(), 123);
}
CHECK(strstr(reporter.lastFailedMessage, "ThrowingFunction()"));
CHECK(strstr(reporter.lastFailedMessage, "123"));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,798 | (anonymous namespace)::TestCheckEqualDoesNotHaveSideEffectsWhenPassing::TestCheckEqualDoesNotHaveSideEffectsWhenPassing() | TEST(CheckEqualDoesNotHaveSideEffectsWhenPassing)
{
g_sideEffect = 0;
{
UnitTest::TestResults testResults;
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, FunctionWithSideEffects());
}
CHECK_EQUAL(1, g_sideEffect);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x1a9d0
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x4571a(%rip), %rsi # 0x60a31
leaq 0x44f63(%rip), %rcx # 0x60281
movl $0xc2, %r8d
callq 0x5d320
movq -0x10(%rbp), %rax
leaq 0x67bbc(%rip), %rcx # 0x82ef0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
10,799 | (anonymous namespace)::TestCheckEqualDoesNotHaveSideEffectsWhenPassing::~TestCheckEqualDoesNotHaveSideEffectsWhenPassing() | TEST(CheckEqualDoesNotHaveSideEffectsWhenPassing)
{
g_sideEffect = 0;
{
UnitTest::TestResults testResults;
ScopedCurrentTest scopedResults(testResults);
CHECK_EQUAL(1, FunctionWithSideEffects());
}
CHECK_EQUAL(1, g_sideEffect);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d390
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/tests/TestCheckMacros.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.