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
|
|---|---|---|---|---|---|---|
4,900 | void Omega_h::binary::read_array<long>(std::istream&, Omega_h::Read<long>&, bool, bool) | void read_array(std::istream& stream, Read<T>& array, bool is_compressed,
bool needs_swapping) {
LO size;
read_value(stream, size, needs_swapping);
OMEGA_H_CHECK(size >= 0);
I64 uncompressed_bytes =
static_cast<I64>(static_cast<std::size_t>(size) * sizeof(T));
HostWrite<T> uncompressed(size);
#ifdef OMEGA_H_USE_ZLIB
if (is_compressed) {
I64 compressed_bytes;
read_value(stream, compressed_bytes, needs_swapping);
OMEGA_H_CHECK(compressed_bytes >= 0);
auto compressed = new ::Bytef[compressed_bytes];
stream.read(reinterpret_cast<char*>(compressed), compressed_bytes);
uLong dest_bytes = static_cast<uLong>(uncompressed_bytes);
uLong source_bytes = static_cast<uLong>(compressed_bytes);
::Bytef* uncompressed_ptr =
reinterpret_cast< ::Bytef*>(nonnull(uncompressed.data()));
int ret =
::uncompress(uncompressed_ptr, &dest_bytes, compressed, source_bytes);
OMEGA_H_CHECK(ret == Z_OK);
OMEGA_H_CHECK(dest_bytes == static_cast<uLong>(uncompressed_bytes));
delete[] compressed;
} else
#else
OMEGA_H_CHECK(is_compressed == false);
#endif
{
stream.read(reinterpret_cast<char*>(nonnull(uncompressed.data())),
uncompressed_bytes);
}
array = swap_bytes(Read<T>(uncompressed.write()), needs_swapping);
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movb -0x12(%rbp), %al
leaq -0x18(%rbp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x1d1890
cmpl $0x0, -0x18(%rbp)
jl 0x35854f
jmp 0x358570
leaq 0x2d2b12(%rip), %rdi # 0x62b068
leaq 0x2d82c3(%rip), %rsi # 0x630820
leaq 0x2d825d(%rip), %rdx # 0x6307c1
movl $0x9b, %ecx
movb $0x0, %al
callq 0x1ce550
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xd4(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1dfbb0
movq -0xd0(%rbp), %rdx
leaq 0x2d8ddc(%rip), %rsi # 0x63137f
leaq -0x50(%rbp), %rdi
callq 0x1d5e00
jmp 0x3585ae
movl -0xd4(%rbp), %esi
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1be440
jmp 0x3585c3
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0x51(%rbp), %rdi
callq 0x1cf450
testb $0x1, -0x11(%rbp)
je 0x358786
movq -0x8(%rbp), %rdi
movzbl -0x12(%rbp), %edx
andl $0x1, %edx
leaq -0x70(%rbp), %rsi
callq 0x1c7720
jmp 0x3585f5
cmpq $0x0, -0x70(%rbp)
jl 0x3585fe
jmp 0x358663
leaq 0x2d2a63(%rip), %rdi # 0x62b068
leaq 0x2d821e(%rip), %rsi # 0x63082a
leaq 0x2d81ae(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xa3, %ecx
callq 0x1ce550
jmp 0x358621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x358644
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0x51(%rbp), %rdi
callq 0x1cf450
jmp 0x3588b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3588aa
movq -0x70(%rbp), %rdi
callq 0x1b8200
movq %rax, -0xe0(%rbp)
jmp 0x358675
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x1d3ac0
jmp 0x358693
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4bb0
movq %rax, -0xe8(%rbp)
jmp 0x3586b8
movq -0xe8(%rbp), %rdi
callq 0x1d89a0
movq %rax, -0xf0(%rbp)
jmp 0x3586cd
movq -0xf0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rsi
callq 0x1bed80
movl %eax, -0xf4(%rbp)
jmp 0x3586fe
movl -0xf4(%rbp), %eax
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jne 0x358715
jmp 0x358738
leaq 0x2d294c(%rip), %rdi # 0x62b068
leaq 0x2d8092(%rip), %rsi # 0x6307b5
leaq 0x2d8097(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xac, %ecx
callq 0x1ce550
jmp 0x358738
movq -0x80(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x358744
jmp 0x358767
leaq 0x2d291d(%rip), %rdi # 0x62b068
leaq 0x2d80ee(%rip), %rsi # 0x630840
leaq 0x2d8068(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xad, %ecx
callq 0x1ce550
jmp 0x358767
movq -0x78(%rbp), %rax
movq %rax, -0x100(%rbp)
cmpq $0x0, %rax
je 0x358784
movq -0x100(%rbp), %rdi
callq 0x1d40c0
jmp 0x3587d3
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c4bb0
movq %rax, -0x108(%rbp)
jmp 0x3587a3
movq -0x108(%rbp), %rdi
callq 0x1d89a0
movq %rax, -0x118(%rbp)
jmp 0x3587b8
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdi
movq -0x20(%rbp), %rdx
callq 0x1d3ac0
jmp 0x3587d1
jmp 0x3587d3
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1e02e0
jmp 0x3587e5
leaq -0xb8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1b9dd0
jmp 0x3587fa
movzbl -0x12(%rbp), %edx
andl $0x1, %edx
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1c2dd0
jmp 0x358816
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1bbdc0
jmp 0x358828
leaq -0xa8(%rbp), %rdi
callq 0x1bc010
leaq -0xb8(%rbp), %rdi
callq 0x1bc010
leaq -0xc8(%rbp), %rdi
callq 0x1e1240
leaq -0x30(%rbp), %rdi
callq 0x1ca150
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x35889e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x358892
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1bc010
leaq -0xb8(%rbp), %rdi
callq 0x1bc010
leaq -0xc8(%rbp), %rdi
callq 0x1e1240
leaq -0x30(%rbp), %rdi
callq 0x1ca150
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_file.cpp |
4,901 | void Omega_h::binary::swap_bytes<double>(double&) | void swap_bytes(T& ptr) {
SwapBytes<T>::swap(&ptr);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
bswapq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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_file.cpp |
4,902 | Omega_h::Read<double> Omega_h::binary::swap_bytes<double>(Omega_h::Read<double>, bool) | Read<T> swap_bytes(Read<T> array, bool needs_swapping) {
if (!needs_swapping) return array;
Write<T> out = deep_copy(array);
auto f = OMEGA_H_LAMBDA(LO i) { SwapBytes<T>::swap(&out[i]); };
parallel_for(out.size(), f, "swap_if_needed");
return out;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0xb8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xb0(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x358950
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x1e4220
jmp 0x358b13
movq -0xc0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1cae10
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1dfbb0
movq -0xc8(%rbp), %rdx
leaq 0x2d8a01(%rip), %rsi # 0x63137f
leaq -0x70(%rbp), %rdi
callq 0x1d5e00
jmp 0x358989
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x1b9d50
jmp 0x35899c
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x71(%rbp), %rdi
callq 0x1cf450
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
leaq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c7e70
jmp 0x3589c9
leaq -0x40(%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 0x358a04
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x358a16
movq -0xd0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, %edi
leaq 0x2d7d7f(%rip), %rdx # 0x6307a6
leaq -0x98(%rbp), %rsi
callq 0x1d6ae0
jmp 0x358a35
leaq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1d8720
jmp 0x358a47
movq -0xb8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1ccda0
jmp 0x358a5c
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x98(%rbp), %rdi
callq 0x1e4280
leaq -0x40(%rbp), %rdi
callq 0x1dc900
jmp 0x358b13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x358aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1c4d10
leaq -0x71(%rbp), %rdi
callq 0x1cf450
leaq -0x50(%rbp), %rdi
callq 0x1e0ab0
jmp 0x358b23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x358b08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x358afc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1dc900
leaq -0x98(%rbp), %rdi
callq 0x1e4280
leaq -0x40(%rbp), %rdi
callq 0x1dc900
jmp 0x358b23
movq -0xb0(%rbp), %rax
addq $0xd0, %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_file.cpp |
4,903 | void Omega_h::parallel_for<Omega_h::Read<double> Omega_h::binary::swap_bytes<double>(Omega_h::Read<double>, bool)::'lambda'(int)>(int, double const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1dee90
movq -0x68(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %edi
movl -0x50(%rbp), %esi
callq 0x1bf330
jmp 0x358ba0
leaq -0x48(%rbp), %rdi
callq 0x1e4280
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1e4280
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
4,904 | void Omega_h::binary::write_value<double>(std::ostream&, double, bool) | void write_value(std::ostream& stream, T val, bool needs_swapping) {
if (needs_swapping) swap_bytes(val);
stream.write(reinterpret_cast<const char*>(&val), sizeof(T));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x358c18
leaq -0x10(%rbp), %rdi
callq 0x1e00d0
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x1d47d0
addq $0x20, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_file.cpp |
4,905 | void Omega_h::binary::read_value<double>(std::istream&, double&, bool) | void read_value(std::istream& stream, T& val, bool needs_swapping) {
stream.read(reinterpret_cast<char*>(&val), sizeof(T));
if (needs_swapping) swap_bytes(val);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x1d3ac0
testb $0x1, -0x11(%rbp)
je 0x358c68
movq -0x10(%rbp), %rdi
callq 0x1e00d0
addq $0x20, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_file.cpp |
4,906 | void Omega_h::binary::write_array<double>(std::ostream&, Omega_h::Read<double>, bool, bool) | void write_array(std::ostream& stream, Read<T> array, bool is_compressed,
bool needs_swapping) {
LO size = array.size();
write_value(stream, size, needs_swapping);
Read<T> swapped = swap_bytes(array, needs_swapping);
HostRead<T> uncompressed(swapped);
I64 uncompressed_bytes =
static_cast<I64>(static_cast<std::size_t>(size) * sizeof(T));
#ifdef OMEGA_H_USE_ZLIB
if (is_compressed) {
uLong source_bytes = static_cast<uLong>(uncompressed_bytes);
uLong dest_bytes = ::compressBound(source_bytes);
auto compressed = new ::Bytef[dest_bytes];
int ret = ::compress2(compressed, &dest_bytes,
reinterpret_cast<const ::Bytef*>(nonnull(uncompressed.data())),
source_bytes, Z_BEST_SPEED);
OMEGA_H_CHECK(ret == Z_OK);
I64 compressed_bytes = static_cast<I64>(dest_bytes);
write_value(stream, compressed_bytes, needs_swapping);
stream.write(reinterpret_cast<const char*>(compressed), compressed_bytes);
delete[] compressed;
} else
#else
OMEGA_H_CHECK(is_compressed == false);
#endif
{
stream.write(reinterpret_cast<const char*>(nonnull(uncompressed.data())),
uncompressed_bytes);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rsi, -0xc8(%rbp)
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x31(%rbp)
andb $0x1, %al
movb %al, -0x32(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x358cd8
movq -0xc0(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x358cea
movq -0xc0(%rbp), %rax
movq (%rax), %rax
shrq $0x3, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movl -0x38(%rbp), %esi
movzbl -0x32(%rbp), %edx
andl $0x1, %edx
callq 0x1e4de0
movq -0xc8(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1cae10
movq -0xd0(%rbp), %rsi
movzbl -0x32(%rbp), %edx
andl $0x1, %edx
leaq -0x48(%rbp), %rdi
callq 0x1c3710
jmp 0x358d38
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1cae10
jmp 0x358d53
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1e4bc0
jmp 0x358d65
leaq -0x88(%rbp), %rdi
callq 0x1e0ab0
movslq -0x38(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x90(%rbp)
testb $0x1, -0x31(%rbp)
je 0x358f43
movq -0x90(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x1db6e0
movq %rax, -0xd8(%rbp)
jmp 0x358dad
movq -0xd8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x1b8200
movq %rax, -0xe0(%rbp)
jmp 0x358dd0
movq -0xe0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1d2070
movq %rax, -0xe8(%rbp)
jmp 0x358dfe
movq -0xe8(%rbp), %rdi
callq 0x1e3f10
movq %rax, -0xf8(%rbp)
jmp 0x358e13
movq -0xf8(%rbp), %rdx
movq -0xf0(%rbp), %rdi
movq -0x98(%rbp), %rcx
leaq -0xa0(%rbp), %rsi
movl $0x1, %r8d
callq 0x1c2990
movl %eax, -0xfc(%rbp)
jmp 0x358e42
movl -0xfc(%rbp), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jne 0x358e5c
jmp 0x358ee1
leaq 0x2d2205(%rip), %rdi # 0x62b068
leaq 0x2d794b(%rip), %rsi # 0x6307b5
leaq 0x2d7950(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0x87, %ecx
callq 0x1ce550
jmp 0x358e7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e0ab0
jmp 0x358fb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x358fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1e0ab0
jmp 0x358fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c8170
jmp 0x358fae
movq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movzbl -0x32(%rbp), %edx
andl $0x1, %edx
callq 0x1be9c0
jmp 0x358f08
movq -0x28(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdx
callq 0x1d47d0
jmp 0x358f21
movq -0xa8(%rbp), %rax
movq %rax, -0x108(%rbp)
cmpq $0x0, %rax
je 0x358f41
movq -0x108(%rbp), %rdi
callq 0x1d40c0
jmp 0x358f93
movq -0x28(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1d2070
movq %rax, -0x110(%rbp)
jmp 0x358f60
movq -0x110(%rbp), %rdi
callq 0x1e3f10
movq %rax, -0x120(%rbp)
jmp 0x358f75
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdi
movq -0x90(%rbp), %rdx
callq 0x1d47d0
jmp 0x358f91
jmp 0x358f93
leaq -0x78(%rbp), %rdi
callq 0x1c8170
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x1e0ab0
movq -0x60(%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_file.cpp |
4,907 | void Omega_h::binary::read_array<double>(std::istream&, Omega_h::Read<double>&, bool, bool) | void read_array(std::istream& stream, Read<T>& array, bool is_compressed,
bool needs_swapping) {
LO size;
read_value(stream, size, needs_swapping);
OMEGA_H_CHECK(size >= 0);
I64 uncompressed_bytes =
static_cast<I64>(static_cast<std::size_t>(size) * sizeof(T));
HostWrite<T> uncompressed(size);
#ifdef OMEGA_H_USE_ZLIB
if (is_compressed) {
I64 compressed_bytes;
read_value(stream, compressed_bytes, needs_swapping);
OMEGA_H_CHECK(compressed_bytes >= 0);
auto compressed = new ::Bytef[compressed_bytes];
stream.read(reinterpret_cast<char*>(compressed), compressed_bytes);
uLong dest_bytes = static_cast<uLong>(uncompressed_bytes);
uLong source_bytes = static_cast<uLong>(compressed_bytes);
::Bytef* uncompressed_ptr =
reinterpret_cast< ::Bytef*>(nonnull(uncompressed.data()));
int ret =
::uncompress(uncompressed_ptr, &dest_bytes, compressed, source_bytes);
OMEGA_H_CHECK(ret == Z_OK);
OMEGA_H_CHECK(dest_bytes == static_cast<uLong>(uncompressed_bytes));
delete[] compressed;
} else
#else
OMEGA_H_CHECK(is_compressed == false);
#endif
{
stream.read(reinterpret_cast<char*>(nonnull(uncompressed.data())),
uncompressed_bytes);
}
array = swap_bytes(Read<T>(uncompressed.write()), needs_swapping);
} | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movb -0x12(%rbp), %al
leaq -0x18(%rbp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x1d1890
cmpl $0x0, -0x18(%rbp)
jl 0x358fff
jmp 0x359020
leaq 0x2d2062(%rip), %rdi # 0x62b068
leaq 0x2d7813(%rip), %rsi # 0x630820
leaq 0x2d77ad(%rip), %rdx # 0x6307c1
movl $0x9b, %ecx
movb $0x0, %al
callq 0x1ce550
movslq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xd4(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1dfbb0
movq -0xd0(%rbp), %rdx
leaq 0x2d832c(%rip), %rsi # 0x63137f
leaq -0x50(%rbp), %rdi
callq 0x1d5e00
jmp 0x35905e
movl -0xd4(%rbp), %esi
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1dd440
jmp 0x359073
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0x51(%rbp), %rdi
callq 0x1cf450
testb $0x1, -0x11(%rbp)
je 0x359236
movq -0x8(%rbp), %rdi
movzbl -0x12(%rbp), %edx
andl $0x1, %edx
leaq -0x70(%rbp), %rsi
callq 0x1c7720
jmp 0x3590a5
cmpq $0x0, -0x70(%rbp)
jl 0x3590ae
jmp 0x359113
leaq 0x2d1fb3(%rip), %rdi # 0x62b068
leaq 0x2d776e(%rip), %rsi # 0x63082a
leaq 0x2d76fe(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xa3, %ecx
callq 0x1ce550
jmp 0x3590d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3590f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4d10
leaq -0x51(%rbp), %rdi
callq 0x1cf450
jmp 0x359363
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x35935a
movq -0x70(%rbp), %rdi
callq 0x1b8200
movq %rax, -0xe0(%rbp)
jmp 0x359125
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x1d3ac0
jmp 0x359143
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d7960
movq %rax, -0xe8(%rbp)
jmp 0x359168
movq -0xe8(%rbp), %rdi
callq 0x1dd880
movq %rax, -0xf0(%rbp)
jmp 0x35917d
movq -0xf0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq -0x80(%rbp), %rsi
callq 0x1bed80
movl %eax, -0xf4(%rbp)
jmp 0x3591ae
movl -0xf4(%rbp), %eax
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jne 0x3591c5
jmp 0x3591e8
leaq 0x2d1e9c(%rip), %rdi # 0x62b068
leaq 0x2d75e2(%rip), %rsi # 0x6307b5
leaq 0x2d75e7(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xac, %ecx
callq 0x1ce550
jmp 0x3591e8
movq -0x80(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x3591f4
jmp 0x359217
leaq 0x2d1e6d(%rip), %rdi # 0x62b068
leaq 0x2d763e(%rip), %rsi # 0x630840
leaq 0x2d75b8(%rip), %rdx # 0x6307c1
xorl %eax, %eax
movl $0xad, %ecx
callq 0x1ce550
jmp 0x359217
movq -0x78(%rbp), %rax
movq %rax, -0x100(%rbp)
cmpq $0x0, %rax
je 0x359234
movq -0x100(%rbp), %rdi
callq 0x1d40c0
jmp 0x359283
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d7960
movq %rax, -0x108(%rbp)
jmp 0x359253
movq -0x108(%rbp), %rdi
callq 0x1dd880
movq %rax, -0x118(%rbp)
jmp 0x359268
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdi
movq -0x20(%rbp), %rdx
callq 0x1d3ac0
jmp 0x359281
jmp 0x359283
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1db430
jmp 0x359295
leaq -0xb8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1ccda0
jmp 0x3592aa
movzbl -0x12(%rbp), %edx
andl $0x1, %edx
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1c3710
jmp 0x3592c6
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1d68d0
jmp 0x3592d8
leaq -0xa8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc8(%rbp), %rdi
callq 0x1dc900
leaq -0x30(%rbp), %rdi
callq 0x1d0f00
addq $0x120, %rsp # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x35934e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x359342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xb8(%rbp), %rdi
callq 0x1e0ab0
leaq -0xc8(%rbp), %rdi
callq 0x1dc900
leaq -0x30(%rbp), %rdi
callq 0x1d0f00
movq -0x60(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_file.cpp |
4,908 | void Omega_h::binary::swap_bytes<unsigned long>(unsigned long&) | void swap_bytes(T& ptr) {
SwapBytes<T>::swap(&ptr);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
bswapq %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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_file.cpp |
4,909 | bool std::operator!=<Omega_h::inertia::Rib const>(std::shared_ptr<Omega_h::inertia::Rib const> const&, std::nullptr_t) | _GLIBCXX_NODISCARD inline bool
operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
{ return (bool)__a; } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d02c0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,910 | std::__shared_ptr_access<Omega_h::inertia::Rib const, (__gnu_cxx::_Lock_policy)2, false, false>::operator->() const | element_type*
operator->() const noexcept
{
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c4720
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,911 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::size() const | size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,912 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1c9b70
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,913 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1c9b70
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,914 | _gnu_cxx::__normal_iterator<Omega_h::Vector<3> const*, std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,915 | std::__shared_ptr<Omega_h::inertia::Rib const, (__gnu_cxx::_Lock_policy)2>::operator bool() const | explicit operator bool() const noexcept
{ return _M_ptr != nullptr; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,916 | std::__shared_ptr_access<Omega_h::inertia::Rib const, (__gnu_cxx::_Lock_policy)2, false, false>::_M_get() const | element_type*
_M_get() const noexcept
{ return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cdf60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,917 | std::__shared_ptr<Omega_h::inertia::Rib const, (__gnu_cxx::_Lock_policy)2>::get() const | element_type*
get() const noexcept
{ return _M_ptr; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,918 | _gnu_cxx::__normal_iterator<Omega_h::Vector<3> const*, std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>>::__normal_iterator(Omega_h::Vector<3> const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,919 | std::operator!=(std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>> const&, std::_Rb_tree_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>> const&) | bool
operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_node != __y._M_node; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
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_tree.h |
4,920 | _gnu_cxx::__normal_iterator<Omega_h::ClassPair*, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,921 | std::shared_ptr<Omega_h::inertia::Rib> std::make_shared<Omega_h::inertia::Rib>() | inline shared_ptr<_Tp>
make_shared(_Args&&... __args)
{
typedef typename std::remove_cv<_Tp>::type _Tp_nc;
return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
std::forward<_Args>(__args)...);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1db680
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c3d20
jmp 0x3596b3
leaq -0x9(%rbp), %rdi
callq 0x1d2c30
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x1d2c30
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,922 | std::__shared_ptr_access<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2, false, false>::operator->() const | element_type*
operator->() const noexcept
{
_GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
return _M_get();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e1980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,923 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::push_back(Omega_h::Vector<3> const&) | void
push_back(const value_type& __x)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
__x);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), __x);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x359755
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1b9700
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
jmp 0x359773
movq -0x20(%rbp), %rdi
callq 0x1bf500
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1bb3b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,924 | std::shared_ptr<Omega_h::inertia::Rib const>::shared_ptr<Omega_h::inertia::Rib, void>(std::shared_ptr<Omega_h::inertia::Rib> const&) | shared_ptr(const shared_ptr<_Yp>& __r) noexcept
: __shared_ptr<_Tp>(__r) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c7ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,925 | std::shared_ptr<Omega_h::inertia::Rib> std::allocate_shared<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>>(std::allocator<Omega_h::inertia::Rib> const&) | inline shared_ptr<_Tp>
allocate_shared(const _Alloc& __a, _Args&&... __args)
{
static_assert(!is_array<_Tp>::value, "make_shared<T[]> not supported");
return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
std::forward<_Args>(__args)...);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1df060
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,926 | std::allocator<Omega_h::inertia::Rib>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b8f10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,927 | std::allocator<Omega_h::inertia::Rib>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,928 | std::shared_ptr<Omega_h::inertia::Rib>::shared_ptr<std::allocator<Omega_h::inertia::Rib>>(std::_Sp_alloc_shared_tag<std::allocator<Omega_h::inertia::Rib>>) | shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1beea0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr.h |
4,929 | std::__shared_ptr<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<std::allocator<Omega_h::inertia::Rib>>(std::_Sp_alloc_shared_tag<std::allocator<Omega_h::inertia::Rib>>) | __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
: _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
{ _M_enable_shared_from_this_with(_M_ptr); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq $0x0, (%rsi)
movq %rsi, %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
callq 0x1d8160
movq -0x20(%rbp), %rdi
movq (%rdi), %rsi
callq 0x1ce980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,930 | std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>>(Omega_h::inertia::Rib*&, std::_Sp_alloc_shared_tag<std::allocator<Omega_h::inertia::Rib>>) | __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
_Args&&... __args)
{
typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
auto __guard = std::__allocate_guarded(__a2);
_Sp_cp_type* __mem = __guard.get();
auto __pi = ::new (__mem)
_Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
__guard = nullptr;
_M_pi = __pi;
__p = __pi->_M_ptr();
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x19(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1da800
movq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1c5270
jmp 0x35990f
leaq -0x30(%rbp), %rdi
callq 0x1ca630
movq %rax, -0x70(%rbp)
jmp 0x35991e
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1d8970
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x1d48e0
jmp 0x35994e
leaq -0x51(%rbp), %rdi
callq 0x1d2c30
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b8e70
movq -0x68(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
callq 0x1ba4e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x1e2a70
leaq -0x19(%rbp), %rdi
callq 0x1cc590
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3599df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3599d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x1d2c30
leaq -0x30(%rbp), %rdi
callq 0x1e2a70
leaq -0x19(%rbp), %rdi
callq 0x1cc590
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,931 | std::enable_if<!__has_esft_base<Omega_h::inertia::Rib>::value, void>::type std::__shared_ptr<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2>::_M_enable_shared_from_this_with<Omega_h::inertia::Rib, Omega_h::inertia::Rib>(Omega_h::inertia::Rib*) | typename enable_if<!__has_esft_base<_Yp2>::value>::type
_M_enable_shared_from_this_with(_Yp*) noexcept
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,932 | std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>::allocator<Omega_h::inertia::Rib>(std::allocator<Omega_h::inertia::Rib> const&) | _GLIBCXX20_CONSTEXPR
allocator(const allocator<_Tp1>&) _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1da120
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,933 | std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>> std::__allocate_guarded<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>(std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>&) | __allocated_ptr<_Alloc>
__allocate_guarded(_Alloc& __a)
{
return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1cb9a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x1c28f0
movq -0x18(%rbp), %rax
addq $0x30, %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/allocated_ptr.h |
4,934 | std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::get() | value_type* get() { return std::__to_address(_M_ptr); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ba970
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocated_ptr.h |
4,935 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_Sp_counted_ptr_inplace<>(std::allocator<Omega_h::inertia::Rib>) | _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
: _M_impl(__a)
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2070. allocate_shared should use allocator_traits<A>::construct
allocator_traits<_Alloc>::construct(__a, _M_ptr(),
std::forward<_Args>(__args)...); // might throw
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x1da9b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rsi
movq 0x39e130(%rip), %rcx # 0x6f7c30
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1d8970
movq -0x30(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x1dbf80
leaq -0x11(%rbp), %rdi
callq 0x1d2c30
movq -0x28(%rbp), %rdi
callq 0x1ba4e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1d4710
addq $0x30, %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/shared_ptr_base.h |
4,936 | std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::operator=(std::nullptr_t) | __allocated_ptr&
operator=(std::nullptr_t) noexcept
{
_M_ptr = nullptr;
return *this;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
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/allocated_ptr.h |
4,937 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_M_ptr() | _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x1e1d00
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,938 | std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr() | ~__allocated_ptr()
{
if (_M_ptr != nullptr)
std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x359bc4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x1dd1d0
jmp 0x359bc2
jmp 0x359bc4
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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/allocated_ptr.h |
4,939 | std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1df790
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
4,940 | _gnu_cxx::new_allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,941 | std::allocator_traits<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::allocate(std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1d0c40
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,942 | std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::__allocated_ptr(std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>&, std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>*) | __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
: _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
{ } | 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, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocated_ptr.h |
4,943 | _gnu_cxx::new_allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1d8680
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x359cbb
movabsq $0x666666666666666, %rax # imm = 0x666666666666666
cmpq %rax, -0x10(%rbp)
jbe 0x359cb6
callq 0x1c85c0
callq 0x1be740
imulq $0x28, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,944 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>* std::__to_address<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>(std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>*) | constexpr _Tp*
__to_address(_Tp* __ptr) noexcept
{
static_assert(!std::is_function<_Tp>::value, "not a function pointer");
return __ptr;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/ptr_traits.h |
4,945 | _gnu_cxx::new_allocator<Omega_h::inertia::Rib>::new_allocator(__gnu_cxx::new_allocator<Omega_h::inertia::Rib> const&) | _GLIBCXX20_CONSTEXPR
new_allocator(const new_allocator&) _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,946 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_Impl::_Impl(std::allocator<Omega_h::inertia::Rib>) | explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d1f40
jmp 0x359d2b
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,947 | void std::allocator_traits<std::allocator<Omega_h::inertia::Rib>>::construct<Omega_h::inertia::Rib>(std::allocator<Omega_h::inertia::Rib>&, Omega_h::inertia::Rib*) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c5fd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,948 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace() | ~_Sp_counted_ptr_inplace() noexcept { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0x1ba990
movq -0x10(%rbp), %rdi
callq 0x1b94e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,949 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace() | ~_Sp_counted_ptr_inplace() noexcept { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1bcd30
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x1ce050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,950 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_M_dispose() | virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x1c69f0
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x1ba4e0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x1d3ee0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,951 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_M_destroy() | virtual void
_M_destroy() noexcept
{
__allocator_type __a(_M_impl._M_alloc());
__allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
this->~_Sp_counted_ptr_inplace();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0x1c69f0
movq %rax, %rsi
leaq -0x9(%rbp), %rdi
callq 0x1da800
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x9(%rbp), %rsi
callq 0x1c28f0
movq -0x28(%rbp), %rdi
callq 0x1bcd30
leaq -0x20(%rbp), %rdi
callq 0x1e2a70
leaq -0x9(%rbp), %rdi
callq 0x1cc590
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,952 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_M_get_deleter(std::type_info const&) | virtual void*
_M_get_deleter(const std::type_info& __ti) noexcept override
{
auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
// Check for the fake type_info first, so we don't try to access it
// as a real type_info object. Otherwise, check if it's the real
// type_info for this class. With RTTI enabled we can check directly,
// or call a library function to do it.
if (&__ti == &_Sp_make_shared_tag::_S_ti()
||
#if __cpp_rtti
__ti == typeid(_Sp_make_shared_tag)
#else
_Sp_make_shared_tag::_S_eq(__ti)
#endif
)
return __ptr;
return nullptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba4e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1c00b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x359ebc
movq -0x18(%rbp), %rdi
movq 0x39dea7(%rip), %rsi # 0x6f7d58
callq 0x1c6100
testb $0x1, %al
jne 0x359ebc
jmp 0x359ec6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x359ece
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,953 | std::_Sp_ebo_helper<0, std::allocator<Omega_h::inertia::Rib>, true>::_Sp_ebo_helper(std::allocator<Omega_h::inertia::Rib> const&) | explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d8970
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,954 | void __gnu_cxx::new_allocator<Omega_h::inertia::Rib>::construct<Omega_h::inertia::Rib>(Omega_h::inertia::Rib*) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x1c2d80
movq -0x18(%rbp), %rdi
callq 0x1d8af0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,955 | _gnu_cxx::new_allocator<Omega_h::inertia::Rib>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,956 | void std::allocator_traits<std::allocator<Omega_h::inertia::Rib>>::destroy<Omega_h::inertia::Rib>(std::allocator<Omega_h::inertia::Rib>&, Omega_h::inertia::Rib*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d7000
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,957 | std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>::_Impl::_M_alloc() | _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bfca0
movq %rax, -0x10(%rbp)
jmp 0x359feb
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,958 | void __gnu_cxx::new_allocator<Omega_h::inertia::Rib>::destroy<Omega_h::inertia::Rib>(Omega_h::inertia::Rib*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d7590
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,959 | std::_Sp_ebo_helper<0, std::allocator<Omega_h::inertia::Rib>, true>::_S_get(std::_Sp_ebo_helper<0, std::allocator<Omega_h::inertia::Rib>, true>&) | static _Tp&
_S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,960 | std::_Sp_make_shared_tag::_S_ti() | _GLIBCXX_VISIBILITY(default)
{
alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
return reinterpret_cast<const type_info&>(__tag);
} | pushq %rbp
movq %rsp, %rbp
movq 0x39de3d(%rip), %rax # 0x6f7e78
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/shared_ptr_base.h |
4,961 | _gnu_cxx::__aligned_buffer<Omega_h::inertia::Rib>::_M_ptr() | _Tp*
_M_ptr() noexcept
{ return static_cast<_Tp*>(_M_addr()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0e00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/aligned_buffer.h |
4,962 | _gnu_cxx::__aligned_buffer<Omega_h::inertia::Rib>::_M_addr() | void*
_M_addr() noexcept
{
return static_cast<void*>(&_M_storage);
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/aligned_buffer.h |
4,963 | std::allocator_traits<std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>>::deallocate(std::allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>&, std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1be240
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,964 | _gnu_cxx::new_allocator<std::_Sp_counted_ptr_inplace<Omega_h::inertia::Rib, std::allocator<Omega_h::inertia::Rib>, (__gnu_cxx::_Lock_policy)2>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,965 | _gnu_cxx::new_allocator<Omega_h::inertia::Rib>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,966 | std::__shared_ptr_access<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2, false, false>::_M_get() const | element_type*
_M_get() const noexcept
{ return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bc470
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,967 | std::__shared_ptr<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2>::get() const | element_type*
get() const noexcept
{ return _M_ptr; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,968 | void std::allocator_traits<std::allocator<Omega_h::Vector<3>>>::construct<Omega_h::Vector<3>, Omega_h::Vector<3> const&>(std::allocator<Omega_h::Vector<3>>&, Omega_h::Vector<3>*, Omega_h::Vector<3> const&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1cacc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,969 | void std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_realloc_insert<Omega_h::Vector<3> const&>(__gnu_cxx::__normal_iterator<Omega_h::Vector<3>*, std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>>, Omega_h::Vector<3> const&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0x2d10ec(%rip), %rdx # 0x62b277
callq 0x1c0090
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x1deb60
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1bd0c0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1bb7b0
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
imulq $0x18, -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1b9700
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c23a0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1c8fa0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x1e4e40
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1c23a0
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x1c8fa0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x1e4e40
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x1bbc90
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x18, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
4,970 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1cf400
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,971 | void __gnu_cxx::new_allocator<Omega_h::Vector<3>>::construct<Omega_h::Vector<3>, Omega_h::Vector<3> const&>(Omega_h::Vector<3>*, Omega_h::Vector<3> const&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,972 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_check_len(unsigned long, char const*) const | size_type
_M_check_len(size_type __n, const char* __s) const
{
if (max_size() - size() < __n)
__throw_length_error(__N(__s));
const size_type __len = size() + (std::max)(size(), __n);
return (__len < size() || __len > max_size()) ? max_size() : __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1da850
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1cc290
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x35a387
movq -0x18(%rbp), %rdi
callq 0x1c2520
movq -0x38(%rbp), %rdi
callq 0x1cc290
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1cc290
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1d5870
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x1cc290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x35a3f6
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x1da850
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x35a405
movq -0x38(%rbp), %rdi
callq 0x1da850
movq %rax, -0x58(%rbp)
jmp 0x35a40d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,973 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1cf400
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,974 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_allocate(unsigned long) | pointer
_M_allocate(size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x35a4d2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c1690
movq %rax, -0x20(%rbp)
jmp 0x35a4da
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x35a4da
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,975 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_S_relocate(Omega_h::Vector<3>*, Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1da8e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,976 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ba060
movq %rax, %rdi
callq 0x1d11b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,977 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_S_max_size(std::allocator<Omega_h::Vector<3>> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x555555555555555, %rax # imm = 0x555555555555555
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dc580
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c7650
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,978 | std::_Vector_base<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_M_get_Tp_allocator() const | const _Tp_alloc_type&
_M_get_Tp_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,979 | std::allocator_traits<std::allocator<Omega_h::Vector<3>>>::max_size(std::allocator<Omega_h::Vector<3>> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c93e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,980 | _gnu_cxx::new_allocator<Omega_h::Vector<3>>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd7f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,981 | _gnu_cxx::__normal_iterator<Omega_h::Vector<3>*, std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>>::__normal_iterator(Omega_h::Vector<3>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
4,982 | std::allocator_traits<std::allocator<Omega_h::Vector<3>>>::allocate(std::allocator<Omega_h::Vector<3>>&, unsigned long) | pointer
allocate(allocator_type& __a, size_type __n)
{ return __a.allocate(__n); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1ce580
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
4,983 | _gnu_cxx::new_allocator<Omega_h::Vector<3>>::allocate(unsigned long, void const*) | _GLIBCXX_NODISCARD _Tp*
allocate(size_type __n, const void* = static_cast<const void*>(0))
{
#if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3308. std::allocator<void>().allocate(n)
static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");
#endif
if (__builtin_expect(__n > this->_M_max_size(), false))
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3190. allocator::allocate sometimes returns too little storage
if (__n > (std::size_t(-1) / sizeof(_Tp)))
std::__throw_bad_array_new_length();
std::__throw_bad_alloc();
}
#if __cpp_aligned_new
if (alignof(_Tp) > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
{
std::align_val_t __al = std::align_val_t(alignof(_Tp));
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
}
#endif
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x1dd7f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x35a6bb
movabsq $0xaaaaaaaaaaaaaaa, %rax # imm = 0xAAAAAAAAAAAAAAA
cmpq %rax, -0x10(%rbp)
jbe 0x35a6b6
callq 0x1c85c0
callq 0x1be740
imulq $0x18, -0x10(%rbp), %rdi
callq 0x1cd9b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
4,984 | std::vector<Omega_h::Vector<3>, std::allocator<Omega_h::Vector<3>>>::_S_do_relocate(Omega_h::Vector<3>*, Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1bdaf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,985 | Omega_h::Vector<3>* std::__relocate_a<Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>>(Omega_h::Vector<3>*, Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e3ae0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e3ae0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1e3ae0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x1cdcc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
4,986 | std::enable_if<std::__is_bitwise_relocatable<Omega_h::Vector<3>>::value, Omega_h::Vector<3>*>::type std::__relocate_a_1<Omega_h::Vector<3>, Omega_h::Vector<3>>(Omega_h::Vector<3>*, Omega_h::Vector<3>*, Omega_h::Vector<3>*, std::allocator<Omega_h::Vector<3>>&) | inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
__relocate_a_1(_Tp* __first, _Tp* __last,
_Tp* __result, allocator<_Up>&) noexcept
{
ptrdiff_t __count = __last - __first;
if (__count > 0)
__builtin_memmove(__result, __first, __count * sizeof(_Tp));
return __result + __count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0x35a7ba
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
imulq $0x18, -0x28(%rbp), %rdx
callq 0x1dc5a0
movq -0x18(%rbp), %rax
imulq $0x18, -0x28(%rbp), %rcx
addq %rcx, %rax
addq $0x30, %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_uninitialized.h |
4,987 | std::__shared_ptr<Omega_h::inertia::Rib const, (__gnu_cxx::_Lock_policy)2>::__shared_ptr<Omega_h::inertia::Rib, void>(std::__shared_ptr<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2> const&) | __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
: _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x1d8550
addq $0x10, %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/shared_ptr_base.h |
4,988 | std::__shared_ptr<Omega_h::inertia::Rib, (__gnu_cxx::_Lock_policy)2>::~__shared_ptr() | ~__shared_ptr() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x1ce190
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,989 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::binary::swap_bytes<signed char>(Omega_h::Read<signed char>, bool)::'lambda'(int)>(signed char, signed char, Omega_h::Read<signed char> Omega_h::binary::swap_bytes<signed char>(Omega_h::Read<signed char>, bool)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 0x35a8a5
jmp 0x35a934
movq 0x39d3dc(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1db6f0
movq 0x39d3c5(%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 0x35a92b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x1bb210
jmp 0x35a8fd
jmp 0x35a8ff
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x35a8c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1d8a50
jmp 0x35a93a
leaq -0x50(%rbp), %rdi
callq 0x1d8a50
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
4,990 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::binary::swap_bytes<int>(Omega_h::Read<int>, bool)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::binary::swap_bytes<int>(Omega_h::Read<int>, bool)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 0x35aa25
jmp 0x35aab4
movq 0x39d25c(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1c7020
movq 0x39d245(%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 0x35aaab
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x1e4980
jmp 0x35aa7d
jmp 0x35aa7f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x35aa46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c13c0
jmp 0x35aaba
leaq -0x50(%rbp), %rdi
callq 0x1c13c0
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
4,991 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::binary::swap_bytes<long>(Omega_h::Read<long>, bool)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::binary::swap_bytes<long>(Omega_h::Read<long>, bool)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 0x35abd5
jmp 0x35ac64
movq 0x39d0ac(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1d5240
movq 0x39d095(%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 0x35ac5b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x1ccd60
jmp 0x35ac2d
jmp 0x35ac2f
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x35abf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1c4620
jmp 0x35ac6a
leaq -0x50(%rbp), %rdi
callq 0x1c4620
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
4,992 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::binary::swap_bytes<double>(Omega_h::Read<double>, bool)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::binary::swap_bytes<double>(Omega_h::Read<double>, bool)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 0x35ad85
jmp 0x35ae14
movq 0x39cefc(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1c0070
movq 0x39cee5(%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 0x35ae0b
leaq -0x34(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x1d77b0
jmp 0x35addd
jmp 0x35addf
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x35ada6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e4280
jmp 0x35ae1a
leaq -0x50(%rbp), %rdi
callq 0x1e4280
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
4,993 | Omega_h::filesystem::create_directory(Omega_h::filesystem::path const&) | bool create_directory(path const& p) {
::mode_t const mode = S_IRWXU | S_IRWXG | S_IRWXO;
errno = 0;
int err = ::mkdir(p.c_str(), mode);
if (err != 0) {
if (errno != EEXIST) {
throw filesystem_error(errno, "create_directory");
}
return false;
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1ff, -0x14(%rbp) # imm = 0x1FF
callq 0x1b88b0
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1b9690
movq %rax, %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x1c05f0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x35af76
callq 0x1b88b0
cmpl $0x11, (%rax)
je 0x35af70
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
callq 0x1b88b0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d5e35(%rip), %rdx # 0x630d70
callq 0x1cb7b0
jmp 0x35af42
movq -0x38(%rbp), %rdi
movq 0x39cbbb(%rip), %rsi # 0x6f7b08
movq 0x39ca94(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1c6df0
jmp 0x35af85
movb $0x0, -0x1(%rbp)
jmp 0x35af7a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
4,994 | Omega_h::filesystem::path::c_str() const | path::value_type const* path::c_str() const noexcept {
return native().c_str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c25a0
movq %rax, %rdi
callq 0x1bf7a0
addq $0x10, %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 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
4,995 | Omega_h::filesystem::current_path() | path current_path() {
char buf[1024];
errno = 0;
char* ret = ::getcwd(buf, sizeof(buf));
if (ret == nullptr) {
throw filesystem_error(errno, "current_path");
}
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp # imm = 0x450
movq %rdi, -0x438(%rbp)
movq %rdi, %rax
movq %rax, -0x430(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x1b88b0
movl $0x0, (%rax)
leaq -0x410(%rbp), %rdi
movl $0x400, %esi # imm = 0x400
callq 0x1c2000
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
jne 0x35b07b
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x440(%rbp)
movq %rax, -0x448(%rbp)
callq 0x1b88b0
movq -0x440(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d5d47(%rip), %rdx # 0x630d81
callq 0x1cb7b0
jmp 0x35b041
movq -0x448(%rbp), %rdi
movq 0x39cab9(%rip), %rsi # 0x6f7b08
movq 0x39c992(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0x448(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
callq 0x1c6df0
jmp 0x35b09e
movq -0x438(%rbp), %rdi
movq -0x418(%rbp), %rsi
callq 0x1c36d0
movq -0x430(%rbp), %rax
addq $0x450, %rsp # imm = 0x450
popq %rbp
retq
movq -0x420(%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_filesystem.cpp |
4,996 | Omega_h::filesystem::remove(Omega_h::filesystem::path const&) | bool remove(path const& p) {
errno = 0;
int err = ::remove(p.impl.c_str());
if (err != 0) {
throw filesystem_error(errno, "remove");
}
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1b88b0
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdi
callq 0x1e0350
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x35b13a
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0x28(%rbp)
movq %rax, -0x30(%rbp)
callq 0x1b88b0
movq -0x28(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d5c89(%rip), %rdx # 0x630d8e
callq 0x1cb7b0
jmp 0x35b10c
movq -0x30(%rbp), %rdi
movq 0x39c9f1(%rip), %rsi # 0x6f7b08
movq 0x39c8ca(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1c6df0
jmp 0x35b144
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%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_filesystem.cpp |
4,997 | Omega_h::filesystem::exists(Omega_h::filesystem::path const&) | bool exists(path const& p) { return ::access(p.impl.c_str(), F_OK) != -1; } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x1dd580
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_filesystem.cpp |
4,998 | Omega_h::filesystem::status(Omega_h::filesystem::path const&) | file_status status(path const& p) {
errno = 0;
struct ::stat buf;
int ret = ::stat(p.c_str(), &buf);
if (ret != 0) {
throw filesystem_error(errno, "status");
}
file_type type;
if (buf.st_mode & S_IFREG)
type = file_type::regular;
else if (buf.st_mode & S_IFDIR)
type = file_type::directory;
else if (buf.st_mode & S_IFLNK)
type = file_type::symlink;
else if (buf.st_mode & S_IFBLK)
type = file_type::block;
else if (buf.st_mode & S_IFCHR)
type = file_type::character;
else if (buf.st_mode & S_IFIFO)
type = file_type::fifo;
else
throw filesystem_error(errno, "type_status");
return file_status(type);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1b88b0
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1b9690
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1cb990
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x35b232
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0xc0(%rbp)
movq %rax, -0xc8(%rbp)
callq 0x1b88b0
movq -0xc0(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d5bac(%rip), %rdx # 0x630d9a
callq 0x1cb7b0
jmp 0x35b1f5
movq -0xc8(%rbp), %rdi
movq 0x39c905(%rip), %rsi # 0x6f7b08
movq 0x39c7de(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x1c6df0
jmp 0x35b37d
movl -0x88(%rbp), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0x35b251
movl $0x2, -0xb8(%rbp)
jmp 0x35b361
movl -0x88(%rbp), %eax
andl $0x4000, %eax # imm = 0x4000
cmpl $0x0, %eax
je 0x35b270
movl $0x3, -0xb8(%rbp)
jmp 0x35b35f
movl -0x88(%rbp), %eax
andl $0xa000, %eax # imm = 0xA000
cmpl $0x0, %eax
je 0x35b28f
movl $0x4, -0xb8(%rbp)
jmp 0x35b35d
movl -0x88(%rbp), %eax
andl $0x6000, %eax # imm = 0x6000
cmpl $0x0, %eax
je 0x35b2ae
movl $0x5, -0xb8(%rbp)
jmp 0x35b35b
movl -0x88(%rbp), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
je 0x35b2cd
movl $0x6, -0xb8(%rbp)
jmp 0x35b359
movl -0x88(%rbp), %eax
andl $0x1000, %eax # imm = 0x1000
cmpl $0x0, %eax
je 0x35b2e9
movl $0x7, -0xb8(%rbp)
jmp 0x35b357
movl $0x20, %edi
callq 0x1c1200
movq %rax, -0xd0(%rbp)
movq %rax, -0xd8(%rbp)
callq 0x1b88b0
movq -0xd0(%rbp), %rdi
movl (%rax), %esi
leaq 0x2d5a7f(%rip), %rdx # 0x630d95
callq 0x1cb7b0
jmp 0x35b31d
movq -0xd8(%rbp), %rdi
movq 0x39c7dd(%rip), %rsi # 0x6f7b08
movq 0x39c6b6(%rip), %rdx # 0x6f79e8
callq 0x1de5c0
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x1c6df0
jmp 0x35b37d
jmp 0x35b359
jmp 0x35b35b
jmp 0x35b35d
jmp 0x35b35f
jmp 0x35b361
leaq -0x4(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1e4ad0
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
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_filesystem.cpp |
4,999 | Omega_h::filesystem::remove_all(Omega_h::filesystem::path const&) | std::uintmax_t remove_all(path const& p) {
directory_iterator end;
std::uintmax_t count = 0;
while (true) {
directory_iterator first(p);
if (first == end) break;
if (first->is_directory()) {
count += remove_all(first->path());
} else {
remove(first->path());
++count;
}
}
remove(p);
++count;
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d4aa0
movq $0x0, -0x38(%rbp)
jmp 0x35b3b2
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1e1660
jmp 0x35b3c1
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c59a0
movb %al, -0x71(%rbp)
jmp 0x35b3d3
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x35b3dc
jmp 0x35b413
movl $0x3, -0x70(%rbp)
jmp 0x35b4ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x35b515
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c8f70
jmp 0x35b515
leaq -0x60(%rbp), %rdi
callq 0x1cc0b0
movq %rax, -0x80(%rbp)
jmp 0x35b422
movq -0x80(%rbp), %rdi
callq 0x1ba1d0
movb %al, -0x81(%rbp)
jmp 0x35b433
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x35b43f
jmp 0x35b47f
leaq -0x60(%rbp), %rdi
callq 0x1cc0b0
movq %rax, -0x90(%rbp)
jmp 0x35b451
movq -0x90(%rbp), %rdi
callq 0x1e3b40
movq %rax, %rdi
callq 0x1d9880
movq %rax, -0x98(%rbp)
jmp 0x35b46e
movq -0x98(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x35b4b3
leaq -0x60(%rbp), %rdi
callq 0x1cc0b0
movq %rax, -0xa0(%rbp)
jmp 0x35b491
movq -0xa0(%rbp), %rdi
callq 0x1e3b40
movq %rax, %rdi
callq 0x1be6c0
jmp 0x35b4a7
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c8f70
movl -0x70(%rbp), %eax
testl %eax, %eax
je 0x35b4ce
jmp 0x35b4cc
jmp 0x35b4d3
jmp 0x35b3b0
movq -0x8(%rbp), %rdi
callq 0x1be6c0
jmp 0x35b4de
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c8f70
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x1c8f70
movq -0x68(%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_filesystem.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.