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
|
|---|---|---|---|---|---|---|
800 | int const* Omega_h::nonnull<int const>(int 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 0x1dbf70
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 |
801 | Omega_h::NonNullPtr<int const>::get(int 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 0x22abfc
movq 0x4cccc2(%rip), %rax # 0x6f78b8
movq %rax, -0x10(%rbp)
jmp 0x22ac04
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 |
802 | Omega_h::Write<int>::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 0x40176c(%rip), %rdi # 0x62c3f5
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
jmp 0x22ac94
movslq -0x6c(%rbp), %rsi
shlq $0x2, %rsi
movq -0x78(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x1d1ca0
jmp 0x22acae
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 0x22ad4c
movq -0xb0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22ad4c
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 0x22ad4a
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x22ad48
movq -0xc0(%rbp), %rdi
callq 0x1bdea0
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22ad4a
jmp 0x22ad4c
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 0x22adcc
movq -0xc8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22adcc
movq 0x4ccee7(%rip), %rax # 0x6f7c88
testb $0x1, (%rax)
je 0x22adca
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 0x22adcc
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 0x22ae6f
movq -0xd0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22ae6f
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 0x22ae6d
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0x22ae6b
movq -0xd8(%rbp), %rdi
callq 0x1bdea0
movq -0xd8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22ae6d
jmp 0x22ae6f
callq 0x1d7be0
jmp 0x22ae76
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 0x22af1a
movq -0xe0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22af1a
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 0x22af18
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
cmpq $0x0, %rax
je 0x22af16
movq -0xe8(%rbp), %rdi
callq 0x1bdea0
movq -0xe8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22af18
jmp 0x22af1a
jmp 0x22af1c
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 |
803 | Omega_h::Write<int>::Write(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Write<T>::Write(LO size_in, T value, std::string const& name_in)
: Write<T>(size_in, name_in) {
fill(*this, value);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1b9830
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1c0f10
jmp 0x22af69
movl -0x10(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x1e2180
jmp 0x22af77
leaq -0x28(%rbp), %rdi
callq 0x1dfdc0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x22afa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1dfdc0
movq -0x40(%rbp), %rdi
callq 0x1dfdc0
movq -0x30(%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 |
804 | void Omega_h::fill<int>(Omega_h::Write<int>, 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 $0x60, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c0f10
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -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 0x22b01c
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b02b
movq -0x58(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
leaq 0x401420(%rip), %rdx # 0x62c45c
leaq -0x40(%rbp), %rsi
callq 0x1be800
jmp 0x22b047
leaq -0x40(%rbp), %rdi
callq 0x1c4df0
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 0x1c4df0
movq -0x48(%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 |
805 | Omega_h::Write<int>::Write(int, int, int, 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)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1b9830
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c0f10
jmp 0x22b0bc
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0x1d2900
jmp 0x22b0cd
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22b0ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
movq -0x48(%rbp), %rdi
callq 0x1dfdc0
movq -0x38(%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 |
806 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, 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 $0x60, %rsp
movl %esi, %eax
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl %edx, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c0f10
movq -0x60(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%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 0x22b185
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b194
movq -0x58(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
leaq 0x4012c9(%rip), %rdx # 0x62c46e
leaq -0x40(%rbp), %rsi
callq 0x1d60e0
jmp 0x22b1b0
leaq -0x40(%rbp), %rdi
callq 0x1dff20
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 0x1dff20
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 |
807 | Omega_h::Write<int>::Write(std::initializer_list<int>, 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 0x1bcec0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1c4a50
jmp 0x22b230
leaq -0x30(%rbp), %rdi
callq 0x1d68e0
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 0x1d68e0
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 |
808 | Omega_h::Write<int>::Write(Omega_h::HostWrite<int>) | 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 0x1cb5a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1c8620
jmp 0x22b294
leaq -0x20(%rbp), %rdi
callq 0x1dfdc0
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 0x1dfdc0
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 |
809 | Omega_h::HostWrite<int>::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 0x401118(%rip), %rsi # 0x62c432
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c0f10
jmp 0x22b336
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 |
810 | Omega_h::Write<int>::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 0x22b3a5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b3b4
movq -0x20(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %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 |
811 | Omega_h::Write<int>::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 $0x2, %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 |
812 | Omega_h::Write<int>::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 |
813 | Omega_h::Write<int>::set(int, int) const | void Write<T>::set(LO i, T value) const {
ScopedTimer timer("single host to device");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
cudaMemcpy(data() + i, &value, sizeof(T), cudaMemcpyHostToDevice);
#else
operator[](i) = value;
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x31(%rbp), %rdi
leaq 0x400fd1(%rip), %rsi # 0x62c406
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x40(%rbp), %rcx
movl -0x30(%rbp), %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)
leaq -0x31(%rbp), %rdi
callq 0x1d03d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
814 | Omega_h::Write<int>::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 0x400f7a(%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
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x1d03d0
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
815 | Omega_h::Write<int>::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 |
816 | Omega_h::Write<int>::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 |
817 | Omega_h::Write<int>::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 |
818 | Omega_h::Write<int>::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 |
819 | Omega_h::Write<int>::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 0x22b5d5
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22b5e4
movq -0x38(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
shlq $0x2, %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 |
820 | Omega_h::Read<int>::Read() | OMEGA_H_INLINE Read() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf620
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 |
821 | Omega_h::Read<int>::Read(Omega_h::Write<int>) | 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 0x1c0f10
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 |
822 | Omega_h::Read<int>::Read(int, int, 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)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1cbcb0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1ce450
jmp 0x22b684
leaq -0x28(%rbp), %rdi
callq 0x1dfdc0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1dfdc0
movq -0x30(%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 |
823 | Omega_h::Read<int>::Read(int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Read<T>::Read(LO size_in, T offset, T stride, std::string const& name_in)
: Read<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e2440
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1ce450
jmp 0x22b70a
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
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 0x1dfdc0
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
824 | Omega_h::Read<int>::Read(std::initializer_list<int>, 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 0x1bcec0
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1cb5a0
jmp 0x22b790
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ce450
jmp 0x22b79f
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
leaq -0x40(%rbp), %rdi
callq 0x1d68e0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22b7da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
leaq -0x40(%rbp), %rdi
callq 0x1d68e0
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 |
825 | Omega_h::Read<int>::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 0x22b82d
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b83c
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %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 |
826 | Omega_h::Read<int>::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 $0x2, %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 |
827 | Omega_h::Read<int>::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 0x1c56d0
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 |
828 | Omega_h::Read<int>::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 0x1db290
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 |
829 | Omega_h::Read<int>::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 0x22b95d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22b96c
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %esi
subl $0x1, %esi
callq 0x1db290
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 |
830 | Omega_h::Read<int>::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 |
831 | Omega_h::Read<int>::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 0x1bed00
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 |
832 | Omega_h::Read<int>::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 |
833 | Omega_h::Read<int>::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 0x22ba95
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x22baa4
movq -0x48(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
shlq $0x2, %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 |
834 | Omega_h::HostWrite<int>::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 0x1bc080
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 |
835 | Omega_h::HostWrite<int>::HostWrite(int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | HostWrite<T>::HostWrite(
LO size_in, T offset, T stride, std::string const& name_in)
: HostWrite<T>(Write<T>(size_in, offset, stride, name_in)) {} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e2440
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1c2800
jmp 0x22bb3a
leaq -0x30(%rbp), %rdi
callq 0x1dfdc0
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 0x1dfdc0
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
836 | Omega_h::HostWrite<int>::HostWrite(Omega_h::Write<int>) | 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 0x1c0f10
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 |
837 | Omega_h::HostWrite<int>::HostWrite(std::initializer_list<int>, 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 0x1d42e0
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x1c86a0
movl $0x0, -0x24(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1cecd0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1cb320
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x22bc31
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
callq 0x1ce010
movl -0x54(%rbp), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x22bbf1
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
838 | Omega_h::HostWrite<int>::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 $0x2, %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 |
839 | Omega_h::HostWrite<int>::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 0x22bcbd
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22bccc
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %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 |
840 | Omega_h::HostWrite<int>::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 |
841 | Omega_h::HostWrite<int>::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 |
842 | Omega_h::HostWrite<int>::set(int, int) | 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)
movl %edx, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movl -0x30(%rbp), %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
| 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 |
843 | Omega_h::HostWrite<int>::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
movl (%rax,%rcx,4), %eax
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 |
844 | Omega_h::HostRead<int>::HostRead(Omega_h::Read<int>) | 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 0x1d99b0
leaq 0x400663(%rip), %rsi # 0x62c447
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22bdf3
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 0x1c7d90
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 |
845 | Omega_h::HostRead<int>::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 0x22be65
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22be74
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %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 |
846 | Omega_h::HostRead<int>::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 $0x2, %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 |
847 | Omega_h::HostRead<int>::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 |
848 | Omega_h::HostRead<int>::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 0x1e2330
movl (%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
849 | Omega_h::HostRead<int>::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 0x1cbde0
movq -0x10(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x1d8db0
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 |
850 | void Omega_h::parallel_for<void Omega_h::fill<int>(Omega_h::Write<int>, int)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $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 0x1d2ba0
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 0x1c4d90
jmp 0x22bfd0
leaq -0x50(%rbp), %rdi
callq 0x1c4df0
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 0x1c4df0
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 |
851 | void Omega_h::fill<int>(Omega_h::Write<int>, 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 $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dfdc0
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 |
852 | void Omega_h::parallel_for<void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, int)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $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 0x1df8d0
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 0x1c2b40
jmp 0x22c090
leaq -0x50(%rbp), %rdi
callq 0x1dff20
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 0x1dff20
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 |
853 | void Omega_h::fill_linear<int>(Omega_h::Write<int>, int, 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 $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dfdc0
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 |
854 | void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<int>) | 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 0x400370(%rip), %rsi # 0x62c492
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x22c130
leaq 0x3ff13e(%rip), %rdx # 0x62b275
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x22c14c
leaq -0x100(%rbp), %rdi
movl $0x152, %esi # imm = 0x152
callq 0x1d4960
jmp 0x22c15f
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x1ca480
jmp 0x22c17b
leaq -0x88(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x4002f7(%rip), %rsi # 0x62c488
leaq -0x61(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22c19c
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 0x22c21e
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22c230
movq -0x140(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x130(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x2, %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 0x22c27c
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x22c28e
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movl -0x14c(%rbp), %eax
movq -0x28(%rbp), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x22c2a5
jmp 0x22c382
leaq 0x3fedbc(%rip), %rdi # 0x62b068
leaq 0x40023f(%rip), %rsi # 0x62c4f2
leaq 0x4001d8(%rip), %rdx # 0x62c492
xorl %eax, %eax
movl $0x153, %ecx # imm = 0x153
callq 0x1ce550
jmp 0x22c2c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22c35a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22c34e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22c342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22c336
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 0x22c487
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x22c47e
movq -0x130(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x1c0f10
jmp 0x22c39e
movq -0x138(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1d99b0
jmp 0x22c3b3
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 0x22c3f1
movq -0x160(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x22c403
movq -0x160(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
leaq 0x4000f3(%rip), %rdx # 0x62c507
leaq -0x120(%rbp), %rsi
callq 0x1db330
jmp 0x22c422
leaq -0x120(%rbp), %rdi
callq 0x1d7d60
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 0x1dfdc0
jmp 0x22c47e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1d7d60
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 |
855 | void Omega_h::parallel_for<void Omega_h::copy_into<int>(Omega_h::Read<int>, Omega_h::Write<int>)::'lambda'(int)>(int, int const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $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 0x1cff40
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 0x1c51c0
jmp 0x22c513
leaq -0x58(%rbp), %rdi
callq 0x1d7d60
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 0x1d7d60
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 |
856 | Omega_h::Write<int> Omega_h::deep_copy<int>(Omega_h::Read<int>, 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 0x3ffec2(%rip), %rsi # 0x62c492
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x22c5de
leaq 0x3fec90(%rip), %rdx # 0x62b275
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1bb5a0
jmp 0x22c5f7
leaq -0xd8(%rbp), %rdi
movl $0x15a, %esi # imm = 0x15A
callq 0x1d4960
jmp 0x22c60a
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x1ca480
jmp 0x22c620
leaq -0x60(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0x3ffee5(%rip), %rsi # 0x62c518
leaq -0x39(%rbp), %rdi
callq 0x1dc4d0
jmp 0x22c63e
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 0x22c683
jmp 0x22c69a
movq -0x140(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1cf3c0
jmp 0x22c698
jmp 0x22c6ae
movq -0x38(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x1c00c0
jmp 0x22c6ac
jmp 0x22c6ae
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 0x22c6fb
movq -0x148(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22c70d
movq -0x148(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x138(%rbp), %rdi
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %esi
leaq -0xf8(%rbp), %rdx
callq 0x1bc080
jmp 0x22c72c
movq -0x140(%rbp), %rsi
leaq -0x110(%rbp), %rdi
callq 0x1d99b0
jmp 0x22c741
movq -0x138(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x1c0f10
jmp 0x22c756
leaq -0x110(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x1e42b0
jmp 0x22c76b
leaq -0x120(%rbp), %rdi
callq 0x1dfdc0
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
movb $0x1, -0xf9(%rbp)
testb $0x1, -0xf9(%rbp)
jne 0x22c8c7
jmp 0x22c8bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c81c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c813
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c807
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 0x22c90d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c8f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c8ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x22c8ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1dfdc0
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
jmp 0x22c8ec
movq -0x138(%rbp), %rdi
callq 0x1dfdc0
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 0x1dfdc0
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 |
857 | long* Omega_h::nonnull<long>(long*) | 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 0x1bf250
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 |
858 | Omega_h::NonNullPtr<long>::get(long*) | static T* get(T* p) { return (p == nullptr) ? scratch : p; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22c95c
movq 0x4cb12a(%rip), %rax # 0x6f7a80
movq %rax, -0x10(%rbp)
jmp 0x22c964
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 |
859 | long const* Omega_h::nonnull<long const>(long 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 0x1d04d0
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 |
860 | Omega_h::NonNullPtr<long const>::get(long 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 0x22c9ac
movq 0x4cb4ea(%rip), %rax # 0x6f7e90
movq %rax, -0x10(%rbp)
jmp 0x22c9b4
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 |
861 | Omega_h::Write<long>::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 0x3ff9bc(%rip), %rdi # 0x62c3f5
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
jmp 0x22ca44
movslq -0x6c(%rbp), %rsi
shlq $0x3, %rsi
movq -0x78(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x1d1ca0
jmp 0x22ca5e
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 0x22cafc
movq -0xb0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22cafc
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 0x22cafa
movq -0xb0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x22caf8
movq -0xc0(%rbp), %rdi
callq 0x1bdea0
movq -0xc0(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22cafa
jmp 0x22cafc
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 0x22cb7c
movq -0xc8(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22cb7c
movq 0x4cb137(%rip), %rax # 0x6f7c88
testb $0x1, (%rax)
je 0x22cb7a
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 0x22cb7c
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 0x22cc1f
movq -0xd0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22cc1f
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 0x22cc1d
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
cmpq $0x0, %rax
je 0x22cc1b
movq -0xd8(%rbp), %rdi
callq 0x1bdea0
movq -0xd8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22cc1d
jmp 0x22cc1f
callq 0x1d7be0
jmp 0x22cc26
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 0x22ccca
movq -0xe0(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x22ccca
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 0x22ccc8
movq -0xe0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
cmpq $0x0, %rax
je 0x22ccc6
movq -0xe8(%rbp), %rdi
callq 0x1bdea0
movq -0xe8(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x22ccc8
jmp 0x22ccca
jmp 0x22cccc
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 |
862 | Omega_h::Write<long>::Write(int, long, 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x1cd7e0
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c78d0
jmp 0x22cd1a
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1bc7e0
jmp 0x22cd29
leaq -0x30(%rbp), %rdi
callq 0x1e1240
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22cd5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1e1240
movq -0x48(%rbp), %rdi
callq 0x1e1240
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
863 | void Omega_h::fill<long>(Omega_h::Write<long>, long) | 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 %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x60(%rbp)
movq %rsi, -0x20(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1c78d0
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -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 0x22cdd0
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22cddf
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 0x3ff66c(%rip), %rdx # 0x62c45c
leaq -0x40(%rbp), %rsi
callq 0x1cc260
jmp 0x22cdfb
leaq -0x40(%rbp), %rdi
callq 0x1d1940
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 0x1d1940
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 |
864 | Omega_h::Write<long>::Write(int, long, long, 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x1cd7e0
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1c78d0
jmp 0x22ce6e
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1c01c0
jmp 0x22ce81
leaq -0x38(%rbp), %rdi
callq 0x1e1240
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x22ceb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1e1240
movq -0x50(%rbp), %rdi
callq 0x1e1240
movq -0x40(%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 |
865 | void Omega_h::fill_linear<long>(Omega_h::Write<long>, long, long) | 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 %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rsi, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c78d0
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -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 0x22cf3c
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22cf4b
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 0x3ff512(%rip), %rdx # 0x62c46e
leaq -0x50(%rbp), %rsi
callq 0x1d3210
jmp 0x22cf67
leaq -0x50(%rbp), %rdi
callq 0x1d28a0
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 0x1d28a0
movq -0x58(%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 |
866 | Omega_h::Write<long>::Write(std::initializer_list<long>, 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 0x1c8960
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1c90c0
jmp 0x22cff0
leaq -0x30(%rbp), %rdi
callq 0x1ca150
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 0x1ca150
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 |
867 | Omega_h::Write<long>::Write(Omega_h::HostWrite<long>) | 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 0x1e02e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1bd640
jmp 0x22d054
leaq -0x20(%rbp), %rdi
callq 0x1e1240
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 0x1e1240
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 |
868 | Omega_h::HostWrite<long>::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 0x3ff358(%rip), %rsi # 0x62c432
xorl %eax, %eax
movl %eax, %edx
leaq -0x11(%rbp), %rdi
callq 0x1dc4d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c78d0
jmp 0x22d0f6
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 |
869 | Omega_h::Write<long>::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 0x22d165
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22d174
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 |
870 | Omega_h::Write<long>::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 |
871 | Omega_h::Write<long>::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 |
872 | Omega_h::Write<long>::set(int, long) 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)
movq %rdx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x39(%rbp), %rdi
leaq 0x3ff210(%rip), %rsi # 0x62c406
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x48(%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)
leaq -0x39(%rbp), %rdi
callq 0x1d03d0
addq $0x50, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
873 | Omega_h::Write<long>::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 0x3ff1ba(%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
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x1d03d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array.cpp |
874 | Omega_h::Write<long>::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 |
875 | Omega_h::Write<long>::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 |
876 | Omega_h::Write<long>::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 |
877 | Omega_h::Write<long>::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 |
878 | Omega_h::Write<long>::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 0x22d395
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x22d3a4
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 |
879 | Omega_h::Read<long>::Read() | OMEGA_H_INLINE Read() {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ce4f0
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 |
880 | Omega_h::Read<long>::Read(Omega_h::Write<long>) | 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 0x1c78d0
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 |
881 | Omega_h::Read<long>::Read(int, long, 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1bd580
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x1c3ca0
jmp 0x22d446
leaq -0x30(%rbp), %rdi
callq 0x1e1240
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 0x1e1240
movq -0x38(%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 |
882 | Omega_h::Read<long>::Read(int, long, long, 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c59f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1c3ca0
jmp 0x22d4ce
leaq -0x38(%rbp), %rdi
callq 0x1e1240
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 0x1e1240
movq -0x40(%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 |
883 | Omega_h::Read<long>::Read(std::initializer_list<long>, 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 0x1c8960
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1e02e0
jmp 0x22d550
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c3ca0
jmp 0x22d55f
leaq -0x30(%rbp), %rdi
callq 0x1e1240
leaq -0x40(%rbp), %rdi
callq 0x1ca150
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x22d59a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1e1240
leaq -0x40(%rbp), %rdi
callq 0x1ca150
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 |
884 | Omega_h::Read<long>::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 0x22d5ed
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22d5fc
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 |
885 | Omega_h::Read<long>::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 |
886 | Omega_h::Read<long>::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 0x1bfaa0
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 |
887 | Omega_h::Read<long>::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 0x1be4d0
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 |
888 | Omega_h::Read<long>::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 0x22d71d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x22d72c
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 0x1be4d0
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 |
889 | Omega_h::Read<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 |
890 | Omega_h::Read<long>::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 0x1c1330
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 |
891 | Omega_h::Read<long>::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 |
892 | Omega_h::Read<long>::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 0x22d855
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x22d864
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 |
893 | Omega_h::HostWrite<long>::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 0x1b9940
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 |
894 | Omega_h::HostWrite<long>::HostWrite(int, long, long, 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)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c59f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1d00e0
jmp 0x22d8fe
leaq -0x38(%rbp), %rdi
callq 0x1e1240
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 0x1e1240
movq -0x40(%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 |
895 | Omega_h::HostWrite<long>::HostWrite(Omega_h::Write<long>) | 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 0x1c78d0
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 |
896 | Omega_h::HostWrite<long>::HostWrite(std::initializer_list<long>, 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 0x1d83b0
movq -0x50(%rbp), %rdi
movl %eax, %esi
movq -0x20(%rbp), %rdx
callq 0x1e37d0
movl $0x0, -0x24(%rbp)
leaq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1e2d30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1c8ae0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x22d9f7
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
callq 0x1e3260
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x22d9b1
addq $0x60, %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 |
897 | std::initializer_list<long>::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 |
898 | std::initializer_list<long>::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 |
899 | std::initializer_list<long>::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 0x1e2d30
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1d83b0
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.