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 |
|---|---|---|---|---|---|---|
6,900 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Write<long> Omega_h::unmap<long>(Omega_h::Read<int>, Omega_h::Read<long>, int)::'lambda'(int)&>(long, long, Omega_h::Write<long> Omega_h::unmap<long>(Omega_h::Read<int>, Omega_h::Read<long>, int)::'lambda'(int)&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cd988
jmp 0x3cda1a
movq 0x3... | 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 |
6,901 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::unmap_range<long>(int, int, Omega_h::Read<long>, int)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::unmap_range<long>(int, int, Omega_h::Read<long>, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cdcb8
jmp 0x3cdd47
movq 0x3... | 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 |
6,902 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::expand_into<long>(Omega_h::Read<long>, Omega_h::Read<int>, Omega_h::Write<long>, int)::'lambda'(int)&>(long, long, void Omega_h::expand_into<long>(Omega_h::Read<long>, Omega_h::Read<int>, Omega_h::Write<long>, int)::'lambda'(int)&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cdee8
jmp 0x3cdf7a
movq 0x3... | 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 |
6,903 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::MinFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MinFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MinFunctor<long>::input_type>, int)::'lambda'(int)>(int, Omega_h::MinFunctor<long> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,904 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::MinFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MinFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MinFunctor<long>::input_type>, int)::'lambda'(int)>(Omega_h::MinFunctor<long>, Omega_h::MinFunctor<long>, Omega_h::Read<Omega_h... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3ce3c8
jmp 0x3ce45a
movq 0x3... | 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 |
6,905 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<long>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<long> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,906 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::MaxFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<long>::input_type>, int)::'lambda'(int)>(Omega_h::MaxFunctor<long>, Omega_h::MaxFunctor<long>, Omega_h::Read<Omega_h... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3ce9a8
jmp 0x3cea3a
movq 0x3... | 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 |
6,907 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::SumFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<long>::input_type>, int)::'lambda'(int)>(int, Omega_h::SumFunctor<long> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,908 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::SumFunctor<long>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<long>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<long>::input_type>, int)::'lambda'(int)>(Omega_h::SumFunctor<long>, Omega_h::SumFunctor<long>, Omega_h::Read<Omega_h... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cef88
jmp 0x3cf01a
movq 0x3... | 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 |
6,909 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::add_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)>(double, double, void Omega_h::add_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cf428
jmp 0x3cf4ba
movq 0x3... | 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 |
6,910 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::map_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)&>(double, double, void Omega_h::map_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cf6e8
jmp 0x3cf77a
movq 0x3... | 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 |
6,911 | void Omega_h::parallel_for<void Omega_h::map_value_into<double>(double, Omega_h::Read<int>, Omega_h::Write<double>)::'lambda'(int)>(int, double const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,912 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::map_value_into<double>(double, Omega_h::Read<int>, Omega_h::Write<double>)::'lambda'(int)>(double, double, void Omega_h::map_value_into<double>(double, Omega_h::Read<int>, Omega_h::Write<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cfac8
jmp 0x3cfb57
movq 0x3... | 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 |
6,913 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::map_into_range<double>(Omega_h::Read<double>, int, int, Omega_h::Write<double>, int)::'lambda'(int)>(double, double, void Omega_h::map_into_range<double>(Omega_h::Read<double>, int, int, Omega_h::Write<double>, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cfd28
jmp 0x3cfdb7
movq 0x3... | 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 |
6,914 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Write<double> Omega_h::unmap<double>(Omega_h::Read<int>, Omega_h::Read<double>, int)::'lambda'(int)&>(double, double, Omega_h::Write<double> Omega_h::unmap<double>(Omega_h::Read<int>, Omega_h::Read<double>, int)::'lambda'(int)&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3cff58
jmp 0x3cffea
movq 0x3... | 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 |
6,915 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::unmap_range<double>(int, int, Omega_h::Read<double>, int)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::unmap_range<double>(int, int, Omega_h::Read<double>, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d0288
jmp 0x3d0317
movq 0x3... | 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 |
6,916 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::expand_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)&>(double, double, void Omega_h::expand_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)::'lambda'(int)&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d04b8
jmp 0x3d054a
movq 0x3... | 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 |
6,917 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::MinFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MinFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MinFunctor<double>::input_type>, int)::'lambda'(int)>(int, Omega_h::MinFunctor<double> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,918 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::MinFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MinFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MinFunctor<double>::input_type>, int)::'lambda'(int)>(Omega_h::MinFunctor<double>, Omega_h::MinFunctor<double>, Omega_h::Re... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d0998
jmp 0x3d0a2a
movq 0x3... | 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 |
6,919 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<double>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<double> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,920 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::MaxFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<double>::input_type>, int)::'lambda'(int)>(Omega_h::MaxFunctor<double>, Omega_h::MaxFunctor<double>, Omega_h::Re... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d0f88
jmp 0x3d101a
movq 0x3... | 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 |
6,921 | void Omega_h::parallel_for<Omega_h::Read<Omega_h::SumFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<double>::input_type>, int)::'lambda'(int)>(int, Omega_h::SumFunctor<double> const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | 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 |
6,922 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<Omega_h::SumFunctor<double>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::SumFunctor<double>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::SumFunctor<double>::input_type>, int)::'lambda'(int)>(Omega_h::SumFunctor<double>, Omega_h::SumFunctor<double>, Omega_h::Re... | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d1578
jmp 0x3d160a
movq 0x3... | 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 |
6,923 | Omega_h::mark_exposed_sides(Omega_h::Mesh*) | Read<I8> mark_exposed_sides(Mesh* mesh) {
auto ns = mesh->nents(mesh->dim() - 1);
auto s2sc = mesh->ask_up(mesh->dim() - 1, mesh->dim()).a2ab;
Write<I8> exposed(ns);
auto f = OMEGA_H_LAMBDA(LO s) { exposed[s] = ((s2sc[s + 1] - s2sc[s]) < 2); };
parallel_for(ns, f, "mark_exposed_sides");
return exposed;
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1ddc00
movq -0xf0(%rbp), %rdi
movl %eax, %esi
decl %esi
callq 0x1c0460
movl %eax, -0x14(... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,924 | void Omega_h::parallel_for<Omega_h::mark_exposed_sides(Omega_h::Mesh*)::$_0>(int, Omega_h::mark_exposed_sides(Omega_h::Mesh*)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
6,925 | Omega_h::mark_down(Omega_h::Graph, Omega_h::Read<signed char>) | Read<I8> mark_down(Graph l2h, Read<I8> high_marked) {
auto l2lh = l2h.a2ab;
auto lh2h = l2h.ab2b;
auto nl = l2lh.size() - 1;
Write<I8> low_marks_w(nl, 0);
auto f = OMEGA_H_LAMBDA(LO l) {
for (LO lh = l2lh[l]; lh < l2lh[l + 1]; ++lh)
if (high_marked[lh2h[lh]]) low_marks_w[l] = 1;
};
parallel_for(... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdx, -0x110(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1d99b0
movq -0xf8(%rbp), %rsi
addq $0x1... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,926 | void Omega_h::parallel_for<Omega_h::mark_down(Omega_h::Graph, Omega_h::Read<signed char>)::$_0>(int, Omega_h::mark_down(Omega_h::Graph, Omega_h::Read<signed char>)::$_0&&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1dfbb0
movq -0xe0(%rbp), %rdx
leaq 0x2599ec(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x3d1fe1
leaq 0x25928d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
6,927 | Omega_h::mark_down(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>) | Read<I8> mark_down(
Mesh* mesh, Int high_dim, Int low_dim, Read<I8> high_marked) {
OMEGA_H_CHECK(0 <= low_dim);
OMEGA_H_CHECK(low_dim <= high_dim);
OMEGA_H_CHECK(high_dim <= 3);
if (high_dim == low_dim) return high_marked;
auto l2h = mesh->ask_up(low_dim, high_dim);
auto low_marks = mark_down(l2h, high_... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %r8, -0xf0(%rbp)
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x18(%rbp), %eax
jg 0x3d223e
jm... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,928 | Omega_h::mark_up(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>) | Read<I8> mark_up(Mesh* mesh, Int low_dim, Int high_dim, Read<I8> low_marked) {
auto l2h = mesh->ask_down(high_dim, low_dim);
auto deg = element_degree(mesh->family(), high_dim, low_dim);
auto hl2l = l2h.ab2b;
auto nh = mesh->nents(high_dim);
Write<I8> out(nh, 0);
auto f = OMEGA_H_LAMBDA(LO h) {
for (Int... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %r8, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl %ecx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %edx
mov... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,929 | void Omega_h::parallel_for<Omega_h::mark_up(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0>(int, Omega_h::mark_up(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
6,930 | Omega_h::mark_adj(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>) | Read<I8> mark_adj(Mesh* mesh, Int from_dim, Int to_dim, Read<I8> from_marked) {
if (from_dim == to_dim) return from_marked;
if (from_dim < to_dim) return mark_up(mesh, from_dim, to_dim, from_marked);
if (from_dim > to_dim) return mark_down(mesh, from_dim, to_dim, from_marked);
OMEGA_H_NORETURN(Read<I8>());
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %r8, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x3d2d16
movq -0x68(%rbp), %r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,931 | Omega_h::mark_up_all(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>) | Read<I8> mark_up_all(
Mesh* mesh, Int low_dim, Int high_dim, Read<I8> low_marked) {
auto l2h = mesh->ask_down(high_dim, low_dim);
auto deg = element_degree(mesh->family(), high_dim, low_dim);
auto hl2l = l2h.ab2b;
auto nh = mesh->nents(high_dim);
Write<I8> out(nh, 0);
auto f = OMEGA_H_LAMBDA(LO h) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %r8, -0x140(%rbp)
movq %rdi, -0x138(%rbp)
movq %rdi, %rax
movq %rax, -0x130(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movl %ecx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %edx
mov... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,932 | void Omega_h::parallel_for<Omega_h::mark_up_all(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0>(int, Omega_h::mark_up_all(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
6,933 | Omega_h::mark_by_class_dim(Omega_h::Mesh*, int, int) | Read<I8> mark_by_class_dim(Mesh* mesh, Int ent_dim, Int class_dim) {
auto e2class_dim = mesh->get_array<I8>(ent_dim, "class_dim");
return each_eq_to(e2class_dim, static_cast<I8>(class_dim));
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x49(%rbp), %rdi
movq %rd... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,934 | Omega_h::mark_by_class(Omega_h::Mesh*, int, int, int) | Read<I8> mark_by_class(Mesh* mesh, Int ent_dim, Int class_dim, I32 class_id) {
auto e2class_id = mesh->get_array<ClassId>(ent_dim, "class_id");
auto id_marks = each_eq_to(e2class_id, class_id);
return land_each(id_marks, mark_by_class_dim(mesh, ent_dim, class_dim));
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,935 | Omega_h::mark_class_closure(Omega_h::Mesh*, int, int, int) | Read<I8> mark_class_closure(
Mesh* mesh, Int ent_dim, Int class_dim, ClassId class_id) {
OMEGA_H_CHECK(ent_dim <= class_dim);
auto eq_marks = mark_by_class(mesh, class_dim, class_dim, class_id);
if (ent_dim == class_dim) return eq_marks;
return mark_down(mesh, class_dim, ent_dim, eq_marks);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x3d38df
jmp 0x3d3900
leaq 0x257782(%rip), %rdi ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,936 | Omega_h::get_eq_marks(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&) | Read<I8> get_eq_marks(
Mesh* mesh, Int class_dim, std::vector<ClassId> const& class_ids) {
auto sorted_class_ids = class_ids;
std::sort(begin(sorted_class_ids), end(sorted_class_ids));
HostWrite<LO> h_sorted_class_ids(LO(sorted_class_ids.size()));
for (size_t i = 0; i < sorted_class_ids.size(); ++i) {
h... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movl %edx, -0x34(%rbp)
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x1c19f0
movq -0x1... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,937 | void Omega_h::parallel_for<Omega_h::get_eq_marks(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&)::$_0>(int, Omega_h::get_eq_marks(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
6,938 | Omega_h::mark_class_closures(Omega_h::Mesh*, int, int, std::vector<int, std::allocator<int>> const&) | Read<I8> mark_class_closures(Mesh* mesh, Int ent_dim, Int class_dim,
std::vector<ClassId> const& class_ids) {
OMEGA_H_CHECK(class_dim >= ent_dim);
auto eq_marks = get_eq_marks(mesh, class_dim, class_ids);
auto marks = mark_down(mesh, class_dim, ent_dim, eq_marks);
return marks;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x3d4202
jmp 0x3d4223
leaq 0x256e5f(%rip), %rdi #... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,939 | Omega_h::mark_class_closures(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&, Omega_h::Graph) | Read<I8> mark_class_closures(Mesh* mesh, Int class_dim,
std::vector<ClassId> const& class_ids, Graph nodes2ents) {
OMEGA_H_CHECK(nodes2ents.a2ab.exists());
OMEGA_H_CHECK(nodes2ents.ab2b.exists());
auto eq_marks = get_eq_marks(mesh, class_dim, class_ids);
auto marks = mark_down(nodes2ents, eq_marks);
retur... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %r8, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x44(%rbp)
movq %rcx, -0x50(%rbp)
movq %r8, -0x58(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,940 | Omega_h::mark_class_closures(Omega_h::Mesh*, int, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>> const&) | Read<I8> mark_class_closures(
Mesh* mesh, Int ent_dim, std::vector<ClassPair> const& class_pairs) {
auto marks = Read<I8>(mesh->nents(ent_dim), I8(0));
for (Int class_dim = ent_dim; class_dim <= mesh->dim(); ++class_dim) {
auto dim_class_ids = get_dim_class_ids(class_dim, class_pairs);
if (dim_class_ids... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c0460
movl %eax, -0xcc(%rbp)
leaq -0x49(%rbp)... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,941 | Omega_h::get_dim_class_ids(int, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>> const&) | static std::vector<LO> get_dim_class_ids(
Int class_dim, std::vector<ClassPair> const& class_pairs) {
std::vector<LO> dim_class_ids;
for (size_t i = 0; i < class_pairs.size(); ++i) {
if (class_pairs[i].dim == class_dim) {
dim_class_ids.push_back(class_pairs[i].id);
}
}
return dim_class_ids;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1d91a0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ce020
mo... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,942 | Omega_h::mark_class_closures(Omega_h::Mesh*, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>> const&, Omega_h::Graph*) | Read<I8> mark_class_closures(Mesh* mesh,
std::vector<ClassPair> const& class_pairs, Graph nodes2ents[4]) {
auto dim = mesh->dim();
OMEGA_H_CHECK(nodes2ents[dim].a2ab.exists());
auto nnodes = nodes2ents[dim].a2ab.size() - 1;
auto marks = Read<I8>(nnodes, I8(0));
for (int class_dim = 0; class_dim <= dim; ++... | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1ddc00
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movslq -0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,943 | Omega_h::mark_dual_layers(Omega_h::Mesh*, Omega_h::Read<signed char>, int) | Read<I8> mark_dual_layers(Mesh* mesh, Read<I8> marks, Int nlayers) {
OMEGA_H_CHECK(mesh->parting() == OMEGA_H_GHOSTED);
auto dual = mesh->ask_dual();
for (Int i = 0; i < nlayers; ++i) {
marks = graph_reduce(dual, marks, 1, OMEGA_H_MAX);
marks = mesh->sync_array(mesh->dim(), marks, 1);
}
return marks;
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xd0(%rbp)
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d4820
cmpl $0x1, %eax
jne 0x3d4d02
jmp 0x3d4d23
leaq 0x25635f(%rip),... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,944 | Omega_h::count_owned_marks(Omega_h::Mesh*, int, Omega_h::Read<signed char>) | GO count_owned_marks(Mesh* mesh, Int ent_dim, Read<I8> marks) {
if (mesh->could_be_shared(ent_dim)) {
marks = land_each(marks, mesh->owned(ent_dim));
}
return get_sum(mesh->comm(), marks);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x1d0aa0
testb $0x1, %al
jne 0x3d4f5f
jmp 0x3d5005
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1bec60
movq -0x8(%rbp), %rsi
mo... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,945 | Omega_h::mark_sliver_layers(Omega_h::Mesh*, double, int) | Read<I8> mark_sliver_layers(Mesh* mesh, Real qual_ceil, Int nlayers) {
OMEGA_H_CHECK(mesh->parting() == OMEGA_H_GHOSTED);
auto quals = mesh->ask_qualities();
auto elems_are_slivers = each_lt(quals, qual_ceil);
return mark_dual_layers(mesh, elems_are_slivers, nlayers);
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d4820
cmpl $0x1, %eax
jne 0x3d50d6
jmp 0x3d50f7
leaq 0x255f8b(%rip), %rdi # 0x62b068
l... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mark.cpp |
6,946 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::mark_exposed_sides(Omega_h::Mesh*)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::mark_exposed_sides(Omega_h::Mesh*)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d5295
jmp 0x3d5324
movq 0x3... | 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 |
6,947 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::mark_down(Omega_h::Graph, Omega_h::Read<signed char>)::$_0&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::mark_down(Omega_h::Graph, Omega_h::Read<signed char>)::$_0&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d54b8
jmp 0x3d554d
movq 0x3... | 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 |
6,948 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::mark_up(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::mark_up(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d5908
jmp 0x3d599a
movq 0x3... | 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 |
6,949 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::mark_up_all(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::mark_up_all(Omega_h::Mesh*, int, int, Omega_h::Read<signed char>)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d5c78
jmp 0x3d5d0a
movq 0x3... | 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 |
6,950 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::get_eq_marks(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::get_eq_marks(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x3d6038
jmp 0x3d60d9
movq 0x3... | 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 |
6,951 | decltype(fp.end()) std::end<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>>&) | inline _GLIBCXX17_CONSTEXPR auto
end(_Container& __cont) -> decltype(__cont.end())
{ return __cont.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c7240
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/range_access.h |
6,952 | std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>::operator[](unsigned long) const | const_reference
operator[](size_type __n) const _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,953 | std::__lg(long) | inline _GLIBCXX_CONSTEXPR long
__lg(long __n)
{ return (int)sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
bsrq %rax, %rax
xorq $0x3f, %rax
movl %eax, %ecx
movl $0x3f, %eax
subl %ecx, %eax
cltq
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/bits/stl_algobase.h |
6,954 | _gnu_cxx::__ops::_Iter_less_val::_Iter_less_val(__gnu_cxx::__ops::_Iter_less_iter) | _GLIBCXX20_CONSTEXPR
bool
operator()(_Iterator __it, _Value& __val) const
{ return *__it < __val; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/predefined_ops.h |
6,955 | Omega_h::math_lang::build_language() | Language build_language() {
Language out;
auto& prods = out.productions;
prods.resize(NPRODS);
prods[PROD_PROGRAM] = {"program", {"statements", "expr?"}};
prods[PROD_NO_STATEMENTS] = {"statements", {}};
prods[PROD_NEXT_STATEMENT] = {
"statements", {"statements", "statement", ";", "S?"}};
prods[PROD_... | pushq %rbp
movq %rsp, %rbp
subq $0x3940, %rsp # imm = 0x3940
movq %rdi, -0x21d0(%rbp)
movq %rdi, %rax
movq %rax, -0x21d8(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x1c87f0
movq -0x21d0(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x27, %esi
callq 0x1c67c0
jmp ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,956 | Omega_h::math_lang::ask_language() | LanguagePtr ask_language() {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
static LanguagePtr ptr;
#ifdef __clang__
#pragma clang diagnostic pop
#endif
if (ptr.use_count() == 0) {
ptr.reset(new Language(build_language()));
}
return ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x32dd92(%rip) # 0x70eb00
jne 0x3e0da7
leaq 0x32dd89(%rip), %rdi # 0x70eb00
callq 0x1e0990
cmpl $0x0, %eax
je 0x3e0da7
movq 0x3170a8(%rip), %rdi # 0x6f7e30
leaq 0x32dd61(%r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,957 | Omega_h::math_lang::ask_reader_tables() | ReaderTablesPtr ask_reader_tables() {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
static ReaderTablesPtr ptr;
#ifdef __clang__
#pragma clang diagnostic pop
#endif
if (ptr.use_count() == 0) {
LanguagePtr lang = ask_language();
ptr = build_r... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0x32dcca(%rip) # 0x70eb18
jne 0x3e0e87
leaq 0x32dcc1(%rip), %rdi # 0x70eb18
callq 0x1e0990
cmpl $0x0, %eax
je 0x3e0e87
movq 0x316da0(%rip), %rdi # 0x6f7c08
leaq 0x32dc99(%r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,958 | Omega_h::math_lang::SymbolSetReader::SymbolSetReader() | SymbolSetReader::SymbolSetReader() : Reader(ask_reader_tables()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1cde40
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1c12d0
jmp 0x3e0f50
leaq -0x18(%rbp), %rdi
callq 0x1e4eb0
movq -0x38(%rbp), %rdi
movq 0x316e94... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,959 | Omega_h::math_lang::SymbolSetReader::at_shift(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | any SymbolSetReader::at_shift(int token, std::string& text) {
if (token == TOK_NAME) return text;
return any();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3e0fe7
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1e4490
jmp 0x3e0ff0
movq -0x30(%r... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,960 | Omega_h::math_lang::SymbolSetReader::at_reduce(int, std::vector<Omega_h::any, std::allocator<Omega_h::any>>&) | any SymbolSetReader::at_reduce(int prod, std::vector<any>& rhs) {
if (prod == PROD_VAR) {
auto& name = any_cast<std::string&>(rhs.at(0));
variable_names.insert(name);
} else if (prod == PROD_CALL) {
auto& name = any_cast<std::string&>(rhs.at(0));
function_names.insert(name);
}
return any();
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x24, -0x14(%rbp)
jne 0x3e1066
movq -0x20(%rbp), %rdi
xorl %eax, %eax
m... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,961 | Omega_h::math_lang::get_variables_used(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::set<std::string> get_variables_used(std::string const& expr) {
SymbolSetReader reader;
reader.read_string(expr, "get_variables_used");
return reader.variable_names;
} | pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x278(%rbp)
movq %rdi, %rax
movq %rax, -0x270(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x1c1a70
movq -0x10(%rbp), %rax
movq %rax, -0x268(%rbp)
leaq -0x241(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,962 | Omega_h::math_lang::get_symbols_used(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::set<std::string> get_symbols_used(std::string const& expr) {
SymbolSetReader reader;
reader.read_string(expr, "get_symbols_used");
auto set = std::move(reader.variable_names);
set.insert(reader.function_names.begin(), reader.function_names.end());
return set;
} | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x288(%rbp)
movq %rdi, %rax
movq %rax, -0x280(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x1c1a70
movq -0x10(%rbp), %rax
movq %rax, -0x278(%rbp)
leaq -0x241(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,963 | std::vector<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::resize(unsigned long) | void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1bdfc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x3e1454
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,964 | std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::vector(std::initializer_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::_... | vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1b92c0
leaq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1c50e0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,965 | std::vector<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x38, -0x10(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,966 | std::vector<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::resize(unsigned long) | void
resize(size_type __new_size)
{
if (__new_size > size())
_M_default_append(__new_size - size());
else if (__new_size < size())
_M_erase_at_end(this->_M_impl._M_start + __new_size);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1beb40
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jbe 0x3e15f4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, ... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,967 | std::vector<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::operator[](unsigned long) | reference
operator[](size_type __n) _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_subscript(__n);
return *(this->_M_impl._M_start + __n);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,968 | std::__shared_ptr<Omega_h::Language, (__gnu_cxx::_Lock_policy)2>::use_count() const | long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bea90
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
6,969 | std::enable_if<__sp_is_constructible<Omega_h::Language, Omega_h::Language>::value, void>::type std::__shared_ptr<Omega_h::Language, (__gnu_cxx::_Lock_policy)2>::reset<Omega_h::Language>(Omega_h::Language*) | _SafeConv<_Yp>
reset(_Yp* __p) // _Yp must be complete.
{
// Catch self-reset errors.
__glibcxx_assert(__p == nullptr || __p != _M_ptr);
__shared_ptr(__p).swap(*this);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x3e174a
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1daa50
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1d1d70
leaq -0x20(%rbp), %rdi
callq 0x1bc5b0
addq $0x30, %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
6,970 | std::shared_ptr<Omega_h::Language>::shared_ptr(std::shared_ptr<Omega_h::Language> const&) | shared_ptr(const shared_ptr&) noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
6,971 | std::__shared_ptr<Omega_h::ReaderTables const, (__gnu_cxx::_Lock_policy)2>::use_count() const | long
use_count() const noexcept
{ return _M_refcount._M_get_use_count(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1bea90
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
6,972 | std::__shared_ptr_access<Omega_h::Language, (__gnu_cxx::_Lock_policy)2, false, false>::operator*() const | element_type&
operator*() const noexcept
{
__glibcxx_assert(_M_get() != nullptr);
return *_M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3e17e6
jmp 0x3e17e8
movq -0x10(%rbp), %rdi
callq 0x1bb530
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
6,973 | std::shared_ptr<Omega_h::ReaderTables const>::operator=(std::shared_ptr<Omega_h::ReaderTables const>&&) | shared_ptr&
operator=(shared_ptr&& __r) noexcept
{
this->__shared_ptr<_Tp>::operator=(std::move(__r));
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d44d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
6,974 | std::shared_ptr<Omega_h::ReaderTables const>::shared_ptr(std::shared_ptr<Omega_h::ReaderTables const> const&) | shared_ptr(const shared_ptr&) noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cdd00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
6,975 | std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::set(std::set<std::__cxx11::basic_string<cha... | set(const set&) = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1dcc80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_set.h |
6,976 | Omega_h::math_lang::SymbolSetReader::~SymbolSetReader() | ~SymbolSetReader() override = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq 0x31654d(%rip), %rax # 0x6f7df8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1c8, %rdi # imm = 0x1C8
callq 0x1bcad0
movq -0x10(%rbp), %rdi
addq $0x198, %rdi # imm = 0x198
callq 0x1b... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_math_lang.cpp |
6,977 | std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::set(std::set<std::__cxx11::basic_string<cha... | set(set&&) = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1b8ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_set.h |
6,978 | void std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::insert<std::_Rb_tree_const_iterator<st... | void
insert(_InputIterator __first, _InputIterator __last)
{ _M_t._M_insert_range_unique(__first, __last); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1dc630
addq $0x30, %rsp
popq %rbp
retq
n... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_set.h |
6,979 | std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::begin() const | iterator
begin() const _GLIBCXX_NOEXCEPT
{ return _M_t.begin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d69a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_set.h |
6,980 | std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::end() const | iterator
end() const _GLIBCXX_NOEXCEPT
{ return _M_t.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1db4a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_set.h |
6,981 | Omega_h::math_lang::SymbolSetReader::~SymbolSetReader() | ~SymbolSetReader() override = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1bc4f0
movq -0x10(%rbp), %rdi
movl $0x1f8, %esi # imm = 0x1F8
callq 0x1ce050
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_math_lang.cpp |
6,982 | std::vector<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d4ea0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,983 | std::vector<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d07d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,984 | std::_Vector_base<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bdfd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,985 | std::_Vector_base<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c32b0
movq -0x10(%rbp), %rdi
callq 0x1cada0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,986 | std::allocator<Omega_h::Language::Token>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf320
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
6,987 | std::_Vector_base<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,988 | _gnu_cxx::new_allocator<Omega_h::Language::Token>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
6,989 | std::_Vector_base<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dad40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,990 | std::_Vector_base<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1da690
movq -0x10(%rbp), %rdi
callq 0x1bf2e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,991 | std::allocator<Omega_h::Language::Production>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d33f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
6,992 | std::_Vector_base<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,993 | _gnu_cxx::new_allocator<Omega_h::Language::Production>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
6,994 | std::vector<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1cdca0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1caba0
jmp 0x3e1bba
movq -0x20(%rbp), %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,995 | std::vector<Omega_h::Language::Token, std::allocator<Omega_h::Language::Token>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1cd8b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1bc160
jmp 0x3e1c1a
movq -0x20(%rbp), %... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,996 | void std::_Destroy<Omega_h::Language::Production*, Omega_h::Language::Production>(Omega_h::Language::Production*, Omega_h::Language::Production*, std::allocator<Omega_h::Language::Production>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c07f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
6,997 | std::_Vector_base<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,998 | std::_Vector_base<Omega_h::Language::Production, std::allocator<Omega_h::Language::Production>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
callq 0x1b8960
jmp 0x3e1cb7
movq -0x10(%rbp), %rdi
callq 0x... | gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
6,999 | void std::_Destroy<Omega_h::Language::Production*>(Omega_h::Language::Production*, Omega_h::Language::Production*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
st... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e01d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.