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
|
|---|---|---|---|---|---|---|
1,900 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::_S_max_size(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
const size_t __diffmax = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max;
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 $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d700
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_deque.h |
1,901 | std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::max_size(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event> 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 0x28d720
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 |
1,902 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::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 0x28d2a0
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 |
1,903 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::empty() const | _GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_finish == this->_M_impl._M_start; } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, %rdi
addq $0x30, %rdi
addq $0x10, %rsi
callq 0x28dc70
andb $0x1, %al
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_deque.h |
1,904 | std::operator==(std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*> const&, std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*> const&) | bool
operator==(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_cur == __y._M_cur; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
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 |
1,905 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::front() | reference
front() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *begin();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x28dcd0
leaq -0x28(%rbp), %rdi
callq 0x28dd00
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_deque.h |
1,906 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_start; } | 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 $0x10, %rsi
callq 0x28dd20
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 |
1,907 | std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::operator*() const | reference
operator*() const _GLIBCXX_NOEXCEPT
{ return *_M_cur; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %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_deque.h |
1,908 | std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::_Deque_iterator(std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*> const&) | _Deque_iterator(const _Deque_iterator& __x) noexcept
: _M_cur(__x._M_cur), _M_first(__x._M_first),
_M_last(__x._M_last), _M_node(__x._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)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
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/stl_deque.h |
1,909 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::pop_front() | void
pop_front() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
if (this->_M_impl._M_start._M_cur
!= this->_M_impl._M_start._M_last - 1)
{
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_start._M_cur);
++this->_M_impl._M_start._M_cur;
}
else
_M_pop_front_aux();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rcx), %rax
movq 0x20(%rcx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x28ddb0
movq -0x10(%rbp), %rdi
callq 0x28de00
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x28ddd0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
jmp 0x28ddbd
movq -0x10(%rbp), %rdi
callq 0x28de10
jmp 0x28ddbb
jmp 0x28ddbd
addq $0x10, %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 |
1,910 | void std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::destroy<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*) | 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 0x28de70
addq $0x10, %rsp
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/alloc_traits.h |
1,911 | std::_Deque_base<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::_M_get_Tp_allocator() | _Tp_alloc_type&
_M_get_Tp_allocator() _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_deque.h |
1,912 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::_M_pop_front_aux() | void deque<_Tp, _Alloc>::
_M_pop_front_aux()
{
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_start._M_cur);
_M_deallocate_node(this->_M_impl._M_start._M_first);
this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x28de00
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x28ddd0
movq -0x10(%rbp), %rdi
movq 0x18(%rdi), %rsi
callq 0x28d2c0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq 0x28(%rax), %rsi
addq $0x8, %rsi
callq 0x28cfc0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x10, %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/deque.tcc |
1,913 | void __gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::destroy<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*) | 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 |
1,914 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::~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 0x28dcd0
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x28df10
movq -0x60(%rbp), %rdi
callq 0x28de00
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
callq 0x28def0
jmp 0x28ded1
movq -0x60(%rbp), %rdi
callq 0x28df40
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 |
1,915 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::_M_destroy_data(std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>, std::_Deque_iterator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event> 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 |
1,916 | std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::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 0x28dd20
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 |
1,917 | std::_Deque_base<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::~_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 0x28df7f
movq -0x10(%rbp), %rdi
movq 0x28(%rdi), %rsi
movq 0x48(%rdi), %rdx
addq $0x8, %rdx
callq 0x28d1b0
movq -0x10(%rbp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
callq 0x28cf70
movq -0x10(%rbp), %rdi
callq 0x28cd80
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 |
1,918 | Omega_h::print_stack(std::vector<int, std::allocator<int>> const&) | static void print_stack(std::vector<int> const& stack) {
for (auto& symb : stack) {
if (symb == MARKER)
std::cerr << " M";
else if (symb == ZERO)
std::cerr << " Z";
else
std::cerr << " " << symb;
}
std::cerr << '\n';
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d7aa0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d71d0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c07d0
testb $0x1, %al
jne 0x28dfd1
jmp 0x28e050
leaq -0x18(%rbp), %rdi
callq 0x1ddbe0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xfffffe4f, (%rax) # imm = 0xFFFFFE4F
jne 0x28dfff
movq 0x469fe7(%rip), %rdi # 0x6f7fd8
leaq 0x39f668(%rip), %rsi # 0x62d660
callq 0x1cd8f0
jmp 0x28e040
movq -0x28(%rbp), %rax
cmpl $-0x64, (%rax)
jne 0x28e01d
movq 0x469fc9(%rip), %rdi # 0x6f7fd8
leaq 0x39f64d(%rip), %rsi # 0x62d663
callq 0x1cd8f0
jmp 0x28e03e
movq 0x469fb4(%rip), %rdi # 0x6f7fd8
leaq 0x3a495b(%rip), %rsi # 0x632986
callq 0x1cd8f0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0x1deb20
jmp 0x28e040
jmp 0x28e042
leaq -0x18(%rbp), %rdi
callq 0x1c0500
jmp 0x28dfbe
movq 0x469f81(%rip), %rdi # 0x6f7fd8
movl $0xa, %esi
callq 0x1d19c0
addq $0x30, %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_build_parser.cpp |
1,919 | Omega_h::get_follow_string(int, std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>> const&, std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>> const&, std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, std::shared_ptr<Omega_h::Grammar const>) | static std::vector<int> get_follow_string(int sc_addr, StateConfigs const& scs,
StatesInProgress const& states, Configs const& cs, GrammarPtr grammar) {
auto& sc = at(scs, sc_addr);
auto& state = *at(states, sc.state);
auto config_i = at(state.configs, sc.config_in_state);
auto& config = at(cs, config_i);
auto& prod = at(grammar->productions, config.production);
auto out_size = size(prod.rhs) - (config.dot + 1);
std::vector<int> out;
/* out_size can be negative */
if (out_size < 1) return out;
reserve(out, out_size);
for (auto i = config.dot + 1; i < size(prod.rhs); ++i) {
out.push_back(at(prod.rhs, i));
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %r9, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1bb8c0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %esi
callq 0x1ba110
movq %rax, %rdi
callq 0x1d1e50
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1dc3d0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1d0b70
movq -0x88(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x1cb3f0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cf2d0
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, -0x5c(%rbp)
movb $0x0, -0x5d(%rbp)
callq 0x1d91a0
cmpl $0x1, -0x5c(%rbp)
jge 0x28e158
movb $0x1, -0x5d(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x28e1fb
movq -0x80(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x1c1480
jmp 0x28e166
movq -0x50(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cf2d0
movl %eax, -0x94(%rbp)
jmp 0x28e191
movl -0x98(%rbp), %eax
movl -0x94(%rbp), %ecx
cmpl %ecx, %eax
jge 0x28e1f0
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movl -0x78(%rbp), %esi
callq 0x1c57d0
movq %rax, -0xa0(%rbp)
jmp 0x28e1ba
movq -0xa0(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x1ba3d0
jmp 0x28e1cc
jmp 0x28e1ce
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x28e173
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x1c8350
jmp 0x28e21a
movb $0x1, -0x5d(%rbp)
movl $0x1, -0x64(%rbp)
testb $0x1, -0x5d(%rbp)
jne 0x28e20a
movq -0x80(%rbp), %rdi
callq 0x1c8350
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%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_build_parser.cpp |
1,920 | Omega_h::print_string(std::vector<int, std::allocator<int>> const&, std::shared_ptr<Omega_h::Grammar const>) | static void print_string(std::vector<int> const& str, GrammarPtr grammar) {
std::cerr << "\"";
for (auto symb : str) {
auto& symb_name = at(grammar->symbol_names, symb);
std::cerr << symb_name;
}
std::cerr << "\"";
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x469d8d(%rip), %rdi # 0x6f7fd8
leaq 0x3a7f02(%rip), %rsi # 0x636154
callq 0x1cd8f0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d7aa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d71d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c07d0
testb $0x1, %al
jne 0x28e28c
jmp 0x28e2d1
leaq -0x20(%rbp), %rdi
callq 0x1ddbe0
movq -0x40(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x1d7fc0
movq %rax, %rdi
addq $0x20, %rdi
movl -0x2c(%rbp), %esi
callq 0x1c2b20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq 0x469d17(%rip), %rdi # 0x6f7fd8
callq 0x1cb420
leaq -0x20(%rbp), %rdi
callq 0x1c0500
jmp 0x28e279
movq 0x469d00(%rip), %rdi # 0x6f7fd8
leaq 0x3a7e75(%rip), %rsi # 0x636154
callq 0x1cd8f0
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_build_parser.cpp |
1,921 | Omega_h::print_set(std::set<int, std::less<int>, std::allocator<int>> const&, Omega_h::Grammar const&) | static void print_set(std::set<int> const& set, Grammar const& grammar) {
std::cerr << "{";
for (auto it = set.begin(); it != set.end(); ++it) {
if (it != set.begin()) std::cerr << ", ";
auto symb = *it;
if (symb == FIRST_NULL)
std::cerr << "null";
else {
auto& symb_name = at(grammar.symbol_names, symb);
if (symb_name == ",")
std::cerr << "','";
else
std::cerr << symb_name;
}
}
std::cerr << "}";
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x469cd1(%rip), %rdi # 0x6f7fd8
leaq 0x39ef7c(%rip), %rsi # 0x62d28a
callq 0x1cd8f0
movq -0x8(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cdb90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x28e343
jmp 0x28e403
movq -0x8(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x28e363
jmp 0x28e376
movq 0x469c6e(%rip), %rdi # 0x6f7fd8
leaq 0x3a3d4f(%rip), %rsi # 0x6320c0
callq 0x1cd8f0
leaq -0x18(%rbp), %rdi
callq 0x1d6320
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0xfffffe57, -0x2c(%rbp) # imm = 0xFFFFFE57
jne 0x28e3a2
movq 0x469c44(%rip), %rdi # 0x6f7fd8
leaq 0x39eef1(%rip), %rsi # 0x62d28c
callq 0x1cd8f0
jmp 0x28e3f3
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x2c(%rbp), %esi
callq 0x1c2b20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x39f2bc(%rip), %rsi # 0x62d67d
callq 0x1e4c20
testb $0x1, %al
jne 0x28e3cc
jmp 0x28e3e1
movq 0x469c05(%rip), %rdi # 0x6f7fd8
leaq 0x39f2a5(%rip), %rsi # 0x62d67f
callq 0x1cd8f0
jmp 0x28e3f1
movq -0x38(%rbp), %rsi
movq 0x469bec(%rip), %rdi # 0x6f7fd8
callq 0x1cb420
jmp 0x28e3f3
jmp 0x28e3f5
leaq -0x18(%rbp), %rdi
callq 0x1bf270
jmp 0x28e320
movq 0x469bce(%rip), %rdi # 0x6f7fd8
leaq 0x39ebe4(%rip), %rsi # 0x62cff5
callq 0x1cd8f0
addq $0x40, %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_build_parser.cpp |
1,922 | Omega_h::has_non_null_terminal_descendant(std::set<int, std::less<int>, std::allocator<int>> const&) | static bool has_non_null_terminal_descendant(FirstSet const& first_set) {
if (first_set.empty()) return false;
if (first_set.size() > 1) return true;
return *(first_set.begin()) != FIRST_NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b8550
testb $0x1, %al
jne 0x28e43b
jmp 0x28e441
movb $0x0, -0x1(%rbp)
jmp 0x28e47a
movq -0x10(%rbp), %rdi
callq 0x1cbe20
cmpq $0x1, %rax
jbe 0x28e456
movb $0x1, -0x1(%rbp)
jmp 0x28e47a
movq -0x10(%rbp), %rdi
callq 0x1c18a0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d6320
cmpl $0xfffffe57, (%rax) # imm = 0xFFFFFE57
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%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_build_parser.cpp |
1,923 | Omega_h::get_contexts(std::set<int, std::less<int>, std::allocator<int>>) | static Context get_contexts(FirstSet first_set) {
auto it = first_set.find(FIRST_NULL);
if (it != first_set.end()) first_set.erase(it);
return first_set;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0xfffffe57, -0x1c(%rbp) # imm = 0xFFFFFE57
leaq -0x1c(%rbp), %rsi
callq 0x1bdc00
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1cdb90
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d3840
testb $0x1, %al
jne 0x28e4ea
jmp 0x28e503
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x1c3c60
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x1b9e20
movq -0x48(%rbp), %rax
addq $0x50, %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_build_parser.cpp |
1,924 | Omega_h::context_adding_routine(std::vector<int, std::allocator<int>> const&, int, 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>>>>&, bool, std::shared_ptr<Omega_h::Grammar const>) | static void context_adding_routine(std::vector<int> const& lane,
int zeta_pointer, Context& contexts_generated, Contexts& contexts,
bool verbose, GrammarPtr grammar) {
if (verbose) {
std::cerr << " CONTEXT ADDING ROUTINE\n";
std::cerr << " LANE:";
print_stack(lane);
std::cerr << " $\\zeta$-POINTER = " << zeta_pointer << '\n';
}
for (int r = zeta_pointer; r >= 0 && (!contexts_generated.empty()); --r) {
auto v_r = at(lane, r);
if (verbose) std::cerr << " r = " << r << ", $v_r$ = ";
if (v_r < 0) {
if (verbose) {
if (v_r == MARKER)
std::cerr << "marker\n";
else if (v_r == ZERO)
std::cerr << "zero\n";
}
continue;
}
auto tau_r_addr = v_r;
if (verbose) {
std::cerr << "$\\tau_r$ = " << tau_r_addr << '\n';
std::cerr << " CONTEXTS_GENERATED = ";
print_set(contexts_generated, *grammar);
std::cerr << "\n CONTEXTS_$\\tau_r$ = ";
print_set(at(contexts, tau_r_addr), *grammar);
std::cerr << "\n CONTEXTS_GENERATED <- CONTEXTS_GENERATED - "
"CONTEXTS_$\\tau_r$";
}
subtract_from(contexts_generated, at(contexts, tau_r_addr));
if (verbose) {
std::cerr << "\n CONTEXTS_GENERATED = ";
print_set(contexts_generated, *grammar);
std::cerr << "\n CONTEXTS_$\\tau_r$ <- CONTEXTS_$\\tau_r$ U "
"CONTEXTS_GENERATED";
}
unite_with(at(contexts, tau_r_addr), contexts_generated);
if (verbose) {
std::cerr << "\n CONTEXTS_$\\tau_r$ = ";
print_set(at(contexts, tau_r_addr), *grammar);
std::cerr << "\n";
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %r9, -0x48(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
je 0x28e5aa
movq 0x469a81(%rip), %rdi # 0x6f7fd8
leaq 0x39f125(%rip), %rsi # 0x62d683
callq 0x1cd8f0
movq 0x469a6e(%rip), %rdi # 0x6f7fd8
leaq 0x39efcf(%rip), %rsi # 0x62d540
callq 0x1cd8f0
movq -0x8(%rbp), %rdi
callq 0x28df90
movq 0x469a52(%rip), %rdi # 0x6f7fd8
leaq 0x39f110(%rip), %rsi # 0x62d69d
callq 0x1cd8f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x34(%rbp)
movb %al, -0x49(%rbp)
jl 0x28e5c9
movq -0x18(%rbp), %rdi
callq 0x1b8550
xorb $-0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x28e5d5
jmp 0x28e7fd
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x1c57d0
movl (%rax), %eax
movl %eax, -0x38(%rbp)
testb $0x1, -0x21(%rbp)
je 0x28e619
movq 0x4699e5(%rip), %rdi # 0x6f7fd8
leaq 0x39f0b8(%rip), %rsi # 0x62d6b2
callq 0x1cd8f0
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39f0a7(%rip), %rsi # 0x62d6bb
callq 0x1cd8f0
cmpl $0x0, -0x38(%rbp)
jge 0x28e665
testb $0x1, -0x21(%rbp)
je 0x28e660
cmpl $0xfffffe4f, -0x38(%rbp) # imm = 0xFFFFFE4F
jne 0x28e643
movq 0x4699a3(%rip), %rdi # 0x6f7fd8
leaq 0x39eec9(%rip), %rsi # 0x62d505
callq 0x1cd8f0
jmp 0x28e65e
cmpl $-0x64, -0x38(%rbp)
jne 0x28e65c
movq 0x469988(%rip), %rdi # 0x6f7fd8
leaq 0x39efa9(%rip), %rsi # 0x62d600
callq 0x1cd8f0
jmp 0x28e65e
jmp 0x28e660
jmp 0x28e7ef
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
testb $0x1, -0x21(%rbp)
je 0x28e71b
movq 0x46995c(%rip), %rdi # 0x6f7fd8
leaq 0x39f051(%rip), %rsi # 0x62d6d4
callq 0x1cd8f0
movq %rax, %rdi
movl -0x3c(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
movq 0x469931(%rip), %rdi # 0x6f7fd8
leaq 0x39f075(%rip), %rsi # 0x62d723
callq 0x1cd8f0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1d2950
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x28e2f0
movq 0x469901(%rip), %rdi # 0x6f7fd8
leaq 0x39efe8(%rip), %rsi # 0x62d6c6
callq 0x1cd8f0
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x1c4a20
movq -0x48(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1d2950
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x28e2f0
movq 0x4698c9(%rip), %rdi # 0x6f7fd8
leaq 0x39efca(%rip), %rsi # 0x62d6e0
callq 0x1cd8f0
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x1c4a20
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x1bb0b0
testb $0x1, -0x21(%rbp)
je 0x28e784
movq 0x469890(%rip), %rdi # 0x6f7fd8
leaq 0x39efd3(%rip), %rsi # 0x62d722
callq 0x1cd8f0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x1d2950
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x28e2f0
movq 0x469860(%rip), %rdi # 0x6f7fd8
leaq 0x39efbe(%rip), %rsi # 0x62d73d
callq 0x1cd8f0
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x1c4a20
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1e4da0
testb $0x1, -0x21(%rbp)
je 0x28e7ed
movq 0x46982f(%rip), %rdi # 0x6f7fd8
leaq 0x39ef16(%rip), %rsi # 0x62d6c6
callq 0x1cd8f0
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x1c4a20
movq -0x48(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x1d2950
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x28e2f0
movq 0x4697f7(%rip), %rdi # 0x6f7fd8
leaq 0x3a2b96(%rip), %rsi # 0x63137e
callq 0x1cd8f0
jmp 0x28e7ef
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x28e5b0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%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_build_parser.cpp |
1,925 | Omega_h::deal_with_tests_failed(int&, int&, int, bool&, std::vector<int, std::allocator<int>>&, std::vector<bool, std::allocator<bool>>&, int, std::vector<int, std::allocator<int>>&, bool) | static void deal_with_tests_failed(int& num_originators_failed,
int& first_originator_failed, int zeta_prime_addr, bool& tests_failed,
std::vector<int>& lane, std::vector<bool>& in_lane, int zeta_addr,
std::vector<int>& stack, bool verbose) {
if (verbose) std::cerr << " Dealing with test failures\n";
if (num_originators_failed == 0) {
if (verbose)
std::cerr << " " << zeta_prime_addr << " is the first originator of "
<< zeta_addr << " to fail the tests\n";
first_originator_failed = zeta_prime_addr;
if (verbose)
std::cerr << " pushing " << zeta_prime_addr << " onto LANE:\n ";
lane.push_back(zeta_prime_addr);
if (verbose) print_stack(lane);
at(in_lane, zeta_prime_addr) = true;
if (verbose) std::cerr << " IN_LANE(" << zeta_prime_addr << ") <- ON\n";
tests_failed = true;
if (verbose) std::cerr << " TESTS_FAILED <- ON\n";
} else if (num_originators_failed == 1) {
if (verbose)
std::cerr << " " << zeta_prime_addr << " is the second originator of "
<< zeta_addr << " to fail the tests\n";
auto zeta_double_prime_addr = first_originator_failed;
if (verbose)
std::cerr << " the first was " << zeta_double_prime_addr << '\n';
OMEGA_H_CHECK(at(lane, size(lane) - 1) == zeta_double_prime_addr);
OMEGA_H_CHECK(at(lane, size(lane) - 2) == zeta_addr);
if (verbose)
std::cerr << " pop LANE, push {marker, " << zeta_double_prime_addr
<< "} onto it:\n ";
lane.resize(lane.size() - 1);
lane.push_back(MARKER);
lane.push_back(zeta_double_prime_addr);
if (verbose) print_stack(lane);
if (verbose)
std::cerr << " push {marker, " << zeta_prime_addr
<< "} onto STACK:\n ";
stack.push_back(MARKER);
stack.push_back(zeta_prime_addr);
if (verbose) print_stack(stack);
} else {
if (verbose)
std::cerr << " " << zeta_prime_addr
<< " is the third or later originator of " << zeta_addr
<< " to fail the tests\n";
if (verbose)
std::cerr << " pushing " << zeta_prime_addr << " onto STACK:\n ";
stack.push_back(zeta_prime_addr);
if (verbose) print_stack(stack);
}
++num_originators_failed;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb 0x20(%rbp), %al
movq 0x18(%rbp), %r10
movl 0x10(%rbp), %r10d
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $0x1, %al
movb %al, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
je 0x28e858
movq 0x46978c(%rip), %rdi # 0x6f7fd8
leaq 0x39ef2b(%rip), %rsi # 0x62d77e
callq 0x1cd8f0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x28e984
testb $0x1, -0x31(%rbp)
je 0x28e8b2
movq 0x469766(%rip), %rdi # 0x6f7fd8
leaq 0x39ef6d(%rip), %rsi # 0x62d7e6
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ef09(%rip), %rsi # 0x62d79c
callq 0x1cd8f0
movq %rax, %rdi
movl 0x10(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ef0c(%rip), %rsi # 0x62d7b9
callq 0x1cd8f0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
testb $0x1, -0x31(%rbp)
je 0x28e8ee
movq 0x469710(%rip), %rdi # 0x6f7fd8
leaq 0x39eefe(%rip), %rsi # 0x62d7cd
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39eef1(%rip), %rsi # 0x62d7da
callq 0x1cd8f0
movq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1ba3d0
testb $0x1, -0x31(%rbp)
je 0x28e90a
movq -0x28(%rbp), %rdi
callq 0x28df90
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1bb780
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x1c3490
testb $0x1, -0x31(%rbp)
je 0x28e95f
movq 0x46969f(%rip), %rdi # 0x6f7fd8
leaq 0x39ec97(%rip), %rsi # 0x62d5d7
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ec8a(%rip), %rsi # 0x62d5e4
callq 0x1cd8f0
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
testb $0x1, -0x31(%rbp)
je 0x28e97f
movq 0x469665(%rip), %rdi # 0x6f7fd8
leaq 0x39ee71(%rip), %rsi # 0x62d7eb
callq 0x1cd8f0
jmp 0x28ec36
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x28eb96
testb $0x1, -0x31(%rbp)
je 0x28e9de
movq 0x46963a(%rip), %rdi # 0x6f7fd8
leaq 0x39ee41(%rip), %rsi # 0x62d7e6
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ee44(%rip), %rsi # 0x62d803
callq 0x1cd8f0
movq %rax, %rdi
movl 0x10(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ede0(%rip), %rsi # 0x62d7b9
callq 0x1cd8f0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
testb $0x1, -0x31(%rbp)
je 0x28ea18
movq 0x4695e4(%rip), %rdi # 0x6f7fd8
leaq 0x39ee26(%rip), %rsi # 0x62d821
callq 0x1cd8f0
movq %rax, %rdi
movl -0x4c(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
movl $0xa, %esi
callq 0x1d19c0
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1cf2d0
movq -0x60(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1dc3d0
movl (%rax), %eax
cmpl -0x4c(%rbp), %eax
jne 0x28ea40
jmp 0x28ea61
leaq 0x39c621(%rip), %rdi # 0x62b068
leaq 0x39ede6(%rip), %rsi # 0x62d834
leaq 0x39e4c4(%rip), %rdx # 0x62cf19
movl $0x2c6, %ecx # imm = 0x2C6
movb $0x0, %al
callq 0x1ce550
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1cf2d0
movq -0x68(%rbp), %rdi
movl %eax, %esi
subl $0x2, %esi
callq 0x1dc3d0
movl (%rax), %eax
cmpl 0x10(%rbp), %eax
jne 0x28ea89
jmp 0x28eaaa
leaq 0x39c5d8(%rip), %rdi # 0x62b068
leaq 0x39edd0(%rip), %rsi # 0x62d867
leaq 0x39e47b(%rip), %rdx # 0x62cf19
movl $0x2c7, %ecx # imm = 0x2C7
movb $0x0, %al
callq 0x1ce550
testb $0x1, -0x31(%rbp)
je 0x28eadd
movq 0x469521(%rip), %rdi # 0x6f7fd8
leaq 0x39edcf(%rip), %rsi # 0x62d88d
callq 0x1cd8f0
movq %rax, %rdi
movl -0x4c(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39edd2(%rip), %rsi # 0x62d8aa
callq 0x1cd8f0
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1e4bf0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x1c6530
movq -0x28(%rbp), %rdi
movl $0xfffffe4f, -0x50(%rbp) # imm = 0xFFFFFE4F
leaq -0x50(%rbp), %rsi
callq 0x1bd4c0
movq -0x28(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x1ba3d0
testb $0x1, -0x31(%rbp)
je 0x28eb2e
movq -0x28(%rbp), %rdi
callq 0x28df90
testb $0x1, -0x31(%rbp)
je 0x28eb61
movq 0x46949d(%rip), %rdi # 0x6f7fd8
leaq 0x39ed78(%rip), %rsi # 0x62d8ba
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ed71(%rip), %rsi # 0x62d8cd
callq 0x1cd8f0
movq 0x18(%rbp), %rdi
movl $0xfffffe4f, -0x54(%rbp) # imm = 0xFFFFFE4F
leaq -0x54(%rbp), %rsi
callq 0x1bd4c0
movq 0x18(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1ba3d0
testb $0x1, -0x31(%rbp)
je 0x28eb91
movq 0x18(%rbp), %rdi
callq 0x28df90
jmp 0x28ec34
testb $0x1, -0x31(%rbp)
je 0x28ebe3
movq 0x469435(%rip), %rdi # 0x6f7fd8
leaq 0x39ec3c(%rip), %rsi # 0x62d7e6
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ed1c(%rip), %rsi # 0x62d8e0
callq 0x1cd8f0
movq %rax, %rdi
movl 0x10(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ebdb(%rip), %rsi # 0x62d7b9
callq 0x1cd8f0
testb $0x1, -0x31(%rbp)
je 0x28ec16
movq 0x4693e8(%rip), %rdi # 0x6f7fd8
leaq 0x39ebd6(%rip), %rsi # 0x62d7cd
callq 0x1cd8f0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x39ecbd(%rip), %rsi # 0x62d8ce
callq 0x1cd8f0
movq 0x18(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1ba3d0
testb $0x1, -0x31(%rbp)
je 0x28ec32
movq 0x18(%rbp), %rdi
callq 0x28df90
jmp 0x28ec34
jmp 0x28ec36
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x70, %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_build_parser.cpp |
1,926 | Omega_h::move_markers(std::vector<int, std::allocator<int>>&, int, int, bool) | static void move_markers(std::vector<int>& lane, int zeta_prime_addr,
int zeta_pointer, bool tests_failed) {
/* TODO: change in_lane to contain the index of that config in the lane,
not just a boolean. this would save us the search here: */
auto it = std::find_if(lane.begin(), lane.end(),
[=](int item) { return item == zeta_prime_addr; });
OMEGA_H_CHECK(it != lane.end());
auto loc_of_zeta_prime = int(it - lane.begin());
int r = 0;
for (int i = loc_of_zeta_prime + 1; i < zeta_pointer; ++i) {
if (at(lane, i) == MARKER) {
++r;
at(lane, i) = ZERO;
}
}
int top_addr = -1;
if (tests_failed) {
top_addr = lane.back();
lane.resize(lane.size() - 1); // pop
}
for (int i = 0; i < r; ++i) lane.push_back(MARKER);
if (tests_failed) lane.push_back(top_addr);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bfd80
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7240
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x28efb0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7240
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1de3b0
testb $0x1, %al
jne 0x28ecbd
jmp 0x28ecbf
jmp 0x28ece0
leaq 0x39c3a2(%rip), %rdi # 0x62b068
leaq 0x39ec53(%rip), %rsi # 0x62d920
leaq 0x39e245(%rip), %rdx # 0x62cf19
movl $0x26a, %ecx # imm = 0x26A
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1bfd80
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1bf400
movl %eax, -0x44(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x28ed51
movq -0x8(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x1dc3d0
cmpl $0xfffffe4f, (%rax) # imm = 0xFFFFFE4F
jne 0x28ed44
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rdi
movl -0x58(%rbp), %esi
callq 0x1dc3d0
movl $0xffffff9c, (%rax) # imm = 0xFFFFFF9C
jmp 0x28ed46
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x28ed0d
movl $0xffffffff, -0x5c(%rbp) # imm = 0xFFFFFFFF
testb $0x1, -0x11(%rbp)
je 0x28ed8d
movq -0x8(%rbp), %rdi
callq 0x1ddda0
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e4bf0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x1c6530
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x54(%rbp), %eax
jge 0x28edbb
movq -0x8(%rbp), %rdi
movl $0xfffffe4f, -0x64(%rbp) # imm = 0xFFFFFE4F
leaq -0x64(%rbp), %rsi
callq 0x1bd4c0
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x28ed94
testb $0x1, -0x11(%rbp)
je 0x28edce
movq -0x8(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x1ba3d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%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_build_parser.cpp |
1,927 | Omega_h::heuristic_propagation_of_context_sets(int, std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>&, std::vector<bool, std::allocator<bool>>&, std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>> const&, std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>> const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, std::shared_ptr<Omega_h::Grammar const>) | static void heuristic_propagation_of_context_sets(int tau_addr,
Contexts& contexts, std::vector<bool>& complete, StateConfigs const& scs,
StatesInProgress const& states, ParserGraph const& states2scs,
Configs const& cs, GrammarPtr grammar) {
auto& tau = at(scs, tau_addr);
auto& state = *at(states, tau.state);
auto config_i = at(state.configs, tau.config_in_state);
auto& config = at(cs, config_i);
if (config.dot != 0) return;
auto& prod = at(grammar->productions, config.production);
for (int cis_j = 0; cis_j < size(state.configs); ++cis_j) {
auto config_j = at(state.configs, cis_j);
if (config_j == config_i) continue;
auto& config2 = at(cs, config_j);
if (config2.dot != 0) continue;
auto& prod2 = at(grammar->productions, config2.production);
if (prod.lhs != prod2.lhs) continue;
auto tau_prime_addr = at(states2scs, tau.state, cis_j);
at(contexts, tau_prime_addr) = at(contexts, tau_addr);
at(complete, tau_prime_addr) = true;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1bb8c0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %esi
callq 0x1ba110
movq %rax, %rdi
callq 0x1d1e50
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1dc3d0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq 0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x1d0b70
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x28ee70
jmp 0x28efa3
movq -0x90(%rbp), %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rax
movl (%rax), %esi
callq 0x1cb3f0
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1cf2d0
movl %eax, %ecx
movl -0x94(%rbp), %eax
cmpl %ecx, %eax
jge 0x28efa3
movq -0x40(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x1dc3d0
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x44(%rbp), %eax
jne 0x28eed9
jmp 0x28ef95
movq 0x10(%rbp), %rdi
movl -0x60(%rbp), %esi
callq 0x1d0b70
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x28eef8
jmp 0x28ef95
movq -0x90(%rbp), %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
movq -0x68(%rbp), %rax
movl (%rax), %esi
callq 0x1cb3f0
movq %rax, -0x70(%rbp)
movq -0x58(%rbp), %rax
movl (%rax), %eax
movq -0x70(%rbp), %rcx
cmpl (%rcx), %eax
je 0x28ef2a
jmp 0x28ef95
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %esi
movl -0x5c(%rbp), %edx
callq 0x1dc260
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x1c4a20
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x1c4a20
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x1dc700
movq -0x18(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x1bb780
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
leaq -0x88(%rbp), %rdi
movl $0x1, %esi
callq 0x1c3490
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x28ee99
addq $0xa0, %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_build_parser.cpp |
1,928 | _gnu_cxx::__ops::_Iter_pred<Omega_h::move_markers(std::vector<int, std::allocator<int>>&, int, int, bool)::$_0>::_Iter_pred(Omega_h::move_markers(std::vector<int, std::allocator<int>>&, int, int, bool)::$_0) | _Iter_pred(_Predicate __pred)
: _M_pred(_GLIBCXX_MOVE(__pred))
{ } | pushq %rbp
movq %rsp, %rbp
movl %esi, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movl %ecx, (%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/predefined_ops.h |
1,929 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cef10
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 |
1,930 | int Omega_h::size<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>(std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>> 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 0x1c17c0
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 |
1,931 | std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::const_reference Omega_h::at<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>(std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>> 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 0x28f348
jmp 0x28f369
leaq 0x39bd19(%rip), %rdi # 0x62b068
leaq 0x39de67(%rip), %rsi # 0x62d1bd
leaq 0x39de67(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c17c0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f384
jmp 0x28f3a5
leaq 0x39bcdd(%rip), %rdi # 0x62b068
leaq 0x39deff(%rip), %rsi # 0x62d291
leaq 0x39de2b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c11a0
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 |
1,932 | std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>::operator*() const | typename add_lvalue_reference<element_type>::type
operator*() const
{
__glibcxx_assert(get() != pointer());
return *get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x28f3d6
movq -0x10(%rbp), %rdi
callq 0x1e2790
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/unique_ptr.h |
1,933 | int Omega_h::size<int>(std::vector<int, std::allocator<int>> 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 0x1e4bf0
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 |
1,934 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::push_back(Omega_h::StateConfig&&) | 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 0x1c97c0
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 |
1,935 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::~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 0x1e3700
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1c6460
jmp 0x28f47a
movq -0x20(%rbp), %rdi
callq 0x1cbe60
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 |
1,936 | int Omega_h::size<Omega_h::StateConfig>(std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>> 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 0x1c7bc0
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 |
1,937 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::const_reference Omega_h::at<Omega_h::StateConfig>(std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>> 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 0x28f4d8
jmp 0x28f4f9
leaq 0x39bb89(%rip), %rdi # 0x62b068
leaq 0x39dcd7(%rip), %rsi # 0x62d1bd
leaq 0x39dcd7(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7bc0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f514
jmp 0x28f535
leaq 0x39bb4d(%rip), %rdi # 0x62b068
leaq 0x39dd6f(%rip), %rsi # 0x62d291
leaq 0x39dc9b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1e01e0
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 |
1,938 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::reference Omega_h::at<std::vector<int, std::allocator<int>>>(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, 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 0x28f568
jmp 0x28f589
leaq 0x39baf9(%rip), %rdi # 0x62b068
leaq 0x39dc47(%rip), %rsi # 0x62d1bd
leaq 0x39dc47(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1db220
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 |
1,939 | std::vector<int, std::allocator<int>>::push_back(int 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 0x28f5e5
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1ba7a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rax)
jmp 0x28f603
movq -0x20(%rbp), %rdi
callq 0x1c7240
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1beff0
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 |
1,940 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::~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 0x1e01a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1befa0
jmp 0x28f64a
movq -0x20(%rbp), %rdi
callq 0x1d1fe0
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 |
1,941 | std::vector<int, std::allocator<int>>::reference Omega_h::at<int>(std::vector<int, std::allocator<int>>&, 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 0x28f688
jmp 0x28f6a9
leaq 0x39b9d9(%rip), %rdi # 0x62b068
leaq 0x39db27(%rip), %rsi # 0x62d1bd
leaq 0x39db27(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c08e0
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 |
1,942 | std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>::const_reference Omega_h::at<Omega_h::Config>(std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> 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 0x28f6d8
jmp 0x28f6f9
leaq 0x39b989(%rip), %rdi # 0x62b068
leaq 0x39dad7(%rip), %rsi # 0x62d1bd
leaq 0x39dad7(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c90f0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f714
jmp 0x28f735
leaq 0x39b94d(%rip), %rdi # 0x62b068
leaq 0x39db6f(%rip), %rsi # 0x62d291
leaq 0x39da9b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1b9800
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 |
1,943 | std::vector<Omega_h::Grammar::Production, std::allocator<Omega_h::Grammar::Production>>::const_reference Omega_h::at<Omega_h::Grammar::Production>(std::vector<Omega_h::Grammar::Production, std::allocator<Omega_h::Grammar::Production>> 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 0x28f768
jmp 0x28f789
leaq 0x39b8f9(%rip), %rdi # 0x62b068
leaq 0x39da47(%rip), %rsi # 0x62d1bd
leaq 0x39da47(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c6cd0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f7a4
jmp 0x28f7c5
leaq 0x39b8bd(%rip), %rdi # 0x62b068
leaq 0x39dadf(%rip), %rsi # 0x62d291
leaq 0x39da0b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c86f0
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 |
1,944 | std::__shared_ptr_access<Omega_h::Grammar const, (__gnu_cxx::_Lock_policy)2, false, false>::operator->() const | element_type*
operator->() const noexcept
{
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1baa00
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/shared_ptr_base.h |
1,945 | std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::const_reference Omega_h::at<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> 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 0x28f818
jmp 0x28f839
leaq 0x39b849(%rip), %rdi # 0x62b068
leaq 0x39d997(%rip), %rsi # 0x62d1bd
leaq 0x39d997(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e1010
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f854
jmp 0x28f875
leaq 0x39b80d(%rip), %rdi # 0x62b068
leaq 0x39da2f(%rip), %rsi # 0x62d291
leaq 0x39d95b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1d20d0
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 |
1,946 | std::vector<int, std::allocator<int>>::const_reference Omega_h::at<int>(std::vector<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 0x28f8a8
jmp 0x28f8c9
leaq 0x39b7b9(%rip), %rdi # 0x62b068
leaq 0x39d907(%rip), %rsi # 0x62d1bd
leaq 0x39d907(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e4bf0
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x28f8e4
jmp 0x28f905
leaq 0x39b77d(%rip), %rdi # 0x62b068
leaq 0x39d99f(%rip), %rsi # 0x62d291
leaq 0x39d8cb(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1d53c0
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 |
1,947 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::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 0x1ba380
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 |
1,948 | std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>::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 0x1ba380
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 |
1,949 | _gnu_cxx::__normal_iterator<Omega_h::ActionInProgress*, std::vector<Omega_h::ActionInProgress, std::allocator<Omega_h::ActionInProgress>>>::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 |
1,950 | std::set<int, std::less<int>, std::allocator<int>>::begin() const | iterator
begin() const _GLIBCXX_NOEXCEPT
{ return _M_t.begin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1deeb0
movq %rax, -0x8(%rbp)
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_set.h |
1,951 | std::operator!=(std::_Rb_tree_const_iterator<int> const&, std::_Rb_tree_const_iterator<int> const&) | bool
operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_node != __y._M_node; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
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 |
1,952 | std::set<int, std::less<int>, std::allocator<int>>::end() const | iterator
end() const _GLIBCXX_NOEXCEPT
{ return _M_t.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d8ce0
movq %rax, -0x8(%rbp)
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_set.h |
1,953 | std::_Rb_tree_const_iterator<int>::operator*() const | reference
operator*() const _GLIBCXX_NOEXCEPT
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1bdac0
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 |
1,954 | std::_Rb_tree_const_iterator<int>::operator++() | _Self&
operator++() _GLIBCXX_NOEXCEPT
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1d1740
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,955 | std::shared_ptr<Omega_h::Grammar const>::operator=(std::shared_ptr<Omega_h::Grammar const> const&) | shared_ptr& operator=(const shared_ptr&) noexcept = 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 0x1c23b0
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/shared_ptr.h |
1,956 | std::__shared_ptr_access<Omega_h::Grammar const, (__gnu_cxx::_Lock_policy)2, false, false>::operator*() const | element_type&
operator*() const noexcept
{
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x28fb86
jmp 0x28fb88
movq -0x10(%rbp), %rdi
callq 0x1baa00
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/shared_ptr_base.h |
1,957 | std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>::operator=(std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>&&) | vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c27f0
movq -0x20(%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_vector.h |
1,958 | std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>::~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 0x1cfd60
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1e2690
jmp 0x28fc0a
movq -0x20(%rbp), %rdi
callq 0x1d1150
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 |
1,959 | std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::operator=(std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>&&) | vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1cf4a0
movq -0x20(%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_vector.h |
1,960 | std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::~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 0x1d3fa0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1c59c0
jmp 0x28fc9a
movq -0x20(%rbp), %rdi
callq 0x1b9330
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 |
1,961 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::operator=(std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>&&) | vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c82c0
movq -0x20(%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_vector.h |
1,962 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::operator=(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&&) | vector&
operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
constexpr bool __move_storage =
_Alloc_traits::_S_propagate_on_move_assign()
|| _Alloc_traits::_S_always_equal();
_M_move_assign(std::move(__x), __bool_constant<__move_storage>());
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1dc2b0
movq -0x20(%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_vector.h |
1,963 | std::shared_ptr<Omega_h::Grammar const>::shared_ptr(std::shared_ptr<Omega_h::Grammar const> 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), %rsi
callq 0x1d67e0
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 |
1,964 | std::vector<bool, std::allocator<bool>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start._M_p, 0); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0x1d2a70
jmp 0x28fdf0
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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 |
1,965 | std::vector<bool, std::allocator<bool>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return this->_M_impl._M_finish; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movups 0x10(%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
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 |
1,966 | std::_Bit_iterator::operator*() const | reference
operator*() const
{ return reference(_M_p, 1UL << _M_offset); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movb 0x8(%rax), %cl
movl $0x1, %edx
shlq %cl, %rdx
leaq -0x10(%rbp), %rdi
callq 0x1cb2c0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
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_bvector.h |
1,967 | std::_Bit_reference::operator bool() const | operator bool() const _GLIBCXX_NOEXCEPT
{ return !!(*_M_p & _M_mask); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq (%rax), %rax
andq 0x8(%rcx), %rax
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
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 |
1,968 | std::vector<bool, std::allocator<bool>> Omega_h::make_vector<bool>(int, bool const&) | inline std::vector<T> make_vector(int n, T const& init_val = T()) {
return std::vector<T>(std::size_t(n), init_val);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1d5060
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1d3540
jmp 0x28fef2
leaq -0x19(%rbp), %rdi
callq 0x1e3c30
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1e3c30
movq -0x28(%rbp), %rdi
callq 0x1dfa40
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_std_vector.hpp |
1,969 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>> Omega_h::make_vector<std::set<int, std::less<int>, std::allocator<int>>>(int, std::set<int, std::less<int>, std::allocator<int>> const&) | inline std::vector<T> make_vector(int n, T const& init_val = T()) {
return std::vector<T>(std::size_t(n), init_val);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c87d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x1db800
jmp 0x28ff82
leaq -0x19(%rbp), %rdi
callq 0x1c5c80
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1c5c80
movq -0x28(%rbp), %rdi
callq 0x1dfa40
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_std_vector.hpp |
1,970 | 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 -0x8(%rbp), %rdi
callq 0x1d1d40
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 |
1,971 | 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 -0x8(%rbp), %rdi
callq 0x1cfd80
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 |
1,972 | std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::reference Omega_h::at<Omega_h::StateConfig>(std::vector<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>&, 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 0x290018
jmp 0x290039
leaq 0x39b049(%rip), %rdi # 0x62b068
leaq 0x39d197(%rip), %rsi # 0x62d1bd
leaq 0x39d197(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1d0ee0
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 |
1,973 | std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::reference Omega_h::at<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>(std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>&, 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 0x290068
jmp 0x290089
leaq 0x39aff9(%rip), %rdi # 0x62b068
leaq 0x39d147(%rip), %rsi # 0x62d1bd
leaq 0x39d147(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1e0730
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 |
1,974 | std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>::reference Omega_h::at<Omega_h::Config>(std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>&, 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 0x2900b8
jmp 0x2900d9
leaq 0x39afa9(%rip), %rdi # 0x62b068
leaq 0x39d0f7(%rip), %rsi # 0x62d1bd
leaq 0x39d0f7(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1b8e80
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 |
1,975 | std::vector<bool, std::allocator<bool>>::reference Omega_h::at<bool>(std::vector<bool, std::allocator<bool>>&, 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 $0x20, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
jg 0x290108
jmp 0x290129
leaq 0x39af59(%rip), %rdi # 0x62b068
leaq 0x39d0a7(%rip), %rsi # 0x62d1bd
leaq 0x39d0a7(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1e2380
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
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 | gahansen[P]omega_h/src/Omega_h_std_vector.hpp |
1,976 | std::_Bit_reference::operator=(bool) | _Bit_reference&
operator=(bool __x) _GLIBCXX_NOEXCEPT
{
if (__x)
*_M_p |= _M_mask;
else
*_M_p &= ~_M_mask;
return *this;
} | pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x290181
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rax), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x290196
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
xorq $-0x1, %rcx
movq (%rax), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %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_bvector.h |
1,977 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::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>>>>&, 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 0x2901b8
jmp 0x2901d9
leaq 0x39aea9(%rip), %rdi # 0x62b068
leaq 0x39cff7(%rip), %rsi # 0x62d1bd
leaq 0x39cff7(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1b9680
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 |
1,978 | std::set<int, std::less<int>, std::allocator<int>>::insert(int&&) | std::pair<iterator, bool>
insert(value_type&& __x)
{
std::pair<typename _Rep_type::iterator, bool> __p =
_M_t._M_insert_unique(std::move(__x));
return std::pair<iterator, bool>(__p.first, __p.second);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1810
movb %dl, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movb -0x38(%rbp), %al
movb %al, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d3a20
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x40, %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/stl_set.h |
1,979 | std::set<int, std::less<int>, std::allocator<int>>::operator=(std::set<int, std::less<int>, std::allocator<int>> const&) | set&
operator=(const 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 0x1d5a00
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 |
1,980 | std::vector<bool, std::allocator<bool>>::operator=(std::vector<bool, std::allocator<bool>>&&) | vector&
operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
{
if (_Bit_alloc_traits::_S_propagate_on_move_assign()
|| this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
{
this->_M_deallocate();
this->_M_move_data(std::move(__x));
std::__alloc_on_move(_M_get_Bit_allocator(),
__x._M_get_Bit_allocator());
}
else
{
if (__x.size() > capacity())
{
this->_M_deallocate();
_M_initialize(__x.size());
}
this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
begin());
__x.clear();
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1dc8b0
jmp 0x29028f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dc5f0
movq -0x18(%rbp), %rdi
callq 0x1c24a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c24a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1c8560
jmp 0x2902c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
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/stl_bvector.h |
1,981 | std::vector<bool, std::allocator<bool>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e2ad0
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_bvector.h |
1,982 | std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::~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 0x1b8f80
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1d2610
jmp 0x29033a
movq -0x20(%rbp), %rdi
callq 0x1ce6b0
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 |
1,983 | std::_Vector_base<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c87b0
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 |
1,984 | std::_Vector_base<Omega_h::StateConfig, std::allocator<Omega_h::StateConfig>>::_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 0x1d0350
movq -0x10(%rbp), %rdi
callq 0x1be2e0
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 |
1,985 | std::allocator<Omega_h::StateConfig>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d91e0
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 |
1,986 | _gnu_cxx::new_allocator<Omega_h::StateConfig>::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 |
1,987 | _gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::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 |
1,988 | std::vector<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e41c0
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 |
1,989 | std::vector<Omega_h::Config, std::allocator<Omega_h::Config>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e48f0
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 |
1,990 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ca2e0
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 |
1,991 | std::shared_ptr<Omega_h::Grammar const>::shared_ptr() | constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c8cf0
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/shared_ptr.h |
1,992 | std::_Vector_base<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b8ad0
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 |
1,993 | std::_Vector_base<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>, std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>>::_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 0x1c5f80
movq -0x10(%rbp), %rdi
callq 0x1c4bf0
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 |
1,994 | std::allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e2db0
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 |
1,995 | _gnu_cxx::new_allocator<std::unique_ptr<Omega_h::StateInProgress, std::default_delete<Omega_h::StateInProgress>>>::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 |
1,996 | std::_Vector_base<Omega_h::Config, std::allocator<Omega_h::Config>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d81b0
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 |
1,997 | std::_Vector_base<Omega_h::Config, std::allocator<Omega_h::Config>>::_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 0x1c9570
movq -0x10(%rbp), %rdi
callq 0x1d0e30
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 |
1,998 | std::allocator<Omega_h::Config>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d52b0
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 |
1,999 | _gnu_cxx::new_allocator<Omega_h::Config>::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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.