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 |
|---|---|---|---|---|---|---|
700 | void Omega_h::amr::transfer_inherit<signed char>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void transfer_inherit(Mesh* old_mesh, Mesh* new_mesh,
Few<LOs, 4> const prods2new_ents, Few<LOs, 4> same_ents2old_ents,
Few<LOs, 4> same_ents2new_ents, std::string const& name) {
Few<Write<T>, 4> new_data;
auto ncomps = old_mesh->get_tag<T>(0, name)->ncomps();
for (Int prod_dim = 0; prod_dim <= old_mesh->... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdx, -0x2d0(%rbp)
movq %rcx, -0x2c8(%rbp)
movq %r8, -0x2c0(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %r8, -0xa8(%rbp)
movq %r9, -0xb0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1dead0
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_amr_transfer.cpp |
701 | void Omega_h::amr::transfer_inherit<int>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void transfer_inherit(Mesh* old_mesh, Mesh* new_mesh,
Few<LOs, 4> const prods2new_ents, Few<LOs, 4> same_ents2old_ents,
Few<LOs, 4> same_ents2new_ents, std::string const& name) {
Few<Write<T>, 4> new_data;
auto ncomps = old_mesh->get_tag<T>(0, name)->ncomps();
for (Int prod_dim = 0; prod_dim <= old_mesh->... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdx, -0x2d0(%rbp)
movq %rcx, -0x2c8(%rbp)
movq %r8, -0x2c0(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %r8, -0xa8(%rbp)
movq %r9, -0xb0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1c8230
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_amr_transfer.cpp |
702 | void Omega_h::amr::transfer_inherit<long>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void transfer_inherit(Mesh* old_mesh, Mesh* new_mesh,
Few<LOs, 4> const prods2new_ents, Few<LOs, 4> same_ents2old_ents,
Few<LOs, 4> same_ents2new_ents, std::string const& name) {
Few<Write<T>, 4> new_data;
auto ncomps = old_mesh->get_tag<T>(0, name)->ncomps();
for (Int prod_dim = 0; prod_dim <= old_mesh->... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdx, -0x2d0(%rbp)
movq %rcx, -0x2c8(%rbp)
movq %r8, -0x2c0(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %r8, -0xa8(%rbp)
movq %r9, -0xb0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1d0140
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_amr_transfer.cpp |
703 | void Omega_h::amr::transfer_inherit<double>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void transfer_inherit(Mesh* old_mesh, Mesh* new_mesh,
Few<LOs, 4> const prods2new_ents, Few<LOs, 4> same_ents2old_ents,
Few<LOs, 4> same_ents2new_ents, std::string const& name) {
Few<Write<T>, 4> new_data;
auto ncomps = old_mesh->get_tag<T>(0, name)->ncomps();
for (Int prod_dim = 0; prod_dim <= old_mesh->... | pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp # imm = 0x330
movq %rdx, -0x2d0(%rbp)
movq %rcx, -0x2c8(%rbp)
movq %r8, -0x2c0(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movq %r8, -0xa8(%rbp)
movq %r9, -0xb0(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1c66f0
movq ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_amr_transfer.cpp |
704 | Omega_h::Few<Omega_h::Write<signed char>, 4>::Few() | inline Few() = default; | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8... | 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 |
705 | Omega_h::Few<Omega_h::Write<signed char>, 4>::Few(Omega_h::Few<Omega_h::Write<signed char>, 4> const&) | inline Few(Few<T, n> const& 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... | 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 |
706 | void Omega_h::parallel_for<void Omega_h::amr::transfer_inherit<signed char>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(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 0x4066ec(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x2252e1
leaq 0x405f8d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
707 | Omega_h::Few<Omega_h::Write<signed char>, 4>::~Few() | inline ~Few() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x1d4740
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_few.hpp |
708 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::amr::transfer_inherit<signed char>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cons... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
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 0x22... | 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 |
709 | Omega_h::Parents::Parents(Omega_h::Parents&&) | OMEGA_H_INLINE Parents() {} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c73c0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1da3b0
jmp 0x225938
addq $0x30, %rsp
popq %rbp
retq
movq -0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_adj.hpp |
710 | Omega_h::Few<Omega_h::Write<signed char>, 4>::Few(Omega_h::Few<Omega_h::Write<signed char>, 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... | 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 |
711 | Omega_h::Few<Omega_h::Write<int>, 4>::Few() | inline Few() = default; | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8... | 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 |
712 | Omega_h::Few<Omega_h::Write<int>, 4>::Few(Omega_h::Few<Omega_h::Write<int>, 4> const&) | inline Few(Few<T, n> const& 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... | 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 |
713 | void Omega_h::parallel_for<void Omega_h::amr::transfer_inherit<int>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(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 0x405e6c(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x225b61
leaq 0x40570d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
714 | Omega_h::Few<Omega_h::Write<int>, 4>::~Few() | inline ~Few() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x1dfdc0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_few.hpp |
715 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::amr::transfer_inherit<int>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'la... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
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 0x22... | 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 |
716 | Omega_h::Few<Omega_h::Write<int>, 4>::Few(Omega_h::Few<Omega_h::Write<int>, 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... | 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 |
717 | Omega_h::Few<Omega_h::Write<long>, 4>::Few() | inline Few() = default; | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8... | 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 |
718 | Omega_h::Read<long> Omega_h::read<long>(Omega_h::Write<long>) | Read<T> read(Write<T> a) {
return Read<T>(a);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c78d0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1b9dd0
jmp 0x2262c7
leaq -0x20(%rbp), %rdi
callq 0x1e1... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
719 | Omega_h::Few<Omega_h::Write<long>, 4>::Few(Omega_h::Few<Omega_h::Write<long>, 4> const&) | inline Few(Few<T, n> const& 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... | 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 |
720 | void Omega_h::parallel_for<void Omega_h::amr::transfer_inherit<long>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(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 0x4055dc(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x2263f1
leaq 0x404e7d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
721 | Omega_h::Few<Omega_h::Write<long>, 4>::~Few() | inline ~Few() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x1e1240
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_few.hpp |
722 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::amr::transfer_inherit<long>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'l... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
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 0x22... | 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 |
723 | Omega_h::Few<Omega_h::Write<long>, 4>::Few(Omega_h::Few<Omega_h::Write<long>, 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... | 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 |
724 | Omega_h::Few<Omega_h::Write<double>, 4>::Few() | inline Few() = default; | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8... | 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 |
725 | Omega_h::Read<double> Omega_h::read<double>(Omega_h::Write<double>) | Read<T> read(Write<T> a) {
return Read<T>(a);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c7e70
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1ccda0
jmp 0x226c87
leaq -0x20(%rbp), %rdi
callq 0x1dc... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
726 | Omega_h::Few<Omega_h::Write<double>, 4>::Few(Omega_h::Few<Omega_h::Write<double>, 4> const&) | inline Few(Few<T, n> const& 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... | 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 |
727 | void Omega_h::parallel_for<void Omega_h::amr::transfer_inherit<double>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)&>(in... | 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 0x404c1c(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x226db1
leaq 0x4044bd(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
728 | Omega_h::Few<Omega_h::Write<double>, 4>::~Few() | inline ~Few() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x20(%rbp)
callq 0x1dc900
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x10(%rbp)
jne 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_few.hpp |
729 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::amr::transfer_inherit<double>(Omega_h::Mesh*, Omega_h::Mesh*, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, Omega_h::Few<Omega_h::Read<int>, 4>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
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 0x22... | 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 |
730 | Omega_h::Few<Omega_h::Write<double>, 4>::Few(Omega_h::Few<Omega_h::Write<double>, 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... | 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 |
731 | Omega_h::bad_any_cast::what() const | const char* bad_any_cast::what() const noexcept { return "bad any cast"; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x404b7d(%rip), %rax # 0x62c0bc
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_any.cpp |
732 | Omega_h::warp_to_limit(Omega_h::Mesh*, Omega_h::AdaptOpts const&, bool, int) | bool warp_to_limit(
Mesh* mesh, AdaptOpts const& opts, bool exit_on_stall, Int max_niters) {
if (!mesh->has_tag(VERT, "warp")) return false;
check_okay(mesh, opts);
auto coords = mesh->coords();
auto warp = mesh->get_array<Real>(VERT, "warp");
mesh->set_coords(add_each(coords, warp));
if (okay(mesh, opt... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movb %dl, %al
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
movl %ecx, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x2c0(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
callq 0x1dfbb0
movq -0x2b8(%rbp), %r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_approach.cpp |
733 | Omega_h::check_okay(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static void check_okay(Mesh* mesh, AdaptOpts const& opts) {
auto minq = min_fixable_quality(mesh, opts);
if (minq < opts.min_quality_allowed) {
Omega_h_fail("minimum element quality %f < minimum allowed quality %f\n",
minq, opts.min_quality_allowed);
}
auto maxl = mesh->max_length();
if (maxl > op... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dce50
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2281e2
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_approach.cpp |
734 | Omega_h::okay(Omega_h::Mesh*, Omega_h::AdaptOpts const&) | static bool okay(Mesh* mesh, AdaptOpts const& opts) {
auto minq = min_fixable_quality(mesh, opts);
if (minq < opts.min_quality_allowed) {
return false;
}
auto maxl = mesh->max_length();
if (maxl > opts.max_length_allowed) {
return false;
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1dce50
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x22826c
movb $0x0, -0x1(%rbp)
jmp 0x228294
mov... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_approach.cpp |
735 | Omega_h::approach_metric(Omega_h::Mesh*, Omega_h::AdaptOpts const&, double) | bool approach_metric(Mesh* mesh, AdaptOpts const& opts, Real min_step) {
auto name = "metric";
auto target_name = "target_metric";
if (!mesh->has_tag(VERT, target_name)) return false;
check_okay(mesh, opts);
auto orig = mesh->get_array<Real>(VERT, name);
auto target = mesh->get_array<Real>(VERT, target_name... | pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp # imm = 0x2D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
leaq 0x403f3a(%rip), %rax # 0x62c1f9
movq %rax, -0x28(%rbp)
leaq 0x403f28(%rip), %rax # 0x62c1f2
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_approach.cpp |
736 | signed char* Omega_h::nonnull<signed char>(signed char*) | T* nonnull(T* p) {
return NonNullPtr<T>::get(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d6af0
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_array.cpp |
737 | Omega_h::NonNullPtr<signed char>::get(signed char*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x228d8c
movq 0x4cf002(%rip), %rax # 0x6f7d88
movq %rax, -0x10(%rbp)
jmp 0x228d94
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
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_array.cpp |
738 | signed char const* Omega_h::nonnull<signed char const>(signed char const*) | T* nonnull(T* p) {
return NonNullPtr<T>::get(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bb9c0
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_array.cpp |
739 | Omega_h::NonNullPtr<signed char const>::get(signed char const*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x228ddc
movq 0x4cf03a(%rip), %rax # 0x6f7e10
movq %rax, -0x10(%rbp)
jmp 0x228de4
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
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_array.cpp |
740 | Omega_h::Write<signed char>::Write(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, std::string const& name_in) {
begin_code("Write allocation");
#ifdef OMEGA_H_USE_KOKKOS
view_ = decltype(view_)(Kokkos::ViewAllocateWithoutInitializing(name_in),
static_cast<std::size_t>(size_in));
#else
shared_alloc_ = decltype(shared_alloc_)(
sizeof(T) * static_cast<std::... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x68(%rbp)
movl %esi, -0x6c(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x40358c(%rip), %rdi # 0x62c3... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
741 | Omega_h::Write<signed char>::Write(int, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, T value, std::string const& name_in)
: Write<T>(size_in, name_in) {
fill(*this, value);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1ba220
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1d26b0
jmp 0x22... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
742 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char) | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movb %al, -0x21(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1d26b0
movq -0x60(%rbp), %rdi
movb -0x21(%rbp), %al
movb %al, -0x30(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
mo... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
743 | Omega_h::Write<signed char>::Write(int, signed char, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, T offset, T stride, std::string const& name_in)
: Write<T>(size_in, name_in) {
fill_linear(*this, offset, stride);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %cl, -0xd(%rbp)
movb %al, -0xe(%rbp)
movq %r8, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1ba220
movq -0x40(%rbp), %rsi
leaq -0x28(%... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
744 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char) | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %esi, %ecx
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movb %dl, %al
movq %rsi, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1d26b0
movq -0x60(%rbp), %rdi
movb -0x21(%rbp), %al
movb %al, -0x30(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
745 | Omega_h::Write<signed char>::Write(std::initializer_list<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(std::initializer_list<T> l, std::string const& name_in)
: Write<T>(HostWrite<T>(l, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
746 | Omega_h::Write<signed char>::Write(Omega_h::HostWrite<signed char>) | Write<T>::Write(HostWrite<T> host_write) : Write<T>(host_write.write()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1dd0c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1e2650
jmp 0x229464
leaq -0x20(%rbp), %rdi
callq 0x1d4740
addq $0x40, %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
747 | Omega_h::HostWrite<signed char>::write() const | Write<T> HostWrite<T>::write() const {
ScopedTimer timer("array host to device");
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::deep_copy(write_.view(), mirror_);
#elif defined(OMEGA_H_USE_CUDA)
auto const err = cudaMemcpy(write_.data(), mirror_.get(),
std::size_t(size()) * sizeof(T), cudaMemcpyHostToDevice);
OMEGA_H... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x402f48(%rip), %rsi # 0x62c432
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
movq -0x38(%r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
748 | Omega_h::Write<signed char>::size() const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(exists());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return static_cast<LO>(view_.size());
#else
return static_cast<LO>(shared_alloc_.size() / sizeof(T));
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x229575
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x229584
movq -0x20(%rbp), %ra... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
749 | Omega_h::Write<signed char>::operator[](int) const | OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%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 | gahansen[P]omega_h/src/Omega_h_array.hpp |
750 | Omega_h::Write<signed char>::data() const | OMEGA_H_INLINE T* data() const noexcept {
#ifdef OMEGA_H_USE_KOKKOS
return view_.data();
#else
return static_cast<T*>(shared_alloc_.data());
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
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_array.hpp |
751 | Omega_h::Write<signed char>::set(int, signed char) const | void Write<T>::set(LO i, T value) const {
ScopedTimer timer("single host to device");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
cudaMemcpy(data() + i, &value, sizeof(T), cudaMemcpyHostToDevice);
#else
operator[](i) = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x2e(%rbp), %rdi
leaq 0x402dff(%rip), %rsi # 0x62c406
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x38(%rbp), %rcx
movb -0x2d(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
752 | Omega_h::Write<signed char>::get(int) const | T Write<T>::get(LO i) const {
ScopedTimer timer("single device to host");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
T value;
cudaMemcpy(&value, data() + i, sizeof(T), cudaMemcpyDeviceToHost);
return value;
#else
return operator[](i);
#... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x2d(%rbp), %rdi
leaq 0x402daa(%rip), %rsi # 0x62c41c
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
753 | Omega_h::Write<signed char>::use_count() const | inline int use_count() const { return shared_alloc_.alloc->use_count; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
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_array.hpp |
754 | Omega_h::Write<signed char>::exists() const | OMEGA_H_INLINE bool exists() const noexcept {
#if defined(OMEGA_H_USE_KOKKOS)
return view().data() != nullptr
#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && (!defined(__CUDA_ARCH__))
/* deprecated Kokkos behavior: zero-span views have data()==nullptr
*/
|| view().use_count() != 0
#e... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
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_array.hpp |
755 | Omega_h::Write<signed char>::name[abi:cxx11]() const | std::string const& Write<T>::name() const {
return shared_alloc_.alloc->name;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
756 | Omega_h::Write<signed char>::begin() const | OMEGA_H_INLINE T* begin() const noexcept { return data(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -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 | gahansen[P]omega_h/src/Omega_h_array.hpp |
757 | Omega_h::Write<signed char>::end() const | OMEGA_H_INLINE T* end() const OMEGA_H_NOEXCEPT { return data() + size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
758 | Omega_h::Read<signed char>::Read() | OMEGA_H_INLINE Read() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d2250
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_array.hpp |
759 | Omega_h::Read<signed char>::Read(Omega_h::Write<signed char>) | Read<T>::Read(Write<T> write) : write_(write) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d26b0
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_array.cpp |
760 | Omega_h::Read<signed char>::Read(int, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(LO size_in, T value, std::string const& name_in)
: Read<T>(Write<T>(size_in, value, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movsbl -0xd(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1e00e0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
761 | Omega_h::Read<signed char>::Read(int, signed char, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(LO size_in, T offset, T stride, std::string const& name_in)
: Read<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %cl, -0xd(%rbp)
movb %al, -0xe(%rbp)
movq %r8, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movsbl -0xd(%rbp), %edx
movsbl -0xe(%rbp), %ecx
movq -0x18(%rbp), %r8
lea... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
762 | Omega_h::Read<signed char>::Read(std::initializer_list<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(std::initializer_list<T> l, std::string const& name_in)
: Read<T>(HostWrite<T>(l, name_in).write()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
763 | Omega_h::Read<signed char>::size() const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x2299fd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %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_array.hpp |
764 | Omega_h::Read<signed char>::operator[](int) const | OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
765 | Omega_h::Read<signed char>::get(int) const | T Read<T>::get(LO i) const {
return write_.get(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 0x1e1bd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
766 | Omega_h::Read<signed char>::first() const | T Read<T>::first() const {
return get(0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x1cb980
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_array.cpp |
767 | Omega_h::Read<signed char>::last() const | T Read<T>::last() const {
return get(size() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
768 | Omega_h::Read<signed char>::exists() const | OMEGA_H_INLINE bool exists() const OMEGA_H_NOEXCEPT {
return write_.exists();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
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_array.hpp |
769 | Omega_h::Read<signed char>::name[abi:cxx11]() const | std::string name() const { return write_.name(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba300
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1c00c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
770 | Omega_h::Read<signed char>::begin() const | OMEGA_H_INLINE T const* begin() const noexcept { return data(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
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_array.hpp |
771 | Omega_h::Read<signed char>::end() const | OMEGA_H_INLINE T const* end() const noexcept { return data() + size(); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
772 | Omega_h::HostWrite<signed char>::HostWrite(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(LO size_in, std::string const& name_in)
: write_(size_in, name_in)
#ifdef OMEGA_H_USE_KOKKOS
,
mirror_(create_uninit_mirror_view(write_.view()))
#endif
{
#if (!defined(OMEGA_H_USE_KOKKOS)) && defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(write_.size())]);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1c2160
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_array.cpp |
773 | Omega_h::HostWrite<signed char>::HostWrite(int, signed char, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(
LO size_in, T offset, T stride, std::string const& name_in)
: HostWrite<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %cl, -0xd(%rbp)
movb %al, -0xe(%rbp)
movq %r8, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movsbl -0xd(%rbp), %edx
movsbl -0xe(%rbp), %ecx
movq -0x18(%rbp), %r8
lea... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
774 | Omega_h::HostWrite<signed char>::HostWrite(Omega_h::Write<signed char>) | HostWrite<T>::HostWrite(Write<T> write_in)
: write_(write_in)
#ifdef OMEGA_H_USE_KOKKOS
,
mirror_(create_uninit_mirror_view(write_.view()))
#endif
{
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::deep_copy(mirror_, write_.view());
#elif defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(write_.size())]);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d26b0
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_array.cpp |
775 | Omega_h::HostWrite<signed char>::HostWrite(std::initializer_list<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(std::initializer_list<T> l, std::string const& name_in)
: // an initializer_list should never have over 2 billion items...
HostWrite<T>(static_cast<LO>(l.size()), name_in) {
LO i = 0;
for (auto v : l) operator[](i++) = v;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1d06e0
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x1db5c0
movl $0x0, -0x24(%rbp)
l... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
776 | std::initializer_list<signed char>::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 |
777 | std::initializer_list<signed char>::begin() const | constexpr const_iterator
begin() const noexcept { return _M_array; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/initializer_list |
778 | std::initializer_list<signed char>::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 0x1cd310
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1d06e0
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 |
779 | Omega_h::HostWrite<signed char>::operator[](int) const | inline T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return write_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
780 | Omega_h::HostWrite<signed char>::size() const | LO HostWrite<T>::size() const OMEGA_H_NOEXCEPT {
return write_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x229f0d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %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_array.cpp |
781 | Omega_h::HostWrite<signed char>::data() const | T* HostWrite<T>::data() const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return write_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
782 | Omega_h::HostWrite<signed char>::exists() const | OMEGA_H_INLINE bool exists() const OMEGA_H_NOEXCEPT {
return write_.exists();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
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_array.hpp |
783 | Omega_h::HostWrite<signed char>::set(int, signed char) | void HostWrite<T>::set(LO i, T value) {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
mirror_[i] = value;
#elif defined(OMEGA_H_USE_CUDA)
mirror_[std::size_t(i)] = value;
#else
write_[i] = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
movq -0x28(%rbp), %rcx
movb -0x2d(%rbp), %dl
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
784 | Omega_h::HostWrite<signed char>::get(int) const | T HostWrite<T>::get(LO i) const {
#ifdef OMEGA_H_USE_KOKKOS
return mirror_[i];
#elif defined(OMEGA_H_USE_CUDA)
return mirror_[std::size_t(i)];
#else
return write_[i];
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
785 | Omega_h::HostRead<signed char>::HostRead(Omega_h::Read<signed char>) | HostRead<T>::HostRead(Read<T> read) : read_(read) {
ScopedTimer timer("array device to host");
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::View<const T*> dev_view = read.view();
Kokkos::View<const T*, Kokkos::HostSpace> h_view =
Kokkos::create_mirror_view_and_copy(Kokkos::HostSpace(), read.view());
mirror_ = h_view... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1bec60
leaq 0x402403(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22a053
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
addq $0x30... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
786 | Omega_h::HostRead<signed char>::size() const | LO HostRead<T>::size() const {
return read_.size();
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22a0c5
movq -0x30(%rbp), %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_array.cpp |
787 | Omega_h::HostRead<signed char>::operator[](int) const | inline T const& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return mirror_(i);
#else
#ifdef OMEGA_H_USE_CUDA
return mirror_[i];
#else
return read_[i];
#endif
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp),... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
788 | Omega_h::HostRead<signed char>::data() const | T const* HostRead<T>::data() const {
#if defined(OMEGA_H_USE_KOKKOS)
return mirror_.data();
#elif defined(OMEGA_H_USE_CUDA)
return mirror_.get();
#else
return read_.data();
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
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_array.cpp |
789 | Omega_h::HostRead<signed char>::get(int) const | T HostRead<T>::get(LO i) const {
return operator[](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 0x1d1970
movb (%rax), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
790 | Omega_h::HostRead<signed char>::last() const | T HostRead<T>::last() const {
return get(size() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1cb410
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1bad70
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_array.cpp |
791 | void Omega_h::parallel_for<void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'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 $0x70, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
792 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::~() | void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d4740
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_array.cpp |
793 | void Omega_h::parallel_for<void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'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 $0x70, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
794 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::~() | void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d4740
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_array.cpp |
795 | void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>) | void copy_into(Read<T> a, Write<T> b) {
OMEGA_H_TIME_FUNCTION;
OMEGA_H_CHECK(a.size() == b.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = a[i]; };
parallel_for(b.size(), f, "copy into kernel");
} | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x138(%rbp)
movq %rsi, -0x130(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 0x402110(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
796 | void Omega_h::parallel_for<void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>)::'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 $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
797 | Omega_h::Write<signed char> Omega_h::deep_copy<signed char>(Omega_h::Read<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T> deep_copy(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
auto name2 = name.empty() ? a.name() : name;
Write<T> b(a.size(), name2);
copy_into(a, b);
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rsi, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x1dfbb0
movq -0x128(%rbp), %rdx
leaq 0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
798 | int* Omega_h::nonnull<int>(int*) | T* nonnull(T* p) {
return NonNullPtr<T>::get(p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ceed0
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_array.cpp |
799 | Omega_h::NonNullPtr<int>::get(int*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22abac
movq 0x4cd0aa(%rip), %rax # 0x6f7c50
movq %rax, -0x10(%rbp)
jmp 0x22abb4
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
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_array.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.