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
|
|---|---|---|---|---|---|---|
2,300 | _gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::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 0x1d2b30
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2964fb
movabsq $0x666666666666666, %rax # imm = 0x666666666666666
cmpq %rax, -0x10(%rbp)
jbe 0x2964f6
callq 0x1c85c0
callq 0x1be740
imulq $0x28, -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 |
2,301 | void std::allocator_traits<std::allocator<std::_Rb_tree_node<int>>>::construct<int, int const&>(std::allocator<std::_Rb_tree_node<int>>&, int*, int 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 0x1e4770
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 |
2,302 | std::_Rb_tree_node<int>::_M_valptr() | const _Val*
_M_valptr() const
{ return _M_storage._M_ptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1c3560
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/bits/stl_tree.h |
2,303 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_put_node(std::_Rb_tree_node<int>*) | void
_M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{ _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e0b30
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1c39d0
jmp 0x2965ac
addq $0x10, %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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
2,304 | void __gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::construct<int, int const&>(int*, int 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%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/ext/new_allocator.h |
2,305 | _gnu_cxx::__aligned_membuf<int>::_M_ptr() | _Tp*
_M_ptr() noexcept
{ return static_cast<_Tp*>(_M_addr()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0910
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/aligned_buffer.h |
2,306 | _gnu_cxx::__aligned_membuf<int>::_M_addr() | void*
_M_addr() noexcept
{ return static_cast<void*>(&_M_storage); } | 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/ext/aligned_buffer.h |
2,307 | std::allocator_traits<std::allocator<std::_Rb_tree_node<int>>>::deallocate(std::allocator<std::_Rb_tree_node<int>>&, std::_Rb_tree_node<int>*, 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 0x1d06c0
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 |
2,308 | std::_Rb_tree_const_iterator<int>::_Rb_tree_const_iterator(std::_Rb_tree_iterator<int> const&) | _Rb_tree_const_iterator(const iterator& __it) _GLIBCXX_NOEXCEPT
: _M_node(__it._M_node) { } | 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_tree.h |
2,309 | std::_Rb_tree<Omega_h::StateInProgress const*, std::pair<Omega_h::StateInProgress const* const, int>, std::_Select1st<std::pair<Omega_h::StateInProgress const* const, int>>, Omega_h::StateCompare, std::allocator<std::pair<Omega_h::StateInProgress const* const, int>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(&this->_M_impl._M_header); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d2370
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_tree.h |
2,310 | void std::allocator_traits<std::allocator<Omega_h::ActionInProgress>>::construct<Omega_h::ActionInProgress, Omega_h::ActionInProgress>(std::allocator<Omega_h::ActionInProgress>&, Omega_h::ActionInProgress*, Omega_h::ActionInProgress&&) | 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 0x1d5330
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 |
2,311 | void std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_M_realloc_insert<Omega_h::ActionInProgress>(__gnu_cxx::__normal_iterator<Omega_h::ActionInProgress*, std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>>, Omega_h::ActionInProgress&&) | 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 0x394aac(%rip), %rdx # 0x62b277
callq 0x1be720
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1d0a70
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c4820
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1b8560
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
imulq $0x38, -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1bfd30
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1cf490
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1bb400
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1c9020
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1cf490
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 0x1bb400
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1c9020
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x38, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x1bcc80
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x38, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
| 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 |
2,312 | void __gnu_cxx::new_allocator<Omega_h::ActionInProgress>::construct<Omega_h::ActionInProgress, Omega_h::ActionInProgress>(Omega_h::ActionInProgress*, Omega_h::ActionInProgress&&) | 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 0x1d0760
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 |
2,313 | std::set<int, std::less<int>, std::allocator<int>>::set(std::set<int, std::less<int>, std::allocator<int>>&&) | set(set&&) = default; | 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 0x1dd430
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_set.h |
2,314 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>&&) | _Rb_tree(_Rb_tree&&) = default; | 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 0x1d50e0
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_tree.h |
2,315 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree_impl<std::less<int>, true>::_Rb_tree_impl(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree_impl<std::less<int>, true>&&) | _Rb_tree_impl(_Rb_tree_impl&&)
noexcept( is_nothrow_move_constructible<_Base_key_compare>::value )
= default; | 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), %rsi
callq 0x1c40d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e3060
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1e16a0
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_tree.h |
2,316 | std::_Rb_tree_key_compare<std::less<int>>::_Rb_tree_key_compare(std::_Rb_tree_key_compare<std::less<int>>&&) | _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
: _M_key_compare(__x._M_key_compare)
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
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_tree.h |
2,317 | std::_Rb_tree_header::_Rb_tree_header(std::_Rb_tree_header&&) | _Rb_tree_header(_Rb_tree_header&& __x) noexcept
{
if (__x._M_header._M_parent != nullptr)
_M_move_data(__x);
else
{
_M_header._M_color = _S_red;
_M_reset();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x296a84
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1baa20
jmp 0x296a82
jmp 0x296a93
movq -0x18(%rbp), %rdi
movl $0x0, (%rdi)
callq 0x1d36a0
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_tree.h |
2,318 | _gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::new_allocator(__gnu_cxx::new_allocator<std::_Rb_tree_node<int>> const&) | _GLIBCXX20_CONSTEXPR
new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
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 |
2,319 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_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 0x1cfe30
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1cd970
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x296b07
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1cd970
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1cd970
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 0x1cd970
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x296b76
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1cfe30
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x296b85
movq -0x38(%rbp), %rdi
callq 0x1cfe30
movq %rax, -0x58(%rbp)
jmp 0x296b8d
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 |
2,320 | std::_Vector_base<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_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 0x296c22
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db500
movq %rax, -0x20(%rbp)
jmp 0x296c2a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x296c2a
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 |
2,321 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_S_relocate(Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>&) | 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 0x1b98f0
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 |
2,322 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::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 0x1cad50
movq %rax, %rdi
callq 0x1dcd30
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 |
2,323 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x38, %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 |
2,324 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_S_max_size(std::allocator<Omega_h::ActionInProgress> 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 $0x249249249249249, %rax # imm = 0x249249249249249
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dfa50
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 |
2,325 | std::_Vector_base<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_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 |
2,326 | std::allocator_traits<std::allocator<Omega_h::ActionInProgress>>::max_size(std::allocator<Omega_h::ActionInProgress> 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 0x1c1750
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 |
2,327 | _gnu_cxx::new_allocator<Omega_h::ActionInProgress>::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 0x1bd0f0
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 |
2,328 | std::allocator_traits<std::allocator<Omega_h::ActionInProgress>>::allocate(std::allocator<Omega_h::ActionInProgress>&, 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 0x1df0c0
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 |
2,329 | _gnu_cxx::new_allocator<Omega_h::ActionInProgress>::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 0x1bd0f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x296e1b
movabsq $0x492492492492492, %rax # imm = 0x492492492492492
cmpq %rax, -0x10(%rbp)
jbe 0x296e16
callq 0x1c85c0
callq 0x1be740
imulq $0x38, -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 |
2,330 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_S_do_relocate(Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>&, 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 0x1d8410
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 |
2,331 | Omega_h::ActionInProgress* std::__relocate_a<Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>>(Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>&) | 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 0x1ba770
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba770
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ba770
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1cf800
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 |
2,332 | Omega_h::ActionInProgress* std::__relocate_a_1<Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>>(Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>&) | 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 0x296f25
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1bac60
movq -0x8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
jmp 0x296ef0
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 |
2,333 | void std::__relocate_object_a<Omega_h::ActionInProgress, Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>(Omega_h::ActionInProgress*, Omega_h::ActionInProgress*, std::allocator<Omega_h::ActionInProgress>&) | 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 0x1bfd30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1df290
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 |
2,334 | void std::allocator_traits<std::allocator<Omega_h::ActionInProgress>>::destroy<Omega_h::ActionInProgress>(std::allocator<Omega_h::ActionInProgress>&, Omega_h::ActionInProgress*) | 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 0x1e3b70
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 |
2,335 | void __gnu_cxx::new_allocator<Omega_h::ActionInProgress>::destroy<Omega_h::ActionInProgress>(Omega_h::ActionInProgress*) | 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 0x1c7c10
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 |
2,336 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::push_back(Omega_h::ActionInProgress 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 0x297055
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1da380
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
jmp 0x297073
movq -0x20(%rbp), %rdi
callq 0x1e2f40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1da050
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 |
2,337 | void std::allocator_traits<std::allocator<Omega_h::ActionInProgress>>::construct<Omega_h::ActionInProgress, Omega_h::ActionInProgress const&>(std::allocator<Omega_h::ActionInProgress>&, Omega_h::ActionInProgress*, Omega_h::ActionInProgress 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 0x1ced40
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 |
2,338 | void std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::_M_realloc_insert<Omega_h::ActionInProgress const&>(__gnu_cxx::__normal_iterator<Omega_h::ActionInProgress*, std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>>, Omega_h::ActionInProgress 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 $0xb0, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq 0x394181(%rip), %rdx # 0x62b277
movl $0x1, %esi
callq 0x1be720
movq -0x68(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1d0a70
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c4820
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1b8560
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1da380
jmp 0x297168
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1cf490
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x1bb400
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
callq 0x1c9020
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1cf490
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x1bb400
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
callq 0x1c9020
movq %rax, -0x50(%rbp)
jmp 0x2972b0
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 0x297248
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
imulq $0x38, -0x38(%rbp), %rax
addq %rax, %rsi
callq 0x1df290
jmp 0x297294
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0x1bb400
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq %rax, %rdx
callq 0x1c6320
jmp 0x29727f
jmp 0x297294
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x1dc770
jmp 0x2972ae
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1bcc80
jmp 0x2972a7
callq 0x1d87c0
jmp 0x297312
jmp 0x297301
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x38, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x1bcc80
movq -0x68(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x38, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
movq %rax, %rdi
callq 0x1e9370
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/vector.tcc |
2,339 | void __gnu_cxx::new_allocator<Omega_h::ActionInProgress>::construct<Omega_h::ActionInProgress, Omega_h::ActionInProgress const&>(Omega_h::ActionInProgress*, Omega_h::ActionInProgress 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 0x1d4420
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 |
2,340 | std::set<int, std::less<int>, std::allocator<int>>::set(std::set<int, std::less<int>, std::allocator<int>> const&) | set(const set&) = default; | 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 0x1da710
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_set.h |
2,341 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>> const&) | _Rb_tree(const _Rb_tree& __x)
: _M_impl(__x._M_impl)
{
if (__x._M_root() != 0)
_M_root() = _M_copy(__x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c5e10
movq -0x10(%rbp), %rdi
callq 0x1cd700
cmpq $0x0, %rax
je 0x29742c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c77d0
movq %rax, -0x30(%rbp)
jmp 0x297403
movq -0x28(%rbp), %rdi
callq 0x1d9120
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x29742c
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e3bd0
jmp 0x297432
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1dfa40
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_tree.h |
2,342 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree_impl<std::less<int>, true>::_Rb_tree_impl(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree_impl<std::less<int>, true> const&) | _Rb_tree_impl(const _Rb_tree_impl& __x)
: _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
, _Base_key_compare(__x._M_key_compare)
, _Rb_tree_header()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c18c0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x1c40d0
movq -0x38(%rbp), %rdi
callq 0x1ba150
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c09c0
jmp 0x29748e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8bc0
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1ba150
movq -0x20(%rbp), %rdi
callq 0x1dfa40
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_tree.h |
2,343 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_root() const | _Const_Base_ptr
_M_root() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_header._M_parent; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
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_tree.h |
2,344 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_copy(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>> const&) | _Link_type
_M_copy(const _Rb_tree& __x)
{
_Alloc_node __an(*this);
return _M_copy<__as_lvalue>(__x, __an);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dcae0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1b8d30
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_tree.h |
2,345 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_root() | _Const_Base_ptr
_M_root() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_header._M_parent; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x8, %rax
popq %rbp
retq
nopw %cs:(%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_tree.h |
2,346 | _gnu_cxx::__alloc_traits<std::allocator<std::_Rb_tree_node<int>>, std::_Rb_tree_node<int>>::_S_select_on_copy(std::allocator<std::_Rb_tree_node<int>> const&) | static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
{ return _Base_type::select_on_container_copy_construction(__a); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1daac0
movq -0x18(%rbp), %rax
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/alloc_traits.h |
2,347 | std::allocator<std::_Rb_tree_node<int>>::~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 0x1e3c10
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 |
2,348 | std::_Rb_tree_key_compare<std::less<int>>::_Rb_tree_key_compare(std::less<int> const&) | _Rb_tree_key_compare(const _Key_compare& __comp)
: _M_key_compare(__comp)
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
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_tree.h |
2,349 | std::allocator_traits<std::allocator<std::_Rb_tree_node<int>>>::select_on_container_copy_construction(std::allocator<std::_Rb_tree_node<int>> const&) | select_on_container_copy_construction(const allocator_type& __rhs)
{ return __rhs; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c40d0
movq -0x18(%rbp), %rax
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 |
2,350 | _gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::~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 |
2,351 | std::_Rb_tree_node<int>* std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_copy<false, std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Alloc_node>(std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>> const&, std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Alloc_node&) | _Link_type
_M_copy(const _Rb_tree& __x, _NodeGen& __gen)
{
_Link_type __root =
_M_copy<_MoveValues>(__x._M_mbegin(), _M_end(), __gen);
_M_leftmost() = _S_minimum(__root);
_M_rightmost() = _S_maximum(__root);
_M_impl._M_node_count = __x._M_impl._M_node_count;
return __root;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dc310
movq -0x28(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x1bbe60
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x1cb180
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1e30c0
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x1dc4f0
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x1e1640
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1cc650
movq -0x30(%rbp), %rdx
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rdx, (%rcx)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %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/stl_tree.h |
2,352 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_S_minimum(std::_Rb_tree_node_base*) | static _Base_ptr
_S_minimum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
{ return _Rb_tree_node_base::_S_minimum(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0590
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_tree.h |
2,353 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_leftmost() | _Base_ptr&
_M_leftmost() _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_header._M_left; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rax
popq %rbp
retq
nopw %cs:(%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_tree.h |
2,354 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_S_maximum(std::_Rb_tree_node_base*) | static _Base_ptr
_S_maximum(_Base_ptr __x) _GLIBCXX_NOEXCEPT
{ return _Rb_tree_node_base::_S_maximum(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b8500
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_tree.h |
2,355 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_rightmost() | _Const_Base_ptr
_M_rightmost() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_header._M_right; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x18, %rax
popq %rbp
retq
nopw %cs:(%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_tree.h |
2,356 | std::_Rb_tree_node<int>* std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_clone_node<false, std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Alloc_node>(std::_Rb_tree_node<int>*, std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Alloc_node&) | _Link_type
_M_clone_node(_Link_type __x, _NodeGen& __node_gen)
{
#if __cplusplus >= 201103L
using _Vp = typename conditional<_MoveValue,
value_type&&,
const value_type&>::type;
#endif
_Link_type __tmp
= __node_gen(_GLIBCXX_FORWARD(_Vp, *__x->_M_valptr()));
__tmp->_M_color = __x->_M_color;
__tmp->_M_left = 0;
__tmp->_M_right = 0;
return __tmp;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd860
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1c0d00
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
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_tree.h |
2,357 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_drop_node(std::_Rb_tree_node<int>*) | void
_M_drop_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{
_M_destroy_node(__p);
_M_put_node(__p);
} | 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), %rsi
callq 0x1dd780
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bd5c0
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_tree.h |
2,358 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_M_destroy_node(std::_Rb_tree_node<int>*) | void
_M_destroy_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{
#if __cplusplus < 201103L
get_allocator().destroy(__p->_M_valptr());
#else
_Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
__p->~_Rb_tree_node<_Val>();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e0b30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd860
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1cdc60
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_tree.h |
2,359 | void std::allocator_traits<std::allocator<std::_Rb_tree_node<int>>>::destroy<int>(std::allocator<std::_Rb_tree_node<int>>&, int*) | 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 0x1ccfc0
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 |
2,360 | void __gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::destroy<int>(int*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
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 |
2,361 | std::deque<int, std::allocator<int>>::~deque() | ~deque()
{ _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1c7ce0
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1d54b0
movq -0x60(%rbp), %rdi
callq 0x1c04c0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
callq 0x1d9420
jmp 0x297ad1
movq -0x60(%rbp), %rdi
callq 0x1d1090
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_deque.h |
2,362 | std::deque<int, std::allocator<int>>::_M_destroy_data(std::_Deque_iterator<int, int&, int*>, std::_Deque_iterator<int, int&, int*>, std::allocator<int> const&) | void
_M_destroy_data(iterator __first, iterator __last,
const std::allocator<_Tp>&)
{
if (!__has_trivial_destructor(value_type))
_M_destroy_data_aux(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
popq %rbp
retq
nopw %cs:(%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_deque.h |
2,363 | std::deque<int, std::allocator<int>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_finish; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x1d1280
movq -0x18(%rbp), %rax
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/bits/stl_deque.h |
2,364 | std::_Deque_base<int, std::allocator<int>>::~_Deque_base() | _Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x297b7f
movq -0x10(%rbp), %rdi
movq 0x28(%rdi), %rsi
movq 0x48(%rdi), %rdx
addq $0x8, %rdx
callq 0x1bd190
movq -0x10(%rbp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
callq 0x1c39f0
movq -0x10(%rbp), %rdi
callq 0x1c4cd0
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/bits/stl_deque.h |
2,365 | std::_Rb_tree<Omega_h::StateInProgress const*, std::pair<Omega_h::StateInProgress const* const, int>, std::_Select1st<std::pair<Omega_h::StateInProgress const* const, int>>, Omega_h::StateCompare, std::allocator<std::pair<Omega_h::StateInProgress const* const, int>>>::~_Rb_tree() | ~_Rb_tree() _GLIBCXX_NOEXCEPT
{ _M_erase(_M_begin()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1d8340
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x1c8de0
jmp 0x297bb7
movq -0x10(%rbp), %rdi
callq 0x1c4f40
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_tree.h |
2,366 | std::allocator<std::_Rb_tree_node<std::pair<Omega_h::StateInProgress const* const, int>>>::~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 0x1d1a30
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 |
2,367 | _gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<Omega_h::StateInProgress const* const, int>>>::~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 |
2,368 | int Omega_h::size<Omega_h::ActionInProgress>(std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>> const&) | inline int size(std::vector<T> const& v) {
return int(v.size());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cd970
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 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
2,369 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::reference Omega_h::at<Omega_h::ActionInProgress>(std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>&, int) | inline typename std::vector<T>::reference at(std::vector<T>& v, int i) {
OMEGA_H_CHECK(0 <= i);
#if !(defined(__GNUC__) && __GNUC__ < 5)
OMEGA_H_CHECK(i < int(v.size()));
#endif
return v[std::size_t(i)];
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x297cb8
jmp 0x297cd9
leaq 0x3933a9(%rip), %rdi # 0x62b068
leaq 0x3954f7(%rip), %rsi # 0x62d1bd
leaq 0x3954f7(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1dea60
addq $0x10, %rsp
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_std_vector.hpp |
2,370 | bool Omega_h::intersects<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&) | bool intersects(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) {
auto it = a.find(x);
if (it != a.end()) return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x297d35
jmp 0x297d86
leaq -0x28(%rbp), %rdi
callq 0x1d6320
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1bdc00
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x297d73
jmp 0x297d79
movb $0x1, -0x1(%rbp)
jmp 0x297d8a
jmp 0x297d7b
leaq -0x28(%rbp), %rdi
callq 0x1bf270
jmp 0x297d22
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %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_set.hpp |
2,371 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x38, -0x10(%rbp), %rcx
addq %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_vector.h |
2,372 | std::set<int, std::less<int>, std::allocator<int>>::find(int const&) | iterator
find(const key_type& __x)
{ return _M_t.find(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dc7f0
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d6f00
movq -0x8(%rbp), %rax
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_set.h |
2,373 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(&this->_M_impl._M_header); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1d37d0
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_tree.h |
2,374 | std::__shared_ptr<Omega_h::Grammar const, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<Omega_h::Grammar const, (__gnu_cxx::_Lock_policy)2> const&) | __shared_ptr(const __shared_ptr&) noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1d8550
addq $0x10, %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/shared_ptr_base.h |
2,375 | std::__shared_ptr<Omega_h::Grammar const, (__gnu_cxx::_Lock_policy)2>::~__shared_ptr() | ~__shared_ptr() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ce190
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/bits/shared_ptr_base.h |
2,376 | std::operator==(std::_Bit_iterator_base const&, std::_Bit_iterator_base const&) | _GLIBCXX20_CONSTEXPR bool
operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{ return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x11(%rbp)
jne 0x298115
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
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_bvector.h |
2,377 | std::operator!=(std::_Bit_iterator_base const&, std::_Bit_iterator_base const&) | bool
operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
{ return !(__x == __y); } | 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 0x1e05d0
xorb $-0x1, %al
andb $0x1, %al
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_bvector.h |
2,378 | std::_Bit_iterator::operator++() | iterator&
operator++()
{
_M_bump_up();
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1df6e0
movq -0x10(%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_bvector.h |
2,379 | std::_Bit_iterator_base::_M_bump_up() | void
_M_bump_up()
{
if (_M_offset++ == int(_S_word_bit) - 1)
{
_M_offset = 0;
++_M_p;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x8(%rcx)
cmpl $0x3f, %eax
jne 0x298215
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
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_bvector.h |
2,380 | std::_Bit_reference::operator<(std::_Bit_reference const&) const | bool
operator<(const _Bit_reference& __x) const
{ return !bool(*this) && bool(__x); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bb190
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x298251
movq -0x10(%rbp), %rdi
callq 0x1bb190
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
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_bvector.h |
2,381 | std::_Bit_reference::_Bit_reference(unsigned long*, unsigned long) | _Bit_reference(_Bit_type * __x, _Bit_type __y)
: _M_p(__x), _M_mask(__y) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%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_bvector.h |
2,382 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree() | _Rb_tree() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2af0
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_tree.h |
2,383 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::_Rb_tree_impl<std::less<int>, true>::_Rb_tree_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Node_allocator>::value
&& is_nothrow_default_constructible<_Base_key_compare>::value )
: _Node_allocator()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1ce2d0
movq -0x10(%rbp), %rdi
callq 0x1c1470
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8bc0
addq $0x10, %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_tree.h |
2,384 | std::allocator<std::_Rb_tree_node<int>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c40f0
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 |
2,385 | std::_Rb_tree_key_compare<std::less<int>>::_Rb_tree_key_compare() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Key_compare>::value)
: _M_key_compare()
{ } | 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/bits/stl_tree.h |
2,386 | _gnu_cxx::new_allocator<std::_Rb_tree_node<int>>::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 |
2,387 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::~_Rb_tree() | ~_Rb_tree() _GLIBCXX_NOEXCEPT
{ _M_erase(_M_begin()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1d44a0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x1c75f0
jmp 0x298357
movq -0x10(%rbp), %rdi
callq 0x1e3bd0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_tree.h |
2,388 | std::set<int, std::less<int>, std::allocator<int>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return _M_t.size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dbf30
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_set.h |
2,389 | std::_Rb_tree<int, int, std::_Identity<int>, std::less<int>, std::allocator<int>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return _M_impl._M_node_count; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
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_tree.h |
2,390 | std::vector<int, std::allocator<int>>::empty() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return begin() == end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1d7aa0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1d71d0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1cc130
andb $0x1, %al
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/bits/stl_vector.h |
2,391 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::const_reference Omega_h::at<std::set<int, std::less<int>, std::allocator<int>>>(std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>> const&, int) | inline typename std::vector<T>::const_reference at(
std::vector<T> const& v, int i) {
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < int(v.size()));
return v[std::size_t(i)];
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x298448
jmp 0x298469
leaq 0x392c19(%rip), %rdi # 0x62b068
leaq 0x394d67(%rip), %rsi # 0x62d1bd
leaq 0x394d67(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bd300
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x298484
jmp 0x2984a5
leaq 0x392bdd(%rip), %rdi # 0x62b068
leaq 0x394dff(%rip), %rsi # 0x62d291
leaq 0x394d2b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1be480
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 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
2,392 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x30, %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 |
2,393 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::operator[](unsigned long) const | const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %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_vector.h |
2,394 | std::vector<int, std::allocator<int>>::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 0x1c7240
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1dec60
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d80e0
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 |
2,395 | std::set<int, std::less<int>, std::allocator<int>>::operator=(std::set<int, std::less<int>, std::allocator<int>>&&) | set&
operator=(set&&) = default; | 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), %rsi
callq 0x1c4500
movq -0x18(%rbp), %rax
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_set.h |
2,396 | void Omega_h::unite_with<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&) | void unite_with(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) a.insert(x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x2985c5
jmp 0x2985f1
leaq -0x20(%rbp), %rdi
callq 0x1d6320
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c1f90
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1bf270
jmp 0x2985b2
addq $0x40, %rsp
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_set.hpp |
2,397 | void Omega_h::resize<int>(std::vector<int, std::allocator<int>>&, int) | inline void resize(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.resize(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x298618
jmp 0x298639
leaq 0x392a49(%rip), %rdi # 0x62b068
leaq 0x395040(%rip), %rsi # 0x62d666
leaq 0x394b97(%rip), %rdx # 0x62d1c4
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c6530
addq $0x10, %rsp
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_std_vector.hpp |
2,398 | _gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>::operator-(long) const | _GLIBCXX20_CONSTEXPR
const _Iterator&
base() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c51d0
movq -0x8(%rbp), %rax
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/bits/stl_iterator.h |
2,399 | void Omega_h::reserve<int>(std::vector<int, std::allocator<int>>&, int) | inline void reserve(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.reserve(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x2986a8
jmp 0x2986c9
leaq 0x3929b9(%rip), %rdi # 0x62b068
leaq 0x394fb0(%rip), %rsi # 0x62d666
leaq 0x394b07(%rip), %rdx # 0x62d1c4
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1d52a0
addq $0x10, %rsp
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_std_vector.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.