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,300 | std::_Deque_base<std::reference_wrapper<duckdb::Catalog>, std::allocator<std::reference_wrapper<duckdb::Catalog>>>::_M_deallocate_node(std::reference_wrapper<duckdb::Catalog>*) | void
_M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x23860
jmp 0x2a710
addq $0x28, %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/stl_deque.h |
10,301 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::Catalog>>>::deallocate(std::allocator<std::reference_wrapper<duckdb::Catalog>>&, std::reference_wrapper<duckdb::Catalog>*, 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 0x24080
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,302 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::Catalog>*>>::deallocate(std::allocator<std::reference_wrapper<duckdb::Catalog>*>&, std::reference_wrapper<duckdb::Catalog>**, 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 0x23f70
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,303 | std::_Deque_iterator<std::reference_wrapper<duckdb::Catalog>, std::reference_wrapper<duckdb::Catalog>&, std::reference_wrapper<duckdb::Catalog>*>::_S_buffer_size() | static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); } | pushq %rax
movl $0x8, %edi
callq 0x23df0
popq %rcx
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_deque.h |
10,304 | std::allocator<std::reference_wrapper<duckdb::Catalog>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22500
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/allocator.h |
10,305 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::Catalog>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,306 | std::deque<unsigned long, std::allocator<unsigned long>>::deque() | deque() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x253c0
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_deque.h |
10,307 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_Deque_base() | _Deque_base()
: _M_impl()
{ _M_initialize_map(0); } | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23230
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22f50
jmp 0x2a848
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x24220
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,308 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_Deque_impl::_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x239d0
movq 0x8(%rsp), %rdi
callq 0x22590
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/stl_deque.h |
10,309 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_Deque_impl::~_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23b00
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_deque.h |
10,310 | std::allocator<unsigned long>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x224d0
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/allocator.h |
10,311 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_Deque_impl_data::_Deque_impl_data() | _Deque_impl_data() _GLIBCXX_NOEXCEPT
: _M_map(), _M_map_size(), _M_start(), _M_finish()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x250a0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x250a0
addq $0x18, %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_deque.h |
10,312 | _gnu_cxx::new_allocator<unsigned long>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,313 | std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>::_Deque_iterator() | _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(), _M_first(), _M_last(), _M_node() { } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
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/stl_deque.h |
10,314 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_M_allocate_map(unsigned long) | _Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23450
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x24010
movq %rax, 0x8(%rsp)
jmp 0x2ab26
leaq 0x27(%rsp), %rdi
callq 0x22ec0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x22ec0
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,315 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_M_deallocate_map(unsigned long**, unsigned long) | void
_M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0xf(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23450
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x25160
jmp 0x2ac6b
leaq 0xf(%rsp), %rdi
callq 0x22ec0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
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_deque.h |
10,316 | std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>::_M_set_node(unsigned long**) | void
_M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
{
_M_node = __new_node;
_M_first = *__new_node;
_M_last = _M_first + difference_type(_S_buffer_size());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x23f90
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
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_deque.h |
10,317 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_M_get_map_allocator() const | _Map_alloc_type
_M_get_map_allocator() const _GLIBCXX_NOEXCEPT
{ return _Map_alloc_type(_M_get_Tp_allocator()); } | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x24d80
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x22030
movq 0x10(%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_deque.h |
10,318 | std::allocator_traits<std::allocator<unsigned long*>>::allocate(std::allocator<unsigned long*>&, 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 0x22190
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,319 | std::allocator<unsigned long*>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22fe0
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/allocator.h |
10,320 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_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_deque.h |
10,321 | std::allocator<unsigned long*>::allocator<unsigned long>(std::allocator<unsigned long> const&) | _GLIBCXX20_CONSTEXPR
allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x23aa0
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/allocator.h |
10,322 | _gnu_cxx::new_allocator<unsigned long*>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,323 | _gnu_cxx::new_allocator<unsigned long*>::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 0x23050
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2adff
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2adfa
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,324 | _gnu_cxx::new_allocator<unsigned long*>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,325 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_M_allocate_node() | _Ptr
_M_allocate_node()
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x24270
addq $0x18, %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_deque.h |
10,326 | std::allocator_traits<std::allocator<unsigned long>>::allocate(std::allocator<unsigned long>&, 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 0x249c0
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,327 | _gnu_cxx::new_allocator<unsigned long>::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 0x23f60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2af4f
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2af4a
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,328 | std::_Deque_base<unsigned long, std::allocator<unsigned long>>::_M_deallocate_node(unsigned long*) | void
_M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x24550
jmp 0x2afc0
addq $0x28, %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/stl_deque.h |
10,329 | std::allocator_traits<std::allocator<unsigned long>>::deallocate(std::allocator<unsigned long>&, unsigned long*, 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 0x23ca0
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,330 | std::allocator_traits<std::allocator<unsigned long*>>::deallocate(std::allocator<unsigned long*>&, unsigned long**, 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 0x22ba0
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,331 | std::_Deque_iterator<unsigned long, unsigned long&, unsigned long*>::_S_buffer_size() | static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); } | pushq %rax
movl $0x8, %edi
callq 0x23df0
popq %rcx
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_deque.h |
10,332 | std::allocator<unsigned long>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x24000
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/allocator.h |
10,333 | _gnu_cxx::new_allocator<unsigned long>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,334 | std::deque<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::deque() | deque() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23520
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_deque.h |
10,335 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_Deque_base() | _Deque_base()
: _M_impl()
{ _M_initialize_map(0); } | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23e40
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x240e0
jmp 0x2b0f8
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x23380
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,336 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_Deque_impl::_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x246d0
movq 0x8(%rsp), %rdi
callq 0x250c0
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/stl_deque.h |
10,337 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_Deque_impl::~_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23d50
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_deque.h |
10,338 | std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22fd0
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/allocator.h |
10,339 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_Deque_impl_data::_Deque_impl_data() | _Deque_impl_data() _GLIBCXX_NOEXCEPT
: _M_map(), _M_map_size(), _M_start(), _M_finish()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x22f90
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x22f90
addq $0x18, %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_deque.h |
10,340 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,341 | std::_Deque_iterator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>&, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::_Deque_iterator() | _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(), _M_first(), _M_last(), _M_node() { } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
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/stl_deque.h |
10,342 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_M_allocate_map(unsigned long) | _Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x246b0
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x22310
movq %rax, 0x8(%rsp)
jmp 0x2b3d6
leaq 0x27(%rsp), %rdi
callq 0x22ee0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x22ee0
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,343 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_M_deallocate_map(std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>**, unsigned long) | void
_M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0xf(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x246b0
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x24920
jmp 0x2b51b
leaq 0xf(%rsp), %rdi
callq 0x22ee0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
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_deque.h |
10,344 | std::_Deque_iterator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>&, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::_M_set_node(std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>**) | void
_M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
{
_M_node = __new_node;
_M_first = *__new_node;
_M_last = _M_first + difference_type(_S_buffer_size());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x225d0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
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_deque.h |
10,345 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_M_get_map_allocator() const | _Map_alloc_type
_M_get_map_allocator() const _GLIBCXX_NOEXCEPT
{ return _Map_alloc_type(_M_get_Tp_allocator()); } | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x25260
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x23020
movq 0x10(%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_deque.h |
10,346 | std::allocator_traits<std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>>::allocate(std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>&, 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 0x22bd0
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,347 | std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23120
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/allocator.h |
10,348 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_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_deque.h |
10,349 | std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>(std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>> const&) | _GLIBCXX20_CONSTEXPR
allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x221b0
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/allocator.h |
10,350 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,351 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::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 0x24d10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2b6af
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2b6aa
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,352 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,353 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_M_allocate_node() | _Ptr
_M_allocate_node()
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x22e60
addq $0x18, %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_deque.h |
10,354 | std::allocator_traits<std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::allocate(std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>&, 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 0x24be0
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,355 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>::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 0x22a90
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2b7ff
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2b7fa
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,356 | std::_Deque_base<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::_M_deallocate_node(std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*) | void
_M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x23650
jmp 0x2b870
addq $0x28, %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/stl_deque.h |
10,357 | std::allocator_traits<std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>>::deallocate(std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>&, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*, 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 0x24fe0
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,358 | std::allocator_traits<std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>>::deallocate(std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>&, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>**, 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 0x23f20
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,359 | std::_Deque_iterator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>&, std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>*>::_S_buffer_size() | static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); } | pushq %rax
movl $0x8, %edi
callq 0x23df0
popq %rcx
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_deque.h |
10,360 | std::allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22ce0
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/allocator.h |
10,361 | _gnu_cxx::new_allocator<std::reference_wrapper<std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, duckdb::shared_ptr<duckdb::BoundParameterData, true>, duckdb::CaseInsensitiveStringHashFunction, duckdb::CaseInsensitiveStringEquality, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, duckdb::shared_ptr<duckdb::BoundParameterData, true>>>>>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,362 | std::deque<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::deque() | deque() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22890
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_deque.h |
10,363 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_Deque_base() | _Deque_base()
: _M_impl()
{ _M_initialize_map(0); } | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23170
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22bf0
jmp 0x2b9a8
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x252c0
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,364 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_Deque_impl::_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x23680
movq 0x8(%rsp), %rdi
callq 0x22c70
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/stl_deque.h |
10,365 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_Deque_impl::~_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22c40
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_deque.h |
10,366 | std::allocator<std::reference_wrapper<duckdb::LogicalType const>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x254d0
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/allocator.h |
10,367 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_Deque_impl_data::_Deque_impl_data() | _Deque_impl_data() _GLIBCXX_NOEXCEPT
: _M_map(), _M_map_size(), _M_start(), _M_finish()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x243a0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x243a0
addq $0x18, %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_deque.h |
10,368 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,369 | std::_Deque_iterator<std::reference_wrapper<duckdb::LogicalType const>, std::reference_wrapper<duckdb::LogicalType const>&, std::reference_wrapper<duckdb::LogicalType const>*>::_Deque_iterator() | _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(), _M_first(), _M_last(), _M_node() { } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
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/stl_deque.h |
10,370 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_M_allocate_map(unsigned long) | _Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23600
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x240c0
movq %rax, 0x8(%rsp)
jmp 0x2bc86
leaq 0x27(%rsp), %rdi
callq 0x22680
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x22680
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,371 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_M_deallocate_map(std::reference_wrapper<duckdb::LogicalType const>**, unsigned long) | void
_M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0xf(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23600
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x250d0
jmp 0x2bdcb
leaq 0xf(%rsp), %rdi
callq 0x22680
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
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_deque.h |
10,372 | std::_Deque_iterator<std::reference_wrapper<duckdb::LogicalType const>, std::reference_wrapper<duckdb::LogicalType const>&, std::reference_wrapper<duckdb::LogicalType const>*>::_M_set_node(std::reference_wrapper<duckdb::LogicalType const>**) | void
_M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
{
_M_node = __new_node;
_M_first = *__new_node;
_M_last = _M_first + difference_type(_S_buffer_size());
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x23690
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x10(%rsp), %rax
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
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_deque.h |
10,373 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_M_get_map_allocator() const | _Map_alloc_type
_M_get_map_allocator() const _GLIBCXX_NOEXCEPT
{ return _Map_alloc_type(_M_get_Tp_allocator()); } | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22210
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x229f0
movq 0x10(%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_deque.h |
10,374 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>>::allocate(std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>&, 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 0x22ca0
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,375 | std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22d20
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/allocator.h |
10,376 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_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_deque.h |
10,377 | std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>::allocator<std::reference_wrapper<duckdb::LogicalType const>>(std::allocator<std::reference_wrapper<duckdb::LogicalType const>> const&) | _GLIBCXX20_CONSTEXPR
allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x23eb0
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/allocator.h |
10,378 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>*>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,379 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>*>::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 0x22670
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2bf5f
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2bf5a
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,380 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>*>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,381 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_M_allocate_node() | _Ptr
_M_allocate_node()
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x246a0
addq $0x18, %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_deque.h |
10,382 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::allocate(std::allocator<std::reference_wrapper<duckdb::LogicalType const>>&, 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 0x24170
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,383 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>>::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 0x223f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2c0af
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x18(%rsp)
jbe 0x2c0aa
callq 0x233a0
callq 0x22820
movq 0x18(%rsp), %rdi
shlq $0x3, %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,384 | std::_Deque_base<std::reference_wrapper<duckdb::LogicalType const>, std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::_M_deallocate_node(std::reference_wrapper<duckdb::LogicalType const>*) | void
_M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x8, %edi
callq 0x23df0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x24a60
jmp 0x2c120
addq $0x28, %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/stl_deque.h |
10,385 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::LogicalType const>>>::deallocate(std::allocator<std::reference_wrapper<duckdb::LogicalType const>>&, std::reference_wrapper<duckdb::LogicalType const>*, 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 0x24790
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,386 | std::allocator_traits<std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>>::deallocate(std::allocator<std::reference_wrapper<duckdb::LogicalType const>*>&, std::reference_wrapper<duckdb::LogicalType const>**, 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 0x22700
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,387 | std::_Deque_iterator<std::reference_wrapper<duckdb::LogicalType const>, std::reference_wrapper<duckdb::LogicalType const>&, std::reference_wrapper<duckdb::LogicalType const>*>::_S_buffer_size() | static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); } | pushq %rax
movl $0x8, %edi
callq 0x23df0
popq %rcx
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_deque.h |
10,388 | std::allocator<std::reference_wrapper<duckdb::LogicalType const>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x251a0
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/allocator.h |
10,389 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::LogicalType const>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,390 | std::deque<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::deque() | deque() = default; | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23b80
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_deque.h |
10,391 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_Deque_base() | _Deque_base()
: _M_impl()
{ _M_initialize_map(0); } | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x243b0
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x24ca0
jmp 0x2c258
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x24430
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,392 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_Deque_impl::_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x24a50
movq 0x8(%rsp), %rdi
callq 0x24690
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/stl_deque.h |
10,393 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_Deque_impl::~_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x23330
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_deque.h |
10,394 | std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x224c0
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/allocator.h |
10,395 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_Deque_impl_data::_Deque_impl_data() | _Deque_impl_data() _GLIBCXX_NOEXCEPT
: _M_map(), _M_map_size(), _M_start(), _M_finish()
{ } | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x238e0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x238e0
addq $0x18, %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_deque.h |
10,396 | _gnu_cxx::new_allocator<std::reference_wrapper<duckdb::CompressionInfo const>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | movq %rdi, -0x8(%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/ext/new_allocator.h |
10,397 | std::_Deque_iterator<std::reference_wrapper<duckdb::CompressionInfo const>, std::reference_wrapper<duckdb::CompressionInfo const>&, std::reference_wrapper<duckdb::CompressionInfo const>*>::_Deque_iterator() | _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(), _M_first(), _M_last(), _M_node() { } | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
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/stl_deque.h |
10,398 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_M_allocate_map(unsigned long) | _Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23890
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x24ce0
movq %rax, 0x8(%rsp)
jmp 0x2c536
leaq 0x27(%rsp), %rdi
callq 0x22ac0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x22ac0
movq 0x18(%rsp), %rdi
callq 0x24f70
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_deque.h |
10,399 | std::_Deque_base<std::reference_wrapper<duckdb::CompressionInfo const>, std::allocator<std::reference_wrapper<duckdb::CompressionInfo const>>>::_M_deallocate_map(std::reference_wrapper<duckdb::CompressionInfo const>**, unsigned long) | void
_M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0xf(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x23890
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x228f0
jmp 0x2c67b
leaq 0xf(%rsp), %rdi
callq 0x22ac0
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x279b0
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_deque.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.