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,800 | Omega_h::build_from_elems2verts(Omega_h::Mesh*, Omega_h_Family, int, Omega_h::Read<int>, int) | void build_from_elems2verts(
Mesh* mesh, Omega_h_Family family, Int edim, LOs ev2v, LO nverts) {
auto vert_globals = Read<GO>(nverts, 0, 1);
build_from_elems2verts(
mesh, mesh->library()->self(), family, edim, ev2v, vert_globals);
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rcx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1dfbb0
movq -0xa0(%rbp), %rdx
leaq 0x3af... | 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.cpp |
1,801 | Omega_h::build_from_elems_and_coords(Omega_h::Mesh*, Omega_h_Family, int, Omega_h::Read<int>, Omega_h::Read<double>) | void build_from_elems_and_coords(
Mesh* mesh, Omega_h_Family family, Int edim, LOs ev2v, Reals coords) {
auto nverts = coords.size() / edim;
build_from_elems2verts(mesh, family, edim, ev2v, nverts);
mesh->add_coords(coords);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rcx, -0x90(%rbp)
movq %r8, -0x88(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
mov... | 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.cpp |
1,802 | Omega_h::build_box_internal(Omega_h::Mesh*, Omega_h_Family, double, double, double, int, int, int, bool) | void build_box_internal(Mesh* mesh, Omega_h_Family family, Real x, Real y,
Real z, LO nx, LO ny, LO nz, bool symmetric) {
OMEGA_H_CHECK(nx > 0);
OMEGA_H_CHECK(ny >= 0);
OMEGA_H_CHECK(nz >= 0);
if (ny == 0) {
LOs ev2v;
Reals coords;
make_1d_box(x, nx, &ev2v, &coords);
build_from_elems_and_coo... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movb %r9b, %al
movq %rdi, -0x98(%rbp)
movl %esi, -0x9c(%rbp)
movsd %xmm0, -0xa8(%rbp)
movsd %xmm1, -0xb0(%rbp)
movsd %xmm2, -0xb8(%rbp)
movl %edx, -0xbc(%rbp)
movl %ecx, -0xc0(%rbp)
movl %r8d, -0xc4(%rbp)
andb $0x1, %al
movb %al, -0xc5(%rbp)
cmpl $0x... | 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.cpp |
1,803 | Omega_h::build_box(std::shared_ptr<Omega_h::Comm>, Omega_h_Family, double, double, double, int, int, int, bool) | Mesh build_box(CommPtr comm, Omega_h_Family family, Real x, Real y, Real z,
LO nx, LO ny, LO nz, bool symmetric) {
auto lib = comm->library();
auto mesh = Mesh(lib);
if (comm->rank() == 0) {
build_box_internal(&mesh, family, x, y, z, nx, ny, nz, symmetric);
reorder_by_hilbert(&mesh);
classify_box(... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rsi
movq -0xa0(%rbp), %rdi
movq %rsi, -0xa8(%rbp)
movq %rsi, %rax
movq %rax, -0xb0(%rbp)
movb 0x10(%rbp), %al
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, ... | 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.cpp |
1,804 | Omega_h::sort_locally_based_on_rank(Omega_h::Read<int>, Omega_h::Read<int>) | LOs sort_locally_based_on_rank(
LOs servers_to_served, Read<I32> served_to_rank) {
OMEGA_H_TIME_FUNCTION;
auto const served_order = Write<LO>(served_to_rank.size());
auto functor = OMEGA_H_LAMBDA(LO const server) {
auto const begin = servers_to_served[server];
auto const end = servers_to_served[server... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x198(%rbp)
movq %rsi, -0x190(%rbp)
movq %rdi, -0x188(%rbp)
movq %rdi, %rax
movq %rax, -0x180(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x178(%rbp)
callq 0x1dfbb0
movq -0... | 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.cpp |
1,805 | void Omega_h::parallel_for<Omega_h::sort_locally_based_on_rank(Omega_h::Read<int>, Omega_h::Read<int>)::$_0>(int, Omega_h::sort_locally_based_on_rank(Omega_h::Read<int>, Omega_h::Read<int>)::$_0&&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1dfbb0
movq -0xe0(%rbp), %rdx
leaq 0x3a8afc(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x282ed1
leaq 0x3a839d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,806 | Omega_h::suggest_slices(long, int, int, long*, long*) | void suggest_slices(
GO total, I32 comm_size, I32 comm_rank, GO* p_begin, GO* p_end) {
auto comm_size_gt = GO(comm_size);
auto quot = total / comm_size_gt;
auto rem = total % comm_size_gt;
if (comm_rank < rem) {
*p_begin = quot * comm_rank + comm_rank;
*p_end = *p_begin + quot + 1;
} else {
*p... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cqto
idivq -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
cqto
idivq -0x28(%rbp)
movq %rdx, -0x38(%rbp... | 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.cpp |
1,807 | Omega_h::assemble_slices(std::shared_ptr<Omega_h::Comm>, Omega_h_Family, int, long, long, Omega_h::Read<long>, long, long, Omega_h::Read<double>, Omega_h::Dist*, Omega_h::Read<int>*, Omega_h::Dist*) | void assemble_slices(CommPtr comm, Omega_h_Family family, Int dim,
GO global_nelems, GO elem_offset, GOs conn_in, GO global_nverts,
GO vert_offset, Reals vert_coords, Dist* p_slice_elems2elems,
LOs* p_conn_out, Dist* p_slice_verts2verts) {
auto verts_per_elem = element_degree(family, dim, 0);
auto nslic... | pushq %rbp
movq %rsp, %rbp
subq $0xa90, %rsp # imm = 0xA90
movq %r9, -0x9a8(%rbp)
movq %rdi, -0x9a0(%rbp)
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq %rax, -0x998(%rbp)
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
m... | 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.cpp |
1,808 | void Omega_h::parallel_for<Omega_h::assemble_slices(std::shared_ptr<Omega_h::Comm>, Omega_h_Family, int, long, long, Omega_h::Read<long>, long, long, Omega_h::Read<double>, Omega_h::Dist*, Omega_h::Read<int>*, Omega_h::Dist*)::$_0>(int, Omega_h::assemble_slices(std::shared_ptr<Omega_h::Comm>, Omega_h_Family, int, long,... | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,809 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::sort_locally_based_on_rank(Omega_h::Read<int>, Omega_h::Read<int>)::$_0&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::sort_locally_based_on_rank(Omega_h::Read<int>, Omega_h::Read<int>)::$_0&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2844d8
jmp 0x284567
movq 0x4... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,810 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::assemble_slices(std::shared_ptr<Omega_h::Comm>, Omega_h_Family, int, long, long, Omega_h::Read<long>, long, long, Omega_h::Read<double>, Omega_h::Dist*, Omega_h::Read<int>*, Omega_h::Dist*)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::assemble_slices(s... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2849e8
jmp 0x284a77
movq 0x4... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,811 | Omega_h::Remotes::Remotes() | Remotes() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
movq $0x0, 0x8(%rcx)
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_remotes.hpp |
1,812 | Omega_h::Remotes::operator=(Omega_h::Remotes&&) | Remotes() {} | 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 0x1d1030
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1d1030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
ret... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_remotes.hpp |
1,813 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_tra... | map&
operator=(map&&) = 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 0x1d8110
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_map.h |
1,814 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, s... | void
clear() _GLIBCXX_NOEXCEPT
{
_M_erase(_M_begin());
_M_impl._M_reset();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1d4350
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x1bce40
jmp 0x284fd7
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d36a0
jmp 0x284fe6
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e93... | 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,815 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, s... | void
_M_move_data(_Rb_tree& __x, true_type)
{ _M_impl._M_move_data(__x._M_impl); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x1baa20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,816 | void std::__alloc_on_move<std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>>(std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_trait... | _GLIBCXX14_CONSTEXPR inline void
__alloc_on_move(_Alloc& __one, _Alloc& __two)
{
typedef allocator_traits<_Alloc> __traits;
typedef typename __traits::propagate_on_container_move_assignment __pocma;
#if __cplusplus >= 201703L
if constexpr (__pocma::value)
__one = std::move(__two);
#else
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cd1a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,817 | std::_Rb_tree_header::_M_move_data(std::_Rb_tree_header&) | void
_M_move_data(_Rb_tree_header& __from)
{
_M_header._M_color = __from._M_header._M_color;
_M_header._M_parent = __from._M_header._M_parent;
_M_header._M_left = __from._M_header._M_left;
_M_header._M_right = __from._M_header._M_right;
_M_header._M_parent->_M_parent = &_M_header;
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%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), ... | 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,818 | void std::__do_alloc_on_move<std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>>(std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_tr... | inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
{ __one = std::move(__two); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,819 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dadd0
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,820 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2170
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,821 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_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 0x1d6390
movq -0x10(%rbp), %rdi
callq 0x1cf180
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,822 | std::allocator<Omega_h::Vector<3>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d91d0
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,823 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,824 | _gnu_cxx::new_allocator<Omega_h::Vector<3>>::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,825 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::~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 0x1c8fa0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1c7480
jmp 0x2851ea
movq -0x20(%rbp), %... | 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,826 | void std::_Destroy<Omega_h::Vector<3>*, Omega_h::Vector<3>>(Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b8270
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,827 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,828 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
callq 0x1bbc90
jmp 0x285287
movq -0x10(%rbp), %rdi
callq 0... | 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,829 | void std::_Destroy<Omega_h::Vector<3>*>(Omega_h::Vector<3>*, Omega_h::Vector<3>*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
st... | 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 0x1c6150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
1,830 | void std::_Destroy_aux<true>::__destroy<Omega_h::Vector<3>*>(Omega_h::Vector<3>*, Omega_h::Vector<3>*) | static void
__destroy(_ForwardIterator, _ForwardIterator) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
1,831 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_deallocate(Omega_h::Vector<3>*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x285314
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1c4a60
addq $0x20, %rsp
popq %rbp
retq
nopw (%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,832 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1df590
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,833 | std::allocator_traits<std::allocator<Omega_h::Vector<3>>>::deallocate(std::allocator<Omega_h::Vector<3>>&, Omega_h::Vector<3>*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1e4cb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,834 | std::allocator<Omega_h::Vector<3>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf0a0
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,835 | _gnu_cxx::new_allocator<Omega_h::Vector<3>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,836 | Omega_h::form_state_configs(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&) | StateConfigs form_state_configs(StatesInProgress const& states) {
StateConfigs out;
for (int i = 0; i < size(states); ++i) {
auto& state = *at(states, i);
for (int j = 0; j < size(state.configs); ++j) out.push_back({i, j});
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1b97d0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cc1e0
movl %eax, -0x54(%rbp)
j... | 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,837 | Omega_h::form_states_to_state_configs(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::StateInProgres... | ParserGraph form_states_to_state_configs(
StateConfigs const& scs, StatesInProgress const& states) {
auto out = make_graph_with_nnodes(size(states));
for (int i = 0; i < size(scs); ++i) {
auto& sc = at(scs, i);
at(out, sc.state).push_back(i);
}
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cc1e0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x1b98c0
movl $0x0, -0x20(%rbp)
movl -0x... | 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,838 | Omega_h::print_dot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Omega_h::ParserInProgress const&) | void print_dot(std::string const& filepath, ParserInProgress const& pip) {
auto& sips = pip.states;
auto& cs = pip.configs;
auto& grammar = pip.grammar;
auto& states2scs = pip.states2state_configs;
std::cerr << "writing " << filepath << "\n\n";
std::ofstream file(filepath.c_str());
OMEGA_H_CHECK(file.is_o... | pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x48... | 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,839 | Omega_h::escape_dot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string escape_dot(std::string const& s) {
std::string out;
for (auto c : s) {
if (c == '\\' || c == '|' || c == '\"' || c == '<' || c == '>') {
out.push_back('\\');
out.push_back(c);
} else if (c == '.') {
out += "\'.\'";
} else {
out.push_back(c);
}
}
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1d67d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ccc60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
c... | 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,840 | Omega_h::build_lalr1_parser(std::shared_ptr<Omega_h::Grammar const>, bool) | ParserInProgress build_lalr1_parser(GrammarPtr grammar, bool verbose) {
ParserInProgress out;
auto& cs = out.configs;
auto& states = out.states;
auto& scs = out.state_configs;
auto& states2scs = out.states2state_configs;
out.grammar = grammar;
cs = make_configs(*grammar);
auto lhs2cs = get_left_hand_sid... | pushq %rbp
movq %rsp, %rbp
subq $0x720, %rsp # imm = 0x720
movq %rsi, -0x488(%rbp)
movq %rdi, -0x490(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x498(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x1d5d00
movq -0x490(%rbp), %rdi
movq... | 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,841 | Omega_h::make_configs(Omega_h::Grammar const&) | static Configs make_configs(Grammar const& g) {
Configs configs;
for (int i = 0; i < size(g.productions); ++i) {
auto& production = at(g.productions, i);
for (int j = 0; j <= size(production.rhs); ++j) {
configs.push_back({i, j});
}
}
return configs;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1c65c0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1de720
movl %ea... | 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,842 | Omega_h::get_left_hand_sides_to_start_configs(std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, Omega_h::Grammar const&) | static ParserGraph get_left_hand_sides_to_start_configs(
Configs const& cs, Grammar const& grammar) {
auto lhs2sc = make_graph_with_nnodes(grammar.nsymbols);
for (int c_i = 0; c_i < size(cs); ++c_i) {
auto& c = at(cs, c_i);
if (c.dot > 0) continue;
auto p_i = c.production;
auto& p = at(grammar.p... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x1b98c0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x60(%rbp... | 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,843 | Omega_h::build_lr0_parser(std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, Omega_h::Grammar const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | static StatesInProgress build_lr0_parser(
Configs const& cs, Grammar const& grammar, ParserGraph const& lhs2sc) {
StatesInProgress states;
StatePtr2StateIndex state_ptrs2idxs;
std::queue<int> state_q;
{ /* start state */
StateInProgress start_state;
auto accept_nt = get_accept_nonterminal(grammar);
... | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x2a0(%rbp)
movq %rdi, %rax
movq %rax, -0x298(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x1d21c0
leaq -0x58(%rbp), %rdi
callq 0x1de700
leaq -0xa8(%rbp), %... | 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,844 | Omega_h::determine_adequate_states(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::shared_ptr<Omega_h::Grammar const>, bool) | static std::vector<bool> determine_adequate_states(
StatesInProgress const& states, GrammarPtr grammar, bool verbose) {
auto out = make_vector<bool>(size(states));
for (int s_i = 0; s_i < size(states); ++s_i) {
auto& state = *at(states, s_i);
bool state_is_adequate = true;
for (int a_i = 0; a_i < si... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x108(%rbp)
movq %rdi, -0xf8(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movq -0x10(%rbp), %rd... | 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,845 | Omega_h::make_originator_graph(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>>>> c... | static ParserGraph make_originator_graph(StateConfigs const& scs,
StatesInProgress const& states, ParserGraph const& states2scs,
Configs const& cs, GrammarPtr grammar) {
auto out = make_graph_with_nnodes(size(scs));
auto ipg =
make_immediate_predecessor_graph(scs, states, states2scs, cs, grammar);
a... | pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp # imm = 0x2B0
movq %r9, -0x208(%rbp)
movq %rdi, -0x210(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq ... | 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,846 | Omega_h::compute_first_sets(Omega_h::Grammar const&, bool) | static std::vector<FirstSet> compute_first_sets(
Grammar const& grammar, bool verbose) {
if (verbose) std::cerr << "computing FIRST sets...\n";
struct Event {
int added_symbol;
int dependee;
};
std::queue<Event> event_q;
auto nsymbols = grammar.nsymbols;
auto first_sets = make_vector<FirstSet>(n... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x268(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x288d64
movq 0x46f280(%rip), %rdi # 0x6f7fd8
leaq 0x3a44e5(... | 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,847 | Omega_h::compute_context_set(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::vector<int, s... | static void compute_context_set(int zeta_j_addr, Contexts& contexts,
std::vector<bool>& complete, StateConfigs const& scs,
ParserGraph const& originator_graph, StatesInProgress const& states,
ParserGraph const& states2scs, Configs const& cs,
std::vector<FirstSet> const& first_sets, GrammarPtr grammar, b... | pushq %rbp
movq %rsp, %rbp
subq $0x690, %rsp # imm = 0x690
movb 0x30(%rbp), %al
movq 0x28(%rbp), %r10
movq %r10, -0x348(%rbp)
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %r10
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq... | 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,848 | Omega_h::accept_parser(Omega_h::ParserInProgress const&) | Parser accept_parser(ParserInProgress const& pip) {
auto& sips = pip.states;
auto& grammar = pip.grammar;
auto out = Parser(grammar, size(sips));
for (int s_i = 0; s_i < size(sips); ++s_i) {
add_state(out);
}
for (int s_i = 0; s_i < size(sips); ++s_i) {
auto& sip = *at(sips, s_i);
for (auto& act... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x20(... | 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,849 | Omega_h::close(Omega_h::StateInProgress&, std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, Omega_h::Grammar const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | static void close(StateInProgress& state, Configs const& cs,
Grammar const& grammar, ParserGraph const& lhs2sc) {
std::queue<int> config_q;
std::set<int> config_set;
for (auto config_i : state.configs) {
config_q.push(config_i);
OMEGA_H_CHECK(!config_set.count(config_i));
config_set.insert(config_... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1dc940
leaq -0xa0(%rbp), %rdi
callq 0x1d1af0
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x1bfd80
... | 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,850 | Omega_h::emplace_back(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>>>>&, Omega_h::StateInProgress&) | static void emplace_back(StatesInProgress& sips, StateInProgress& sip) {
sips.push_back(
std::unique_ptr<StateInProgress>(new StateInProgress(std::move(sip))));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1db240
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x... | 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,851 | Omega_h::add_reduction_actions(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>>>>&, std::vector<Omega_h::Config, std::allocator<Omega_h::Config>> const&, Omega_h::... | static void add_reduction_actions(
StatesInProgress& states, Configs const& cs, Grammar const& grammar) {
for (auto& state_uptr : states) {
auto& state = *state_uptr;
for (auto config_i : state.configs) {
auto& config = at(cs, config_i);
auto prod_i = config.production;
auto& prod = at(g... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1da420
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b80d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), ... | 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,852 | Omega_h::set_lr0_contexts(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>>>>&, Omega_h::Grammar const&) | static void set_lr0_contexts(StatesInProgress& states, Grammar const& grammar) {
for (auto& state_uptr : states) {
auto& state = *state_uptr;
for (auto& action : state.actions) {
if (action.action.kind != ACTION_REDUCE) continue;
if (action.action.production == get_accept_production(grammar)) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1da420
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b80d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e1260
tes... | 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,853 | Omega_h::make_immediate_predecessor_graph(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::StateInPro... | static ParserGraph make_immediate_predecessor_graph(StateConfigs const& scs,
StatesInProgress const& states, ParserGraph const& states2scs,
Configs const& cs, GrammarPtr grammar) {
auto out = make_graph_with_nnodes(size(scs));
for (int s_i = 0; s_i < size(states); ++s_i) {
auto& state = *at(states, s_i)... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %r9, -0xa8(%rbp)
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x... | 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,854 | Omega_h::find_transition_predecessors(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::StateInProgres... | static ParserGraph find_transition_predecessors(StateConfigs const& scs,
StatesInProgress const& states, ParserGraph const& states2scs,
Configs const& cs, GrammarPtr grammar) {
auto out = make_graph_with_nnodes(size(scs));
for (int state_i = 0; state_i < size(states); ++state_i) {
auto& state = *at(stat... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %r9, -0xe0(%rbp)
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x... | 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,855 | std::queue<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, 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>>>::queue<std::deque<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Ev... | queue()
: c() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x1c2d80
movq -0x10(%rbp), %rdi
callq 0x28cb50
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_queue.h |
1,856 | Omega_h::get_productions_by_lhs(Omega_h::Grammar const&) | static ParserGraph get_productions_by_lhs(Grammar const& grammar) {
auto nsymbols = grammar.nsymbols;
auto lhs2prods = make_graph_with_nnodes(nsymbols);
for (int prod_i = 0; prod_i < size(grammar.productions); ++prod_i) {
auto& prod = at(grammar.productions, prod_i);
add_edge(lhs2prods, prod.lhs, prod_i);... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %esi
callq 0x1b98c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ea... | 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,857 | std::queue<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, 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>>>::push(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&&) | void
push(value_type&& __x)
{ c.push_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 0x28d410
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/stl_queue.h |
1,858 | Omega_h::get_symbol_graph(Omega_h::Grammar const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | static ParserGraph get_symbol_graph(
Grammar const& grammar, ParserGraph const& lhs2prods) {
auto nsymbols = grammar.nsymbols;
auto out = make_graph_with_nnodes(nsymbols);
for (int lhs = 0; lhs < nsymbols; ++lhs) {
std::set<int> dependees;
auto& lhs_prods = get_edges(lhs2prods, lhs);
for (auto pro... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0x1c(%rbp), %esi
callq 0x1b... | 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,859 | std::queue<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, 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
{ return c.empty(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28dc40
andb $0x1, %al
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_queue.h |
1,860 | std::queue<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, 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_requires_nonempty();
return c.front();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28dca0
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_queue.h |
1,861 | std::queue<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event, 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() | void
pop()
{
__glibcxx_requires_nonempty();
c.pop_front();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28dd60
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_queue.h |
1,862 | Omega_h::get_first_set_of_string(std::vector<int, std::allocator<int>> const&, std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>> const&) | static FirstSet get_first_set_of_string(
std::vector<int> const& string, std::vector<FirstSet> const& first_sets) {
FirstSet out;
/* walk the string, stop when any symbol is found that doesn't
have a null terminal descendant */
int i;
for (i = 0; i < size(string); ++i) {
auto symbol = at(string, i)... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1d1af0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cf2d0
m... | 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,863 | 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() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28cb70
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,864 | 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()
: _M_impl()
{ _M_initialize_map(0); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x28cbc0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x28cbf0
jmp 0x28cb98
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
m... | 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,865 | 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_impl::_Deque_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 0x28cda0
movq -0x10(%rbp), %rdi
callq 0x28cdc0
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,866 | 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_impl::~_Deque_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d3e0
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,867 | std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28ce00
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,868 | 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_impl_data::_Deque_impl_data() | _Deque_impl_data() _GLIBCXX_NOEXCEPT
: _M_map(), _M_map_size(), _M_start(), _M_finish()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
addq $0x10, %rdi
callq 0x28ce10
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x28ce10
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,869 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::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,870 | 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() | _Deque_iterator() _GLIBCXX_NOEXCEPT
: _M_cur(), _M_first(), _M_last(), _M_node() { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%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_deque.h |
1,871 | 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_allocate_map(unsigned long) | _Map_pointer
_M_allocate_map(size_t __n)
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
return _Map_alloc_traits::allocate(__map_alloc, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x28d020
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x28d060
movq %rax, -0x30(%rbp)
jmp 0x28ce74
leaq -0x11(%rbp), %rdi
callq 0x28d090
movq -0x30(%r... | 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,872 | 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_deallocate_map(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event**, unsigned long) | void
_M_deallocate_map(_Map_pointer __p, size_t __n) _GLIBCXX_NOEXCEPT
{
_Map_alloc_type __map_alloc = _M_get_map_allocator();
_Map_alloc_traits::deallocate(__map_alloc, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x19(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x28d020
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28d370
jmp 0x28cfa8
leaq -0x19(%rbp), %rdi
callq... | 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,873 | 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*>::_M_set_node(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event**) | void
_M_set_node(_Map_pointer __new_node) _GLIBCXX_NOEXCEPT
{
_M_node = __new_node;
_M_first = *__new_node;
_M_last = _M_first + difference_type(_S_buffer_size());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x28d3d0
movq -0x20(%rbp), %r... | 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,874 | 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_map_allocator() const | _Map_alloc_type
_M_get_map_allocator() const _GLIBCXX_NOEXCEPT
{ return _Map_alloc_type(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28d0b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x28d0c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.h |
1,875 | std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>>::allocate(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x28d0f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,876 | std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d170
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,877 | 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() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.h |
1,878 | std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::allocator<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&) | _GLIBCXX20_CONSTEXPR
allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d0e0
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/allocator.h |
1,879 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::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,880 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > t... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x28d150
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x28d13b
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFF... | 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,881 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,882 | 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_allocate_node() | _Ptr
_M_allocate_node()
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x8, %edi
callq 0x1d0c20
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x28d210
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/stl_deque.h |
1,883 | std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::allocate(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x28d240
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,884 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > t... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x28d2a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x28d28b
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFF... | 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,885 | 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_deallocate_node(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*) | void
_M_deallocate_node(_Ptr __p) _GLIBCXX_NOEXCEPT
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
_Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x8, %edi
callq 0x1d0c20
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x28d310
jmp 0x28d2fc
addq $0x20, %rsp
po... | 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,886 | std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::deallocate(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28d340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,887 | std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>>::deallocate(std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event*>&, Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event**, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28d3a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,888 | 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*>::_S_buffer_size() | static size_t _S_buffer_size() _GLIBCXX_NOEXCEPT
{ return __deque_buf_size(sizeof(_Tp)); } | pushq %rbp
movq %rsp, %rbp
movl $0x8, %edi
callq 0x1d0c20
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,889 | std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d400
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,890 | _gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,891 | 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>>::push_back(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&&) | 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 0x28d440
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/stl_deque.h |
1,892 | void 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>>::emplace_back<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&&) | deque<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish._M_cur;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x30(%rcx), %rax
movq 0x40(%rcx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x28d48c
movq -0x18(%rbp), %rdi
movq 0x30(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x28d4a0
movq -0x18(%rb... | 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,893 | void std::allocator_traits<std::allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>>::construct<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... | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x28d570
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,894 | void 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_push_back_aux<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>(Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event&&) | void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x28d590
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x28d5c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x28d512
leaq 0x39fc29(%rip), %rdi # 0x62d136
ca... | 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,895 | void __gnu_cxx::new_allocator<Omega_h::compute_first_sets(Omega_h::Grammar const&, bool)::Event>::construct<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*, Omega_h::c... | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%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/ext/new_allocator.h |
1,896 | 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>>::size() const | size_type
size() 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 0x28d640
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/stl_deque.h |
1,897 | 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>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28d0b0
movq %rax, %rdi
callq 0x28d6c0
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/stl_deque.h |
1,898 | 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_reserve_map_at_back(unsigned long) | void
_M_reserve_map_at_back(size_type __nodes_to_add = 1)
{
if (__nodes_to_add + 1 > this->_M_impl._M_map_size
- (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
_M_reallocate_map(__nodes_to_add, false);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq 0x8(%rsi), %rcx
movq 0x48(%rsi), %rdx
movq (%rsi), %rsi
subq %rsi, %rdx
sarq $0x3, %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x28d639
movq -0x1... | 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,899 | 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&,... | difference_type
operator-(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{
return difference_type(_S_buffer_size())
* (__x._M_node - __y._M_node - bool(__x._M_node))
+ (__x._M_cur - __x._M_first)
+ (__y._M_last - __y._M_cur);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x28d3d0
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x18(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
movq -0x8(%rbp), %rdx
cmpq $0x0, 0x18(%rdx)
setne %dl
andb $0x1, %dl
movzbl %dl, %edx
subq %rdx... | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.