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 |
|---|---|---|---|---|---|---|
8,200 | std::initializer_list<bool>::end() const | constexpr const_iterator
end() const noexcept { return begin() + size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1c5d00
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1da310
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq %rcx, %rax
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/initializer_list |
8,201 | std::initializer_list<bool>::size() const | constexpr size_type
size() const noexcept { return _M_len; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/initializer_list |
8,202 | Omega_h::Few<Omega_h::Adj, 4>::Few(Omega_h::Few<Omega_h::Adj, 4>&&) | inline Few(Few<T, n>&& rhs) = default; | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
shlq $0x4, %rax
leaq (%rax,%rax,2), %rax
addq %rax, %rdi
movq %rdi, -0x40(%rbp)
addq %rax, %rsi
callq 0x1ceb50
jmp 0x4dbcff
movq -0x48(%rbp), %rax
addq $0x1, %rax
cmpq $0x4, %rax
movq %rax, -0x28(%rbp)
jne 0x4dbcd6
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rcx
movq %rax, %rsi
movq -0x40(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x50(%rbp)
je 0x4dbd54
movq -0x50(%rbp), %rdi
addq $-0x30, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1cb510
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x4dbd32
jmp 0x4dbd56
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_few.hpp |
8,203 | void Omega_h::parallel_for<void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda'(int)>(int, int&&) | 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 0x14fc2c(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dbda1
leaq 0x14f4cd(%rip), %rdx # 0x62b275
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1bb5a0
jmp 0x4dbdba
leaq -0xc8(%rbp), %rdi
movl $0x54, %esi
callq 0x1d4960
jmp 0x4dbdcd
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x1ca480
jmp 0x4dbde3
leaq -0x50(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x14fbbc(%rip), %rsi # 0x62b9b2
leaq -0x29(%rbp), %rdi
callq 0x1dc4d0
jmp 0x4dbe01
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
leaq -0xcc(%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 -0xd0(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xcc(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0x28(%rbp), %rdx
movl -0xd4(%rbp), %edi
movl -0xd8(%rbp), %esi
callq 0x1e15e0
jmp 0x4dbe9b
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dbf39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dbf2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dbf24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dbf18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
jmp 0x4dbf62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
movq -0xa0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,204 | void Omega_h::parallel_for<void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda0'(int)>(int, int&&) | 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 0x14f9bc(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dc011
leaq 0x14f25d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1bb5a0
jmp 0x4dc02a
leaq -0xc8(%rbp), %rdi
movl $0x54, %esi
callq 0x1d4960
jmp 0x4dc03d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x1ca480
jmp 0x4dc053
leaq -0x50(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x14f94c(%rip), %rsi # 0x62b9b2
leaq -0x29(%rbp), %rdi
callq 0x1dc4d0
jmp 0x4dc071
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
leaq -0xcc(%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 -0xd0(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xcc(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0x28(%rbp), %rdx
movl -0xd4(%rbp), %edi
movl -0xd8(%rbp), %esi
callq 0x1ca090
jmp 0x4dc10b
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dc1a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dc19d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dc194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x4dc188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
jmp 0x4dc1d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
movq -0xa0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,205 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda'(int)&>(int, int, void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda'(int)&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %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 0x4dc258
jmp 0x4dc2f9
movq 0x21ba29(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x1bc3f0
movq 0x21ba0f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4dc2ed
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x98(%rbp), %rdi
callq 0x1d42f0
jmp 0x4dc2b6
jmp 0x4dc2b8
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4dc27c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1dfb70
jmp 0x4dc302
leaq -0x98(%rbp), %rdi
callq 0x1dfb70
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,206 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda0'(int)&>(int, int, void Omega_h::assign_new_numbering<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Read<int>*, Omega_h::Read<int>*, bool)::'lambda0'(int)&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0x4dc6d8
jmp 0x4dc76a
movq 0x21b5a9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1ceee0
movq 0x21b592(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4dc761
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1d61b0
jmp 0x4dc730
jmp 0x4dc732
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4dc6f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1dbc70
jmp 0x4dc773
leaq -0x78(%rbp), %rdi
callq 0x1dbc70
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,207 | Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>) | Remotes update_ownership(Dist copies2old_owners, Read<I32> own_ranks) {
auto ncopies = copies2old_owners.nitems();
auto old_owners2copies = copies2old_owners.invert();
auto nold_owners = old_owners2copies.nroots();
auto serv_copies2copy_idxs = copies2old_owners.exch(LOs(ncopies, 0, 1), 1);
auto client2serv_comm = copies2old_owners.comm();
auto serv_copies2clients = old_owners2copies.items2msgs();
auto old_owners2serv_copies = old_owners2copies.roots2items();
auto clients2ranks = old_owners2copies.msgs2ranks();
Write<LO> old_owners2own_idxs(nold_owners);
Read<LO> copies2own_ranks;
if (own_ranks.exists()) {
auto serv_copies2own_ranks = copies2old_owners.exch(own_ranks, 1);
auto f = OMEGA_H_LAMBDA(LO old_owner) {
auto own_idx = -1;
for (auto serv_copy = old_owners2serv_copies[old_owner];
serv_copy < old_owners2serv_copies[old_owner + 1]; ++serv_copy) {
auto client = serv_copies2clients[serv_copy];
auto client_rank = clients2ranks[client];
auto own_rank = serv_copies2own_ranks[serv_copy];
if (own_rank == client_rank) {
own_idx = serv_copies2copy_idxs[serv_copy];
break;
}
}
old_owners2own_idxs[old_owner] = own_idx;
};
parallel_for(nold_owners, f, "update_ownership(ranks)");
copies2own_ranks = own_ranks;
} else {
Write<I32> old_owners2own_ranks(nold_owners);
auto clients2ncopies = client2serv_comm->allgather(ncopies);
auto f = OMEGA_H_LAMBDA(LO old_owner) {
I32 own_rank = -1;
LO nown_client_copies = -1;
LO own_idx = -1;
for (auto serv_copy = old_owners2serv_copies[old_owner];
serv_copy < old_owners2serv_copies[old_owner + 1]; ++serv_copy) {
auto client = serv_copies2clients[serv_copy];
auto nclient_copies = clients2ncopies[client];
auto client_rank = clients2ranks[client];
if ((own_rank == -1) || (nclient_copies < nown_client_copies) ||
((nclient_copies == nown_client_copies) &&
(client_rank < own_rank))) {
auto copy_idx = serv_copies2copy_idxs[serv_copy];
own_rank = client_rank;
nown_client_copies = nclient_copies;
own_idx = copy_idx;
}
}
old_owners2own_ranks[old_owner] = own_rank;
old_owners2own_idxs[old_owner] = own_idx;
};
parallel_for(nold_owners, f, "update_ownership");
copies2own_ranks =
old_owners2copies.exch(Read<I32>(old_owners2own_ranks), 1);
}
auto copies2own_idxs =
old_owners2copies.exch(Read<LO>(old_owners2own_idxs), 1);
return Remotes(copies2own_ranks, copies2own_idxs);
} | pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp # imm = 0x440
movq %rdx, -0x3b0(%rbp)
movq %rsi, -0x398(%rbp)
movq %rdi, %rax
movq -0x398(%rbp), %rdi
movq %rax, -0x3a8(%rbp)
movq %rax, %rcx
movq %rcx, -0x3a0(%rbp)
movq %rax, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
callq 0x1c9650
movq -0x398(%rbp), %rsi
movl %eax, -0x4c(%rbp)
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x390(%rbp)
callq 0x1d9700
movq -0x390(%rbp), %rdi
callq 0x1cda20
movl %eax, -0x384(%rbp)
jmp 0x4dca06
movl -0x384(%rbp), %eax
movl %eax, -0xe4(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x3bc(%rbp)
leaq -0x139(%rbp), %rdi
movq %rdi, -0x3b8(%rbp)
callq 0x1dfbb0
movq -0x3b8(%rbp), %rdx
leaq 0x154943(%rip), %rsi # 0x63137f
leaq -0x138(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dca4a
movl -0x3bc(%rbp), %esi
leaq -0x118(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0x138(%rbp), %r8
callq 0x1c6500
jmp 0x4dca6c
movq -0x398(%rbp), %rsi
leaq -0x108(%rbp), %rdi
leaq -0x118(%rbp), %rdx
movl $0x1, %ecx
callq 0x1d77c0
jmp 0x4dca8d
leaq -0x118(%rbp), %rdi
callq 0x1c7d90
leaq -0x138(%rbp), %rdi
callq 0x1c4d10
leaq -0x139(%rbp), %rdi
callq 0x1cf450
movq -0x398(%rbp), %rsi
leaq -0x150(%rbp), %rdi
callq 0x1bd060
jmp 0x4dcac6
leaq -0x160(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cba50
jmp 0x4dcadb
leaq -0x170(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1de450
jmp 0x4dcaf0
leaq -0x180(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1c9870
jmp 0x4dcb05
movl -0xe4(%rbp), %eax
movl %eax, -0x3cc(%rbp)
leaq -0x1b1(%rbp), %rdi
movq %rdi, -0x3c8(%rbp)
callq 0x1dfbb0
movq -0x3c8(%rbp), %rdx
leaq 0x15484d(%rip), %rsi # 0x63137f
leaq -0x1b0(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dcb40
movl -0x3cc(%rbp), %esi
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rdx
callq 0x1bc080
jmp 0x4dcb5b
leaq -0x1b0(%rbp), %rdi
callq 0x1c4d10
leaq -0x1b1(%rbp), %rdi
callq 0x1cf450
leaq -0x1c8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq -0x3b0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4dcf34
movq -0x3b0(%rbp), %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x1d99b0
jmp 0x4dcbe0
movq -0x398(%rbp), %rsi
leaq -0x1d8(%rbp), %rdi
leaq -0x1e8(%rbp), %rdx
movl $0x1, %ecx
callq 0x1d77c0
jmp 0x4dcc01
leaq -0x1e8(%rbp), %rdi
callq 0x1c7d90
leaq -0x248(%rbp), %rdi
movq %rdi, -0x3d8(%rbp)
leaq -0x170(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcc29
leaq -0x238(%rbp), %rdi
movq %rdi, -0x3e0(%rbp)
leaq -0x160(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcc45
leaq -0x228(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
leaq -0x180(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcc61
leaq -0x218(%rbp), %rdi
movq %rdi, -0x3f0(%rbp)
leaq -0x1d8(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcc7d
leaq -0x208(%rbp), %rdi
movq %rdi, -0x3f8(%rbp)
leaq -0x108(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcc99
leaq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x1c0f10
jmp 0x4dccae
movl -0xe4(%rbp), %edi
leaq 0x15835d(%rip), %rdx # 0x635018
leaq -0x248(%rbp), %rsi
callq 0x4dd560
jmp 0x4dccc9
movq -0x3b0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x1d4a20
jmp 0x4dccde
leaq -0x248(%rbp), %rdi
callq 0x4dd630
leaq -0x1d8(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dd316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dcd64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dcd58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1c7d90
leaq -0x138(%rbp), %rdi
callq 0x1c4d10
leaq -0x139(%rbp), %rdi
callq 0x1cf450
jmp 0x4dd545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd539
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd52d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd521
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd515
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dce03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x1c4d10
leaq -0x1b1(%rbp), %rdi
callq 0x1cf450
jmp 0x4dd509
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd4f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dd4f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dcf23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dcef7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dceeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dcedf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dced3
movq -0x3f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
callq 0x1c7d90
movq -0x3f0(%rbp), %rdi
callq 0x1c7d90
movq -0x3e8(%rbp), %rdi
callq 0x1c7d90
movq -0x3e0(%rbp), %rdi
callq 0x1c7d90
movq -0x3d8(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dcf23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x4dd630
leaq -0x1d8(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dd4f1
movl -0xe4(%rbp), %eax
movl %eax, -0x404(%rbp)
leaq -0x279(%rbp), %rdi
movq %rdi, -0x400(%rbp)
callq 0x1dfbb0
movq -0x400(%rbp), %rdx
leaq 0x15441e(%rip), %rsi # 0x63137f
leaq -0x278(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dcf6f
movl -0x404(%rbp), %esi
leaq -0x258(%rbp), %rdi
leaq -0x278(%rbp), %rdx
callq 0x1bc080
jmp 0x4dcf8a
leaq -0x278(%rbp), %rdi
callq 0x1c4d10
leaq -0x279(%rbp), %rdi
callq 0x1cf450
leaq -0x150(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rsi
movl -0x4c(%rbp), %edx
leaq -0x290(%rbp), %rdi
callq 0x1d9380
jmp 0x4dcfc2
leaq -0x300(%rbp), %rdi
movq %rdi, -0x410(%rbp)
leaq -0x170(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcfde
leaq -0x2f0(%rbp), %rdi
movq %rdi, -0x418(%rbp)
leaq -0x160(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dcffa
leaq -0x2e0(%rbp), %rdi
movq %rdi, -0x420(%rbp)
leaq -0x290(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dd016
leaq -0x2d0(%rbp), %rdi
movq %rdi, -0x428(%rbp)
leaq -0x180(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dd032
leaq -0x2c0(%rbp), %rdi
movq %rdi, -0x430(%rbp)
leaq -0x108(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dd04e
leaq -0x2b0(%rbp), %rdi
movq %rdi, -0x438(%rbp)
leaq -0x258(%rbp), %rsi
callq 0x1c0f10
jmp 0x4dd06a
leaq -0x2a0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x1c0f10
jmp 0x4dd07f
movl -0xe4(%rbp), %edi
leaq 0x157fa4(%rip), %rdx # 0x635030
leaq -0x300(%rbp), %rsi
callq 0x4dd690
jmp 0x4dd09a
leaq -0x330(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x1c0f10
jmp 0x4dd0af
leaq -0x320(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x1cfc00
jmp 0x4dd0c4
leaq -0x310(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x320(%rbp), %rdx
movl $0x1, %ecx
callq 0x1d77c0
jmp 0x4dd0e5
leaq -0x1c8(%rbp), %rdi
leaq -0x310(%rbp), %rsi
callq 0x1d1030
jmp 0x4dd0fa
leaq -0x310(%rbp), %rdi
callq 0x1c7d90
leaq -0x320(%rbp), %rdi
callq 0x1c7d90
leaq -0x330(%rbp), %rdi
callq 0x1dfdc0
leaq -0x300(%rbp), %rdi
callq 0x4dd760
leaq -0x290(%rbp), %rdi
callq 0x1c7d90
leaq -0x258(%rbp), %rdi
callq 0x1dfdc0
jmp 0x4dd316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x1c4d10
leaq -0x279(%rbp), %rdi
callq 0x1cf450
jmp 0x4dd4f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd2f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd26d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd261
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd255
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd23d
movq -0x438(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
callq 0x1dfdc0
movq -0x430(%rbp), %rdi
callq 0x1c7d90
movq -0x428(%rbp), %rdi
callq 0x1c7d90
movq -0x420(%rbp), %rdi
callq 0x1c7d90
movq -0x418(%rbp), %rdi
callq 0x1c7d90
movq -0x410(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dd2f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd2ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd2e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd2d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x310(%rbp), %rdi
callq 0x1c7d90
leaq -0x320(%rbp), %rdi
callq 0x1c7d90
leaq -0x330(%rbp), %rdi
callq 0x1dfdc0
leaq -0x300(%rbp), %rdi
callq 0x4dd760
leaq -0x290(%rbp), %rdi
callq 0x1c7d90
leaq -0x258(%rbp), %rdi
callq 0x1dfdc0
jmp 0x4dd4f1
leaq -0x360(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x1c0f10
jmp 0x4dd32b
leaq -0x350(%rbp), %rdi
leaq -0x360(%rbp), %rsi
callq 0x1cfc00
jmp 0x4dd340
leaq -0x340(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x350(%rbp), %rdx
movl $0x1, %ecx
callq 0x1d77c0
jmp 0x4dd361
leaq -0x350(%rbp), %rdi
callq 0x1c7d90
leaq -0x360(%rbp), %rdi
callq 0x1dfdc0
leaq -0x370(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dd38e
leaq -0x380(%rbp), %rdi
leaq -0x340(%rbp), %rsi
callq 0x1d99b0
jmp 0x4dd3a3
movq -0x3a8(%rbp), %rdi
leaq -0x370(%rbp), %rsi
leaq -0x380(%rbp), %rdx
callq 0x1bc530
jmp 0x4dd3bf
leaq -0x380(%rbp), %rdi
callq 0x1c7d90
leaq -0x370(%rbp), %rdi
callq 0x1c7d90
leaq -0x340(%rbp), %rdi
callq 0x1c7d90
leaq -0x1c8(%rbp), %rdi
callq 0x1c7d90
leaq -0x190(%rbp), %rdi
callq 0x1dfdc0
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
leaq -0x170(%rbp), %rdi
callq 0x1c7d90
leaq -0x160(%rbp), %rdi
callq 0x1c7d90
leaq -0x150(%rbp), %rdi
callq 0x1cb520
leaq -0x108(%rbp), %rdi
callq 0x1c7d90
leaq -0xe0(%rbp), %rdi
callq 0x1d7290
movq -0x3a0(%rbp), %rax
addq $0x440, %rsp # imm = 0x440
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd485
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x1c7d90
leaq -0x360(%rbp), %rdi
callq 0x1dfdc0
jmp 0x4dd4f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd4e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
jmp 0x4dd4d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf0(%rbp)
movl %eax, -0xf4(%rbp)
leaq -0x380(%rbp), %rdi
callq 0x1c7d90
leaq -0x370(%rbp), %rdi
callq 0x1c7d90
leaq -0x340(%rbp), %rdi
callq 0x1c7d90
leaq -0x1c8(%rbp), %rdi
callq 0x1c7d90
leaq -0x190(%rbp), %rdi
callq 0x1dfdc0
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
leaq -0x170(%rbp), %rdi
callq 0x1c7d90
leaq -0x160(%rbp), %rdi
callq 0x1c7d90
leaq -0x150(%rbp), %rdi
callq 0x1cb520
leaq -0x108(%rbp), %rdi
callq 0x1c7d90
leaq -0xe0(%rbp), %rdi
callq 0x1d7290
movq -0xf0(%rbp), %rdi
callq 0x1dfa40
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_owners.cpp |
8,208 | void Omega_h::parallel_for<Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_0>(int, Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_0 const&, char const*) | 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 $0xc0, %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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4ddc40
movq -0xb8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xa0(%rbp)
movl -0x9c(%rbp), %edi
movl -0xa0(%rbp), %esi
callq 0x4ddd70
jmp 0x4dd5e8
leaq -0x98(%rbp), %rdi
callq 0x4dd630
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4dd630
movq -0xa8(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,209 | void Omega_h::parallel_for<Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_1>(int, Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_1 const&, char const*) | 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 $0xd0, %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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x4de270
movq -0xc8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0xac(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xb0(%rbp)
movl -0xac(%rbp), %edi
movl -0xb0(%rbp), %esi
callq 0x4de3d0
jmp 0x4dd718
leaq -0xa8(%rbp), %rdi
callq 0x4dd760
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4dd760
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,210 | Omega_h::owners_from_globals(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>, Omega_h::Read<int>) | Remotes owners_from_globals(
CommPtr comm, Read<GO> globals, Read<I32> own_ranks) {
auto copies2lins_dist = copies_to_linear_owners(comm, globals);
return update_ownership(copies2lins_dist, own_ranks);
} | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, -0x1a0(%rbp)
movq %rdx, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rax
movq %rax, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1d9d90
movq -0x188(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1c3090
jmp 0x4dd82b
leaq -0xb0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x1d9820
jmp 0x4dd847
leaq -0xd0(%rbp), %rdi
callq 0x1bc010
leaq -0xc0(%rbp), %rdi
callq 0x1cb520
leaq -0x170(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1bea00
jmp 0x4dd874
movq -0x1a0(%rbp), %rsi
leaq -0x180(%rbp), %rdi
callq 0x1d99b0
jmp 0x4dd889
movq -0x198(%rbp), %rdi
leaq -0x170(%rbp), %rsi
leaq -0x180(%rbp), %rdx
callq 0x1c6da0
jmp 0x4dd8a5
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
leaq -0x170(%rbp), %rdi
callq 0x1d7290
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0x190(%rbp), %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dd90b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1bc010
leaq -0xc0(%rbp), %rdi
callq 0x1cb520
jmp 0x4dd977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dd96b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dd95f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
leaq -0x170(%rbp), %rdi
callq 0x1d7290
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0xd8(%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_owners.cpp |
8,211 | Omega_h::globals_from_owners(Omega_h::Mesh*, int) | GOs globals_from_owners(Mesh* mesh, Int ent_dim) {
auto nnew_ents = mesh->nents(ent_dim);
if (!mesh->could_be_shared(ent_dim)) {
auto start = mesh->comm()->exscan(GO(nnew_ents), OMEGA_H_SUM);
return Read<GO>(nnew_ents, start, 1);
}
auto new_owned = mesh->owned(ent_dim);
auto new_globals = rescan_globals(mesh, new_owned);
return mesh->sync_array(ent_dim, new_globals, 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c0460
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1d0aa0
testb $0x1, %al
jne 0x4ddaeb
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1be0a0
movq -0xc8(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x1bbd30
movq %rax, -0xc0(%rbp)
jmp 0x4dda14
leaq -0x30(%rbp), %rdi
callq 0x1cb520
movq -0xc0(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xdc(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1dfbb0
movq -0xd0(%rbp), %rdx
leaq 0x153925(%rip), %rsi # 0x63137f
leaq -0x60(%rbp), %rdi
callq 0x1d5e00
jmp 0x4dda65
movq -0xd8(%rbp), %rdx
movl -0xdc(%rbp), %esi
movq -0xb8(%rbp), %rdi
movl $0x1, %ecx
leaq -0x60(%rbp), %r8
callq 0x1e1a00
jmp 0x4dda89
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x61(%rbp), %rdi
callq 0x1cf450
jmp 0x4ddc23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cb520
jmp 0x4ddc33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4ddadd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0x61(%rbp), %rdi
callq 0x1cf450
jmp 0x4ddc33
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x78(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1b9af0
movq -0xf0(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1bec60
jmp 0x4ddb22
movq -0xe8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x1ce160
jmp 0x4ddb3e
leaq -0x98(%rbp), %rdi
callq 0x1e0060
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xf4(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1c3090
jmp 0x4ddb73
movl -0xf4(%rbp), %edx
movq -0x100(%rbp), %rsi
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
movl $0x1, %r8d
callq 0x1bbe90
jmp 0x4ddb9b
leaq -0xa8(%rbp), %rdi
callq 0x1bc010
leaq -0x88(%rbp), %rdi
callq 0x1bc010
leaq -0x78(%rbp), %rdi
callq 0x1e0060
jmp 0x4ddc23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4ddc18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1e0060
jmp 0x4ddc18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4ddc0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1bc010
leaq -0x88(%rbp), %rdi
callq 0x1bc010
leaq -0x78(%rbp), %rdi
callq 0x1e0060
jmp 0x4ddc33
movq -0xb0(%rbp), %rax
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
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_owners.cpp |
8,212 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::update_ownership(Omega_h::Dist, 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %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 0x4ddda8
jmp 0x4dde49
movq 0x219ed9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x4dde60
movq 0x219ebf(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4dde3d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0xa0(%rbp), %rdi
callq 0x4ddf90
jmp 0x4dde06
jmp 0x4dde08
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4dddcc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4dd630
jmp 0x4dde52
leaq -0xa0(%rbp), %rdi
callq 0x4dd630
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,213 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_1>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::update_ownership(Omega_h::Dist, Omega_h::Read<int>)::$_1&&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %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 0x4de408
jmp 0x4de4a9
movq 0x219879(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x4de4c0
movq 0x21985f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4de49d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0xb0(%rbp), %rdi
callq 0x4de620
jmp 0x4de466
jmp 0x4de468
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4de42c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x4dd760
jmp 0x4de4b2
leaq -0xb0(%rbp), %rdi
callq 0x4dd760
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
8,214 | Omega_h::Read<signed char> Omega_h::reduce_data_to_owners<signed char>(Omega_h::Read<signed char>, Omega_h::Dist, int) | Read<T> reduce_data_to_owners(
Read<T> copy_data, Dist copies2owners, Int ncomps) {
auto owners2copies = copies2owners.invert();
auto serv_copy_data = copies2owners.exch(copy_data, ncomps);
auto nowners = owners2copies.nroots();
auto comm = copies2owners.parent_comm();
auto owners2serv_copies = owners2copies.roots2items();
auto owner_data_w = Write<T>(nowners * ncomps);
auto f = OMEGA_H_LAMBDA(LO owner) {
auto sc_begin = owners2serv_copies[owner];
for (Int c = 0; c < ncomps; ++c) {
owner_data_w[owner * ncomps + c] = serv_copy_data[sc_begin * ncomps + c];
}
};
parallel_for(nowners, f, "reduce_data_to_owners");
return owner_data_w;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x1a0(%rbp)
movq %rsi, %rax
movq -0x1a0(%rbp), %rsi
movq %rax, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rdx
movq %rdx, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1d9700
movq -0x188(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1bec60
jmp 0x4dea24
movq -0x1a0(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x1d52f0
jmp 0x4dea43
leaq -0xd0(%rbp), %rdi
callq 0x1e0060
leaq -0xb0(%rbp), %rdi
callq 0x1cda20
movl %eax, -0x1a4(%rbp)
jmp 0x4dea63
movq -0x1a0(%rbp), %rsi
movl -0x1a4(%rbp), %eax
movl %eax, -0xe0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1d2930
jmp 0x4dea84
leaq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1de450
jmp 0x4dea99
movl -0xe0(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x1b4(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0x1528b3(%rip), %rsi # 0x63137f
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x4deada
movl -0x1b4(%rbp), %esi
leaq -0x110(%rbp), %rdi
leaq -0x130(%rbp), %rdx
callq 0x1c2160
jmp 0x4deaf5
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x100(%rbp), %rsi
callq 0x1d99b0
jmp 0x4deb29
movl -0x1c(%rbp), %eax
movl %eax, -0x160(%rbp)
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d26b0
jmp 0x4deb4e
leaq -0x148(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1bec60
jmp 0x4deb63
movl -0xe0(%rbp), %edi
leaq 0x156492(%rip), %rdx # 0x635002
leaq -0x170(%rbp), %rsi
callq 0x1e1040
jmp 0x4deb7e
leaq -0x180(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1e2650
jmp 0x4deb93
movq -0x198(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1d12a0
jmp 0x4deba8
leaq -0x180(%rbp), %rdi
callq 0x1d4740
leaq -0x170(%rbp), %rdi
callq 0x1d6660
leaq -0x110(%rbp), %rdi
callq 0x1d4740
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1e0060
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0x190(%rbp), %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ded79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1e0060
jmp 0x4ded79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ded6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ded61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4deca6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x4ded55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ded49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4decfd
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1d4740
movq -0x1c0(%rbp), %rdi
callq 0x1c7d90
jmp 0x4ded49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4ded3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1d4740
leaq -0x170(%rbp), %rdi
callq 0x1d6660
leaq -0x110(%rbp), %rdi
callq 0x1d4740
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1e0060
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
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_owners.cpp |
8,215 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::reduce_data_to_owners<signed char>(Omega_h::Read<signed char>, Omega_h::Dist, int)::'lambda'(int)>(int, signed char const&, char const*) | 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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1c7000
movq -0x90(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %edi
movl -0x78(%rbp), %esi
callq 0x1ca6f0
jmp 0x4dee19
leaq -0x70(%rbp), %rdi
callq 0x1d6660
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d6660
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,216 | Omega_h::Read<int> Omega_h::reduce_data_to_owners<int>(Omega_h::Read<int>, Omega_h::Dist, int) | Read<T> reduce_data_to_owners(
Read<T> copy_data, Dist copies2owners, Int ncomps) {
auto owners2copies = copies2owners.invert();
auto serv_copy_data = copies2owners.exch(copy_data, ncomps);
auto nowners = owners2copies.nroots();
auto comm = copies2owners.parent_comm();
auto owners2serv_copies = owners2copies.roots2items();
auto owner_data_w = Write<T>(nowners * ncomps);
auto f = OMEGA_H_LAMBDA(LO owner) {
auto sc_begin = owners2serv_copies[owner];
for (Int c = 0; c < ncomps; ++c) {
owner_data_w[owner * ncomps + c] = serv_copy_data[sc_begin * ncomps + c];
}
};
parallel_for(nowners, f, "reduce_data_to_owners");
return owner_data_w;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x1a0(%rbp)
movq %rsi, %rax
movq -0x1a0(%rbp), %rsi
movq %rax, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rdx
movq %rdx, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1d9700
movq -0x188(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1d99b0
jmp 0x4deef4
movq -0x1a0(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x1d77c0
jmp 0x4def13
leaq -0xd0(%rbp), %rdi
callq 0x1c7d90
leaq -0xb0(%rbp), %rdi
callq 0x1cda20
movl %eax, -0x1a4(%rbp)
jmp 0x4def33
movq -0x1a0(%rbp), %rsi
movl -0x1a4(%rbp), %eax
movl %eax, -0xe0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1d2930
jmp 0x4def54
leaq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1de450
jmp 0x4def69
movl -0xe0(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x1b4(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0x1523e3(%rip), %rsi # 0x63137f
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x4defaa
movl -0x1b4(%rbp), %esi
leaq -0x110(%rbp), %rdi
leaq -0x130(%rbp), %rdx
callq 0x1bc080
jmp 0x4defc5
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x100(%rbp), %rsi
callq 0x1d99b0
jmp 0x4deff9
movl -0x1c(%rbp), %eax
movl %eax, -0x160(%rbp)
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1c0f10
jmp 0x4df01e
leaq -0x148(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1d99b0
jmp 0x4df033
movl -0xe0(%rbp), %edi
leaq 0x155fc2(%rip), %rdx # 0x635002
leaq -0x170(%rbp), %rsi
callq 0x1cbb60
jmp 0x4df04e
leaq -0x180(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1c8620
jmp 0x4df063
movq -0x198(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1cfc00
jmp 0x4df078
leaq -0x180(%rbp), %rdi
callq 0x1dfdc0
leaq -0x170(%rbp), %rdi
callq 0x1c3a10
leaq -0x110(%rbp), %rdi
callq 0x1dfdc0
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1c7d90
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0x190(%rbp), %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1c7d90
jmp 0x4df249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df23d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df231
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df176
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x4df225
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df1cd
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1dfdc0
movq -0x1c0(%rbp), %rdi
callq 0x1c7d90
jmp 0x4df219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1dfdc0
leaq -0x170(%rbp), %rdi
callq 0x1c3a10
leaq -0x110(%rbp), %rdi
callq 0x1dfdc0
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1c7d90
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
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_owners.cpp |
8,217 | void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::reduce_data_to_owners<int>(Omega_h::Read<int>, Omega_h::Dist, int)::'lambda'(int)>(int, int const&, char const*) | 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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1cb020
movq -0x90(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %edi
movl -0x78(%rbp), %esi
callq 0x1c6f40
jmp 0x4df2e9
leaq -0x70(%rbp), %rdi
callq 0x1c3a10
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1c3a10
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,218 | Omega_h::Read<long> Omega_h::reduce_data_to_owners<long>(Omega_h::Read<long>, Omega_h::Dist, int) | Read<T> reduce_data_to_owners(
Read<T> copy_data, Dist copies2owners, Int ncomps) {
auto owners2copies = copies2owners.invert();
auto serv_copy_data = copies2owners.exch(copy_data, ncomps);
auto nowners = owners2copies.nroots();
auto comm = copies2owners.parent_comm();
auto owners2serv_copies = owners2copies.roots2items();
auto owner_data_w = Write<T>(nowners * ncomps);
auto f = OMEGA_H_LAMBDA(LO owner) {
auto sc_begin = owners2serv_copies[owner];
for (Int c = 0; c < ncomps; ++c) {
owner_data_w[owner * ncomps + c] = serv_copy_data[sc_begin * ncomps + c];
}
};
parallel_for(nowners, f, "reduce_data_to_owners");
return owner_data_w;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x1a0(%rbp)
movq %rsi, %rax
movq -0x1a0(%rbp), %rsi
movq %rax, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rdx
movq %rdx, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1d9700
movq -0x188(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1c3090
jmp 0x4df3c4
movq -0x1a0(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x1db7f0
jmp 0x4df3e3
leaq -0xd0(%rbp), %rdi
callq 0x1bc010
leaq -0xb0(%rbp), %rdi
callq 0x1cda20
movl %eax, -0x1a4(%rbp)
jmp 0x4df403
movq -0x1a0(%rbp), %rsi
movl -0x1a4(%rbp), %eax
movl %eax, -0xe0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1d2930
jmp 0x4df424
leaq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1de450
jmp 0x4df439
movl -0xe0(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x1b4(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0x151f13(%rip), %rsi # 0x63137f
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x4df47a
movl -0x1b4(%rbp), %esi
leaq -0x110(%rbp), %rdi
leaq -0x130(%rbp), %rdx
callq 0x1b9940
jmp 0x4df495
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x100(%rbp), %rsi
callq 0x1d99b0
jmp 0x4df4c9
movl -0x1c(%rbp), %eax
movl %eax, -0x160(%rbp)
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1c78d0
jmp 0x4df4ee
leaq -0x148(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1c3090
jmp 0x4df503
movl -0xe0(%rbp), %edi
leaq 0x155af2(%rip), %rdx # 0x635002
leaq -0x170(%rbp), %rsi
callq 0x1e02c0
jmp 0x4df51e
leaq -0x180(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1bd640
jmp 0x4df533
movq -0x198(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1b9dd0
jmp 0x4df548
leaq -0x180(%rbp), %rdi
callq 0x1e1240
leaq -0x170(%rbp), %rdi
callq 0x1bd0b0
leaq -0x110(%rbp), %rdi
callq 0x1e1240
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1bc010
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0x190(%rbp), %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1bc010
jmp 0x4df719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df70d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df646
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x4df6f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df6e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df69d
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1e1240
movq -0x1c0(%rbp), %rdi
callq 0x1c7d90
jmp 0x4df6e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4df6dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1e1240
leaq -0x170(%rbp), %rdi
callq 0x1bd0b0
leaq -0x110(%rbp), %rdi
callq 0x1e1240
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1bc010
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
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_owners.cpp |
8,219 | void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::reduce_data_to_owners<long>(Omega_h::Read<long>, Omega_h::Dist, int)::'lambda'(int)>(int, long const&, char const*) | 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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1cf2c0
movq -0x90(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %edi
movl -0x78(%rbp), %esi
callq 0x1d13b0
jmp 0x4df7b9
leaq -0x70(%rbp), %rdi
callq 0x1bd0b0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1bd0b0
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,220 | Omega_h::Read<double> Omega_h::reduce_data_to_owners<double>(Omega_h::Read<double>, Omega_h::Dist, int) | Read<T> reduce_data_to_owners(
Read<T> copy_data, Dist copies2owners, Int ncomps) {
auto owners2copies = copies2owners.invert();
auto serv_copy_data = copies2owners.exch(copy_data, ncomps);
auto nowners = owners2copies.nroots();
auto comm = copies2owners.parent_comm();
auto owners2serv_copies = owners2copies.roots2items();
auto owner_data_w = Write<T>(nowners * ncomps);
auto f = OMEGA_H_LAMBDA(LO owner) {
auto sc_begin = owners2serv_copies[owner];
for (Int c = 0; c < ncomps; ++c) {
owner_data_w[owner * ncomps + c] = serv_copy_data[sc_begin * ncomps + c];
}
};
parallel_for(nowners, f, "reduce_data_to_owners");
return owner_data_w;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdx, -0x1a0(%rbp)
movq %rsi, %rax
movq -0x1a0(%rbp), %rsi
movq %rax, -0x188(%rbp)
movq %rdi, -0x198(%rbp)
movq %rdi, %rdx
movq %rdx, -0x190(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1d9700
movq -0x188(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0x1cae10
jmp 0x4df894
movq -0x1a0(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x1d2bb0
jmp 0x4df8b3
leaq -0xd0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb0(%rbp), %rdi
callq 0x1cda20
movl %eax, -0x1a4(%rbp)
jmp 0x4df8d3
movq -0x1a0(%rbp), %rsi
movl -0x1a4(%rbp), %eax
movl %eax, -0xe0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1d2930
jmp 0x4df8f4
leaq -0x100(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1de450
jmp 0x4df909
movl -0xe0(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x1b4(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0x151a43(%rip), %rsi # 0x63137f
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x4df94a
movl -0x1b4(%rbp), %esi
leaq -0x110(%rbp), %rdi
leaq -0x130(%rbp), %rdx
callq 0x1cd090
jmp 0x4df965
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
leaq -0x100(%rbp), %rsi
callq 0x1d99b0
jmp 0x4df999
movl -0x1c(%rbp), %eax
movl %eax, -0x160(%rbp)
leaq -0x158(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1c7e70
jmp 0x4df9be
leaq -0x148(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1cae10
jmp 0x4df9d3
movl -0xe0(%rbp), %edi
leaq 0x155622(%rip), %rdx # 0x635002
leaq -0x170(%rbp), %rsi
callq 0x1bc5f0
jmp 0x4df9ee
leaq -0x180(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1d8720
jmp 0x4dfa03
movq -0x198(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1ccda0
jmp 0x4dfa18
leaq -0x180(%rbp), %rdi
callq 0x1dc900
leaq -0x170(%rbp), %rdi
callq 0x1e1e00
leaq -0x110(%rbp), %rdi
callq 0x1dc900
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0x190(%rbp), %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfbe9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1e0ab0
jmp 0x4dfbe9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfbdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfbd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfb16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x4dfbc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfbb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfb6d
movq -0x1c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1dc900
movq -0x1c0(%rbp), %rdi
callq 0x1c7d90
jmp 0x4dfbb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x4dfbad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x180(%rbp), %rdi
callq 0x1dc900
leaq -0x170(%rbp), %rdi
callq 0x1e1e00
leaq -0x110(%rbp), %rdi
callq 0x1dc900
leaq -0x100(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1cb520
leaq -0xc0(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb0(%rbp), %rdi
callq 0x1d7290
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
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_owners.cpp |
8,221 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::reduce_data_to_owners<double>(Omega_h::Read<double>, Omega_h::Dist, int)::'lambda'(int)>(int, double const&, char const*) | 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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1c6d30
movq -0x90(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x74(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %edi
movl -0x78(%rbp), %esi
callq 0x1c5490
jmp 0x4dfc89
leaq -0x70(%rbp), %rdi
callq 0x1e1e00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e1e00
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,222 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::reduce_data_to_owners<signed char>(Omega_h::Read<signed char>, Omega_h::Dist, int)::'lambda'(int)>(signed char, signed char, Omega_h::Read<signed char> Omega_h::reduce_data_to_owners<signed char>(Omega_h::Read<signed char>, Omega_h::Dist, int)::'lambda'(int)&&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0x4dfdd8
jmp 0x4dfe6a
movq 0x217ea9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1e2f10
movq 0x217e92(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4dfe61
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1ca5c0
jmp 0x4dfe30
jmp 0x4dfe32
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4dfdf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1d6660
jmp 0x4dfe73
leaq -0x78(%rbp), %rdi
callq 0x1d6660
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,223 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::reduce_data_to_owners<int>(Omega_h::Read<int>, Omega_h::Dist, int)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::reduce_data_to_owners<int>(Omega_h::Read<int>, Omega_h::Dist, int)::'lambda'(int)&&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0x4e0128
jmp 0x4e01ba
movq 0x217b59(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1d7b70
movq 0x217b42(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4e01b1
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1e0f20
jmp 0x4e0180
jmp 0x4e0182
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4e0149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c3a10
jmp 0x4e01c3
leaq -0x78(%rbp), %rdi
callq 0x1c3a10
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,224 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::reduce_data_to_owners<long>(Omega_h::Read<long>, Omega_h::Dist, int)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::reduce_data_to_owners<long>(Omega_h::Read<long>, Omega_h::Dist, int)::'lambda'(int)&&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0x4e0478
jmp 0x4e050a
movq 0x217809(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1d3bc0
movq 0x2177f2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4e0501
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1bed10
jmp 0x4e04d0
jmp 0x4e04d2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4e0499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1bd0b0
jmp 0x4e0513
leaq -0x78(%rbp), %rdi
callq 0x1bd0b0
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,225 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::reduce_data_to_owners<double>(Omega_h::Read<double>, Omega_h::Dist, int)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::reduce_data_to_owners<double>(Omega_h::Read<double>, Omega_h::Dist, int)::'lambda'(int)&&) | 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; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %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 0x4e07c8
jmp 0x4e085a
movq 0x2174b9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1bbab0
movq 0x2174a2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4e0851
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1e3de0
jmp 0x4e0820
jmp 0x4e0822
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x4e07e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e1e00
jmp 0x4e0863
leaq -0x78(%rbp), %rdi
callq 0x1e1e00
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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_for.hpp |
8,226 | Omega_h::Parser::Parser(std::shared_ptr<Omega_h::Grammar const>, int) | Parser::Parser(GrammarPtr g, int nstates_reserve)
: grammar(g),
terminal_table(g->nterminals, nstates_reserve),
nonterminal_table(get_nnonterminals(*g), nstates_reserve) {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x1d6400
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
addq $0x10, %rax
movq %rax, -0x30(%rbp)
callq 0x1d7fc0
movq -0x30(%rbp), %rdi
movl 0x4(%rax), %esi
movl -0x14(%rbp), %edx
callq 0x1bc850
jmp 0x4e0a91
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x58(%rbp)
callq 0x1d2950
movq %rax, %rdi
callq 0x1d7140
movl %eax, -0x4c(%rbp)
jmp 0x4e0ab3
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0x1d51d0
jmp 0x4e0ac4
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4e0aed
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1ce0c0
movq -0x40(%rbp), %rdi
callq 0x1e3dc0
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,227 | Omega_h::get_nstates(Omega_h::Parser const&) | int get_nstates(Parser const& p) { return get_nrows(p.terminal_table); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1dde50
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,228 | Omega_h::add_state(Omega_h::Parser&) | int add_state(Parser& p) {
auto state = get_nstates(p);
resize(p.terminal_table, state + 1, get_ncols(p.terminal_table));
resize(p.nonterminal_table, state + 1, get_ncols(p.nonterminal_table));
for (int t = 0; t < p.grammar->nterminals; ++t) {
Action action;
action.kind = ACTION_NONE;
at(p.terminal_table, state, t) = action;
}
for (int nt = 0; nt < get_nnonterminals(*(p.grammar)); ++nt) {
at(p.nonterminal_table, state, nt) = -1;
}
return state;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf8c0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1bf7d0
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl %eax, %edx
callq 0x1bc490
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x1b9630
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl %eax, %edx
callq 0x1d2fa0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d7fc0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x4e0be5
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1c2480
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4e0b9f
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d2950
movq %rax, %rdi
callq 0x1d7140
movl %eax, %ecx
movl -0x40(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e0c30
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1e0d80
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e0bec
movl -0xc(%rbp), %eax
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_parser.cpp |
8,229 | Omega_h::add_terminal_action(Omega_h::Parser&, int, int, Omega_h::Action) | void add_terminal_action(Parser& p, int state, int terminal, Action action) {
OMEGA_H_CHECK(at(p.terminal_table, state, terminal).kind == ACTION_NONE);
OMEGA_H_CHECK(action.kind != ACTION_NONE);
if (action.kind == ACTION_SHIFT) {
OMEGA_H_CHECK(0 <= action.next_state);
OMEGA_H_CHECK(action.next_state < get_nstates(p));
} else {
OMEGA_H_CHECK(0 <= action.production);
OMEGA_H_CHECK(action.production < size(p.grammar->productions));
}
at(p.terminal_table, state, terminal) = action;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1c2480
cmpl $0x0, (%rax)
jne 0x4e0c70
jmp 0x4e0c91
leaq 0x14a3f1(%rip), %rdi # 0x62b068
leaq 0x1543c3(%rip), %rsi # 0x635041
leaq 0x1543f6(%rip), %rdx # 0x63507b
movl $0x1c, %ecx
movb $0x0, %al
callq 0x1ce550
cmpl $0x0, -0x8(%rbp)
je 0x4e0c99
jmp 0x4e0cba
leaq 0x14a3c8(%rip), %rdi # 0x62b068
leaq 0x154435(%rip), %rsi # 0x6350dc
leaq 0x1543cd(%rip), %rdx # 0x63507b
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
cmpl $0x1, -0x8(%rbp)
jne 0x4e0d27
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jg 0x4e0cc9
jmp 0x4e0cea
leaq 0x14a398(%rip), %rdi # 0x62b068
leaq 0x154420(%rip), %rsi # 0x6350f7
leaq 0x15439d(%rip), %rdx # 0x63507b
movl $0x1f, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bf8c0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e0d04
jmp 0x4e0d25
leaq 0x14a35d(%rip), %rdi # 0x62b068
leaq 0x1543fc(%rip), %rsi # 0x63510e
leaq 0x154362(%rip), %rdx # 0x63507b
movl $0x20, %ecx
movb $0x0, %al
callq 0x1ce550
jmp 0x4e0d9a
xorl %eax, %eax
cmpl -0x4(%rbp), %eax
jg 0x4e0d30
jmp 0x4e0d51
leaq 0x14a331(%rip), %rdi # 0x62b068
leaq 0x1543f3(%rip), %rsi # 0x635131
leaq 0x154336(%rip), %rdx # 0x63507b
movl $0x22, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1de720
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e0d77
jmp 0x4e0d98
leaq 0x14a2ea(%rip), %rdi # 0x62b068
leaq 0x1543c3(%rip), %rsi # 0x635148
leaq 0x1542ef(%rip), %rdx # 0x63507b
movl $0x23, %ecx
movb $0x0, %al
callq 0x1ce550
jmp 0x4e0d9a
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x1c2480
movq -0x8(%rbp), %rcx
movq %rcx, (%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 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,230 | Omega_h::add_nonterminal_action(Omega_h::Parser&, int, int, int) | void add_nonterminal_action(
Parser& p, int state, int nonterminal, int next_state) {
OMEGA_H_CHECK(0 <= next_state);
OMEGA_H_CHECK(next_state < get_nstates(p));
OMEGA_H_CHECK(at(p.nonterminal_table, state, nonterminal) == -1);
at(p.nonterminal_table, state, nonterminal) = next_state;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x4e0dde
jmp 0x4e0dff
leaq 0x14a283(%rip), %rdi # 0x62b068
leaq 0x15438d(%rip), %rsi # 0x635179
leaq 0x154288(%rip), %rdx # 0x63507b
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf8c0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e0e19
jmp 0x4e0e3a
leaq 0x14a248(%rip), %rdi # 0x62b068
leaq 0x1542ee(%rip), %rsi # 0x635115
leaq 0x15424d(%rip), %rdx # 0x63507b
movl $0x2b, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e0d80
cmpl $-0x1, (%rax)
jne 0x4e0e54
jmp 0x4e0e75
leaq 0x14a20d(%rip), %rdi # 0x62b068
leaq 0x154327(%rip), %rsi # 0x635189
leaq 0x154212(%rip), %rdx # 0x63507b
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e0d80
movl -0x1c(%rbp), %ecx
movl %ecx, (%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 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,231 | Omega_h::get_action(Omega_h::Parser const&, int, int) | Action const& get_action(Parser const& p, int state, int terminal) {
return at(p.terminal_table, state, terminal);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x1e41d0
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_parser.cpp |
8,232 | Omega_h::execute_action(Omega_h::Parser const&, std::vector<int, std::allocator<int>>&, Omega_h::Action const&) | int execute_action(
Parser const& p, std::vector<int>& stack, Action const& action) {
OMEGA_H_CHECK(action.kind != ACTION_NONE);
if (action.kind == ACTION_SHIFT) {
stack.push_back(action.next_state);
} else {
auto& prod = at(p.grammar->productions, action.production);
for (int i = 0; i < size(prod.rhs); ++i) stack.pop_back();
OMEGA_H_CHECK(p.grammar.get());
auto& grammar = *(p.grammar);
auto nt = as_nonterminal(grammar, prod.lhs);
OMEGA_H_CHECK(!stack.empty());
auto next_state = at(p.nonterminal_table, stack.back(), nt);
stack.push_back(next_state);
}
return stack.back();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4e0eef
jmp 0x4e0f10
leaq 0x14a172(%rip), %rdi # 0x62b068
leaq 0x1541df(%rip), %rsi # 0x6350dc
leaq 0x154177(%rip), %rdx # 0x63507b
movl $0x36, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4e0f2f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x1ba3d0
jmp 0x4e103c
movq -0x8(%rbp), %rdi
callq 0x1d7fc0
movq %rax, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1cb3f0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cf2d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e0f86
movq -0x10(%rbp), %rdi
callq 0x1ded30
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4e0f56
movq -0x8(%rbp), %rdi
callq 0x1c19b0
cmpq $0x0, %rax
je 0x4e0f97
jmp 0x4e0fb8
leaq 0x14a0ca(%rip), %rdi # 0x62b068
leaq 0x154216(%rip), %rsi # 0x6351bb
leaq 0x1540cf(%rip), %rdx # 0x63507b
movl $0x3c, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1d2950
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x1d4d80
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c8180
testb $0x1, %al
jne 0x4e0fe6
jmp 0x4e1007
leaq 0x14a07b(%rip), %rdi # 0x62b068
leaq 0x14c530(%rip), %rsi # 0x62d524
leaq 0x154080(%rip), %rdx # 0x63507b
movl $0x3f, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddda0
movq -0x48(%rbp), %rdi
movl (%rax), %esi
movl -0x34(%rbp), %edx
callq 0x1bcf90
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1ba3d0
movq -0x10(%rbp), %rdi
callq 0x1ddda0
movl (%rax), %eax
addq $0x50, %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_parser.cpp |
8,233 | Omega_h::get_grammar(Omega_h::Parser const&) | GrammarPtr const& get_grammar(Parser const& p) { return p.grammar; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,234 | Omega_h::ParserFail::ParserFail(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ParserFail::ParserFail(const std::string& msg) : std::invalid_argument(msg) {} | 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 0x1ce7a0
movq -0x18(%rbp), %rax
movq 0x216b8c(%rip), %rcx # 0x6f7c18
addq $0x10, %rcx
movq %rcx, (%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 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,235 | Omega_h::ParserFail::out_of_line_virtual_method() | void ParserFail::out_of_line_virtual_method() {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser.cpp |
8,236 | Omega_h::Table<Omega_h::Action>::Table(int, int) | Table(int ncols_init, int nrows_reserve) : ncols(ncols_init) {
OMEGA_H_CHECK(0 <= ncols_init);
reserve(data, ncols * nrows_reserve);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1c3160
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x4e10e2
jmp 0x4e111c
leaq 0x149f7f(%rip), %rdi # 0x62b068
leaq 0x14ff93(%rip), %rsi # 0x631083
leaq 0x14ff9c(%rip), %rdx # 0x631093
xorl %eax, %eax
movl $0x11, %ecx
callq 0x1ce550
jmp 0x4e1105
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1c69c0
jmp 0x4e1136
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %esi
movl -0x10(%rbp), %eax
imull %eax, %esi
callq 0x1dac10
jmp 0x4e1130
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_table.hpp |
8,237 | int Omega_h::get_nrows<Omega_h::Action>(Omega_h::Table<Omega_h::Action> const&) | int get_nrows(Table<T> const& t) {
OMEGA_H_CHECK(t.ncols > 0);
OMEGA_H_CHECK(size(t.data) % t.ncols == 0);
return size(t.data) / t.ncols;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x4e1158
jmp 0x4e1179
leaq 0x149f09(%rip), %rdi # 0x62b068
leaq 0x14ff8d(%rip), %rsi # 0x6310f3
leaq 0x14ff26(%rip), %rdx # 0x631093
movl $0x18, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1c60d0
movq -0x8(%rbp), %rcx
cltd
idivl 0x18(%rcx)
cmpl $0x0, %edx
jne 0x4e1191
jmp 0x4e11b2
leaq 0x149ed0(%rip), %rdi # 0x62b068
leaq 0x14ff60(%rip), %rsi # 0x6310ff
leaq 0x14feed(%rip), %rdx # 0x631093
movl $0x19, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
callq 0x1c60d0
movq -0x8(%rbp), %rcx
cltd
idivl 0x18(%rcx)
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_table.hpp |
8,238 | void Omega_h::resize<Omega_h::Action>(Omega_h::Table<Omega_h::Action>&, int, int) | void resize(Table<T>& t, int new_nrows, int new_ncols) {
OMEGA_H_CHECK(new_ncols == t.ncols); // pretty specialized right now
Omega_h::resize(t.data, new_nrows * t.ncols);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x4e11f0
jmp 0x4e1211
leaq 0x149e71(%rip), %rdi # 0x62b068
leaq 0x14ff1d(%rip), %rsi # 0x63111b
leaq 0x14fe8e(%rip), %rdx # 0x631093
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
callq 0x1c3950
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_table.hpp |
8,239 | int Omega_h::get_ncols<Omega_h::Action>(Omega_h::Table<Omega_h::Action> const&) | int get_ncols(Table<T> const& t) {
return t.ncols;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
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 | gahansen[P]omega_h/src/Omega_h_table.hpp |
8,240 | Omega_h::Table<Omega_h::Action>::Ref Omega_h::at<Omega_h::Action>(Omega_h::Table<Omega_h::Action>&, int, int) | typename Table<T>::Ref at(Table<T>& t, int row, int col) {
OMEGA_H_CHECK(0 <= col);
OMEGA_H_CHECK(col < t.ncols);
OMEGA_H_CHECK(0 <= row);
OMEGA_H_CHECK(row < get_nrows(t));
return Omega_h::at(t.data, row * t.ncols + col);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x4e126b
jmp 0x4e128c
leaq 0x149df6(%rip), %rdi # 0x62b068
leaq 0x14feb7(%rip), %rsi # 0x631130
leaq 0x14fe13(%rip), %rdx # 0x631093
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4e129a
jmp 0x4e12bb
leaq 0x149dc7(%rip), %rdi # 0x62b068
leaq 0x14fe91(%rip), %rsi # 0x631139
leaq 0x14fde4(%rip), %rdx # 0x631093
movl $0x2b, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x4e12c4
jmp 0x4e12e5
leaq 0x149d9d(%rip), %rdi # 0x62b068
leaq 0x14fe75(%rip), %rsi # 0x631147
leaq 0x14fdba(%rip), %rdx # 0x631093
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dde50
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e12ff
jmp 0x4e1320
leaq 0x149d62(%rip), %rdi # 0x62b068
leaq 0x14fe43(%rip), %rsi # 0x631150
leaq 0x14fd7f(%rip), %rdx # 0x631093
movl $0x2d, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
addl -0x10(%rbp), %esi
callq 0x1cb390
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_table.hpp |
8,241 | Omega_h::Table<Omega_h::Action>::ConstRef Omega_h::at<Omega_h::Action>(Omega_h::Table<Omega_h::Action> const&, int, int) | typename Table<T>::ConstRef at(Table<T> const& t, int row, int col) {
OMEGA_H_CHECK(0 <= col);
OMEGA_H_CHECK(col < t.ncols);
OMEGA_H_CHECK(0 <= row);
OMEGA_H_CHECK(row < get_nrows(t));
return Omega_h::at(t.data, row * t.ncols + col);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x4e135b
jmp 0x4e137c
leaq 0x149d06(%rip), %rdi # 0x62b068
leaq 0x14fdc7(%rip), %rsi # 0x631130
leaq 0x14fd23(%rip), %rdx # 0x631093
movl $0x33, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x4e138a
jmp 0x4e13ab
leaq 0x149cd7(%rip), %rdi # 0x62b068
leaq 0x14fda1(%rip), %rsi # 0x631139
leaq 0x14fcf4(%rip), %rdx # 0x631093
movl $0x34, %ecx
movb $0x0, %al
callq 0x1ce550
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x4e13b4
jmp 0x4e13d5
leaq 0x149cad(%rip), %rdi # 0x62b068
leaq 0x14fd85(%rip), %rsi # 0x631147
leaq 0x14fcca(%rip), %rdx # 0x631093
movl $0x35, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dde50
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e13ef
jmp 0x4e1410
leaq 0x149c72(%rip), %rdi # 0x62b068
leaq 0x14fd53(%rip), %rsi # 0x631150
leaq 0x14fc8f(%rip), %rdx # 0x631093
movl $0x36, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
imull 0x18(%rax), %esi
addl -0x10(%rbp), %esi
callq 0x1d4c30
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_table.hpp |
8,242 | std::vector<int, std::allocator<int>>::pop_back() | void
pop_back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
--this->_M_impl._M_finish;
_Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
_GLIBCXX_ASAN_ANNOTATE_SHRINK(1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x8(%rdi), %rax
addq $-0x4, %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rdi), %rsi
callq 0x1baf50
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 |
8,243 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1de6f0
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 |
8,244 | void Omega_h::reserve<Omega_h::Action>(std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>&, int) | inline void reserve(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.reserve(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x4e14c8
jmp 0x4e14e9
leaq 0x149b99(%rip), %rdi # 0x62b068
leaq 0x14c190(%rip), %rsi # 0x62d666
leaq 0x14bce7(%rip), %rdx # 0x62d1c4
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1b8ef0
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 |
8,245 | std::_Vector_base<Omega_h::Action, std::allocator<Omega_h::Action>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7470
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 |
8,246 | std::_Vector_base<Omega_h::Action, std::allocator<Omega_h::Action>>::_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 0x1caa30
movq -0x10(%rbp), %rdi
callq 0x1d8930
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 |
8,247 | std::allocator<Omega_h::Action>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d7420
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 |
8,248 | _gnu_cxx::new_allocator<Omega_h::Action>::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 |
8,249 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::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 0x1d8e40
movq %rax, %rdi
callq 0x1cab60
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 |
8,250 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::capacity() const | size_type
capacity() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_end_of_storage
- this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,251 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::_S_relocate(Omega_h::Action*, Omega_h::Action*, Omega_h::Action*, std::allocator<Omega_h::Action>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1bf030
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,252 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::_S_max_size(std::allocator<Omega_h::Action> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0xfffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFFF
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b9a70
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq %rax, -0x20(%rbp)
jmp 0x4e174a
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,253 | std::allocator_traits<std::allocator<Omega_h::Action>>::max_size(std::allocator<Omega_h::Action> 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 0x1c3c80
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 |
8,254 | _gnu_cxx::new_allocator<Omega_h::Action>::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 0x1c0430
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 |
8,255 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::_S_do_relocate(Omega_h::Action*, Omega_h::Action*, Omega_h::Action*, std::allocator<Omega_h::Action>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1cecc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,256 | Omega_h::Action* std::__relocate_a<Omega_h::Action*, Omega_h::Action*, std::allocator<Omega_h::Action>>(Omega_h::Action*, Omega_h::Action*, Omega_h::Action*, std::allocator<Omega_h::Action>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ddbd0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddbd0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ddbd0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1cc3f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
8,257 | std::enable_if<std::__is_bitwise_relocatable<Omega_h::Action>::value, Omega_h::Action*>::type std::__relocate_a_1<Omega_h::Action, Omega_h::Action>(Omega_h::Action*, Omega_h::Action*, Omega_h::Action*, std::allocator<Omega_h::Action>&) | inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
__relocate_a_1(_Tp* __first, _Tp* __last,
_Tp* __result, allocator<_Up>&) noexcept
{
ptrdiff_t __count = __last - __first;
if (__count > 0)
__builtin_memmove(__result, __first, __count * sizeof(_Tp));
return __result + __count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x4e1887
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
shlq $0x3, %rdx
callq 0x1dc5a0
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
8,258 | int Omega_h::size<Omega_h::Action>(std::vector<Omega_h::Action, std::allocator<Omega_h::Action>> 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 0x1bf600
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 |
8,259 | void Omega_h::resize<Omega_h::Action>(std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>&, int) | inline void resize(std::vector<T>& v, int n) {
OMEGA_H_CHECK(0 <= n);
v.resize(std::size_t(n));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpl -0xc(%rbp), %eax
jg 0x4e18d8
jmp 0x4e18f9
leaq 0x149789(%rip), %rdi # 0x62b068
leaq 0x14bd80(%rip), %rsi # 0x62d666
leaq 0x14b8d7(%rip), %rdx # 0x62d1c4
movl $0x24, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1c9190
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 |
8,260 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::resize(unsigned long) | void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1bf600
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4e1964
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1bf600
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
subq %rax, %rsi
callq 0x1d4f90
jmp 0x4e199a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1bf600
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x4e1998
movq -0x20(%rbp), %rdi
movq (%rdi), %rsi
movq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1d89d0
jmp 0x4e199a
addq $0x30, %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_vector.h |
8,261 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::_M_erase_at_end(Omega_h::Action*) | void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e1c39
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x1d7010
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1d0a40
jmp 0x4e1c2d
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,262 | Omega_h::Action* std::__uninitialized_default_n_a<Omega_h::Action*, unsigned long, Omega_h::Action>(Omega_h::Action*, unsigned long, std::allocator<Omega_h::Action>&) | inline _ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
{ return std::__uninitialized_default_n(__first, __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
callq 0x1bc570
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_uninitialized.h |
8,263 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1bb000
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1bf600
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x4e1cc7
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1bf600
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1bf600
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1bf600
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x4e1d36
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1bb000
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4e1d45
movq -0x38(%rbp), %rdi
callq 0x1bb000
movq %rax, -0x58(%rbp)
jmp 0x4e1d4d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,264 | Omega_h::Action* std::__uninitialized_default_n<Omega_h::Action*, unsigned long>(Omega_h::Action*, unsigned long) | inline _ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
// See uninitialized_fill_n for the conditions for using std::fill_n.
constexpr bool __can_fill
= __and_<is_integral<_Size>, is_copy_assignable<_ValueType>>::value;
return __uninitialized_default_n_1<__is_trivial(_ValueType)
&& __can_fill>::
__uninit_default_n(__first, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ba580
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_uninitialized.h |
8,265 | Omega_h::Action* std::__uninitialized_default_n_1<true>::__uninit_default_n<Omega_h::Action*, unsigned long>(Omega_h::Action*, unsigned long) | static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
{
if (__n > 0)
{
typename iterator_traits<_ForwardIterator>::value_type* __val
= std::__addressof(*__first);
std::_Construct(__val);
++__first;
__first = std::fill_n(__first, __n - 1, *__val);
}
return __first;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x4e1ddd
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d52e0
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0x1bda30
movq %rax, -0x8(%rbp)
movq -0x8(%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_uninitialized.h |
8,266 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::reference Omega_h::at<Omega_h::Action>(std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>&, 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 0x4e1f78
jmp 0x4e1f99
leaq 0x1490e9(%rip), %rdi # 0x62b068
leaq 0x14b237(%rip), %rsi # 0x62d1bd
leaq 0x14b237(%rip), %rdx # 0x62d1c4
movl $0x13, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1bb8b0
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 |
8,267 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %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/bits/stl_vector.h |
8,268 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::const_reference Omega_h::at<Omega_h::Action>(std::vector<Omega_h::Action, std::allocator<Omega_h::Action>> 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 0x4e1fe8
jmp 0x4e2009
leaq 0x149079(%rip), %rdi # 0x62b068
leaq 0x14b1c7(%rip), %rsi # 0x62d1bd
leaq 0x14b1c7(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf600
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e2024
jmp 0x4e2045
leaq 0x14903d(%rip), %rdi # 0x62b068
leaq 0x14b25f(%rip), %rsi # 0x62d291
leaq 0x14b18b(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1dcb70
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 |
8,269 | std::vector<Omega_h::Action, std::allocator<Omega_h::Action>>::operator[](unsigned long) const | const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %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/bits/stl_vector.h |
8,270 | Omega_h::make_graph_with_nnodes(int) | ParserGraph make_graph_with_nnodes(int nnodes) {
return ParserGraph(std::size_t(nnodes));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0xd(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1d9be0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1b83f0
jmp 0x4e20c2
leaq -0xd(%rbp), %rdi
callq 0x1dc0f0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x1dc0f0
movq -0x18(%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_parser_graph.cpp |
8,271 | Omega_h::get_nnodes(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | int get_nnodes(ParserGraph const& g) { return size(g); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d94f0
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_parser_graph.cpp |
8,272 | Omega_h::add_edge(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int, int) | void add_edge(ParserGraph& g, int i, int j) { at(g, i).push_back(j); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c8aa0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1ba3d0
addq $0x10, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser_graph.cpp |
8,273 | Omega_h::get_edges(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, int) | NodeEdges const& get_edges(ParserGraph const& g, int i) { return at(g, i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d0190
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 | gahansen[P]omega_h/src/Omega_h_parser_graph.cpp |
8,274 | Omega_h::get_edges(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, int) | NodeEdges& get_edges(ParserGraph& g, int i) { return at(g, i); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1c8aa0
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 | gahansen[P]omega_h/src/Omega_h_parser_graph.cpp |
8,275 | Omega_h::make_transpose(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | ParserGraph make_transpose(ParserGraph const& g) {
auto nnodes = get_nnodes(g);
auto transpose = make_graph_with_nnodes(nnodes);
for (int i = 0; i < nnodes; ++i) {
for (auto j : get_edges(g, i)) {
add_edge(transpose, j, i);
}
}
return transpose;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d8c10
movq -0x58(%rbp), %rdi
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
movl -0x14(%rbp), %esi
callq 0x1b98c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4e2294
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1c4c90
movq %rax, -0x68(%rbp)
jmp 0x4e220c
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1d7aa0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1d71d0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c07d0
testb $0x1, %al
jne 0x4e2241
jmp 0x4e2284
leaq -0x40(%rbp), %rdi
callq 0x1ddbe0
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x1df3a0
jmp 0x4e2260
jmp 0x4e2262
leaq -0x40(%rbp), %rdi
callq 0x1c0500
jmp 0x4e222e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1dd000
jmp 0x4e22b1
jmp 0x4e2286
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4e21ee
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x4e22a7
movq -0x58(%rbp), %rdi
callq 0x1dd000
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1dfa40
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_parser_graph.cpp |
8,276 | Omega_h::at(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, int, int) | int at(ParserGraph const& g, int i, int j) { return at(at(g, i), j); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d0190
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x1c57d0
movl (%rax), %eax
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 | gahansen[P]omega_h/src/Omega_h_parser_graph.cpp |
8,277 | Omega_h::operator<<(std::ostream&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&) | std::ostream& operator<<(std::ostream& os, ParserGraph const& g) {
for (int i = 0; i < get_nnodes(g); ++i) {
os << i << ":";
for (auto j : get_edges(g, i)) os << " " << j;
os << '\n';
}
return os;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d8c10
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e23db
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1deb20
movq %rax, %rdi
leaq 0x148f2c(%rip), %rsi # 0x62b275
callq 0x1cd8f0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c4c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d7aa0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d71d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c07d0
testb $0x1, %al
jne 0x4e238b
jmp 0x4e23bf
leaq -0x28(%rbp), %rdi
callq 0x1ddbe0
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1505e2(%rip), %rsi # 0x632986
callq 0x1cd8f0
movq %rax, %rdi
movl -0x34(%rbp), %esi
callq 0x1deb20
leaq -0x28(%rbp), %rdi
callq 0x1c0500
jmp 0x4e2378
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e2317
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_parser_graph.cpp |
8,278 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::vector(unsigned long, std::allocator<std::vector<int, std::allocator<int>>> const&) | explicit
vector(size_type __n, const allocator_type& __a = allocator_type())
: _Base(_S_check_init_len(__n, __a), __a)
{ _M_default_initialize(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d1f20
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1d9ca0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e2150
jmp 0x4e2438
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1d1fe0
movq -0x20(%rbp), %rdi
callq 0x1dfa40
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 |
8,279 | int Omega_h::size<std::vector<int, std::allocator<int>>>(std::vector<std::vector<int, std::allocator<int>>, std::allocator<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 0x1c3600
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 |
8,280 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::const_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>>>> 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 0x4e2498
jmp 0x4e24b9
leaq 0x148bc9(%rip), %rdi # 0x62b068
leaq 0x14ad17(%rip), %rsi # 0x62d1bd
leaq 0x14ad17(%rip), %rdx # 0x62d1c4
movl $0x1d, %ecx
movb $0x0, %al
callq 0x1ce550
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c3600
movq %rax, %rcx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x4e24d4
jmp 0x4e24f5
leaq 0x148b8d(%rip), %rdi # 0x62b068
leaq 0x14adaf(%rip), %rsi # 0x62d291
leaq 0x14acdb(%rip), %rdx # 0x62d1c4
movl $0x1e, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1cd4b0
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 |
8,281 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::_S_check_init_len(unsigned long, std::allocator<std::vector<int, std::allocator<int>>> const&) | static size_type
_S_check_init_len(size_type __n, const allocator_type& __a)
{
if (__n > _S_max_size(_Tp_alloc_type(__a)))
__throw_length_error(
__N("cannot create std::vector larger than max_size()"));
return __n;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0x1e24c0
leaq -0x11(%rbp), %rdi
callq 0x1d9dc0
movq %rax, -0x28(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1dc0f0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4e2564
leaq 0x14a283(%rip), %rdi # 0x62c7e2
callq 0x1c2520
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,282 | std::_Vector_base<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::_Vector_base(unsigned long, std::allocator<std::vector<int, std::allocator<int>>> const&) | _Vector_base(size_t __n, const allocator_type& __a)
: _M_impl(__a)
{ _M_create_storage(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1cb9d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d8de0
jmp 0x4e25a4
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c7410
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,283 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::_M_default_initialize(unsigned long) | void
_M_default_initialize(size_type __n)
{
this->_M_impl._M_finish =
std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
_M_get_Tp_allocator());
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1e01a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x1c9f90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,284 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::_S_max_size(std::allocator<std::vector<int, std::allocator<int>>> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x555555555555555, %rax # imm = 0x555555555555555
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bcc30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq %rax, -0x20(%rbp)
jmp 0x4e265a
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,285 | std::allocator_traits<std::allocator<std::vector<int, std::allocator<int>>>>::max_size(std::allocator<std::vector<int, std::allocator<int>>> 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 0x1d01c0
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 |
8,286 | _gnu_cxx::new_allocator<std::vector<int, std::allocator<int>>>::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 0x1d6f80
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 |
8,287 | std::_Vector_base<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4e2752
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dd8b0
movq %rax, -0x20(%rbp)
jmp 0x4e275a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x4e275a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,288 | std::allocator_traits<std::allocator<std::vector<int, std::allocator<int>>>>::allocate(std::allocator<std::vector<int, std::allocator<int>>>&, 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 0x1b9e70
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 |
8,289 | _gnu_cxx::new_allocator<std::vector<int, std::allocator<int>>>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1d6f80
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4e27eb
movabsq $0xaaaaaaaaaaaaaaa, %rax # imm = 0xAAAAAAAAAAAAAAA
cmpq %rax, -0x10(%rbp)
jbe 0x4e27e6
callq 0x1c85c0
callq 0x1be740
imulq $0x18, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
8,290 | std::vector<int, std::allocator<int>>* std::__uninitialized_default_n_a<std::vector<int, std::allocator<int>>*, unsigned long, std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>>*, unsigned long, std::allocator<std::vector<int, std::allocator<int>>>&) | inline _ForwardIterator
__uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
allocator<_Tp>&)
{ return std::__uninitialized_default_n(__first, __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
callq 0x1dd6c0
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_uninitialized.h |
8,291 | std::vector<int, std::allocator<int>>* std::__uninitialized_default_n<std::vector<int, std::allocator<int>>*, unsigned long>(std::vector<int, std::allocator<int>>*, unsigned long) | inline _ForwardIterator
__uninitialized_default_n(_ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType;
// See uninitialized_fill_n for the conditions for using std::fill_n.
constexpr bool __can_fill
= __and_<is_integral<_Size>, is_copy_assignable<_ValueType>>::value;
return __uninitialized_default_n_1<__is_trivial(_ValueType)
&& __can_fill>::
__uninit_default_n(__first, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b9210
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_uninitialized.h |
8,292 | std::vector<int, std::allocator<int>>* std::__uninitialized_default_n_1<false>::__uninit_default_n<std::vector<int, std::allocator<int>>*, unsigned long>(std::vector<int, std::allocator<int>>*, unsigned long) | static _ForwardIterator
__uninit_default_n(_ForwardIterator __first, _Size __n)
{
_ForwardIterator __cur = __first;
__try
{
for (; __n > 0; --__n, (void) ++__cur)
std::_Construct(std::__addressof(*__cur));
return __cur;
}
__catch(...)
{
std::_Destroy(__first, __cur);
__throw_exception_again;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x4e28d1
movq -0x18(%rbp), %rdi
callq 0x1c5fb0
jmp 0x4e288a
jmp 0x4e288c
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e2878
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1bf6c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cbb40
jmp 0x4e28ca
callq 0x1d87c0
jmp 0x4e2901
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1dc770
jmp 0x4e28ee
jmp 0x4e28f0
movq -0x20(%rbp), %rdi
callq 0x1dfa40
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_uninitialized.h |
8,293 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,294 | std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>::operator[](unsigned long) const | const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
8,295 | Omega_h::Pool::Pool(std::function<void* (unsigned long)>, std::function<void (void*, unsigned long)>) | Pool::Pool(MallocFunc malloc_in, FreeFunc free_in)
: underlying_malloc(malloc_in), underlying_free(free_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x600, %rcx # imm = 0x600
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1b9770
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x4e29c9
movq -0x40(%rbp), %rax
addq $0x600, %rax # imm = 0x600
movq %rax, -0x70(%rbp)
movq %rax, %rcx
addq $0x600, %rcx # imm = 0x600
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1b9770
movq -0x78(%rbp), %rax
movq -0x68(%rbp), %rcx
addq $0x18, %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x4e2a0b
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0xc00, %rdi # imm = 0xC00
movq %rdi, -0x80(%rbp)
callq 0x1dd3e0
jmp 0x4e2a47
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0xc20, %rdi # imm = 0xC20
callq 0x1ba850
jmp 0x4e2a5d
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4e2a89
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c1c60
movq -0x70(%rbp), %rax
addq $0x600, %rax # imm = 0x600
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x90(%rbp)
callq 0x1ddff0
movq -0x70(%rbp), %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x88(%rbp)
jne 0x4e2a9a
movq -0x40(%rbp), %rax
addq $0x600, %rax # imm = 0x600
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1ddff0
movq -0x40(%rbp), %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x98(%rbp)
jne 0x4e2ad9
jmp 0x4e2b09
movq -0x20(%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_pool.cpp |
8,296 | Omega_h::Pool::~Pool() | Pool::~Pool() {
call_underlying_frees(*this, used_blocks);
call_underlying_frees(*this, free_blocks);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
movq %rsi, %rdi
callq 0x4e2bf0
jmp 0x4e2b3e
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x600, %rsi # imm = 0x600
callq 0x4e2bf0
jmp 0x4e2b53
movq -0x10(%rbp), %rdi
addq $0xc20, %rdi # imm = 0xC20
callq 0x1c67f0
movq -0x10(%rbp), %rdi
addq $0xc00, %rdi # imm = 0xC00
callq 0x1c1c60
movq -0x10(%rbp), %rax
addq $0x600, %rax # imm = 0x600
movq %rax, -0x20(%rbp)
addq $0x600, %rax # imm = 0x600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x28(%rbp)
callq 0x1ddff0
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x18(%rbp)
jne 0x4e2b8b
movq -0x10(%rbp), %rax
addq $0x600, %rax # imm = 0x600
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x1ddff0
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x4e2bbb
addq $0x40, %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 | gahansen[P]omega_h/src/Omega_h_pool.cpp |
8,297 | Omega_h::call_underlying_frees(Omega_h::Pool&, std::vector<void*, std::allocator<void*>>*) | static void call_underlying_frees(Pool& pool, BlockList list[]) {
for (std::size_t i = 0; i < 64; ++i) {
for (auto block : list[i]) {
pool.underlying_free(block, (std::size_t(1) << i));
}
list[i].clear();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jae 0x4e2cad
movq -0x10(%rbp), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b9c80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d1a40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c1c50
testb $0x1, %al
jne 0x4e2c50
jmp 0x4e2c8b
leaq -0x28(%rbp), %rdi
callq 0x1d8660
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc20, %rdi # imm = 0xC20
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
callq 0x1da9c0
leaq -0x28(%rbp), %rdi
callq 0x1dc020
jmp 0x4e2c3d
movq -0x10(%rbp), %rdi
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rdi
callq 0x1c3690
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e2c08
addq $0x40, %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_pool.cpp |
8,298 | Omega_h::allocate(Omega_h::Pool&, unsigned long) | void* allocate(Pool& pool, std::size_t size) {
ScopedTimer timer("pool allocate");
std::size_t shift;
for (shift = 0; ((std::size_t(1) << shift) < size); ++shift)
;
if (!pool.free_blocks[shift].empty()) {
auto const data = pool.free_blocks[shift].back();
pool.used_blocks[shift].push_back(data);
pool.free_blocks[shift].pop_back();
return data;
}
auto const size_to_alloc = (std::size_t(1) << shift);
auto data = pool.underlying_malloc(size_to_alloc);
if (data == nullptr) {
call_underlying_frees(pool, pool.free_blocks);
data = pool.underlying_malloc(size_to_alloc);
}
if (data == nullptr) {
Omega_h_fail(
"Pool failed to allocate %zu bytes, %zu bytes already allocated\n",
size_to_alloc, underlying_total_size(pool));
}
pool.used_blocks[shift].push_back(data);
return data;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x19(%rbp), %rdi
leaq 0x152519(%rip), %rsi # 0x6351f4
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
cmpq -0x18(%rbp), %rax
jae 0x4e2d0e
jmp 0x4e2d00
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4e2cec
movq -0x10(%rbp), %rdi
addq $0x600, %rdi # imm = 0x600
imulq $0x18, -0x28(%rbp), %rax
addq %rax, %rdi
callq 0x1b89e0
testb $0x1, %al
jne 0x4e2daf
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq 0x600(%rax,%rcx,8), %rdi
callq 0x1cd420
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1cc7e0
jmp 0x4e2d69
movq -0x10(%rbp), %rdi
addq $0x600, %rdi # imm = 0x600
imulq $0x18, -0x28(%rbp), %rax
addq %rax, %rdi
callq 0x1bc270
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x4e2e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
jmp 0x4e2e91
movb -0x28(%rbp), %cl
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0xc00, %rdi # imm = 0xC00
movq -0x48(%rbp), %rsi
callq 0x1d22f0
movq %rax, -0x58(%rbp)
jmp 0x4e2dd8
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x4e2e1e
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x600, %rsi # imm = 0x600
callq 0x4e2bf0
jmp 0x4e2dfc
movq -0x10(%rbp), %rdi
addq $0xc00, %rdi # imm = 0xC00
movq -0x48(%rbp), %rsi
callq 0x1d22f0
movq %rax, -0x60(%rbp)
jmp 0x4e2e16
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x4e2e54
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4e2ea0
movq %rax, -0x68(%rbp)
jmp 0x4e2e3c
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rsi
leaq 0x1523b7(%rip), %rdi # 0x635202
xorl %eax, %eax
callq 0x1ce550
jmp 0x4e2e54
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1cc7e0
jmp 0x4e2e6f
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1d03d0
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
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_pool.cpp |
8,299 | Omega_h::underlying_total_size(Omega_h::Pool&) | static std::size_t underlying_total_size(Pool& pool) {
std::size_t total_size = 0;
for (std::size_t i = 0; i < 64; ++i) {
total_size += (std::size_t(1) << i) * pool.used_blocks[i].size();
total_size += (std::size_t(1) << i) * pool.free_blocks[i].size();
}
return total_size;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jae 0x4e2f47
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rdi
callq 0x1ce850
movq %rax, %rcx
movq -0x28(%rbp), %rax
imulq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x600, %rdi # imm = 0x600
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rdi
callq 0x1ce850
movq %rax, %rcx
movq -0x20(%rbp), %rax
imulq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e2ebc
movq -0x10(%rbp), %rax
addq $0x30, %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_pool.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.