idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
9,100 | Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e);
lengths[a] = measurer.measure(v);
};
parallel_for(na, f, "measure_edges");
return lengths;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rsi, %rax
movq -0x158(%rbp), %rsi
movq %rdi, -0x150(%rbp)
movq %rdi, %rcx
movq %rcx, -0x148(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1cae10
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x1cc9b0
jmp 0x5497f8
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x549818
movq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54985e
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x549870
movq -0x168(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x174(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1dfbb0
movq -0x170(%rbp), %rdx
leaq 0xe7ad4(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x5498b9
movl -0x174(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1cd090
jmp 0x5498d4
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x160(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d99b0
jmp 0x549908
leaq -0x110(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x549924
leaq -0x100(%rbp), %rdi
movq %rdi, -0x190(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x1c7e70
jmp 0x549940
leaq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1bc440
jmp 0x549952
movl -0x94(%rbp), %edi
leaq 0xecb22(%rip), %rdx # 0x636481
leaq -0x120(%rbp), %rsi
callq 0x1bee60
jmp 0x54996d
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d8720
jmp 0x549982
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1ccda0
jmp 0x549997
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8200
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1e2850
movq -0x148(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x549af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549aeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549a31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x549adf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549ad3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549a93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549a87
movq -0x190(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dc900
movq -0x188(%rbp), %rdi
callq 0x1c7d90
movq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x549ad3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549ac7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8200
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1e2850
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,101 | Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e);
lengths[a] = measurer.measure(v);
};
parallel_for(na, f, "measure_edges");
return lengths;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rsi, %rax
movq -0x158(%rbp), %rsi
movq %rdi, -0x150(%rbp)
movq %rdi, %rcx
movq %rcx, -0x148(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1cae10
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x1b95a0
jmp 0x549b78
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x549b98
movq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x549bde
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x549bf0
movq -0x168(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x174(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1dfbb0
movq -0x170(%rbp), %rdx
leaq 0xe7754(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x549c39
movl -0x174(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1cd090
jmp 0x549c54
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x160(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d99b0
jmp 0x549c88
leaq -0x110(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x549ca4
leaq -0x100(%rbp), %rdi
movq %rdi, -0x190(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x1c7e70
jmp 0x549cc0
leaq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1df160
jmp 0x549cd2
movl -0x94(%rbp), %edi
leaq 0xec7a2(%rip), %rdx # 0x636481
leaq -0x120(%rbp), %rsi
callq 0x1d9a20
jmp 0x549ced
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d8720
jmp 0x549d02
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1ccda0
jmp 0x549d17
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1b8480
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1bd700
movq -0x148(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x549e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549e6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549db1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x549e5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549e53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549e07
movq -0x190(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dc900
movq -0x188(%rbp), %rdi
callq 0x1c7d90
movq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x549e53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x549e47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1b8480
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1bd700
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,102 | Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e);
lengths[a] = measurer.measure(v);
};
parallel_for(na, f, "measure_edges");
return lengths;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rsi, %rax
movq -0x158(%rbp), %rsi
movq %rdi, -0x150(%rbp)
movq %rdi, %rcx
movq %rcx, -0x148(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1cae10
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x1c30a0
jmp 0x549ef8
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x549f18
movq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x549f5e
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x549f70
movq -0x168(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x174(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1dfbb0
movq -0x170(%rbp), %rdx
leaq 0xe73d4(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x549fb9
movl -0x174(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1cd090
jmp 0x549fd4
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x160(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d99b0
jmp 0x54a008
leaq -0x110(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x54a024
leaq -0x100(%rbp), %rdi
movq %rdi, -0x190(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x1c7e70
jmp 0x54a040
leaq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1dcfa0
jmp 0x54a052
movl -0x94(%rbp), %edi
leaq 0xec422(%rip), %rdx # 0x636481
leaq -0x120(%rbp), %rsi
callq 0x1ce750
jmp 0x54a06d
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d8720
jmp 0x54a082
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1ccda0
jmp 0x54a097
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1dbdf0
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1e20f0
movq -0x148(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54a1f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a1eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a131
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x54a1df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a1d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a187
movq -0x190(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dc900
movq -0x188(%rbp), %rdi
callq 0x1c7d90
movq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x54a1d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a1c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1dbdf0
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1e20f0
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,103 | Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e);
lengths[a] = measurer.measure(v);
};
parallel_for(na, f, "measure_edges");
return lengths;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rsi, %rax
movq -0x158(%rbp), %rsi
movq %rdi, -0x150(%rbp)
movq %rdi, %rcx
movq %rcx, -0x148(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1cae10
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x1d6550
jmp 0x54a278
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x54a298
movq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54a2de
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54a2f0
movq -0x168(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x174(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1dfbb0
movq -0x170(%rbp), %rdx
leaq 0xe7054(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54a339
movl -0x174(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1cd090
jmp 0x54a354
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x160(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d99b0
jmp 0x54a388
leaq -0x110(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x54a3a4
leaq -0x100(%rbp), %rdi
movq %rdi, -0x190(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x1c7e70
jmp 0x54a3c0
leaq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1be850
jmp 0x54a3d2
movl -0x94(%rbp), %edi
leaq 0xec0a2(%rip), %rdx # 0x636481
leaq -0x120(%rbp), %rsi
callq 0x1d7260
jmp 0x54a3ed
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d8720
jmp 0x54a402
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1ccda0
jmp 0x54a417
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8230
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1de5b0
movq -0x148(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54a574
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a56b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a4b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x54a55f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a553
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a513
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a507
movq -0x190(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dc900
movq -0x188(%rbp), %rdi
callq 0x1c7d90
movq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x54a553
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a547
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8230
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1de5b0
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,104 | Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_edges_metric_tmpl(Mesh* mesh, LOs a2e, Reals metrics) {
MetricEdgeLengths<mesh_dim, metric_dim> measurer(mesh, metrics);
auto ev2v = mesh->ask_verts_of(EDGE);
auto na = a2e.size();
Write<Real> lengths(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<2>(ev2v, e);
lengths[a] = measurer.measure(v);
};
parallel_for(na, f, "measure_edges");
return lengths;
} | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rcx, -0x158(%rbp)
movq %rdx, -0x160(%rbp)
movq %rsi, %rax
movq -0x158(%rbp), %rsi
movq %rdi, -0x150(%rbp)
movq %rdi, %rcx
movq %rcx, -0x148(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1cae10
movq -0x140(%rbp), %rsi
movq -0x138(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x1d6d90
jmp 0x54a5f8
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x54a618
movq -0x160(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x168(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54a65e
movq -0x168(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54a670
movq -0x168(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %eax
movl %eax, -0x174(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x1dfbb0
movq -0x170(%rbp), %rdx
leaq 0xe6cd4(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54a6b9
movl -0x174(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1cd090
jmp 0x54a6d4
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
movq -0x160(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1d99b0
jmp 0x54a708
leaq -0x110(%rbp), %rdi
movq %rdi, -0x188(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x1d99b0
jmp 0x54a724
leaq -0x100(%rbp), %rdi
movq %rdi, -0x190(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x1c7e70
jmp 0x54a740
leaq -0xf0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c1640
jmp 0x54a752
movl -0x94(%rbp), %edi
leaq 0xebd22(%rip), %rdx # 0x636481
leaq -0x120(%rbp), %rsi
callq 0x1c6170
jmp 0x54a76d
leaq -0x130(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d8720
jmp 0x54a782
movq -0x150(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0x1ccda0
jmp 0x54a797
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8990
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1cd920
movq -0x148(%rbp), %rax
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54a8f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a8eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a831
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x54a8df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a8d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a887
movq -0x190(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dc900
movq -0x188(%rbp), %rdi
callq 0x1c7d90
movq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x54a8d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x54a8c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1dc900
leaq -0x120(%rbp), %rdi
callq 0x1d8990
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1cd920
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,105 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xebac6(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54a969
leaq 0xe0905(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54a985
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54a998
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54a9b1
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xebacb(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54a9cf
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54aa1d
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54aa32
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x3, %edx
callq 0x1c74e0
jmp 0x54aa55
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54aa9b
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54aaad
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe6897(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54aaf6
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54ab11
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54ab45
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54ab61
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54ab7d
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54ab92
movl -0x114(%rbp), %edi
leaq 0xeb907(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1c57b0
jmp 0x54abad
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54abc2
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54abd7
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c89f0
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54acbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54acaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54aca3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ac97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54ae42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ae39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54ae39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ae2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ad4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54ae21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ae15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54adc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54adbd
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54ae15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54ae09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c89f0
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,106 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xeb576(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54aeb9
leaq 0xe03b5(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54aed5
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54aee8
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54af01
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xeb57b(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54af1f
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54af6d
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54af82
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x2, %edx
callq 0x1c74e0
jmp 0x54afa5
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54afeb
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54affd
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe6347(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54b046
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54b061
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54b095
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54b0b1
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54b0cd
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54b0e2
movl -0x114(%rbp), %edi
leaq 0xeb3b7(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1df440
jmp 0x54b0fd
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54b112
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54b127
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1baf80
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b20b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b1ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b1f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b1e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54b392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b389
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54b389
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b37d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b29f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54b371
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b365
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b319
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b30d
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54b365
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1baf80
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,107 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xeb026(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54b409
leaq 0xdfe65(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54b425
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54b438
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54b451
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xeb02b(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54b46f
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54b4bd
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54b4d2
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x54b4f5
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54b53b
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54b54d
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe5df7(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54b596
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54b5b1
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54b5e5
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54b601
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54b61d
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54b632
movl -0x114(%rbp), %edi
leaq 0xeae67(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1b8620
jmp 0x54b64d
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54b662
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54b677
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1dd410
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b75b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b74f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b737
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54b8e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b8d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54b8d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b8cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b7ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54b8c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b8b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b869
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b85d
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54b8b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54b8a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1dd410
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,108 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xeaad6(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54b959
leaq 0xdf915(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54b975
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54b988
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54b9a1
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xeaadb(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54b9bf
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54ba0d
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54ba22
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x2, %edx
callq 0x1c74e0
jmp 0x54ba45
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54ba8b
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54ba9d
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe58a7(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54bae6
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54bb01
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54bb35
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54bb51
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54bb6d
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54bb82
movl -0x114(%rbp), %edi
leaq 0xea917(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1c9710
jmp 0x54bb9d
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54bbb2
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54bbc7
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c5890
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bcab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bc9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bc93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bc87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54be32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54be29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54be29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54be1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bd3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54be11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54be05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bdb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bdad
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54be05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54bdf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c5890
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,109 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xea586(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54bea9
leaq 0xdf3c5(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54bec5
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54bed8
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54bef1
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xea58b(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54bf0f
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54bf5d
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54bf72
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x54bf95
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54bfdb
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54bfed
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe5357(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54c036
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54c051
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54c085
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54c0a1
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54c0bd
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54c0d2
movl -0x114(%rbp), %edi
leaq 0xea3c7(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1de8f0
jmp 0x54c0ed
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54c102
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54c117
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1d9d10
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c1fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c1ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c1e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c1d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54c382
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54c379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c36d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c28f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54c361
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c2fd
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54c355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c349
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1d9d10
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,110 | Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>) | Reals measure_ents_real_tmpl(Mesh* mesh, LOs a2e, Reals coords) {
OMEGA_H_TIME_FUNCTION;
RealSimplexSizes measurer(coords);
auto ev2v = mesh->ask_verts_of(edim);
auto na = a2e.size();
Write<Real> sizes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto e = a2e[a];
auto v = gather_verts<edim + 1>(ev2v, e);
sizes[a] = measurer.measure<sdim, edim>(v);
};
parallel_for(na, f, "measure_ents_real");
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rcx, -0x1c8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1dfbb0
movq -0x1a8(%rbp), %rdx
leaq 0xea036(%rip), %rsi # 0x636421
leaq -0xa8(%rbp), %rdi
callq 0x1d5e00
jmp 0x54c3f9
leaq 0xdee75(%rip), %rdx # 0x62b275
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bb5a0
jmp 0x54c415
leaq -0xe0(%rbp), %rdi
movl $0x35, %esi
callq 0x1d4960
jmp 0x54c428
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x1ca480
jmp 0x54c441
leaq -0x68(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xea03b(%rip), %rsi # 0x63648f
leaq -0x41(%rbp), %rdi
callq 0x1dc4d0
jmp 0x54c45f
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
movq -0x1c8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x1cae10
jmp 0x54c4ad
leaq -0xf0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1c09f0
jmp 0x54c4c2
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
movq -0x30(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movl $0x1, %edx
callq 0x1c74e0
jmp 0x54c4e5
movq -0x1c0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x54c52b
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x54c53d
movq -0x1d0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %eax
movl %eax, -0x1dc(%rbp)
leaq -0x149(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x1dfbb0
movq -0x1d8(%rbp), %rdx
leaq 0xe4e07(%rip), %rsi # 0x63137f
leaq -0x148(%rbp), %rdi
callq 0x1d5e00
jmp 0x54c586
movl -0x1dc(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x1cd090
jmp 0x54c5a1
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x1d99b0
jmp 0x54c5d5
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
leaq -0x110(%rbp), %rsi
callq 0x1d99b0
jmp 0x54c5f1
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
leaq -0x128(%rbp), %rsi
callq 0x1c7e70
jmp 0x54c60d
leaq -0x160(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x1d8610
jmp 0x54c622
movl -0x114(%rbp), %edi
leaq 0xe9e77(%rip), %rdx # 0x6364a6
leaq -0x190(%rbp), %rsi
callq 0x1dc7c0
jmp 0x54c63d
leaq -0x1a0(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1d8720
jmp 0x54c652
movq -0x1b8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1ccda0
jmp 0x54c667
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c4790
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0x1b0(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c74b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c73f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c733
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c727
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0xe0(%rbp), %rdi
callq 0x1c4d10
leaq -0x88(%rbp), %rdi
callq 0x1c4d10
leaq -0xa8(%rbp), %rdi
callq 0x1c4d10
leaq -0xa9(%rbp), %rdi
callq 0x1cf450
jmp 0x54c8d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c8c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1e0ab0
jmp 0x54c8c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c8bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c7df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x1c4d10
leaq -0x149(%rbp), %rdi
callq 0x1cf450
jmp 0x54c8b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c8a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c84d
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x1dc900
movq -0x1f0(%rbp), %rdi
callq 0x1c7d90
movq -0x1e8(%rbp), %rdi
callq 0x1c7d90
jmp 0x54c8a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x54c899
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1dc900
leaq -0x190(%rbp), %rdi
callq 0x1c4790
leaq -0x128(%rbp), %rdi
callq 0x1dc900
leaq -0x110(%rbp), %rdi
callq 0x1c7d90
leaq -0xf0(%rbp), %rdi
callq 0x1e2810
leaq -0x41(%rbp), %rdi
callq 0x1d03d0
movq -0xb8(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.cpp |
9,111 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1dd260
movq -0xa8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x1c8580
jmp 0x54c968
leaq -0x88(%rbp), %rdi
callq 0x1d8200
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1d8200
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,112 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x54cb08
jmp 0x54cba9
movq 0x1ab179(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1d1a80
movq 0x1ab15f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x54cb9d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x1d81d0
jmp 0x54cb66
jmp 0x54cb68
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x54cb2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1d8200
jmp 0x54cbb2
leaq -0x90(%rbp), %rdi
callq 0x1d8200
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,113 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1c24b0
movq -0xa8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x1de840
jmp 0x54ea58
leaq -0x88(%rbp), %rdi
callq 0x1b8480
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1b8480
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,114 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x54ebf8
jmp 0x54ec99
movq 0x1a9089(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1c4f70
movq 0x1a906f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x54ec8d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x1bb900
jmp 0x54ec56
jmp 0x54ec58
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x54ec1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1b8480
jmp 0x54eca2
leaq -0x90(%rbp), %rdi
callq 0x1b8480
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,115 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1de640
movq -0xa8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x1c7fd0
jmp 0x550998
leaq -0x88(%rbp), %rdi
callq 0x1dbdf0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1dbdf0
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,116 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x550b38
jmp 0x550bd9
movq 0x1a7149(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1e12e0
movq 0x1a712f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x550bcd
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x1bce60
jmp 0x550b96
jmp 0x550b98
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x550b5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1dbdf0
jmp 0x550be2
leaq -0x90(%rbp), %rdi
callq 0x1dbdf0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,117 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1bd5d0
movq -0xa8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x1db610
jmp 0x552108
leaq -0x88(%rbp), %rdi
callq 0x1d8230
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1d8230
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,118 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x5522a8
jmp 0x552349
movq 0x1a59d9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1cc4e0
movq 0x1a59bf(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x55233d
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x1c76b0
jmp 0x552306
jmp 0x552308
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5522cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1d8230
jmp 0x552352
leaq -0x90(%rbp), %rdi
callq 0x1d8230
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,119 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1e1560
movq -0xa8(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x8c(%rbp), %edi
movl -0x90(%rbp), %esi
callq 0x1d0bf0
jmp 0x553788
leaq -0x88(%rbp), %rdi
callq 0x1d8990
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1d8990
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,120 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_edges_metric_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x553928
jmp 0x5539c9
movq 0x1a4359(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1d2430
movq 0x1a433f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5539bd
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x1dbbd0
jmp 0x553986
jmp 0x553988
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x55394c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1d8990
jmp 0x5539d2
leaq -0x90(%rbp), %rdi
callq 0x1d8990
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,121 | Omega_h::RealSimplexSizes::RealSimplexSizes(Omega_h::Read<double>) | RealSimplexSizes(Reals coords_in) : coords(coords_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cae10
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.hpp |
9,122 | Omega_h::RealSimplexSizes::RealSimplexSizes(Omega_h::RealSimplexSizes const&) | RealSimplexSizes(Reals coords_in) : coords(coords_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cae10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.hpp |
9,123 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c2b00
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1d9560
jmp 0x555029
leaq -0x78(%rbp), %rdi
callq 0x1c89f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c89f0
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,124 | Omega_h::RealSimplexSizes::~RealSimplexSizes() | RealSimplexSizes(Reals coords_in) : coords(coords_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e0ab0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.hpp |
9,125 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 3>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x5551e8
jmp 0x55527d
movq 0x1a2a99(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1bdd20
movq 0x1a2a82(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x555274
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1c5190
jmp 0x555240
jmp 0x555242
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x555209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c89f0
jmp 0x555286
leaq -0x80(%rbp), %rdi
callq 0x1c89f0
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,126 | Omega_h::RealSimplexSizes::RealSimplexSizes(Omega_h::RealSimplexSizes&&) | RealSimplexSizes(Reals coords_in) : coords(coords_in) {} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e4220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shape.hpp |
9,127 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1bf8a0
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1b8040
jmp 0x556109
leaq -0x78(%rbp), %rdi
callq 0x1baf80
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1baf80
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,128 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x5562a8
jmp 0x55633d
movq 0x1a19d9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1c1120
movq 0x1a19c2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x556334
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1b9490
jmp 0x556300
jmp 0x556302
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5562c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1baf80
jmp 0x556346
leaq -0x80(%rbp), %rdi
callq 0x1baf80
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,129 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c2720
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1d4df0
jmp 0x5572c9
leaq -0x78(%rbp), %rdi
callq 0x1dd410
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1dd410
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,130 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<3, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x557468
jmp 0x5574fd
movq 0x1a0819(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1e2fb0
movq 0x1a0802(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x5574f4
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1c5340
jmp 0x5574c0
jmp 0x5574c2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x557489
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1dd410
jmp 0x557506
leaq -0x80(%rbp), %rdi
callq 0x1dd410
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,131 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1ca870
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1dad80
jmp 0x557ff9
leaq -0x78(%rbp), %rdi
callq 0x1c5890
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c5890
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,132 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 2>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x558198
jmp 0x55822d
movq 0x19fae9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1d6c30
movq 0x19fad2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x558224
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1d2210
jmp 0x5581f0
jmp 0x5581f2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5581b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c5890
jmp 0x558236
leaq -0x80(%rbp), %rdi
callq 0x1c5890
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,133 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c57a0
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1ceb20
jmp 0x558d09
leaq -0x78(%rbp), %rdi
callq 0x1d9d10
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1d9d10
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,134 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<2, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x558ea8
jmp 0x558f3d
movq 0x19edd9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1d8a40
movq 0x19edc2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x558f34
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1db930
jmp 0x558f00
jmp 0x558f02
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x558ec9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1d9d10
jmp 0x558f46
leaq -0x80(%rbp), %rdi
callq 0x1d9d10
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,135 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(int, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int) const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c5a20
movq -0x98(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
callq 0x1c68f0
jmp 0x5599d9
leaq -0x78(%rbp), %rdi
callq 0x1c4790
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c4790
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,136 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::Read<double> Omega_h::measure_ents_real_tmpl<1, 1>(Omega_h::Mesh*, Omega_h::Read<int>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x559b78
jmp 0x559c0d
movq 0x19e109(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1c8400
movq 0x19e0f2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
je 0x559c04
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x80(%rbp), %rdi
callq 0x1b9b70
jmp 0x559bd0
jmp 0x559bd2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x559b99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4790
jmp 0x559c16
leaq -0x80(%rbp), %rdi
callq 0x1c4790
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,137 | Omega_h::start_tracking_allocations() | void start_tracking_allocations() {
OMEGA_H_CHECK(global_allocs == nullptr);
global_allocs = new Allocs();
global_allocs->first = nullptr;
global_allocs->last = nullptr;
global_allocs->total_bytes = 0;
global_allocs->high_water_bytes = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x19d6f9(%rip), %rax # 0x6f7a48
cmpq $0x0, (%rax)
jne 0x55a357
jmp 0x55a378
leaq 0xd0d0a(%rip), %rdi # 0x62b068
leaq 0xdc153(%rip), %rsi # 0x6364b8
leaq 0xdc165(%rip), %rdx # 0x6364d1
movl $0xe, %ecx
movb $0x0, %al
callq 0x1ce550
movl $0x38, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, -0x8(%rbp)
xorl %esi, %esi
movl $0x38, %edx
callq 0x1c2d80
movq -0x8(%rbp), %rdi
callq 0x1e2f20
movq -0x8(%rbp), %rcx
movq 0x19d69f(%rip), %rax # 0x6f7a48
movq %rcx, (%rax)
movq 0x19d695(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq $0x0, (%rax)
movq 0x19d684(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq 0x19d672(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x19d660(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,138 | Omega_h::stop_tracking_allocations(Omega_h::Library*) | void stop_tracking_allocations(Library* lib) {
OMEGA_H_CHECK(global_allocs != nullptr);
auto comm = lib->world();
auto mpi_high_water_bytes =
comm->allreduce(I64(global_allocs->high_water_bytes), OMEGA_H_MAX);
auto candidate_rank =
(I64(global_allocs->high_water_bytes) == mpi_high_water_bytes)
? comm->rank()
: comm->size();
auto winner_rank = comm->allreduce(candidate_rank, OMEGA_H_MIN);
if (comm->rank() == winner_rank) {
std::stringstream ss;
ss << "MPI rank " << comm->rank()
<< " had the highest memory high water mark.\n";
ss << "The high water memory usage was " << global_allocs->high_water_bytes
<< " bytes, allocated as follows:\n";
for (auto& rec : global_allocs->high_water_records) {
ss << rec.name << ": " << rec.bytes << " bytes.\n";
}
auto s = ss.str();
std::printf("%s\n", s.c_str());
}
delete global_allocs;
global_allocs = nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movq 0x19d632(%rip), %rax # 0x6f7a48
cmpq $0x0, (%rax)
je 0x55a41e
jmp 0x55a43f
leaq 0xd0c43(%rip), %rdi # 0x62b068
leaq 0xdc10c(%rip), %rsi # 0x636538
leaq 0xdc09e(%rip), %rdx # 0x6364d1
movl $0x17, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0x1e3770
movq -0x210(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
movq 0x19d5df(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq 0x18(%rax), %rsi
movl $0x1, %edx
callq 0x1b8750
movq %rax, -0x208(%rbp)
jmp 0x55a483
movq -0x208(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x19d5b3(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x55a4c9
leaq -0x18(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x214(%rbp)
jmp 0x55a4bb
movl -0x214(%rbp), %eax
movl %eax, -0x218(%rbp)
jmp 0x55a4f0
leaq -0x18(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
callq 0x1d60c0
movl %eax, -0x21c(%rbp)
jmp 0x55a4e2
movl -0x21c(%rbp), %eax
movl %eax, -0x218(%rbp)
jmp 0x55a4f0
movl -0x218(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
movl -0x30(%rbp), %esi
xorl %edx, %edx
callq 0x1bf8f0
movl %eax, -0x220(%rbp)
jmp 0x55a517
movl -0x220(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x224(%rbp)
jmp 0x55a539
movl -0x224(%rbp), %eax
cmpl -0x34(%rbp), %eax
jne 0x55a78c
leaq -0x1c0(%rbp), %rdi
callq 0x1c6c20
jmp 0x55a556
leaq -0x1b0(%rbp), %rdi
leaq 0xdbfed(%rip), %rsi # 0x636551
callq 0x1cd8f0
movq %rax, -0x230(%rbp)
jmp 0x55a572
leaq -0x18(%rbp), %rdi
callq 0x1d9de0
movq %rax, %rdi
callq 0x1c1090
movl %eax, -0x234(%rbp)
jmp 0x55a58b
movl -0x234(%rbp), %esi
movq -0x230(%rbp), %rdi
callq 0x1deb20
movq %rax, -0x240(%rbp)
jmp 0x55a5a6
movq -0x240(%rbp), %rdi
leaq 0xdbfa7(%rip), %rsi # 0x63655b
callq 0x1cd8f0
jmp 0x55a5bb
leaq -0x1b0(%rbp), %rdi
leaq 0xdbfbc(%rip), %rsi # 0x636585
callq 0x1cd8f0
movq %rax, -0x248(%rbp)
jmp 0x55a5d7
movq -0x248(%rbp), %rdi
movq 0x19d463(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq 0x18(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x250(%rbp)
jmp 0x55a5fa
movq -0x250(%rbp), %rdi
leaq 0xdbf9e(%rip), %rsi # 0x6365a6
callq 0x1cd8f0
jmp 0x55a60f
movq 0x19d432(%rip), %rax # 0x6f7a48
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x1c8(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x1dc520
movq %rax, -0x1d0(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x1c72c0
movq %rax, -0x1d8(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x1c4ca0
testb $0x1, %al
jne 0x55a666
jmp 0x55a718
leaq -0x1d0(%rbp), %rdi
callq 0x1da200
movq %rax, -0x1e0(%rbp)
leaq -0x1b0(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
callq 0x1cb420
movq %rax, -0x258(%rbp)
jmp 0x55a695
movq -0x258(%rbp), %rdi
leaq 0xd51ec(%rip), %rsi # 0x62f88f
callq 0x1cd8f0
movq %rax, -0x260(%rbp)
jmp 0x55a6b1
movq -0x260(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x268(%rbp)
jmp 0x55a6d1
movq -0x268(%rbp), %rdi
leaq 0xdbee6(%rip), %rsi # 0x6365c5
callq 0x1cd8f0
jmp 0x55a6e6
jmp 0x55a6e8
leaq -0x1d0(%rbp), %rdi
callq 0x1db030
jmp 0x55a64a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x55a7e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x55a77e
leaq -0x200(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x1cd640
jmp 0x55a72d
leaq -0x200(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0xd97ce(%rip), %rdi # 0x633f11
xorl %eax, %eax
callq 0x1b88f0
jmp 0x55a74c
leaq -0x200(%rbp), %rdi
callq 0x1c4d10
leaq -0x1c0(%rbp), %rdi
callq 0x1c76d0
jmp 0x55a78c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x1c4d10
leaq -0x1c0(%rbp), %rdi
callq 0x1c76d0
jmp 0x55a7e0
movq 0x19d2b5(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq %rax, -0x270(%rbp)
cmpq $0x0, %rax
je 0x55a7c0
movq -0x270(%rbp), %rdi
callq 0x1d0990
movq -0x270(%rbp), %rdi
movl $0x38, %esi
callq 0x1ce050
movq 0x19d281(%rip), %rax # 0x6f7a48
movq $0x0, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x1cb520
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x1cb520
movq -0x28(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,139 | Omega_h::Alloc::Alloc(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Alloc::Alloc(std::size_t size_in, std::string const& name_in)
: size(size_in), name(name_in) {
init();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c00c0
movq -0x30(%rbp), %rdi
callq 0x1ddcb0
jmp 0x55a83f
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c4d10
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,140 | Omega_h::Alloc::init() | void Alloc::init() {
ptr = ::Omega_h::maybe_pooled_device_malloc(size);
use_count = 1;
auto ga = global_allocs;
if (size && (ptr == nullptr)) {
std::stringstream ss;
ss << "Failed to allocate " << size << " bytes for " << name << '\n';
if (ga) {
ss << "at the time, " << ga->total_bytes
<< " total bytes were allocated as follows:\n";
for (auto a = ga->first; a; a = a->next) {
ss << a->name << ": " << a->size << " bytes\n";
}
}
auto s = ss.str();
Omega_h_fail("%s\n", s.c_str());
}
if (ga) {
auto old_last = ga->last;
this->prev = old_last;
this->next = nullptr;
if (old_last) {
old_last->next = this;
} else {
ga->first = this;
ga->last = this;
}
ga->total_bytes += size;
if (ga->total_bytes > ga->high_water_bytes) {
Omega_h::ScopedTimer high_water_timer("high water update");
ga->high_water_bytes = ga->total_bytes;
ga->high_water_records.clear();
for (auto a = ga->first; a; a = a->next) {
ga->high_water_records.push_back({a->name, a->size});
}
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x218(%rbp)
movq (%rax), %rdi
callq 0x1e1a80
movq %rax, %rcx
movq -0x218(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x1, 0x30(%rax)
movq 0x19d19a(%rip), %rcx # 0x6f7a48
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x55aade
movq -0x218(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x55aade
leaq -0x198(%rbp), %rdi
callq 0x1c6c20
leaq -0x188(%rbp), %rdi
leaq 0xdbce3(%rip), %rsi # 0x6365ce
callq 0x1cd8f0
movq %rax, -0x220(%rbp)
jmp 0x55a8f9
movq -0x220(%rbp), %rdi
movq -0x218(%rbp), %rax
movq (%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x228(%rbp)
jmp 0x55a918
movq -0x228(%rbp), %rdi
leaq 0xdbcbc(%rip), %rsi # 0x6365e2
callq 0x1cd8f0
movq %rax, -0x230(%rbp)
jmp 0x55a934
movq -0x230(%rbp), %rdi
movq -0x218(%rbp), %rsi
addq $0x8, %rsi
callq 0x1cb420
movq %rax, -0x238(%rbp)
jmp 0x55a954
movq -0x238(%rbp), %rdi
movl $0xa, %esi
callq 0x1d19c0
jmp 0x55a967
cmpq $0x0, -0x10(%rbp)
je 0x55aa7b
leaq -0x188(%rbp), %rdi
leaq 0xdbc6e(%rip), %rsi # 0x6365ee
callq 0x1cd8f0
movq %rax, -0x240(%rbp)
jmp 0x55a98e
movq -0x240(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x248(%rbp)
jmp 0x55a9ab
movq -0x248(%rbp), %rdi
leaq 0xdbc43(%rip), %rsi # 0x6365fc
callq 0x1cd8f0
jmp 0x55a9c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
cmpq $0x0, -0x1b0(%rbp)
je 0x55aa79
leaq -0x188(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
addq $0x8, %rsi
callq 0x1cb420
movq %rax, -0x250(%rbp)
jmp 0x55a9fc
movq -0x250(%rbp), %rdi
leaq 0xd4e85(%rip), %rsi # 0x62f88f
callq 0x1cd8f0
movq %rax, -0x258(%rbp)
jmp 0x55aa18
movq -0x258(%rbp), %rdi
movq -0x1b0(%rbp), %rax
movq (%rax), %rsi
callq 0x1bbaf0
movq %rax, -0x260(%rbp)
jmp 0x55aa37
movq -0x260(%rbp), %rdi
leaq 0xdbbe0(%rip), %rsi # 0x636625
callq 0x1cd8f0
jmp 0x55aa4c
jmp 0x55aa4e
movq -0x1b0(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x1b0(%rbp)
jmp 0x55a9ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x55aacd
jmp 0x55aa7b
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1cd640
jmp 0x55aa90
leaq -0x1d0(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0xd946b(%rip), %rdi # 0x633f11
xorl %eax, %eax
callq 0x1ce550
jmp 0x55aaaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1c4d10
leaq -0x198(%rbp), %rdi
callq 0x1c76d0
jmp 0x55ac8b
cmpq $0x0, -0x10(%rbp)
je 0x55ac82
movq -0x218(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x1d8(%rbp)
movq -0x1d8(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq $0x0, 0x40(%rax)
cmpq $0x0, -0x1d8(%rbp)
je 0x55ab30
movq -0x218(%rbp), %rcx
movq -0x1d8(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x55ab46
movq -0x218(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x218(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x55ac80
leaq -0x1d9(%rbp), %rdi
leaq 0xdbaad(%rip), %rsi # 0x63662d
xorl %eax, %eax
movl %eax, %edx
callq 0x1dc4d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x1c94b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1e8(%rbp)
cmpq $0x0, -0x1e8(%rbp)
je 0x55ac64
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x268(%rbp)
movq -0x1e8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x210(%rbp), %rdi
callq 0x1c00c0
jmp 0x55abea
movq -0x268(%rbp), %rdi
movq -0x1e8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x210(%rbp), %rsi
callq 0x1c7ee0
jmp 0x55ac10
leaq -0x210(%rbp), %rdi
callq 0x1e4600
movq -0x1e8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x1e8(%rbp)
jmp 0x55abb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x55ac72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x1e4600
jmp 0x55ac72
leaq -0x1d9(%rbp), %rdi
callq 0x1d03d0
jmp 0x55ac80
leaq -0x1d9(%rbp), %rdi
callq 0x1d03d0
jmp 0x55ac8b
jmp 0x55ac82
addq $0x270, %rsp # imm = 0x270
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,141 | Omega_h::Alloc::Alloc(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | Alloc::Alloc(std::size_t size_in, std::string&& name_in)
: size(size_in), name(name_in) {
init();
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c00c0
movq -0x30(%rbp), %rdi
callq 0x1ddcb0
jmp 0x55acdf
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c4d10
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,142 | Omega_h::Alloc::~Alloc() | OMEGA_H_DLL Alloc::~Alloc() {
::Omega_h::maybe_pooled_device_free(ptr, size);
auto ga = global_allocs;
if (ga) {
if (next == nullptr) {
ga->last = prev;
} else {
next->prev = prev;
}
if (prev == nullptr) {
ga->first = next;
} else {
prev->next = next;
}
ga->total_bytes -= size;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rsi
movq 0x28(%rax), %rdi
callq 0x1d22b0
jmp 0x55ad32
movq 0x19cd0f(%rip), %rax # 0x6f7a48
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x55adb6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x55ad64
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x55ad74
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x55ad90
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x55ada0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1c4d10
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,143 | Omega_h::SharedAlloc::SharedAlloc(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SharedAlloc::SharedAlloc(std::size_t size_in, std::string const& name_in) {
alloc = new Alloc(size_in, name_in);
direct_ptr = alloc->ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x48, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d2dc0
jmp 0x55ae1f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x1ce050
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,144 | Omega_h::SharedAlloc::SharedAlloc(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | SharedAlloc::SharedAlloc(std::size_t size_in, std::string&& name_in) {
alloc = new Alloc(size_in, name_in);
direct_ptr = alloc->ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x48, %edi
callq 0x1cd9b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1d2dc0
jmp 0x55ae9f
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x48, %esi
callq 0x1ce050
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,145 | Omega_h::SharedAlloc::SharedAlloc(unsigned long) | SharedAlloc::SharedAlloc(std::size_t size_in) : SharedAlloc(size_in, "") {} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1dfbb0
movq -0x50(%rbp), %rdx
leaq 0xd6467(%rip), %rsi # 0x63137f
leaq -0x30(%rbp), %rdi
callq 0x1d5e00
jmp 0x55af23
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1e2630
jmp 0x55af36
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
leaq -0x31(%rbp), %rdi
callq 0x1cf450
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x55af71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4d10
leaq -0x31(%rbp), %rdi
callq 0x1cf450
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,146 | Omega_h::SharedAlloc::identity(unsigned long) | SharedAlloc SharedAlloc::identity(std::size_t size_in) {
SharedAlloc out;
out.direct_ptr = nullptr;
out.alloc = reinterpret_cast<Alloc*>(
(static_cast<std::uintptr_t>(size_in) << 3) & IS_IDENTITY);
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x8(%rdi)
movq -0x28(%rbp), %rax
shlq $0x3, %rax
andq $0x2, %rax
movq %rax, (%rdi)
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x55b05f
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
je 0x55b05b
movq -0x48(%rbp), %rax
movq (%rax), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x55b05b
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movl 0x30(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x30(%rcx)
movq (%rax), %rax
cmpl $0x0, 0x30(%rax)
jne 0x55b059
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x55b057
movq -0x50(%rbp), %rdi
callq 0x1bdea0
movq -0x50(%rbp), %rdi
movl $0x48, %esi
callq 0x1ce050
jmp 0x55b059
jmp 0x55b05b
jmp 0x55b05d
jmp 0x55b05f
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_shared_alloc.cpp |
9,147 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1de4d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,148 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1de4d0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,149 | _gnu_cxx::__normal_iterator<Omega_h::HighWaterRecord*, std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
9,150 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::clear() | void
clear() _GLIBCXX_NOEXCEPT
{ _M_erase_at_end(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1cae90
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,151 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::push_back(Omega_h::HighWaterRecord&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cbda0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,152 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c70f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,153 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d2da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,154 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c8e80
movq -0x10(%rbp), %rdi
callq 0x1bafd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,155 | std::allocator<Omega_h::HighWaterRecord>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cd6c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
9,156 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,157 | _gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,158 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1c8e30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1cff20
jmp 0x55b30a
movq -0x20(%rbp), %rdi
callq 0x1df020
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,159 | void std::_Destroy<Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1df0d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,160 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_get_Tp_allocator() | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,161 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::~_Vector_base() | ~_Vector_base() _GLIBCXX_NOEXCEPT
{
_M_deallocate(_M_impl._M_start,
_M_impl._M_end_of_storage - _M_impl._M_start);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
callq 0x1e2460
jmp 0x55b3a7
movq -0x10(%rbp), %rdi
callq 0x1d1070
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,162 | void std::_Destroy<Omega_h::HighWaterRecord*>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d91c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
9,163 | void std::_Destroy_aux<false>::__destroy<Omega_h::HighWaterRecord*>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*) | static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x55b421
movq -0x8(%rbp), %rdi
callq 0x1b86f0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x55b400
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
9,164 | void std::_Destroy<Omega_h::HighWaterRecord>(Omega_h::HighWaterRecord*) | _GLIBCXX14_CONSTEXPR inline void
_Destroy(_Tp* __pointer)
{
#if __cplusplus > 201703L
std::destroy_at(__pointer);
#else
__pointer->~_Tp();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e4600
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
9,165 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_deallocate(Omega_h::HighWaterRecord*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x55b484
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1e2eb0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,166 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c3d80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,167 | std::allocator_traits<std::allocator<Omega_h::HighWaterRecord>>::deallocate(std::allocator<Omega_h::HighWaterRecord>&, Omega_h::HighWaterRecord*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1dca70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,168 | std::allocator<Omega_h::HighWaterRecord>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d9a00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
9,169 | _gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,170 | _gnu_cxx::__normal_iterator<Omega_h::HighWaterRecord*, std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>>::__normal_iterator(Omega_h::HighWaterRecord* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
9,171 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_erase_at_end(Omega_h::HighWaterRecord*) | void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x55b5df
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x1c8e30
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x1cff20
jmp 0x55b5d3
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,172 | void std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::emplace_back<Omega_h::HighWaterRecord>(Omega_h::HighWaterRecord&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x55b635
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1c2900
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
jmp 0x55b653
movq -0x20(%rbp), %rdi
callq 0x1c72c0
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1bc200
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
9,173 | void std::allocator_traits<std::allocator<Omega_h::HighWaterRecord>>::construct<Omega_h::HighWaterRecord, Omega_h::HighWaterRecord>(std::allocator<Omega_h::HighWaterRecord>&, Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1bd7c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,174 | void std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_realloc_insert<Omega_h::HighWaterRecord>(__gnu_cxx::__normal_iterator<Omega_h::HighWaterRecord*, std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>>, Omega_h::HighWaterRecord&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0xcfbbc(%rip), %rdx # 0x62b277
callq 0x1bf080
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1dc520
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bd010
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1bb0c0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
imulq $0x28, -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1c2900
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c5480
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1c8e30
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1d6480
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c5480
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1c8e30
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1d6480
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x1e2460
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x28, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
9,175 | void __gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::construct<Omega_h::HighWaterRecord, Omega_h::HighWaterRecord>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b9740
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,176 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1ba040
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1c0940
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x55b8c7
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1c0940
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1c0940
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1c0940
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x55b936
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1ba040
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x55b945
movq -0x38(%rbp), %rdi
callq 0x1ba040
movq %rax, -0x58(%rbp)
jmp 0x55b94d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,177 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x55b9e2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e1e10
movq %rax, -0x20(%rbp)
jmp 0x55b9ea
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x55b9ea
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,178 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_S_relocate(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c6e10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,179 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bded0
movq %rax, %rdi
callq 0x1c5150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,180 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,181 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_S_max_size(std::allocator<Omega_h::HighWaterRecord> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x333333333333333, %rax # imm = 0x333333333333333
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e2980
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,182 | std::_Vector_base<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,183 | std::allocator_traits<std::allocator<Omega_h::HighWaterRecord>>::max_size(std::allocator<Omega_h::HighWaterRecord> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c2da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,184 | _gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7f60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,185 | std::allocator_traits<std::allocator<Omega_h::HighWaterRecord>>::allocate(std::allocator<Omega_h::HighWaterRecord>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1df5b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,186 | _gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1c7f60
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x55bbcb
movabsq $0x666666666666666, %rax # imm = 0x666666666666666
cmpq %rax, -0x10(%rbp)
jbe 0x55bbc6
callq 0x1c85c0
callq 0x1be740
imulq $0x28, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,187 | std::vector<Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>::_S_do_relocate(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1bab00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
9,188 | Omega_h::HighWaterRecord* std::__relocate_a<Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d6690
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d6690
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d6690
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1e4d60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
9,189 | Omega_h::HighWaterRecord* std::__relocate_a_1<Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&) | inline _ForwardIterator
__relocate_a_1(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
std::addressof(*__first),
__alloc)))
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
static_assert(std::is_same<_ValueType, _ValueType2>::value,
"relocation is only possible for values of the same type");
_ForwardIterator __cur = __result;
for (; __first != __last; ++__first, (void)++__cur)
std::__relocate_object_a(std::__addressof(*__cur),
std::__addressof(*__first), __alloc);
return __cur;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x55bcd5
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1bad30
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
jmp 0x55bca0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
9,190 | void std::__relocate_object_a<Omega_h::HighWaterRecord, Omega_h::HighWaterRecord, std::allocator<Omega_h::HighWaterRecord>>(Omega_h::HighWaterRecord*, Omega_h::HighWaterRecord*, std::allocator<Omega_h::HighWaterRecord>&) | inline void
__relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
_Allocator& __alloc)
noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
__dest, std::move(*__orig)))
&& noexcept(std::allocator_traits<_Allocator>::destroy(
__alloc, std::__addressof(*__orig))))
{
typedef std::allocator_traits<_Allocator> __traits;
__traits::construct(__alloc, __dest, std::move(*__orig));
__traits::destroy(__alloc, std::__addressof(*__orig));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1c2900
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ba0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
9,191 | void std::allocator_traits<std::allocator<Omega_h::HighWaterRecord>>::destroy<Omega_h::HighWaterRecord>(std::allocator<Omega_h::HighWaterRecord>&, Omega_h::HighWaterRecord*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ce870
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
9,192 | void __gnu_cxx::new_allocator<Omega_h::HighWaterRecord>::destroy<Omega_h::HighWaterRecord>(Omega_h::HighWaterRecord*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e4600
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
9,193 | Omega_h::tris_from_quads(Omega_h::Read<int>) | LOs tris_from_quads(LOs qv2v) {
LO nq = divide_no_remainder(qv2v.size(), 4);
LO nt = nq * 2;
Write<LO> tv2v(nt * 3);
auto f = OMEGA_H_LAMBDA(LO q) {
LO qv_begin = q * 4;
LO qqv2v[4];
for (Int i = 0; i < 4; ++i) qqv2v[i] = qv2v[qv_begin + i];
/* rotate the quad such that the smallest vertex
is in the lower left */
Int min_i = find_min(qqv2v, 4);
rot_to_first(qqv2v, 4, min_i);
/* split it into two triangles via a template */
for (Int i = 0; i < 2; ++i) {
LO t = q * 2 + i;
LO tv_begin = t * 3;
for (Int j = 0; j < 3; ++j) {
tv2v[tv_begin + j] = qqv2v[qtv2qqv[i][j]];
}
}
};
parallel_for(nq, f, "tris_from_quads");
return tv2v;
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xd0(%rbp)
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x55bdea
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x55bdfc
movq -0xb8(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
movl $0x4, %esi
callq 0x1db260
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addl %eax, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0xdc(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x1dfbb0
movq -0xd8(%rbp), %rdx
leaq 0xd5538(%rip), %rsi # 0x63137f
leaq -0x68(%rbp), %rdi
callq 0x1d5e00
jmp 0x55be52
movl -0xdc(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1bc080
jmp 0x55be67
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0x69(%rbp), %rdi
callq 0x1cf450
movq -0xd0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1d99b0
jmp 0x55be95
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c0f10
jmp 0x55bea7
movl -0x34(%rbp), %edi
leaq 0xdaaf7(%rip), %rdx # 0x6369a8
leaq -0xa0(%rbp), %rsi
callq 0x55bfc0
jmp 0x55bebf
leaq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c8620
jmp 0x55bed1
movq -0xc8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1cfc00
jmp 0x55bee6
leaq -0xb0(%rbp), %rdi
callq 0x1dfdc0
leaq -0xa0(%rbp), %rdi
callq 0x55c070
leaq -0x48(%rbp), %rdi
callq 0x1dfdc0
movq -0xc0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55bf3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0x69(%rbp), %rdi
callq 0x1cf450
jmp 0x55bfa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55bf9f
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1c7d90
jmp 0x55bf9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55bf93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1dfdc0
leaq -0xa0(%rbp), %rdi
callq 0x55c070
leaq -0x48(%rbp), %rdi
callq 0x1dfdc0
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_simplify.cpp |
9,194 | void Omega_h::parallel_for<Omega_h::tris_from_quads(Omega_h::Read<int>)::$_0>(int, Omega_h::tris_from_quads(Omega_h::Read<int>)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x55da30
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x55da90
jmp 0x55c033
leaq -0x58(%rbp), %rdi
callq 0x55c070
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x55c070
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,195 | Omega_h::tets_from_hexes(Omega_h::Read<int>) | LOs tets_from_hexes(LOs hv2v) {
LO nh = divide_no_remainder(hv2v.size(), 8);
Write<LO> degrees(nh);
auto count = OMEGA_H_LAMBDA(LO h) {
LO hhv2v[8];
Int diags_into[3];
Int ndiags_into;
tets_from_hex_1(h, hv2v, hhv2v, diags_into, ndiags_into);
if (ndiags_into == 0)
degrees[h] = 5;
else
degrees[h] = 6;
};
parallel_for(nh, count, "tets_from_hexes(count)");
auto h2ht = offset_scan(LOs(degrees));
LO nt = h2ht.last();
Write<LO> tv2v(nt * 4);
auto fill = OMEGA_H_LAMBDA(LO h) {
LO hhv2v[8];
Int diags_into[3];
Int ndiags_into;
tets_from_hex_1(h, hv2v, hhv2v, diags_into, ndiags_into);
if (ndiags_into == 0) {
fill_tets_from_hex(tv2v, h2ht, h, hhv2v, htv2hhv_0, 5);
} else if (ndiags_into == 1) {
/* one diagonal into the far corner.
find it, rotate it to the right side, apply template */
Int diag_face = -1;
for (Int i = 0; i < 3; ++i)
if (diags_into[i]) diag_face = i;
hex_bur_rot_to_right(hhv2v, diag_face);
fill_tets_from_hex(tv2v, h2ht, h, hhv2v, htv2hhv_1, 6);
} else if (ndiags_into == 2) {
/* two diagonals into the far corner.
find the face with diagonal not into the corner,
rotate it to the right side, apply template */
Int diag_face = -1;
for (Int i = 0; i < 3; ++i)
if (!diags_into[i]) diag_face = i;
hex_bur_rot_to_right(hhv2v, diag_face);
fill_tets_from_hex(tv2v, h2ht, h, hhv2v, htv2hhv_2, 6);
} else {
/* three diagonals into the far corner. */
fill_tets_from_hex(tv2v, h2ht, h, hhv2v, htv2hhv_3, 6);
}
};
parallel_for(nh, fill, "tets_from_hexes(fill)");
return tv2v;
} | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, -0x190(%rbp)
movq %rdi, -0x188(%rbp)
movq %rdi, %rax
movq %rax, -0x180(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x55c10a
movq -0x178(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x55c11c
movq -0x178(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
movl $0x8, %esi
callq 0x1db260
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x19c(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x1dfbb0
movq -0x198(%rbp), %rdx
leaq 0xd5225(%rip), %rsi # 0x63137f
leaq -0x68(%rbp), %rdi
callq 0x1d5e00
jmp 0x55c165
movl -0x19c(%rbp), %esi
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1bc080
jmp 0x55c17a
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0x69(%rbp), %rdi
callq 0x1cf450
movq -0x190(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x1d99b0
jmp 0x55c1a8
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c0f10
jmp 0x55c1ba
movl -0x34(%rbp), %edi
leaq 0xda7f4(%rip), %rdx # 0x6369b8
leaq -0xa0(%rbp), %rsi
callq 0x55c5b0
jmp 0x55c1d2
leaq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c0f10
jmp 0x55c1e4
leaq -0xc0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1cfc00
jmp 0x55c1f9
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x1dfbb0
movq -0x1b0(%rbp), %rdx
leaq 0xd5165(%rip), %rsi # 0x63137f
leaq -0xf0(%rbp), %rdi
callq 0x1d5e00
jmp 0x55c228
leaq -0xb0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
callq 0x1cbf20
jmp 0x55c244
leaq -0xf0(%rbp), %rdi
callq 0x1c4d10
leaq -0xf1(%rbp), %rdi
callq 0x1cf450
leaq -0xc0(%rbp), %rdi
callq 0x1c7d90
leaq -0xd0(%rbp), %rdi
callq 0x1dfdc0
leaq -0xb0(%rbp), %rdi
callq 0x1d2020
movl %eax, -0x1b4(%rbp)
jmp 0x55c288
movl -0x1b4(%rbp), %eax
movl %eax, -0xf8(%rbp)
movl -0xf8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c4(%rbp)
leaq -0x129(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x1dfbb0
movq -0x1c0(%rbp), %rdx
leaq 0xd50bb(%rip), %rsi # 0x63137f
leaq -0x128(%rbp), %rdi
callq 0x1d5e00
jmp 0x55c2d2
movl -0x1c4(%rbp), %esi
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rdx
callq 0x1bc080
jmp 0x55c2ed
leaq -0x128(%rbp), %rdi
callq 0x1c4d10
leaq -0x129(%rbp), %rdi
callq 0x1cf450
movq -0x190(%rbp), %rsi
leaq -0x160(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x1d99b0
jmp 0x55c321
leaq -0x150(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
leaq -0x108(%rbp), %rsi
callq 0x1c0f10
jmp 0x55c33d
leaq -0x140(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1d99b0
jmp 0x55c352
movl -0x34(%rbp), %edi
leaq 0xda673(%rip), %rdx # 0x6369cf
leaq -0x160(%rbp), %rsi
callq 0x55c660
jmp 0x55c36a
leaq -0x170(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1c8620
jmp 0x55c37f
movq -0x188(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x1cfc00
jmp 0x55c394
leaq -0x170(%rbp), %rdi
callq 0x1dfdc0
leaq -0x160(%rbp), %rdi
callq 0x55c710
leaq -0x108(%rbp), %rdi
callq 0x1dfdc0
leaq -0xb0(%rbp), %rdi
callq 0x1c7d90
leaq -0xa0(%rbp), %rdi
callq 0x55c750
leaq -0x48(%rbp), %rdi
callq 0x1dfdc0
movq -0x180(%rbp), %rax
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c40c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4d10
leaq -0x69(%rbp), %rdi
callq 0x1cf450
jmp 0x55c59f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c596
movq -0x1a8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1c7d90
jmp 0x55c596
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c58a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c4a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c48d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x1c4d10
leaq -0xf1(%rbp), %rdi
callq 0x1cf450
leaq -0xc0(%rbp), %rdi
callq 0x1c7d90
leaq -0xd0(%rbp), %rdi
callq 0x1dfdc0
jmp 0x55c58a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c57e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c4ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x1c4d10
leaq -0x129(%rbp), %rdi
callq 0x1cf450
jmp 0x55c57e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c572
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c532
movq -0x1d8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x1dfdc0
movq -0x1d0(%rbp), %rdi
callq 0x1c7d90
jmp 0x55c572
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x55c566
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x1dfdc0
leaq -0x160(%rbp), %rdi
callq 0x55c710
leaq -0x108(%rbp), %rdi
callq 0x1dfdc0
leaq -0xb0(%rbp), %rdi
callq 0x1c7d90
leaq -0xa0(%rbp), %rdi
callq 0x55c750
leaq -0x48(%rbp), %rdi
callq 0x1dfdc0
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_simplify.cpp |
9,196 | void Omega_h::parallel_for<Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_0>(int, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_0 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x55ded0
movq -0x78(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %edi
movl -0x60(%rbp), %esi
callq 0x55df30
jmp 0x55c623
leaq -0x58(%rbp), %rdi
callq 0x55c750
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x55c750
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,197 | void Omega_h::parallel_for<Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_1>(int, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_1 const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x55e740
movq -0x88(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x6c(%rbp), %edi
movl -0x70(%rbp), %esi
callq 0x55e7e0
jmp 0x55c6d9
leaq -0x68(%rbp), %rdi
callq 0x55c710
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x55c710
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
9,198 | Omega_h::tris_from_quads_symmetric(Omega_h::Mesh*) | void tris_from_quads_symmetric(Mesh* mesh) {
auto nold_verts = mesh->nverts();
auto nquads = mesh->nfaces();
auto old_coords = mesh->coords();
auto quad_center_coords = average_field(mesh, 2, 2, old_coords);
auto nverts = nold_verts + nquads;
auto coords = Write<Real>(nverts * 2);
auto ntris = nquads * 4;
auto qv2v = mesh->ask_elem_verts();
auto tv2v = Write<LO>(ntris * 3);
auto f = OMEGA_H_LAMBDA(LO q) {
auto qqv2v = gather_verts<4>(qv2v, q);
for (Int qqt = 0; qqt < 4; ++qqt) {
auto t = q * 4 + qqt;
auto v0 = qqv2v[qqt];
auto v1 = qqv2v[(qqt + 1) % 4];
auto vq = nold_verts + q;
tv2v[t * 3 + 0] = vq;
tv2v[t * 3 + 1] = v0;
tv2v[t * 3 + 2] = v1;
}
};
parallel_for(nquads, f);
map_into_range(old_coords, 0, nold_verts, coords, 2);
map_into_range(
quad_center_coords, nold_verts, nold_verts + nquads, coords, 2);
Mesh new_mesh(mesh->library());
build_from_elems_and_coords(&new_mesh, OMEGA_H_SIMPLEX, 2, tv2v, coords);
assign(*mesh, new_mesh);
} | pushq %rbp
movq %rsp, %rbp
subq $0x5a0, %rsp # imm = 0x5A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d8940
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c8f90
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x560(%rbp)
callq 0x1e0da0
movq -0x560(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x558(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1cae10
jmp 0x55c7d8
movq -0x558(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x2, %ecx
leaq -0x40(%rbp), %r8
movl %ecx, %edx
callq 0x1cb6e0
jmp 0x55c7f5
leaq -0x40(%rbp), %rdi
callq 0x1e0ab0
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
addl %eax, %eax
movl %eax, -0x56c(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0x568(%rbp)
callq 0x1dfbb0
movq -0x568(%rbp), %rdx
leaq 0xd4b4a(%rip), %rsi # 0x63137f
leaq -0x80(%rbp), %rdi
callq 0x1d5e00
jmp 0x55c840
movl -0x56c(%rbp), %esi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x1cd090
jmp 0x55c855
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
movl -0x10(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x88(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x1c65b0
jmp 0x55c888
movl -0x88(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0x57c(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0x578(%rbp)
callq 0x1dfbb0
movq -0x578(%rbp), %rdx
leaq 0xd4ac5(%rip), %rsi # 0x63137f
leaq -0xc8(%rbp), %rdi
callq 0x1d5e00
jmp 0x55c8c8
movl -0x57c(%rbp), %esi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1bc080
jmp 0x55c8e3
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x588(%rbp)
leaq -0x98(%rbp), %rsi
callq 0x1d99b0
jmp 0x55c917
movl -0xc(%rbp), %eax
movl %eax, -0xe8(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1c0f10
jmp 0x55c935
movl -0x10(%rbp), %edi
leaq -0xf8(%rbp), %rsi
callq 0x55cd80
jmp 0x55c946
leaq -0x108(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1cae10
jmp 0x55c958
movl -0xc(%rbp), %eax
movl %eax, -0x58c(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x55c973
movl -0x58c(%rbp), %edx
leaq -0x108(%rbp), %rdi
xorl %esi, %esi
leaq -0x118(%rbp), %rcx
movl $0x2, %r8d
callq 0x1c8650
jmp 0x55c996
leaq -0x118(%rbp), %rdi
callq 0x1dc900
leaq -0x108(%rbp), %rdi
callq 0x1e0ab0
leaq -0x128(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1cae10
jmp 0x55c9c0
movl -0xc(%rbp), %eax
movl %eax, -0x594(%rbp)
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x590(%rbp)
leaq -0x138(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x55c9e6
movl -0x590(%rbp), %edx
movl -0x594(%rbp), %esi
leaq -0x128(%rbp), %rdi
leaq -0x138(%rbp), %rcx
movl $0x2, %r8d
callq 0x1c8650
jmp 0x55ca0d
leaq -0x138(%rbp), %rdi
callq 0x1dc900
leaq -0x128(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rdi
callq 0x1d45c0
movq %rax, -0x5a0(%rbp)
jmp 0x55ca37
movq -0x5a0(%rbp), %rsi
leaq -0x510(%rbp), %rdi
callq 0x1df340
jmp 0x55ca4c
leaq -0x530(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1c0f10
jmp 0x55ca61
leaq -0x520(%rbp), %rdi
leaq -0x530(%rbp), %rsi
callq 0x1cfc00
jmp 0x55ca76
leaq -0x550(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1c7e70
jmp 0x55ca88
leaq -0x540(%rbp), %rdi
leaq -0x550(%rbp), %rsi
callq 0x1ccda0
jmp 0x55ca9d
leaq -0x510(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
leaq -0x520(%rbp), %rcx
leaq -0x540(%rbp), %r8
callq 0x1bb910
jmp 0x55cac0
leaq -0x540(%rbp), %rdi
callq 0x1e0ab0
leaq -0x550(%rbp), %rdi
callq 0x1dc900
leaq -0x520(%rbp), %rdi
callq 0x1c7d90
leaq -0x530(%rbp), %rdi
callq 0x1dfdc0
movq -0x8(%rbp), %rdi
leaq -0x510(%rbp), %rsi
callq 0x1c12b0
jmp 0x55cb02
leaq -0x510(%rbp), %rdi
callq 0x1dad60
leaq -0xf8(%rbp), %rdi
callq 0x55cf90
leaq -0xa8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x98(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
leaq -0x20(%rbp), %rdi
callq 0x1e0ab0
addq $0x5a0, %rsp # imm = 0x5A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55cd60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cba4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c4d10
leaq -0x81(%rbp), %rdi
callq 0x1cf450
jmp 0x55cd57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cbec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0xc9(%rbp), %rdi
callq 0x1cf450
jmp 0x55cd42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd36
movq -0x588(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x1c7d90
jmp 0x55cd36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cc62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1dc900
leaq -0x108(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55cd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cc99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1dc900
leaq -0x128(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55cd2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55cd06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55ccfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x1e0ab0
leaq -0x550(%rbp), %rdi
callq 0x1dc900
leaq -0x520(%rbp), %rdi
callq 0x1c7d90
leaq -0x530(%rbp), %rdi
callq 0x1dfdc0
leaq -0x510(%rbp), %rdi
callq 0x1dad60
leaq -0xf8(%rbp), %rdi
callq 0x55cf90
leaq -0xa8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x98(%rbp), %rdi
callq 0x1c7d90
leaq -0x60(%rbp), %rdi
callq 0x1dc900
leaq -0x30(%rbp), %rdi
callq 0x1e0ab0
leaq -0x20(%rbp), %rdi
callq 0x1e0ab0
movq -0x48(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_simplify.cpp |
9,199 | void Omega_h::parallel_for<Omega_h::tris_from_quads_symmetric(Omega_h::Mesh*)::$_0&>(int, Omega_h::tris_from_quads_symmetric(Omega_h::Mesh*)::$_0&) | void parallel_for(LO n, UnaryFunction&& f) {
OMEGA_H_TIME_FUNCTION;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
::Omega_h::for_each(first, last, f);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1dfbb0
movq -0xe0(%rbp), %rdx
leaq 0xcec0c(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x55cdc1
leaq 0xce4ad(%rip), %rdx # 0x62b275
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1bb5a0
jmp 0x55cdda
leaq -0xc8(%rbp), %rdi
movl $0x54, %esi
callq 0x1d4960
jmp 0x55cded
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x1ca480
jmp 0x55ce03
leaq -0x50(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xceb9c(%rip), %rsi # 0x62b9b2
leaq -0x29(%rbp), %rdi
callq 0x1dc4d0
jmp 0x55ce21
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
leaq -0xcc(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xcc(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xd8(%rbp)
movq -0x28(%rbp), %rdx
movl -0xd4(%rbp), %edi
movl -0xd8(%rbp), %esi
callq 0x55fc50
jmp 0x55cebb
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55cf59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55cf4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55cf44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55cf38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0xc8(%rbp), %rdi
callq 0x1c4d10
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x90(%rbp), %rdi
callq 0x1c4d10
leaq -0x91(%rbp), %rdi
callq 0x1cf450
jmp 0x55cf82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1d03d0
movq -0xa0(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.