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
|
|---|---|---|---|---|---|---|
4,400 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,401 | _gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,402 | _gnu_cxx::__normal_iterator<Omega_h::any const*, std::vector<Omega_h::any, std::allocator<Omega_h::any>>>::__normal_iterator(Omega_h::any const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,403 | std::shared_ptr<Omega_h::ExprOp> const const* Omega_h::any_cast<std::shared_ptr<Omega_h::ExprOp> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34a171
movq -0x10(%rbp), %rdi
movq 0x3ad822(%rip), %rsi # 0x6f7980
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x34a168
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x34a17b
jmp 0x34a171
movq $0x0, -0x8(%rbp)
jmp 0x34a188
movq -0x10(%rbp), %rdi
callq 0x1baa30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,404 | std::shared_ptr<Omega_h::ExprOp> const const* Omega_h::any::cast<std::shared_ptr<Omega_h::ExprOp> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,405 | void std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::construct<std::shared_ptr<Omega_h::ExprOp>, std::shared_ptr<Omega_h::ExprOp> const&>(std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp> const&) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1cb790
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,406 | void std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_M_realloc_insert<std::shared_ptr<Omega_h::ExprOp> const&>(__gnu_cxx::__normal_iterator<std::shared_ptr<Omega_h::ExprOp>*, std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>>, std::shared_ptr<Omega_h::ExprOp> const&) | 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;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0x2e106c(%rip), %rdx # 0x62b277
callq 0x1d9e10
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1dd1b0
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d40f0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1c8540
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1c4a30
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1bf6e0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1ca580
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1c2090
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1bf6e0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1ca580
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1c2090
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
sarq $0x4, %rdx
callq 0x1c9c90
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
4,407 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1bfa90
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,408 | void __gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::construct<std::shared_ptr<Omega_h::ExprOp>, std::shared_ptr<Omega_h::ExprOp> const&>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp> const&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d9100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,409 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_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;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1ce710
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1babe0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x34a407
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1babe0
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1babe0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1babe0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x34a476
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1ce710
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x34a485
movq -0x38(%rbp), %rdi
callq 0x1ce710
movq %rax, -0x58(%rbp)
jmp 0x34a48d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,410 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1bfa90
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,411 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_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();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34a542
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b9c60
movq %rax, -0x20(%rbp)
jmp 0x34a54a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x34a54a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,412 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_S_relocate(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c7960
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,413 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,414 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_M_deallocate(std::shared_ptr<Omega_h::ExprOp>*, 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34a5f4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1cf610
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,415 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c9520
movq %rax, %rdi
callq 0x1def20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,416 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_S_max_size(std::allocator<std::shared_ptr<Omega_h::ExprOp>> 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x7ffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ccb30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,417 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,418 | std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::max_size(std::allocator<std::shared_ptr<Omega_h::ExprOp>> 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e2940
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,419 | _gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cb1a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,420 | _gnu_cxx::__normal_iterator<std::shared_ptr<Omega_h::ExprOp>*, std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>>::__normal_iterator(std::shared_ptr<Omega_h::ExprOp>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,421 | std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::allocate(std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1ce350
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,422 | _gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::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)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1cb1a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x34a77b
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x34a776
callq 0x1c85c0
callq 0x1be740
movq -0x10(%rbp), %rdi
shlq $0x4, %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,423 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_S_do_relocate(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1db150
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,424 | std::shared_ptr<Omega_h::ExprOp>* std::__relocate_a<std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c5c70
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c5c70
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c5c70
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1d71b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,425 | std::shared_ptr<Omega_h::ExprOp>* std::__relocate_a_1<std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&) | inline _ForwardIterator
__relocate_a_1(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
std::addressof(*__first),
__alloc)))
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
static_assert(std::is_same<_ValueType, _ValueType2>::value,
"relocation is only possible for values of the same type");
_ForwardIterator __cur = __result;
for (; __first != __last; ++__first, (void)++__cur)
std::__relocate_object_a(std::__addressof(*__cur),
std::__addressof(*__first), __alloc);
return __cur;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x34a885
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1d7470
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x34a850
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,426 | void std::__relocate_object_a<std::shared_ptr<Omega_h::ExprOp>, std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&) | inline void
__relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
_Allocator& __alloc)
noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
__dest, std::move(*__orig)))
&& noexcept(std::allocator_traits<_Allocator>::destroy(
__alloc, std::__addressof(*__orig))))
{
typedef std::allocator_traits<_Allocator> __traits;
__traits::construct(__alloc, __dest, std::move(*__orig));
__traits::destroy(__alloc, std::__addressof(*__orig));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1c9240
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b9f20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,427 | void std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::construct<std::shared_ptr<Omega_h::ExprOp>, std::shared_ptr<Omega_h::ExprOp>>(std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>&&) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d4b60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,428 | void std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::destroy<std::shared_ptr<Omega_h::ExprOp>>(std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, std::shared_ptr<Omega_h::ExprOp>*) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1be390
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,429 | void __gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::construct<std::shared_ptr<Omega_h::ExprOp>, std::shared_ptr<Omega_h::ExprOp>>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c98c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,430 | std::shared_ptr<Omega_h::ExprOp>::shared_ptr(std::shared_ptr<Omega_h::ExprOp>&&) | shared_ptr(shared_ptr&& __r) noexcept
: __shared_ptr<_Tp>(std::move(__r)) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d8ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,431 | std::__shared_ptr<Omega_h::ExprOp, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<Omega_h::ExprOp, (__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;
} | 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), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x1c5f70
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1e10e0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,432 | void __gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::destroy<std::shared_ptr<Omega_h::ExprOp>>(std::shared_ptr<Omega_h::ExprOp>*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dded0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,433 | std::allocator_traits<std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::deallocate(std::allocator<std::shared_ptr<Omega_h::ExprOp>>&, std::shared_ptr<Omega_h::ExprOp>*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1bdbf0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,434 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5b50
movq %rax, %rdi
callq 0x1cd3b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,435 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::capacity() const | size_type
capacity() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,436 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_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();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34ab12
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d54a0
movq %rax, -0x20(%rbp)
jmp 0x34ab1a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x34ab1a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,437 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::_S_relocate(Omega_h::any*, Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1dd2e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,438 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,439 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_M_deallocate(Omega_h::any*, 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34abb4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1e1b40
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,440 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::_S_max_size(std::allocator<Omega_h::any> 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x555555555555555, %rax # imm = 0x555555555555555
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bbb10
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,441 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,442 | std::allocator_traits<std::allocator<Omega_h::any>>::max_size(std::allocator<Omega_h::any> 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e12f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,443 | _gnu_cxx::new_allocator<Omega_h::any>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1da1d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,444 | std::allocator_traits<std::allocator<Omega_h::any>>::allocate(std::allocator<Omega_h::any>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1d2e00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,445 | _gnu_cxx::new_allocator<Omega_h::any>::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)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1da1d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x34aceb
movabsq $0xaaaaaaaaaaaaaaa, %rax # imm = 0xAAAAAAAAAAAAAAA
cmpq %rax, -0x10(%rbp)
jbe 0x34ace6
callq 0x1c85c0
callq 0x1be740
imulq $0x18, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,446 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::_S_do_relocate(Omega_h::any*, Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1bda10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,447 | Omega_h::any* std::__relocate_a<Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>>(Omega_h::any*, Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1db0a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1db0a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1db0a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1e1150
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,448 | Omega_h::any* std::__relocate_a_1<Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>>(Omega_h::any*, Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>&) | inline _ForwardIterator
__relocate_a_1(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
std::addressof(*__first),
__alloc)))
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
static_assert(std::is_same<_ValueType, _ValueType2>::value,
"relocation is only possible for values of the same type");
_ForwardIterator __cur = __result;
for (; __first != __last; ++__first, (void)++__cur)
std::__relocate_object_a(std::__addressof(*__cur),
std::__addressof(*__first), __alloc);
return __cur;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x34adf5
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1e2310
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
jmp 0x34adc0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,449 | void std::__relocate_object_a<Omega_h::any, Omega_h::any, std::allocator<Omega_h::any>>(Omega_h::any*, Omega_h::any*, std::allocator<Omega_h::any>&) | inline void
__relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
_Allocator& __alloc)
noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
__dest, std::move(*__orig)))
&& noexcept(std::allocator_traits<_Allocator>::destroy(
__alloc, std::__addressof(*__orig))))
{
typedef std::allocator_traits<_Allocator> __traits;
__traits::construct(__alloc, __dest, std::move(*__orig));
__traits::destroy(__alloc, std::__addressof(*__orig));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1cd0d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c1160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,450 | void std::allocator_traits<std::allocator<Omega_h::any>>::construct<Omega_h::any, Omega_h::any>(std::allocator<Omega_h::any>&, Omega_h::any*, Omega_h::any&&) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,451 | void std::allocator_traits<std::allocator<Omega_h::any>>::destroy<Omega_h::any>(std::allocator<Omega_h::any>&, Omega_h::any*) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dcf60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,452 | void __gnu_cxx::new_allocator<Omega_h::any>::construct<Omega_h::any, Omega_h::any>(Omega_h::any*, Omega_h::any&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bc0d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,453 | void __gnu_cxx::new_allocator<Omega_h::any>::destroy<Omega_h::any>(Omega_h::any*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cd2d0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,454 | std::allocator_traits<std::allocator<Omega_h::any>>::deallocate(std::allocator<Omega_h::any>&, Omega_h::any*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ba9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,455 | void std::_Destroy<std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*, std::allocator<std::shared_ptr<Omega_h::ExprOp>>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dfa30
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,456 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x4, %rdx
callq 0x1c9c90
jmp 0x34afb9
movq -0x10(%rbp), %rdi
callq 0x1cda40
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,457 | void std::_Destroy<std::shared_ptr<Omega_h::ExprOp>*>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*) | _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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c1a90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
4,458 | void std::_Destroy_aux<false>::__destroy<std::shared_ptr<Omega_h::ExprOp>*>(std::shared_ptr<Omega_h::ExprOp>*, std::shared_ptr<Omega_h::ExprOp>*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x34b031
movq -0x8(%rbp), %rdi
callq 0x1d5be0
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x34b010
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
4,459 | void std::_Destroy<std::shared_ptr<Omega_h::ExprOp>>(std::shared_ptr<Omega_h::ExprOp>*) | _GLIBCXX14_CONSTEXPR inline void
_Destroy(_Tp* __pointer)
{
#if __cplusplus > 201703L
std::destroy_at(__pointer);
#else
__pointer->~_Tp();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dded0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
4,460 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bd480
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,461 | std::allocator<std::shared_ptr<Omega_h::ExprOp>>::~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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c1790
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,462 | _gnu_cxx::new_allocator<std::shared_ptr<Omega_h::ExprOp>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,463 | void Omega_h::any::construct<double>(double&&) | void construct(ValueType&& value) {
using T = typename std::decay<ValueType>::type;
this->vtable = vtable_for_type<T>();
do_construct<ValueType, T>(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1e2450
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1e47e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,464 | Omega_h::any::vtable_type* Omega_h::any::vtable_for_type<double>() | static vtable_type* vtable_for_type() {
using VTableType = typename std::conditional<requires_allocation<T>::value,
vtable_dynamic<T>, vtable_stack<T>>::type;
static vtable_type table = {
VTableType::type,
VTableType::destroy,
VTableType::copy,
VTableType::move,
VTableType::swap,
};
return &table;
} | pushq %rbp
movq %rsp, %rbp
movq 0x3ac8dd(%rip), %rax # 0x6f79d8
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,465 | std::enable_if<!requires_allocation<double>::value, void>::type Omega_h::any::do_construct<double, double>(double&&) | typename std::enable_if<!requires_allocation<T>::value>::type do_construct(
ValueType&& value) {
new (&storage.stack) T(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,466 | Omega_h::any::vtable_stack<double>::type() | static const std::type_info& type() noexcept { return typeid(T); } | pushq %rbp
movq %rsp, %rbp
movq 0x3aceb5(%rip), %rax # 0x6f7fe0
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,467 | Omega_h::any::vtable_stack<double>::destroy(Omega_h::any::storage_union&) | static void destroy(storage_union& storage) noexcept {
reinterpret_cast<T*>(&storage.stack)->~T();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,468 | Omega_h::any::vtable_stack<double>::copy(Omega_h::any::storage_union const&, Omega_h::any::storage_union&) | static void copy(const storage_union& src, storage_union& dest) {
new (&dest.stack) T(reinterpret_cast<const T&>(src.stack));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,469 | Omega_h::any::vtable_stack<double>::move(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void move(storage_union& src, storage_union& dest) noexcept {
// one of the conditions for using vtable_stack is a nothrow move
// constructor, so this move constructor will never throw a exception.
new (&dest.stack) T(std::move(reinterpret_cast<T&>(src.stack)));
destroy(src);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1e0d70
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,470 | Omega_h::any::vtable_stack<double>::swap(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void swap(storage_union& lhs, storage_union& rhs) noexcept {
std::swap(
reinterpret_cast<T&>(lhs.stack), reinterpret_cast<T&>(rhs.stack));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c4f10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,471 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::_M_range_check(unsigned long) const | void
_M_range_check(size_type __n) const
{
if (__n >= this->size())
__throw_out_of_range_fmt(__N("vector::_M_range_check: __n "
"(which is %zu) >= this->size() "
"(which is %zu)"),
__n, this->size());
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1dd800
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jb 0x34b257
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1dd800
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x2e2cd3(%rip), %rdi # 0x62df23
movb $0x0, %al
callq 0x1d9980
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,472 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d17c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,473 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d17c0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,474 | _gnu_cxx::__normal_iterator<Omega_h::any*, std::vector<Omega_h::any, std::allocator<Omega_h::any>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,475 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d0fc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,476 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::push_back(Omega_h::Read<double>&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d68f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,477 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::push_back(Omega_h::Read<double> const&) | void
push_back(const value_type& __x)
{
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,
__x);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), __x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x34b3d5
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1db360
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
jmp 0x34b3f3
movq -0x20(%rbp), %rdi
callq 0x1b9bd0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1d9f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,478 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9bd0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1e3f60
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d11e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,479 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::vector(std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>> const&) | vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c2b30
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d0970
movq %rax, %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1de170
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1c0e20
jmp 0x34b491
leaq -0x11(%rbp), %rdi
callq 0x1e06a0
movq -0x10(%rbp), %rdi
callq 0x1df9d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1db340
movq -0x50(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq (%rdi), %rax
movq %rax, -0x60(%rbp)
callq 0x1c7210
movq -0x60(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1e4500
movq %rax, -0x58(%rbp)
jmp 0x34b4de
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1e06a0
jmp 0x34b51c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c2640
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,480 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1c7210
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1d1300
jmp 0x34b56a
movq -0x20(%rbp), %rdi
callq 0x1c2640
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,481 | _gnu_cxx::__normal_iterator<Omega_h::any*, std::vector<Omega_h::any, std::allocator<Omega_h::any>>>::__normal_iterator(Omega_h::any* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,482 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cffe0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,483 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c3bb0
movq -0x10(%rbp), %rdi
callq 0x1de3e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,484 | std::allocator<Omega_h::Read<double>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1de5a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,485 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,486 | _gnu_cxx::new_allocator<Omega_h::Read<double>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,487 | void std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::emplace_back<Omega_h::Read<double>>(Omega_h::Read<double>&&) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x34b6b5
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1df0a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
jmp 0x34b6d3
movq -0x20(%rbp), %rdi
callq 0x1b9bd0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1c8970
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
4,488 | void std::allocator_traits<std::allocator<Omega_h::Read<double>>>::construct<Omega_h::Read<double>, Omega_h::Read<double>>(std::allocator<Omega_h::Read<double>>&, Omega_h::Read<double>*, Omega_h::Read<double>&&) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1df990
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,489 | void std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_M_realloc_insert<Omega_h::Read<double>>(__gnu_cxx::__normal_iterator<Omega_h::Read<double>*, std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>>, Omega_h::Read<double>&&) | 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;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq 0x2dfb41(%rip), %rdx # 0x62b277
movl $0x1, %esi
callq 0x1bf9a0
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1e41a0
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bbf20
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1bb1f0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1df0a0
jmp 0x34b7a8
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1d9050
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1c7210
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1dbd80
movq %rax, -0x70(%rbp)
jmp 0x34b7f9
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1d9050
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x1c7210
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, %rcx
callq 0x1dbd80
movq %rax, -0x90(%rbp)
jmp 0x34b865
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x34b919
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
callq 0x1bf6c0
cmpq $0x0, -0x50(%rbp)
jne 0x34b8ab
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x1cd720
jmp 0x34b8f7
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x1c7210
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
callq 0x1d1300
jmp 0x34b8e2
jmp 0x34b8f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x1dc770
jmp 0x34b914
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1db3c0
jmp 0x34b90a
callq 0x1d87c0
jmp 0x34b9aa
jmp 0x34b999
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x1c7210
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
callq 0x1d1300
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
sarq $0x4, %rdx
callq 0x1db3c0
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
4,490 | void __gnu_cxx::new_allocator<Omega_h::Read<double>>::construct<Omega_h::Read<double>, Omega_h::Read<double>>(Omega_h::Read<double>*, Omega_h::Read<double>&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e4220
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,491 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_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;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d0790
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1c2b30
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x34ba27
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1c2b30
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1c2b30
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1c2b30
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x34ba96
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1d0790
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x34baa5
movq -0x38(%rbp), %rdi
callq 0x1d0790
movq %rax, -0x58(%rbp)
jmp 0x34baad
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,492 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_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();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34bb32
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1da300
movq %rax, -0x20(%rbp)
jmp 0x34bb3a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x34bb3a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,493 | Omega_h::Read<double>* std::__uninitialized_move_if_noexcept_a<Omega_h::Read<double>*, Omega_h::Read<double>*, std::allocator<Omega_h::Read<double>>>(Omega_h::Read<double>*, Omega_h::Read<double>*, Omega_h::Read<double>*, std::allocator<Omega_h::Read<double>>&) | 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1decf0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1decf0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c5b50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,494 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,495 | void std::allocator_traits<std::allocator<Omega_h::Read<double>>>::destroy<Omega_h::Read<double>>(std::allocator<Omega_h::Read<double>>&, Omega_h::Read<double>*) | 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
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d0ea0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,496 | void std::_Destroy<Omega_h::Read<double>*, Omega_h::Read<double>>(Omega_h::Read<double>*, Omega_h::Read<double>*, std::allocator<Omega_h::Read<double>>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cf070
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,497 | std::_Vector_base<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_M_deallocate(Omega_h::Read<double>*, 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34bc44
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1c6160
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,498 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d0970
movq %rax, %rdi
callq 0x1b9d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,499 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::_S_max_size(std::allocator<Omega_h::Read<double>> 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);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x7ffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d3440
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.