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,200 | Omega_h::tets_from_hexes_symmetric(Omega_h::Mesh*) | void tets_from_hexes_symmetric(Mesh* mesh) {
auto nold_verts = mesh->nverts();
auto nquads = mesh->nfaces();
auto nhexes = mesh->nregions();
auto old_coords = mesh->coords();
auto quad_center_coords = average_field(mesh, 2, 3, old_coords);
auto hex_center_coords = average_field(mesh, 3, 3, old_coords);
auto nverts = nold_verts + nquads + nhexes;
auto coords = Write<Real>(nverts * 3);
auto ntets = nhexes * 6 * 4;
auto hv2v = mesh->ask_elem_verts();
auto hq2q = mesh->ask_down(3, 2).ab2b;
auto tv2v = Write<LO>(ntets * 4);
auto f = OMEGA_H_LAMBDA(LO h) {
auto hhv2v = gather_verts<8>(hv2v, h);
auto hhq2q = gather_down<6>(hq2q, h);
for (Int hhq = 0; hhq < 6; ++hhq) {
auto q = hhq2q[hhq];
for (Int hhqt = 0; hhqt < 4; ++hhqt) {
auto t = (h * 6 + hhq) * 4 + hhqt;
auto v0 = hhv2v[hypercube_down_template(3, 2, hhq, hhqt)];
auto v1 = hhv2v[hypercube_down_template(3, 2, hhq, (hhqt + 1) % 4)];
auto vq = nold_verts + q;
auto vh = nold_verts + nquads + h;
tv2v[t * 4 + 0] = vq;
tv2v[t * 4 + 1] = v1;
tv2v[t * 4 + 2] = v0;
tv2v[t * 4 + 3] = vh;
}
}
};
parallel_for(nhexes, f);
map_into_range(old_coords, 0, nold_verts, coords, 3);
map_into_range(
quad_center_coords, nold_verts, nold_verts + nquads, coords, 3);
map_into_range(hex_center_coords, nold_verts + nquads, nverts, coords, 3);
Mesh new_mesh(mesh->library());
build_from_elems_and_coords(&new_mesh, OMEGA_H_SIMPLEX, 3, tv2v, coords);
assign(*mesh, new_mesh);
} | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
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), %rdi
callq 0x1c8300
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x600(%rbp)
callq 0x1e0da0
movq -0x600(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x5f8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1cae10
jmp 0x55d024
movq -0x5f8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x2, %edx
movl $0x3, %ecx
leaq -0x48(%rbp), %r8
callq 0x1cb6e0
jmp 0x55d044
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rax
movq %rax, -0x608(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x55d067
movq -0x608(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movl $0x3, %ecx
leaq -0x78(%rbp), %r8
movl %ecx, %edx
callq 0x1cb6e0
jmp 0x55d084
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl -0x14(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0x614(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0x610(%rbp)
callq 0x1dfbb0
movq -0x610(%rbp), %rdx
leaq 0xd42b3(%rip), %rsi # 0x63137f
leaq -0xb0(%rbp), %rdi
callq 0x1d5e00
jmp 0x55d0da
movl -0x614(%rbp), %esi
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x1cd090
jmp 0x55d0f5
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0xb1(%rbp), %rdi
callq 0x1cf450
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0xb8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x1c65b0
jmp 0x55d130
movq -0x8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
movl $0x3, %edx
movl $0x2, %ecx
callq 0x1cd9c0
jmp 0x55d14c
leaq -0xf8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1c73c0
jmp 0x55d161
leaq -0x108(%rbp), %rdi
callq 0x1cb510
movl -0xb8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x624(%rbp)
leaq -0x139(%rbp), %rdi
movq %rdi, -0x620(%rbp)
callq 0x1dfbb0
movq -0x620(%rbp), %rdx
leaq 0xd41e2(%rip), %rsi # 0x63137f
leaq -0x138(%rbp), %rdi
callq 0x1d5e00
jmp 0x55d1ab
movl -0x624(%rbp), %esi
leaq -0x118(%rbp), %rdi
leaq -0x138(%rbp), %rdx
callq 0x1bc080
jmp 0x55d1c6
leaq -0x138(%rbp), %rdi
callq 0x1c4d10
leaq -0x139(%rbp), %rdi
callq 0x1cf450
leaq -0x178(%rbp), %rdi
movq %rdi, -0x630(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0x1d99b0
jmp 0x55d1fa
leaq -0x168(%rbp), %rdi
movq %rdi, -0x638(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x1d99b0
jmp 0x55d216
movl -0xc(%rbp), %eax
movl %eax, -0x158(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x154(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x1c0f10
jmp 0x55d23d
movl -0x14(%rbp), %edi
leaq -0x178(%rbp), %rsi
callq 0x55d7e0
jmp 0x55d24e
leaq -0x188(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1cae10
jmp 0x55d260
movl -0xc(%rbp), %eax
movl %eax, -0x63c(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1c7e70
jmp 0x55d27e
movl -0x63c(%rbp), %edx
leaq -0x188(%rbp), %rdi
xorl %esi, %esi
leaq -0x198(%rbp), %rcx
movl $0x3, %r8d
callq 0x1c8650
jmp 0x55d2a1
leaq -0x198(%rbp), %rdi
callq 0x1dc900
leaq -0x188(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1a8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1cae10
jmp 0x55d2cb
movl -0xc(%rbp), %eax
movl %eax, -0x644(%rbp)
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x640(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1c7e70
jmp 0x55d2f4
movl -0x640(%rbp), %edx
movl -0x644(%rbp), %esi
leaq -0x1a8(%rbp), %rdi
leaq -0x1b8(%rbp), %rcx
movl $0x3, %r8d
callq 0x1c8650
jmp 0x55d31b
leaq -0x1b8(%rbp), %rdi
callq 0x1dc900
leaq -0x1a8(%rbp), %rdi
callq 0x1e0ab0
leaq -0x1c8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1cae10
jmp 0x55d345
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x64c(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, -0x648(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1c7e70
jmp 0x55d371
movl -0x648(%rbp), %edx
movl -0x64c(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
leaq -0x1d8(%rbp), %rcx
movl $0x3, %r8d
callq 0x1c8650
jmp 0x55d398
leaq -0x1d8(%rbp), %rdi
callq 0x1dc900
leaq -0x1c8(%rbp), %rdi
callq 0x1e0ab0
movq -0x8(%rbp), %rdi
callq 0x1d45c0
movq %rax, -0x658(%rbp)
jmp 0x55d3c2
movq -0x658(%rbp), %rsi
leaq -0x5b0(%rbp), %rdi
callq 0x1df340
jmp 0x55d3d7
leaq -0x5d0(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x1c0f10
jmp 0x55d3ec
leaq -0x5c0(%rbp), %rdi
leaq -0x5d0(%rbp), %rsi
callq 0x1cfc00
jmp 0x55d401
leaq -0x5f0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1c7e70
jmp 0x55d416
leaq -0x5e0(%rbp), %rdi
leaq -0x5f0(%rbp), %rsi
callq 0x1ccda0
jmp 0x55d42b
leaq -0x5b0(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
leaq -0x5c0(%rbp), %rcx
leaq -0x5e0(%rbp), %r8
callq 0x1bb910
jmp 0x55d44e
leaq -0x5e0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x5f0(%rbp), %rdi
callq 0x1dc900
leaq -0x5c0(%rbp), %rdi
callq 0x1c7d90
leaq -0x5d0(%rbp), %rdi
callq 0x1dfdc0
movq -0x8(%rbp), %rdi
leaq -0x5b0(%rbp), %rsi
callq 0x1c12b0
jmp 0x55d490
leaq -0x5b0(%rbp), %rdi
callq 0x1dad60
leaq -0x178(%rbp), %rdi
callq 0x55d9f0
leaq -0x118(%rbp), %rdi
callq 0x1dfdc0
leaq -0xd8(%rbp), %rdi
callq 0x1c7d90
leaq -0xc8(%rbp), %rdi
callq 0x1c7d90
leaq -0x90(%rbp), %rdi
callq 0x1dc900
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
addq $0x660, %rsp # imm = 0x660
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d7cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55d7cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d7c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55d7c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d578
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x1c4d10
leaq -0xb1(%rbp), %rdi
callq 0x1cf450
jmp 0x55d7b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d7ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d7a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x1cb510
jmp 0x55d7a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d5ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x138(%rbp), %rdi
callq 0x1c4d10
leaq -0x139(%rbp), %rdi
callq 0x1cf450
jmp 0x55d795
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d636
movq -0x638(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x1c7d90
movq -0x630(%rbp), %rdi
callq 0x1c7d90
jmp 0x55d789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d77d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d67e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1dc900
leaq -0x188(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55d77d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d6b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1dc900
leaq -0x1a8(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55d77d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d6ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1dc900
leaq -0x1c8(%rbp), %rdi
callq 0x1e0ab0
jmp 0x55d77d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d771
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d759
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x55d74d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x5e0(%rbp), %rdi
callq 0x1e0ab0
leaq -0x5f0(%rbp), %rdi
callq 0x1dc900
leaq -0x5c0(%rbp), %rdi
callq 0x1c7d90
leaq -0x5d0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x5b0(%rbp), %rdi
callq 0x1dad60
leaq -0x178(%rbp), %rdi
callq 0x55d9f0
leaq -0x118(%rbp), %rdi
callq 0x1dfdc0
leaq -0xd8(%rbp), %rdi
callq 0x1c7d90
leaq -0xc8(%rbp), %rdi
callq 0x1c7d90
leaq -0x90(%rbp), %rdi
callq 0x1dc900
leaq -0x68(%rbp), %rdi
callq 0x1e0ab0
leaq -0x38(%rbp), %rdi
callq 0x1e0ab0
leaq -0x28(%rbp), %rdi
callq 0x1e0ab0
movq -0x50(%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_simplify.cpp |
9,201 | void Omega_h::parallel_for<Omega_h::tets_from_hexes_symmetric(Omega_h::Mesh*)::$_0&>(int, Omega_h::tets_from_hexes_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 0xce1ac(%rip), %rsi # 0x62b9bf
leaq -0x90(%rbp), %rdi
callq 0x1d5e00
jmp 0x55d821
leaq 0xcda4d(%rip), %rdx # 0x62b275
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1bb5a0
jmp 0x55d83a
leaq -0xc8(%rbp), %rdi
movl $0x54, %esi
callq 0x1d4960
jmp 0x55d84d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x1ca480
jmp 0x55d863
leaq -0x50(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdx
leaq 0xce13c(%rip), %rsi # 0x62b9b2
leaq -0x29(%rbp), %rdi
callq 0x1dc4d0
jmp 0x55d881
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 0x560050
jmp 0x55d91b
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 0x55d9b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55d9ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55d9a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x55d998
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 0x55d9e2
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 |
9,202 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::tris_from_quads(Omega_h::Read<int>)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::tris_from_quads(Omega_h::Read<int>)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x55dac5
jmp 0x55db54
movq 0x19a1bc(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x55db70
movq 0x19a1a5(%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 0x55db4b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x55dbd0
jmp 0x55db1d
jmp 0x55db1f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x55dae6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x55c070
jmp 0x55db5a
leaq -0x60(%rbp), %rdi
callq 0x55c070
addq $0x70, %rsp
popq %rbp
retq
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,203 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_0>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_0&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x55df65
jmp 0x55dff4
movq 0x199d1c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x55e010
movq 0x199d05(%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 0x55dfeb
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x55e070
jmp 0x55dfbd
jmp 0x55dfbf
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x55df86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x55c750
jmp 0x55dffa
leaq -0x60(%rbp), %rdi
callq 0x55c750
addq $0x70, %rsp
popq %rbp
retq
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,204 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_1>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::tets_from_hexes(Omega_h::Read<int>)::$_1&&) | 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 $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x55e818
jmp 0x55e8a7
movq 0x199469(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x55e8c0
movq 0x199452(%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 0x55e89e
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x55e960
jmp 0x55e870
jmp 0x55e872
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x55e839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x55c710
jmp 0x55e8b0
leaq -0x70(%rbp), %rdi
callq 0x55c710
addq $0x80, %rsp
popq %rbp
retq
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,205 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::tris_from_quads_symmetric(Omega_h::Mesh*)::$_0&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::tris_from_quads_symmetric(Omega_h::Mesh*)::$_0&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x55fc88
jmp 0x55fd17
movq 0x197ff9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x55fd30
movq 0x197fe2(%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 0x55fd0e
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x55fda0
jmp 0x55fce0
jmp 0x55fce2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x55fca9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x55cf90
jmp 0x55fd20
leaq -0x68(%rbp), %rdi
callq 0x55cf90
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%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,206 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::tets_from_hexes_symmetric(Omega_h::Mesh*)::$_0&>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::tets_from_hexes_symmetric(Omega_h::Mesh*)::$_0&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++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 0x560088
jmp 0x56011a
movq 0x197bf9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x560130
movq 0x197be2(%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 0x560111
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x5601e0
jmp 0x5600e0
jmp 0x5600e2
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5600a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x55d9f0
jmp 0x560123
leaq -0x78(%rbp), %rdi
callq 0x55d9f0
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%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,207 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<1, int>(Omega_h::Read<int>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd5442(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x561651
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x561663
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
movl $0x1, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcfcdb(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x5616b2
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x5616d1
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1e08a0
jmp 0x561786
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562b50
jmp 0x5617a2
callq 0x1d7be0
jmp 0x5617a9
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x5617bb
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x5617d0
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561827
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x561870
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,208 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<2, int>(Omega_h::Read<int>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd5192(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x561901
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x561913
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
movl $0x2, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcfa2b(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x561962
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x561981
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1ddb70
jmp 0x561a36
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562ba0
jmp 0x561a52
callq 0x1d7be0
jmp 0x561a59
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x561a6b
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x561a80
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561ad7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x561b20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561b17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,209 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<3, int>(Omega_h::Read<int>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd4ee2(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x561bb1
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x561bc3
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
movl $0x3, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcf77b(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x561c12
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x561c31
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1e2520
jmp 0x561ce6
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562bf0
jmp 0x561d02
callq 0x1d7be0
jmp 0x561d09
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x561d1b
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x561d30
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561d87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x561dd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x561dc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,210 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<4, int>(Omega_h::Read<int>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd4c32(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x561e61
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x561e73
movq -0xf0(%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, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcf4cb(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x561ec2
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x561ee1
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1c1940
jmp 0x561f96
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562c40
jmp 0x561fb2
callq 0x1d7be0
jmp 0x561fb9
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x561fcb
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x561fe0
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x562080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,211 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<1, long>(Omega_h::Read<long>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd4982(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x562111
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x562123
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
movl $0x1, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcf21b(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x562172
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x562191
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1c8c30
jmp 0x562246
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562c90
jmp 0x562262
callq 0x1d7be0
jmp 0x562269
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x56227b
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x562290
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x5622e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x562330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562327
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,212 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<2, long>(Omega_h::Read<long>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd46d2(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5623c1
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5623d3
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
movl $0x2, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcef6b(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x562422
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x562441
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1c0670
jmp 0x5624f6
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562ce0
jmp 0x562512
callq 0x1d7be0
jmp 0x562519
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x56252b
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x562540
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562597
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x5625e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x5625d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,213 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<3, long>(Omega_h::Read<long>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd4422(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x562671
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x562683
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
movl $0x3, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcecbb(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x5626d2
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x5626f1
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1baa40
jmp 0x5627a6
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562d30
jmp 0x5627c2
callq 0x1d7be0
jmp 0x5627c9
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x5627db
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x5627f0
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x562890
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562887
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,214 | Omega_h::Read<int> Omega_h::sort_by_keys_tmpl<4, long>(Omega_h::Read<long>) | static LOs sort_by_keys_tmpl(Read<T> keys) {
begin_code("sort_by_keys");
auto n = divide_no_remainder(keys.size(), N);
Write<LO> perm(n, 0, 1);
LO* begin = perm.data();
LO* end = perm.data() + n;
T const* keyptr = keys.data();
parallel_sort<LO, CompareKeySets<T, N>>(
begin, end, CompareKeySets<T, N>(keyptr));
end_code();
return perm;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
leaq 0xd4172(%rip), %rdi # 0x636a44
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0xf8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x562921
movq -0xf0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x562933
movq -0xf0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
movl $0x4, %esi
callq 0x1db260
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x1dfbb0
movq -0x110(%rbp), %rdx
leaq 0xcea0b(%rip), %rsi # 0x63137f
leaq -0xa0(%rbp), %rdi
callq 0x1d5e00
jmp 0x562982
movl -0x114(%rbp), %esi
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
leaq -0xa0(%rbp), %r8
callq 0x1e2440
jmp 0x5629a1
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
movq -0xf8(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x50(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rdx, -0xc0(%rbp)
movq %rcx, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x6c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movq %rcx, -0xc8(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0xd0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x1bec40
jmp 0x562a56
movq -0x120(%rbp), %rsi
movq -0x128(%rbp), %rdi
movq -0xd8(%rbp), %rdx
callq 0x562d80
jmp 0x562a72
callq 0x1d7be0
jmp 0x562a79
leaq -0xe8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c8620
jmp 0x562a8b
movq -0x108(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1cfc00
jmp 0x562aa0
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562af7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c4d10
leaq -0xa1(%rbp), %rdi
callq 0x1cf450
jmp 0x562b40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x562b37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1dfdc0
leaq -0x80(%rbp), %rdi
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,215 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<int, 1>>(int*, int*, Omega_h::CompareKeySets<int, 1>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3ee6(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1d4600
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,216 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<int, 2>>(int*, int*, Omega_h::CompareKeySets<int, 2>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3e96(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1ce300
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,217 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<int, 3>>(int*, int*, Omega_h::CompareKeySets<int, 3>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3e46(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1cda00
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,218 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<int, 4>>(int*, int*, Omega_h::CompareKeySets<int, 4>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3df6(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1c4050
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,219 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<long, 1>>(int*, int*, Omega_h::CompareKeySets<long, 1>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3da6(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1dcc30
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,220 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<long, 2>>(int*, int*, Omega_h::CompareKeySets<long, 2>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3d56(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1ce570
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,221 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<long, 3>>(int*, int*, Omega_h::CompareKeySets<long, 3>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3d06(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1d86b0
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,222 | void Omega_h::parallel_sort<int, Omega_h::CompareKeySets<long, 4>>(int*, int*, Omega_h::CompareKeySets<long, 4>) | static void parallel_sort(T* b, T* e, Comp c) {
begin_code("parallel_sort");
#if defined(OMEGA_H_USE_CUDA)
auto bptr = thrust::device_ptr<T>(b);
auto eptr = thrust::device_ptr<T>(e);
thrust::stable_sort(bptr, eptr, c);
#elif defined(OMEGA_H_USE_OPENMP)
pss::parallel_stable_sort(b, e, c);
#else
std::stable_sort(b, e, c);
#endif
end_code();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0xd3cb6(%rip), %rdi # 0x636a51
xorl %eax, %eax
movl %eax, %esi
callq 0x1d4380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1dbb70
callq 0x1d7be0
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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,223 | Omega_h::Read<int> Omega_h::sort_by_keys<int>(Omega_h::Read<int>, int) | LOs sort_by_keys(Read<T> keys, Int width) {
if (width == 1) return sort_by_keys_tmpl<1>(keys);
if (width == 2) return sort_by_keys_tmpl<2>(keys);
if (width == 3) return sort_by_keys_tmpl<3>(keys);
if (width == 4) return sort_by_keys_tmpl<4>(keys);
OMEGA_H_NORETURN(LOs());
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x562e49
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1d99b0
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x5615d0
jmp 0x562e21
leaq -0x28(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f6a
cmpl $0x2, -0x14(%rbp)
jne 0x562e9d
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1d99b0
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x561880
jmp 0x562e75
leaq -0x48(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f6a
cmpl $0x3, -0x14(%rbp)
jne 0x562eee
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1d99b0
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x561b30
jmp 0x562ec9
leaq -0x58(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f6a
cmpl $0x4, -0x14(%rbp)
jne 0x562f3c
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1d99b0
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x561de0
jmp 0x562f1a
leaq -0x68(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c7d90
jmp 0x562f6a
leaq 0xc8125(%rip), %rdi # 0x62b068
leaq 0xc881f(%rip), %rsi # 0x62b769
leaq 0xd3a94(%rip), %rdx # 0x6369e5
movl $0x5b, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%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_sort.cpp |
9,224 | Omega_h::Read<int> Omega_h::sort_by_keys<long>(Omega_h::Read<long>, int) | LOs sort_by_keys(Read<T> keys, Int width) {
if (width == 1) return sort_by_keys_tmpl<1>(keys);
if (width == 2) return sort_by_keys_tmpl<2>(keys);
if (width == 3) return sort_by_keys_tmpl<3>(keys);
if (width == 4) return sort_by_keys_tmpl<4>(keys);
OMEGA_H_NORETURN(LOs());
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x562ff9
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1c3090
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x562090
jmp 0x562fd1
leaq -0x28(%rbp), %rdi
callq 0x1bc010
jmp 0x56310d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1bc010
jmp 0x56311a
cmpl $0x2, -0x14(%rbp)
jne 0x56304d
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1c3090
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x562340
jmp 0x563025
leaq -0x48(%rbp), %rdi
callq 0x1bc010
jmp 0x56310d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1bc010
jmp 0x56311a
cmpl $0x3, -0x14(%rbp)
jne 0x56309e
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c3090
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x5625f0
jmp 0x563079
leaq -0x58(%rbp), %rdi
callq 0x1bc010
jmp 0x56310d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1bc010
jmp 0x56311a
cmpl $0x4, -0x14(%rbp)
jne 0x5630ec
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1c3090
movq -0x78(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x5628a0
jmp 0x5630ca
leaq -0x68(%rbp), %rdi
callq 0x1bc010
jmp 0x56310d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1bc010
jmp 0x56311a
leaq 0xc7f75(%rip), %rdi # 0x62b068
leaq 0xc866f(%rip), %rsi # 0x62b769
leaq 0xd38e4(%rip), %rdx # 0x6369e5
movl $0x5b, %ecx
movb $0x0, %al
callq 0x1ce550
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%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_sort.cpp |
9,225 | void Omega_h::sort_small_range<int>(Omega_h::Read<int>, Omega_h::Read<int>*, Omega_h::Read<int>*, Omega_h::Read<int>*) | void sort_small_range(Read<T> a, LOs* p_perm, LOs* p_fan, Read<T>* p_uniq) {
LO ndone = 0;
T value = get_min(a);
Write<LO> tmp_perm(a.size() + 1);
Write<LO> perm(a.size(), -42);
std::vector<LO> fan_vec;
std::vector<T> uniq_vec;
fan_vec.push_back(0);
if (a.size()) {
while (true) {
uniq_vec.push_back(value);
auto const ndid = number_same_values(a, value, tmp_perm);
combine_perms(a, value, tmp_perm, perm, ndone);
ndone += ndid;
fan_vec.push_back(ndone);
if (ndone == a.size()) break;
value = next_smallest_value(a, value);
}
}
HostWrite<LO> h_fan(LO(fan_vec.size()));
for (LO i = 0; i < h_fan.size(); ++i) {
h_fan[i] = fan_vec[std::size_t(i)];
}
HostWrite<T> h_uniq(LO(uniq_vec.size()));
for (LO i = 0; i < h_uniq.size(); ++i) {
h_uniq[i] = uniq_vec[std::size_t(i)];
}
*p_perm = perm;
*p_fan = h_fan.write();
*p_uniq = h_uniq.write();
} | pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp # imm = 0x350
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x2b8(%rbp)
movq %rsi, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq %rdx, -0x98(%rbp)
movq %rcx, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x1d99b0
movq -0x2b0(%rbp), %rdi
callq 0x1c7e60
movl %eax, -0x2a4(%rbp)
jmp 0x563195
leaq -0xb8(%rbp), %rdi
callq 0x1c7d90
movl -0x2a4(%rbp), %ecx
movq -0x2b8(%rbp), %rax
movl %ecx, -0xa8(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5631f3
movq -0x2c0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x563205
movq -0x2c0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
incl %eax
movl %eax, -0x2cc(%rbp)
leaq -0xf9(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x1dfbb0
movq -0x2c8(%rbp), %rdx
leaq 0xce149(%rip), %rsi # 0x63137f
leaq -0xf8(%rbp), %rdi
callq 0x1d5e00
jmp 0x563244
movl -0x2cc(%rbp), %esi
leaq -0xd8(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0x1bc080
jmp 0x56325f
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0xf9(%rbp), %rdi
callq 0x1cf450
movq -0x2b8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2d8(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5632bd
movq -0x2d8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5632cf
movq -0x2d8(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x2, %rax
movl %eax, -0x2e4(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x2e0(%rbp)
callq 0x1dfbb0
movq -0x2e0(%rbp), %rdx
leaq 0xce081(%rip), %rsi # 0x63137f
leaq -0x130(%rbp), %rdi
callq 0x1d5e00
jmp 0x56330c
movl -0x2e4(%rbp), %esi
leaq -0x110(%rbp), %rdi
movl $0xffffffd6, %edx # imm = 0xFFFFFFD6
leaq -0x130(%rbp), %rcx
callq 0x1cbcb0
jmp 0x56332c
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
leaq -0x150(%rbp), %rdi
movq %rdi, -0x2f0(%rbp)
callq 0x1d91a0
leaq -0x168(%rbp), %rdi
callq 0x1d91a0
movq -0x2f0(%rbp), %rdi
movl $0x0, -0x16c(%rbp)
leaq -0x16c(%rbp), %rsi
callq 0x1bd4c0
jmp 0x563382
movq -0x2b8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x2f8(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5633c8
movq -0x2f8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5633da
movq -0x2f8(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x2, %rax
cmpl $0x0, %eax
je 0x563796
jmp 0x5633ed
jmp 0x5633ef
leaq -0x168(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1ba3d0
jmp 0x563404
movq -0x2b8(%rbp), %rsi
leaq -0x180(%rbp), %rdi
callq 0x1d99b0
jmp 0x563419
movl -0xa8(%rbp), %eax
movl %eax, -0x2fc(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1c0f10
jmp 0x56343a
movl -0x2fc(%rbp), %esi
leaq -0x180(%rbp), %rdi
leaq -0x190(%rbp), %rdx
callq 0x1ce7b0
movl %eax, -0x300(%rbp)
jmp 0x56345b
leaq -0x190(%rbp), %rdi
callq 0x1dfdc0
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
movl -0x300(%rbp), %eax
movq -0x2b8(%rbp), %rsi
movl %eax, -0x170(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1d99b0
jmp 0x563494
movl -0xa8(%rbp), %eax
movl %eax, -0x304(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1c0f10
jmp 0x5634b5
leaq -0x1c0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1c0f10
jmp 0x5634ca
movl -0x304(%rbp), %esi
movl -0xa4(%rbp), %r8d
leaq -0x1a0(%rbp), %rdi
leaq -0x1b0(%rbp), %rdx
leaq -0x1c0(%rbp), %rcx
callq 0x1d0550
jmp 0x5634f3
leaq -0x1c0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x1b0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x1a0(%rbp), %rdi
callq 0x1c7d90
movl -0x170(%rbp), %ecx
movl -0xa4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xa4(%rbp)
leaq -0x150(%rbp), %rdi
leaq -0xa4(%rbp), %rsi
callq 0x1ba3d0
jmp 0x563540
movq -0x2b8(%rbp), %rax
movl -0xa4(%rbp), %ecx
movl %ecx, -0x314(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x310(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x563592
movq -0x310(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x5635a4
movq -0x310(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x38(%rbp)
movl -0x314(%rbp), %eax
movq -0x38(%rbp), %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x563725
jmp 0x563794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1c7d90
jmp 0x563c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563614
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x1c4d10
leaq -0xf9(%rbp), %rdi
callq 0x1cf450
jmp 0x563c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563657
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x130(%rbp), %rdi
callq 0x1c4d10
leaq -0x131(%rbp), %rdi
callq 0x1cf450
jmp 0x563c5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5636b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x1dfdc0
leaq -0x180(%rbp), %rdi
callq 0x1c7d90
jmp 0x563c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563714
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563708
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x1b0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x1a0(%rbp), %rdi
callq 0x1c7d90
jmp 0x563c37
movq -0x2b8(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x1d99b0
jmp 0x56373a
movl -0xa8(%rbp), %esi
leaq -0x1d0(%rbp), %rdi
callq 0x1bea80
movl %eax, -0x318(%rbp)
jmp 0x563754
movl -0x318(%rbp), %eax
movl %eax, -0xa8(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1c7d90
jmp 0x5633ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1c7d90
jmp 0x563c37
jmp 0x563796
leaq -0x150(%rbp), %rdi
callq 0x1e4bf0
movl %eax, -0x324(%rbp)
leaq -0x201(%rbp), %rdi
movq %rdi, -0x320(%rbp)
callq 0x1dfbb0
movq -0x320(%rbp), %rdx
leaq 0xcdbb6(%rip), %rsi # 0x63137f
leaq -0x200(%rbp), %rdi
callq 0x1d5e00
jmp 0x5637d7
movl -0x324(%rbp), %esi
leaq -0x1e0(%rbp), %rdi
leaq -0x200(%rbp), %rdx
callq 0x1dde10
jmp 0x5637f2
leaq -0x200(%rbp), %rdi
callq 0x1c4d10
leaq -0x201(%rbp), %rdi
callq 0x1cf450
movl $0x0, -0x208(%rbp)
movl -0x208(%rbp), %eax
movl %eax, -0x328(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x1d3c80
movl %eax, %ecx
movl -0x328(%rbp), %eax
cmpl %ecx, %eax
jge 0x5638c5
movslq -0x208(%rbp), %rsi
leaq -0x150(%rbp), %rdi
callq 0x1c08e0
movl (%rax), %eax
movl %eax, -0x32c(%rbp)
movl -0x208(%rbp), %esi
leaq -0x1e0(%rbp), %rdi
callq 0x1ce010
movl -0x32c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x208(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x208(%rbp)
jmp 0x563814
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5638b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x1c4d10
leaq -0x201(%rbp), %rdi
callq 0x1cf450
jmp 0x563c37
leaq -0x168(%rbp), %rdi
callq 0x1e4bf0
movl %eax, -0x33c(%rbp)
leaq -0x239(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0x1dfbb0
movq -0x338(%rbp), %rdx
leaq 0xcda87(%rip), %rsi # 0x63137f
leaq -0x238(%rbp), %rdi
callq 0x1d5e00
jmp 0x563906
movl -0x33c(%rbp), %esi
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rdx
callq 0x1dde10
jmp 0x563921
leaq -0x238(%rbp), %rdi
callq 0x1c4d10
leaq -0x239(%rbp), %rdi
callq 0x1cf450
movl $0x0, -0x240(%rbp)
movl -0x240(%rbp), %eax
movl %eax, -0x340(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x1d3c80
movl %eax, %ecx
movl -0x340(%rbp), %eax
cmpl %ecx, %eax
jge 0x5639f4
movslq -0x240(%rbp), %rsi
leaq -0x168(%rbp), %rdi
callq 0x1c08e0
movl (%rax), %eax
movl %eax, -0x344(%rbp)
movl -0x240(%rbp), %esi
leaq -0x218(%rbp), %rdi
callq 0x1ce010
movl -0x344(%rbp), %ecx
movl %ecx, (%rax)
movl -0x240(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x240(%rbp)
jmp 0x563943
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x5639e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x1c4d10
leaq -0x239(%rbp), %rdi
callq 0x1cf450
jmp 0x563c2b
leaq -0x260(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1c0f10
jmp 0x563a09
leaq -0x250(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x1cfc00
jmp 0x563a1e
movq -0x90(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x1d1030
jmp 0x563a33
leaq -0x250(%rbp), %rdi
callq 0x1c7d90
leaq -0x260(%rbp), %rdi
callq 0x1dfdc0
leaq -0x280(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x1cb5a0
jmp 0x563a60
leaq -0x270(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0x1cfc00
jmp 0x563a75
movq -0x98(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x1d1030
jmp 0x563a8a
leaq -0x270(%rbp), %rdi
callq 0x1c7d90
leaq -0x280(%rbp), %rdi
callq 0x1dfdc0
leaq -0x2a0(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1cb5a0
jmp 0x563ab7
leaq -0x290(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x1cfc00
jmp 0x563acc
movq -0xa0(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x1d1030
jmp 0x563ae1
leaq -0x290(%rbp), %rdi
callq 0x1c7d90
leaq -0x2a0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x218(%rbp), %rdi
callq 0x1d68e0
leaq -0x1e0(%rbp), %rdi
callq 0x1d68e0
leaq -0x168(%rbp), %rdi
callq 0x1c8350
leaq -0x150(%rbp), %rdi
callq 0x1c8350
leaq -0x110(%rbp), %rdi
callq 0x1dfdc0
leaq -0xd8(%rbp), %rdi
callq 0x1dfdc0
addq $0x350, %rsp # imm = 0x350
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563c1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563b93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x1c7d90
leaq -0x260(%rbp), %rdi
callq 0x1dfdc0
jmp 0x563c1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563bd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x1c7d90
leaq -0x280(%rbp), %rdi
callq 0x1dfdc0
jmp 0x563c1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x563c13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x1c7d90
leaq -0x2a0(%rbp), %rdi
callq 0x1dfdc0
leaq -0x218(%rbp), %rdi
callq 0x1d68e0
leaq -0x1e0(%rbp), %rdi
callq 0x1d68e0
leaq -0x168(%rbp), %rdi
callq 0x1c8350
leaq -0x150(%rbp), %rdi
callq 0x1c8350
leaq -0x110(%rbp), %rdi
callq 0x1dfdc0
leaq -0xd8(%rbp), %rdi
callq 0x1dfdc0
movq -0xc0(%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_sort.cpp |
9,226 | int Omega_h::number_same_values<int>(Omega_h::Read<int>, int, Omega_h::Write<int>) | LO number_same_values(
Read<T> const a, T const value, Write<LO> const tmp_perm) {
tmp_perm.set(0, 0);
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const result = tmp_perm.begin() + 1;
auto const op = plus<LO>();
auto transform = OMEGA_H_LAMBDA(LO i)->LO {
return a[i] == value ? LO(1) : LO(0);
};
transform_inclusive_scan(first, last, result, op, std::move(transform));
return read(tmp_perm).last();
} | pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
movq %rdx, -0x100(%rbp)
movq %rdi, %rax
movq -0x100(%rbp), %rdi
movq %rax, -0xf0(%rbp)
movq %rdi, -0xf8(%rbp)
movq %rax, -0x60(%rbp)
movl %esi, -0x64(%rbp)
movq %rdi, -0x70(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x1c2cc0
movq -0xf0(%rbp), %rdi
leaq -0x74(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x563d1c
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x563d2e
movq -0xe8(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x40(%rbp)
movq -0xf0(%rbp), %rsi
movq -0xf8(%rbp), %rax
movq -0x40(%rbp), %rcx
shrq $0x2, %rcx
leaq -0x78(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %edx
movl %edx, (%rcx)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x4, %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x81(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1d99b0
movq -0x108(%rbp), %rcx
movl -0x64(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0xa4(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq -0x80(%rbp), %rdx
movl -0xa4(%rbp), %edi
movl -0xa8(%rbp), %esi
callq 0x1d1e90
jmp 0x563dcf
movq -0xf8(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x1c0f10
jmp 0x563de4
leaq -0xd0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1d7fd0
jmp 0x563df9
leaq -0xd0(%rbp), %rdi
callq 0x1d2020
movl %eax, -0x10c(%rbp)
jmp 0x563e0d
leaq -0xd0(%rbp), %rdi
callq 0x1c7d90
leaq -0xe0(%rbp), %rdi
callq 0x1dfdc0
leaq -0xa0(%rbp), %rdi
callq 0x1d2de0
movl -0x10c(%rbp), %eax
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x563e92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x563e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x1c7d90
leaq -0xe0(%rbp), %rdi
callq 0x1dfdc0
leaq -0xa0(%rbp), %rdi
callq 0x1d2de0
movq -0xb8(%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_sort.cpp |
9,227 | void Omega_h::combine_perms<int>(Omega_h::Read<int>, int, Omega_h::Write<int>, Omega_h::Write<int>, int) | void combine_perms(Read<T> const a, T const value,
Write<LO> const tmp_perm, Write<LO> const perm, LO ndone) {
tmp_perm.set(0, 0);
auto functor = OMEGA_H_LAMBDA(LO i) {
if (a[i] == value) perm[i] = tmp_perm[i] + ndone;
};
parallel_for(a.size(), std::move(functor));
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rax, -0xb8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rcx, -0xa8(%rbp)
movq %rax, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movl %r8d, -0x44(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x1c2cc0
movq -0xb8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x1d99b0
movq -0xa8(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1c0f10
jmp 0x563f36
movq -0xc0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1c0f10
jmp 0x563f48
movq -0xb8(%rbp), %rax
movl -0x44(%rbp), %ecx
movl %ecx, -0x50(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x563f94
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x563fa6
movq -0xd0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movl %eax, %edi
leaq -0x88(%rbp), %rsi
callq 0x1ccc40
jmp 0x563fbe
leaq -0x88(%rbp), %rdi
callq 0x1c14a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x564005
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x1dfdc0
movq -0xb0(%rbp), %rdi
callq 0x1c7d90
jmp 0x564031
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1c14a0
movq -0x90(%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_sort.cpp |
9,228 | int Omega_h::next_smallest_value<int>(Omega_h::Read<int>, int) | T next_smallest_value(Read<T> const a, T const value) {
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = ArithTraits<T>::max();
auto const op = minimum<T>();
auto transform = OMEGA_H_LAMBDA(LO i)->T {
return (a[i] > value) ? a[i] : init;
};
return transform_reduce(first, last, init, op, std::move(transform));
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x48(%rbp)
movl %esi, -0x4c(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x5640b0
movq -0xa0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5640c2
movq -0xa0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0xa8(%rbp), %rsi
movq -0x28(%rbp), %rax
shrq $0x2, %rax
leaq -0x54(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x7fffffff, -0x58(%rbp) # imm = 0x7FFFFFFF
movb $0x0, -0x59(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1d99b0
movq -0xb8(%rbp), %rcx
movl -0x4c(%rbp), %eax
movl %eax, -0x68(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x7c(%rbp), %edi
movl -0x80(%rbp), %esi
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
callq 0x1d4290
movl %eax, -0xac(%rbp)
jmp 0x564131
leaq -0x78(%rbp), %rdi
callq 0x1e3930
movl -0xac(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1e3930
movq -0x90(%rbp), %rdi
callq 0x1dfa40
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,229 | Omega_h::CompareKeySets<int, 1>::CompareKeySets(int const*) | CompareKeySets(T const* keys) : keys_(keys) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,230 | void std::stable_sort<int*, Omega_h::CompareKeySets<int, 1>>(int*, int*, Omega_h::CompareKeySets<int, 1>) | inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
// concept requirements
__glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIterator>::value_type,
typename iterator_traits<_RandomAccessIterator>::value_type>)
__glibcxx_requires_valid_range(__first, __last);
__glibcxx_requires_irreflexive_pred(__first, __last, __comp);
_GLIBCXX_STD_A::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1d2450
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1e4c80
addq $0x40, %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/stl_algo.h |
9,231 | void std::__stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
if (__first == __last)
return;
// __stable_sort_adaptive sorts the range in two halves,
// so the buffer only needs to fit half the range at once.
_TmpBuf __buf(__first, (__last - __first + 1) / 2);
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x564206
jmp 0x5642dd
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
subq %rsi, %rax
sarq $0x2, %rax
movq %rax, %rcx
incq %rcx
shrq $0x3f, %rcx
leaq 0x1(%rax,%rcx), %rdx
sarq %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1c6980
movq -0x60(%rbp), %rdi
callq 0x1dd6f0
movq %rax, -0x58(%rbp)
jmp 0x564243
movq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x564281
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
callq 0x1ba100
jmp 0x564268
jmp 0x5642d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
jmp 0x5642e6
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1dd6f0
movq %rax, -0x68(%rbp)
jmp 0x5642a0
leaq -0x30(%rbp), %rdi
callq 0x1daec0
movq %rax, -0x80(%rbp)
jmp 0x5642af
movq -0x80(%rbp), %rcx
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1bc6b0
jmp 0x5642d2
jmp 0x5642d4
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1dfa40
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_algo.h |
9,232 | std::_Temporary_buffer<int*, int>::_Temporary_buffer(int*, long) | _Temporary_buffer<_ForwardIterator, _Tp>::
_Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
: _M_original_len(__original_len), _M_len(0), _M_buffer(0)
{
std::pair<pointer, size_type> __p(
std::get_temporary_buffer<value_type>(_M_original_len));
if (__p.first)
{
__try
{
std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
__seed);
_M_buffer = __p.first;
_M_len = __p.second;
}
__catch(...)
{
std::__detail::__return_temporary_buffer(__p.first, __p.second);
__throw_exception_again;
}
}
} | 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, -0x40(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq (%rax), %rdi
callq 0x1e03b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5643d9
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
leaq (%rdi,%rax,4), %rsi
movq -0x10(%rbp), %rdx
callq 0x1dcd60
jmp 0x564381
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5643d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1bf6c0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1dfd10
jmp 0x5643bb
callq 0x1d87c0
jmp 0x5643f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x1dc770
jmp 0x5643d5
jmp 0x5643df
jmp 0x5643d9
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1dfa40
movq %rax, %rdi
callq 0x1e9370
| 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_tempbuf.h |
9,233 | std::_Temporary_buffer<int*, int>::begin() | iterator
begin()
{ return _M_buffer; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tempbuf.h |
9,234 | void std::__inplace_stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq $0xf, %rax
jge 0x564457
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1c5940
jmp 0x5644f7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1ba100
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1ba100
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r9
callq 0x1bef30
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,235 | void std::__stable_sort_adaptive<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
const _Distance __len = (__last - __first + 1) / 2;
const _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size)
{
std::__stable_sort_adaptive(__first, __middle, __buffer,
__buffer_size, __comp);
std::__stable_sort_adaptive(__middle, __last, __buffer,
__buffer_size, __comp);
}
else
{
std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
std::__merge_adaptive(__first, __middle, __last,
_Distance(__middle - __first),
_Distance(__last - __middle),
__buffer, __buffer_size,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x56459e
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r8
callq 0x1bc6b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1bc6b0
jmp 0x5645d8
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
callq 0x1d70f0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1d70f0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x38(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d99f0
addq $0x70, %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_algo.h |
9,236 | std::_Temporary_buffer<int*, int>::size() const | size_type
size() const
{ return _M_len; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tempbuf.h |
9,237 | std::_Temporary_buffer<int*, int>::~_Temporary_buffer() | ~_Temporary_buffer()
{
std::_Destroy(_M_buffer, _M_buffer + _M_len);
std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rdi
leaq (%rdi,%rax,4), %rsi
callq 0x1d6a20
jmp 0x564677
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x1dfd10
addq $0x10, %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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tempbuf.h |
9,238 | std::pair<int*, long> std::get_temporary_buffer<int>(long) | pair<_Tp*, ptrdiff_t>
get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT
{
const ptrdiff_t __max =
__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
if (__len > __max)
__len = __max;
while (__len > 0)
{
_Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
std::nothrow));
if (__tmp != 0)
return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
__len = __len == 1 ? 0 : ((__len + 1) / 2);
}
return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
movq %rax, -0x20(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
jle 0x5646d8
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
movq %rax, -0x18(%rbp)
jmp 0x5646da
cmpq $0x0, -0x18(%rbp)
jle 0x564744
movq -0x18(%rbp), %rdi
shlq $0x2, %rdi
movq 0x193268(%rip), %rsi # 0x6f7958
callq 0x1e4800
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x564715
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1d1cc0
jmp 0x564713
jmp 0x564768
cmpq $0x1, -0x18(%rbp)
jne 0x564724
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x56473a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x5646da
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
callq 0x1c5d40
jmp 0x564766
jmp 0x564768
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %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_tempbuf.h |
9,239 | void std::__uninitialized_construct_buf<int*, int*>(int*, int*, int*) | inline void
__uninitialized_construct_buf(_Pointer __first, _Pointer __last,
_ForwardIterator __seed)
{
typedef typename std::iterator_traits<_Pointer>::value_type
_ValueType;
std::__uninitialized_construct_buf_dispatch<
__has_trivial_constructor(_ValueType)>::
__ucr(__first, __last, __seed);
} | 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 0x1c9590
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_tempbuf.h |
9,240 | void std::__detail::__return_temporary_buffer<int>(int*, unsigned long) | inline void
__return_temporary_buffer(_Tp* __p,
size_t __len __attribute__((__unused__)))
{
#if __cpp_sized_deallocation
::operator delete(__p, __len * sizeof(_Tp));
#else
::operator delete(__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
shlq $0x2, %rsi
callq 0x1ce050
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_tempbuf.h |
9,241 | std::pair<int*, long>::pair<int*&, long&, true>(int*&, long&) | constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
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_pair.h |
9,242 | std::pair<int*, long>::pair<int*, int, true>(int*&&, int&&) | constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq %rcx, 0x8(%rax)
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_pair.h |
9,243 | void std::__uninitialized_construct_buf_dispatch<true>::__ucr<int*, int*>(int*, int*, int*) | static void
__ucr(_Pointer, _Pointer, _ForwardIterator) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
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_tempbuf.h |
9,244 | void std::__merge_without_buffer<int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, long, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x564951
cmpq $0x0, -0x30(%rbp)
jne 0x564956
jmp 0x564b3d
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq $0x2, %rax
jne 0x56498d
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1d86d0
testb $0x1, %al
jne 0x56497b
jmp 0x564988
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c26c0
jmp 0x564b3d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x564a48
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1d5800
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1df670
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x50(%rbp)
jmp 0x564ad0
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1c31d0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
callq 0x1de600
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1c1d30
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %r9
callq 0x1bef30
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %r9
callq 0x1bef30
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,245 | _gnu_cxx::__ops::_Val_comp_iter<Omega_h::CompareKeySets<int, 1>>::_Val_comp_iter(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>&&) | _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,246 | void std::advance<int*, long>(int*&, long) | inline _GLIBCXX17_CONSTEXPR void
advance(_InputIterator& __i, _Distance __n)
{
// concept requirements -- taken care of in __advance
typename iterator_traits<_InputIterator>::difference_type __d = __n;
std::__advance(__i, __d, std::__iterator_category(__i));
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ce9c0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1d0f80
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_iterator_base_funcs.h |
9,247 | void std::__advance<int*, long>(int*&, long, std::random_access_iterator_tag) | inline _GLIBCXX14_CONSTEXPR void
__advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag)
{
// concept requirements
__glibcxx_function_requires(_RandomAccessIteratorConcept<
_RandomAccessIterator>)
if (__builtin_constant_p(__n) && __n == 1)
++__i;
else if (__builtin_constant_p(__n) && __n == -1)
--__i;
else
__i += __n;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
shlq $0x2, %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x5650c0
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_iterator_base_funcs.h |
9,248 | _gnu_cxx::__ops::_Iter_comp_val<Omega_h::CompareKeySets<int, 1>>::_Iter_comp_val(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>&&) | _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,249 | void std::__merge_sort_with_buffer<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
while (__step_size < __len)
{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x7, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
callq 0x1d22d0
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x5657a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1bd5b0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1bd5b0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x565743
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,250 | void std::__merge_adaptive<int*, long, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, long, long, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
__first, __comp);
}
else if (__len2 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
std::__move_merge_adaptive_backward(__first, __middle, __buffer,
__buffer_end, __last, __comp);
}
else
{
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
__len22, __buffer, __buffer_size, __comp);
std::__merge_adaptive(__new_middle, __second_cut, __last,
__len1 - __len11,
__len2 - __len22, __buffer,
__buffer_size, __comp);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %r10
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0x565832
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x565832
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1be6f0
jmp 0x565a88
movq -0x30(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x56587b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %r9
callq 0x1c26d0
jmp 0x565a86
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x56593c
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x1d5800
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rcx
callq 0x1df670
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x78(%rbp)
jmp 0x5659d0
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x1c31d0
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
callq 0x1de600
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1da7d0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d99f0
movq -0xa0(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d99f0
jmp 0x565a88
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,251 | void std::__merge_sort_loop<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;
while (__last - __first >= __two_step)
{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq -0x30(%rbp), %rax
jl 0x565bc8
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %r9
callq 0x1bb660
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x565b57
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e20a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1bb660
addq $0x50, %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/stl_algo.h |
9,252 | int* std::__move_merge<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | _OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
return _GLIBCXX_MOVE3(__first2, __last2,
_GLIBCXX_MOVE3(__first1, __last1,
__result));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x565c6d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x565c76
jmp 0x565ccd
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1d86d0
testb $0x1, %al
jne 0x565c8d
jmp 0x565ca7
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x565cbf
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x565c50
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x1bba80
addq $0x50, %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_algo.h |
9,253 | void std::__move_merge_adaptive<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x565d4d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x565d56
jmp 0x565dad
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1d86d0
testb $0x1, %al
jne 0x565d6d
jmp 0x565d87
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x565d9f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x565d30
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x565dc8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
addq $0x40, %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_algo.h |
9,254 | void std::__move_merge_adaptive_backward<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>) | void
__move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
_BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
return;
}
else if (__first2 == __last2)
return;
--__last1;
--__last2;
while (true)
{
if (__comp(__last2, __last1))
{
*--__result = _GLIBCXX_MOVE(*__last1);
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
return;
}
--__last1;
}
else
{
*--__result = _GLIBCXX_MOVE(*__last2);
if (__first2 == __last2)
return;
--__last2;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x565e10
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x565ed0
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x565e1f
jmp 0x565ed0
jmp 0x565e21
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1d86d0
testb $0x1, %al
jne 0x565e50
jmp 0x565e9b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x565e8d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x565ed0
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x565ecb
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x565ebf
jmp 0x565ed0
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x565e39
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,255 | int* std::__rotate_adaptive<int*, int*, long>(int*, int*, int*, long, long, int*, long) | _BidirectionalIterator1
__rotate_adaptive(_BidirectionalIterator1 __first,
_BidirectionalIterator1 __middle,
_BidirectionalIterator1 __last,
_Distance __len1, _Distance __len2,
_BidirectionalIterator2 __buffer,
_Distance __buffer_size)
{
_BidirectionalIterator2 __buffer_end;
if (__len1 > __len2 && __len2 <= __buffer_size)
{
if (__len2)
{
__buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
_GLIBCXX_MOVE_BACKWARD3(__first, __middle, __last);
return _GLIBCXX_MOVE3(__buffer, __buffer_end, __first);
}
else
return __first;
}
else if (__len1 <= __buffer_size)
{
if (__len1)
{
__buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
_GLIBCXX_MOVE3(__middle, __last, __first);
return _GLIBCXX_MOVE_BACKWARD3(__buffer, __buffer_end, __last);
}
else
return __last;
}
else
return std::rotate(__first, __middle, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x565f66
movq -0x30(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x565f66
cmpq $0x0, -0x30(%rbp)
je 0x565f5c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1c8360
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x8(%rbp)
jmp 0x565fd3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x565fd3
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x565fbe
cmpq $0x0, -0x28(%rbp)
je 0x565fb4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1bba80
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1c8360
movq %rax, -0x8(%rbp)
jmp 0x565fd3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x565fd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1c1d30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,256 | _gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 1>>::_Iter_comp_iter(Omega_h::CompareKeySets<int, 1>) | explicit _GLIBCXX14_CONSTEXPR
_Iter_comp_iter(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp))
{ } | pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %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/predefined_ops.h |
9,257 | Omega_h::CompareKeySets<int, 2>::CompareKeySets(int const*) | CompareKeySets(T const* keys) : keys_(keys) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,258 | void std::stable_sort<int*, Omega_h::CompareKeySets<int, 2>>(int*, int*, Omega_h::CompareKeySets<int, 2>) | inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
// concept requirements
__glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIterator>::value_type,
typename iterator_traits<_RandomAccessIterator>::value_type>)
__glibcxx_requires_valid_range(__first, __last);
__glibcxx_requires_irreflexive_pred(__first, __last, __comp);
_GLIBCXX_STD_A::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1b99a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1d30f0
addq $0x40, %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/stl_algo.h |
9,259 | void std::__stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
if (__first == __last)
return;
// __stable_sort_adaptive sorts the range in two halves,
// so the buffer only needs to fit half the range at once.
_TmpBuf __buf(__first, (__last - __first + 1) / 2);
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x566093
jmp 0x56615a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1c6980
leaq -0x30(%rbp), %rdi
callq 0x1dd6f0
cmpq $0x0, %rax
jne 0x566103
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1df910
jmp 0x5660ea
jmp 0x566151
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
jmp 0x566160
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1dd6f0
movq -0x70(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1daec0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1e3e00
jmp 0x56614f
jmp 0x566151
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,260 | void std::__inplace_stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq $0xf, %rax
jge 0x5661e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1d6670
jmp 0x566287
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1df910
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1df910
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r9
callq 0x1d9c90
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,261 | void std::__stable_sort_adaptive<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
const _Distance __len = (__last - __first + 1) / 2;
const _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size)
{
std::__stable_sort_adaptive(__first, __middle, __buffer,
__buffer_size, __comp);
std::__stable_sort_adaptive(__middle, __last, __buffer,
__buffer_size, __comp);
}
else
{
std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
std::__merge_adaptive(__first, __middle, __last,
_Distance(__middle - __first),
_Distance(__last - __middle),
__buffer, __buffer_size,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x56632e
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r8
callq 0x1e3e00
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1e3e00
jmp 0x566368
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
callq 0x1dab10
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1dab10
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x38(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1c2230
addq $0x70, %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_algo.h |
9,262 | void std::__merge_without_buffer<int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, long, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5664b1
cmpq $0x0, -0x30(%rbp)
jne 0x5664b6
jmp 0x56669d
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq $0x2, %rax
jne 0x5664ed
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1dbd40
testb $0x1, %al
jne 0x5664db
jmp 0x5664e8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c26c0
jmp 0x56669d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x5665a8
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1e0420
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1df9f0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x50(%rbp)
jmp 0x566630
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1d6fe0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
callq 0x1bc210
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1c1d30
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %r9
callq 0x1d9c90
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %r9
callq 0x1d9c90
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,263 | _gnu_cxx::__ops::_Val_comp_iter<Omega_h::CompareKeySets<int, 2>>::_Val_comp_iter(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>&&) | _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,264 | _gnu_cxx::__ops::_Iter_comp_val<Omega_h::CompareKeySets<int, 2>>::_Iter_comp_val(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>&&) | _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,265 | void std::__merge_sort_with_buffer<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
while (__step_size < __len)
{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x7, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
callq 0x1d4580
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x566c77
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1b93a0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1b93a0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x566c13
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,266 | void std::__merge_adaptive<int*, long, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, long, long, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
__first, __comp);
}
else if (__len2 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
std::__move_merge_adaptive_backward(__first, __middle, __buffer,
__buffer_end, __last, __comp);
}
else
{
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
__len22, __buffer, __buffer_size, __comp);
std::__merge_adaptive(__new_middle, __second_cut, __last,
__len1 - __len11,
__len2 - __len22, __buffer,
__buffer_size, __comp);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %r10
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0x566d02
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x566d02
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1da410
jmp 0x566f58
movq -0x30(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x566d4b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %r9
callq 0x1d3b50
jmp 0x566f56
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x566e0c
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x1e0420
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rcx
callq 0x1df9f0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x78(%rbp)
jmp 0x566ea0
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x1d6fe0
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
callq 0x1bc210
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1da7d0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1c2230
movq -0xa0(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1c2230
jmp 0x566f58
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,267 | void std::__merge_sort_loop<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;
while (__last - __first >= __two_step)
{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq -0x30(%rbp), %rax
jl 0x567098
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %r9
callq 0x1ddec0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x567027
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e20a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1ddec0
addq $0x50, %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/stl_algo.h |
9,268 | int* std::__move_merge<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | _OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
return _GLIBCXX_MOVE3(__first2, __last2,
_GLIBCXX_MOVE3(__first1, __last1,
__result));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x56713d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x567146
jmp 0x56719d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1dbd40
testb $0x1, %al
jne 0x56715d
jmp 0x567177
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56718f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x567120
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x1bba80
addq $0x50, %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_algo.h |
9,269 | void std::__move_merge_adaptive<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x56721d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x567226
jmp 0x56727d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1dbd40
testb $0x1, %al
jne 0x56723d
jmp 0x567257
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56726f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x567200
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x567298
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
addq $0x40, %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_algo.h |
9,270 | void std::__move_merge_adaptive_backward<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>) | void
__move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
_BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
return;
}
else if (__first2 == __last2)
return;
--__last1;
--__last2;
while (true)
{
if (__comp(__last2, __last1))
{
*--__result = _GLIBCXX_MOVE(*__last1);
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
return;
}
--__last1;
}
else
{
*--__result = _GLIBCXX_MOVE(*__last2);
if (__first2 == __last2)
return;
--__last2;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5672e0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x5673a0
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x5672ef
jmp 0x5673a0
jmp 0x5672f1
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1dbd40
testb $0x1, %al
jne 0x567320
jmp 0x56736b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x56735d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x5673a0
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x56739b
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x56738f
jmp 0x5673a0
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x567309
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,271 | _gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 2>>::_Iter_comp_iter(Omega_h::CompareKeySets<int, 2>) | explicit _GLIBCXX14_CONSTEXPR
_Iter_comp_iter(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp))
{ } | pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %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/predefined_ops.h |
9,272 | Omega_h::CompareKeySets<int, 3>::CompareKeySets(int const*) | CompareKeySets(T const* keys) : keys_(keys) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,273 | void std::stable_sort<int*, Omega_h::CompareKeySets<int, 3>>(int*, int*, Omega_h::CompareKeySets<int, 3>) | inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
// concept requirements
__glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIterator>::value_type,
typename iterator_traits<_RandomAccessIterator>::value_type>)
__glibcxx_requires_valid_range(__first, __last);
__glibcxx_requires_irreflexive_pred(__first, __last, __comp);
_GLIBCXX_STD_A::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1bf2a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1bc830
addq $0x40, %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/stl_algo.h |
9,274 | void std::__stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
if (__first == __last)
return;
// __stable_sort_adaptive sorts the range in two halves,
// so the buffer only needs to fit half the range at once.
_TmpBuf __buf(__first, (__last - __first + 1) / 2);
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x567463
jmp 0x56752a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1c6980
leaq -0x30(%rbp), %rdi
callq 0x1dd6f0
cmpq $0x0, %rax
jne 0x5674d3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1cdcd0
jmp 0x5674ba
jmp 0x567521
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
jmp 0x567530
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1dd6f0
movq -0x70(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1daec0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1d46b0
jmp 0x56751f
jmp 0x567521
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,275 | void std::__inplace_stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq $0xf, %rax
jge 0x5675b7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1cb640
jmp 0x567657
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1cdcd0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1cdcd0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r9
callq 0x1d1ed0
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,276 | void std::__stable_sort_adaptive<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
const _Distance __len = (__last - __first + 1) / 2;
const _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size)
{
std::__stable_sort_adaptive(__first, __middle, __buffer,
__buffer_size, __comp);
std::__stable_sort_adaptive(__middle, __last, __buffer,
__buffer_size, __comp);
}
else
{
std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
std::__merge_adaptive(__first, __middle, __last,
_Distance(__middle - __first),
_Distance(__last - __middle),
__buffer, __buffer_size,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x5676fe
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r8
callq 0x1d46b0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1d46b0
jmp 0x567738
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
callq 0x1d4520
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1d4520
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x38(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d6960
addq $0x70, %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_algo.h |
9,277 | void std::__merge_without_buffer<int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, long, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x567881
cmpq $0x0, -0x30(%rbp)
jne 0x567886
jmp 0x567a6d
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq $0x2, %rax
jne 0x5678bd
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1c3980
testb $0x1, %al
jne 0x5678ab
jmp 0x5678b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c26c0
jmp 0x567a6d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x567978
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1d19d0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1d2110
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x50(%rbp)
jmp 0x567a00
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1cfa70
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
callq 0x1da240
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1c1d30
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %r9
callq 0x1d1ed0
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %r9
callq 0x1d1ed0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,278 | _gnu_cxx::__ops::_Val_comp_iter<Omega_h::CompareKeySets<int, 3>>::_Val_comp_iter(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>&&) | _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,279 | _gnu_cxx::__ops::_Iter_comp_val<Omega_h::CompareKeySets<int, 3>>::_Iter_comp_val(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>&&) | _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,280 | void std::__merge_sort_with_buffer<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
while (__step_size < __len)
{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x7, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
callq 0x1c9790
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x568047
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1ce4b0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1ce4b0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x567fe3
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,281 | void std::__merge_adaptive<int*, long, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, long, long, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
__first, __comp);
}
else if (__len2 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
std::__move_merge_adaptive_backward(__first, __middle, __buffer,
__buffer_end, __last, __comp);
}
else
{
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
__len22, __buffer, __buffer_size, __comp);
std::__merge_adaptive(__new_middle, __second_cut, __last,
__len1 - __len11,
__len2 - __len22, __buffer,
__buffer_size, __comp);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %r10
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0x5680d2
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x5680d2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1bde90
jmp 0x568328
movq -0x30(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x56811b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %r9
callq 0x1bbdf0
jmp 0x568326
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x5681dc
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x1d19d0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rcx
callq 0x1d2110
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x78(%rbp)
jmp 0x568270
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x1cfa70
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
callq 0x1da240
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1da7d0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d6960
movq -0xa0(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d6960
jmp 0x568328
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,282 | void std::__merge_sort_loop<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;
while (__last - __first >= __two_step)
{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq -0x30(%rbp), %rax
jl 0x568468
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %r9
callq 0x1bd3d0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5683f7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e20a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1bd3d0
addq $0x50, %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/stl_algo.h |
9,283 | int* std::__move_merge<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | _OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
return _GLIBCXX_MOVE3(__first2, __last2,
_GLIBCXX_MOVE3(__first1, __last1,
__result));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x56850d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x568516
jmp 0x56856d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1c3980
testb $0x1, %al
jne 0x56852d
jmp 0x568547
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56855f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x5684f0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x1bba80
addq $0x50, %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_algo.h |
9,284 | void std::__move_merge_adaptive<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5685ed
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5685f6
jmp 0x56864d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1c3980
testb $0x1, %al
jne 0x56860d
jmp 0x568627
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56863f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x5685d0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x568668
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
addq $0x40, %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_algo.h |
9,285 | void std::__move_merge_adaptive_backward<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>) | void
__move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
_BidirectionalIterator1 __last1,
_BidirectionalIterator2 __first2,
_BidirectionalIterator2 __last2,
_BidirectionalIterator3 __result,
_Compare __comp)
{
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, __last2, __result);
return;
}
else if (__first2 == __last2)
return;
--__last1;
--__last2;
while (true)
{
if (__comp(__last2, __last1))
{
*--__result = _GLIBCXX_MOVE(*__last1);
if (__first1 == __last1)
{
_GLIBCXX_MOVE_BACKWARD3(__first2, ++__last2, __result);
return;
}
--__last1;
}
else
{
*--__result = _GLIBCXX_MOVE(*__last2);
if (__first2 == __last2)
return;
--__last2;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5686b0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x568770
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x5686bf
jmp 0x568770
jmp 0x5686c1
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1c3980
testb $0x1, %al
jne 0x5686f0
jmp 0x56873b
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x56872d
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1c8360
jmp 0x568770
movq -0x18(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x56876b
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
movl %ecx, -0x4(%rax)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x56875f
jmp 0x568770
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x5686d9
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,286 | _gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 3>>::_Iter_comp_iter(Omega_h::CompareKeySets<int, 3>) | explicit _GLIBCXX14_CONSTEXPR
_Iter_comp_iter(_Compare __comp)
: _M_comp(_GLIBCXX_MOVE(__comp))
{ } | pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %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/predefined_ops.h |
9,287 | Omega_h::CompareKeySets<int, 4>::CompareKeySets(int const*) | CompareKeySets(T const* keys) : keys_(keys) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %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 | gahansen[P]omega_h/src/Omega_h_sort.cpp |
9,288 | void std::stable_sort<int*, Omega_h::CompareKeySets<int, 4>>(int*, int*, Omega_h::CompareKeySets<int, 4>) | inline void
stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
// concept requirements
__glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
_RandomAccessIterator>)
__glibcxx_function_requires(_BinaryPredicateConcept<_Compare,
typename iterator_traits<_RandomAccessIterator>::value_type,
typename iterator_traits<_RandomAccessIterator>::value_type>)
__glibcxx_requires_valid_range(__first, __last);
__glibcxx_requires_irreflexive_pred(__first, __last, __comp);
_GLIBCXX_STD_A::__stable_sort(__first, __last,
__gnu_cxx::__ops::__iter_comp_iter(__comp));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1bc500
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1dd710
addq $0x40, %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/stl_algo.h |
9,289 | void std::__stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | inline void
__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
_Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type
_ValueType;
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_DistanceType;
typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
if (__first == __last)
return;
// __stable_sort_adaptive sorts the range in two halves,
// so the buffer only needs to fit half the range at once.
_TmpBuf __buf(__first, (__last - __first + 1) / 2);
if (__buf.begin() == 0)
std::__inplace_stable_sort(__first, __last, __comp);
else
std::__stable_sort_adaptive(__first, __last, __buf.begin(),
_DistanceType(__buf.size()), __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x568833
jmp 0x5688fa
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rdx
leaq -0x30(%rbp), %rdi
callq 0x1c6980
leaq -0x30(%rbp), %rdi
callq 0x1dd6f0
cmpq $0x0, %rax
jne 0x5688a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1d8d40
jmp 0x56888a
jmp 0x5688f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
jmp 0x568900
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1dd6f0
movq -0x70(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1daec0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1c96f0
jmp 0x5688ef
jmp 0x5688f1
leaq -0x30(%rbp), %rdi
callq 0x1bdc30
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,290 | void std::__inplace_stable_sort<int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__inplace_stable_sort(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Compare __comp)
{
if (__last - __first < 15)
{
std::__insertion_sort(__first, __last, __comp);
return;
}
_RandomAccessIterator __middle = __first + (__last - __first) / 2;
std::__inplace_stable_sort(__first, __middle, __comp);
std::__inplace_stable_sort(__middle, __last, __comp);
std::__merge_without_buffer(__first, __middle, __last,
__middle - __first,
__last - __middle,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq $0xf, %rax
jge 0x568987
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x1e29b0
jmp 0x568a27
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0x1d8d40
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x1d8d40
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x28(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r9
callq 0x1dfdd0
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,291 | void std::__stable_sort_adaptive<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__stable_sort_adaptive(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
const _Distance __len = (__last - __first + 1) / 2;
const _RandomAccessIterator __middle = __first + __len;
if (__len > __buffer_size)
{
std::__stable_sort_adaptive(__first, __middle, __buffer,
__buffer_size, __comp);
std::__stable_sort_adaptive(__middle, __last, __buffer,
__buffer_size, __comp);
}
else
{
std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
}
std::__merge_adaptive(__first, __middle, __last,
_Distance(__middle - __first),
_Distance(__last - __middle),
__buffer, __buffer_size,
__comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
addq $0x1, %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x568ace
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %r8
callq 0x1c96f0
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1c96f0
jmp 0x568b08
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rcx
callq 0x1e2320
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1e2320
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
sarq $0x2, %rcx
movq -0x18(%rbp), %r8
movq -0x38(%rbp), %rax
subq %rax, %r8
sarq $0x2, %r8
movq -0x20(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1cc3a0
addq $0x70, %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_algo.h |
9,292 | void std::__merge_without_buffer<int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, long, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__merge_without_buffer(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Compare __comp)
{
if (__len1 == 0 || __len2 == 0)
return;
if (__len1 + __len2 == 2)
{
if (__comp(__middle, __first))
std::iter_swap(__first, __middle);
return;
}
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::rotate(__first_cut, __middle, __second_cut);
std::__merge_without_buffer(__first, __first_cut, __new_middle,
__len11, __len22, __comp);
std::__merge_without_buffer(__new_middle, __second_cut, __last,
__len1 - __len11, __len2 - __len22, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x568c51
cmpq $0x0, -0x30(%rbp)
jne 0x568c56
jmp 0x568e3d
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
cmpq $0x2, %rax
jne 0x568c8d
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1e10f0
testb $0x1, %al
jne 0x568c7b
jmp 0x568c88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c26c0
jmp 0x568e3d
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x568d48
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1c7a80
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
callq 0x1dc5c0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x50(%rbp)
jmp 0x568dd0
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x1d3870
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
callq 0x1e2970
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1c1d30
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %r9
callq 0x1dfdd0
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x48(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x50(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %r9
callq 0x1dfdd0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%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_algo.h |
9,293 | _gnu_cxx::__ops::_Val_comp_iter<Omega_h::CompareKeySets<int, 4>>::_Val_comp_iter(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>&&) | _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,294 | _gnu_cxx::__ops::_Iter_comp_val<Omega_h::CompareKeySets<int, 4>>::_Iter_comp_val(__gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>&&) | _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
: _M_comp(std::move(__comp._M_comp))
{ } | 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/predefined_ops.h |
9,295 | void std::__merge_sort_with_buffer<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__merge_sort_with_buffer(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Pointer __buffer, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::difference_type
_Distance;
const _Distance __len = __last - __first;
const _Pointer __buffer_last = __buffer + __len;
_Distance __step_size = _S_chunk_size;
std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
while (__step_size < __len)
{
std::__merge_sort_loop(__first, __last, __buffer,
__step_size, __comp);
__step_size *= 2;
std::__merge_sort_loop(__buffer, __buffer_last, __first,
__step_size, __comp);
__step_size *= 2;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x7, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
callq 0x1ba520
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x569417
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r8
callq 0x1c3ab0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %r8
callq 0x1c3ab0
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x5693b3
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,296 | void std::__merge_adaptive<int*, long, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, long, long, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__merge_adaptive(_BidirectionalIterator __first,
_BidirectionalIterator __middle,
_BidirectionalIterator __last,
_Distance __len1, _Distance __len2,
_Pointer __buffer, _Distance __buffer_size,
_Compare __comp)
{
if (__len1 <= __len2 && __len1 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__first, __middle, __buffer);
std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
__first, __comp);
}
else if (__len2 <= __buffer_size)
{
_Pointer __buffer_end = _GLIBCXX_MOVE3(__middle, __last, __buffer);
std::__move_merge_adaptive_backward(__first, __middle, __buffer,
__buffer_end, __last, __comp);
}
else
{
_BidirectionalIterator __first_cut = __first;
_BidirectionalIterator __second_cut = __middle;
_Distance __len11 = 0;
_Distance __len22 = 0;
if (__len1 > __len2)
{
__len11 = __len1 / 2;
std::advance(__first_cut, __len11);
__second_cut
= std::__lower_bound(__middle, __last, *__first_cut,
__gnu_cxx::__ops::__iter_comp_val(__comp));
__len22 = std::distance(__middle, __second_cut);
}
else
{
__len22 = __len2 / 2;
std::advance(__second_cut, __len22);
__first_cut
= std::__upper_bound(__first, __middle, *__second_cut,
__gnu_cxx::__ops::__val_comp_iter(__comp));
__len11 = std::distance(__first, __first_cut);
}
_BidirectionalIterator __new_middle
= std::__rotate_adaptive(__first_cut, __middle, __second_cut,
__len1 - __len11, __len22, __buffer,
__buffer_size);
std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
__len22, __buffer, __buffer_size, __comp);
std::__merge_adaptive(__new_middle, __second_cut, __last,
__len1 - __len11,
__len2 - __len22, __buffer,
__buffer_size, __comp);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %r10
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0x5694a2
movq -0x28(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x5694a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1cf200
jmp 0x5696f8
movq -0x30(%rbp), %rax
cmpq 0x10(%rbp), %rax
jg 0x5694eb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1bba80
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %r9
callq 0x1bd270
jmp 0x5696f6
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x5695ac
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8bb0
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x1c7a80
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rcx
callq 0x1dc5c0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x78(%rbp)
jmp 0x569640
movq -0x30(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1b8bb0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x1d3870
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rcx
callq 0x1e2970
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x1d5280
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x1da7d0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1cc3a0
movq -0xa0(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq -0x70(%rbp), %rcx
movq -0x30(%rbp), %r8
subq -0x78(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1cc3a0
jmp 0x5696f8
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_algo.h |
9,297 | void std::__merge_sort_loop<int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, long, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__merge_sort_loop(_RandomAccessIterator1 __first,
_RandomAccessIterator1 __last,
_RandomAccessIterator2 __result, _Distance __step_size,
_Compare __comp)
{
const _Distance __two_step = 2 * __step_size;
while (__last - __first >= __two_step)
{
__result = std::__move_merge(__first, __first + __step_size,
__first + __step_size,
__first + __two_step,
__result, __comp);
__first += __two_step;
}
__step_size = std::min(_Distance(__last - __first), __step_size);
std::__move_merge(__first, __first + __step_size,
__first + __step_size, __last, __result, __comp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
cmpq -0x30(%rbp), %rax
jl 0x569838
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %r9
callq 0x1d89f0
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5697c7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1e20a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %r9
callq 0x1d89f0
addq $0x50, %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/stl_algo.h |
9,298 | int* std::__move_merge<int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | _OutputIterator
__move_merge(_InputIterator __first1, _InputIterator __last1,
_InputIterator __first2, _InputIterator __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
return _GLIBCXX_MOVE3(__first2, __last2,
_GLIBCXX_MOVE3(__first1, __last1,
__result));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5698dd
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5698e6
jmp 0x56993d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1e10f0
testb $0x1, %al
jne 0x5698fd
jmp 0x569917
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x56992f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x5698c0
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x1bba80
addq $0x50, %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_algo.h |
9,299 | void std::__move_merge_adaptive<int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>>(int*, int*, int*, int*, int*, __gnu_cxx::__ops::_Iter_comp_iter<Omega_h::CompareKeySets<int, 4>>) | void
__move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
_InputIterator2 __first2, _InputIterator2 __last2,
_OutputIterator __result, _Compare __comp)
{
while (__first1 != __last1 && __first2 != __last2)
{
if (__comp(__first2, __first1))
{
*__result = _GLIBCXX_MOVE(*__first2);
++__first2;
}
else
{
*__result = _GLIBCXX_MOVE(*__first1);
++__first1;
}
++__result;
}
if (__first1 != __last1)
_GLIBCXX_MOVE3(__first1, __last1, __result);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %r9, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x5699bd
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5699c6
jmp 0x569a1d
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x1e10f0
testb $0x1, %al
jne 0x5699dd
jmp 0x5699f7
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x569a0f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x5699a0
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x569a38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1bba80
addq $0x40, %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_algo.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.