name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
Omega_h::BBox<3> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<3>, Omega_h::BBox<3>, Omega_h::UniteOp<3>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<3>, Omega_h::UniteOp<3>, Omega_h::GetBBoxOp<3>&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x110(%rsp), %r12
movq 0x1d6611(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xfbcb0
movb $0x0, (%r13)
leaq 0x48(%rsp), %rax
movslq %r14d, %rcx
movslq %ebp, %rdx
imulq $0x18, %rcx, %rsi
addq 0x8(%r15), %rsi
cmpq %rdx, %rcx
je 0x13b7d9
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x13b6fc
movsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rsp,%rdi,8)
incq %rdi
jmp 0x13b6e7
movq 0x10(%rsp), %rdi
movq %rdi, 0x10(%rax)
movups (%rsp), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movups (%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movaps 0x50(%rsp), %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movaps %xmm0, (%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x90(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x13b7a0
movsd (%rsp,%rdi,8), %xmm0
movsd 0x18(%rsp,%rdi,8), %xmm1
minsd 0x70(%rsp,%rdi,8), %xmm0
movsd %xmm0, 0xa8(%rsp,%rdi,8)
maxsd 0x88(%rsp,%rdi,8), %xmm1
movsd %xmm1, 0xc0(%rsp,%rdi,8)
incq %rdi
jmp 0x13b769
movupd 0xa8(%rsp), %xmm0
movupd 0xb8(%rsp), %xmm1
movups 0xc8(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movupd %xmm1, 0x10(%r12)
movupd %xmm0, (%r12)
incq %rcx
addq $0x18, %rsi
jmp 0x13b6dc
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x60(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
Omega_h::BBox<1> Omega_h::get_bounding_box<1>(Omega_h::Mesh*)
|
BBox<dim> get_bounding_box(Mesh* mesh) {
auto bb = find_bounding_box<dim>(mesh->coords());
for (Int i = 0; i < dim; ++i) {
bb.min[i] = mesh->comm()->allreduce(bb.min[i], OMEGA_H_MIN);
bb.max[i] = mesh->comm()->allreduce(bb.max[i], OMEGA_H_MAX);
}
return bb;
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xffe20
movq %r14, %rdi
callq 0xef430
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xfdc90
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeef10
movq (%r14), %rdi
movsd 0x10(%rsp), %xmm0
xorl %esi, %esi
callq 0xf3800
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf6d50
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeef10
movq (%r14), %rdi
pushq $0x1
popq %rsi
movsd 0x8(%rsp), %xmm0
callq 0xf3800
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf6d50
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x13b8c3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf6d50
jmp 0x13b8df
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_bbox.cpp
|
std::vector<int, std::allocator<int>>::const_reference Omega_h::at<int>(std::vector<int, std::allocator<int>> const&, int)
|
inline typename std::vector<T>::const_reference at(
std::vector<T> const& v, int i) {
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < int(v.size()));
return v[std::size_t(i)];
}
|
pushq %rax
testl %esi, %esi
js 0x147263
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
cmpl %esi, %ecx
jle 0x14727c
movl %esi, %ecx
leaq (%rax,%rcx,4), %rax
popq %rcx
retq
leaq 0x12fe1e(%rip), %rdi # 0x277088
leaq 0x1323c4(%rip), %rsi # 0x279635
leaq 0x1323c4(%rip), %rdx # 0x27963c
pushq $0x1d
jmp 0x147293
leaq 0x12fe05(%rip), %rdi # 0x277088
leaq 0x13247f(%rip), %rsi # 0x279709
leaq 0x1323ab(%rip), %rdx # 0x27963c
pushq $0x1e
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
nop
|
/gahansen[P]omega_h/src/Omega_h_std_vector.hpp
|
bool Omega_h::intersects<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&)
|
bool intersects(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) {
auto it = a.find(x);
if (it != a.end()) return true;
}
return false;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r12
cmpq %rbx, %r15
je 0x148b82
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xfdbe0
cmpq %r12, %rax
jne 0x148b82
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x148b5f
cmpq %rbx, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/gahansen[P]omega_h/src/Omega_h_set.hpp
|
std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>::const_reference Omega_h::at<std::set<int, std::less<int>, std::allocator<int>>>(std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>> const&, int)
|
inline typename std::vector<T>::const_reference at(
std::vector<T> const& v, int i) {
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < int(v.size()));
return v[std::size_t(i)];
}
|
pushq %rax
testl %esi, %esi
js 0x148cb1
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
pushq $0x30
popq %rdi
cqto
idivq %rdi
cmpl %esi, %eax
jle 0x148cca
movl %esi, %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq %rcx, %rax
popq %rcx
retq
leaq 0x12e3d0(%rip), %rdi # 0x277088
leaq 0x130976(%rip), %rsi # 0x279635
leaq 0x130976(%rip), %rdx # 0x27963c
pushq $0x1d
jmp 0x148ce1
leaq 0x12e3b7(%rip), %rdi # 0x277088
leaq 0x130a31(%rip), %rsi # 0x279709
leaq 0x13095d(%rip), %rdx # 0x27963c
pushq $0x1e
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
|
/gahansen[P]omega_h/src/Omega_h_std_vector.hpp
|
void Omega_h::unite_with<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&)
|
void unite_with(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) a.insert(x);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x148d1a
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xf7390
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x148cfc
popq %rbx
popq %r14
popq %r15
retq
|
/gahansen[P]omega_h/src/Omega_h_set.hpp
|
void Omega_h::subtract_from<int>(std::set<int, std::less<int>, std::allocator<int>>&, std::set<int, std::less<int>, std::allocator<int>> const&)
|
void subtract_from(std::set<T>& a, std::set<T> const& b) {
for (auto& x : b) {
auto it = a.find(x);
if (it == a.end()) continue;
a.erase(it);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r15
addq $0x8, %rbx
leaq 0x8(%rdi), %r12
cmpq %rbx, %r15
je 0x148f2b
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0xfdbe0
cmpq %r12, %rax
je 0x148f1e
movq %r14, %rdi
movq %rax, %rsi
callq 0xecb70
movq %r15, %rdi
callq 0xf86e0
movq %rax, %r15
jmp 0x148efd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_set.hpp
|
Omega_h::check_collapse_class(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
Read<I8> check_collapse_class(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes) {
auto ncands = cands2edges.size();
auto verts2class_dim = mesh->get_array<I8>(VERT, "class_dim");
auto edges2class_dim = mesh->get_array<I8>(EDGE, "class_dim");
auto edge_verts2verts = mesh->ask_verts_of(EDGE);
auto cand_codes_w = Write<I8>(ncands);
auto f = OMEGA_H_LAMBDA(LO cand) {
auto code = cand_codes[cand];
auto edge = cands2edges[cand];
LO eev2v[2];
for (Int eev = 0; eev < 2; ++eev)
eev2v[eev] = edge_verts2verts[edge * 2 + eev];
Int eev_cd[2];
for (Int eev = 0; eev < 2; ++eev) eev_cd[eev] = verts2class_dim[eev2v[eev]];
Int e_cd = edges2class_dim[edge];
/* if both vertices are classified onto the same dimension,
the edge must also be classified onto that dimension */
if (eev_cd[0] == eev_cd[1]) {
if (eev_cd[0] != e_cd) code = DONT_COLLAPSE;
} else {
for (Int col_v = 0; col_v < 2; ++col_v) {
if (collapses(cand_codes[cand], col_v)) {
/* otherwise, the vertex to collapse and the edge must
be classified onto the same dimension */
if (eev_cd[col_v] != e_cd) {
code = dont_collapse(code, col_v);
}
}
}
}
cand_codes_w[cand] = code;
};
parallel_for(ncands, f, "check_collapse_class");
return cand_codes_w;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x78(%rsp)
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x149ce5
movq (%r14), %r14
jmp 0x149ce9
shrq $0x3, %r14
leaq 0x135c0d(%rip), %rsi # 0x27f8fd
leaq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
callq 0xef870
leaq 0xb0(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %rbx, %rsi
xorl %edx, %edx
callq 0xef910
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x135bd3(%rip), %rsi # 0x27f8fd
leaq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
callq 0xef870
leaq 0xa0(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0x18(%rsp), %rcx
movq %rbx, %rsi
callq 0xef910
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
pushq $0x1
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0xf3940
leaq 0x13373d(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
callq 0xef870
shrq $0x2, %r14
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movl %r14d, %esi
callq 0xf0f30
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x128(%rsp), %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x138(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x148(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf0580
leaq 0x158(%rsp), %rbx
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0x168(%rsp), %r15
leaq 0xa0(%rsp), %rsi
movq %r15, %rdi
callq 0xf8e10
leaq 0x178(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0xf8e10
leaq 0xc8(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xf8e10
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0xf0580
leaq 0xe8(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xf0580
leaq 0xf8(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x108(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x118(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf8e10
testl %r14d, %r14d
jle 0x149fea
movq 0x1c7e14(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
leaq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x100b80
leaq 0x28(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xf4160
leaq 0x38(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xf4160
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x100b80
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x100b80
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x100b80
movb $0x0, (%r12)
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %eax, %eax
xorl %edx, %edx
cmpq %r14, %rdx
je 0x149fe0
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %r8
movb (%rcx,%rdx), %sil
movsbl %sil, %edi
movslq (%r8,%rdx,4), %rcx
leal (%rcx,%rcx), %r8d
movslq %r8d, %r8
shlq $0x2, %r8
addq 0x40(%rsp), %r8
xorl %r9d, %r9d
cmpq $0x2, %r9
je 0x149f6a
movl (%r8,%r9,4), %r10d
movl %r10d, 0xc0(%rsp,%r9,4)
incq %r9
jmp 0x149f53
movq 0x50(%rsp), %r8
xorl %r9d, %r9d
cmpq $0x2, %r9
je 0x149f8e
movslq 0xc0(%rsp,%r9,4), %r10
movsbl (%r8,%r10), %r10d
movl %r10d, (%rsp,%r9,4)
incq %r9
jmp 0x149f72
movq 0x60(%rsp), %r8
movsbl (%r8,%rcx), %r8d
movl (%rsp), %ecx
cmpl 0x4(%rsp), %ecx
jne 0x149fbc
cmpl %r8d, %ecx
movzbl %sil, %esi
cmovnel %eax, %esi
movq 0x70(%rsp), %rcx
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0x149f21
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x149fab
movl %ebp, %r9d
shll %cl, %r9d
btl %ecx, %edi
jae 0x149fdb
cmpl %r8d, (%rsp,%rcx,4)
je 0x149fdb
notb %r9b
andb %r9b, %sil
incq %rcx
jmp 0x149fbe
leaq 0x18(%rsp), %rdi
callq 0x14a216
leaq 0xc8(%rsp), %rdi
callq 0x14a216
leaq 0x80(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0xf8470
leaq 0x80(%rsp), %rdi
callq 0xf9e00
leaq 0x128(%rsp), %rdi
callq 0x14a216
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x90(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xf9e00
leaq 0xb0(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0xf9e00
jmp 0x14a08e
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xf9e00
jmp 0x14a09d
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xff620
jmp 0x14a0ac
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xff620
jmp 0x14a0bb
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0xc8(%rsp), %rdi
callq 0x14a216
jmp 0x14a1d0
movq %rax, %r14
jmp 0x14a0c5
movq %rax, %r14
leaq 0x80(%rsp), %rdi
jmp 0x14a132
movq %rax, %r14
movq %rbx, %rdi
callq 0xf9e00
jmp 0x14a0f9
movq %rax, %r14
movq %r13, %rdi
callq 0xf9e00
jmp 0x14a106
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
callq 0xff620
jmp 0x14a118
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
callq 0xff620
jmp 0x14a12a
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0xf9e00
jmp 0x14a1d0
movq %rax, %r14
movq %r15, %rdi
callq 0xf9e00
jmp 0x14a14c
movq %rax, %r14
movq %rbx, %rdi
callq 0xf9e00
jmp 0x14a159
movq %rax, %r14
leaq 0x148(%rsp), %rdi
callq 0xff620
jmp 0x14a16b
movq %rax, %r14
movq %r13, %rdi
callq 0xff620
jmp 0x14a178
movq %rax, %r14
leaq 0x128(%rsp), %rdi
callq 0xf9e00
jmp 0x14a1dd
movq %rax, %r14
jmp 0x14a1dd
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x14a1e7
movq %rax, %r14
jmp 0x14a1e7
movq %rax, %r14
jmp 0x14a1f4
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x14a201
movq %rax, %r14
jmp 0x14a201
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x14a20e
movq %rax, %r14
jmp 0x14a20e
movq %rax, %r14
leaq 0x128(%rsp), %rdi
callq 0x14a216
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x90(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xf9e00
leaq 0xb0(%rsp), %rdi
callq 0xf9e00
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_check_collapse.cpp
|
Omega_h::check_collapse_exposure(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>, int)
|
Read<I8> check_collapse_exposure(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes, Int cell_dim) {
auto e2c = mesh->ask_up(EDGE, cell_dim);
auto e2ec = e2c.a2ab;
auto ec2c = e2c.ab2b;
auto ec_codes = e2c.codes;
auto cs2s = mesh->ask_down(cell_dim, cell_dim - 1).ab2b;
auto nccs = simplex_degree(cell_dim, cell_dim - 1);
auto c2dim = mesh->get_array<I8>(cell_dim, "class_dim");
auto s2dim = mesh->get_array<I8>(cell_dim - 1, "class_dim");
auto ncands = cands2edges.size();
auto cand_codes_w = Write<I8>(ncands);
auto f = OMEGA_H_LAMBDA(LO cand) {
auto code = cand_codes[cand];
auto e = cands2edges[cand];
for (auto ec = e2ec[e]; ec < e2ec[e + 1]; ++ec) {
auto c = ec2c[ec];
auto ec_code = ec_codes[ec];
auto cce = code_which_down(ec_code);
auto rot = code_rotation(ec_code);
auto c_dim = c2dim[c];
for (Int eev_col = 0; eev_col < 2; ++eev_col) {
if (!collapses(code, eev_col)) continue;
auto eev_onto = 1 - eev_col;
auto cev_onto = rot ^ eev_onto;
auto ccv_onto = simplex_down_template(cell_dim, EDGE, cce, cev_onto);
auto ccs_opp = simplex_opposite_template(cell_dim, VERT, ccv_onto);
auto s_opp = cs2s[c * nccs + ccs_opp];
if (s2dim[s_opp] != c_dim) {
code = dont_collapse(code, eev_col);
}
}
}
cand_codes_w[cand] = code;
};
parallel_for(ncands, f, "check_collapse_exposure");
return cand_codes_w;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movl %r8d, %r15d
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x298(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %r8d, %ecx
callq 0xf2f20
leaq 0x148(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x2a8(%rsp), %rsi
leaq 0x138(%rsp), %rdi
callq 0xf0580
leaq 0x2b8(%rsp), %rsi
leaq 0x128(%rsp), %rdi
callq 0xf8e10
leal -0x1(%r15), %r14d
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0xf6910
movq %rbp, 0x8(%rsp)
movq %r13, 0x18(%rsp)
leaq 0x48(%rsp), %rsi
leaq 0x118(%rsp), %rdi
callq 0xf4160
leaq 0x38(%rsp), %rdi
callq 0xf58a0
leal 0x1(%r15), %ebp
cmpl $0x4, %r15d
pushq $-0x1
popq %rax
cmovael %eax, %ebp
leaq 0x1355eb(%rip), %rsi # 0x27f8fd
leaq 0x38(%rsp), %rdi
leaq 0x158(%rsp), %rdx
callq 0xef870
leaq 0x108(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movq %rbx, %rsi
movl %r15d, %edx
callq 0xef910
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0x1355b0(%rip), %rsi # 0x27f8fd
leaq 0x38(%rsp), %rdi
leaq 0x158(%rsp), %rdx
callq 0xef870
leaq 0xf8(%rsp), %rdi
leaq 0x38(%rsp), %rcx
movq %rbx, %rsi
movl %r14d, %edx
callq 0xef910
leaq 0x38(%rsp), %rdi
callq 0xf00f0
movq (%r12), %r14
testb $0x1, %r14b
jne 0x14a390
movq (%r14), %r14
jmp 0x14a394
shrq $0x3, %r14
leaq 0x13311c(%rip), %rsi # 0x27d4b7
leaq 0x38(%rsp), %rdi
leaq 0x158(%rsp), %rdx
callq 0xef870
shrq $0x2, %r14
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movl %r14d, %esi
callq 0xf0f30
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0x1f8(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x208(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x218(%rsp), %r12
leaq 0x148(%rsp), %rsi
movq %r12, %rdi
callq 0xf0580
leaq 0x228(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0xf0580
leaq 0x238(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xf8e10
leaq 0x248(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0xf8e10
leaq 0x260(%rsp), %rdi
movl %r15d, -0x8(%rdi)
leaq 0x118(%rsp), %rsi
callq 0xf0580
leaq 0x278(%rsp), %r15
movl %ebp, -0x8(%r15)
leaq 0xf8(%rsp), %rsi
movq %r15, %rdi
callq 0xf8e10
leaq 0x288(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf8e10
movq 0x18(%rsp), %r13
leaq 0x158(%rsp), %rdi
leaq 0x1f8(%rsp), %rsi
callq 0xf8e10
leaq 0x168(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x178(%rsp), %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x188(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0xf0580
leaq 0x198(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0xf8e10
leaq 0x1a8(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0xf8e10
movl 0x258(%rsp), %eax
leaq 0x1c0(%rsp), %rbx
movl %eax, -0x8(%rbx)
movq %rbx, %rdi
leaq 0x260(%rsp), %rsi
callq 0xf0580
movl 0x270(%rsp), %eax
leaq 0x1d8(%rsp), %r12
movl %eax, -0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x1e8(%rsp), %rdi
leaq 0x288(%rsp), %rsi
callq 0xf8e10
testl %r14d, %r14d
jle 0x14a9bd
movq %rbp, %r15
movq %r14, %rbp
movq 0x1c7748(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x38(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x100b80
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0xf4160
leaq 0x58(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0xf4160
leaq 0x68(%rsp), %rdi
leaq 0x188(%rsp), %rsi
callq 0xf4160
leaq 0x78(%rsp), %rdi
leaq 0x198(%rsp), %rsi
callq 0x100b80
leaq 0x88(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x100b80
movl 0x1b8(%rsp), %eax
leaq 0xa0(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf4160
movl 0x1d0(%rsp), %eax
leaq 0xb8(%rsp), %rbx
movl %eax, -0x8(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x100b80
leaq 0xc8(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x100b80
pushq $-0x1
popq %r12
movb $0x0, (%r14)
andl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
xorl %edx, %edx
movq %rbp, 0xd8(%rsp)
cmpq %rbp, %rdx
je 0x14a9b3
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
movb (%rax,%rdx), %r9b
movq %rdx, 0xe0(%rsp)
movslq (%rcx,%rdx,4), %rax
movq 0x60(%rsp), %rcx
movslq (%rcx,%rax,4), %r10
movslq 0x4(%rcx,%rax,4), %r11
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %r15
movq 0x90(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x98(%rsp), %r14d
movl 0xb0(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movq 0xa8(%rsp), %rbp
movq 0xc0(%rsp), %rsi
movq %rax, (%rsp)
movq %r15, 0x20(%rsp)
cmpq %r11, %r10
jge 0x14a98a
movslq (%rax,%r10,4), %rcx
movb (%r15,%r10), %dl
movl %edx, %r13d
sarb $0x3, %r13b
shrb %dl
andb $0x3, %dl
movq 0x8(%rsp), %rdi
movb (%rdi,%rcx), %dil
imull 0x14(%rsp), %ecx
movzbl %r9b, %ebx
movzbl %r13b, %r8d
testb $0x1, %r9b
je 0x14a87b
cmpl $0x1, %r14d
je 0x14a797
cmpl $0x2, %r14d
je 0x14a758
movl %r12d, %r15d
cmpl $0x3, %r14d
jne 0x14a85d
movl %r12d, %r15d
cmpb $0x5, %r13b
ja 0x14a85d
movl %r12d, %eax
leaq 0x12f8de(%rip), %r12 # 0x27a014
movslq (%r12,%r8,4), %r15
addq %r12, %r15
jmpq *%r15
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x3, %r15d
jmp 0x14a811
cmpb $0x2, %r13b
je 0x14a7b7
cmpl $0x1, %r8d
je 0x14a7a0
movl %r12d, %r15d
testl %r8d, %r8d
jne 0x14a85d
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x2, %r15d
cmpb $0x1, %dl
pushq $0x1
popq %r12
cmovel %r12d, %r15d
pushq $-0x1
popq %r12
jmp 0x14a85d
pushq $0x2
popq %r15
jmp 0x14a85d
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
cmpb $0x1, %dl
movl %r12d, %eax
jmp 0x14a814
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x1, %r15d
cmpb $0x1, %dl
movl %r12d, %eax
movl $0x0, %r12d
cmovel %r12d, %r15d
jmp 0x14a836
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
jmp 0x14a82b
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x2, %r15d
jmp 0x14a84a
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
cmpb $0x1, %dl
pushq $0x2
jmp 0x14a830
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
orl $0x1, %r15d
cmpb $0x1, %dl
pushq $0x3
popq %r12
cmovel %r12d, %r15d
movl %eax, %r12d
jmp 0x14a859
movl %edx, %r15d
negb %r15b
movl $0x0, %r15d
sbbl %r15d, %r15d
cmpb $0x1, %dl
pushq $0x1
popq %r12
cmovel %r12d, %r15d
pushq $-0x1
popq %r12
movq (%rsp), %rax
addl %ecx, %r15d
movslq %r15d, %r15
movslq (%rbp,%r15,4), %r15
cmpb %dil, (%rsi,%r15)
je 0x14a876
andb $-0x2, %r9b
movzbl %r9b, %ebx
movq 0x20(%rsp), %r15
testb $0x2, %bl
je 0x14a982
cmpl $0x3, %r14d
je 0x14a8de
cmpl $0x2, %r14d
je 0x14a8a5
movl %r12d, %ebx
cmpl $0x1, %r14d
jne 0x14a964
pushq $0x2
popq %rbx
jmp 0x14a964
testb %r13b, %r13b
je 0x14a91c
cmpl $0x1, %r8d
je 0x14a90c
movl %r12d, %ebx
cmpl $0x2, %r8d
jne 0x14a964
xorl %r8d, %r8d
cmpb $0x1, %dl
sete %r8b
leal -0x1(,%r8,2), %ebx
testb %dl, %dl
movl $0x0, %edx
cmovel %edx, %ebx
jmp 0x14a964
movl %r12d, %ebx
cmpb $0x5, %r13b
ja 0x14a964
leaq 0x12f73e(%rip), %rbx # 0x27a02c
movslq (%rbx,%r8,4), %r8
addq %rbx, %r8
jmpq *%r8
xorl %r8d, %r8d
cmpb $0x1, %dl
sete %r8b
leal -0x1(,%r8,4), %ebx
jmp 0x14a916
xorl %ebx, %ebx
cmpb $0x1, %dl
setne %bl
negl %ebx
testb %dl, %dl
pushq $0x2
jmp 0x14a960
xorl %r8d, %r8d
cmpb $0x1, %dl
sete %r8b
leal (%r8,%r8,2), %ebx
decl %ebx
jmp 0x14a95c
xorl %ebx, %ebx
cmpb $0x1, %dl
setne %bl
negl %ebx
jmp 0x14a94c
xorl %r8d, %r8d
cmpb $0x1, %dl
sete %r8b
leal -0x1(,%r8,2), %ebx
testb %dl, %dl
pushq $0x3
jmp 0x14a960
xorl %ebx, %ebx
cmpb $0x1, %dl
setne %bl
negl %ebx
testb %dl, %dl
pushq $0x1
popq %rdx
cmovel %edx, %ebx
addl %ecx, %ebx
movslq %ebx, %rcx
movslq (%rbp,%rcx,4), %rcx
movzbl %r9b, %edx
andb $-0x3, %r9b
cmpb %dil, (%rsi,%rcx)
movzbl %r9b, %r9d
cmovel %edx, %r9d
incq %r10
jmp 0x14a6c5
movq 0xd0(%rsp), %rax
movq 0xe0(%rsp), %rdx
movb %r9b, (%rax,%rdx)
incq %rdx
movq 0x18(%rsp), %r13
movq 0xd8(%rsp), %rbp
jmp 0x14a64e
leaq 0x38(%rsp), %rdi
callq 0x14ad2c
leaq 0x158(%rsp), %rdi
callq 0x14ad2c
leaq 0xe8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x100b80
leaq 0xe8(%rsp), %rsi
movq %r13, %rdi
callq 0xf8470
leaq 0xe8(%rsp), %rdi
callq 0xf9e00
leaq 0x1f8(%rsp), %rdi
callq 0x14ad2c
leaq 0x28(%rsp), %rdi
callq 0xf9e00
leaq 0xf8(%rsp), %rdi
callq 0xf9e00
leaq 0x108(%rsp), %rdi
callq 0xf9e00
leaq 0x118(%rsp), %rdi
callq 0xff620
leaq 0x128(%rsp), %rdi
callq 0xf9e00
leaq 0x138(%rsp), %rdi
callq 0xff620
leaq 0x148(%rsp), %rdi
callq 0xff620
leaq 0x298(%rsp), %rdi
callq 0xf58a0
movq %r13, %rax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xf9e00
jmp 0x14aa90
movq %rax, %r14
movq %r15, %rdi
callq 0xff620
jmp 0x14aa9d
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0xf9e00
jmp 0x14aaaf
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0xf9e00
jmp 0x14aabe
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xff620
leaq 0x58(%rsp), %rdi
callq 0xff620
leaq 0x48(%rsp), %rdi
callq 0xff620
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x158(%rsp), %rdi
callq 0x14ad2c
jmp 0x14ab89
movq %rax, %r14
jmp 0x14aac8
movq %rax, %r14
jmp 0x14aad2
movq %rax, %r14
jmp 0x14aadc
movq %rax, %r14
jmp 0x14aae6
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
jmp 0x14ab84
movq %rax, %r14
movq %r12, %rdi
callq 0xf9e00
jmp 0x14ab29
movq %rax, %r14
movq %rbx, %rdi
callq 0xff620
jmp 0x14ab36
movq %rax, %r14
leaq 0x1a8(%rsp), %rdi
callq 0xf9e00
jmp 0x14ab48
movq %rax, %r14
leaq 0x198(%rsp), %rdi
callq 0xf9e00
jmp 0x14ab5a
movq %rax, %r14
leaq 0x188(%rsp), %rdi
callq 0xff620
leaq 0x178(%rsp), %rdi
callq 0xff620
movq %rbp, %rdi
callq 0xff620
leaq 0x158(%rsp), %rdi
callq 0xf9e00
leaq 0x1f8(%rsp), %rdi
callq 0x14ad2c
jmp 0x14ac17
movq %rax, %r14
jmp 0x14ab67
movq %rax, %r14
jmp 0x14ab74
movq %rax, %r14
jmp 0x14ab7c
movq %rax, %r14
movq %r15, %rdi
callq 0xf9e00
jmp 0x14abb7
movq %rax, %r14
leaq 0x260(%rsp), %rdi
callq 0xff620
jmp 0x14abc9
movq %rax, %r14
leaq 0x248(%rsp), %rdi
callq 0xf9e00
jmp 0x14abdb
movq %rax, %r14
leaq 0x238(%rsp), %rdi
callq 0xf9e00
jmp 0x14abed
movq %rax, %r14
leaq 0x228(%rsp), %rdi
callq 0xff620
movq %r12, %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff620
leaq 0x1f8(%rsp), %rdi
callq 0xf9e00
leaq 0x28(%rsp), %rdi
callq 0xf9e00
leaq 0xf8(%rsp), %rdi
callq 0xf9e00
leaq 0x108(%rsp), %rdi
callq 0xf9e00
leaq 0x118(%rsp), %rdi
callq 0xff620
leaq 0x128(%rsp), %rdi
callq 0xf9e00
leaq 0x138(%rsp), %rdi
callq 0xff620
leaq 0x148(%rsp), %rdi
callq 0xff620
leaq 0x298(%rsp), %rdi
callq 0xf58a0
movq %r14, %rdi
callq 0xff4a0
movq %rax, %r14
jmp 0x14abfa
movq %rax, %r14
jmp 0x14ac02
movq %rax, %r14
jmp 0x14ac0a
movq %rax, %r14
jmp 0x14ac17
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x14ac21
movq %rax, %r14
jmp 0x14ac21
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x14ac2e
movq %rax, %r14
jmp 0x14ac2e
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x14ac3b
movq %rax, %r14
jmp 0x14ac3b
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf58a0
jmp 0x14ac48
movq %rax, %r14
jmp 0x14ac48
movq %rax, %r14
jmp 0x14ac55
movq %rax, %r14
jmp 0x14ac62
movq %rax, %r14
jmp 0x14ac6f
movq %rax, %r14
jmp 0x14ab89
|
/gahansen[P]omega_h/src/Omega_h_check_collapse.cpp
|
Omega_h::check_collapse_exposure(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
Read<I8> check_collapse_exposure(
Mesh* mesh, LOs cands2edges, Read<I8> cand_codes) {
OMEGA_H_CHECK(mesh->parting() == OMEGA_H_GHOSTED);
for (Int cell_dim = Int(EDGE) + 1; cell_dim <= mesh->dim(); ++cell_dim) {
cand_codes =
check_collapse_exposure(mesh, cands2edges, cand_codes, cell_dim);
}
return mesh->sync_subset_array(
EDGE, cand_codes, cands2edges, I8(DONT_COLLAPSE), 1);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0xf9e70
cmpl $0x1, %eax
jne 0x14ae90
pushq $0x2
popq %rbp
leaq 0x48(%rsp), %r13
leaq 0x38(%rsp), %rbx
leaq 0x58(%rsp), %r15
movq %r14, %rdi
callq 0xfe5f0
cmpl %eax, %ebp
jg 0x14ae27
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0xf0580
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf8e10
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0xedad0
movq %r12, %rdi
movq %r15, %rsi
callq 0xef740
movq %r15, %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xf9e00
movq %r13, %rdi
callq 0xff620
incl %ebp
jmp 0x14adc8
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf0580
movl $0x1, (%rsp)
pushq $0x1
popq %rdx
leaq 0x28(%rsp), %rcx
leaq 0x18(%rsp), %r8
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r9d, %r9d
callq 0xf6530
leaq 0x18(%rsp), %rdi
callq 0xff620
leaq 0x28(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12c1f1(%rip), %rdi # 0x277088
leaq 0x12f1a6(%rip), %rsi # 0x27a044
leaq 0x12f1c2(%rip), %rdx # 0x27a067
pushq $0x6e
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xff620
jmp 0x14aec1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
jmp 0x14aef8
movq %rax, %rbx
jmp 0x14aeee
movq %rax, %rbx
jmp 0x14aee4
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x48(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_check_collapse.cpp
|
Omega_h::classify_sides_by_exposure(Omega_h::Mesh*, Omega_h::Read<signed char>)
|
void classify_sides_by_exposure(Mesh* mesh, Read<I8> side_is_exposed) {
auto dim = mesh->dim();
auto ns = mesh->nents(dim - 1);
Write<I8> class_dim(ns);
auto f = OMEGA_H_LAMBDA(LO s) {
class_dim[s] = static_cast<I8>(dim - side_is_exposed[s]);
};
parallel_for(ns, f, "classify_sides_by_exposure");
mesh->add_tag<I8>(dim - 1, "class_dim", 1, class_dim);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r12d
leal -0x1(%r12), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf0100
movl %eax, %r14d
leaq 0x13257f(%rip), %rsi # 0x27d4b7
movq %rsp, %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
leaq 0x28(%rsp), %rdi
movq %rsp, %rdx
movl %r14d, %esi
callq 0xf0f30
movq %rsp, %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf8e10
leaq 0x98(%rsp), %r13
movl %r12d, -0x8(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x58(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf8e10
movl 0x90(%rsp), %eax
leaq 0x70(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
movq %r13, %rsi
callq 0xf8e10
testl %r14d, %r14d
jle 0x14b015
movq 0x1c6d01(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
callq 0x100b80
movl 0x68(%rsp), %eax
leaq 0x18(%rsp), %rdi
movl %eax, -0x8(%rdi)
movq %r15, %rsi
callq 0x100b80
movb $0x0, (%r12)
movl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x14b00d
movb 0x10(%rsp), %dl
movq 0x20(%rsp), %rsi
subb (%rsi,%rcx), %dl
movq 0x8(%rsp), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0x14afef
movq %rsp, %rdi
callq 0x14b152
leaq 0x58(%rsp), %rdi
callq 0x14b152
leaq 0x1348d7(%rip), %rsi # 0x27f8fd
movq %rsp, %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf8e10
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf8470
movq %rsp, %rdx
pushq $0x1
popq %rcx
leaq 0x48(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %esi
xorl %r9d, %r9d
callq 0xfe780
leaq 0x48(%rsp), %rdi
callq 0xf9e00
leaq 0x38(%rsp), %rdi
callq 0xf9e00
movq %rsp, %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
callq 0x14b152
leaq 0x28(%rsp), %rdi
callq 0xf9e00
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf9e00
jmp 0x14b0be
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x14b152
jmp 0x14b109
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf9e00
jmp 0x14b0dc
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf9e00
jmp 0x14b0eb
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf00f0
jmp 0x14b109
jmp 0x14b106
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x14b109
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x14b152
leaq 0x28(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xf9e00
jmp 0x14b116
movq %rax, %rbx
jmp 0x14b116
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf00f0
jmp 0x14b120
movq %rax, %rbx
jmp 0x14b120
nop
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::classify_hinges_by_sharpness(Omega_h::Mesh*, Omega_h::Read<signed char>, Omega_h::Read<signed char>)
|
void classify_hinges_by_sharpness(
Mesh* mesh, Read<I8> hinge_is_exposed, Read<I8> hinge_is_sharp) {
auto dim = mesh->dim();
auto nh = mesh->nents(dim - 2);
Write<I8> class_dim(nh);
auto f = OMEGA_H_LAMBDA(LO h) {
class_dim[h] =
static_cast<I8>(dim - hinge_is_exposed[h] - hinge_is_sharp[h]);
};
parallel_for(nh, f, "classify_hinges_by_sharpness");
mesh->add_tag<I8>(dim - 2, "class_dim", 1, class_dim);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r13d
leal -0x2(%r13), %esi
movq %rbx, %rdi
movl %esi, 0xc(%rsp)
callq 0xf0100
movl %eax, %r14d
leaq 0x132313(%rip), %rsi # 0x27d4b7
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl %r14d, %esi
callq 0xf0f30
leaq 0x20(%rsp), %rdi
callq 0xf00f0
leaq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
leaq 0xc8(%rsp), %rbp
movl %r13d, -0x8(%rbp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x78(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xf8e10
movl 0xc0(%rsp), %eax
leaq 0x90(%rsp), %r15
movl %eax, -0x8(%r15)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xf8e10
leaq 0xa0(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xf8e10
testl %r14d, %r14d
jle 0x14b2d8
movq 0x1c6a62(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x100b80
movl 0x88(%rsp), %eax
leaq 0x38(%rsp), %r13
movl %eax, -0x8(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0x100b80
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x100b80
movb $0x0, (%rbp)
movl %r14d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x14b2ce
movl 0x30(%rsp), %edx
movq 0x40(%rsp), %rsi
movzbl (%rsi,%rcx), %esi
movq 0x50(%rsp), %rdi
movzbl (%rdi,%rcx), %edi
addl %esi, %edi
subl %edi, %edx
movq 0x28(%rsp), %rsi
movb %dl, (%rsi,%rcx)
incq %rcx
jmp 0x14b2a2
leaq 0x20(%rsp), %rdi
callq 0x14b44a
leaq 0x78(%rsp), %rdi
callq 0x14b44a
leaq 0x134614(%rip), %rsi # 0x27f8fd
leaq 0x20(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xef870
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf8470
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
leaq 0x68(%rsp), %r8
movq %rbx, %rdi
movl 0xc(%rsp), %esi
xorl %r9d, %r9d
callq 0xfe780
leaq 0x68(%rsp), %rdi
callq 0xf9e00
leaq 0x58(%rsp), %rdi
callq 0xf9e00
leaq 0x20(%rsp), %rdi
callq 0xf00f0
leaq 0xb0(%rsp), %rdi
callq 0x14b44a
leaq 0x10(%rsp), %rdi
callq 0xf9e00
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0xf9e00
jmp 0x14b389
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf9e00
jmp 0x14b398
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x14b44a
jmp 0x14b3f2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf9e00
jmp 0x14b3b6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x14b3c5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x14b3f2
jmp 0x14b3ef
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x14b3e3
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf9e00
jmp 0x14b3f2
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x14b44a
leaq 0x10(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
movq %rax, %rbx
movq %rbp, %rdi
callq 0xf9e00
jmp 0x14b421
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xf9e00
jmp 0x14b3ff
movq %rax, %rbx
jmp 0x14b3ff
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x14b409
movq %rax, %rbx
jmp 0x14b409
nop
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::classify_elements(Omega_h::Mesh*)
|
void classify_elements(Mesh* mesh) {
mesh->add_tag<I8>(mesh->dim(), "class_dim", 1,
Read<I8>(mesh->nelems(), static_cast<I8>(mesh->dim())));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %ebp
leaq 0x134479(%rip), %rsi # 0x27f8fd
leaq 0x38(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
movq %rbx, %rdi
callq 0xff990
movl %eax, %r14d
movq %rbx, %rdi
callq 0xfe5f0
movl %eax, %r15d
leaq 0x132007(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xef870
movsbl %r15b, %edx
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movl %r14d, %esi
callq 0xf4590
leaq 0x38(%rsp), %rdx
pushq $0x1
popq %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %esi
xorl %r9d, %r9d
callq 0xfe780
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x38(%rsp), %rdi
callq 0xf00f0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
jmp 0x14b52a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x14b53b
jmp 0x14b538
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::classify_by_angles(Omega_h::Mesh*, double)
|
void classify_by_angles(Mesh* mesh, Real sharp_angle) {
OMEGA_H_CHECK(mesh->family() == OMEGA_H_SIMPLEX);
auto dim = mesh->dim();
classify_elements(mesh);
auto side_is_exposed = mark_exposed_sides(mesh);
classify_sides_by_exposure(mesh, side_is_exposed);
if (dim == 1) return;
auto hinge_is_exposed = mark_down(mesh, dim - 1, dim - 2, side_is_exposed);
auto surf_side2side = collect_marked(side_is_exposed);
auto surf_side_normals = get_side_vectors(mesh, surf_side2side);
auto surf_hinge2hinge = collect_marked(hinge_is_exposed);
auto nsurf_hinges = surf_hinge2hinge.size();
auto nsides = mesh->nents(dim - 1);
auto side2surf_side = invert_injective_map(surf_side2side, nsides);
auto surf_hinge_angles = get_hinge_angles(
mesh, surf_side_normals, surf_hinge2hinge, side2surf_side);
auto nhinges = mesh->nents(dim - 2);
Write<I8> hinge_is_sharp(nhinges, 0);
auto f = OMEGA_H_LAMBDA(LO surf_hinge) {
LO hinge = surf_hinge2hinge[surf_hinge];
hinge_is_sharp[hinge] = (surf_hinge_angles[surf_hinge] >= sharp_angle);
};
parallel_for(nsurf_hinges, f, "classify_by_angles(is_sharp)");
classify_hinges_by_sharpness(mesh, hinge_is_exposed, hinge_is_sharp);
if (dim == 2) return;
finalize_classification(mesh);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movsd %xmm0, 0x58(%rsp)
cmpl $0x0, (%rdi)
jne 0x14ba17
movq %rdi, %rbx
callq 0xfe5f0
movl %eax, %r12d
movq %rbx, %rdi
callq 0xf91a0
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x101770
leaq 0x140(%rsp), %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x140(%rsp), %rsi
movq %rbx, %rdi
callq 0xfe0c0
leaq 0x140(%rsp), %rdi
callq 0xf9e00
cmpl $0x1, %r12d
je 0x14b9fb
leaq 0x130(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf8e10
leal -0x1(%r12), %r15d
leal -0x2(%r12), %ebp
leaq 0x30(%rsp), %rdi
leaq 0x130(%rsp), %r8
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0xfb000
leaq 0x130(%rsp), %rdi
callq 0xf9e00
leaq 0x120(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf8e10
leaq 0x20(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0xff640
leaq 0x120(%rsp), %rdi
callq 0xf9e00
leaq 0x100(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf0580
leaq 0x110(%rsp), %rdi
leaq 0x100(%rsp), %rdx
movq %rbx, %rsi
callq 0xfb1c0
leaq 0x100(%rsp), %rdi
callq 0xff620
leaq 0xf0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
movq %rsp, %rdi
leaq 0xf0(%rsp), %rsi
callq 0xff640
leaq 0xf0(%rsp), %rdi
callq 0xf9e00
movq (%rsp), %r14
testb $0x1, %r14b
jne 0x14b6b0
movq (%r14), %r14
jmp 0x14b6b4
shrq $0x3, %r14
movq %rbx, %rdi
movl %r15d, %esi
callq 0xf0100
movl %eax, %r15d
leaq 0xd0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf0580
leaq 0xe0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
movl %r15d, %edx
callq 0xfb370
leaq 0xd0(%rsp), %rdi
callq 0xff620
leaq 0xb0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0xf3e40
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
callq 0xf0580
leaq 0x90(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf0580
leaq 0xc0(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x90(%rsp), %r8
movq %rbx, %rsi
callq 0xeeb60
leaq 0x90(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xff620
leaq 0xb0(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf0100
movl %eax, %ebp
leaq 0x131d22(%rip), %rsi # 0x27d4b7
leaq 0x150(%rsp), %rdi
leaq 0x188(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x150(%rsp), %rcx
movl %ebp, %esi
xorl %edx, %edx
callq 0xff7c0
leaq 0x150(%rsp), %rdi
callq 0xf00f0
leaq 0x1c0(%rsp), %rdi
movq %rsp, %rsi
callq 0xf0580
movq %r12, 0x50(%rsp)
leaq 0x1d0(%rsp), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0xf8e10
leaq 0x1e0(%rsp), %r13
leaq 0xc0(%rsp), %rsi
movq %r13, %rdi
callq 0xf3e40
leaq 0x1c0(%rsp), %rsi
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x30(%rsi)
leaq 0x188(%rsp), %rdi
callq 0xf0580
leaq 0x198(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x1a8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xf3e40
shrq $0x2, %r14
movsd 0x1f0(%rsp), %xmm0
movsd %xmm0, 0x1b8(%rsp)
testl %r14d, %r14d
jle 0x14b91b
movq 0x1c6445(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x150(%rsp), %rdi
leaq 0x188(%rsp), %rsi
callq 0xf4160
leaq 0x160(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x100b80
leaq 0x170(%rsp), %rdi
movq %r12, %rsi
callq 0xfbcb0
movsd 0x1b8(%rsp), %xmm0
movsd %xmm0, 0x180(%rsp)
movb $0x0, (%rbp)
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r14
je 0x14b90e
movq 0x158(%rsp), %rcx
movq 0x168(%rsp), %rdx
movslq (%rcx,%rax,4), %rcx
movq 0x178(%rsp), %rsi
movsd (%rsi,%rax,8), %xmm0
ucomisd 0x180(%rsp), %xmm0
setae (%rdx,%rcx)
incq %rax
jmp 0x14b8d6
leaq 0x150(%rsp), %rdi
callq 0x14c284
leaq 0x188(%rsp), %rdi
callq 0x14c284
leaq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
leaq 0x70(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf8470
movq 0x50(%rsp), %r14
leaq 0x80(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %rbx, %rdi
callq 0xfcca0
leaq 0x70(%rsp), %rdi
callq 0xf9e00
leaq 0x60(%rsp), %rdi
callq 0xf9e00
leaq 0x80(%rsp), %rdi
callq 0xf9e00
cmpl $0x2, %r14d
je 0x14b9a1
movq %rbx, %rdi
callq 0xf7330
leaq 0x1c0(%rsp), %rdi
callq 0x14c284
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0xc0(%rsp), %rdi
callq 0xfdc90
leaq 0xe0(%rsp), %rdi
callq 0xff620
movq %rsp, %rdi
callq 0xff620
leaq 0x110(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x40(%rsp), %rdi
callq 0xf9e00
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12b66a(%rip), %rdi # 0x277088
leaq 0x12b7cf(%rip), %rsi # 0x2771f4
leaq 0x12e6a4(%rip), %rdx # 0x27a0d0
pushq $0x2b
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r13, %rdi
callq 0xf9e00
jmp 0x14ba46
movq %rax, %rbx
leaq 0x150(%rsp), %rdi
callq 0xff620
jmp 0x14ba58
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x14c284
jmp 0x14bbd3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf9e00
jmp 0x14ba7c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf9e00
jmp 0x14ba8b
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xf9e00
jmp 0x14bbd3
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x14baad
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0xff620
jmp 0x14bbd3
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x14bacf
movq %rax, %rbx
leaq 0x1c0(%rsp), %rdi
callq 0xff620
jmp 0x14bbe0
movq %rax, %rbx
jmp 0x14bbe0
movq %rax, %rbx
leaq 0x150(%rsp), %rdi
callq 0xf00f0
jmp 0x14bbea
jmp 0x14bb00
movq %rax, %rbx
jmp 0x14bbea
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x14bb1d
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xff620
jmp 0x14bb2f
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
jmp 0x14bbf2
movq %rax, %rbx
jmp 0x14bbf7
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
jmp 0x14bbff
jmp 0x14bb56
movq %rax, %rbx
jmp 0x14bc04
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xf9e00
jmp 0x14bc0c
movq %rax, %rbx
jmp 0x14bc0c
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0xff620
jmp 0x14bc19
movq %rax, %rbx
jmp 0x14bc19
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xf9e00
jmp 0x14bc23
movq %rax, %rbx
jmp 0x14bc23
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
jmp 0x14bc28
jmp 0x14bbcb
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
jmp 0x14bc28
movq %rax, %rbx
jmp 0x14bc2d
movq %rax, %rbx
leaq 0x1c0(%rsp), %rdi
callq 0x14c284
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0xc0(%rsp), %rdi
callq 0xfdc90
leaq 0xe0(%rsp), %rdi
callq 0xff620
movq %rsp, %rdi
callq 0xff620
leaq 0x110(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x40(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::project_classification(Omega_h::Mesh*, int, Omega_h::Write<signed char>, Omega_h::Write<int>, bool)
|
void project_classification(Mesh* mesh, Int ent_dim, Write<I8> class_dim,
Write<ClassId> class_id, bool relaxed) {
auto l2h = mesh->ask_up(ent_dim, ent_dim + 1);
auto l2lh = l2h.a2ab;
auto lh2h = l2h.ab2b;
auto high_class_dim = mesh->get_array<I8>(ent_dim + 1, "class_dim");
auto high_class_id = mesh->get_array<ClassId>(ent_dim + 1, "class_id");
auto f = OMEGA_H_LAMBDA(LO l) {
Int best_dim = class_dim[l];
auto best_id = class_id[l];
Int nadj = 0;
for (auto lh = l2lh[l]; lh < l2lh[l + 1]; ++lh) {
auto h = lh2h[lh];
Int high_dim = high_class_dim[h];
auto high_id = high_class_id[h];
if (high_dim < best_dim) {
best_dim = high_dim;
best_id = high_id;
nadj = 1;
} else if (high_dim == best_dim) {
if (high_id != best_id && (!relaxed || high_id != -1)) {
if (best_id == -1) {
best_id = high_id;
++nadj;
} else {
--best_dim;
best_id = -1;
nadj = 0;
}
} else {
++nadj;
}
}
}
if ((nadj != 2 && best_dim == ent_dim + 1) ||
(nadj < 2 && best_dim > ent_dim + 1)) {
best_dim = ent_dim;
best_id = -1;
}
class_dim[l] = static_cast<I8>(best_dim);
class_id[l] = best_id;
};
parallel_for(mesh->nents(ent_dim), f, "project_classification");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %r8d, 0xc(%rsp)
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %r13d
leaq 0x188(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %r13d, %ecx
callq 0xf2f20
leaq 0xa8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0x198(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0xf0580
leaq 0x1335f1(%rip), %rsi # 0x27f8fd
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
callq 0xef870
leaq 0x88(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r14, %rsi
movl %r13d, %edx
callq 0xef910
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x12ce82(%rip), %rsi # 0x2791c9
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rdx
callq 0xef870
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r14, %rsi
movl %r13d, %edx
callq 0xf4ae0
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x120(%rsp), %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x130(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x140(%rsp), %r13
leaq 0xa8(%rsp), %rsi
movq %r13, %rdi
callq 0xf0580
leaq 0x150(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xf0580
leaq 0x160(%rsp), %r15
leaq 0x88(%rsp), %rsi
movq %r15, %rdi
callq 0xf8e10
leaq 0x170(%rsp), %r12
leaq 0x78(%rsp), %rsi
movq %r12, %rdi
callq 0xf0580
movl 0xc(%rsp), %eax
movb %al, 0x180(%rsp)
movl %ebx, 0x184(%rsp)
movq %r14, %rdi
movl %ebx, %esi
callq 0xf0100
movl %eax, %ebx
leaq 0xb8(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0xf8e10
leaq 0xc8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0xf0580
leaq 0xe8(%rsp), %rbp
movq %rbp, %rdi
leaq 0x150(%rsp), %rsi
callq 0xf0580
leaq 0xf8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x108(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf0580
movq 0x180(%rsp), %rax
movq %rax, 0x118(%rsp)
testl %ebx, %ebx
jle 0x14c5fe
movq 0x1c5818(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
leaq 0x10(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x100b80
leaq 0x20(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xf4160
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xf4160
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0xf4160
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x100b80
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0xf4160
movq 0x118(%rsp), %rax
movq %rax, 0x70(%rsp)
movb $0x0, (%r12)
movl %ebx, %eax
xorl %ecx, %ecx
pushq $0x1
popq %rdx
cmpq %rax, %rcx
je 0x14c5f4
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %r8
movsbl (%rdi,%rcx), %esi
movl (%r8,%rcx,4), %r9d
movq 0x38(%rsp), %r8
movslq (%r8,%rcx,4), %r11
movslq 0x4(%r8,%rcx,4), %rbx
movq 0x48(%rsp), %r14
movq 0x58(%rsp), %r15
movq 0x68(%rsp), %r12
movb 0x70(%rsp), %bpl
xorl %r10d, %r10d
cmpq %rbx, %r11
jge 0x14c5bb
movslq (%r14,%r11,4), %r13
movsbl (%r15,%r13), %r8d
movl (%r12,%r13,4), %r13d
cmpl %r8d, %esi
jle 0x14c586
movl %edx, %r10d
movl %r13d, %r9d
movl %r8d, %esi
jmp 0x14c5b6
jne 0x14c5b6
cmpl $-0x1, %r13d
sete %r8b
cmpl %r9d, %r13d
je 0x14c5a8
andb %bpl, %r8b
jne 0x14c5a8
cmpl $-0x1, %r9d
jne 0x14c5ad
incl %r10d
movl %r13d, %r9d
jmp 0x14c5b6
incl %r10d
jmp 0x14c5b6
decl %esi
xorl %r10d, %r10d
pushq $-0x1
popq %r9
incq %r11
jmp 0x14c564
cmpl $0x2, %r10d
je 0x14c5df
movl 0x74(%rsp), %r11d
leal 0x1(%r11), %ebx
cmpl %ebx, %esi
je 0x14c5d8
cmpl $0x1, %r10d
jg 0x14c5df
cmpl %ebx, %esi
jle 0x14c5df
pushq $-0x1
popq %r9
movl %r11d, %esi
movb %sil, (%rdi,%rcx)
movq 0x28(%rsp), %rsi
movl %r9d, (%rsi,%rcx,4)
incq %rcx
jmp 0x14c524
leaq 0x10(%rsp), %rdi
callq 0x14c7ea
leaq 0xb8(%rsp), %rdi
callq 0x14c7ea
leaq 0x120(%rsp), %rdi
callq 0x14c7ea
leaq 0x78(%rsp), %rdi
callq 0xff620
leaq 0x88(%rsp), %rdi
callq 0xf9e00
leaq 0x98(%rsp), %rdi
callq 0xff620
leaq 0xa8(%rsp), %rdi
callq 0xff620
leaq 0x188(%rsp), %rdi
callq 0xf58a0
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0xf9e00
jmp 0x14c678
movq %rax, %rbx
movq %r14, %rdi
callq 0xff620
jmp 0x14c685
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xff620
jmp 0x14c694
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xff620
jmp 0x14c6a3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0xb8(%rsp), %rdi
callq 0x14c7ea
jmp 0x14c797
movq %rax, %rbx
jmp 0x14c6ad
movq %rax, %rbx
movq %r13, %rdi
callq 0xf9e00
jmp 0x14c6d4
movq %rax, %rbx
movq %rbp, %rdi
callq 0xff620
jmp 0x14c6e1
movq %rax, %rbx
movq %r14, %rdi
callq 0xff620
jmp 0x14c6ee
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xff620
jmp 0x14c700
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xf9e00
jmp 0x14c797
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x14c722
movq %rax, %rbx
leaq 0x150(%rsp), %rdi
callq 0xff620
jmp 0x14c734
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x14c741
movq %rax, %rbx
movq %rbp, %rdi
callq 0xff620
jmp 0x14c74e
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xf9e00
jmp 0x14c7a4
movq %rax, %rbx
jmp 0x14c7a4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x14c7ae
movq %rax, %rbx
jmp 0x14c7ae
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x14c7bb
movq %rax, %rbx
jmp 0x14c7bb
movq %rax, %rbx
jmp 0x14c7c8
movq %rax, %rbx
jmp 0x14c7d5
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x14c7ea
leaq 0x78(%rsp), %rdi
callq 0xff620
leaq 0x88(%rsp), %rdi
callq 0xf9e00
leaq 0x98(%rsp), %rdi
callq 0xff620
leaq 0xa8(%rsp), %rdi
callq 0xff620
leaq 0x188(%rsp), %rdi
callq 0xf58a0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::classify_equal_order(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>)
|
void classify_equal_order(
Mesh* mesh, Int ent_dim, LOs eqv2v, Read<ClassId> eq_class_ids) {
LOs eq2e;
if (ent_dim == mesh->dim()) {
/* assuming elements were constructed in the same order ! */
eq2e = LOs(mesh->nelems(), 0, 1);
} else if (ent_dim == VERT) {
eq2e = eqv2v;
} else {
Write<LO> eq2e_w;
Write<I8> codes;
auto ev2v = mesh->ask_verts_of(ent_dim);
auto v2e = mesh->ask_up(VERT, ent_dim);
find_matches(mesh->family(), ent_dim, eqv2v, ev2v, v2e, &eq2e_w, &codes);
eq2e = eq2e_w;
}
auto neq = eqv2v.size() / (ent_dim + 1);
auto eq_class_dim = Read<I8>(neq, I8(ent_dim));
auto class_dim =
map_onto(eq_class_dim, eq2e, mesh->nents(ent_dim), I8(mesh->dim()), 1);
auto class_id = map_onto(eq_class_ids, eq2e, mesh->nents(ent_dim), -1, 1);
mesh->add_tag<I8>(ent_dim, "class_dim", 1, class_dim);
mesh->add_tag<ClassId>(ent_dim, "class_id", 1, class_id);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
callq 0xfe5f0
cmpl %ebx, %eax
jne 0x14cc78
movq %r14, %rdi
callq 0xff990
movl %eax, %ebp
leaq 0x13088c(%rip), %rsi # 0x27d4b7
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rcx
leaq 0x50(%rsp), %r8
movl %ebp, %esi
xorl %edx, %edx
callq 0xf3150
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfa4d0
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x14cdc4
testl %ebx, %ebx
je 0x14cdb7
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0xf3940
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movl %ebx, %ecx
callq 0xf2f20
movl (%r14), %ebp
leaq 0x110(%rsp), %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf0580
leaq 0x120(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xee220
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x110(%rsp), %rdx
leaq 0x100(%rsp), %rcx
leaq 0x120(%rsp), %r8
leaq 0x10(%rsp), %r9
movl %ebp, %edi
movl %ebx, %esi
callq 0xff7f0
leaq 0x120(%rsp), %rdi
callq 0xf58a0
leaq 0x100(%rsp), %rdi
callq 0xff620
leaq 0x110(%rsp), %rdi
callq 0xff620
leaq 0xf0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf0580
leaq 0x80(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xf7a10
leaq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xfa4d0
leaq 0x80(%rsp), %rdi
callq 0xff620
leaq 0xf0(%rsp), %rdi
callq 0xff620
leaq 0x50(%rsp), %rdi
callq 0xf58a0
leaq 0x40(%rsp), %rdi
callq 0xff620
leaq 0x20(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x14cdc4
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xf7670
movq (%r12), %r12
testb $0x1, %r12b
jne 0x14cdd4
movq (%r12), %r12
jmp 0x14cdd8
shrq $0x3, %r12
leaq 0x1306d8(%rip), %rsi # 0x27d4b7
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
leal 0x1(%rbx), %ecx
movl %r12d, %eax
cltd
idivl %ecx
movsbl %bl, %edx
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
movl %eax, %esi
callq 0xf4590
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0xe0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
leaq 0xd0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf0580
movq %r14, %rdi
movl %ebx, %esi
callq 0xf0100
movl %eax, %ebp
movq %r14, %rdi
callq 0xfe5f0
movsbl %al, %r8d
leaq 0x20(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
pushq $0x1
popq %r9
movl %ebp, %ecx
callq 0xf33a0
leaq 0xd0(%rsp), %rdi
callq 0xff620
leaq 0xe0(%rsp), %rdi
callq 0xf9e00
leaq 0xc0(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf0580
movq %r14, %rdi
movl %ebx, %esi
callq 0xf0100
leaq 0x40(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
pushq $-0x1
popq %r8
pushq $0x1
popq %r9
movl %eax, %ecx
callq 0xf77f0
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xc0(%rsp), %rdi
callq 0xff620
leaq 0x1329fd(%rip), %rsi # 0x27f8fd
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0xef870
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf8e10
leaq 0x50(%rsp), %rdx
pushq $0x1
popq %rcx
leaq 0xa0(%rsp), %r8
movq %r14, %rdi
movl %ebx, %esi
xorl %r9d, %r9d
callq 0xfe780
leaq 0xa0(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x12c26a(%rip), %rsi # 0x2791c9
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0xef870
leaq 0x90(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xf0580
leaq 0x50(%rsp), %rdx
pushq $0x1
popq %rcx
leaq 0x90(%rsp), %r8
movq %r14, %rdi
movl %ebx, %esi
xorl %r9d, %r9d
callq 0xeeb90
leaq 0x90(%rsp), %rdi
callq 0xff620
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xff620
leaq 0x20(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0x30(%rsp), %rdi
callq 0xff620
addq $0x150, %rsp # imm = 0x150
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xff620
jmp 0x14d004
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
jmp 0x14d03f
jmp 0x14d046
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xf58a0
jmp 0x14d025
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0xff620
jmp 0x14d037
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0xff620
jmp 0x14d049
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf58a0
leaq 0x40(%rsp), %rdi
callq 0xff620
leaq 0x20(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x14d14b
movq %rax, %rbx
jmp 0x14d053
movq %rax, %rbx
jmp 0x14d05d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x14d0ed
jmp 0x14d0ea
jmp 0x14d0fb
jmp 0x14d0fb
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x14d0c0
jmp 0x14d0bd
jmp 0x14d0cc
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xf9e00
jmp 0x14d0c0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x14d0cf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x14d118
movq %rax, %rbx
jmp 0x14d110
movq %rax, %rbx
jmp 0x14d11d
movq %rax, %rbx
jmp 0x14d134
movq %rax, %rbx
jmp 0x14d141
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x14d14b
jmp 0x14d0fb
movq %rax, %rbx
jmp 0x14d14b
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xc0(%rsp), %rdi
callq 0xff620
leaq 0x20(%rsp), %rdi
jmp 0x14d13c
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xff620
leaq 0xe0(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0x30(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
nopl (%rax)
|
/gahansen[P]omega_h/src/Omega_h_class.cpp
|
Omega_h::CmdLineFlag::arg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
CmdLineItem* CmdLineFlag::arg(std::string const& arg_name) {
for (auto const& the_arg : args_)
if (the_arg->name() == arg_name) return the_arg.get();
OMEGA_H_NORETURN(nullptr);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x50(%rdi), %r14
movq 0x58(%rdi), %r15
cmpq %r15, %r14
je 0x14d23b
movq (%r14), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0xf1cd0
testb %al, %al
jne 0x14d232
addq $0x8, %r14
jmp 0x14d214
movq (%r14), %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x129e46(%rip), %rdi # 0x277088
leaq 0x12a5ac(%rip), %rsi # 0x2777f5
leaq 0x12cf20(%rip), %rdx # 0x27a170
movl $0x82, %ecx
xorl %eax, %eax
callq 0xf6ee0
|
/gahansen[P]omega_h/src/Omega_h_cmdline.cpp
|
Omega_h::CmdLineItem::parse(int*, char**, int, bool)
|
bool CmdLineItem::parse(int* p_argc, char** argv, int i, bool should_print) {
if (parsed_) {
if (should_print) {
std::cout << "argument <" << name() << " being parsed twice!\n";
}
return false;
}
auto ok = parse_impl(p_argc, argv, i, should_print);
if (ok) parsed_ = true;
return ok;
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x14d346
testb %r8b, %r8b
je 0x14d35f
movq 0x1c4a1e(%rip), %rdi # 0x311d38
leaq 0x12cf62(%rip), %rsi # 0x27a283
callq 0xf68a0
addq $0x8, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf5810
leaq 0x12cec9(%rip), %rsi # 0x27a205
movq %rax, %rdi
callq 0xf68a0
jmp 0x14d35f
movq (%rbx), %rax
movzbl %r8b, %r8d
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x14d35f
movb $0x1, 0x28(%rbx)
movb $0x1, %al
jmp 0x14d361
xorl %eax, %eax
popq %rbx
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_cmdline.cpp
|
Omega_h::CmdLineFlag::parse_impl(int*, char**, int, bool)
|
bool CmdLineFlag::parse_impl(
int* p_argc, char** argv, int i, bool should_print) {
shift(p_argc, argv, i);
if (((*p_argc) - i) < int(args_.size())) {
if (should_print) {
std::cout << "flag " << name() << " takes " << args_.size()
<< " arguments\n";
}
return false;
}
for (auto const& the_arg : args_) {
if (!the_arg->parse(p_argc, argv, i, should_print)) {
if (should_print) {
std::cout << "could not parse argument <" << the_arg->name()
<< "> of flag " << name() << '\n';
}
return false;
}
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
movq %rdx, 0x10(%rsp)
movq %rdx, %rsi
movl %ecx, %edx
callq 0x14d199
movl (%r12), %eax
subl %r14d, %eax
movq 0x50(%r13), %rbp
movq 0x58(%r13), %rbx
movq %rbx, %rcx
subq %rbp, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jge 0x14d460
testb %r15b, %r15b
je 0x14d4e6
movq 0x1c4927(%rip), %rdi # 0x311d38
leaq 0x12ce4d(%rip), %rsi # 0x27a265
callq 0xf68a0
leaq 0x8(%r13), %rsi
movq %rax, %rdi
callq 0xf5810
leaq 0x12cdeb(%rip), %rsi # 0x27a21b
movq %rax, %rdi
callq 0xf68a0
movq 0x58(%r13), %rsi
subq 0x50(%r13), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0xf3010
leaq 0x12cdd0(%rip), %rsi # 0x27a223
movq %rax, %rdi
callq 0xf68a0
jmp 0x14d4e6
movq %r13, 0x8(%rsp)
movzbl %r15b, %r13d
cmpq %rbx, %rbp
je 0x14d48f
movq (%rbp), %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movl %r14d, %ecx
movl %r13d, %r8d
callq 0xee430
testb %al, %al
je 0x14d493
addq $0x8, %rbp
jmp 0x14d469
movb $0x1, %al
jmp 0x14d4e8
testb %r15b, %r15b
je 0x14d4e6
movq 0x1c4899(%rip), %rdi # 0x311d38
leaq 0x12cd89(%rip), %rsi # 0x27a22f
callq 0xf68a0
movq (%rbp), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0xf5810
leaq 0x12cd88(%rip), %rsi # 0x27a24a
movq %rax, %rdi
callq 0xf68a0
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0xf5810
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0xf8840
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_cmdline.cpp
|
Omega_h::CmdLine::parse(int*, char**, bool)
|
bool CmdLine::parse(int* p_argc, char** argv, bool should_print) {
for (int i = 1; i < *p_argc;) {
bool parsed_by_flag = false;
for (auto const& flag : flags_) {
if (flag->name() == argv[i]) {
if (!flag->parse(p_argc, argv, i, should_print)) {
if (should_print) {
std::cout << "failed to parse flag " << flag->name() << '\n';
}
return false;
}
parsed_by_flag = true;
}
}
if (parsed_by_flag) {
continue;
} else if (std::string("--help") == argv[i]) {
parsed_help_ = true;
++i;
} else if (args_.size() > nargs_parsed_) {
if (args_[nargs_parsed_]->parse(p_argc, argv, i, should_print)) {
++nargs_parsed_;
}
} else {
++i;
}
}
if (nargs_parsed_ < args_.size()) {
if (should_print) {
for (std::size_t i = nargs_parsed_; i < args_.size(); ++i) {
std::cout << "missing required argument <" << args_[i]->name() << ">\n";
}
}
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
pushq $0x1
popq %rax
movzbl %cl, %edx
movl %edx, 0x8(%rsp)
xorb $0x1, %cl
movl %ecx, 0x4(%rsp)
movq %rdi, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movslq %eax, %r13
cmpl (%r15), %r13d
jge 0x14d738
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r12
xorl %ebp, %ebp
cmpq %r12, %rbx
je 0x14d66b
movq (%rbx), %rdi
addq $0x8, %rdi
movq (%r14,%r13,8), %rsi
callq 0x101e60
testb %al, %al
je 0x14d665
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
movl 0x8(%rsp), %r8d
callq 0xee430
movl %eax, %ecx
orb 0x4(%rsp), %cl
je 0x14d6fa
movb $0x1, %bpl
testb %al, %al
je 0x14d727
addq $0x8, %rbx
jmp 0x14d61f
testb $0x1, %bpl
movq 0x10(%rsp), %rbp
jne 0x14d60c
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
leaq 0x12cbe6(%rip), %rsi # 0x27a26b
leaq 0x3(%rsp), %rdx
callq 0xef870
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
callq 0x101e60
movl %eax, %r12d
movq %rbx, %rdi
callq 0xf00f0
testb %r12b, %r12b
jne 0x14d6eb
movq (%rbp), %rax
movq 0x8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movq 0x30(%rbp), %rcx
cmpq %rcx, %rdx
jbe 0x14d6ef
movq (%rax,%rcx,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
movl 0x8(%rsp), %r8d
callq 0xee430
testb %al, %al
je 0x14d60c
incq 0x30(%rbp)
jmp 0x14d60c
movb $0x1, 0x38(%rbp)
movl 0xc(%rsp), %eax
incl %eax
jmp 0x14d605
movq 0x1c4637(%rip), %rdi # 0x311d38
leaq 0x12cb4d(%rip), %rsi # 0x27a255
callq 0xf68a0
movq (%rbx), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0xf5810
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0xf8840
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rbp), %rbx
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
movq %rcx, %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %rax, %rbx
setae %al
movl 0x4(%rsp), %esi
orb %al, %sil
jne 0x14d729
movq 0x1c45d4(%rip), %r14 # 0x311d38
leaq 0x12cb07(%rip), %r15 # 0x27a272
leaq 0x137816(%rip), %r12 # 0x284f88
subq %rdx, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbx
jae 0x14d727
movq %r14, %rdi
movq %r15, %rsi
callq 0xf68a0
movq (%rbp), %rcx
movq (%rcx,%rbx,8), %rsi
addq $0x8, %rsi
movq %rax, %rdi
callq 0xf5810
movq %rax, %rdi
movq %r12, %rsi
callq 0xf68a0
incq %rbx
movq (%rbp), %rdx
movq 0x8(%rbp), %rcx
jmp 0x14d772
nop
|
/gahansen[P]omega_h/src/Omega_h_cmdline.cpp
|
void Omega_h::CmdLineFlag::add_arg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void CmdLineFlag::add_arg(std::string const& arg_name, T const& defval) {
args_.push_back(
std::unique_ptr<CmdLineArg<T>>(new CmdLineArg<T>(arg_name, defval)));
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0xf6900
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x100900
addq $0x50, %rbx
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfa160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14e199
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x14e1c7
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14e1c7
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0xf6cf0
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_cmdline.cpp
|
Omega_h::MetricEdgeLengths<2, 2>::MetricEdgeLengths(Omega_h::Mesh const*)
|
MetricEdgeLengths(Mesh const* mesh)
: MetricEdgeLengths(mesh, mesh->get_array<Real>(VERT, "metric")) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1258c1(%rip), %rsi # 0x278771
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xef870
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xf1f50
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xeca80
leaq 0x10(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xf00f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x152f14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_shape.hpp
|
Omega_h::MetricEdgeLengths<3, 1>::MetricEdgeLengths(Omega_h::Mesh const*)
|
MetricEdgeLengths(Mesh const* mesh)
: MetricEdgeLengths(mesh, mesh->get_array<Real>(VERT, "metric")) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x124fb9(%rip), %rsi # 0x278771
leaq 0x20(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0xef870
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xf1f50
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf1740
leaq 0x10(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xf00f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x15381c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_shape.hpp
|
Omega_h::get_verts_onto(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
LOs get_verts_onto(Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs) {
auto nkeys = rails2edges.size();
auto ev2v = mesh->ask_verts_of(EDGE);
auto keys2verts_onto_w = Write<LO>(nkeys, -1);
auto set_key_onto = OMEGA_H_LAMBDA(LO key) {
auto e = rails2edges[key];
auto eev = rail_col_dirs[key];
keys2verts_onto_w[key] = ev2v[e * 2 + (1 - eev)];
};
parallel_for(nkeys, set_key_onto, "get_verts_onto");
return keys2verts_onto_w;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x15a10c
movq (%r14), %r14
jmp 0x15a110
shrq $0x3, %r14
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xf3940
leaq 0x123393(%rip), %rsi # 0x27d4b7
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xef870
shrq $0x2, %r14
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
leaq 0x38(%rsp), %rcx
movl %r14d, %esi
callq 0xf5d40
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0xb8(%rsp), %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0xd8(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0xf0580
leaq 0xe8(%rsp), %rbp
leaq 0x28(%rsp), %rsi
movq %rbp, %rdi
callq 0xf0580
leaq 0x78(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xf0580
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xf0580
leaq 0xa8(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0xf0580
testl %r14d, %r14d
jle 0x15a28f
movq 0x1b7ac2(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xf4160
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0x100b80
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf4160
leaq 0x68(%rsp), %rdi
movq %r13, %rsi
callq 0xf4160
movb $0x0, (%rbp)
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
movq 0x70(%rsp), %rdx
movq 0x60(%rsp), %rsi
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %edi, %edi
cmpq %rdi, %r14
je 0x15a285
movl (%rax,%rdi,4), %r8d
movsbl (%rcx,%rdi), %r9d
leal 0x1(,%r8,2), %r8d
subl %r9d, %r8d
movslq %r8d, %r8
movl (%rdx,%r8,4), %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rdi
jmp 0x15a25c
leaq 0x38(%rsp), %rdi
callq 0x15a3d4
leaq 0x78(%rsp), %rdi
callq 0x15a3d4
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf4160
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a10
leaq 0x18(%rsp), %rdi
callq 0xff620
leaq 0xb8(%rsp), %rdi
callq 0x15a3d4
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x28(%rsp), %rdi
callq 0xff620
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xff620
jmp 0x15a305
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf9e00
jmp 0x15a314
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xff620
jmp 0x15a323
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x15a3d4
jmp 0x15a3aa
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x15a35b
movq %rax, %rbx
movq %r12, %rdi
callq 0xff620
jmp 0x15a349
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x15a356
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xff620
jmp 0x15a3aa
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x15a372
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x15a37f
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xff620
jmp 0x15a3b7
movq %rax, %rbx
jmp 0x15a3b7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x15a3c1
movq %rax, %rbx
jmp 0x15a3c1
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x15a3d4
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x28(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp
|
Omega_h::mark_dead_ents(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>, int, Omega_h::Write<signed char>&, Omega_h::Write<signed char>&)
|
void mark_dead_ents(Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs,
Int cell_dim, Write<I8>& dead_cells, Write<I8>& dead_sides) {
auto e2c = mesh->ask_up(EDGE, cell_dim);
auto e2ec = e2c.a2ab;
auto ec2c = e2c.ab2b;
auto ec_codes = e2c.codes;
auto cs2s = mesh->ask_down(cell_dim, cell_dim - 1).ab2b;
auto nccs = simplex_degree(cell_dim, cell_dim - 1);
auto nrails = rails2edges.size();
auto f = OMEGA_H_LAMBDA(LO rail) {
auto e = rails2edges[rail];
auto eev_col = rail_col_dirs[rail];
auto eev_onto = 1 - eev_col;
for (auto ec = e2ec[e]; ec < e2ec[e + 1]; ++ec) {
auto c = ec2c[ec];
auto ec_code = ec_codes[ec];
auto cce = code_which_down(ec_code);
auto rot = code_rotation(ec_code);
auto cev_onto = rot ^ eev_onto;
auto ccv_onto = simplex_down_template(cell_dim, EDGE, cce, cev_onto);
auto ccs_opp = simplex_opposite_template(cell_dim, VERT, ccv_onto);
auto s_opp = cs2s[c * nccs + ccs_opp];
dead_cells[c] = 1;
dead_sides[s_opp] = 1;
}
};
parallel_for(nrails, f, "mark_dead_ents");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r9, %rbx
movq %r8, %r12
movl %ecx, %r13d
movq %rdx, (%rsp)
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x1f8(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf2f20
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x208(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xf0580
leaq 0x218(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0xf8e10
leal -0x1(%r13), %ecx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0xf6910
movq %r12, %r15
movq %rbx, %r14
leaq 0x58(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xf4160
leaq 0x48(%rsp), %rdi
callq 0xf58a0
leal 0x1(%r13), %r12d
cmpl $0x4, %r13d
pushq $-0x1
popq %rax
cmovael %eax, %r12d
movq (%rbp), %rbx
testb $0x1, %bl
jne 0x15a4b7
movq (%rbx), %rbx
jmp 0x15a4bb
shrq $0x3, %rbx
leaq 0xd8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xe8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf8e10
leaq 0xf8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf0580
leaq 0x108(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf0580
leaq 0x118(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
leaq 0x130(%rsp), %rbp
movl %r13d, -0x8(%rbp)
leaq 0x8(%rsp), %rsi
movq %rbp, %rdi
callq 0xf0580
leaq 0x148(%rsp), %r13
movl %r12d, -0x8(%r13)
movq %r13, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x158(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xf8e10
leaq 0x168(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xf0580
leaq 0x178(%rsp), %r15
movq %r15, %rdi
leaq 0xe8(%rsp), %rsi
callq 0xf8e10
leaq 0x188(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0xf0580
leaq 0x198(%rsp), %rdi
leaq 0x108(%rsp), %rsi
callq 0xf0580
leaq 0x1a8(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0xf8e10
movl 0x128(%rsp), %eax
leaq 0x1c0(%rsp), %rdi
movl %eax, -0x8(%rdi)
movq %rbp, %rsi
callq 0xf0580
movl 0x140(%rsp), %eax
leaq 0x1d8(%rsp), %r14
movl %eax, -0x8(%r14)
movq %r14, %rdi
movq %r13, %rsi
callq 0xf8e10
leaq 0x1e8(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf8e10
shrq $0x2, %rbx
testl %ebx, %ebx
jle 0x15a893
movq 0x1b76a1(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
leaq 0x48(%rsp), %rdi
leaq 0x168(%rsp), %rsi
callq 0xf4160
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x100b80
leaq 0x68(%rsp), %rdi
leaq 0x188(%rsp), %rsi
callq 0xf4160
leaq 0x78(%rsp), %rdi
leaq 0x198(%rsp), %rsi
callq 0xf4160
leaq 0x88(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x100b80
movq %rbp, %r15
movl 0x1b8(%rsp), %eax
leaq 0xa0(%rsp), %r13
movl %eax, -0x8(%r13)
movq %r13, %rdi
leaq 0x1c0(%rsp), %rsi
callq 0xf4160
movl 0x1d0(%rsp), %eax
leaq 0xb8(%rsp), %rbp
movl %eax, -0x8(%rbp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x100b80
leaq 0xc8(%rsp), %rdi
movq %r15, %rsi
callq 0x100b80
movb $0x0, (%r12)
andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
xorl %eax, %eax
pushq $0x2
popq %rcx
movb $0x1, %dl
leaq 0x11ff60(%rip), %rsi # 0x27a648
cmpq %rbx, %rax
je 0x15a889
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %r9
movslq (%rdi,%rax,4), %r8
movsbl (%r9,%rax), %edi
pushq $0x1
popq %r9
subl %edi, %r9d
movq 0x70(%rsp), %rdi
movslq (%rdi,%r8,4), %r10
movslq 0x4(%rdi,%r8,4), %rdi
cmpq %rdi, %r10
jge 0x15a881
movq %rbx, %r15
movq 0x80(%rsp), %rdi
movslq (%rdi,%r10,4), %r11
movl 0x98(%rsp), %edi
cmpl $0x1, %edi
je 0x15a7b9
movq 0x90(%rsp), %rbx
movzbl (%rbx,%r10), %ebp
movl %ebp, %ebx
sarb $0x3, %bl
shrl %ebp
andl $0x3, %ebp
movl %r9d, %r13d
xorl %ebp, %r13d
movzbl %bl, %r14d
cmpl $0x2, %edi
je 0x15a796
pushq $-0x1
popq %r12
cmpl $0x3, %edi
jne 0x15a83c
cmpb $0x5, %bl
ja 0x15a81e
movslq (%rsi,%r14,4), %rdi
addq %rsi, %rdi
jmpq *%rdi
xorl %edi, %edi
cmpl $0x1, %r13d
sete %dil
leal -0x1(,%rdi,4), %r12d
jmp 0x15a7cc
cmpb $0x2, %bl
je 0x15a7d5
cmpl $0x1, %r14d
je 0x15a7be
testl %r14d, %r14d
jne 0x15a81e
xorl %edi, %edi
cmpl $0x1, %r13d
sete %dil
leal (%rdi,%rdi,2), %r12d
decl %r12d
jmp 0x15a832
movl %ecx, %r12d
jmp 0x15a83c
xorl %r12d, %r12d
cmpl $0x1, %r13d
setne %r12b
negl %r12d
cmpl %ebp, %r9d
cmovel %ecx, %r12d
jmp 0x15a83c
xorl %r12d, %r12d
cmpl %ebp, %r9d
je 0x15a83c
pushq $0x1
popq %r12
jmp 0x15a818
xorl %r12d, %r12d
cmpl $0x1, %r13d
setne %r12b
negl %r12d
jmp 0x15a805
xorl %edi, %edi
cmpl $0x1, %r13d
sete %dil
leal -0x1(,%rdi,2), %r12d
cmpl %ebp, %r9d
pushq $0x3
jmp 0x15a837
pushq $0x1
popq %r12
cmpl %ebp, %r9d
je 0x15a83c
movl %ecx, %r12d
cmpl $0x1, %r13d
je 0x15a83c
pushq $-0x1
popq %r12
jmp 0x15a83c
xorl %r12d, %r12d
cmpl $0x1, %r13d
setne %r12b
negl %r12d
cmpl %ebp, %r9d
pushq $0x1
popq %rdi
cmovel %edi, %r12d
movl 0xb0(%rsp), %edi
imull %r11d, %edi
addl %r12d, %edi
movslq %edi, %rdi
movq 0xa8(%rsp), %rbx
movq 0xc0(%rsp), %r14
movslq (%rbx,%rdi,4), %rdi
movb %dl, (%r14,%r11)
movq 0xd0(%rsp), %r11
movb %dl, (%r11,%rdi)
incq %r10
movq 0x70(%rsp), %rdi
movq %r15, %rbx
jmp 0x15a714
incq %rax
jmp 0x15a6e8
leaq 0x48(%rsp), %rdi
callq 0x15aacc
leaq 0x168(%rsp), %rdi
callq 0x15aacc
leaq 0xd8(%rsp), %rdi
callq 0x15aacc
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x28(%rsp), %rdi
callq 0xff620
leaq 0x38(%rsp), %rdi
callq 0xff620
leaq 0x1f8(%rsp), %rdi
callq 0xf58a0
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0xf9e00
jmp 0x15a904
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x15a911
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf9e00
jmp 0x15a923
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xff620
jmp 0x15a932
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xff620
leaq 0x58(%rsp), %rdi
callq 0xf9e00
leaq 0x48(%rsp), %rdi
callq 0xff620
leaq 0x168(%rsp), %rdi
callq 0x15aacc
jmp 0x15a9d6
movq %rax, %rbx
jmp 0x15a93c
movq %rax, %rbx
jmp 0x15a946
movq %rax, %rbx
jmp 0x15a950
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9e00
jmp 0x15a97e
movq %rax, %rbx
leaq 0x1c0(%rsp), %rdi
callq 0xff620
jmp 0x15a990
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0xf9e00
jmp 0x15a9a2
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0xff620
jmp 0x15a9b4
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0xff620
movq %r15, %rdi
callq 0xf9e00
leaq 0x168(%rsp), %rdi
callq 0xff620
leaq 0xd8(%rsp), %rdi
callq 0x15aacc
jmp 0x15aa5c
movq %rax, %rbx
jmp 0x15a9c1
movq %rax, %rbx
jmp 0x15a9c9
movq %rax, %rbx
jmp 0x15a9d6
movq %rax, %rbx
movq %r13, %rdi
callq 0xf9e00
jmp 0x15aa04
movq %rax, %rbx
movq %rbp, %rdi
callq 0xff620
jmp 0x15aa11
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0xf9e00
jmp 0x15aa23
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0xff620
jmp 0x15aa35
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xff620
leaq 0xe8(%rsp), %rdi
callq 0xf9e00
leaq 0xd8(%rsp), %rdi
callq 0xff620
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x28(%rsp), %rdi
callq 0xff620
leaq 0x38(%rsp), %rdi
callq 0xff620
leaq 0x1f8(%rsp), %rdi
callq 0xf58a0
movq %rbx, %rdi
callq 0xff4a0
movq %rax, %rbx
jmp 0x15aa42
movq %rax, %rbx
jmp 0x15aa4f
movq %rax, %rbx
jmp 0x15aa5c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf58a0
jmp 0x15aa66
movq %rax, %rbx
jmp 0x15aa66
movq %rax, %rbx
jmp 0x15aa70
movq %rax, %rbx
jmp 0x15aa7a
movq %rax, %rbx
jmp 0x15aa84
nop
|
/gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp
|
Omega_h::mark_dead_ents(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
HostFew<Read<I8>, 4> mark_dead_ents(
Mesh* mesh, LOs rails2edges, Read<I8> rail_col_dirs) {
HostFew<Write<I8>, 4> writes;
writes[EDGE] = deep_copy(mark_image(rails2edges, mesh->nedges()));
for (Int dim = Int(EDGE) + 1; dim <= mesh->dim(); ++dim)
writes[dim] = Write<I8>(mesh->nents(dim), 0);
for (Int dim = mesh->dim(); dim > EDGE; --dim)
mark_dead_ents(
mesh, rails2edges, rail_col_dirs, dim, writes[dim], writes[dim - 1]);
HostFew<Read<I8>, 4> reads;
for (Int dim = 0; dim < 4; ++dim) reads[dim] = writes[dim];
return reads;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdx, 0x28(%rsp)
movq %rdx, %rsi
callq 0xf0580
movq %r12, %rdi
callq 0xee2f0
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %eax, %edx
callq 0xfa880
leaq 0x12292c(%rip), %rsi # 0x27d4b7
leaq 0x50(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xfe660
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xef740
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x30(%rsp), %rdi
callq 0xff620
pushq $0x2
popq %rbx
leaq 0x90(%rsp), %r14
movq %r12, %rdi
callq 0xfe5f0
cltq
cmpq %rax, %rbx
jg 0x15ac5d
movq %r12, %rdi
movl %ebx, %esi
callq 0xf0100
movl %eax, %r15d
movq %rbp, %rdi
leaq 0x122898(%rip), %rsi # 0x27d4b7
leaq 0x7(%rsp), %rdx
callq 0xef870
movq %r13, %rdi
movl %r15d, %esi
xorl %edx, %edx
movq %rbp, %rcx
callq 0xff7c0
movq %r14, %rdi
movq %r13, %rsi
callq 0xef740
movq %r13, %rdi
callq 0xf9e00
movq %rbp, %rdi
callq 0xf00f0
incq %rbx
addq $0x10, %r14
jmp 0x15abf9
movq %r12, %rdi
callq 0xfe5f0
movl %eax, %ebx
movl %eax, %eax
shlq $0x4, %rax
leaq (%rsp,%rax), %r13
addq $0x70, %r13
leaq 0xd8(%rsp), %r14
leaq 0xc8(%rsp), %r15
cmpl $0x1, %ebx
jle 0x15acd5
movq %r14, %rdi
movq 0x28(%rsp), %rsi
callq 0xf0580
movq %r15, %rdi
movq 0x20(%rsp), %rsi
callq 0xf8e10
leaq -0x10(%r13), %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
movq %r13, %r8
movq %rbp, %r9
callq 0xf43a0
movq %r15, %rdi
callq 0xf9e00
movq %r14, %rdi
callq 0xff620
decl %ebx
movq %rbp, %r13
jmp 0x15ac85
xorps %xmm0, %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
xorl %r15d, %r15d
leaq 0xb8(%rsp), %rbx
leaq 0x50(%rsp), %r14
cmpq $0x40, %r15
je 0x15ad44
leaq (%rsp,%r15), %rsi
addq $0x70, %rsi
movq %rbx, %rdi
callq 0xf8e10
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf8470
movq 0x8(%rsp), %rax
leaq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0xef740
movq %r14, %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xf9e00
addq $0x10, %r15
jmp 0x15acfc
leaq 0x70(%rsp), %rdi
callq 0xf9c00
movq 0x8(%rsp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15ae1e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xf9e00
jmp 0x15ad7c
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x15ad8b
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x15ad9f
jmp 0x15ae1e
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x15adf3
movq %rax, %r14
jmp 0x15adca
movq %rax, %r14
jmp 0x15adbd
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xf9e00
leaq 0xb8(%rsp), %rdi
callq 0xf9e00
movq 0x8(%rsp), %rdi
callq 0xed4d0
jmp 0x15ae21
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0xf9e00
jmp 0x15adeb
movq %rax, %r14
leaq 0xd8(%rsp), %rdi
callq 0xff620
jmp 0x15ae21
jmp 0x15ae1e
jmp 0x15ae1e
movq %rax, %r14
jmp 0x15ae10
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x15ae21
jmp 0x15ae1e
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xf9c00
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_coarsen_topology.cpp
|
r3d::tet_face_from_verts(r3d::Vector<3>, r3d::Vector<3>, r3d::Vector<3>)
|
R3D_INLINE Plane<3> tet_face_from_verts(Vector<3> a, Vector<3> b, Vector<3> c) {
auto center = ONE_THIRD * (a + b + c);
auto normal = normalize(cross((b - a), (c - a)));
auto d = -(normal * center);
return Plane<3>{normal, d};
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x148(%rsp), %r12
movq %r12, %rdi
callq 0xfe090
leaq 0x130(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0xfe090
leaq 0x160(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xfa260
leaq 0x118(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xfe090
leaq 0x178(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xfa260
leaq 0x190(%rsp), %r12
movsd 0x108485(%rip), %xmm0 # 0x27ada8
movq %r12, %rdi
movq %rbp, %rsi
callq 0xecef0
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfe090
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xfe090
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xf54b0
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfe090
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xfe090
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf54b0
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0xf7050
leaq 0x100(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x100810
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfe090
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xfe090
movq %rbx, %rdi
movq %r15, %rsi
callq 0x101880
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfe090
movaps 0x10(%rsp), %xmm0
xorps 0x107b6b(%rip), %xmm0 # 0x27a580
movlps %xmm0, 0x18(%rbx)
movq %rbx, %rax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/r3d.hpp
|
Omega_h::(anonymous namespace)::lt(Omega_h::any&, Omega_h::any&)
|
any lt(any& lhs, any& rhs) {
if (lhs.type() == typeid(Real)) {
return any_cast<Real>(lhs) < any_cast<Real>(rhs);
} else if (lhs.type() == typeid(Reals)) {
return lt_each(any_cast<Reals>(lhs), any_cast<Reals>(rhs));
} else {
throw ParserFail("Invalid operand types to < operator");
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17d598
callq *(%rax)
movq %rax, %rdi
jmp 0x17d59f
movq 0x1946b9(%rip), %rdi # 0x311c58
movq 0x194a42(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
je 0x17d5de
movq %r15, %rdi
callq 0xfe930
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0xfe930
ucomisd 0x10(%rsp), %xmm0
movq 0x1945de(%rip), %rax # 0x311bb0
movq %rax, 0x10(%rbx)
seta (%rbx)
jmp 0x17d65e
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17d5ee
callq *(%rax)
movq %rax, %rdi
jmp 0x17d5f5
movq 0x194663(%rip), %rdi # 0x311c58
movq 0x1949bc(%rip), %rsi # 0x311fb8
callq 0xf2f10
testb %al, %al
je 0x17d66c
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x101270
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x101270
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xfd310
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8fd0
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xfe53f(%rip), %rsi # 0x27bbbd
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x1943ba(%rip), %rsi # 0x311a60
movq 0x19436b(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf00f0
testb %bpl, %bpl
jne 0x17d6cc
jmp 0x17d701
movq %rax, %r14
movq %rbx, %rdi
callq 0xf35c0
jmp 0x17d701
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf9e00
jmp 0x17d6e8
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xfdc90
jmp 0x17d6f7
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::(anonymous namespace)::eq(Omega_h::any&, Omega_h::any&)
|
any eq(any& lhs, any& rhs) {
if (lhs.type() == typeid(Real)) {
return any_cast<Real>(lhs) == any_cast<Real>(rhs);
} else if (lhs.type() == typeid(Reals)) {
return eq_each(any_cast<Reals>(lhs), any_cast<Reals>(rhs));
} else {
throw ParserFail("Invalid operand types to == operator");
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x17d72c
callq *(%rax)
movq %rax, %rdi
jmp 0x17d733
movq 0x194525(%rip), %rdi # 0x311c58
movq 0x1948ae(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
je 0x17d77d
movq %r15, %rdi
callq 0xfe930
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0xfe930
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
setnp %al
sete %cl
andb %al, %cl
movq 0x19443e(%rip), %rax # 0x311bb0
movq %rax, 0x10(%rbx)
movb %cl, (%rbx)
jmp 0x17d7fd
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x17d78d
callq *(%rax)
movq %rax, %rdi
jmp 0x17d794
movq 0x1944c4(%rip), %rdi # 0x311c58
movq 0x19481d(%rip), %rsi # 0x311fb8
callq 0xf2f10
testb %al, %al
je 0x17d80b
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x101270
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x101270
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0xf3e10
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8fd0
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xfe3c4(%rip), %rsi # 0x27bbe1
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x19421b(%rip), %rsi # 0x311a60
movq 0x1941cc(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf00f0
testb %bpl, %bpl
jne 0x17d86b
jmp 0x17d8a0
movq %rax, %r14
movq %rbx, %rdi
callq 0xf35c0
jmp 0x17d8a0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xf9e00
jmp 0x17d887
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xfdc90
jmp 0x17d896
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::(anonymous namespace)::eval_pow(int, Omega_h::any&, Omega_h::any&)
|
any eval_pow(Int dim, any& lhs, any& rhs) {
if (dim == 3) return eval_pow<3>(lhs, rhs);
if (dim == 2) return eval_pow<2>(lhs, rhs);
return eval_pow<1>(lhs, rhs);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x2, %esi
je 0x1817cc
cmpl $0x3, %esi
jne 0x1817e3
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1817fa
callq *(%rax)
movq %rax, %rdi
jmp 0x181801
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x181868
callq *(%rax)
movq %rax, %rdi
jmp 0x18186f
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1818d3
callq *(%rax)
movq %rax, %rdi
jmp 0x1818da
movq 0x190457(%rip), %rdi # 0x311c58
movq 0x1907b0(%rip), %rsi # 0x311fb8
callq 0xf2f10
testb %al, %al
je 0x181851
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x101270
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x101270
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xf39f0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xfcaa0
jmp 0x181925
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x18195f
callq *(%rax)
movq %rax, %rdi
jmp 0x181966
movq 0x1903e9(%rip), %rdi # 0x311c58
movq 0x190742(%rip), %rsi # 0x311fb8
callq 0xf2f10
testb %al, %al
je 0x1818bc
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x101270
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x101270
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xf39f0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xfcaa0
jmp 0x181925
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1819c3
callq *(%rax)
movq %rax, %rdi
jmp 0x1819ca
movq 0x19037e(%rip), %rdi # 0x311c58
movq 0x1906d7(%rip), %rsi # 0x311fb8
callq 0xf2f10
testb %al, %al
je 0x181948
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x101270
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x101270
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xf39f0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xfcaa0
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfdc90
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x181a6d
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x181a23
callq *(%rax)
movq %rax, %rdi
jmp 0x181a2a
movq 0x1902f2(%rip), %rdi # 0x311c58
movq 0x19067b(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
jne 0x181a3a
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %r14
leaq 0xfa337(%rip), %rsi # 0x27bcc3
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x1900ac(%rip), %rsi # 0x311a60
movq 0x19005d(%rip), %rdx # 0x311a18
movq %r14, %rdi
callq 0xfeae0
movq 0x19028e(%rip), %rdi # 0x311c58
movq 0x190617(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
jne 0x181a3a
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %r14
leaq 0xfa2d7(%rip), %rsi # 0x27bcc3
leaq 0x38(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x19004c(%rip), %rsi # 0x311a60
movq 0x18fffd(%rip), %rdx # 0x311a18
movq %r14, %rdi
callq 0xfeae0
movq 0x19022e(%rip), %rdi # 0x311c58
movq 0x1905b7(%rip), %rsi # 0x311fe8
callq 0xf2f10
testb %al, %al
je 0x181a7b
movq %r15, %rdi
callq 0xfe930
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0xfe930
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
callq 0xff0b0
movq 0x18ffc3(%rip), %rax # 0x311a28
movq %rax, 0x10(%rbx)
movsd %xmm0, (%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %r14
leaq 0xfa236(%rip), %rsi # 0x27bcc3
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x18ffab(%rip), %rsi # 0x311a60
movq 0x18ff5c(%rip), %rdx # 0x311a18
movq %r14, %rdi
callq 0xfeae0
jmp 0x181acc
jmp 0x181ae0
jmp 0x181acc
jmp 0x181ae0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
testb %bpl, %bpl
jne 0x181ae3
jmp 0x181b24
movq %rax, %rbx
movq %r14, %rdi
callq 0xf35c0
jmp 0x181b24
jmp 0x181af1
jmp 0x181af1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfdc90
jmp 0x181b07
jmp 0x181b04
jmp 0x181b04
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xfdc90
jmp 0x181b1a
jmp 0x181b17
jmp 0x181b17
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::AssignOp::eval(Omega_h::ExprEnv&)
|
any AssignOp::eval(ExprEnv& env) {
env.variables[name] = rhs->eval(env);
return any();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
addq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xf53e0
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xf1a10
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x182c85
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x182cac
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::NegOp::eval(Omega_h::ExprEnv&)
|
any NegOp::eval(ExprEnv& env) { return neg(env.dim, rhs->eval(env)); }
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x64(%rdx), %ebp
movq 0x8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x182532
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x182df3
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x182e14
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::ExprEnv::string[abi:cxx11](int)
|
std::string ExprEnv::string(int verbose) {
//std::map<std::string, any> variables;
//std::map<std::string, Function> functions;
//LO size;
//Int dim;
std::ostringstream oss, vs;
std::string sep = "";
for(auto i : variables) {
auto v = i.second;
std::string str = any_cast<std::string>(v);
vs << sep << "{" << i.first << " : " << str << "}";
sep = " ";
}
oss << "ExprEnv:"
<< "\n size = " << size
<< "\n dim = " << dim
<< "\n variables = " << vs.str();
(void)verbose;
return oss.str();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x220(%rsp), %rdi
callq 0xfa530
leaq 0xa8(%rsp), %rdi
callq 0xfa530
movq %rbx, 0x10(%rsp)
leaq 0xf89ce(%rip), %rsi # 0x27d4b7
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xef870
movq 0x18(%r14), %r13
movq %r14, 0x8(%rsp)
addq $0x8, %r14
leaq 0x30(%rsp), %r12
leaq 0x88(%rsp), %rbp
leaq 0x18(%rsp), %rbx
leaq 0x68(%rsp), %r15
cmpq %r14, %r13
je 0x184be8
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0xfc890
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x184b4b
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xee520
leaq 0xa8(%rsp), %rdi
movq %r15, %rsi
callq 0xf5810
movq %rax, %rdi
leaq 0xf4b92(%rip), %rsi # 0x279702
callq 0xf68a0
movq %rax, %rdi
movq %r12, %rsi
callq 0xf5810
movq %rax, %rdi
leaq 0xf6e83(%rip), %rsi # 0x27ba0d
callq 0xf68a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0xf5810
movq %rax, %rdi
leaq 0xf48c9(%rip), %rsi # 0x27946d
callq 0xf68a0
movq %r15, %rdi
leaq 0xf9e5a(%rip), %rsi # 0x27ea0d
callq 0x101250
movq %rbp, %rdi
callq 0xf00f0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x184bd0
movq %rbx, %rdi
callq *0x8(%rax)
movq %r12, %rdi
callq 0xf1b90
movq %r13, %rdi
callq 0xf32d0
movq %rax, %r13
jmp 0x184b1c
leaq 0xf6e22(%rip), %rsi # 0x27ba11
leaq 0x220(%rsp), %rdi
callq 0xf68a0
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rbx
leaq 0xf6e0d(%rip), %rsi # 0x27ba1a
movq %rax, %rdi
callq 0xf68a0
movl 0x60(%rbx), %esi
movq %rax, %rdi
callq 0xfed90
leaq 0xf6e03(%rip), %rsi # 0x27ba2a
movq %rax, %rdi
callq 0xf68a0
movl 0x64(%rbx), %esi
movq %rax, %rdi
callq 0xfed90
leaq 0xf6df9(%rip), %rsi # 0x27ba3a
movq %rax, %rdi
callq 0xf68a0
movq %rax, %rbx
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0xfd390
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf5810
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x228(%rsp), %rsi
movq %r14, %rdi
callq 0xfd390
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
callq 0xedd80
leaq 0x220(%rsp), %rdi
callq 0xedd80
movq %r14, %rax
addq $0x398, %rsp # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x184d16
jmp 0x184ce5
movq %rax, %rbx
jmp 0x184d20
movq %rax, %rbx
jmp 0x184d2d
jmp 0x184ce5
movq %rax, %rbx
jmp 0x184d0c
movq %rax, %rbx
jmp 0x184cfa
movq %rax, %rbx
jmp 0x184d16
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf00f0
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x184d0c
leaq 0x18(%rsp), %rdi
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
callq 0xf1b90
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
callq 0xedd80
leaq 0x220(%rsp), %rdi
callq 0xedd80
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::(anonymous namespace)::promote_bools(int, Omega_h::any&, Omega_h::any&)
|
void promote_bools(LO size, any& lhs, any& rhs) {
if (lhs.type() == typeid(bool) && rhs.type() == typeid(Bytes)) {
OMEGA_H_CHECK(any_cast<Bytes>(rhs).size() == size);
promote_bool(size, lhs);
}
if (lhs.type() == typeid(Bytes) && rhs.type() == typeid(bool)) {
OMEGA_H_CHECK(any_cast<Bytes>(lhs).size() == size);
promote_bool(size, rhs);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x1850cd
callq *(%rax)
movq %rax, %rdi
jmp 0x1850d4
movq 0x18cb84(%rip), %rdi # 0x311c58
movq 0x18cbbd(%rip), %rsi # 0x311c98
callq 0xf2f10
testb %al, %al
je 0x185147
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1850f4
callq *(%rax)
movq %rax, %rdi
jmp 0x1850fb
movq 0x18cb5d(%rip), %rdi # 0x311c58
movq 0x18cdbe(%rip), %rsi # 0x311ec0
callq 0xf2f10
testb %al, %al
je 0x185147
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfddf0
movq (%r15), %rax
testb $0x1, %al
jne 0x185127
movq (%rax), %rax
jmp 0x18512b
shrq $0x3, %rax
cmpl %ebp, %eax
jne 0x1851d8
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movl %ebp, %edi
movq %r14, %rsi
callq 0x184d42
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x185157
callq *(%rax)
movq %rax, %rdi
jmp 0x18515e
movq 0x18cafa(%rip), %rdi # 0x311c58
movq 0x18cd5b(%rip), %rsi # 0x311ec0
callq 0xf2f10
testb %al, %al
je 0x1851cd
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x18517e
callq *(%rax)
movq %rax, %rdi
jmp 0x185185
movq 0x18cad3(%rip), %rdi # 0x311c58
movq 0x18cb0c(%rip), %rsi # 0x311c98
callq 0xf2f10
testb %al, %al
je 0x1851cd
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xfddf0
movq (%r15), %rax
testb $0x1, %al
jne 0x1851b1
movq (%rax), %rax
jmp 0x1851b5
shrq $0x3, %rax
cmpl %ebp, %eax
jne 0x1851f7
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movl %ebp, %edi
movq %rbx, %rsi
callq 0x184d42
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf1ea9(%rip), %rdi # 0x277088
leaq 0xf68ba(%rip), %rsi # 0x27baa0
leaq 0xf66c7(%rip), %rdx # 0x27b8b4
pushq $0x15
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
leaq 0xf1e8a(%rip), %rdi # 0x277088
leaq 0xf68bf(%rip), %rsi # 0x27bac4
leaq 0xf66a8(%rip), %rdx # 0x27b8b4
pushq $0x19
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
jmp 0x185218
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
std::vector<Omega_h::any, std::allocator<Omega_h::any>>& Omega_h::any_cast<std::vector<Omega_h::any, std::allocator<Omega_h::any>>&>(Omega_h::any&)
|
inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
}
|
pushq %rax
callq 0xf3860
testq %rax, %rax
je 0x18888b
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0xf0720
movq 0x189666(%rip), %rcx # 0x311f00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x189108(%rip), %rsi # 0x3119b0
movq 0x1895c9(%rip), %rdx # 0x311e78
movq %rax, %rdi
callq 0xfeae0
nop
|
/gahansen[P]omega_h/src/Omega_h_any.hpp
|
Omega_h::CallOp::CallOp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Omega_h::any, std::allocator<Omega_h::any>> const&)
|
CallOp(std::string const& name_in, ExprEnv::Args const& args_in)
: name(name_in) {
for (auto& arg : args_in) {
OpPtr op = any_cast<OpPtr>(arg);
rhs.push_back(op);
}
args.reserve(rhs.size());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r12
movq 0x188dff(%rip), %rax # 0x311af0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0xfabe0
leaq 0x28(%r12), %r14
leaq 0x40(%r12), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r12)
movups %xmm0, 0x38(%r12)
movups %xmm0, 0x28(%r12)
movq (%rbx), %rbp
movq 0x8(%rbx), %r15
leaq 0x20(%rsp), %r13
leaq 0x18(%rsp), %rbx
cmpq %r15, %rbp
je 0x188d64
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf13f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc7f0
movq %r13, %rdi
callq 0xf6d50
addq $0x18, %rbp
jmp 0x188d3b
movq 0x30(%r12), %rsi
subq 0x28(%r12), %rsi
sarq $0x4, %rsi
movq 0x8(%rsp), %rdi
callq 0xfc4a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x188d8d
movq %rax, %rbx
jmp 0x188d9d
movq %rax, %rbx
movq %r13, %rdi
callq 0xf6d50
movq 0x8(%rsp), %rdi
callq 0xfac20
movq %r14, %rdi
callq 0xf1b60
movq 0x10(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_expr.cpp
|
Omega_h::any::swap(Omega_h::any&)
|
void swap(any& rhs) noexcept {
if (this->vtable != rhs.vtable) {
any tmp(std::move(rhs));
// move from *this to rhs.
rhs.vtable = this->vtable;
if (this->vtable != nullptr) {
this->vtable->move(this->storage, rhs.storage);
// this->vtable = nullptr; -- uneeded, see below
}
// move from tmp (previously rhs) to *this.
this->vtable = tmp.vtable;
if (tmp.vtable != nullptr) {
tmp.vtable->move(tmp.storage, this->storage);
tmp.vtable = nullptr;
}
} else // same types
{
if (this->vtable != nullptr)
this->vtable->swap(this->storage, rhs.storage);
}
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
je 0x1893a7
movq %rsp, %rdi
movq %r14, %rsi
callq 0xedf40
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x18938e
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1893bf
movq %rsp, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x1893bf
testq %rax, %rax
je 0x1893bf
movq 0x20(%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_any.hpp
|
bool Omega_h::any_cast<bool>(Omega_h::any&)
|
inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
}
|
pushq %rax
callq 0xfab30
testq %rax, %rax
je 0x1893ff
movb (%rax), %al
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0xf0720
movq 0x188af2(%rip), %rcx # 0x311f00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x188594(%rip), %rsi # 0x3119b0
movq 0x188a55(%rip), %rdx # 0x311e78
movq %rax, %rdi
callq 0xfeae0
nop
|
/gahansen[P]omega_h/src/Omega_h_any.hpp
|
Omega_h::binary::read(Omega_h::filesystem::path const&, std::shared_ptr<Omega_h::Comm>, bool)
|
Mesh read(filesystem::path const& path, CommPtr comm, bool strict) {
ScopedTimer timer("binary::read(path, comm, strict)");
auto mesh = Mesh(comm->library());
binary::read(path, comm, &mesh, strict);
return mesh;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xee796(%rip), %rdi # 0x27cc26
xorl %esi, %esi
callq 0xf9c20
movq (%r15), %rdi
callq 0x101500
movq %rbx, %rdi
movq %rax, %rsi
callq 0xff100
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf21a0
movzbl %bpl, %ecx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xf8ce0
leaq 0x18(%rsp), %rdi
callq 0xf6d50
leaq 0xf(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xf6d50
movq %rbx, %rdi
callq 0xfcf10
jmp 0x18e50a
movq %rax, %r14
leaq 0xf(%rsp), %rdi
callq 0xf7d50
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_file.cpp
|
Omega_h::filesystem::current_path()
|
path current_path() {
char buf[1024];
errno = 0;
char* ret = ::getcwd(buf, sizeof(buf));
if (ret == nullptr) {
throw filesystem_error(errno, "current_path");
}
return ret;
}
|
pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdi, %rbx
callq 0xec440
movq %rax, %r14
andl $0x0, (%rax)
movq %rsp, %rdi
movl $0x400, %esi # imm = 0x400
callq 0xf0ea0
testq %rax, %rax
je 0x1907e5
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf1a70
movq %rbx, %rax
addq $0x408, %rsp # imm = 0x408
popq %rbx
popq %r14
retq
pushq $0x20
popq %rdi
callq 0xf0720
movq %rax, %rbx
movl (%r14), %esi
leaq 0xec6bf(%rip), %rdx # 0x27ceb9
movq %rax, %rdi
callq 0xf5a10
movq 0x181337(%rip), %rsi # 0x311b40
movq 0x181228(%rip), %rdx # 0x311a38
movq %rbx, %rdi
callq 0xfeae0
movq %rax, %r14
movq %rbx, %rdi
callq 0xf35c0
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_filesystem.cpp
|
Omega_h::filesystem::path::filename() const
|
path path::filename() const {
auto const last_sep_pos = impl.find_last_of(preferred_separator);
if (last_sep_pos == std::string::npos) return impl;
return impl.substr(last_sep_pos + 1, std::string::npos);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2f
popq %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x101ae0
cmpq $-0x1, %rax
je 0x190b0f
incq %rax
movq %rsp, %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf7020
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd9e0
movq %rsp, %rdi
callq 0xf00f0
jmp 0x190b1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd9e0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_filesystem.cpp
|
Omega_h::filesystem::path::extension() const
|
path path::extension() const {
auto const filename_str = filename().native();
auto const last_dot_pos = filename_str.find_last_of('.');
// If the pathname is either . or .., or if filename() does not contain the .
// character, then empty path is returned.
if (last_dot_pos == std::string::npos) return path();
if (filename_str == "." || filename_str == "..") return path();
// If the first character in the filename is a period, that period is ignored
// (a filename like ".profile" is not treated as an extension)
if (last_dot_pos == 0) return path();
// If the filename() component of the generic-format path contains a period
// (.), and is not one of the special filesystem elements dot or dot-dot, then
// the extension is the substring beginning at the rightmost period (including
// the period) and until the end of the pathname.
return filename_str.substr(last_dot_pos, std::string::npos);
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xfa5d0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xfabe0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
pushq $0x2e
popq %rsi
pushq $-0x1
popq %rdx
callq 0x101ae0
cmpq $-0x1, %rax
je 0x190c54
movq %rax, %r14
leaq 0xe883c(%rip), %rsi # 0x27943a
leaq 0x28(%rsp), %rdi
callq 0x101e60
testb %al, %al
jne 0x190c54
leaq 0xec2c6(%rip), %rsi # 0x27ced9
leaq 0x28(%rsp), %rdi
callq 0x101e60
testb %al, %al
jne 0x190c54
testq %r14, %r14
je 0x190c54
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0xf7020
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xfd9e0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x190c67
leaq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
leaq 0x28(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x190c8e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x190c9d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_filesystem.cpp
|
Omega_h::filesystem::IteratorImpl::increment()
|
void increment() {
errno = 0;
entry = ::readdir(stream);
if (entry == nullptr) {
if (errno != 0) {
throw filesystem_error(errno, "directory_iterator");
}
// safely reached the end of the directory
close();
} else {
// we just extracted a good entry from the stream
// skip dot and dot-dot, max 3-call recursion
if (0 == strcmp(entry->d_name, "."))
increment();
else if (0 == strcmp(entry->d_name, ".."))
increment();
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xec440
movq %rax, %rbx
andl $0x0, (%rbx)
movq 0x20(%r14), %rdi
callq 0xfc930
movq %rax, 0x28(%r14)
testq %rax, %rax
je 0x191270
cmpb $0x2e, 0x13(%rax)
jne 0x191268
cmpb $0x0, 0x14(%rax)
je 0x19123b
cmpb $0x2e, 0x14(%rax)
jne 0x191268
cmpb $0x0, 0x15(%rax)
je 0x19123b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%rbx)
jne 0x191284
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xffaf0
pushq $0x20
popq %rdi
callq 0xf0720
movq %rax, %r14
movl (%rbx), %esi
leaq 0xebc44(%rip), %rdx # 0x27cedc
movq %rax, %rdi
callq 0xf5a10
movq 0x180899(%rip), %rsi # 0x311b40
movq 0x18078a(%rip), %rdx # 0x311a38
movq %r14, %rdi
callq 0xfeae0
movq %rax, %rbx
movq %r14, %rdi
callq 0xf35c0
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_filesystem.cpp
|
Omega_h::add_transition(Omega_h::FiniteAutomaton&, int, int, int)
|
void add_transition(
FiniteAutomaton& fa, int from_state, int at_symbol, int to_state) {
OMEGA_H_CHECK(0 <= to_state);
OMEGA_H_CHECK(to_state < get_nstates(fa));
OMEGA_H_CHECK(0 <= at_symbol);
OMEGA_H_CHECK(
at_symbol < get_ncols(fa.table)); // allow setting epsilon transitions
OMEGA_H_CHECK(at(fa.table, from_state, at_symbol) == -1);
at(fa.table, from_state, at_symbol) = to_state;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %ecx, %ecx
js 0x19160a
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0xf0f90
cmpl %ebx, %eax
jle 0x191623
testl %ebp, %ebp
js 0x19163c
cmpl %ebp, 0x18(%r15)
jle 0x191655
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xffe00
cmpl $-0x1, (%rax)
jne 0x19166e
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xffe00
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe5a77(%rip), %rdi # 0x277088
leaq 0xeb9f6(%rip), %rsi # 0x27d00e
leaq 0xeb984(%rip), %rdx # 0x27cfa3
pushq $0x34
jmp 0x191685
leaq 0xe5a5e(%rip), %rdi # 0x277088
leaq 0xeb9eb(%rip), %rsi # 0x27d01c
leaq 0xeb96b(%rip), %rdx # 0x27cfa3
pushq $0x35
jmp 0x191685
leaq 0xe5a45(%rip), %rdi # 0x277088
leaq 0xeb9ed(%rip), %rsi # 0x27d037
leaq 0xeb952(%rip), %rdx # 0x27cfa3
pushq $0x36
jmp 0x191685
leaq 0xe5a2c(%rip), %rdi # 0x277088
leaq 0xeb9e3(%rip), %rsi # 0x27d046
leaq 0xeb939(%rip), %rdx # 0x27cfa3
pushq $0x38
jmp 0x191685
leaq 0xe5a13(%rip), %rdi # 0x277088
leaq 0xeb9ea(%rip), %rsi # 0x27d066
leaq 0xeb920(%rip), %rdx # 0x27cfa3
pushq $0x39
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::FiniteAutomaton::maybe(Omega_h::FiniteAutomaton const&, int)
|
FiniteAutomaton FiniteAutomaton::maybe(FiniteAutomaton const& a, int token) {
FiniteAutomaton out(get_nsymbols(a), false, get_nstates(a) + 2);
auto new_start_state = add_state(out);
auto offset = get_nstates(out);
append_states(out, a);
auto new_accept_state = add_state(out);
auto epsilon0 = get_epsilon0(out);
auto epsilon1 = get_epsilon1(out);
add_transition(out, new_start_state, epsilon1, offset);
/* form an epsilon0 linked list of new start state,
all old accepting states, and new accepting state */
auto last = new_start_state;
for (int i = 0; i < get_nstates(a); ++i) {
if (accepts(a, i) != -1) {
add_transition(out, last, epsilon0, i + offset);
remove_accept(out, i + offset);
last = i + offset;
}
}
add_transition(out, last, epsilon0, new_accept_state);
add_accept(out, new_accept_state, token);
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movl 0x18(%rsi), %eax
movzbl 0x38(%rsi), %ecx
leal (%rax,%rcx,2), %ebp
addl $-0x2, %ebp
movq %rsi, %rdi
callq 0xf0f90
leal 0x2(%rax), %ecx
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xeea00
movq %rbx, %rdi
callq 0xf67c0
movl %eax, %r15d
movq %rbx, %rdi
callq 0xf0f90
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfcff0
movq %rbx, %rdi
callq 0xf67c0
movl %eax, 0x8(%rsp)
movq %rbx, %rdi
callq 0xf0350
movl %eax, %ebp
movq %rbx, %rdi
callq 0xed970
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
movq 0x10(%rsp), %rcx
callq 0xffdb0
xorl %r12d, %r12d
movq %r14, %rdi
callq 0xf0f90
cmpl %eax, %r12d
jge 0x191de6
movq %r14, %rdi
movl %r12d, %esi
callq 0xf3750
cmpl $-0x1, %eax
je 0x191ddb
movq 0x10(%rsp), %rax
leal (%rax,%r12), %r13d
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xffdb0
movq %rbx, %rdi
movl %r13d, %esi
callq 0xf3970
jmp 0x191dde
movl %r15d, %r13d
incl %r12d
movl %r13d, %r15d
jmp 0x191d98
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
movl 0x8(%rsp), %ebp
movl %ebp, %ecx
callq 0xffdb0
movq %rbx, %rdi
movl %ebp, %esi
movl 0xc(%rsp), %edx
callq 0xf82f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x191e25
jmp 0x191e25
jmp 0x191e25
jmp 0x191e25
jmp 0x191e25
jmp 0x191e25
movq %rax, %r14
movq %rbx, %rdi
callq 0xff8e0
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::FiniteAutomaton::simplify_once(Omega_h::FiniteAutomaton const&)
|
FiniteAutomaton FiniteAutomaton::simplify_once(FiniteAutomaton const& fa) {
StateRow2SimpleState sr2ss({fa.table, fa.accepted_tokens});
int nsimple = 0;
for (int state = 0; state < get_nstates(fa); ++state) {
auto res = sr2ss.insert(std::make_pair(state, nsimple));
if (res.second) {
++nsimple;
}
}
FiniteAutomaton out(get_nsymbols(fa), get_determinism(fa), nsimple);
for (int simple = 0; simple < nsimple; ++simple) {
add_state(out);
}
std::vector<bool> did_simple(size_t(nsimple), false);
for (int state = 0; state < get_nstates(fa); ++state) {
OMEGA_H_CHECK(sr2ss.count(state));
auto simple = sr2ss[state];
if (at(did_simple, simple)) continue;
for (int symbol = 0; symbol < get_nsymbols_eps(fa); ++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state == -1) continue;
OMEGA_H_CHECK(sr2ss.count(next_state));
auto next_simple = sr2ss[next_state];
add_transition(out, simple, symbol, next_simple);
}
auto token = accepts(fa, state);
if (token != -1) {
add_accept(out, simple, token);
}
at(did_simple, simple) = true;
}
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsi), %rax
leaq 0x40(%rsp), %rcx
movq %rsi, -0x10(%rcx)
movq %rax, -0x8(%rcx)
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
leaq 0x8(%rsp), %r13
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xf0f90
cltq
cmpq %rax, %rbp
jge 0x192458
movq %r15, %rax
shlq $0x20, %rax
addq %rbp, %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xf9d00
andb $0x1, %dl
movzbl %dl, %eax
addl %eax, %r15d
incq %rbp
jmp 0x192421
movl 0x18(%r14), %eax
movzbl 0x38(%r14), %edx
leal (%rax,%rdx,2), %esi
addl $-0x2, %esi
movq %rbx, %rdi
movl %r15d, %ecx
callq 0xeea00
movl %r15d, %ebp
subl $0x1, %ebp
jb 0x192484
movq %rbx, %rdi
callq 0xf67c0
jmp 0x192475
movl %r15d, %esi
movq %rsp, %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rcx
callq 0xf94d0
xorl %r12d, %r12d
leaq 0x30(%rsp), %r15
leaq 0x4(%rsp), %rbp
movl %r12d, (%rsp)
movq %r14, %rdi
callq 0xf0f90
cmpl %eax, %r12d
jge 0x19257b
movq %r15, %rdi
movq %rsp, %rsi
callq 0xef200
testq %rax, %rax
je 0x1925c2
movq %r15, %rdi
movq %rsp, %rsi
callq 0xee4e0
movl (%rax), %r13d
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
callq 0xeda60
testq %rdx, (%rax)
jne 0x19256f
xorl %r12d, %r12d
cmpl 0x18(%r14), %r12d
jge 0x192542
movl (%rsp), %esi
movq %r14, %rdi
movl %r12d, %edx
callq 0xfaa30
movl %eax, 0x4(%rsp)
cmpl $-0x1, %eax
je 0x19253d
movq %r15, %rdi
movq %rbp, %rsi
callq 0xef200
testq %rax, %rax
je 0x1925a1
movq %r15, %rdi
movq %rbp, %rsi
callq 0xee4e0
movl (%rax), %ecx
movq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0xffdb0
incl %r12d
jmp 0x1924f5
movl (%rsp), %esi
movq %r14, %rdi
callq 0xf3750
cmpl $-0x1, %eax
je 0x19255f
movq %rbx, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0xf82f0
leaq 0x8(%rsp), %rdi
movl %r13d, %esi
callq 0xeda60
orq %rdx, (%rax)
movl (%rsp), %r12d
incl %r12d
jmp 0x1924a9
leaq 0x8(%rsp), %rdi
callq 0x100e00
leaq 0x30(%rsp), %rdi
callq 0x100540
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe4ae0(%rip), %rdi # 0x277088
leaq 0xeab7e(%rip), %rsi # 0x27d12d
leaq 0xea9ed(%rip), %rdx # 0x27cfa3
movl $0x164, %ecx # imm = 0x164
xorl %eax, %eax
callq 0xf6ee0
leaq 0xe4abf(%rip), %rdi # 0x277088
leaq 0xeab4a(%rip), %rsi # 0x27d11a
leaq 0xea9cc(%rip), %rdx # 0x27cfa3
movl $0x15e, %ecx # imm = 0x15E
xorl %eax, %eax
callq 0xf6ee0
jmp 0x1925f1
jmp 0x1925f8
jmp 0x192603
jmp 0x192603
jmp 0x192603
jmp 0x192603
jmp 0x192603
movq %rax, %r14
jmp 0x192610
jmp 0x1925f8
movq %rax, %r14
jmp 0x192618
jmp 0x192603
jmp 0x192603
jmp 0x192603
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x100e00
movq %rbx, %rdi
callq 0xff8e0
leaq 0x30(%rsp), %rdi
callq 0x100540
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::make_char_set_nfa(std::set<char, std::less<char>, std::allocator<char>> const&, int)
|
FiniteAutomaton make_char_set_nfa(std::set<char> const& accepted, int token) {
std::set<int> symbol_set;
for (auto c : accepted) symbol_set.insert(get_symbol(c));
return FiniteAutomaton::make_set_nfa(Omega_h::NCHARS, symbol_set, token);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x18(%rsi), %r12
addq $0x8, %r14
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r13
cmpq %r14, %r12
je 0x1927dd
movsbl 0x20(%r12), %edi
callq 0xffd60
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0xf8780
movq %r12, %rdi
callq 0xf86e0
movq %rax, %r12
jmp 0x1927b1
pushq $0x62
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x101210
leaq 0x8(%rsp), %rdi
callq 0xf7aa0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19280d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf7aa0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::operator<<(std::ostream&, Omega_h::FiniteAutomaton const&)
|
std::ostream& operator<<(std::ostream& os, FiniteAutomaton const& fa) {
if (get_determinism(fa))
os << "dfa ";
else
os << "nfa ";
os << get_nstates(fa) << " states " << get_nsymbols(fa) << " symbols\n";
for (int state = 0; state < get_nstates(fa); ++state) {
for (int symbol = 0; symbol < get_nsymbols(fa); ++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state != -1)
os << "(" << state << ", " << symbol << ") -> " << next_state << '\n';
}
if (!get_determinism(fa)) {
for (int symbol = get_epsilon0(fa); symbol <= get_epsilon1(fa);
++symbol) {
auto next_state = step(fa, state, symbol);
if (next_state != -1)
os << "(" << state << ", eps" << (symbol - get_epsilon0(fa))
<< ") -> " << next_state << '\n';
}
}
auto token = accepts(fa, state);
if (token != -1) os << state << " accepts " << token << '\n';
}
return os;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xea83f(%rip), %rax # 0x27d188
leaq 0xea83d(%rip), %rsi # 0x27d18d
cmpb $0x0, 0x38(%r14)
cmovneq %rax, %rsi
callq 0xf68a0
movq %r14, %rdi
callq 0xf0f90
movq %rbx, %rdi
movl %eax, %esi
callq 0xfed90
leaq 0xea81b(%rip), %rsi # 0x27d192
movq %rax, %rdi
callq 0xf68a0
movl 0x18(%r14), %ecx
movzbl 0x38(%r14), %edx
leal (%rcx,%rdx,2), %esi
addl $-0x2, %esi
movq %rax, %rdi
callq 0xfed90
leaq 0xea7fe(%rip), %rsi # 0x27d19b
movq %rax, %rdi
callq 0xf68a0
xorl %ebp, %ebp
leaq 0xee4dc(%rip), %r12 # 0x280e8a
movq %r14, %rdi
callq 0xf0f90
cmpl %eax, %ebp
jge 0x192b3c
xorl %r15d, %r15d
movl 0x18(%r14), %ecx
movzbl 0x38(%r14), %eax
leal (%rcx,%rax,2), %ecx
addl $-0x2, %ecx
cmpl %ecx, %r15d
jge 0x192a46
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xfaa30
cmpl $-0x1, %eax
je 0x192a3e
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf68a0
movq %rax, %rdi
movl %ebp, %esi
callq 0xfed90
movq %rax, %rdi
leaq 0xeb787(%rip), %rsi # 0x27e190
callq 0xf68a0
movq %rax, %rdi
movl %r15d, %esi
callq 0xfed90
movq %rax, %rdi
leaq 0xea782(%rip), %rsi # 0x27d1a5
callq 0xf68a0
movq %rax, %rdi
movl %r13d, %esi
callq 0xfed90
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0xf8840
incl %r15d
jmp 0x1929c1
testb %al, %al
je 0x192a92
movq %r14, %rdi
movl %ebp, %esi
callq 0xf3750
cmpl $-0x1, %eax
je 0x192a8b
movl %eax, %r15d
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfed90
movq %rax, %rdi
leaq 0xea741(%rip), %rsi # 0x27d1b1
callq 0xf68a0
movq %rax, %rdi
movl %r15d, %esi
callq 0xfed90
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0xf8840
incl %ebp
jmp 0x1929ae
movq %r14, %rdi
callq 0xf0350
movl %eax, %r15d
movl %ebp, 0x4(%rsp)
movq %r14, %rdi
callq 0xed970
cmpl %eax, %r15d
jg 0x192a4a
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0xfaa30
cmpl $-0x1, %eax
je 0x192b34
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf68a0
movq %rax, %rdi
movl %ebp, %esi
callq 0xfed90
movq %rax, %rdi
leaq 0xea6c9(%rip), %rsi # 0x27d1ab
callq 0xf68a0
movq %rbx, %rbp
movq %r12, %rbx
movq %rax, %r12
movq %r14, %rdi
callq 0xf0350
movl %r15d, %esi
subl %eax, %esi
movq %r12, %rdi
movq %rbx, %r12
movq %rbp, %rbx
movl 0x4(%rsp), %ebp
callq 0xfed90
movq %rax, %rdi
leaq 0xea68c(%rip), %rsi # 0x27d1a5
callq 0xf68a0
movq %rax, %rdi
movl %r13d, %esi
callq 0xfed90
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0xf8840
incl %r15d
jmp 0x192aa1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::StateRowLess::operator()(int const&, int const&) const
|
bool operator()(int const& a, int const& b) const {
auto aa = at(accepted, a);
auto ab = at(accepted, b);
if (aa != ab) return aa < ab;
for (int symbol = 0, ncols = get_ncols(table); symbol < ncols; ++symbol) {
auto ea = at(table, a, symbol);
auto eb = at(table, b, symbol);
if (ea != eb) return ea < eb;
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movl (%rsi), %esi
callq 0xf2a70
movl (%rax), %ebp
movq 0x8(%r15), %rdi
movl (%rbx), %esi
callq 0xf2a70
cmpl (%rax), %ebp
jne 0x193a28
movq (%r15), %rax
movl 0x18(%rax), %r12d
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
cmpl %ebp, %r12d
je 0x193a2d
movq (%r15), %rdi
movl (%r14), %esi
movl %ebp, %edx
callq 0xee680
movl (%rax), %r13d
movq (%r15), %rdi
movl (%rbx), %esi
movl %ebp, %edx
callq 0xee680
incl %ebp
cmpl (%rax), %r13d
je 0x193a00
setl %al
jmp 0x193a2f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_finite_automaton.cpp
|
Omega_h::get_histogram(Omega_h::Mesh*, int, int, double, double, Omega_h::Read<double>)
|
Histogram get_histogram(Mesh* mesh, Int dim, Int nbins, Real min_value,
Real max_value, Reals values) {
OMEGA_H_CHECK(values.size() == mesh->nents(dim));
auto owned_values = mesh->owned_array(dim, values, 1);
auto interval = (max_value - min_value) / Real(nbins);
Histogram histogram;
histogram.min = min_value;
histogram.max = max_value;
histogram.bins.resize(std::size_t(nbins));
for (Int i = 0; i < nbins; ++i) {
auto floor = interval * i + min_value;
auto ceil = interval * (i + 1) + min_value;
if (i == nbins - 1) ceil = max_value;
auto floor_marks = each_geq_to(owned_values, floor);
Read<I8> ceil_marks;
if (i == nbins - 1)
ceil_marks = each_leq_to(owned_values, ceil);
else
ceil_marks = each_lt(owned_values, ceil);
auto marked = land_each(floor_marks, ceil_marks);
histogram.bins[std::size_t(i)] = get_sum(mesh->comm(), marked);
}
return histogram;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r8, %r14
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r13
movq %rdi, 0x38(%rsp)
movq (%r8), %r15
testb $0x1, %r15b
jne 0x1a32e7
movq (%r15), %r15
jmp 0x1a32eb
shrq $0x3, %r15
shrq $0x3, %r15
movq %r13, %rdi
movl %ebx, %esi
callq 0xf0100
cmpl %r15d, %eax
jne 0x1a3582
leaq 0xf8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
movq %rsp, %rdi
pushq $0x1
popq %r8
movq %r13, %rsi
movl %ebx, %edx
movq %r15, %rcx
callq 0xfe2d0
movq %r13, 0x50(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xfdc90
movq 0x38(%rsp), %rax
leaq 0x10(%rax), %rdi
xorpd %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movupd %xmm0, 0x10(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movslq %r12d, %rsi
movq %rdi, 0x40(%rsp)
callq 0xf8a40
movsd 0x18(%rsp), %xmm1
subsd 0x10(%rsp), %xmm1
cvtsi2sd %r12d, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x48(%rsp)
leal -0x1(%r12), %eax
movq %rax, 0x58(%rsp)
xorl %ebp, %ebp
testl %r12d, %r12d
cmovlel %ebp, %r12d
movq %r12, 0x60(%rsp)
leaq 0xa8(%rsp), %r13
leaq 0x78(%rsp), %r14
leaq 0xd8(%rsp), %r15
leaq 0xc8(%rsp), %r12
cmpq %rbp, 0x60(%rsp)
je 0x1a3563
movq %r13, %rdi
movq %rsp, %rsi
callq 0xf3e40
cvtsi2sd %ebp, %xmm0
mulsd 0x48(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
leaq 0x88(%rsp), %rdi
movq %r13, %rsi
callq 0xef750
movq %r13, %rdi
callq 0xfdc90
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
cmpq 0x58(%rsp), %rbp
jne 0x1a3451
leaq 0xe8(%rsp), %r13
movq %r13, %rdi
movq %rsp, %rsi
callq 0xf3e40
movq %r14, %rdi
movq %r13, %rsi
movsd 0x18(%rsp), %xmm0
callq 0xf3240
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xef740
movq %r14, %rdi
callq 0xf9e00
movq %r13, %rdi
jmp 0x1a349f
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xf3e40
leal 0x1(%rbp), %eax
cvtsi2sd %eax, %xmm0
mulsd 0x48(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfda50
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xef740
movq %r14, %rdi
callq 0xf9e00
leaq 0x98(%rsp), %rdi
callq 0xfdc90
movq %r15, %rdi
leaq 0x88(%rsp), %rsi
callq 0xf8e10
movq %r12, %rbx
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
callq 0xf8e10
movq %r14, %rdi
movq %r15, %r13
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfc5b0
movq %rbx, %rdi
callq 0xf9e00
movq %r13, %rdi
callq 0xf9e00
leaq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xeef10
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf8e10
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x100460
cltq
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx,%rbp,8)
movq %rbx, %rdi
callq 0xf9e00
leaq 0x70(%rsp), %rdi
callq 0xf6d50
movq %r14, %rdi
callq 0xf9e00
leaq 0x20(%rsp), %rdi
callq 0xf9e00
leaq 0x88(%rsp), %rdi
callq 0xf9e00
incq %rbp
leaq 0xa8(%rsp), %r13
jmp 0x1a33c4
movq %rsp, %rdi
callq 0xfdc90
movq 0x38(%rsp), %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd3aff(%rip), %rdi # 0x277088
leaq 0xdaa40(%rip), %rsi # 0x27dfd0
leaq 0xdaa5b(%rip), %rdx # 0x27dff2
pushq $0x11
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
jmp 0x1a3603
movq %rax, %rbx
jmp 0x1a367c
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf9e00
jmp 0x1a35c2
movq %rax, %rbx
jmp 0x1a35db
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
jmp 0x1a35e3
jmp 0x1a3643
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf9e00
leaq 0xe8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a3658
jmp 0x1a3643
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xf9e00
jmp 0x1a364b
movq %rax, %rbx
jmp 0x1a363c
movq %rax, %rbx
jmp 0x1a361d
movq %rax, %rbx
jmp 0x1a3632
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xfdc90
movq %rsp, %r15
jmp 0x1a3672
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xf9e00
leaq 0x70(%rsp), %rdi
callq 0xf6d50
leaq 0x78(%rsp), %rdi
jmp 0x1a3653
movq %rax, %rbx
jmp 0x1a3658
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0xf9e00
movq %rsp, %r15
leaq 0x20(%rsp), %rdi
callq 0xf9e00
leaq 0x88(%rsp), %rdi
callq 0xf9e00
movq 0x40(%rsp), %rdi
callq 0xede80
movq %r15, %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_histogram.cpp
|
Omega_h::find_indset(Omega_h::Mesh*, int, Omega_h::Read<double>, Omega_h::Read<signed char>)
|
Read<I8> find_indset(
Mesh* mesh, Int ent_dim, Reals quality, Read<I8> candidates) {
if (ent_dim == mesh->dim()) return candidates;
mesh->owners_have_all_upward(ent_dim);
OMEGA_H_CHECK(mesh->owners_have_all_upward(ent_dim));
auto graph = mesh->ask_star(ent_dim);
return find_indset(mesh, ent_dim, graph, quality, candidates);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
cmpl %ebp, %eax
jne 0x1a43ca
movq %rbx, %rdi
movq %r15, %rsi
callq 0x100b80
jmp 0x1a4463
movq %r14, %rdi
movl %ebp, %esi
callq 0xec380
movq %r14, %rdi
movl %ebp, %esi
callq 0xec380
testb %al, %al
je 0x1a4475
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xf6cd0
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0xf8b70
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x28(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xfdd00
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfe010
leaq 0x48(%rsp), %rdi
callq 0xfe010
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd2c0c(%rip), %rdi # 0x277088
leaq 0xd5cc7(%rip), %rsi # 0x27a14a
leaq 0xd9d8a(%rip), %rdx # 0x27e214
pushq $0x1f
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
jmp 0x1a44a6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xfdc90
jmp 0x1a44b5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xfe010
jmp 0x1a44c4
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xfe010
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_indset.cpp
|
void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::indset::find<Omega_h::QualityCompare>(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::QualityCompare)::'lambda'(int)&>(int, Omega_h::QualityCompare&&)
|
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
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xd31a2(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xd29d6(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf4ff0
movq 0x68(%rsp), %rsi
leaq 0xd3143(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x48(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
callq 0xf00f0
xorl %edi, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xecae0
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1a4996
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x1a4969
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1a4978
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf00f0
jmp 0x1a4987
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x1a4996
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::indset::find<Omega_h::QualityCompare>(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::QualityCompare)::'lambda'(int)&>(Omega_h::QualityCompare, Omega_h::QualityCompare, Omega_h::Read<signed char> Omega_h::indset::find<Omega_h::QualityCompare>(Omega_h::Mesh*, int, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>, Omega_h::QualityCompare)::'lambda'(int)&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1a4b4e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x16d1bb(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xf9810
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x1a4b3e
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rsi
cmpb $0x0, (%rdx,%rax)
setne %dl
addb %dl, %dl
movb %dl, (%rsi,%rax)
incq %rax
jmp 0x1a4b1e
movq %rsp, %rdi
callq 0x101600
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
Omega_h::inertia::mark_bisection(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, Omega_h::Vector<3>&)
|
Read<I8> mark_bisection(
CommPtr comm, Reals coords, Reals masses, Real tolerance, Vector<3>& axis) {
OMEGA_H_CHECK(coords.size() == masses.size() * 3);
auto total_mass = repro_sum(comm, masses);
auto center = get_center(comm, coords, masses, total_mass);
axis = get_axis(comm, coords, masses, center);
return mark_bisection_internal(
comm, coords, masses, tolerance, axis, center, total_mass);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x578, %rsp # imm = 0x578
movq %r8, %r14
movsd %xmm0, 0x428(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdx), %rax
testb $0x1, %al
jne 0x1a5081
movq (%rax), %rax
jmp 0x1a5085
shrq $0x3, %rax
shrq $0x3, %rax
movq (%r15), %rcx
testb $0x1, %cl
jne 0x1a5096
movq (%rcx), %rcx
jmp 0x1a509a
shrq $0x3, %rcx
shrq $0x3, %rcx
leal (%rcx,%rcx,2), %ecx
cmpl %eax, %ecx
jne 0x1a71a4
leaq 0x4d0(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0x4c0(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x4d0(%rsp), %rdi
leaq 0x4c0(%rsp), %rsi
callq 0x101840
movsd %xmm0, 0x2d8(%rsp)
leaq 0x4c0(%rsp), %rdi
callq 0xfdc90
leaq 0x4d8(%rsp), %rdi
callq 0xf6d50
leaq 0x4b0(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0x4a0(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x490(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x518(%rsp), %rdi
leaq 0x4b0(%rsp), %rsi
leaq 0x4a0(%rsp), %rdx
leaq 0x490(%rsp), %rcx
movsd 0x2d8(%rsp), %xmm0
callq 0x1a73c0
leaq 0x490(%rsp), %rdi
callq 0xfdc90
leaq 0x4a0(%rsp), %rdi
callq 0xfdc90
leaq 0x4b8(%rsp), %rdi
callq 0xf6d50
leaq 0x480(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0x470(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x460(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x4f0(%rsp), %rdi
leaq 0x480(%rsp), %rsi
callq 0xf21a0
leaq 0x4e0(%rsp), %rdi
leaq 0x470(%rsp), %rsi
callq 0xf3e40
movq %r13, 0x2d0(%rsp)
leaq 0x2f0(%rsp), %rdi
leaq 0x460(%rsp), %rsi
callq 0xf3e40
movq 0x2f0(%rsp), %r13
testb $0x1, %r13b
jne 0x1a5211
movq (%r13), %r13
jmp 0x1a5215
shrq $0x3, %r13
leaq 0xd829b(%rip), %rsi # 0x27d4b7
leaq 0x70(%rsp), %rdi
leaq 0x130(%rsp), %rdx
callq 0xef870
shrq $0x3, %r13
imull $0x6, %r13d, %esi
leaq 0x300(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0xf6560
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x398(%rsp), %rdi
leaq 0x4e0(%rsp), %rsi
callq 0xf3e40
movq %r12, 0x410(%rsp)
movq %r15, 0x418(%rsp)
movq %r14, 0x420(%rsp)
movq 0x528(%rsp), %rax
leaq 0x3c0(%rsp), %rbp
movq %rax, -0x8(%rbp)
movups 0x518(%rsp), %xmm0
movups %xmm0, -0x18(%rbp)
leaq 0x300(%rsp), %rsi
movq %rbp, %rdi
callq 0xf3e40
leaq 0x3d0(%rsp), %r12
leaq 0x2f0(%rsp), %rsi
movq %r12, %rdi
callq 0xf3e40
leaq 0x310(%rsp), %rdi
leaq 0x398(%rsp), %rsi
callq 0xf3e40
movq %rbx, 0x2c8(%rsp)
leaq 0x3a8(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x338(%rsp), %r14
movq %rcx, -0x8(%r14)
movups (%rax), %xmm0
movups %xmm0, -0x18(%r14)
movq %r14, %rdi
movq %rbp, %rsi
callq 0xf3e40
leaq 0x348(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf3e40
testl %r13d, %r13d
jle 0x1a577d
movq 0x16c98e(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0xe0(%rsp), %rdi
leaq 0x310(%rsp), %rsi
callq 0xfbcb0
leaq 0x320(%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x108(%rsp), %r12
movq %rcx, -0x8(%r12)
movups (%rax), %xmm0
movups %xmm0, -0x18(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0xfbcb0
leaq 0x118(%rsp), %rdi
movq %rbx, %rsi
callq 0xfbcb0
leaq 0xf0(%rsp), %rax
movb $0x0, (%r15)
movq -0x8(%rax), %rcx
movq 0x20(%rax), %rdx
movq 0x30(%rax), %rsi
andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
xorl %edi, %edi
movaps 0xd51d0(%rip), %xmm0 # 0x27a580
pushq $0x1
popq %r8
cmpq %r13, %rdi
je 0x1a5770
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x1a53db
movsd (%rcx,%r9,8), %xmm1
movsd %xmm1, 0x560(%rsp,%r9,8)
incq %r9
jmp 0x1a53c0
movq 0x10(%rax), %r9
movq %r9, 0x80(%rsp)
movups (%rax), %xmm1
movaps %xmm1, 0x70(%rsp)
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x1a5418
movsd 0x560(%rsp,%r9,8), %xmm1
subsd 0x70(%rsp,%r9,8), %xmm1
movsd %xmm1, 0x130(%rsp,%r9,8)
incq %r9
jmp 0x1a53f2
movsd 0x130(%rsp), %xmm2
movaps %xmm2, %xmm3
movups 0x138(%rsp), %xmm4
movaps %xmm4, %xmm5
xorps %xmm0, %xmm5
movsd (%rsi,%rdi,8), %xmm1
andq $0x0, 0x130(%rsp)
movaps %xmm4, %xmm6
shufps $0x4e, %xmm5, %xmm6 # xmm6 = xmm6[2,3],xmm5[0,1]
movups %xmm6, 0x138(%rsp)
pshufd $0xee, %xmm5, %xmm6 # xmm6 = xmm5[2,3,2,3]
movq %xmm6, 0x148(%rsp)
andq $0x0, 0x150(%rsp)
xorps %xmm0, %xmm3
movsd %xmm2, 0x158(%rsp)
movaps %xmm4, %xmm6
movlhps %xmm3, %xmm6 # xmm6 = xmm6[0],xmm3[0]
movups %xmm6, 0x160(%rsp)
andq $0x0, 0x170(%rsp)
movaps %xmm4, %xmm6
unpckhpd %xmm4, %xmm6 # xmm6 = xmm6[1],xmm4[1]
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x1a566c
imulq $0x18, %r9, %r10
andq $0x0, 0x70(%rsp)
movsd %xmm6, 0x78(%rsp)
movupd %xmm5, 0x80(%rsp)
andq $0x0, 0x90(%rsp)
movq 0x140(%rsp,%r10), %r11
movq %r11, 0x540(%rsp)
movsd %xmm2, 0x98(%rsp)
movsd %xmm4, 0xa0(%rsp)
movsd %xmm3, 0xa8(%rsp)
andq $0x0, 0xb0(%rsp)
movups 0x130(%rsp,%r10), %xmm7
movaps %xmm7, 0x530(%rsp)
movq 0x80(%rsp), %r11
movq %r11, 0x1c0(%rsp)
movups 0x70(%rsp), %xmm7
movaps %xmm7, 0x1b0(%rsp)
movsd 0x530(%rsp), %xmm7
xorl %r11d, %r11d
cmpq $0x3, %r11
je 0x1a5551
movsd 0x1b0(%rsp,%r11,8), %xmm8
mulsd %xmm7, %xmm8
movsd %xmm8, 0x360(%rsp,%r11,8)
incq %r11
jmp 0x1a552d
movq %r8, %r11
cmpq $0x3, %r11
je 0x1a5641
imulq $0x18, %r11, %rbx
movq 0x80(%rsp,%rbx), %r14
movq %r14, 0x1c0(%rsp)
movups 0x70(%rsp,%rbx), %xmm7
movaps %xmm7, 0x1b0(%rsp)
movsd 0x530(%rsp,%r11,8), %xmm7
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x1a55af
movsd 0x1b0(%rsp,%rbx,8), %xmm8
mulsd %xmm7, %xmm8
movsd %xmm8, 0x548(%rsp,%rbx,8)
incq %rbx
jmp 0x1a558b
movq 0x558(%rsp), %rbx
movq %rbx, 0x1c0(%rsp)
movups 0x548(%rsp), %xmm7
movaps %xmm7, 0x1b0(%rsp)
movups 0x360(%rsp), %xmm7
movaps %xmm7, 0x380(%rsp)
movq 0x370(%rsp), %rbx
movq %rbx, 0x390(%rsp)
xorl %ebx, %ebx
cmpq $0x3, %rbx
je 0x1a5617
movsd 0x380(%rsp,%rbx,8), %xmm7
addsd 0x1b0(%rsp,%rbx,8), %xmm7
movsd %xmm7, 0x230(%rsp,%rbx,8)
incq %rbx
jmp 0x1a55f1
movupd 0x230(%rsp), %xmm7
movapd %xmm7, 0x360(%rsp)
movq 0x240(%rsp), %rbx
movq %rbx, 0x370(%rsp)
incq %r11
jmp 0x1a5554
movq 0x370(%rsp), %r11
movq %r11, 0x1f0(%rsp,%r10)
movapd 0x360(%rsp), %xmm7
movupd %xmm7, 0x1e0(%rsp,%r10)
incq %r9
jmp 0x1a5493
xorps %xmm0, %xmm1
xorl %r9d, %r9d
cmpq $0x3, %r9
je 0x1a56e6
imulq $0x18, %r9, %r10
movq 0x1f0(%rsp,%r10), %r11
movq %r11, 0x140(%rsp)
movups 0x1e0(%rsp,%r10), %xmm2
movaps %xmm2, 0x130(%rsp)
xorl %r11d, %r11d
cmpq $0x3, %r11
je 0x1a56c3
movsd 0x130(%rsp,%r11,8), %xmm2
mulsd %xmm1, %xmm2
movsd %xmm2, 0x1b0(%rsp,%r11,8)
incq %r11
jmp 0x1a56a0
movq 0x1c0(%rsp), %r11
movq %r11, 0x80(%rsp,%r10)
movups 0x1b0(%rsp), %xmm2
movups %xmm2, 0x70(%rsp,%r10)
incq %r9
jmp 0x1a5672
movsd 0x70(%rsp), %xmm1
movsd 0x88(%rsp), %xmm2
movsd 0x90(%rsp), %xmm3
movsd 0xb0(%rsp), %xmm4
movsd %xmm1, 0x130(%rsp)
movsd %xmm3, 0x138(%rsp)
movsd %xmm4, 0x140(%rsp)
movsd %xmm2, 0x148(%rsp)
movupd 0xa0(%rsp), %xmm1
shufpd $0x1, %xmm1, %xmm1 # xmm1 = xmm1[1,0]
movupd %xmm1, 0x150(%rsp)
xorl %r9d, %r9d
cmpq $0x6, %r9
je 0x1a5760
movsd 0x130(%rsp,%r9,8), %xmm1
movsd %xmm1, (%rdx,%r9,8)
incq %r9
jmp 0x1a5745
incq %rdi
addq $0x18, %rcx
addq $0x30, %rdx
jmp 0x1a53b4
leaq 0xe0(%rsp), %rdi
callq 0x1a823a
leaq 0x310(%rsp), %rdi
callq 0x1a823a
leaq 0x130(%rsp), %rdi
leaq 0x4f0(%rsp), %rsi
callq 0xf21a0
leaq 0xe0(%rsp), %rdi
leaq 0x300(%rsp), %rsi
callq 0xf3e40
leaq 0x1e0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf6440
movq 0x2d0(%rsp), %r13
leaq 0x130(%rsp), %rbx
leaq 0x1e0(%rsp), %rsi
pushq $0x6
popq %rdx
leaq 0x70(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0xeea90
pushq $0x1
popq %r12
leaq 0x1e0(%rsp), %rdi
callq 0xfdc90
leaq 0xe0(%rsp), %rdi
callq 0xfdc90
leaq 0x138(%rsp), %rdi
callq 0xf6d50
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x80(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x88(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0xd0(%rsp)
leaq 0x398(%rsp), %rdi
callq 0x1a823a
leaq 0x300(%rsp), %rdi
callq 0xfdc90
leaq 0x2f0(%rsp), %rdi
callq 0xfdc90
leaq 0x4e0(%rsp), %rdi
callq 0xfdc90
leaq 0x4f8(%rsp), %rdi
callq 0xf6d50
movsd 0x40(%rsp), %xmm8
movsd 0x50(%rsp), %xmm6
movapd 0xd0(%rsp), %xmm5
movsd 0x60(%rsp), %xmm4
movsd 0x30(%rsp), %xmm3
movsd %xmm6, 0x70(%rsp)
movsd %xmm8, 0x78(%rsp)
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0 # xmm0 = xmm0[1],xmm5[1]
movhpd %xmm5, 0x80(%rsp)
movsd %xmm8, 0x88(%rsp)
movsd %xmm4, 0x90(%rsp)
movupd %xmm5, 0x98(%rsp)
movlpd %xmm5, 0xa8(%rsp)
movsd %xmm3, 0xb0(%rsp)
xorpd %xmm7, %xmm7
xorl %eax, %eax
movapd 0xd319e(%rip), %xmm1 # 0x278ac0
cmpq $0x3, %rax
je 0x1a5950
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1a5947
movsd (%r14,%rcx,8), %xmm2
andpd %xmm1, %xmm2
maxsd %xmm7, %xmm2
incq %rcx
movapd %xmm2, %xmm7
jmp 0x1a592a
incq %rax
addq $0x18, %r14
jmp 0x1a5922
movsd 0xd89c8(%rip), %xmm1 # 0x27e320
ucomisd %xmm7, %xmm1
jae 0x1a5a1d
movsd %xmm6, 0x70(%rsp)
movsd %xmm8, 0x78(%rsp)
movsd %xmm0, 0x80(%rsp)
movsd %xmm8, 0x88(%rsp)
movsd %xmm4, 0x90(%rsp)
movupd %xmm5, 0x98(%rsp)
movsd %xmm5, 0xa8(%rsp)
movsd %xmm3, 0xb0(%rsp)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1a5a59
imulq $0x18, %rax, %rcx
movq 0x80(%rsp,%rcx), %rdx
movq %rdx, 0x1f0(%rsp)
movups 0x70(%rsp,%rcx), %xmm0
movaps %xmm0, 0x1e0(%rsp)
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x1a59f6
movsd 0x1e0(%rsp,%rdx,8), %xmm0
divsd %xmm7, %xmm0
movsd %xmm0, 0xe0(%rsp,%rdx,8)
incq %rdx
jmp 0x1a59d5
movq 0xf0(%rsp), %rdx
movq %rdx, 0x140(%rsp,%rcx)
movupd 0xe0(%rsp), %xmm0
movupd %xmm0, 0x130(%rsp,%rcx)
incq %rax
jmp 0x1a59a8
xorl %eax, %eax
movsd 0xd1621(%rip), %xmm0 # 0x277048
cmpq $0x3, %rax
je 0x1a5c88
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1a5a50
movapd %xmm0, %xmm1
cmpq %rcx, %rax
je 0x1a5a46
xorpd %xmm1, %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
jmp 0x1a5a33
incq %rax
addq $0x18, %rbx
jmp 0x1a5a27
movapd 0x130(%rsp), %xmm8
movapd 0x140(%rsp), %xmm9
movapd 0x150(%rsp), %xmm10
movapd 0x160(%rsp), %xmm11
movsd 0x170(%rsp), %xmm12
movapd %xmm8, %xmm13
addsd %xmm10, %xmm13
movapd %xmm8, 0x130(%rsp)
movapd %xmm9, 0x140(%rsp)
movapd %xmm10, 0x150(%rsp)
movapd %xmm11, 0x160(%rsp)
movsd %xmm12, 0x170(%rsp)
xorl %eax, %eax
pushq $0x1
popq %rcx
cmpq $0x3, %rax
je 0x1a5caa
imulq $0x18, %rax, %rdx
movq 0x140(%rsp,%rdx), %rsi
movq %rsi, 0x390(%rsp)
movups 0x130(%rsp,%rdx), %xmm0
movaps %xmm0, 0x380(%rsp)
movapd %xmm8, 0x70(%rsp)
movapd %xmm9, 0x80(%rsp)
movapd %xmm10, 0x90(%rsp)
movapd %xmm11, 0xa0(%rsp)
movsd %xmm12, 0xb0(%rsp)
movq 0x80(%rsp), %rsi
movq %rsi, 0xf0(%rsp)
movaps 0x70(%rsp), %xmm0
movaps %xmm0, 0xe0(%rsp)
movsd 0x380(%rsp), %xmm0
xorl %esi, %esi
cmpq $0x3, %rsi
je 0x1a5b72
movsd 0xe0(%rsp,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x230(%rsp,%rsi,8)
incq %rsi
jmp 0x1a5b51
movq %rcx, %rsi
cmpq $0x3, %rsi
je 0x1a5c5e
imulq $0x18, %rsi, %rdi
movq 0x80(%rsp,%rdi), %r8
movq %r8, 0xf0(%rsp)
movups 0x70(%rsp,%rdi), %xmm0
movaps %xmm0, 0xe0(%rsp)
movsd 0x380(%rsp,%rsi,8), %xmm0
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1a5bcc
movsd 0xe0(%rsp,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x1b0(%rsp,%rdi,8)
incq %rdi
jmp 0x1a5bab
movq 0x1c0(%rsp), %rdi
movq %rdi, 0xf0(%rsp)
movups 0x1b0(%rsp), %xmm0
movaps %xmm0, 0xe0(%rsp)
movups 0x230(%rsp), %xmm0
movaps %xmm0, 0x310(%rsp)
movq 0x240(%rsp), %rdi
movq %rdi, 0x320(%rsp)
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1a5c34
movsd 0x310(%rsp,%rdi,8), %xmm0
addsd 0xe0(%rsp,%rdi,8), %xmm0
movsd %xmm0, 0x398(%rsp,%rdi,8)
incq %rdi
jmp 0x1a5c0e
movupd 0x398(%rsp), %xmm0
movapd %xmm0, 0x230(%rsp)
movq 0x3a8(%rsp), %rdi
movq %rdi, 0x240(%rsp)
incq %rsi
jmp 0x1a5b75
movq 0x240(%rsp), %rsi
movq %rsi, 0x1f0(%rsp,%rdx)
movapd 0x230(%rsp), %xmm0
movupd %xmm0, 0x1e0(%rsp,%rdx)
incq %rax
jmp 0x1a5acc
xorl %eax, %eax
movq 0x2c8(%rsp), %rbx
cmpq $0x3, %rax
je 0x1a69e8
andq $0x0, 0x178(%rsp,%rax,8)
incq %rax
jmp 0x1a5c92
addsd %xmm12, %xmm13
movsd 0x1e0(%rsp), %xmm0
addsd 0x200(%rsp), %xmm0
addsd 0x220(%rsp), %xmm0
movapd %xmm13, %xmm14
mulsd %xmm13, %xmm14
movapd %xmm14, %xmm1
subsd %xmm0, %xmm1
movsd 0xd297b(%rip), %xmm0 # 0x278660
mulsd %xmm0, %xmm1
movapd %xmm8, %xmm4
mulsd %xmm10, %xmm4
movapd %xmm9, %xmm6
unpckhpd %xmm9, %xmm6 # xmm6 = xmm6[1],xmm9[1]
movapd %xmm11, %xmm3
unpckhpd %xmm11, %xmm3 # xmm3 = xmm3[1],xmm11[1]
movapd %xmm8, %xmm5
unpckhpd %xmm8, %xmm5 # xmm5 = xmm5[1],xmm8[1]
movapd %xmm5, %xmm2
mulsd %xmm6, %xmm5
mulsd %xmm3, %xmm6
mulsd %xmm9, %xmm6
mulsd %xmm12, %xmm4
addsd %xmm6, %xmm4
mulsd %xmm11, %xmm2
movapd %xmm10, %xmm6
unpckhpd %xmm10, %xmm6 # xmm6 = xmm6[1],xmm10[1]
mulsd %xmm6, %xmm2
addsd %xmm4, %xmm2
movapd %xmm10, %xmm4
mulsd %xmm11, %xmm4
mulsd %xmm9, %xmm4
subsd %xmm4, %xmm2
mulsd %xmm12, %xmm5
subsd %xmm5, %xmm2
mulsd %xmm8, %xmm3
mulsd %xmm6, %xmm3
subsd %xmm3, %xmm2
movsd 0xd12cd(%rip), %xmm4 # 0x277040
movapd %xmm1, %xmm5
mulsd %xmm4, %xmm5
subsd %xmm14, %xmm5
divsd %xmm4, %xmm5
mulsd 0xd566c(%rip), %xmm1 # 0x27b3f8
movsd 0xd566c(%rip), %xmm3 # 0x27b400
mulsd %xmm3, %xmm2
mulsd %xmm13, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm13, %xmm14
addsd %xmm14, %xmm14
addsd %xmm1, %xmm14
divsd %xmm3, %xmm14
divsd %xmm4, %xmm5
mulsd %xmm0, %xmm14
movapd %xmm5, %xmm1
mulsd %xmm5, %xmm1
mulsd %xmm5, %xmm1
movapd %xmm14, %xmm2
mulsd %xmm14, %xmm2
addsd %xmm1, %xmm2
divsd %xmm4, %xmm13
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd %xmm7, 0x1c8(%rsp)
movapd %xmm8, 0x2b0(%rsp)
movapd %xmm9, 0x2a0(%rsp)
movapd %xmm10, 0x290(%rsp)
movapd %xmm11, 0x280(%rsp)
movsd %xmm12, 0x198(%rsp)
movapd %xmm13, 0x50(%rsp)
jae 0x1a5e56
movapd %xmm5, 0x60(%rsp)
movapd 0xd4749(%rip), %xmm0 # 0x27a580
xorpd %xmm1, %xmm0
movsd 0xd55cd(%rip), %xmm2 # 0x27b410
ucomisd %xmm1, %xmm2
jb 0x1a5ef4
sqrtsd %xmm0, %xmm0
jmp 0x1a5f07
movapd %xmm2, 0x40(%rsp)
sqrtsd %xmm2, %xmm0
movsd %xmm0, 0xd0(%rsp)
movapd %xmm14, 0x30(%rsp)
jae 0x1a5e84
movapd 0x40(%rsp), %xmm0
callq 0xf42e0
movapd 0x30(%rsp), %xmm14
addsd %xmm14, %xmm0
callq 0xed2c0
movsd %xmm0, 0x60(%rsp)
xorpd %xmm1, %xmm1
movapd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
movsd 0xd0(%rsp), %xmm1
jae 0x1a5eb6
callq 0xf42e0
movapd %xmm0, %xmm1
movapd 0x30(%rsp), %xmm0
subsd %xmm1, %xmm0
callq 0xed2c0
movsd 0x60(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd 0x50(%rsp), %xmm0
movapd %xmm0, %xmm10
addsd %xmm1, %xmm10
mulsd 0xd5521(%rip), %xmm1 # 0x27b408
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0x1a5ff9
movapd %xmm14, 0x30(%rsp)
callq 0xf42e0
movapd 0x30(%rsp), %xmm14
divsd %xmm0, %xmm14
movsd 0xd2644(%rip), %xmm1 # 0x278558
maxsd %xmm14, %xmm1
movsd 0xd1127(%rip), %xmm0 # 0x277048
minsd %xmm1, %xmm0
callq 0xf63a0
movapd %xmm0, %xmm2
movapd 0x60(%rsp), %xmm0
movsd 0xd54d4(%rip), %xmm1 # 0x27b410
ucomisd %xmm0, %xmm1
xorpd 0xd4638(%rip), %xmm0 # 0x27a580
movsd %xmm2, 0x40(%rsp)
jb 0x1a5f56
sqrtsd %xmm0, %xmm0
jmp 0x1a5f61
callq 0xf42e0
movsd 0x40(%rsp), %xmm2
movsd 0xd10d7(%rip), %xmm1 # 0x277040
addsd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x100850
mulsd 0x30(%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
movapd %xmm0, 0xd0(%rsp)
movsd 0xd547b(%rip), %xmm0 # 0x27b418
addsd 0x40(%rsp), %xmm0
divsd 0xd1095(%rip), %xmm0 # 0x277040
callq 0x100850
mulsd 0x30(%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0xd5450(%rip), %xmm0 # 0x27b420
divsd 0xd1068(%rip), %xmm0 # 0x277040
callq 0x100850
movsd 0x60(%rsp), %xmm1
movapd 0xd0(%rsp), %xmm10
mulsd 0x30(%rsp), %xmm0
addsd 0x50(%rsp), %xmm0
movapd %xmm10, %xmm2
movapd %xmm1, %xmm9
subsd %xmm1, %xmm2
andpd 0xd2ab1(%rip), %xmm2 # 0x278ac0
movsd 0xd5411(%rip), %xmm1 # 0x27b428
ucomisd %xmm2, %xmm1
movsd 0x1c8(%rsp), %xmm3
movapd 0x2b0(%rsp), %xmm4
movapd 0x2a0(%rsp), %xmm5
movapd 0x290(%rsp), %xmm6
movapd 0x280(%rsp), %xmm7
movsd 0x198(%rsp), %xmm8
jbe 0x1a605a
movapd %xmm0, %xmm2
jmp 0x1a60a2
movapd %xmm10, %xmm2
subsd %xmm0, %xmm2
andpd 0xd2a55(%rip), %xmm2 # 0x278ac0
ucomisd %xmm2, %xmm1
jbe 0x1a607d
movapd %xmm9, %xmm2
movapd %xmm10, %xmm9
jmp 0x1a609d
movapd %xmm9, %xmm2
subsd %xmm0, %xmm2
andpd 0xd2a32(%rip), %xmm2 # 0x278ac0
ucomisd %xmm2, %xmm1
jbe 0x1a6c15
movapd %xmm10, %xmm2
movapd %xmm0, %xmm10
addsd %xmm10, %xmm9
mulsd 0xd25b0(%rip), %xmm9 # 0x278660
movapd %xmm2, %xmm0
subsd %xmm9, %xmm0
andpd 0xd29ff(%rip), %xmm0 # 0x278ac0
ucomisd %xmm0, %xmm1
jbe 0x1a6139
mulsd 0xd5360(%rip), %xmm9 # 0x27b430
mulsd 0xd4cd0(%rip), %xmm2 # 0x27ada8
addsd %xmm9, %xmm2
movsd %xmm2, 0x3a8(%rsp)
movsd %xmm2, 0x3a0(%rsp)
movsd %xmm2, 0x398(%rsp)
leaq 0x70(%rsp), %rax
xorl %ecx, %ecx
movsd 0xd0f41(%rip), %xmm0 # 0x277048
cmpq $0x3, %rcx
je 0x1a6192
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x1a6130
movapd %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x1a6126
xorpd %xmm1, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x1a6113
incq %rcx
addq $0x18, %rax
jmp 0x1a6107
movsd %xmm2, 0x310(%rsp)
movsd %xmm9, 0x318(%rsp)
movsd %xmm10, 0x320(%rsp)
leaq 0x70(%rsp), %rax
movapd %xmm4, (%rax)
movapd %xmm5, 0x10(%rax)
movapd %xmm6, 0x20(%rax)
movapd %xmm7, 0x30(%rax)
movsd %xmm8, 0x40(%rax)
xorl %ecx, %ecx
cmpq $0x48, %rcx
je 0x1a61aa
movsd (%rax), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, (%rax)
addq $0x20, %rax
addq $0x18, %rcx
jmp 0x1a6176
pushq $0x9
popq %rcx
leaq 0x1e0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
jmp 0x1a695e
pushq $0x9
popq %rcx
leaq 0x130(%rsp), %rax
leaq 0x70(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1a61f5
movq %rax, %rsi
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1a61e8
movsd (%rsi), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
incq %rdi
addq $0x18, %rsi
jmp 0x1a61d0
incq %rcx
addq $0x18, %rdx
addq $0x8, %rax
jmp 0x1a61c5
movsd 0x70(%rsp), %xmm3
movsd 0x88(%rsp), %xmm10
movupd 0x78(%rsp), %xmm4
movupd 0x90(%rsp), %xmm11
movapd %xmm4, %xmm6
shufpd $0x1, %xmm3, %xmm6 # xmm6 = xmm6[1],xmm3[0]
movapd 0xd435a(%rip), %xmm5 # 0x27a580
movapd %xmm11, %xmm0
mulpd %xmm6, %xmm0
xorpd %xmm5, %xmm6
movapd %xmm11, %xmm12
shufpd $0x1, %xmm10, %xmm12 # xmm12 = xmm12[1],xmm10[0]
movapd %xmm4, %xmm7
mulpd %xmm12, %xmm7
subpd %xmm0, %xmm7
xorpd %xmm4, %xmm5
movapd %xmm10, %xmm0
mulsd %xmm4, %xmm0
movapd %xmm3, %xmm8
mulsd %xmm11, %xmm8
subsd %xmm0, %xmm8
movapd %xmm7, 0x130(%rsp)
movsd %xmm8, 0x140(%rsp)
movapd %xmm7, 0xe0(%rsp)
movsd %xmm8, 0xf0(%rsp)
movapd %xmm7, %xmm0
mulsd %xmm7, %xmm0
pushq $0x1
popq %rax
cmpq $0x3, %rax
je 0x1a62b9
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a6298
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd %xmm9, 0x60(%rsp)
movsd %xmm2, 0x400(%rsp)
movapd %xmm3, 0x50(%rsp)
movapd %xmm4, 0x30(%rsp)
movapd %xmm5, 0x40(%rsp)
movapd %xmm6, 0xd0(%rsp)
movapd %xmm7, 0x270(%rsp)
movapd %xmm8, 0x2e0(%rsp)
jb 0x1a6307
sqrtsd %xmm0, %xmm5
jmp 0x1a634c
movapd %xmm10, 0x1a0(%rsp)
movapd %xmm11, 0x1d0(%rsp)
movapd %xmm12, 0x260(%rsp)
callq 0xf42e0
movapd 0x260(%rsp), %xmm12
movapd 0x1d0(%rsp), %xmm11
movapd 0x1a0(%rsp), %xmm10
movapd %xmm0, %xmm5
movsd 0xa0(%rsp), %xmm3
movupd 0xa8(%rsp), %xmm4
mulpd %xmm4, %xmm12
movapd %xmm4, %xmm6
shufpd $0x1, %xmm3, %xmm6 # xmm6 = xmm6[1],xmm3[0]
movapd %xmm11, %xmm9
mulpd %xmm6, %xmm9
subpd %xmm12, %xmm9
mulsd %xmm3, %xmm11
mulsd %xmm4, %xmm10
subsd %xmm11, %xmm10
movapd %xmm9, 0x130(%rsp)
movsd %xmm10, 0x140(%rsp)
movapd %xmm9, 0xe0(%rsp)
movsd %xmm10, 0xf0(%rsp)
movapd %xmm9, %xmm0
mulsd %xmm9, %xmm0
pushq $0x1
popq %rax
cmpq $0x3, %rax
je 0x1a63e0
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a63bf
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a63f1
sqrtsd %xmm0, %xmm11
jmp 0x1a646b
movapd %xmm10, 0x1a0(%rsp)
movapd %xmm9, 0x1d0(%rsp)
movapd %xmm3, 0x260(%rsp)
movapd %xmm4, 0x3f0(%rsp)
movsd %xmm5, 0x3e0(%rsp)
movapd %xmm6, 0x250(%rsp)
callq 0xf42e0
movapd 0x250(%rsp), %xmm6
movsd 0x3e0(%rsp), %xmm5
movapd 0x3f0(%rsp), %xmm4
movapd 0x260(%rsp), %xmm3
movapd 0x1d0(%rsp), %xmm9
movapd 0x1a0(%rsp), %xmm10
movapd %xmm0, %xmm11
movapd 0x50(%rsp), %xmm7
movapd 0x30(%rsp), %xmm8
movapd 0x40(%rsp), %xmm1
movapd 0xd0(%rsp), %xmm2
movapd 0x2e0(%rsp), %xmm0
ucomisd %xmm5, %xmm11
movapd %xmm5, %xmm12
cmpltsd %xmm11, %xmm12
andpd %xmm12, %xmm10
andnpd %xmm0, %xmm12
orpd %xmm10, %xmm12
ja 0x1a64bb
movapd 0x270(%rsp), %xmm9
maxsd %xmm5, %xmm11
movapd %xmm4, %xmm0
mulpd %xmm2, %xmm0
mulpd %xmm6, %xmm8
addpd %xmm0, %xmm8
mulsd %xmm1, %xmm3
mulsd %xmm4, %xmm7
addsd %xmm3, %xmm7
movapd %xmm8, 0x130(%rsp)
movsd %xmm7, 0x140(%rsp)
movapd %xmm8, 0xe0(%rsp)
movsd %xmm7, 0xf0(%rsp)
movapd %xmm8, %xmm0
mulsd %xmm8, %xmm0
pushq $0x1
popq %rax
cmpq $0x3, %rax
je 0x1a6532
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a6511
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a6542
sqrtsd %xmm0, %xmm0
jmp 0x1a6597
movapd %xmm7, 0x50(%rsp)
movapd %xmm8, 0x30(%rsp)
movapd %xmm9, 0x1d0(%rsp)
movapd %xmm11, 0x40(%rsp)
movapd %xmm12, 0xd0(%rsp)
callq 0xf42e0
movapd 0xd0(%rsp), %xmm12
movapd 0x40(%rsp), %xmm11
movapd 0x1d0(%rsp), %xmm9
movapd 0x30(%rsp), %xmm8
movapd 0x50(%rsp), %xmm7
movapd 0x2b0(%rsp), %xmm2
movapd 0x2a0(%rsp), %xmm3
movapd 0x290(%rsp), %xmm4
movapd 0x280(%rsp), %xmm5
movsd 0x198(%rsp), %xmm6
ucomisd %xmm11, %xmm0
movapd %xmm0, %xmm1
maxsd %xmm11, %xmm1
ja 0x1a65d9
movapd %xmm9, %xmm8
ucomisd 0xd7d3f(%rip), %xmm1 # 0x27e320
jbe 0x1a71c5
cmpltsd %xmm0, %xmm11
andpd %xmm11, %xmm7
andnpd %xmm12, %xmm11
orpd %xmm7, %xmm11
movapd %xmm8, 0x130(%rsp)
movsd %xmm11, 0x140(%rsp)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1a6633
movsd 0x130(%rsp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xe0(%rsp,%rax,8)
incq %rax
jmp 0x1a6612
movsd 0xf0(%rsp), %xmm0
movaps 0xe0(%rsp), %xmm1
movaps %xmm1, 0x1e0(%rsp)
movsd %xmm0, 0x1f0(%rsp)
movsd 0x400(%rsp), %xmm0
movsd %xmm0, 0x398(%rsp)
leaq 0x130(%rsp), %rax
movapd %xmm2, (%rax)
movapd %xmm3, 0x10(%rax)
movapd %xmm4, 0x20(%rax)
movapd %xmm5, 0x30(%rax)
movsd %xmm6, 0x40(%rax)
xorl %ecx, %ecx
movsd 0x60(%rsp), %xmm1
cmpq $0x48, %rcx
je 0x1a66ab
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
addq $0x20, %rax
addq $0x18, %rcx
jmp 0x1a668f
pushq $0x9
popq %rcx
leaq 0x70(%rsp), %rax
leaq 0x130(%rsp), %rdx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x1a66f6
movq %rax, %rsi
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1a66e9
movsd (%rsi), %xmm0
movsd %xmm0, (%rdx,%rdi,8)
incq %rdi
addq $0x18, %rsi
jmp 0x1a66d1
incq %rcx
addq $0x18, %rdx
addq $0x8, %rax
jmp 0x1a66c6
movq 0x140(%rsp), %rax
movq %rax, 0x80(%rsp)
movups 0x130(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0xe0(%rsp)
movq %rax, 0xf0(%rsp)
movsd 0xe0(%rsp), %xmm0
mulsd 0x70(%rsp), %xmm0
pushq $0x1
popq %rax
cmpq $0x3, %rax
je 0x1a6753
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x70(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a6735
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
jb 0x1a6763
sqrtsd %xmm0, %xmm2
jmp 0x1a6770
callq 0xf42e0
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm2
xorl %ebx, %ebx
pushq $0x1
popq %r14
movq %r14, %r15
cmpq $0x3, %r15
je 0x1a682d
imulq $0x18, %r15, %rax
movq 0x140(%rsp,%rax), %rcx
movq %rcx, 0x80(%rsp)
movups 0x130(%rsp,%rax), %xmm0
movaps %xmm0, 0x70(%rsp)
movups 0x130(%rsp,%rax), %xmm0
movaps %xmm0, 0xe0(%rsp)
movq 0x140(%rsp,%rax), %rax
movq %rax, 0xf0(%rsp)
movsd 0xe0(%rsp), %xmm0
mulsd 0x70(%rsp), %xmm0
movq %r14, %rax
cmpq $0x3, %rax
je 0x1a67f4
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x70(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a67d6
ucomisd %xmm3, %xmm0
jb 0x1a6800
sqrtsd %xmm0, %xmm0
jmp 0x1a6815
movsd %xmm2, 0x50(%rsp)
callq 0xf42e0
xorpd %xmm3, %xmm3
movsd 0x50(%rsp), %xmm2
ucomisd %xmm2, %xmm0
cmoval %r15d, %ebx
maxsd %xmm2, %xmm0
incq %r15
movapd %xmm0, %xmm2
jmp 0x1a6779
ucomisd 0xd7aeb(%rip), %xmm2 # 0x27e320
jbe 0x1a71d3
movslq %ebx, %rax
imulq $0x18, %rax, %rax
movq 0x140(%rsp,%rax), %rcx
movq %rcx, 0x80(%rsp)
movupd 0x130(%rsp,%rax), %xmm0
movapd %xmm0, 0x70(%rsp)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1a6881
movsd 0x70(%rsp,%rax,8), %xmm0
divsd %xmm2, %xmm0
movsd %xmm0, 0xe0(%rsp,%rax,8)
incq %rax
jmp 0x1a6863
movsd 0xe0(%rsp), %xmm3
movsd 0xe8(%rsp), %xmm0
movsd 0xf0(%rsp), %xmm4
movapd 0xd3cdc(%rip), %xmm2 # 0x27a580
movapd %xmm4, %xmm1
andpd %xmm2, %xmm1
orpd 0xd7a4c(%rip), %xmm1 # 0x27e300
addsd %xmm1, %xmm4
movsd 0xd1c98(%rip), %xmm5 # 0x278558
divsd %xmm4, %xmm5
movapd %xmm3, %xmm4
mulsd %xmm1, %xmm4
mulsd %xmm3, %xmm4
movapd %xmm1, %xmm6
movapd %xmm0, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm5, %xmm7
addsd %xmm1, %xmm7
unpcklpd %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0]
mulsd %xmm0, %xmm3
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm4
addsd 0xd074c(%rip), %xmm4 # 0x277048
xorpd %xmm2, %xmm6
xorpd %xmm2, %xmm0
movsd %xmm4, 0x1f8(%rsp)
movapd %xmm3, %xmm2
unpcklpd %xmm6, %xmm2 # xmm2 = xmm2[0],xmm6[0]
mulpd %xmm1, %xmm2
movapd %xmm2, 0x200(%rsp)
movsd %xmm3, 0x210(%rsp)
movsd %xmm7, 0x218(%rsp)
movlpd %xmm0, 0x220(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x3a8(%rsp)
movsd %xmm0, 0x3a0(%rsp)
movsd 0x1c8(%rsp), %xmm3
pushq $0x9
popq %rax
leaq 0x70(%rsp), %rdx
leaq 0x1e0(%rsp), %r8
movq %rax, %rcx
movq %rdx, %rdi
movq %r8, %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x3a8(%rsp), %rcx
movq %rcx, 0x58(%rdx)
movups 0x398(%rsp), %xmm0
movups %xmm0, 0x48(%rdx)
leaq 0x130(%rsp), %rdi
movq %rax, %rcx
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x58(%rdx), %rax
movq %rax, 0x10(%r8)
movupd 0x48(%rdx), %xmm0
movapd %xmm0, (%r8)
xorl %eax, %eax
movq 0x2c8(%rsp), %rbx
movq 0x2d0(%rsp), %r13
cmpq $0x3, %rax
je 0x1a69e8
movsd 0x1e0(%rsp,%rax,8), %xmm0
mulsd %xmm3, %xmm0
movsd %xmm0, 0x178(%rsp,%rax,8)
incq %rax
jmp 0x1a69c7
leaq 0x130(%rsp), %rsi
movq 0x58(%rsi), %rax
movq %rax, 0x320(%rsp)
movupd 0x48(%rsi), %xmm0
movapd %xmm0, 0x310(%rsp)
pushq $0x9
popq %rcx
leaq 0x70(%rsp), %rdi
rep movsq (%rsi), %es:(%rdi)
xorl %eax, %eax
movslq %eax, %rcx
cmpq $0x3, %r12
je 0x1a6a41
movsd 0x310(%rsp,%rcx,8), %xmm0
ucomisd 0x310(%rsp,%r12,8), %xmm0
movl %r12d, %ecx
ja 0x1a6a3a
movl %eax, %ecx
incq %r12
movl %ecx, %eax
jmp 0x1a6a17
imulq $0x18, %rcx, %rax
addq %rsp, %rax
addq $0x70, %rax
movq 0x10(%rax), %rcx
movq %rcx, 0xf0(%rsp)
movupd (%rax), %xmm0
movapd %xmm0, 0xe0(%rsp)
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movq 0x420(%rsp), %r14
movq 0x418(%rsp), %r15
movq 0x410(%rsp), %r12
cmpq $0x3, %rcx
je 0x1a6aa7
movsd 0xe0(%rsp,%rcx,8), %xmm1
xorl %esi, %esi
ucomisd %xmm0, %xmm1
setae %sil
shll %cl, %esi
orl %esi, %edx
incq %rcx
jmp 0x1a6a85
movl %edx, %ecx
notl %ecx
andl $0x7, %ecx
cmpl %edx, %ecx
jbe 0x1a6af4
movq 0x10(%rax), %rcx
movq %rcx, 0x1f0(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x1e0(%rsp)
xorl %eax, %eax
movapd 0xd3aad(%rip), %xmm0 # 0x27a580
cmpq $0x3, %rax
je 0x1a6b0d
movsd 0x1e0(%rsp,%rax,8), %xmm1
xorpd %xmm0, %xmm1
movlpd %xmm1, 0x500(%rsp,%rax,8)
incq %rax
jmp 0x1a6ad3
movq 0x10(%rax), %rcx
movq %rcx, 0x510(%rsp)
movupd (%rax), %xmm0
movapd %xmm0, 0x500(%rsp)
movq 0x510(%rsp), %rax
movq %rax, 0x10(%r14)
movaps 0x500(%rsp), %xmm0
movups %xmm0, (%r14)
leaq 0x460(%rsp), %rdi
callq 0xfdc90
leaq 0x470(%rsp), %rdi
callq 0xfdc90
leaq 0x488(%rsp), %rdi
callq 0xf6d50
leaq 0x450(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0x440(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x430(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
movq 0x528(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x518(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
leaq 0x450(%rsp), %rsi
leaq 0x440(%rsp), %rdx
leaq 0x430(%rsp), %rcx
movq %rbx, %rdi
movsd 0x428(%rsp), %xmm0
movsd 0x2d8(%rsp), %xmm1
callq 0x1a771f
leaq 0x430(%rsp), %rdi
callq 0xfdc90
leaq 0x440(%rsp), %rdi
callq 0xfdc90
leaq 0x458(%rsp), %rdi
callq 0xf6d50
movq %rbx, %rax
addq $0x578, %rsp # imm = 0x578
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd %xmm10, 0x310(%rsp)
movsd %xmm9, 0x318(%rsp)
movsd %xmm0, 0x320(%rsp)
xorl %r13d, %r13d
leaq 0x70(%rsp), %rbp
pushq $0x9
popq %rbx
leaq 0x130(%rsp), %r14
pushq $0x1
popq %r15
xorpd %xmm2, %xmm2
leaq 0xd77b9(%rip), %rax # 0x27e40d
movq %rax, 0x250(%rsp)
cmpq $0x3, %r13
je 0x1a695e
movsd 0x310(%rsp,%r13,8), %xmm3
movapd %xmm4, 0x70(%rsp)
movapd %xmm5, 0x80(%rsp)
movapd %xmm6, 0x90(%rsp)
movapd %xmm7, 0xa0(%rsp)
movsd %xmm8, 0xb0(%rsp)
xorl %eax, %eax
movq %rbp, %rcx
cmpq $0x48, %rax
je 0x1a6cbc
movsd (%rcx), %xmm0
subsd %xmm3, %xmm0
movsd %xmm0, (%rcx)
addq $0x20, %rcx
addq $0x18, %rax
jmp 0x1a6ca0
movq %rbx, %rcx
movq %r14, %rdi
movq %rbp, %rsi
rep movsq (%rsi), %es:(%rdi)
movq %r14, %rax
movq %rbp, %rcx
xorl %edx, %edx
cmpq $0x3, %rdx
je 0x1a6d00
movq %rax, %rsi
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x1a6cf3
movsd (%rsi), %xmm0
movsd %xmm0, (%rcx,%rdi,8)
incq %rdi
addq $0x18, %rsi
jmp 0x1a6cdb
incq %rdx
addq $0x18, %rcx
addq $0x8, %rax
jmp 0x1a6cd0
movsd 0x70(%rsp), %xmm4
movsd 0x88(%rsp), %xmm7
movupd 0x78(%rsp), %xmm5
movupd 0x90(%rsp), %xmm12
movapd %xmm5, %xmm6
shufpd $0x1, %xmm4, %xmm6 # xmm6 = xmm6[1],xmm4[0]
movapd %xmm12, %xmm0
mulpd %xmm6, %xmm0
movapd 0xd3847(%rip), %xmm1 # 0x27a580
xorpd %xmm1, %xmm6
movapd %xmm12, %xmm13
shufpd $0x1, %xmm7, %xmm13 # xmm13 = xmm13[1],xmm7[0]
movapd %xmm5, %xmm9
mulpd %xmm13, %xmm9
subpd %xmm0, %xmm9
movapd %xmm5, %xmm8
xorpd %xmm1, %xmm8
movapd %xmm7, %xmm0
mulsd %xmm5, %xmm0
movapd %xmm4, %xmm10
mulsd %xmm12, %xmm10
subsd %xmm0, %xmm10
movhpd %xmm9, 0x138(%rsp)
movsd %xmm10, 0x140(%rsp)
movhpd %xmm9, 0xe8(%rsp)
movsd %xmm10, 0xf0(%rsp)
movapd %xmm9, %xmm0
mulsd %xmm9, %xmm0
movq %r15, %rax
cmpq $0x3, %rax
je 0x1a6dce
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a6dad
ucomisd %xmm2, %xmm0
movsd %xmm3, 0x2e0(%rsp)
movapd %xmm4, 0x50(%rsp)
movapd %xmm5, 0x60(%rsp)
movapd %xmm6, 0x30(%rsp)
movapd %xmm8, 0xd0(%rsp)
movapd %xmm9, 0x400(%rsp)
movapd %xmm10, 0x1d0(%rsp)
jb 0x1a6e13
sqrtsd %xmm0, %xmm6
jmp 0x1a6e54
movapd %xmm7, 0x40(%rsp)
movapd %xmm12, 0x1a0(%rsp)
movapd %xmm13, 0x270(%rsp)
callq 0xf42e0
movapd 0x270(%rsp), %xmm13
movapd 0x1a0(%rsp), %xmm12
movapd 0x40(%rsp), %xmm7
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm6
movsd 0xa0(%rsp), %xmm4
movupd 0xa8(%rsp), %xmm5
mulpd %xmm5, %xmm13
movapd %xmm5, %xmm8
shufpd $0x1, %xmm4, %xmm8 # xmm8 = xmm8[1],xmm4[0]
movapd %xmm12, %xmm11
mulpd %xmm8, %xmm11
subpd %xmm13, %xmm11
mulsd %xmm4, %xmm12
mulsd %xmm5, %xmm7
subsd %xmm12, %xmm7
movhpd %xmm11, 0x138(%rsp)
movsd %xmm7, 0x140(%rsp)
movhpd %xmm11, 0xe8(%rsp)
movsd %xmm7, 0xf0(%rsp)
movapd %xmm11, %xmm0
mulsd %xmm11, %xmm0
movq %r15, %rax
cmpq $0x3, %rax
je 0x1a6ee7
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a6ec6
ucomisd %xmm2, %xmm0
jb 0x1a6ef4
sqrtsd %xmm0, %xmm12
jmp 0x1a6f6c
movapd %xmm7, 0x40(%rsp)
movapd %xmm11, 0x1a0(%rsp)
movapd %xmm4, 0x270(%rsp)
movapd %xmm5, 0x260(%rsp)
movsd %xmm6, 0x3f0(%rsp)
movapd %xmm8, 0x3e0(%rsp)
callq 0xf42e0
movapd 0x3e0(%rsp), %xmm8
movsd 0x3f0(%rsp), %xmm6
movapd 0x260(%rsp), %xmm5
movapd 0x270(%rsp), %xmm4
movapd 0x1a0(%rsp), %xmm11
movapd 0x40(%rsp), %xmm7
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm12
movapd 0x50(%rsp), %xmm9
movapd 0x60(%rsp), %xmm10
movapd 0x30(%rsp), %xmm1
movapd 0xd0(%rsp), %xmm3
movapd 0x1d0(%rsp), %xmm0
ucomisd %xmm6, %xmm12
ja 0x1a6fa3
movapd 0x400(%rsp), %xmm11
movapd %xmm6, %xmm13
cmpltsd %xmm12, %xmm13
andpd %xmm13, %xmm7
andnpd %xmm0, %xmm13
orpd %xmm7, %xmm13
maxsd %xmm6, %xmm12
movapd %xmm5, %xmm0
mulpd %xmm1, %xmm0
mulpd %xmm8, %xmm10
addpd %xmm0, %xmm10
mulsd %xmm3, %xmm4
mulsd %xmm5, %xmm9
addsd %xmm4, %xmm9
movhpd %xmm10, 0x138(%rsp)
movsd %xmm9, 0x140(%rsp)
movhpd %xmm10, 0xe8(%rsp)
movsd %xmm9, 0xf0(%rsp)
movapd %xmm10, %xmm0
mulsd %xmm10, %xmm0
movq %r15, %rax
cmpq $0x3, %rax
je 0x1a7038
movsd 0xe0(%rsp,%rax,8), %xmm1
mulsd 0x130(%rsp,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1a7017
ucomisd %xmm2, %xmm0
jb 0x1a7044
sqrtsd %xmm0, %xmm0
jmp 0x1a7099
movapd %xmm9, 0x50(%rsp)
movapd %xmm10, 0x60(%rsp)
movapd %xmm11, 0x1a0(%rsp)
movapd %xmm12, 0x30(%rsp)
movapd %xmm13, 0x40(%rsp)
callq 0xf42e0
movapd 0x40(%rsp), %xmm13
movapd 0x30(%rsp), %xmm12
movapd 0x1a0(%rsp), %xmm11
movapd 0x60(%rsp), %xmm10
movapd 0x50(%rsp), %xmm9
xorpd %xmm2, %xmm2
movsd 0x1c8(%rsp), %xmm3
movapd 0x2b0(%rsp), %xmm4
movapd 0x2a0(%rsp), %xmm5
movapd 0x290(%rsp), %xmm6
movapd 0x280(%rsp), %xmm7
movsd 0x198(%rsp), %xmm8
ucomisd %xmm12, %xmm0
ja 0x1a70dc
movapd %xmm11, %xmm10
movapd %xmm0, %xmm1
maxsd %xmm12, %xmm1
ucomisd 0xd7233(%rip), %xmm1 # 0x27e320
jbe 0x1a7182
cmpltsd %xmm0, %xmm12
andpd %xmm12, %xmm9
andnpd %xmm13, %xmm12
orpd %xmm9, %xmm12
movapd %xmm10, 0x130(%rsp)
movsd %xmm12, 0x140(%rsp)
xorl %eax, %eax
cmpq $0x3, %rax
je 0x1a713f
movsd 0x130(%rsp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xe0(%rsp,%rax,8)
incq %rax
jmp 0x1a711e
movsd 0xf0(%rsp), %xmm0
imulq $0x18, %r13, %rax
movapd 0xe0(%rsp), %xmm1
movupd %xmm1, 0x1e0(%rsp,%rax)
movsd %xmm0, 0x1f0(%rsp,%rax)
movsd 0x2e0(%rsp), %xmm0
movsd %xmm0, 0x398(%rsp,%r13,8)
incq %r13
jmp 0x1a6c5c
movl $0xbf, %ecx
leaq 0xcfefa(%rip), %rdi # 0x277088
leaq 0xd7218(%rip), %rdx # 0x27e3ad
movq 0x250(%rsp), %rsi
xorl %eax, %eax
callq 0xf6ee0
leaq 0xcfedd(%rip), %rdi # 0x277088
leaq 0xd7176(%rip), %rsi # 0x27e328
leaq 0xd7192(%rip), %rdx # 0x27e34b
movl $0x91, %ecx
xorl %eax, %eax
callq 0xf6ee0
movl $0xbf, %ecx
leaq 0xd723c(%rip), %rax # 0x27e40d
jmp 0x1a71df
movl $0xd3, %ecx
leaq 0xd723f(%rip), %rax # 0x27e41e
movq %rax, 0x250(%rsp)
jmp 0x1a7187
movq %rax, %rbx
movq %r12, %rdi
callq 0xfdc90
jmp 0x1a71f9
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a720b
movq %rax, %rbx
leaq 0x310(%rsp), %rdi
callq 0x1a823a
jmp 0x1a72a9
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7232
movq %rax, %rbx
leaq 0x440(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7244
movq %rax, %rbx
leaq 0x458(%rsp), %rdi
jmp 0x1a7330
movq %rax, %rbx
leaq 0x1e0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7266
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7278
movq %rax, %rbx
leaq 0x138(%rsp), %rdi
callq 0xf6d50
jmp 0x1a72a9
movq %rax, %rbx
movq %r14, %rdi
callq 0xfdc90
jmp 0x1a7297
movq %rax, %rbx
leaq 0x310(%rsp), %rdi
callq 0xfdc90
jmp 0x1a72a9
movq %rax, %rbx
leaq 0x398(%rsp), %rdi
callq 0x1a823a
jmp 0x1a72da
movq %rax, %rbx
movq %rbp, %rdi
callq 0xfdc90
jmp 0x1a72c8
movq %rax, %rbx
leaq 0x398(%rsp), %rdi
callq 0xfdc90
jmp 0x1a72da
movq %rax, %rbx
leaq 0x300(%rsp), %rdi
callq 0xfdc90
leaq 0x2f0(%rsp), %rdi
callq 0xfdc90
leaq 0x4e0(%rsp), %rdi
callq 0xfdc90
leaq 0x4f8(%rsp), %rdi
callq 0xf6d50
leaq 0x460(%rsp), %rdi
callq 0xfdc90
leaq 0x470(%rsp), %rdi
callq 0xfdc90
leaq 0x488(%rsp), %rdi
callq 0xf6d50
movq %rbx, %rdi
callq 0xff4a0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x1a72e7
movq %rax, %rbx
jmp 0x1a72e7
movq %rax, %rbx
jmp 0x1a72f4
movq %rax, %rbx
jmp 0x1a7301
movq %rax, %rbx
jmp 0x1a731b
movq %rax, %rbx
jmp 0x1a7328
movq %rax, %rbx
leaq 0x490(%rsp), %rdi
callq 0xfdc90
jmp 0x1a737a
movq %rax, %rbx
leaq 0x4a0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a738c
movq %rax, %rbx
leaq 0x4b8(%rsp), %rdi
jmp 0x1a7330
movq %rax, %rbx
leaq 0x4c0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a73ab
movq %rax, %rbx
leaq 0x4d8(%rsp), %rdi
jmp 0x1a7330
movq %rax, %rbx
jmp 0x1a730e
|
/gahansen[P]omega_h/src/Omega_h_inertia.cpp
|
Omega_h::inertia::(anonymous namespace)::mark_bisection_internal(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, Omega_h::Vector<3>, Omega_h::Vector<3>, double)
|
Read<I8> mark_bisection_internal(CommPtr comm, Reals coords, Reals masses,
Real tolerance, Vector<3> axis, Vector<3> center, Real total_mass) {
auto dists = get_distances(coords, center, axis);
Read<I8> marked;
if (mark_axis_bisection(comm, dists, masses, total_mass, tolerance, marked)) {
return marked;
}
// if we couldn't find a decent cutting plane, this may be a highly
// structured mesh with many points coincident on the cutting plane.
// perturb the axis vector to escape this scenario
for (Int i = 0; i < 3 * 2; ++i) {
auto axis2 = axis;
axis2[i / 2] += (i % 2) ? 1e-3 : -1e-3;
dists = get_distances(coords, center, axis2);
if (mark_axis_bisection(
comm, dists, masses, total_mass, tolerance, marked)) {
return marked;
}
}
// even perturbation of the axis could not find a good
// cutting plane. warn the user of this failure, but continue
// with the axis that we have, because the cutting plane
// is still the best we could find.
// (to date I have not seen this happen, even with > 1 billion elements)
std::cerr << "Omega_h WARNING: no good inertial bisection\n";
return marked;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movsd %xmm1, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rcx, 0x58(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x108(%rsp), %r14
movq %r14, %rdi
movq %rdx, 0x80(%rsp)
movq %rdx, %rsi
callq 0xf3e40
movq 0x170(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x160(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x188(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x178(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0xc8(%rsp), %rdi
movq %r14, %rsi
callq 0x1a8259
leaq 0x108(%rsp), %rdi
callq 0xfdc90
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0xb8(%rsp), %rdi
movq %r15, %rsi
callq 0xf21a0
leaq 0xa8(%rsp), %rdi
leaq 0xc8(%rsp), %r14
movq %r14, %rsi
movq %rbx, 0x38(%rsp)
movq %r14, 0x40(%rsp)
callq 0xf3e40
leaq 0x98(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf3e40
movq %r15, 0x78(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x98(%rsp), %rdx
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movq %rbx, %rcx
callq 0x1a856e
movl %eax, %ebx
leaq 0x98(%rsp), %rdi
callq 0xfdc90
leaq 0xa8(%rsp), %rdi
callq 0xfdc90
leaq 0xc0(%rsp), %rdi
callq 0xf6d50
testb %bl, %bl
jne 0x1a79c1
xorl %r15d, %r15d
leaq 0xf8(%rsp), %r14
leaq 0x118(%rsp), %rbp
leaq 0xe8(%rsp), %r12
leaq 0xd8(%rsp), %r13
cmpl $0x6, %r15d
je 0x1a79ae
leaq 0x160(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x70(%rsp)
movups (%rcx), %xmm0
movaps %xmm0, 0x60(%rsp)
xorl %eax, %eax
testb $0x1, %r15b
sete %al
leaq 0xd6a5c(%rip), %rcx # 0x27e310
movsd (%rcx,%rax,8), %xmm0
movl %r15d, %eax
shrl %eax
addsd 0x60(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x60(%rsp,%rax,8)
movq %r14, %rdi
movq 0x80(%rsp), %rsi
callq 0xf3e40
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
leaq 0x178(%rsp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x1a8259
leaq 0xc8(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xef4f0
movq %rbp, %rdi
callq 0xfdc90
movq %r14, %rdi
callq 0xfdc90
leaq 0x88(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf21a0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf3e40
movq %r13, %rdi
movq 0x58(%rsp), %rsi
callq 0xf3e40
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movsd 0x50(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
movq 0x38(%rsp), %rcx
callq 0x1a856e
movl %eax, %ebx
movq %r13, %rdi
callq 0xfdc90
movq %r12, %rdi
callq 0xfdc90
leaq 0x90(%rsp), %rdi
callq 0xf6d50
incl %r15d
testb %bl, %bl
je 0x1a7881
jmp 0x1a79c1
movq 0x16a62b(%rip), %rdi # 0x311fe0
leaq 0xd6a76(%rip), %rsi # 0x27e432
callq 0xf68a0
leaq 0xc8(%rsp), %rdi
callq 0xfdc90
movq 0x38(%rsp), %rax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a7a6d
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xfdc90
jmp 0x1a79ff
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7a11
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x1a7a66
movq %r14, 0x40(%rsp)
movq %rax, %rbx
jmp 0x1a7a7a
movq %rax, %rbx
jmp 0x1a7a5e
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7a51
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a7a70
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xfdc90
leaq 0x90(%rsp), %rdi
callq 0xf6d50
jmp 0x1a7a70
movq %rax, %rbx
movq 0x38(%rsp), %rdi
callq 0xf9e00
movq 0x40(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_inertia.cpp
|
Omega_h::inertia::recursively_bisect(std::shared_ptr<Omega_h::Comm>, double, Omega_h::Read<double>*, Omega_h::Read<double>*, Omega_h::Remotes*, Omega_h::inertia::Rib*)
|
void recursively_bisect(CommPtr comm, Real tolerance, Reals* p_coords,
Reals* p_masses, Remotes* p_owners, Rib* p_hints) {
auto& coords = *p_coords;
auto& masses = *p_masses;
auto& owners = *p_owners;
auto& hints = *p_hints;
if (comm->size() == 1) {
return;
}
Vector<3> axis;
Read<I8> marks;
if (hints.axes.empty()) {
marks = inertia::mark_bisection(comm, coords, masses, tolerance, axis);
} else {
axis = hints.axes.front();
hints.axes.erase(hints.axes.begin());
marks = inertia::mark_bisection_given_axis(
comm, coords, masses, tolerance, axis);
}
auto dist = bi_partition(comm, marks);
coords = dist.exch(coords, 3);
masses = dist.exch(masses, 1);
owners = dist.exch(owners, 1);
auto halfsize = divide_no_remainder(comm->size(), 2);
comm = comm->split(comm->rank() / halfsize, comm->rank() % halfsize);
recursively_bisect(comm, tolerance, p_coords, p_masses, p_owners, p_hints);
hints.axes.insert(hints.axes.begin(), axis);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %rbp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %r13
movq (%rdi), %rdi
callq 0xfa970
cmpl $0x1, %eax
je 0x1a80d7
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%r15), %rsi
cmpq 0x8(%r15), %rsi
je 0x1a7e0b
movq 0x10(%rsi), %rax
movq %rax, 0x60(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
movq %r15, %rdi
callq 0x100b30
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0xc8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf3e40
leaq 0xb8(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x148(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
leaq 0xb8(%rsp), %rcx
movsd 0x18(%rsp), %xmm0
callq 0xf3ea0
leaq 0x20(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xef740
leaq 0x148(%rsp), %rdi
callq 0xf9e00
leaq 0xb8(%rsp), %rdi
callq 0xfdc90
leaq 0xc8(%rsp), %rdi
callq 0xfdc90
leaq 0xe0(%rsp), %rdi
jmp 0x1a7eac
leaq 0x108(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0xf8(%rsp), %rdi
movq %rbp, %rsi
callq 0xf3e40
leaq 0xe8(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x148(%rsp), %rdi
leaq 0x108(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
leaq 0xe8(%rsp), %rcx
leaq 0x50(%rsp), %r8
movsd 0x18(%rsp), %xmm0
callq 0xf1080
leaq 0x20(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xef740
leaq 0x148(%rsp), %rdi
callq 0xf9e00
leaq 0xe8(%rsp), %rdi
callq 0xfdc90
leaq 0xf8(%rsp), %rdi
callq 0xfdc90
leaq 0x110(%rsp), %rdi
callq 0xf6d50
leaq 0xa8(%rsp), %rdi
movq %r13, %rsi
callq 0xf21a0
leaq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf8e10
leaq 0x148(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x100a30
leaq 0x98(%rsp), %rdi
callq 0xf9e00
leaq 0xb0(%rsp), %rdi
callq 0xf6d50
leaq 0x88(%rsp), %rdi
movq %rbp, %rsi
callq 0xf3e40
leaq 0x30(%rsp), %rdi
leaq 0x148(%rsp), %rsi
leaq 0x88(%rsp), %rdx
pushq $0x3
popq %rcx
callq 0xf9050
leaq 0x30(%rsp), %r14
movq %rbp, %rdi
movq %r14, %rsi
callq 0xef4f0
movq %r14, %rdi
callq 0xfdc90
leaq 0x88(%rsp), %rdi
callq 0xfdc90
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x30(%rsp), %rdi
leaq 0x148(%rsp), %rsi
leaq 0x78(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0xf9050
leaq 0x30(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0xef4f0
movq %r14, %rdi
callq 0xfdc90
leaq 0x78(%rsp), %rdi
callq 0xfdc90
leaq 0x128(%rsp), %rdi
movq %rbx, %rsi
callq 0xf7740
leaq 0x30(%rsp), %rdi
leaq 0x148(%rsp), %rsi
leaq 0x128(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0xf2ee0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf45b0
movq %rbx, %rax
movq %rbp, %rbx
movq %r15, 0x70(%rsp)
movq %rax, 0x68(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xed2f0
leaq 0x128(%rsp), %rdi
callq 0xed2f0
movq (%r13), %rdi
callq 0xfa970
pushq $0x2
popq %rsi
movl %eax, %edi
callq 0xfd130
movl %eax, %r14d
movq (%r13), %rbp
movq %rbp, %rdi
callq 0xf0630
movl %eax, %r15d
movq (%r13), %rdi
callq 0xf0630
movl %eax, %ecx
movl %r15d, %eax
cltd
idivl %r14d
movl %eax, %r8d
movl %ecx, %eax
cltd
idivl %r14d
movl %edx, %ecx
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
movl %r8d, %edx
callq 0xefa70
leaq 0x30(%rsp), %rsi
movq %r13, %rdi
callq 0x100200
leaq 0x38(%rsp), %rdi
callq 0xf6d50
leaq 0x118(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0xf21a0
movq %r14, %rdi
movsd 0x18(%rsp), %xmm0
movq %rbx, %rsi
movq %r12, %rdx
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rbx
movq %rbx, %r8
callq 0x101580
leaq 0x120(%rsp), %rdi
callq 0xf6d50
movq (%rbx), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0xf5e90
leaq 0x148(%rsp), %rdi
callq 0xfb230
leaq 0x20(%rsp), %rdi
callq 0xf9e00
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0xf9e00
jmp 0x1a80fe
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8110
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8122
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
jmp 0x1a81ee
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8144
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8156
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8168
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
jmp 0x1a81ee
movq %rax, %rbx
jmp 0x1a8207
jmp 0x1a81f7
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xf6d50
jmp 0x1a81fa
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xed2f0
jmp 0x1a81a0
movq %rax, %rbx
leaq 0x128(%rsp), %rdi
callq 0xed2f0
jmp 0x1a81fa
jmp 0x1a81f7
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
jmp 0x1a81c8
jmp 0x1a81f7
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xfdc90
jmp 0x1a81fa
jmp 0x1a81f7
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xf9e00
jmp 0x1a81e6
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xf6d50
jmp 0x1a8207
jmp 0x1a81f7
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0xfb230
leaq 0x20(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_inertia.cpp
|
Omega_h::inertia::(anonymous namespace)::mark_axis_bisection(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, Omega_h::Read<double>, double, double, Omega_h::Read<signed char>&)
|
bool mark_axis_bisection(CommPtr comm, Reals distances, Reals masses,
Real total_mass, Real tolerance, Read<I8>& marked) {
auto n = distances.size();
OMEGA_H_CHECK(n == masses.size());
auto minmax_dist = get_minmax(comm, distances);
auto range = max2(std::abs(minmax_dist.min), std::abs(minmax_dist.max));
auto step = range / 2.;
Real distance = 0.;
for (Int i = 0; i < MANTISSA_BITS; ++i) {
marked = mark_half(distances, distance);
auto half_weight = get_half_weight(comm, masses, marked);
if (std::abs(half_weight - (total_mass / 2.)) <= tolerance) {
return true;
}
if (half_weight > total_mass / 2.) {
distance += step;
} else {
distance -= step;
}
step /= 2.;
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rcx, 0x38(%rsp)
movsd %xmm1, 0x118(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x30(%rsp)
movq (%rsi), %rax
testb $0x1, %al
jne 0x1a85a8
movq (%rax), %rax
jmp 0x1a85ac
shrq $0x3, %rax
shrq $0x3, %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
testb $0x1, %cl
jne 0x1a85c2
movq (%rcx), %rcx
jmp 0x1a85c6
shrq $0x3, %rcx
movsd %xmm0, 0x8(%rsp)
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x1a8acd
leaq 0x158(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf21a0
leaq 0x148(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf3e40
leaq 0x158(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xf8c20
movapd %xmm0, 0x10(%rsp)
movapd %xmm1, 0x100(%rsp)
leaq 0x148(%rsp), %rdi
callq 0xfdc90
leaq 0x160(%rsp), %rdi
callq 0xf6d50
movapd 0xd047e(%rip), %xmm0 # 0x278ac0
movapd 0x10(%rsp), %xmm1
andpd %xmm0, %xmm1
movapd 0x100(%rsp), %xmm4
andpd %xmm0, %xmm4
maxsd %xmm1, %xmm4
movsd 0x8(%rsp), %xmm3
mulsd 0xcfff5(%rip), %xmm3 # 0x278660
xorl %r13d, %r13d
xorpd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x50(%rsp), %rbx
leaq 0xa0(%rsp), %rbp
leaq 0x168(%rsp), %r15
leaq 0xd0(%rsp), %r12
movsd %xmm3, 0x8(%rsp)
mulsd 0xcffbd(%rip), %xmm4 # 0x278660
cmpl $0x34, %r13d
je 0x1a8ab4
movapd %xmm4, 0x100(%rsp)
leaq 0x90(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf3e40
movq 0x90(%rsp), %r14
testb $0x1, %r14b
jne 0x1a86db
movq (%r14), %r14
jmp 0x1a86df
shrq $0x3, %r14
movq %rbx, %rdi
leaq 0xd4dce(%rip), %rsi # 0x27d4b7
movq %rbp, %rdx
callq 0xef870
shrq $0x3, %r14
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0xf0f30
movq %rbx, %rdi
callq 0xf00f0
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0xe0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf3e40
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0xf0(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0xb0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf3e40
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0xc0(%rsp)
testl %r14d, %r14d
jle 0x1a87e5
movq 0x169548(%rip), %rax # 0x311cc0
movb $0x1, (%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x100b80
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xfbcb0
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x169512(%rip), %rax # 0x311cc0
movb $0x0, (%rax)
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r14
je 0x1a87dd
movq 0x58(%rsp), %rcx
movq 0x68(%rsp), %rdx
movsd (%rdx,%rax,8), %xmm0
ucomisd 0x70(%rsp), %xmm0
seta (%rcx,%rax)
incq %rax
jmp 0x1a87ba
movq %rbx, %rdi
callq 0x1a8ce6
movq %rbp, %rdi
callq 0x1a8ce6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x100b80
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf8470
movq %rbx, %rdi
callq 0xf9e00
movq %r12, %rdi
callq 0x1a8ce6
movq %r15, %rdi
callq 0xf9e00
movq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0xef740
movq %r14, %rdi
callq 0xf9e00
leaq 0x90(%rsp), %rdi
callq 0xfdc90
leaq 0x138(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf21a0
leaq 0x80(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf3e40
leaq 0x128(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf8e10
movq 0x80(%rsp), %r14
testb $0x1, %r14b
jne 0x1a888b
movq (%r14), %r14
jmp 0x1a888f
shrq $0x3, %r14
movq %rbx, %rdi
leaq 0xd4c1e(%rip), %rsi # 0x27d4b7
movq %rbp, %rdx
callq 0xef870
shrq $0x3, %r14
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0xf6560
movq %rbx, %rdi
callq 0xf00f0
movq %r12, %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0xe0(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0xf8e10
leaq 0xf0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf3e40
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0xb0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xf8e10
leaq 0xc0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xf3e40
testl %r14d, %r14d
jle 0x1a89a9
movq 0x16938f(%rip), %rax # 0x311cc0
movb $0x1, (%rax)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xfbcb0
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x100b80
leaq 0x70(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xfbcb0
movq 0x169356(%rip), %rax # 0x311cc0
movb $0x0, (%rax)
movq 0x58(%rsp), %rax
movq 0x68(%rsp), %rcx
movq 0x78(%rsp), %rdx
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %r14
je 0x1a89a1
movsbl (%rcx,%rsi), %edi
cvtsi2sd %edi, %xmm0
mulsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0x1a8985
movq %rbx, %rdi
callq 0x1a8cfc
movq %rbp, %rdi
callq 0x1a8cfc
leaq 0x40(%rsp), %rdi
leaq 0x138(%rsp), %rsi
callq 0xf21a0
movq %rbp, %rdi
movq %r15, %rsi
callq 0xf3e40
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xf6440
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x101840
movsd %xmm0, 0x120(%rsp)
movq %rbx, %rdi
callq 0xfdc90
movq %rbp, %rdi
callq 0xfdc90
leaq 0x48(%rsp), %rdi
callq 0xf6d50
movq %r12, %rdi
callq 0x1a8cfc
movq %r15, %rdi
callq 0xfdc90
leaq 0x128(%rsp), %rdi
callq 0xf9e00
leaq 0x80(%rsp), %rdi
callq 0xfdc90
leaq 0x140(%rsp), %rdi
callq 0xf6d50
movsd 0x120(%rsp), %xmm2
movapd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm3
subsd %xmm3, %xmm0
andpd 0xd0061(%rip), %xmm0 # 0x278ac0
movsd 0x118(%rsp), %xmm1
ucomisd %xmm0, %xmm1
movapd 0x100(%rsp), %xmm4
jae 0x1a8ab4
movapd %xmm4, %xmm0
xorpd 0xd1afd(%rip), %xmm0 # 0x27a580
movapd %xmm3, %xmm1
cmpltsd %xmm2, %xmm1
movapd %xmm1, %xmm2
andpd %xmm4, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
incl %r13d
jmp 0x1a869b
cmpl $0x34, %r13d
setb %al
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce5b4(%rip), %rdi # 0x277088
leaq 0xd5984(%rip), %rsi # 0x27e45f
leaq 0xd5869(%rip), %rdx # 0x27e34b
pushq $0x5c
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8b01
movq %rax, %rbx
leaq 0x160(%rsp), %rdi
jmp 0x1a8c57
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8b20
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x1a8ce6
jmp 0x1a8ca0
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8b44
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8b53
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x1a8cfc
jmp 0x1a8bb9
movq %rax, %rbx
jmp 0x1a8bb9
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8b81
movq %rax, %rbx
jmp 0x1a8ba2
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xfdc90
jmp 0x1a8bb9
movq %rax, %rbx
jmp 0x1a8baf
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xfdc90
leaq 0xa0(%rsp), %rdi
callq 0xfdc90
leaq 0x48(%rsp), %rdi
callq 0xf6d50
leaq 0xd0(%rsp), %rdi
callq 0x1a8cfc
jmp 0x1a8c28
movq %rax, %rbx
jmp 0x1a8c1b
movq %rax, %rbx
jmp 0x1a8cba
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x1a8bf7
movq %rax, %rbx
jmp 0x1a8cad
movq %rax, %rbx
jmp 0x1a8c4f
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8ca0
movq %rax, %rbx
jmp 0x1a8c35
movq %rax, %rbx
jmp 0x1a8c28
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xf9e00
leaq 0xd0(%rsp), %rdi
callq 0xfdc90
leaq 0x168(%rsp), %rdi
callq 0xfdc90
leaq 0x128(%rsp), %rdi
callq 0xf9e00
leaq 0x80(%rsp), %rdi
callq 0xfdc90
leaq 0x140(%rsp), %rdi
callq 0xf6d50
jmp 0x1a8cc7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x1a8cba
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x1a8cb5
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xf9e00
jmp 0x1a8cad
movq %rax, %rbx
jmp 0x1a8c42
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x1a8c35
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x1a8ce6
leaq 0x168(%rsp), %rdi
callq 0xf9e00
leaq 0x90(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_inertia.cpp
|
Omega_h::Read<int> Omega_h::offset_scan<int>(Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
LOs offset_scan(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
Write<LO> out(a.size() + 1, name);
out.set(0, 0);
auto const first = CastIterator<LO, T>(a.begin());
auto const last = CastIterator<LO, T>(a.end());
auto const result = out.begin() + 1;
inclusive_scan(first, last, result);
return out;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd1578(%rip), %rsi # 0x27ec2c
leaq 0x60(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xc9bcb(%rip), %rdx # 0x277295
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xed920
leaq 0x40(%rsp), %rdi
pushq $0xc
popq %rsi
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0xd1514(%rip), %rdi # 0x27ec20
callq 0xf9c20
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
callq 0xf00f0
leaq 0x60(%rsp), %rdi
callq 0xf00f0
movq (%r14), %rsi
testb $0x1, %sil
jne 0x1ad74a
movq (%rsi), %rsi
jmp 0x1ad74e
shrq $0x3, %rsi
shrq $0x2, %rsi
incl %esi
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0xedf20
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xf1560
movq (%r14), %rax
movq 0x8(%r14), %rdi
testb $0x1, %al
jne 0x1ad77f
movq (%rax), %rax
jmp 0x1ad783
shrq $0x3, %rax
shrq $0x2, %rax
cltq
leaq (%rdi,%rax,4), %rsi
movq 0x18(%rsp), %rdx
addq $0x4, %rdx
callq 0xf8f40
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf4160
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a10
leaq 0x30(%rsp), %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0xe(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xff620
jmp 0x1ad842
jmp 0x1ad83f
movq %rax, %rbx
jmp 0x1ad84c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x1ad80d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x1ad81c
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xf00f0
jmp 0x1ad82e
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf00f0
jmp 0x1ad856
movq %rax, %rbx
jmp 0x1ad856
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0xe(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_int_scan.cpp
|
int* Omega_h::transform_inclusive_scan<int*, int*, Omega_h::maximum<int>, Omega_h::identity<int>>(int*, int*, int*, Omega_h::maximum<int>, Omega_h::identity<int>&&)
|
OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
OutputIterator result, BinaryOp op, UnaryOp&& transform) {
auto const n = last - first;
if (n <= 0) return result;
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
auto value = transform_local(first[0]);
result[0] = value;
using d_t = typename std::remove_const<decltype(n)>::type;
for (d_t i = 1; i < n; ++i) {
value = op(std::move(value), transform_local(first[i]));
result[i] = value;
}
return result + n;
}
|
movq %rdx, %rax
subq %rdi, %rsi
movq %rsi, %rcx
sarq $0x2, %rcx
testq %rcx, %rcx
jle 0x1ad8ce
movq 0x164419(%rip), %rdx # 0x311cc0
movb $0x0, (%rdx)
movl (%rdi), %edx
movl %edx, (%rax)
pushq $0x1
popq %r8
cmpq %r8, %rcx
je 0x1ad8cb
movl (%rdi,%r8,4), %r9d
cmpl %r9d, %edx
cmovlel %r9d, %edx
movl %edx, (%rax,%r8,4)
incq %r8
jmp 0x1ad8b2
addq %rsi, %rax
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_scan.hpp
|
Omega_h::build_reader_tables(Omega_h::Language const&)
|
ReaderTablesPtr build_reader_tables(Language const& language) {
auto lexer = build_lexer(language);
auto indent_info = build_indent_info(language);
auto grammar = build_grammar(language);
auto parser = accept_parser(build_lalr1_parser(grammar));
return ReaderTablesPtr(new ReaderTables({parser, lexer, indent_info}));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xf5300
xorl %r12d, %r12d
pushq $-0x1
popq %r13
movl %r13d, %r15d
xorl %ebp, %ebp
movl %r13d, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x1ae148
movq %r14, %rdi
movl %ebp, %esi
callq 0xee7c0
movq %rax, %rbx
movq %rax, %rdi
leaq 0xd0c9f(%rip), %rsi # 0x27ed80
callq 0x101e60
testb %al, %al
je 0x1ae0fb
movb $0x1, %r12b
cmpl $-0x1, %r13d
movl %ebp, %r13d
je 0x1ae141
jmp 0x1ae28d
movq %rbx, %rdi
leaq 0xd0cb1(%rip), %rsi # 0x27edb6
callq 0x101e60
testb %al, %al
je 0x1ae11c
cmpl $-0x1, %r15d
movl %ebp, %r15d
je 0x1ae141
jmp 0x1ae2de
movq %rbx, %rdi
leaq 0xd0cc6(%rip), %rsi # 0x27edec
callq 0x101e60
testb %al, %al
je 0x1ae141
cmpl $-0x1, 0x8(%rsp)
movl %ebp, %eax
movq %rax, 0x8(%rsp)
jne 0x1ae32f
incl %ebp
jmp 0x1ae0bb
cmpl $-0x1, %r13d
sete %al
testb %al, %r12b
jne 0x1ae380
cmpl $-0x1, %r15d
sete %al
andb %r12b, %al
cmpb $0x1, %al
je 0x1ae3d1
movq 0x8(%rsp), %rcx
cmpl $-0x1, %ecx
sete %al
andb %r12b, %al
cmpb $0x1, %al
je 0x1ae422
cmpl %ecx, %r13d
jl 0x1ae470
cmpl %ecx, %r15d
jl 0x1ae470
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xf4eb0
leaq 0x98(%rsp), %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xfacf0
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xed590
leaq 0xa8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf6070
leaq 0x28(%rsp), %rdi
callq 0xf0d70
leaq 0xa0(%rsp), %rdi
callq 0xf6d50
movl $0xa0, %edi
callq 0xf6900
movq %rax, %rbx
leaq 0xa8(%rsp), %rsi
movq %rax, %rdi
callq 0xf0600
movq %rbx, %rdi
addq $0x50, %rdi
leaq 0xf8(%rsp), %rsi
callq 0xfbbf0
shlq $0x20, %r13
movzbl %r12b, %eax
orq %r13, %rax
movq 0x8(%rsp), %rdx
shlq $0x20, %rdx
movl %r15d, %ecx
orq %rdx, %rcx
movq %rax, 0x90(%rbx)
movq %rcx, 0x98(%rbx)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xf5ec0
leaq 0xa8(%rsp), %rdi
callq 0xfb740
leaq 0x20(%rsp), %rdi
callq 0xf6d50
leaq 0xf8(%rsp), %rdi
callq 0xff8e0
movq 0x10(%rsp), %rax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0ae8(%rip), %rsi # 0x27ed87
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x163796(%rip), %rsi # 0x311a60
movq 0x163747(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0acd(%rip), %rsi # 0x27edbd
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x163745(%rip), %rsi # 0x311a60
movq 0x1636f6(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0ab3(%rip), %rsi # 0x27edf4
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x1636f4(%rip), %rsi # 0x311a60
movq 0x1636a5(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0a92(%rip), %rsi # 0x27ee24
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x1636a3(%rip), %rsi # 0x311a60
movq 0x163654(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0a7c(%rip), %rsi # 0x27ee5f
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x163652(%rip), %rsi # 0x311a60
movq 0x163603(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0a66(%rip), %rsi # 0x27ee9a
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x163601(%rip), %rsi # 0x311a60
movq 0x1635b2(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae4bc
pushq $0x10
popq %rdi
callq 0xf0720
movq %rax, %rbx
leaq 0xd0a54(%rip), %rsi # 0x27eed6
leaq 0x28(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0xfa020
xorl %ebp, %ebp
movq 0x1635b3(%rip), %rsi # 0x311a60
movq 0x163564(%rip), %rdx # 0x311a18
movq %rbx, %rdi
callq 0xfeae0
jmp 0x1ae538
jmp 0x1ae54c
jmp 0x1ae538
jmp 0x1ae54c
jmp 0x1ae538
jmp 0x1ae54c
jmp 0x1ae538
jmp 0x1ae54c
movq %rax, %r14
movq %rbx, %rdi
callq 0xfb740
jmp 0x1ae4e2
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0xf6cf0
jmp 0x1ae51b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xf0d70
jmp 0x1ae503
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0xf6d50
jmp 0x1ae528
jmp 0x1ae559
jmp 0x1ae538
jmp 0x1ae54c
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0xfb740
leaq 0x20(%rsp), %rdi
callq 0xf6d50
jmp 0x1ae55c
jmp 0x1ae538
jmp 0x1ae54c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xf00f0
testb %bpl, %bpl
jne 0x1ae54f
jmp 0x1ae55c
movq %rax, %r14
movq %rbx, %rdi
callq 0xf35c0
jmp 0x1ae55c
movq %rax, %r14
leaq 0xf8(%rsp), %rdi
callq 0xff8e0
movq %r14, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_language.cpp
|
Omega_h::find_total_globals(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<long>)
|
GO find_total_globals(CommPtr comm, Read<GO> globals) {
auto const a = get_max(comm, globals);
if (a < 0) return 0;
return a + 1;
}
|
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
callq 0xf21a0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xf3b80
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0xf5310
movq %rax, %rbx
movq %rsp, %rdi
callq 0x100060
leaq 0x18(%rsp), %rdi
callq 0xf6d50
leaq 0x1(%rbx), %rcx
xorl %eax, %eax
testq %rbx, %rbx
cmovnsq %rcx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x100060
jmp 0x1b1061
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf6d50
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_linpart.cpp
|
Omega_h::compound_maps(Omega_h::Read<int>, Omega_h::Read<int>)
|
LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xcd804(%rip), %rsi # 0x27f5bb
leaq 0xa8(%rsp), %rdi
leaq 0xc8(%rsp), %rdx
callq 0xef870
leaq 0xc54c2(%rip), %rdx # 0x277295
leaq 0x58(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xed920
leaq 0x88(%rsp), %rdi
movl $0x94, %esi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0xcd97d(%rip), %rdi # 0x27f797
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
callq 0xf00f0
leaq 0x58(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1b1e63
movq (%r12), %r12
movq %r12, %r13
shrq $0x2, %r13
jmp 0x1b1e6e
movq %r12, %r13
shrq $0x5, %r13
shrq $0x3, %r12
leaq 0xcb642(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %r12d, %esi
callq 0xedf20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x78(%rsp), %r14
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0xf0580
leaq 0xc5b71(%rip), %rsi # 0x277a4b
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xc53a2(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xed920
leaq 0xc8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0xc5b00(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0xc8(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
callq 0xf00f0
testl %r13d, %r13d
jle 0x1b1fea
movq 0x15fd40(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xf4160
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf4160
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xf4160
movb $0x0, (%rbp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %r13
je 0x1b1fe0
movslq (%rax,%rsi,4), %rdi
movl (%rcx,%rdi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
jmp 0x1b1fcc
leaq 0x8(%rsp), %rdi
callq 0x1b2174
leaq 0x6(%rsp), %rdi
callq 0xf7d50
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xf4160
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a10
leaq 0x48(%rsp), %rdi
callq 0xff620
leaq 0x58(%rsp), %rdi
callq 0x1b2174
leaq 0x38(%rsp), %rdi
callq 0xff620
leaq 0x5(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0xff620
jmp 0x1b205d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
jmp 0x1b206c
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1b20d1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xff620
jmp 0x1b20d1
jmp 0x1b20ce
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b209b
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b20ad
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b20bf
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf00f0
jmp 0x1b20d1
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x1b2174
leaq 0x38(%rsp), %rdi
callq 0xff620
leaq 0x5(%rsp), %rdi
callq 0xf7d50
jmp 0x1b216b
movq %rax, %rbx
movq %r15, %rdi
callq 0xff620
jmp 0x1b2101
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xff620
jmp 0x1b20db
movq %rax, %rbx
jmp 0x1b20db
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b20e5
movq %rax, %rbx
jmp 0x1b20e5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b2138
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf00f0
jmp 0x1b214a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf00f0
jmp 0x1b2159
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b216b
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
Omega_h::invert_marks(Omega_h::Read<signed char>)
|
Read<I8> invert_marks(Read<I8> marks) {
Write<I8> out(marks.size());
auto f = OMEGA_H_LAMBDA(LO i) { out[i] = !marks[i]; };
parallel_for(out.size(), f, "invert_marks");
return out;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x1b23ae
movq (%r15), %r15
jmp 0x1b23b2
shrq $0x3, %r15
leaq 0xcb0fe(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movl %r15d, %esi
callq 0xf0f30
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movq 0x8(%rsp), %r12
testb $0x1, %r12b
jne 0x1b2414
movq (%r12), %r12
jmp 0x1b2418
shrq $0x3, %r12
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xf8e10
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf8e10
testl %r12d, %r12d
jle 0x1b2496
movq 0x15f87d(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x100b80
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x100b80
movb $0x0, (%r15)
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r12
je 0x1b248c
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
cmpb $0x0, (%rdx,%rax)
sete (%rcx,%rax)
incq %rax
jmp 0x1b2470
leaq 0x18(%rsp), %rdi
callq 0x1b256a
leaq 0x48(%rsp), %rdi
callq 0x1b256a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x68(%rsp), %rdi
callq 0x1b256a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
jmp 0x1b24fe
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1b256a
jmp 0x1b254e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x1b251c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf9e00
jmp 0x1b254e
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf9e00
jmp 0x1b2558
movq %rax, %rbx
jmp 0x1b2558
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x1b2562
movq %rax, %rbx
jmp 0x1b2562
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1b256a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
Omega_h::invert_map_by_sorting(Omega_h::Read<int>, int)
|
Graph invert_map_by_sorting(LOs a2b, LO nb) {
auto& ab2b = a2b;
auto ba2ab = sort_by_keys(ab2b);
auto ba2b = unmap(ba2ab, ab2b, 1);
auto b2ba = invert_funnel(ba2b, nb);
auto& ba2a = ba2ab;
return Graph(b2ba, ba2a);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0xf0580
leaq 0x88(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x101340
leaq 0x98(%rsp), %rdi
callq 0xff620
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rbx
movq %rbx, %rsi
callq 0xf0580
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x58(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0xf17d0
leaq 0x58(%rsp), %rdi
callq 0xff620
leaq 0x68(%rsp), %rdi
callq 0xff620
leaq 0x28(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xf0580
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf7a10
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl %ebp, %edx
callq 0xf63e0
leaq 0x38(%rsp), %rdi
callq 0xff620
leaq 0x28(%rsp), %rdi
callq 0xff620
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf0580
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf0580
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xf6db0
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x18(%rsp), %rdi
callq 0xff620
leaq 0x48(%rsp), %rdi
callq 0xff620
leaq 0x78(%rsp), %rdi
callq 0xff620
leaq 0x88(%rsp), %rdi
callq 0xff620
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xff620
jmp 0x1b3204
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xff620
jmp 0x1b3213
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x1b3231
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xff620
jmp 0x1b322c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xff620
leaq 0x78(%rsp), %rdi
jmp 0x1b3259
movq %rax, %r14
jmp 0x1b3236
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0xff620
jmp 0x1b3254
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xff620
jmp 0x1b3265
jmp 0x1b3262
movq %rax, %r14
movq %rbx, %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::add_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)
|
void add_into(Read<T> a_data, LOs a2b, Write<T> b_data, Int width) {
auto na = a2b.size();
OMEGA_H_CHECK(a_data.size() == na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
b_data[b * width + j] += a_data[a * width + j];
}
};
parallel_for(na, f, "add_into");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %r14
movq (%rsi), %rbx
testb $0x1, %bl
jne 0x1b401d
movq (%rbx), %rbx
jmp 0x1b4021
shrq $0x3, %rbx
shrq $0x2, %rbx
movq (%r14), %rax
testb $0x1, %al
jne 0x1b4031
movq (%rax), %rax
jmp 0x1b4035
shrq $0x3, %rax
movl %ebx, %ecx
imull %ebp, %ecx
cmpl %eax, %ecx
jne 0x1b4097
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf0580
movl %ebp, 0x10(%r12)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xf8e10
leaq 0xcb5a5(%rip), %rdx # 0x27f619
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0xf6920
leaq 0x8(%rsp), %rdi
callq 0xfc6c0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc2fea(%rip), %rdi # 0x277088
leaq 0xcb4fa(%rip), %rsi # 0x27f59f
leaq 0xcb50f(%rip), %rdx # 0x27f5bb
pushq $0xf
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfc6c0
jmp 0x1b40df
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x1b40d5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::parallel_for<void Omega_h::expand_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)>(int, signed char&&)
|
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
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc2820(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xc2054(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf4ff0
movq 0x68(%rsp), %rsi
leaq 0xc27c1(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x48(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
callq 0xf00f0
xorl %edi, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xf1030
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1b5318
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x1b52eb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b52fa
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf00f0
jmp 0x1b5309
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x1b5318
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
void Omega_h::map_into_range<int>(Omega_h::Read<int>, int, int, Omega_h::Write<int>, int)
|
void map_into_range(
Read<T> a_data, LO begin, LO end, Write<T> b_data, Int width) {
auto na = end - begin;
OMEGA_H_CHECK(a_data.size() == na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = begin + a;
for (Int j = 0; j < width; ++j) {
b_data[b * width + j] = a_data[a * width + j];
}
};
parallel_for(na, f, "map_into_range");
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rdi, %r14
subl %esi, %ebx
movq (%rdi), %rax
testb $0x1, %al
jne 0x1b613a
movq (%rax), %rax
jmp 0x1b613e
shrq $0x3, %rax
shrq $0x2, %rax
movl %ebx, %edx
imull %r8d, %edx
cmpl %eax, %edx
jne 0x1b6198
leaq 0x10(%rsp), %r15
movl %esi, -0x8(%r15)
movl %r8d, -0x4(%r15)
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf0580
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0xc94eb(%rip), %rdx # 0x27f663
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0xfc600
leaq 0x8(%rsp), %rdi
callq 0x100830
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xc0ee9(%rip), %rdi # 0x277088
leaq 0xc93f9(%rip), %rsi # 0x27f59f
leaq 0xc940e(%rip), %rdx # 0x27f5bb
pushq $0x32
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x100830
jmp 0x1b61d1
movq %rax, %rbx
movq %r15, %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::parallel_for<Omega_h::Write<int> Omega_h::unmap<int>(Omega_h::Read<int>, Omega_h::Read<int>, int)::'lambda'(int)>(int, int&&)
|
void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
}
|
pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc1387(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xc0bbb(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf4ff0
movq 0x68(%rsp), %rsi
leaq 0xc1328(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x48(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
callq 0xf00f0
xorl %edi, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xf5180
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1b67b1
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x1b6784
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b6793
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf00f0
jmp 0x1b67a2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x1b67b1
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
Omega_h::Read<Omega_h::MaxFunctor<int>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<int>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<int>::input_type>, int)
|
Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto functor = Functor();
for (Int j = 0; j < width; ++j) {
VT res;
functor.init(res);
for (auto b = a2b[a]; b < a2b[a + 1]; ++b) {
VT update = b_data[b * width + j];
functor.join(res, update);
}
a_data[a * width + j] = static_cast<T>(res);
}
};
parallel_for(na, f, "fan_reduce");
return a_data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1b751e
movq (%rcx), %rcx
jmp 0x1b7522
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x1b7613
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1b753d
movq (%r12), %r12
jmp 0x1b7541
shrq $0x3, %r12
leaq 0xc5f6f(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
decl %r12d
movl %r12d, %esi
imull %ebp, %esi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xedf20
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0xf00f0
movl %ebp, (%r13)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf0580
leaq 0xc8244(%rip), %rdx # 0x27f7fe
leaq 0x30(%rsp), %rsi
movl %r12d, %edi
callq 0x101f20
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf4160
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a10
leaq 0x20(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0x1016d0
leaq 0x10(%rsp), %rdi
callq 0xff620
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbfa6e(%rip), %rdi # 0x277088
leaq 0xc81b9(%rip), %rsi # 0x27f7da
leaq 0xc7f93(%rip), %rdx # 0x27f5bb
movl $0x127, %ecx # imm = 0x127
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xff620
jmp 0x1b7679
movq %rax, %rbx
movq %r15, %rdi
callq 0xff620
jmp 0x1b7653
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x1b7683
movq %rax, %rbx
jmp 0x1b7683
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1b768d
movq %rax, %rbx
jmp 0x1b768d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1016d0
leaq 0x10(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
Omega_h::Write<long> Omega_h::unmap<long>(Omega_h::Read<int>, Omega_h::Read<long>, int)
|
Write<T> unmap(LOs a2b, Read<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size();
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
a_data[a * width + j] = b_data[b * width + j];
}
};
parallel_for(na, std::move(f));
return a_data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc747a(%rip), %rsi # 0x27f5bb
leaq 0x80(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xbf13b(%rip), %rdx # 0x277295
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xed920
leaq 0x60(%rsp), %rdi
pushq $0x4c
popq %rsi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0xc753c(%rip), %rdi # 0x27f6d5
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x60(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
callq 0xf00f0
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1b81d8
movq (%r12), %r12
jmp 0x1b81dc
shrq $0x3, %r12
leaq 0xc52d4(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
movl %r12d, %esi
imull %ebp, %esi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xecc90
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x20(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf3b80
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xf3b80
leaq 0x8(%rsp), %rsi
movl %r12d, %edi
callq 0xedab0
leaq 0x8(%rsp), %rdi
callq 0xff760
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xff760
jmp 0x1b82a3
movq %rax, %r14
movq %r15, %rdi
callq 0x100060
jmp 0x1b8294
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xff620
jmp 0x1b82a3
movq %rax, %r14
movq %rbx, %rdi
callq 0x100060
jmp 0x1b82bf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b82bf
movq %rax, %r14
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1b830d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b82dd
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0xf00f0
jmp 0x1b82ec
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x1b82fb
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0xf00f0
jmp 0x1b830d
movq %rax, %r14
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
Omega_h::Read<long> Omega_h::fan_reduce<long>(Omega_h::Read<int>, Omega_h::Read<long>, int, Omega_h_Op)
|
Read<T> fan_reduce(LOs a2b, Read<T> b_data, Int width, Omega_h_Op op) {
switch (op) {
case OMEGA_H_MIN:
return fan_reduce_tmpl<MinFunctor<T>>(a2b, b_data, width);
case OMEGA_H_MAX:
return fan_reduce_tmpl<MaxFunctor<T>>(a2b, b_data, width);
case OMEGA_H_SUM:
return fan_reduce_tmpl<SumFunctor<T>>(a2b, b_data, width);
}
OMEGA_H_NORETURN(Read<T>());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x2, %r8d
je 0x1b8eeb
cmpl $0x1, %r8d
je 0x1b8eb7
testl %r8d, %r8d
jne 0x1b8f39
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf3b80
leaq 0x20(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xf4a90
jmp 0x1b8f19
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf3b80
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xf9d90
jmp 0x1b8f19
movq %rsp, %r14
movq %r14, %rdi
callq 0xf0580
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf3b80
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xf1bd0
movq %r15, %rdi
callq 0x100060
movq %r14, %rdi
callq 0xff620
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbe148(%rip), %rdi # 0x277088
leaq 0xbe8ae(%rip), %rsi # 0x2777f5
leaq 0xc666d(%rip), %rdx # 0x27f5bb
movl $0x144, %ecx # imm = 0x144
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x100060
leaq 0x20(%rsp), %r14
jmp 0x1b8f9b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x100060
movq %rsp, %r14
jmp 0x1b8f9b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x100060
leaq 0x10(%rsp), %r14
jmp 0x1b8f9b
jmp 0x1b8f98
jmp 0x1b8f98
movq %rax, %rbx
movq %r14, %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
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)
|
Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto functor = Functor();
for (Int j = 0; j < width; ++j) {
VT res;
functor.init(res);
for (auto b = a2b[a]; b < a2b[a + 1]; ++b) {
VT update = b_data[b * width + j];
functor.join(res, update);
}
a_data[a * width + j] = static_cast<T>(res);
}
};
parallel_for(na, f, "fan_reduce");
return a_data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1b932c
movq (%rcx), %rcx
jmp 0x1b9330
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x1b9421
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1b934b
movq (%r12), %r12
jmp 0x1b934f
shrq $0x3, %r12
leaq 0xc4161(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
decl %r12d
movl %r12d, %esi
imull %ebp, %esi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xecc90
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0xf00f0
movl %ebp, (%r13)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3b80
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3b80
leaq 0xc6436(%rip), %rdx # 0x27f7fe
leaq 0x30(%rsp), %rsi
movl %r12d, %edi
callq 0xf3f90
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xee9e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xece80
leaq 0x20(%rsp), %rdi
callq 0x100060
leaq 0x30(%rsp), %rdi
callq 0xf6730
leaq 0x10(%rsp), %rdi
callq 0x100060
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbdc60(%rip), %rdi # 0x277088
leaq 0xc63ab(%rip), %rsi # 0x27f7da
leaq 0xc6185(%rip), %rdx # 0x27f5bb
movl $0x127, %ecx # imm = 0x127
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x100060
jmp 0x1b9487
movq %rax, %rbx
movq %r15, %rdi
callq 0x100060
jmp 0x1b9461
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x1b9491
movq %rax, %rbx
jmp 0x1b9491
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1b949b
movq %rax, %rbx
jmp 0x1b949b
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf6730
leaq 0x10(%rsp), %rdi
callq 0x100060
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::parallel_for<void Omega_h::map_into_range<double>(Omega_h::Read<double>, int, int, Omega_h::Write<double>, int)::'lambda'(int)>(int, double const&, char const*)
|
void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0x101530
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf54e0
movq %rsp, %rdi
callq 0xffa10
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xffa10
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
Omega_h::Write<double> Omega_h::unmap<double>(Omega_h::Read<int>, Omega_h::Read<double>, int)
|
Write<T> unmap(LOs a2b, Read<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size();
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto b = a2b[a];
for (Int j = 0; j < width; ++j) {
a_data[a * width + j] = b_data[b * width + j];
}
};
parallel_for(na, std::move(f));
return a_data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc5801(%rip), %rsi # 0x27f5bb
leaq 0x80(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xbd4c2(%rip), %rdx # 0x277295
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xed920
leaq 0x60(%rsp), %rdi
pushq $0x4c
popq %rsi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0xc58c3(%rip), %rdi # 0x27f6d5
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x60(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
callq 0xf00f0
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1b9e51
movq (%r12), %r12
jmp 0x1b9e55
shrq $0x3, %r12
leaq 0xc365b(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
movl %r12d, %esi
imull %ebp, %esi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xf6560
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x20(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf3e40
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x8(%rsp), %rsi
movl %r12d, %edi
callq 0xfa910
leaq 0x8(%rsp), %rdi
callq 0xf9cf0
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf9cf0
jmp 0x1b9f1c
movq %rax, %r14
movq %r15, %rdi
callq 0xfdc90
jmp 0x1b9f0d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xff620
jmp 0x1b9f1c
movq %rax, %r14
movq %rbx, %rdi
callq 0xfdc90
jmp 0x1b9f38
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b9f38
movq %rax, %r14
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1b9f86
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1b9f56
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0xf00f0
jmp 0x1b9f65
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x1b9f74
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0xf00f0
jmp 0x1b9f86
movq %rax, %r14
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::expand_into<double>(Omega_h::Read<double>, Omega_h::Read<int>, Omega_h::Write<double>, int)
|
void expand_into(Read<T> a_data, LOs a2b, Write<T> b_data, Int width) {
OMEGA_H_TIME_FUNCTION;
auto na = a2b.size() - 1;
if(a_data.size() != na * width) printf("This error can happen when an array has been subsetted - check sync_array usage vs sync_subset_array:\n"
" a_data.size= %d na= %d width= %d", a_data.size(), na, width);
OMEGA_H_CHECK_PRINTF(a_data.size() == na * width, "a_data.size= %d na= %d width= %d", a_data.size(), na, width);
auto f = OMEGA_H_LAMBDA(LO a) {
for (auto b = a2b[a]; b < a2b[a + 1]; ++b) {
for (Int j = 0; j < width; ++j) {
b_data[b * width + j] = a_data[a * width + j];
}
}
};
parallel_for(na, std::move(f));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %r14d
movq %rdx, 0x18(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc50d8(%rip), %rsi # 0x27f5bb
leaq 0x78(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0xbcd9c(%rip), %rdx # 0x277295
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xed920
leaq 0x58(%rsp), %rdi
pushq $0x6a
popq %rsi
callq 0xf9ed0
leaq 0x20(%rsp), %rdi
leaq 0x98(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0xf4ff0
movq 0x20(%rsp), %rsi
leaq 0xc51c0(%rip), %rdi # 0x27f6fb
callq 0xf9c20
leaq 0x20(%rsp), %rdi
callq 0xf00f0
leaq 0x58(%rsp), %rdi
callq 0xf00f0
leaq 0x98(%rsp), %rdi
callq 0xf00f0
leaq 0x78(%rsp), %rdi
callq 0xf00f0
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1ba57a
movq (%r12), %r12
jmp 0x1ba57e
shrq $0x3, %r12
shrq $0x2, %r12
decl %r12d
movq (%rbx), %rax
testb $0x1, %al
jne 0x1ba5a9
movq (%rax), %rsi
shrq $0x3, %rsi
movl %r12d, %r13d
movl %r14d, %ebp
imull %r14d, %r13d
cmpl %esi, %r13d
jne 0x1ba5d0
movq 0x18(%rsp), %r14
jmp 0x1ba5fe
movl %r14d, %ecx
movq %r15, 0x10(%rsp)
movq 0x18(%rsp), %r15
movq %rax, %r13
shrq $0x6, %r13
movl %r12d, %r14d
movl %ecx, %ebp
imull %ecx, %r14d
cmpl %r13d, %r14d
je 0x1ba5f6
movl %r13d, %esi
jmp 0x1ba5dd
movq %r15, 0x10(%rsp)
movq 0x18(%rsp), %r15
movl %r13d, %r14d
leaq 0xc5123(%rip), %rdi # 0x27f707
movl %r12d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xec460
movq (%rbx), %rax
movl %r14d, %r13d
movq %r15, %r14
movq 0x10(%rsp), %r15
testb $0x1, %al
jne 0x1ba60b
movq (%rax), %rsi
shrq $0x3, %rsi
jmp 0x1ba612
movq %rax, %rsi
shrq $0x6, %rsi
cmpl %esi, %r13d
je 0x1ba62d
leaq 0xc500d(%rip), %rdi # 0x27f62b
movl %r12d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xec460
movq (%rbx), %rax
testb $0x1, %al
jne 0x1ba636
movq (%rax), %rax
jmp 0x1ba63a
shrq $0x3, %rax
shrq $0x3, %rax
cmpl %eax, %r13d
jne 0x1ba6a4
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x38(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0xf3e40
leaq 0x20(%rsp), %rsi
movl %r12d, %edi
callq 0xf0490
leaq 0x20(%rsp), %rdi
callq 0xf5380
leaq 0xe(%rsp), %rdi
callq 0xf7d50
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbc9dd(%rip), %rdi # 0x277088
leaq 0xc4eed(%rip), %rsi # 0x27f59f
leaq 0xc4f02(%rip), %rdx # 0x27f5bb
pushq $0x6e
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf5380
jmp 0x1ba6f3
movq %rax, %rbx
movq %r15, %rdi
callq 0xfdc90
jmp 0x1ba6e2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xff620
jmp 0x1ba6f3
jmp 0x1ba6f0
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0xf7d50
jmp 0x1ba741
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x1ba711
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf00f0
jmp 0x1ba720
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xf00f0
jmp 0x1ba732
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf00f0
jmp 0x1ba741
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
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)
|
Read<typename Functor::input_type> fan_reduce_tmpl(
LOs a2b, Read<typename Functor::input_type> b_data, Int width) {
using T = typename Functor::input_type;
using VT = typename Functor::value_type;
OMEGA_H_CHECK(a2b.last() * width == b_data.size());
auto na = a2b.size() - 1;
Write<T> a_data(na * width);
auto f = OMEGA_H_LAMBDA(LO a) {
auto functor = Functor();
for (Int j = 0; j < width; ++j) {
VT res;
functor.init(res);
for (auto b = a2b[a]; b < a2b[a + 1]; ++b) {
VT update = b_data[b * width + j];
functor.join(res, update);
}
a_data[a * width + j] = static_cast<T>(res);
}
};
parallel_for(na, f, "fan_reduce");
return a_data;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xf8ab0
imull %ebp, %eax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1bafa4
movq (%rcx), %rcx
jmp 0x1bafa8
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x1bb099
movq (%r15), %r12
testb $0x1, %r12b
jne 0x1bafc3
movq (%r12), %r12
jmp 0x1bafc7
shrq $0x3, %r12
leaq 0xc24e9(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
shrq $0x2, %r12
decl %r12d
movl %r12d, %esi
imull %ebp, %esi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xf6560
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0xf00f0
movl %ebp, (%r13)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x58(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3e40
leaq 0xc47be(%rip), %rdx # 0x27f7fe
leaq 0x30(%rsp), %rsi
movl %r12d, %edi
callq 0xff070
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfbcb0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x20(%rsp), %rdi
callq 0xfdc90
leaq 0x30(%rsp), %rdi
callq 0xf13c0
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbbfe8(%rip), %rdi # 0x277088
leaq 0xc4733(%rip), %rsi # 0x27f7da
leaq 0xc450d(%rip), %rdx # 0x27f5bb
movl $0x127, %ecx # imm = 0x127
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
jmp 0x1bb0ff
movq %rax, %rbx
movq %r15, %rdi
callq 0xfdc90
jmp 0x1bb0d9
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x1bb109
movq %rax, %rbx
jmp 0x1bb109
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1bb113
movq %rax, %rbx
jmp 0x1bb113
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf13c0
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::map_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)::operator()(int) const
|
OMEGA_H_INLINE void* data() const noexcept { return direct_ptr; }
|
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
xorl %ecx, %ecx
movl 0x10(%rdi), %edx
cmpl %edx, %ecx
jge 0x1bb358
movl %edx, %r8d
imull %esi, %r8d
addl %ecx, %r8d
movq 0x20(%rdi), %r9
movq 0x30(%rdi), %r10
movslq %r8d, %r8
movb (%r10,%r8), %r8b
imull %eax, %edx
addl %ecx, %edx
movslq %edx, %rdx
movb %r8b, (%r9,%rdx)
incl %ecx
jmp 0x1bb328
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::map_value_into<signed char>(signed char, Omega_h::Read<int>, Omega_h::Write<signed char>)::'lambda'(int)>(signed char, signed char, void Omega_h::map_value_into<signed char>(signed char, Omega_h::Read<int>, Omega_h::Write<signed char>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1bb43d
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1568cf(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf5830
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x1bb42b
movb 0x28(%rsp), %dl
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
movslq (%rdi,%rax,4), %rdi
movb %dl, (%rsi,%rdi)
incq %rax
jmp 0x1bb40c
leaq 0x8(%rsp), %rdi
callq 0xf6e30
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::expand_into<signed char>(Omega_h::Read<signed char>, Omega_h::Read<int>, Omega_h::Write<signed char>, int)::'lambda'(int)::operator()(int) const
|
OMEGA_H_INLINE void* data() const noexcept { return direct_ptr; }
|
movq 0x8(%rdi), %rdx
movslq %esi, %rax
movl (%rdx,%rax,4), %ecx
cmpl 0x4(%rdx,%rax,4), %ecx
jge 0x1bb8bc
xorl %edx, %edx
movl 0x10(%rdi), %r8d
cmpl %r8d, %edx
jge 0x1bb8b4
movl %ecx, %r9d
imull %r8d, %r9d
imull %esi, %r8d
addl %edx, %r8d
movq 0x20(%rdi), %r10
movq 0x30(%rdi), %r11
movslq %r8d, %r8
movb (%r11,%r8), %r8b
addl %edx, %r9d
movslq %r9d, %r9
movb %r8b, (%r10,%r9)
incl %edx
jmp 0x1bb880
incl %ecx
movq 0x8(%rdi), %rdx
jmp 0x1bb878
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<signed char>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<signed char>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<signed char>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<signed char> const&, char const*)
|
void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf8f70
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf9620
movq %rsp, %rdi
callq 0xf4250
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf4250
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
void Omega_h::expand_into<int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Write<int>, int)::'lambda'(int)::operator()(int) const
|
LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
}
|
pushq %rbx
movq 0x8(%rdi), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %edx
cmpl 0x4(%rax,%rcx,4), %edx
jge 0x1bc6fc
movq 0x20(%rdi), %r8
movq 0x30(%rdi), %r9
xorl %r10d, %r10d
movl 0x10(%rdi), %r11d
cmpl %r11d, %r10d
jge 0x1bc6f8
movl %edx, %ebx
imull %r11d, %ebx
imull %esi, %r11d
addl %r10d, %r11d
movslq %r11d, %r11
movl (%r9,%r11,4), %r11d
addl %r10d, %ebx
movslq %ebx, %rbx
movl %r11d, (%r8,%rbx,4)
incl %r10d
jmp 0x1bc6cc
incl %edx
jmp 0x1bc6bb
popq %rbx
retq
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
void Omega_h::parallel_for<Omega_h::Read<Omega_h::MaxFunctor<int>::input_type> Omega_h::fan_reduce_tmpl<Omega_h::MaxFunctor<int>>(Omega_h::Read<int>, Omega_h::Read<Omega_h::MaxFunctor<int>::input_type>, int)::'lambda'(int)>(int, Omega_h::MaxFunctor<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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xeeea0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf4f10
movq %rsp, %rdi
callq 0x1016d0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1016d0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
void Omega_h::expand_into<long>(Omega_h::Read<long>, Omega_h::Read<int>, Omega_h::Write<long>, int)::'lambda'(int)::operator()(int) const
|
LOs compound_maps(LOs a2b, LOs b2c) {
OMEGA_H_TIME_FUNCTION;
LO na = a2b.size();
Write<LO> a2c(a2b.size());
auto f = OMEGA_H_LAMBDA(LO a) {
LO b = a2b[a];
LO c = b2c[b];
a2c[a] = c;
};
parallel_for(na, std::move(f));
return a2c;
}
|
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
movslq %esi, %rsi
movslq (%rcx,%rsi,4), %rax
movslq 0x4(%rcx,%rsi,4), %rcx
movslq 0x10(%rdi), %rdx
imull %edx, %esi
movslq %esi, %rsi
xorl %r8d, %r8d
testl %edx, %edx
cmovgl %edx, %r8d
movq %rax, %r9
imulq %rdx, %r9
shlq $0x3, %r9
shlq $0x3, %rdx
shlq $0x3, %rsi
cmpq %rcx, %rax
jge 0x1bd596
movq 0x30(%rdi), %r10
addq %rsi, %r10
movq 0x20(%rdi), %r11
addq %r9, %r11
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x1bd58e
movq (%r10,%rbx,8), %r14
movq %r14, (%r11,%rbx,8)
incq %rbx
jmp 0x1bd57c
incq %rax
addq %rdx, %r9
jmp 0x1bd567
popq %rbx
popq %r14
retq
|
/gahansen[P]omega_h/src/Omega_h_map.cpp
|
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 %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf97d0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf9fe0
movq %rsp, %rdi
callq 0xf6730
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf6730
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
Omega_h::mark_class_closures(Omega_h::Mesh*, int, std::vector<int, std::allocator<int>> const&, Omega_h::Graph)
|
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 %r14
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%r8)
je 0x1c056a
movq %r8, %r14
cmpq $0x0, 0x18(%r8)
je 0x1c0586
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf15b0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xf8b70
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xfe5d0
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x28(%rsp), %rdi
callq 0xfe010
leaq 0x18(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
leaq 0xb6b17(%rip), %rdi # 0x277088
leaq 0xbf3a4(%rip), %rsi # 0x27f91c
leaq 0xbf2f2(%rip), %rdx # 0x27f871
movl $0x8f, %ecx
jmp 0x1c05a0
leaq 0xb6afb(%rip), %rdi # 0x277088
leaq 0xbf3a1(%rip), %rsi # 0x27f935
leaq 0xbf2d6(%rip), %rdx # 0x27f871
movl $0x90, %ecx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
jmp 0x1c05b9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xfe010
jmp 0x1c05c8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_mark.cpp
|
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; ++class_dim) {
auto dim_class_ids = get_dim_class_ids(class_dim, class_pairs);
if (dim_class_ids.empty()) continue;
auto class_dim_marks = mark_class_closures(
mesh, class_dim, dim_class_ids, nodes2ents[class_dim]);
marks = lor_each(marks, class_dim_marks);
}
return marks;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, 0x28(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rsi, %rdi
callq 0xfe5f0
cltq
movq %rax, 0x30(%rsp)
shlq $0x5, %rax
cmpq $0x0, 0x8(%r14,%rax)
je 0x1c0976
addq %r14, %rax
movq (%rax), %rbx
testb $0x1, %bl
jne 0x1c0846
movq (%rbx), %rbx
jmp 0x1c084a
shrq $0x3, %rbx
leaq 0xbcc66(%rip), %rsi # 0x27d4b7
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xef870
shrq $0x2, %rbx
decl %ebx
leaq 0x48(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0xf4590
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0xf00f0
xorl %ebp, %ebp
leaq 0x68(%rsp), %r12
leaq 0x78(%rsp), %rbx
cmpq 0x30(%rsp), %rbp
jg 0x1c095f
movq %r13, %rdi
movl %ebp, %esi
movq 0x28(%rsp), %rdx
callq 0x1c0785
movq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1c094b
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8b70
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %ebp, %edx
movq %r13, %rcx
movq %r15, %r8
callq 0xeec50
movq %r15, %rdi
callq 0xfe010
leaq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf8e10
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8e10
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
movq %r12, %rdx
callq 0xfb700
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xef740
movq %rbx, %rdi
callq 0xf9e00
movq %r12, %rdi
callq 0xf9e00
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf9e00
movq %r13, %rdi
callq 0xf8380
incq %rbp
addq $0x20, %r14
jmp 0x1c0892
movq 0x8(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb670b(%rip), %rdi # 0x277088
leaq 0xbefca(%rip), %rsi # 0x27f94e
leaq 0xbeee6(%rip), %rdx # 0x27f871
movl $0xb1, %ecx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf00f0
jmp 0x1c0a15
movq %rax, %rbx
jmp 0x1c0a15
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xfe010
jmp 0x1c09fc
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf9e00
jmp 0x1c09de
movq %rax, %rbx
jmp 0x1c09f2
movq %rax, %rbx
jmp 0x1c09e8
movq %rax, %rbx
jmp 0x1c09fc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf9e00
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf9e00
leaq 0x48(%rsp), %rdi
callq 0xf8380
jmp 0x1c0a0b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_mark.cpp
|
Omega_h::symms_inria2osh(int, Omega_h::Read<double>)
|
Reals symms_inria2osh(Int dim, Reals symms) {
if (dim == 3) return symms_inria2osh_dim<3>(symms);
if (dim == 2) return symms_inria2osh_dim<2>(symms);
if (dim == 1) return symms_inria2osh_dim<1>(symms);
OMEGA_H_NORETURN(Reals());
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x1c4d99
cmpl $0x2, %esi
je 0x1c4d7c
cmpl $0x3, %esi
jne 0x1c4dc7
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd720
jmp 0x1c4db4
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf43d0
jmp 0x1c4db4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf3e40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x101ea0
movq %r14, %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0xb22ba(%rip), %rdi # 0x277088
leaq 0xb2a20(%rip), %rsi # 0x2777f5
leaq 0xbacff(%rip), %rdx # 0x27fadb
pushq $0x6a
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x1c4e02
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1c4e02
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::repeat_symm<3>(int, Omega_h::Matrix<3, 3>)
|
Reals repeat_symm(LO const n, Tensor<dim> const symm) {
return repeat_vector(n, symm2vector(symm));
}
|
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm0
movsd 0x88(%rsp), %xmm1
movsd 0x90(%rsp), %xmm2
movsd 0xb0(%rsp), %xmm3
movsd %xmm0, 0x30(%rsp)
movsd %xmm2, 0x38(%rsp)
movsd %xmm3, 0x40(%rsp)
movsd %xmm1, 0x48(%rsp)
movaps 0xa0(%rsp), %xmm0
shufps $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x50(%rsp)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups 0x50(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xf1200
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::resize_symms_tmpl<2, 3>(Omega_h::Read<double>)
|
Reals resize_symms_tmpl(Reals old_symms) {
auto n = divide_no_remainder(old_symms.size(), symm_ncomps(old_dim));
Write<Real> new_symms(n * symm_ncomps(new_dim));
constexpr auto min_dim = min2(old_dim, new_dim);
auto f = OMEGA_H_LAMBDA(Int i) {
auto a = get_symm<old_dim>(old_symms, i);
auto b = zero_matrix<new_dim, new_dim>();
for (Int j = 0; j < min_dim; ++j) {
for (Int k = 0; k < min_dim; ++k) {
b[j][k] = a[j][k];
}
}
set_symm(new_symms, i, b);
};
parallel_for(n, f, "resize_symms");
return new_symms;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c517e
movq (%rdi), %rdi
jmp 0x1c5182
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0xb8320(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
imull $0x6, %ebp, %esi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xf6560
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf3e40
leaq 0xba957(%rip), %rdx # 0x27fb3c
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq 0xf7d10
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfbcb0
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x40(%rsp), %rdi
callq 0xfdc90
leaq 0x10(%rsp), %rdi
callq 0xf7c10
leaq 0x30(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5271
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x1c527b
movq %rax, %rbx
jmp 0x1c527b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x1c5285
movq %rax, %rbx
jmp 0x1c5285
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf7c10
leaq 0x30(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)
|
Reals matrices_times_vectors_dim(Reals ms, Reals vs) {
auto n = divide_no_remainder(vs.size(), dim);
OMEGA_H_CHECK(ms.size() == n * matrix_ncomps(dim, dim));
auto out = Write<Real>(n * dim);
auto f = OMEGA_H_LAMBDA(LO i) {
set_vector(out, i, get_matrix<dim, dim>(ms, i) * get_vector<dim>(vs, i));
};
parallel_for(n, f, "matrices_times_vectors");
return out;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %r14
testb $0x1, %r14b
jne 0x1c5713
movq (%r14), %r14
jmp 0x1c5717
shrq $0x3, %r14
shrq $0x3, %r14
movq (%r12), %rax
testb $0x1, %al
jne 0x1c5728
movq (%rax), %rax
jmp 0x1c572c
shrq $0x3, %rax
shrq $0x3, %rax
cmpl %r14d, %eax
jne 0x1c57f6
leaq 0xb7d77(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %r14d, %esi
callq 0xf6560
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3e40
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0xba3d4(%rip), %rdx # 0x27fb72
leaq 0x30(%rsp), %rsi
movl %r14d, %edi
callq 0x100ff0
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfbcb0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x20(%rsp), %rdi
callq 0xfdc90
leaq 0x30(%rsp), %rdi
callq 0xf32c0
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb188b(%rip), %rdi # 0x277088
leaq 0xba345(%rip), %rsi # 0x27fb49
leaq 0xba2d0(%rip), %rdx # 0x27fadb
pushq $0x35
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
jmp 0x1c585c
movq %rax, %rbx
movq %r13, %rdi
callq 0xfdc90
jmp 0x1c5834
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5866
movq %rax, %rbx
jmp 0x1c5866
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1c5870
movq %rax, %rbx
jmp 0x1c5870
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf32c0
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::matrices_times_matrices_dim<2>(Omega_h::Read<double>, Omega_h::Read<double>)
|
Reals matrices_times_matrices_dim(Reals a, Reals b) {
auto n = divide_no_remainder(a.size(), matrix_ncomps(dim, dim));
OMEGA_H_CHECK(b.size() == n * matrix_ncomps(dim, dim));
auto out = Write<Real>(n * matrix_ncomps(dim, dim));
auto f = OMEGA_H_LAMBDA(LO i) {
set_matrix(out, i, get_matrix<dim, dim>(a, i) * get_matrix<dim, dim>(b, i));
};
parallel_for(n, f, "matrices_times_matrices");
return out;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c5a36
movq (%rdi), %rdi
jmp 0x1c5a3a
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x4
popq %rsi
callq 0xfd130
movl %eax, %r12d
movq (%r14), %r13
testb $0x1, %r13b
jne 0x1c5a58
movq (%r13), %r13
jmp 0x1c5a5c
shrq $0x3, %r13
shrq $0x3, %r13
leal (,%r12,4), %eax
cmpl %r13d, %eax
jne 0x1c5b2e
leaq 0xb7a3f(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %r13d, %esi
callq 0xf6560
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3e40
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0xba0db(%rip), %rdx # 0x27fbb1
leaq 0x30(%rsp), %rsi
movl %r12d, %edi
callq 0xf7a90
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xfbcb0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x20(%rsp), %rdi
callq 0xfdc90
leaq 0x30(%rsp), %rdi
callq 0xf2110
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xb1553(%rip), %rdi # 0x277088
leaq 0xba04d(%rip), %rsi # 0x27fb89
leaq 0xb9f98(%rip), %rdx # 0x27fadb
pushq $0x48
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5b94
movq %rax, %rbx
movq %r13, %rdi
callq 0xfdc90
jmp 0x1c5b6c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5b9e
movq %rax, %rbx
jmp 0x1c5b9e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1c5ba8
movq %rax, %rbx
jmp 0x1c5ba8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf2110
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::symms_inria2osh_dim<2>(Omega_h::Read<double>)
|
Reals symms_inria2osh_dim(Reals symms) {
auto n = divide_no_remainder(symms.size(), symm_ncomps(dim));
Write<Real> out(symms.size());
auto f = OMEGA_H_LAMBDA(LO i) {
auto iv = get_vector<symm_ncomps(dim)>(symms, i);
auto is = vector2symm_inria(iv);
auto ov = symm2vector(is);
set_vector(out, i, ov);
};
parallel_for(n, f);
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x1c5e94
movq (%rdi), %rdi
jmp 0x1c5e98
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
movq (%r14), %r15
testb $0x1, %r15b
jne 0x1c5eb4
movq (%r15), %r15
jmp 0x1c5eb8
shrq $0x3, %r15
leaq 0xb75f8(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
shrq $0x3, %r15
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %r15d, %esi
callq 0xf6560
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf3e40
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
callq 0xf9b30
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfbcb0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x8(%rsp), %rdi
callq 0xef610
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5f98
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfdc90
jmp 0x1c5fa2
movq %rax, %rbx
jmp 0x1c5fa2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1c5fac
movq %rax, %rbx
jmp 0x1c5fac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xef610
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>)
|
Reals symms_inria2osh_dim(Reals symms) {
auto n = divide_no_remainder(symms.size(), symm_ncomps(dim));
Write<Real> out(symms.size());
auto f = OMEGA_H_LAMBDA(LO i) {
auto iv = get_vector<symm_ncomps(dim)>(symms, i);
auto is = vector2symm_inria(iv);
auto ov = symm2vector(is);
set_vector(out, i, ov);
};
parallel_for(n, f);
return out;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1c5fdb
movq (%r12), %r12
movq %r12, %r14
shrq $0x3, %r14
jmp 0x1c5fe6
movq %r12, %r14
shrq $0x6, %r14
shrq $0x3, %r12
leaq 0xb74ca(%rip), %rsi # 0x27d4b7
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
shrq $0x3, %r12
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl %r12d, %esi
callq 0xf6560
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf3e40
leaq 0x8(%rsp), %rsi
movl %r14d, %edi
callq 0xedaa0
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfbcb0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x8(%rsp), %rdi
callq 0xfaa80
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfdc90
jmp 0x1c60c8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfdc90
jmp 0x1c60d2
movq %rax, %rbx
jmp 0x1c60d2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1c60dc
movq %rax, %rbx
jmp 0x1c60dc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfaa80
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_matrix.cpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_times_vectors_dim<1>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1c73aa
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x14a96d(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xef900
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rdx
movslq %ebp, %rsi
movslq %ebx, %rdi
cmpq %rsi, %rdi
je 0x1c7396
movsd (%rcx,%rsi,8), %xmm0
mulsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
jmp 0x1c737d
leaq 0x8(%rsp), %rdi
callq 0xf32c0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>)::'lambda'(int)&>(int, Omega_h::Read<double> Omega_h::symms_inria2osh_dim<1>(Omega_h::Read<double>)::'lambda'(int)&)
|
void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
}
|
pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xaf8c7(%rip), %rsi # 0x277a4b
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0xaf0fb(%rip), %rdx # 0x277295
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xed920
leaq 0x8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xf4ff0
movq 0x68(%rsp), %rsi
leaq 0xaf868(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x48(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
callq 0xf00f0
xorl %edi, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xfc920
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1c8271
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x1c8244
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1c8253
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf00f0
jmp 0x1c8262
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x1c8271
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_to_symms_dim<1>(Omega_h::Read<double>)::'lambda'(int)&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::matrices_to_symms_dim<1>(Omega_h::Read<double>)::'lambda'(int)&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1c8fdf
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x148d2f(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xffd10
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movslq %ebp, %rdx
movslq %ebx, %rsi
cmpq %rdx, %rsi
je 0x1c8fcb
movsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x1c8fb7
leaq 0x8(%rsp), %rdi
callq 0xeecc0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
Omega_h::Mesh::ask_qualities()
|
Reals Mesh::ask_qualities() {
if (!has_tag(dim(), "quality")) {
auto qualities = measure_qualities(this);
add_tag(dim(), "quality", 1, qualities);
}
return get_array<Real>(dim(), "quality");
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfe5f0
movl %eax, %ebp
leaq 0xaf1f5(%rip), %rsi # 0x27a488
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xef870
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0xf6400
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0xf00f0
testb %bpl, %bpl
jne 0x1cb336
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf1a50
movq %r14, %rdi
callq 0xfe5f0
movl %eax, %ebp
leaq 0xaf1a8(%rip), %rsi # 0x27a488
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3e40
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
leaq 0x40(%rsp), %r8
movq %r14, %rdi
movl %ebp, %esi
xorl %r9d, %r9d
callq 0xf5a90
leaq 0x40(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %r14, %rdi
callq 0xfe5f0
movl %eax, %ebp
leaq 0xaf141(%rip), %rsi # 0x27a488
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xef870
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xf1f50
leaq 0x20(%rsp), %rdi
callq 0xf00f0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xfdc90
jmp 0x1cb390
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x1cb3a1
jmp 0x1cb39e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x1cb3c3
jmp 0x1cb3b1
jmp 0x1cb3c0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x1cb3c3
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_mesh.cpp
|
Omega_h::Mesh::set_parting(Omega_h_Parting, int, bool)
|
void Mesh::set_parting(Omega_h_Parting parting_in, Int nlayers, bool verbose) {
if (verbose && comm_->rank() == 0) {
std::cout << "going to ";
switch (parting_in) {
case OMEGA_H_ELEM_BASED:
std::cout << "element based";
break;
case OMEGA_H_VERT_BASED:
std::cout << "vertex based";
break;
case OMEGA_H_GHOSTED:
std::cout << "ghosted (" << nlayers << " layers)";
break;
}
std::cout << " partitioning\n";
}
if (parting_ == -1) {
parting_ = parting_in;
nghost_layers_ = nlayers;
return;
}
if (parting_ == parting_in && nghost_layers_ == nlayers) {
return;
}
if (parting_in == OMEGA_H_ELEM_BASED) {
OMEGA_H_CHECK(nlayers == 0);
if (comm_->size() > 1) partition_by_elems(this, verbose);
} else if (parting_in == OMEGA_H_GHOSTED) {
if (parting_ != OMEGA_H_GHOSTED || nlayers < nghost_layers_) {
set_parting(OMEGA_H_ELEM_BASED, 0, false);
}
if (comm_->size() > 1) ghost_mesh(this, nlayers, verbose);
} else if (parting_in == OMEGA_H_VERT_BASED) {
OMEGA_H_CHECK(nlayers == 1);
if (comm_->size() > 1) partition_by_verts(this, verbose);
}
parting_ = parting_in;
nghost_layers_ = nlayers;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0x1cbec8
movq 0x8(%r14), %rdi
callq 0xf0630
testl %eax, %eax
jne 0x1cbec8
movq 0x145ee9(%rip), %rdi # 0x311d38
leaq 0xb4240(%rip), %rsi # 0x280096
callq 0xf68a0
cmpl $0x2, %ebp
je 0x1cbea2
cmpl $0x1, %ebp
je 0x1cbe79
testl %ebp, %ebp
jne 0x1cbeb5
movq 0x145ec8(%rip), %rdi # 0x311d38
leaq 0xb4229(%rip), %rsi # 0x2800a0
jmp 0x1cbeb0
movq 0x145eb8(%rip), %rdi # 0x311d38
leaq 0xb4234(%rip), %rsi # 0x2800bb
callq 0xf68a0
movq %rax, %rdi
movl %ebx, %esi
callq 0xfed90
leaq 0xb4228(%rip), %rsi # 0x2800c5
movq %rax, %rdi
jmp 0x1cbeb0
movq 0x145e8f(%rip), %rdi # 0x311d38
leaq 0xb41fe(%rip), %rsi # 0x2800ae
callq 0xf68a0
movq 0x145e7c(%rip), %rdi # 0x311d38
leaq 0xb420b(%rip), %rsi # 0x2800ce
callq 0xf68a0
movl 0x18(%r14), %eax
cmpl $-0x1, %eax
je 0x1cbf7c
movl %eax, %edx
xorl %ebp, %edx
movl 0x1c(%r14), %ecx
movl %ecx, %esi
xorl %ebx, %esi
orl %edx, %esi
je 0x1cbf84
cmpl $0x2, %ebp
je 0x1cbf5d
cmpl $0x1, %ebp
je 0x1cbf1f
testl %ebp, %ebp
jne 0x1cbf7c
testl %ebx, %ebx
jne 0x1cbfab
movq 0x8(%r14), %rdi
callq 0xfa970
cmpl $0x2, %eax
jl 0x1cbf7c
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x101470
jmp 0x1cbf7c
cmpl $0x1, %eax
setne %al
cmpl %ebx, %ecx
setg %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1cbf3f
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xf03b0
movq 0x8(%r14), %rdi
callq 0xfa970
cmpl $0x2, %eax
jl 0x1cbf7c
movzbl %r15b, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0xfe910
jmp 0x1cbf7c
cmpl $0x1, %ebx
jne 0x1cbf8f
movq 0x8(%r14), %rdi
callq 0xfa970
cmpl $0x2, %eax
jl 0x1cbf7c
movzbl %r15b, %esi
movq %r14, %rdi
callq 0xf41d0
movl %ebp, 0x18(%r14)
movl %ebx, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xab0f2(%rip), %rdi # 0x277088
leaq 0xb414d(%rip), %rsi # 0x2800ea
leaq 0xb3d20(%rip), %rdx # 0x27fcc4
movl $0x208, %ecx # imm = 0x208
jmp 0x1cbfc5
leaq 0xab0d6(%rip), %rdi # 0x277088
leaq 0xb4124(%rip), %rsi # 0x2800dd
leaq 0xb3d04(%rip), %rdx # 0x27fcc4
movl $0x200, %ecx # imm = 0x200
xorl %eax, %eax
callq 0xf6ee0
|
/gahansen[P]omega_h/src/Omega_h_mesh.cpp
|
Omega_h::Mesh::imbalance(int) const
|
Real Mesh::imbalance(Int ent_dim) const {
if (ent_dim == -1) ent_dim = dim();
auto local = Real(nents(ent_dim));
auto s = comm_->allreduce(local, OMEGA_H_SUM);
if (s == 0.0) return 1.0;
auto m = comm_->allreduce(local, OMEGA_H_MAX);
auto n = comm_->size();
auto a = s / n;
return m / a;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x1cda95
movq %rbx, %rdi
callq 0xfe5f0
movl %eax, %esi
movq %rbx, %rdi
callq 0xf0100
cvtsi2sd %eax, %xmm0
movq 0x8(%rbx), %rdi
pushq $0x2
popq %rsi
movsd %xmm0, (%rsp)
callq 0xf3800
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1cdacc
jp 0x1cdacc
movsd 0xa957e(%rip), %xmm0 # 0x277048
jmp 0x1cdb08
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
movsd (%rsp), %xmm0
movsd %xmm1, (%rsp)
callq 0xf3800
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
callq 0xfa970
cvtsi2sd %eax, %xmm0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
|
/gahansen[P]omega_h/src/Omega_h_mesh.cpp
|
Omega_h::get_all_mesh_tags[abi:cxx11](Omega_h::Mesh*)
|
TagSet get_all_mesh_tags(Mesh* mesh) {
TagSet out;
for (Int i = 0; i <= mesh->dim(); ++i) {
for (Int j = 0; j < mesh->ntags(i); ++j) {
auto tagbase = mesh->get_tag(i, j);
out[size_t(i)].insert(tagbase->name());
}
}
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf7c90
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xfe5f0
cltq
cmpq %rax, %r15
jg 0x1ce4e6
imulq $0x30, %r15, %r12
addq %rbx, %r12
xorl %ebp, %ebp
movq %r14, %rdi
movl %r15d, %esi
callq 0xf4870
cmpl %eax, %ebp
jge 0x1ce4e1
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xfa760
movq %rax, %rdi
callq 0xf5eb0
movq %r12, %rdi
movq %rax, %rsi
callq 0xfd270
incl %ebp
jmp 0x1ce4ae
incq %r15
jmp 0x1ce496
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ce4f6
jmp 0x1ce4f6
movq %rax, %r14
movq %rbx, %rdi
callq 0xf95f0
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_mesh.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.