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
|
|---|---|---|---|---|---|---|
900 | Omega_h::HostWrite<long>::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), %rcx
shlq $0x3, %rcx
addq %rcx, %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_array.hpp |
901 | Omega_h::HostWrite<long>::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 0x22dafd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22db0c
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
902 | Omega_h::HostWrite<long>::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 |
903 | Omega_h::HostWrite<long>::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 |
904 | Omega_h::HostWrite<long>::set(int, long) | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
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), %rcx
movq %rdx, (%rax,%rcx,8)
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 |
905 | Omega_h::HostWrite<long>::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), %rcx
movq (%rax,%rcx,8), %rax
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 |
906 | Omega_h::HostRead<long>::HostRead(Omega_h::Read<long>) | 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;
#elif defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(read_.size())]);
auto const err = cudaMemcpy(mirror_.get(), read_.data(),
std::size_t(size()) * sizeof(T), cudaMemcpyDeviceToHost);
OMEGA_H_CHECK(err == cudaSuccess);
#endif
} | 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 0x1c3090
leaq 0x3fe813(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22dc43
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
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 0x1bc010
movq -0x20(%rbp), %rdi
callq 0x1dfa40
| 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 |
907 | Omega_h::HostRead<long>::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 0x22dcb5
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22dcc4
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %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_array.cpp |
908 | Omega_h::HostRead<long>::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), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %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 |
909 | Omega_h::HostRead<long>::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 |
910 | Omega_h::HostRead<long>::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 0x1c6560
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
911 | Omega_h::HostRead<long>::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 0x1ce0a0
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1bf800
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 |
912 | void Omega_h::parallel_for<void Omega_h::fill<long>(Omega_h::Write<long>, long)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1bf9c0
movq -0x70(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x54(%rbp), %edi
movl -0x58(%rbp), %esi
callq 0x1e3d70
jmp 0x22de20
leaq -0x50(%rbp), %rdi
callq 0x1d1940
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1d1940
movq -0x60(%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 |
913 | void Omega_h::fill<long>(Omega_h::Write<long>, long)::'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 0x1e1240
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 |
914 | void Omega_h::parallel_for<void Omega_h::fill_linear<long>(Omega_h::Write<long>, long, long)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1bb390
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x1d95d0
jmp 0x22dee3
leaq -0x58(%rbp), %rdi
callq 0x1d28a0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d28a0
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
915 | void Omega_h::fill_linear<long>(Omega_h::Write<long>, long, long)::'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 0x1e1240
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 |
916 | void Omega_h::copy_into<long>(Omega_h::Read<long>, Omega_h::Write<long>) | 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 0x3fe510(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x22df90
leaq 0x3fd2de(%rip), %rdx # 0x62b275
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x22dfac
leaq -0x100(%rbp), %rdi
movl $0x152, %esi # imm = 0x152
callq 0x1d4960
jmp 0x22dfbf
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x1ca480
jmp 0x22dfdb
leaq -0x88(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x3fe497(%rip), %rsi # 0x62c488
leaq -0x61(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22dffc
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0x100(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x138(%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, -0x140(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22e07e
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22e090
movq -0x140(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x130(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x3, %rcx
movl %ecx, -0x14c(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x148(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22e0dc
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x22e0ee
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movl -0x14c(%rbp), %eax
movq -0x28(%rbp), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x22e105
jmp 0x22e1e2
leaq 0x3fcf5c(%rip), %rdi # 0x62b068
leaq 0x3fe3df(%rip), %rsi # 0x62c4f2
leaq 0x3fe378(%rip), %rdx # 0x62c492
xorl %eax, %eax
movl $0x153, %ecx # imm = 0x153
callq 0x1ce550
jmp 0x22e128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22e1ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22e1ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22e1a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22e196
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0x100(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x22e2e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22e2de
movq -0x130(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x1c78d0
jmp 0x22e1fe
movq -0x138(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1c3090
jmp 0x22e213
movq -0x130(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x160(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22e251
movq -0x160(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x22e263
movq -0x160(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
leaq 0x3fe293(%rip), %rdx # 0x62c507
leaq -0x120(%rbp), %rsi
callq 0x1b8b40
jmp 0x22e282
leaq -0x120(%rbp), %rdi
callq 0x1c42f0
leaq -0x61(%rbp), %rdi
callq 0x1d03d0
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
movq -0x158(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1e1240
jmp 0x22e2de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1c42f0
leaq -0x61(%rbp), %rdi
callq 0x1d03d0
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
917 | void Omega_h::parallel_for<void Omega_h::copy_into<long>(Omega_h::Read<long>, Omega_h::Write<long>)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1cc710
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x1cd880
jmp 0x22e373
leaq -0x58(%rbp), %rdi
callq 0x1c42f0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c42f0
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
918 | Omega_h::Write<long> Omega_h::deep_copy<long>(Omega_h::Read<long>, 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 0x3fe062(%rip), %rsi # 0x62c492
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x22e43e
leaq 0x3fce30(%rip), %rdx # 0x62b275
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1bb5a0
jmp 0x22e457
leaq -0xd8(%rbp), %rdi
movl $0x15a, %esi # imm = 0x15A
callq 0x1d4960
jmp 0x22e46a
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x1ca480
jmp 0x22e480
leaq -0x60(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x3fe085(%rip), %rsi # 0x62c518
leaq -0x39(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22e49e
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0x38(%rbp), %rdi
callq 0x1dd4c0
testb $0x1, %al
jne 0x22e4e3
jmp 0x22e4fa
movq -0x140(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1e1390
jmp 0x22e4f8
jmp 0x22e50e
movq -0x38(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1c00c0
jmp 0x22e50c
jmp 0x22e50e
movq -0x140(%rbp), %rax
movb $0x0, -0xf9(%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, -0x148(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22e55b
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22e56d
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x138(%rbp), %rdi
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %esi
leaq -0xf8(%rbp), %rdx
callq 0x1b9940
jmp 0x22e58c
movq -0x140(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1c3090
jmp 0x22e5a1
movq -0x138(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x1c78d0
jmp 0x22e5b6
leaq -0x110(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x1bf490
jmp 0x22e5cb
leaq -0x120(%rbp), %rdi
callq 0x1e1240
leaq -0x110(%rbp), %rdi
callq 0x1bc010
movb $0x1, -0xf9(%rbp)
testb $0x1, -0xf9(%rbp)
jne 0x22e727
jmp 0x22e71b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e67c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e673
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x22e76d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e74c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22e70d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1e1240
leaq -0x110(%rbp), %rdi
callq 0x1bc010
jmp 0x22e74c
movq -0x138(%rbp), %rdi
callq 0x1e1240
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
movq -0x130(%rbp), %rax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x1e1240
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
movq -0xb0(%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_array.cpp |
919 | double* Omega_h::nonnull<double>(double*) | 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 0x1bc4c0
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 |
920 | Omega_h::NonNullPtr<double>::get(double*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22e7bc
movq 0x4c944a(%rip), %rax # 0x6f7c00
movq %rax, -0x10(%rbp)
jmp 0x22e7c4
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 |
921 | double const* Omega_h::nonnull<double const>(double 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 0x1c5220
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 |
922 | Omega_h::NonNullPtr<double const>::get(double 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 0x22e80c
movq 0x4c974a(%rip), %rax # 0x6f7f50
movq %rax, -0x10(%rbp)
jmp 0x22e814
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 |
923 | Omega_h::Write<double>::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::size_t>(size_in), name_in);
#endif
end_code();
} | 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 0x3fdb5c(%rip), %rdi # 0x62c3f5
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
jmp 0x22e8a4
movslq -0x6c(%rbp), %rsi
shlq $0x3, %rsi
movq -0x78(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x1d1ca0
jmp 0x22e8be
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, (%rax)
je 0x22e95c
movq -0xb0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22e95c
movq -0xb0(%rbp), %rax
movq (%rax), %rcx
movl 0x30(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x30(%rcx)
movq (%rax), %rax
cmpl $0x0, 0x30(%rax)
jne 0x22e95a
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x22e958
movq -0xc0(%rbp), %rdi
callq 0x1bdea0
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22e95a
jmp 0x22e95c
movq -0xb8(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, (%rax)
je 0x22e9dc
movq -0xc8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22e9dc
movq 0x4c92d7(%rip), %rax # 0x6f7c88
testb $0x1, (%rax)
je 0x22e9da
movq -0xc8(%rbp), %rax
movq (%rax), %rcx
movl 0x30(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x30(%rcx)
movq (%rax), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x22e9dc
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
leaq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, (%rax)
je 0x22ea7f
movq -0xd0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22ea7f
movq -0xd0(%rbp), %rax
movq (%rax), %rcx
movl 0x30(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x30(%rcx)
movq (%rax), %rax
cmpl $0x0, 0x30(%rax)
jne 0x22ea7d
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0x22ea7b
movq -0xd8(%rbp), %rdi
callq 0x1bdea0
movq -0xd8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22ea7d
jmp 0x22ea7f
callq 0x1d7be0
jmp 0x22ea86
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xe0(%rbp)
cmpq $0x0, (%rax)
je 0x22eb2a
movq -0xe0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22eb2a
movq -0xe0(%rbp), %rax
movq (%rax), %rcx
movl 0x30(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x30(%rcx)
movq (%rax), %rax
cmpl $0x0, 0x30(%rax)
jne 0x22eb28
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
cmpq $0x0, %rax
je 0x22eb26
movq -0xe8(%rbp), %rdi
callq 0x1bdea0
movq -0xe8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22eb28
jmp 0x22eb2a
jmp 0x22eb2c
movq -0x80(%rbp), %rdi
callq 0x1dfa40
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 |
924 | Omega_h::Write<double>::Write(int, double, 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 $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1d7b50
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c7e70
jmp 0x22eb7b
movsd -0x18(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x1c6ac0
jmp 0x22eb8b
leaq -0x30(%rbp), %rdi
callq 0x1dc900
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22ebbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dc900
movq -0x48(%rbp), %rdi
callq 0x1dc900
movq -0x38(%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_array.cpp |
925 | void Omega_h::fill<double>(Omega_h::Write<double>, double) | 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
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c7e70
movq -0x60(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22ec30
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22ec3f
movq -0x58(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
leaq 0x3fd80c(%rip), %rdx # 0x62c45c
leaq -0x40(%rbp), %rsi
callq 0x1e17e0
jmp 0x22ec5b
leaq -0x40(%rbp), %rdi
callq 0x1bccc0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1bccc0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
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 |
926 | Omega_h::Write<double>::Write(int, double, double, 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 $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1d7b50
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c7e70
jmp 0x22ecd0
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq -0x38(%rbp), %rdi
callq 0x1deb80
jmp 0x22ece5
leaq -0x38(%rbp), %rdi
callq 0x1dc900
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x22ed17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1dc900
movq -0x50(%rbp), %rdi
callq 0x1dc900
movq -0x40(%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_array.cpp |
927 | void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double) | 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 $0x70, %rsp
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rsi, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c7e70
movq -0x70(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22ed9f
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22edae
movq -0x68(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
leaq 0x3fd6af(%rip), %rdx # 0x62c46e
leaq -0x50(%rbp), %rsi
callq 0x1d8fa0
jmp 0x22edca
leaq -0x50(%rbp), %rdi
callq 0x1c0450
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c0450
movq -0x58(%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_array.cpp |
928 | Omega_h::Write<double>::Write(std::initializer_list<double>, 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), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1c5140
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1d5b40
jmp 0x22ee50
leaq -0x30(%rbp), %rdi
callq 0x1d0f00
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d0f00
movq -0x48(%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_array.cpp |
929 | Omega_h::Write<double>::Write(Omega_h::HostWrite<double>) | 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 0x1db430
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d8720
jmp 0x22eeb4
leaq -0x20(%rbp), %rdi
callq 0x1dc900
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1dc900
movq -0x28(%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_array.cpp |
930 | Omega_h::HostWrite<double>::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_CHECK(err == cudaSuccess);
#endif
return write_;
} | 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 0x3fd4f8(%rip), %rsi # 0x62c432
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c7e70
jmp 0x22ef56
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
movq -0x20(%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_array.cpp |
931 | Omega_h::Write<double>::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 0x22efc5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22efd4
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %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_array.hpp |
932 | Omega_h::Write<double>::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
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 | gahansen[P]omega_h/src/Omega_h_array.hpp |
933 | Omega_h::Write<double>::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 |
934 | Omega_h::Write<double>::set(int, double) 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 $0x50, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x39(%rbp), %rdi
leaq 0x3fd3af(%rip), %rsi # 0x62c406
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x48(%rbp), %rcx
movsd -0x38(%rbp), %xmm0
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), %rcx
movsd %xmm0, (%rax,%rcx,8)
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
addq $0x50, %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 |
935 | Omega_h::Write<double>::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);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x2d(%rbp), %rdi
leaq 0x3fd34a(%rip), %rsi # 0x62c41c
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x40(%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), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x1d03d0
movsd -0x38(%rbp), %xmm0
addq $0x40, %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 |
936 | Omega_h::Write<double>::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 |
937 | Omega_h::Write<double>::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
#endif
;
#else
return shared_alloc_.data() != nullptr;
#endif
} | 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 |
938 | Omega_h::Write<double>::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 |
939 | Omega_h::Write<double>::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 |
940 | Omega_h::Write<double>::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)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22f215
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22f224
movq -0x38(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
shlq $0x3, %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 |
941 | Omega_h::Read<double>::Read() | OMEGA_H_INLINE Read() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c5bc0
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 |
942 | Omega_h::Read<double>::Read(Omega_h::Write<double>) | 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 0x1c7e70
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 |
943 | Omega_h::Read<double>::Read(int, double, 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1d8d60
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1be690
jmp 0x22f2c8
leaq -0x30(%rbp), %rdi
callq 0x1dc900
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dc900
movq -0x38(%rbp), %rdi
callq 0x1dfa40
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 |
944 | Omega_h::Read<double>::Read(int, double, double, 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 $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1cb250
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1be690
jmp 0x22f352
leaq -0x38(%rbp), %rdi
callq 0x1dc900
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1dc900
movq -0x40(%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_array.cpp |
945 | Omega_h::Read<double>::Read(std::initializer_list<double>, 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), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1c5140
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1db430
jmp 0x22f3d0
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1be690
jmp 0x22f3df
leaq -0x30(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1d0f00
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22f41a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dc900
leaq -0x40(%rbp), %rdi
callq 0x1d0f00
movq -0x58(%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_array.cpp |
946 | Omega_h::Read<double>::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 0x22f46d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22f47c
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.hpp |
947 | Omega_h::Read<double>::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), %rcx
shlq $0x3, %rcx
addq %rcx, %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_array.hpp |
948 | Omega_h::Read<double>::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 0x1bc380
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 |
949 | Omega_h::Read<double>::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 0x1c8390
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 |
950 | Omega_h::Read<double>::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, %rax
jne 0x22f59d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22f5ac
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %esi
subl $0x1, %esi
callq 0x1c8390
addq $0x40, %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 |
951 | Omega_h::Read<double>::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 |
952 | Omega_h::Read<double>::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 0x1ddfd0
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 |
953 | Omega_h::Read<double>::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 |
954 | Omega_h::Read<double>::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)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22f6d5
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x22f6e4
movq -0x48(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
shlq $0x3, %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 |
955 | Omega_h::HostWrite<double>::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 0x1cd090
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 |
956 | Omega_h::HostWrite<double>::HostWrite(int, double, double, 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 $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1cb250
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1cd300
jmp 0x22f782
leaq -0x38(%rbp), %rdi
callq 0x1dc900
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1dc900
movq -0x40(%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_array.cpp |
957 | Omega_h::HostWrite<double>::HostWrite(Omega_h::Write<double>) | 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())]);
auto const err = cudaMemcpy(mirror_.get(), write_.data(),
std::size_t(write_.size()) * sizeof(T), cudaMemcpyDeviceToHost);
OMEGA_H_CHECK(err == cudaSuccess);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7e70
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 |
958 | Omega_h::HostWrite<double>::HostWrite(std::initializer_list<double>, 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 0x1d2820
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x1e31a0
movl $0x0, -0x24(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1d4c40
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf1c0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x22f87d
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
callq 0x1d6ab0
movsd -0x58(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x22f831
addq $0x60, %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 |
959 | std::initializer_list<double>::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 |
960 | std::initializer_list<double>::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 |
961 | std::initializer_list<double>::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 0x1d4c40
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1d2820
movq %rax, %rcx
movq -0x10(%rbp), %rax
shlq $0x3, %rcx
addq %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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/initializer_list |
962 | Omega_h::HostWrite<double>::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), %rcx
shlq $0x3, %rcx
addq %rcx, %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_array.hpp |
963 | Omega_h::HostWrite<double>::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 0x22f98d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22f99c
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
964 | Omega_h::HostWrite<double>::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 |
965 | Omega_h::HostWrite<double>::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 |
966 | Omega_h::HostWrite<double>::set(int, double) | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movsd -0x38(%rbp), %xmm0
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), %rcx
movsd %xmm0, (%rax,%rcx,8)
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_array.cpp |
967 | Omega_h::HostWrite<double>::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), %rcx
movsd (%rax,%rcx,8), %xmm0
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 |
968 | Omega_h::HostRead<double>::HostRead(Omega_h::Read<double>) | 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;
#elif defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(read_.size())]);
auto const err = cudaMemcpy(mirror_.get(), read_.data(),
std::size_t(size()) * sizeof(T), cudaMemcpyDeviceToHost);
OMEGA_H_CHECK(err == cudaSuccess);
#endif
} | 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 0x1cae10
leaq 0x3fc983(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22fad3
leaq -0x11(%rbp), %rdi
callq 0x1d03d0
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 0x1e0ab0
movq -0x20(%rbp), %rdi
callq 0x1dfa40
| 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 |
969 | Omega_h::HostRead<double>::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 0x22fb45
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22fb54
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %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_array.cpp |
970 | Omega_h::HostRead<double>::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), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x3, %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 |
971 | Omega_h::HostRead<double>::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 |
972 | Omega_h::HostRead<double>::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 0x1e23e0
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
973 | Omega_h::HostRead<double>::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 0x1e0740
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1dee50
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 |
974 | void Omega_h::parallel_for<void Omega_h::fill<double>(Omega_h::Write<double>, double)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1e0890
movq -0x70(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x54(%rbp), %edi
movl -0x58(%rbp), %esi
callq 0x1d2d30
jmp 0x22fcb0
leaq -0x50(%rbp), %rdi
callq 0x1bccc0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1bccc0
movq -0x60(%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 |
975 | void Omega_h::fill<double>(Omega_h::Write<double>, double)::'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 0x1dc900
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 |
976 | void Omega_h::parallel_for<void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1c5910
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x1bc410
jmp 0x22fd73
leaq -0x58(%rbp), %rdi
callq 0x1c0450
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c0450
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
977 | void Omega_h::fill_linear<double>(Omega_h::Write<double>, double, double)::'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 0x1dc900
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 |
978 | void Omega_h::copy_into<double>(Omega_h::Read<double>, Omega_h::Write<double>) | 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 0x3fc680(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x22fe20
leaq 0x3fb44e(%rip), %rdx # 0x62b275
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x22fe3c
leaq -0x100(%rbp), %rdi
movl $0x152, %esi # imm = 0x152
callq 0x1d4960
jmp 0x22fe4f
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x1ca480
jmp 0x22fe6b
leaq -0x88(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x3fc607(%rip), %rsi # 0x62c488
leaq -0x61(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22fe8c
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0x100(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x138(%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, -0x140(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22ff0e
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22ff20
movq -0x140(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x130(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x3, %rcx
movl %ecx, -0x14c(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x148(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x22ff6c
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x22ff7e
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movl -0x14c(%rbp), %eax
movq -0x28(%rbp), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x22ff95
jmp 0x230072
leaq 0x3fb0cc(%rip), %rdi # 0x62b068
leaq 0x3fc54f(%rip), %rsi # 0x62c4f2
leaq 0x3fc4e8(%rip), %rdx # 0x62c492
xorl %eax, %eax
movl $0x153, %ecx # imm = 0x153
callq 0x1ce550
jmp 0x22ffb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x23004a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x23003e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x230032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x230026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0x100(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x230177
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x23016e
movq -0x130(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x1c7e70
jmp 0x23008e
movq -0x138(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1cae10
jmp 0x2300a3
movq -0x130(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x160(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x2300e1
movq -0x160(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2300f3
movq -0x160(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
leaq 0x3fc403(%rip), %rdx # 0x62c507
leaq -0x120(%rbp), %rsi
callq 0x1bb640
jmp 0x230112
leaq -0x120(%rbp), %rdi
callq 0x1ca7d0
leaq -0x61(%rbp), %rdi
callq 0x1d03d0
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
movq -0x158(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
callq 0x1dc900
jmp 0x23016e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1ca7d0
leaq -0x61(%rbp), %rdi
callq 0x1d03d0
movq -0xd8(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
979 | void Omega_h::parallel_for<void Omega_h::copy_into<double>(Omega_h::Read<double>, Omega_h::Write<double>)::'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 $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 %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1d0e90
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x1be880
jmp 0x230203
leaq -0x58(%rbp), %rdi
callq 0x1ca7d0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1ca7d0
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
980 | Omega_h::Write<double> Omega_h::deep_copy<double>(Omega_h::Read<double>, 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 0x3fc1d2(%rip), %rsi # 0x62c492
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x2302ce
leaq 0x3fafa0(%rip), %rdx # 0x62b275
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1bb5a0
jmp 0x2302e7
leaq -0xd8(%rbp), %rdi
movl $0x15a, %esi # imm = 0x15A
callq 0x1d4960
jmp 0x2302fa
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x1ca480
jmp 0x230310
leaq -0x60(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x3fc1f5(%rip), %rsi # 0x62c518
leaq -0x39(%rbp), %rdi
callq 0x1dc4d0
jmp 0x23032e
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0x38(%rbp), %rdi
callq 0x1dd4c0
testb $0x1, %al
jne 0x230373
jmp 0x23038a
movq -0x140(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1e2e30
jmp 0x230388
jmp 0x23039e
movq -0x38(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1c00c0
jmp 0x23039c
jmp 0x23039e
movq -0x140(%rbp), %rax
movb $0x0, -0xf9(%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, -0x148(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x2303eb
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2303fd
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x138(%rbp), %rdi
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %esi
leaq -0xf8(%rbp), %rdx
callq 0x1cd090
jmp 0x23041c
movq -0x140(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1cae10
jmp 0x230431
movq -0x138(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x1c7e70
jmp 0x230446
leaq -0x110(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x1e1470
jmp 0x23045b
leaq -0x120(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1e0ab0
movb $0x1, -0xf9(%rbp)
testb $0x1, -0xf9(%rbp)
jne 0x2305b7
jmp 0x2305ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x230518
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x23050c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x230503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2304f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c4d10
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x2305fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2305f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2305e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2305dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x23059d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1e0ab0
jmp 0x2305dc
movq -0x138(%rbp), %rdi
callq 0x1dc900
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
movq -0x130(%rbp), %rax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x1dc900
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
movq -0xb0(%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_array.cpp |
981 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::('lambda'(int) const&) | 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d26b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x10(%rcx), %cl
movb %cl, 0x10(%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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
982 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)>(signed char, signed char, void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'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 $0x70, %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 0x230685
jmp 0x230714
movq 0x4c75fc(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1e3470
movq 0x4c75e5(%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 0x23070b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x1cbbf0
jmp 0x2306dd
jmp 0x2306df
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2306a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d4f60
jmp 0x23071a
leaq -0x58(%rbp), %rdi
callq 0x1d4f60
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
983 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::('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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e2650
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x10(%rcx), %cl
movb %cl, 0x10(%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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
984 | void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)::'lambda'(int)::operator()(int) const | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movb 0x10(%rcx), %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 -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
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 |
985 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::('lambda'(int) const&) | 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d26b0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movw 0x10(%rcx), %cx
movw %cx, 0x10(%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.cpp |
986 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)>(signed char, signed char, void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'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 $0x70, %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 0x230825
jmp 0x2308b4
movq 0x4c745c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1cf240
movq 0x4c7445(%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 0x2308ab
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x1cce40
jmp 0x23087d
jmp 0x23087f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x230846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1d14d0
jmp 0x2308ba
leaq -0x58(%rbp), %rdi
callq 0x1d14d0
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
987 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::('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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e2650
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movw 0x10(%rcx), %cx
movw %cx, 0x10(%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.cpp |
988 | void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)::'lambda'(int)::operator()(int) const | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movsbl 0x10(%rcx), %eax
movsbl 0x11(%rcx), %edx
movl -0x2c(%rbp), %esi
movsbl %sil, %esi
imull %esi, %edx
addl %edx, %eax
movb %al, %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 -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
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.cpp |
989 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>)::'lambda'(int)>(signed char, signed char, void Omega_h::copy_into<signed char>(Omega_h::Read<signed char>, Omega_h::Write<signed char>)::'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 $0x70, %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 0x2309f5
jmp 0x230a84
movq 0x4c728c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8920
movq 0x4c7275(%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 0x230a7b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1cbad0
jmp 0x230a4d
jmp 0x230a4f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x230a16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ce600
jmp 0x230a8a
leaq -0x60(%rbp), %rdi
callq 0x1ce600
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
990 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::('lambda'(int) const&) | 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c0f10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
991 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)>(int, int, void Omega_h::fill<int>(Omega_h::Write<int>, 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 $0x70, %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 0x230bf5
jmp 0x230c84
movq 0x4c708c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1daa40
movq 0x4c7075(%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 0x230c7b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x1e28e0
jmp 0x230c4d
jmp 0x230c4f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x230c16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c4df0
jmp 0x230c8a
leaq -0x58(%rbp), %rdi
callq 0x1c4df0
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
992 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::('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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c8620
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%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 | gahansen[P]omega_h/src/Omega_h_array.cpp |
993 | void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)::operator()(int) const | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %edx
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), %rcx
movl %edx, (%rax,%rcx,4)
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 |
994 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::('lambda'(int) const&) | 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c0f10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%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.cpp |
995 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)>(int, int, void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, 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 $0x70, %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 0x230d95
jmp 0x230e24
movq 0x4c6eec(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1e4810
movq 0x4c6ed5(%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 0x230e1b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x58(%rbp), %rdi
callq 0x1be8c0
jmp 0x230ded
jmp 0x230def
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x230db6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1dff20
jmp 0x230e2a
leaq -0x58(%rbp), %rdi
callq 0x1dff20
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
996 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::('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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c8620
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%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.cpp |
997 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)::operator()(int) const | 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
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rcx
movl 0x10(%rcx), %edx
movl 0x14(%rcx), %eax
imull -0x2c(%rbp), %eax
addl %eax, %edx
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), %rcx
movl %edx, (%rax,%rcx,4)
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_array.cpp |
998 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<int>)::'lambda'(int)>(int, int, void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<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 $0x70, %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 0x230f65
jmp 0x230ff4
movq 0x4c6d1c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1d56a0
movq 0x4c6d05(%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 0x230feb
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1c4e80
jmp 0x230fbd
jmp 0x230fbf
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x230f86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1d7d60
jmp 0x230ffa
leaq -0x60(%rbp), %rdi
callq 0x1d7d60
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
999 | void Omega_h::fill<long>(Omega_h::Write<long>, long)::'lambda'(int)::('lambda'(int) const&) | 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 $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c78d0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%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.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.