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,300 | void std::_Destroy<Omega_h::Reader::IndentStackEntry*>(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*) | _GLIBCXX20_CONSTEXPR inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type
_Value_type;
#if __cplusplus >= 201103L
// A deleted destructor is trivial, this ensures we reject such types:
static_assert(is_destructible<_Value_type>::value,
"value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return _Destroy_aux<false>::__destroy(__first, __last);
#endif
std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
__destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c0150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h |
4,301 | void std::_Destroy_aux<true>::__destroy<Omega_h::Reader::IndentStackEntry*>(Omega_h::Reader::IndentStackEntry*, Omega_h::Reader::IndentStackEntry*) | static void
__destroy(_ForwardIterator, _ForwardIterator) { } | 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/stl_construct.h |
4,302 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_M_deallocate(Omega_h::Reader::IndentStackEntry*, unsigned long) | void
_M_deallocate(pointer __p, size_t __n)
{
typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
if (__p)
_Tr::deallocate(_M_impl, __p, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348784
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1bf560
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,303 | std::_Vector_base<Omega_h::Reader::IndentStackEntry, std::allocator<Omega_h::Reader::IndentStackEntry>>::_Vector_impl::~_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7900
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,304 | std::allocator_traits<std::allocator<Omega_h::Reader::IndentStackEntry>>::deallocate(std::allocator<Omega_h::Reader::IndentStackEntry>&, Omega_h::Reader::IndentStackEntry*, 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 0x1c1740
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,305 | std::allocator<Omega_h::Reader::IndentStackEntry>::~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 0x1de8d0
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,306 | _gnu_cxx::new_allocator<Omega_h::Reader::IndentStackEntry>::~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,307 | Omega_h::Read<signed char> Omega_h::any_cast<Omega_h::Read<signed char>>(Omega_h::any&) | inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c3360
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3488ac
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x30(%rbp), %rdi
callq 0x1d5260
movq -0x30(%rbp), %rdi
movq 0x3af0c0(%rip), %rsi # 0x6f7960
movq 0x3af129(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bec60
movq -0x20(%rbp), %rax
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,308 | Omega_h::Read<signed char>* Omega_h::any_cast<Omega_h::Read<signed char>>(Omega_h::any*) | inline T* any_cast(any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348901
movq -0x10(%rbp), %rdi
movq 0x3af5ba(%rip), %rsi # 0x6f7ea8
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x3488f8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x34890b
jmp 0x348901
movq $0x0, -0x8(%rbp)
jmp 0x348918
movq -0x10(%rbp), %rdi
callq 0x1e0cb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,309 | Omega_h::Read<signed char>* Omega_h::any::cast<Omega_h::Read<signed char>>() | T* cast() noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<T*>(storage.dynamic)
: reinterpret_cast<T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,310 | bool Omega_h::any_cast<bool>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ded10
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3489ad
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x18(%rbp), %rdi
callq 0x1d5260
movq -0x18(%rbp), %rdi
movq 0x3aefbf(%rip), %rsi # 0x6f7960
movq 0x3af028(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,311 | Omega_h::Read<double> Omega_h::any_cast<Omega_h::Read<double>>(Omega_h::any&) | inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c1130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x348a2c
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x30(%rbp), %rdi
callq 0x1d5260
movq -0x30(%rbp), %rdi
movq 0x3aef40(%rip), %rsi # 0x6f7960
movq 0x3aefa9(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cae10
movq -0x20(%rbp), %rax
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,312 | Omega_h::Read<signed char> Omega_h::any_cast<Omega_h::Read<signed char>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ba2a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x348abc
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x30(%rbp), %rdi
callq 0x1d5260
movq -0x30(%rbp), %rdi
movq 0x3aeeb0(%rip), %rsi # 0x6f7960
movq 0x3aef19(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1bec60
movq -0x20(%rbp), %rax
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,313 | bool const const* Omega_h::any_cast<bool const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348b11
movq -0x10(%rbp), %rdi
movq 0x3af16a(%rip), %rsi # 0x6f7c68
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x348b08
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x348b1b
jmp 0x348b11
movq $0x0, -0x8(%rbp)
jmp 0x348b28
movq -0x10(%rbp), %rdi
callq 0x1d06d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,314 | bool const const* Omega_h::any::cast<bool const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,315 | Omega_h::Read<double>* Omega_h::any_cast<Omega_h::Read<double>>(Omega_h::any*) | inline T* any_cast(any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348b81
movq -0x10(%rbp), %rdi
movq 0x3af442(%rip), %rsi # 0x6f7fb0
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x348b78
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x348b8b
jmp 0x348b81
movq $0x0, -0x8(%rbp)
jmp 0x348b98
movq -0x10(%rbp), %rdi
callq 0x1c82d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,316 | Omega_h::Read<double>* Omega_h::any::cast<Omega_h::Read<double>>() | T* cast() noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<T*>(storage.dynamic)
: reinterpret_cast<T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,317 | Omega_h::Read<signed char> const const* Omega_h::any_cast<Omega_h::Read<signed char> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x348c01
movq -0x10(%rbp), %rdi
movq 0x3af2ba(%rip), %rsi # 0x6f7ea8
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x348bf8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x348c0b
jmp 0x348c01
movq $0x0, -0x8(%rbp)
jmp 0x348c18
movq -0x10(%rbp), %rdi
callq 0x1d26f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,318 | Omega_h::Read<signed char> const const* Omega_h::any::cast<Omega_h::Read<signed char> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,319 | Omega_h::any::any<bool, void>(bool&&) | any(ValueType&& value) {
static_assert(
std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
"T shall satisfy the CopyConstructible requirements.");
this->construct(std::forward<ValueType>(value));
} | 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 0x1c5ee0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,320 | void Omega_h::any::construct<bool>(bool&&) | void construct(ValueType&& value) {
using T = typename std::decay<ValueType>::type;
this->vtable = vtable_for_type<T>();
do_construct<ValueType, T>(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1dd560
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1b85b0
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,321 | Omega_h::any::vtable_type* Omega_h::any::vtable_for_type<bool>() | static vtable_type* vtable_for_type() {
using VTableType = typename std::conditional<requires_allocation<T>::value,
vtable_dynamic<T>, vtable_stack<T>>::type;
static vtable_type table = {
VTableType::type,
VTableType::destroy,
VTableType::copy,
VTableType::move,
VTableType::swap,
};
return &table;
} | pushq %rbp
movq %rsp, %rbp
movq 0x3aeead(%rip), %rax # 0x6f7b78
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_any.hpp |
4,322 | std::enable_if<!requires_allocation<bool>::value, void>::type Omega_h::any::do_construct<bool, bool>(bool&&) | typename std::enable_if<!requires_allocation<T>::value>::type do_construct(
ValueType&& value) {
new (&storage.stack) T(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,323 | Omega_h::any::vtable_stack<bool>::type() | static const std::type_info& type() noexcept { return typeid(T); } | pushq %rbp
movq %rsp, %rbp
movq 0x3aef6d(%rip), %rax # 0x6f7c68
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_any.hpp |
4,324 | Omega_h::any::vtable_stack<bool>::destroy(Omega_h::any::storage_union&) | static void destroy(storage_union& storage) noexcept {
reinterpret_cast<T*>(&storage.stack)->~T();
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,325 | Omega_h::any::vtable_stack<bool>::copy(Omega_h::any::storage_union const&, Omega_h::any::storage_union&) | static void copy(const storage_union& src, storage_union& dest) {
new (&dest.stack) T(reinterpret_cast<const T&>(src.stack));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,326 | Omega_h::any::vtable_stack<bool>::move(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void move(storage_union& src, storage_union& dest) noexcept {
// one of the conditions for using vtable_stack is a nothrow move
// constructor, so this move constructor will never throw a exception.
new (&dest.stack) T(std::move(reinterpret_cast<T&>(src.stack)));
destroy(src);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1d36b0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,327 | Omega_h::any::vtable_stack<bool>::swap(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void swap(storage_union& lhs, storage_union& rhs) noexcept {
std::swap(
reinterpret_cast<T&>(lhs.stack), reinterpret_cast<T&>(rhs.stack));
} | 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 0x1d2e10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,328 | Omega_h::any::any<Omega_h::Vector<3>, void>(Omega_h::Vector<3>&&) | any(ValueType&& value) {
static_assert(
std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
"T shall satisfy the CopyConstructible requirements.");
this->construct(std::forward<ValueType>(value));
} | 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 0x1cb220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,329 | void Omega_h::any::construct<Omega_h::Vector<3>>(Omega_h::Vector<3>&&) | void construct(ValueType&& value) {
using T = typename std::decay<ValueType>::type;
this->vtable = vtable_for_type<T>();
do_construct<ValueType, T>(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c99a0
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1c5b40
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,330 | Omega_h::any::vtable_type* Omega_h::any::vtable_for_type<Omega_h::Vector<3>>() | static vtable_type* vtable_for_type() {
using VTableType = typename std::conditional<requires_allocation<T>::value,
vtable_dynamic<T>, vtable_stack<T>>::type;
static vtable_type table = {
VTableType::type,
VTableType::destroy,
VTableType::copy,
VTableType::move,
VTableType::swap,
};
return &table;
} | pushq %rbp
movq %rsp, %rbp
movq 0x3af11d(%rip), %rax # 0x6f7f68
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_any.hpp |
4,331 | std::enable_if<requires_allocation<Omega_h::Vector<3>>::value, void>::type Omega_h::any::do_construct<Omega_h::Vector<3>, Omega_h::Vector<3>>(Omega_h::Vector<3>&&) | typename std::enable_if<requires_allocation<T>::value>::type do_construct(
ValueType&& value) {
storage.dynamic = new T(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x18, %edi
callq 0x1cd9b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rcx, (%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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,332 | Omega_h::any::vtable_dynamic<Omega_h::Vector<3>>::type() | static const std::type_info& type() noexcept { return typeid(T); } | pushq %rbp
movq %rsp, %rbp
movq 0x3aeee5(%rip), %rax # 0x6f7d90
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_any.hpp |
4,333 | Omega_h::any::vtable_dynamic<Omega_h::Vector<3>>::destroy(Omega_h::any::storage_union&) | static void destroy(storage_union& storage) noexcept {
// assert(reinterpret_cast<T*>(storage.dynamic));
delete reinterpret_cast<T*>(storage.dynamic);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x348edb
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x1ce050
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,334 | Omega_h::any::vtable_dynamic<Omega_h::Vector<3>>::copy(Omega_h::any::storage_union const&, Omega_h::any::storage_union&) | static void copy(const storage_union& src, storage_union& dest) {
dest.dynamic = new T(*reinterpret_cast<const T*>(src.dynamic));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x1cd9b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rcx)
movq -0x10(%rbp), %rax
movq %rcx, (%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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,335 | Omega_h::any::vtable_dynamic<Omega_h::Vector<3>>::move(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void move(storage_union& src, storage_union& dest) noexcept {
dest.dynamic = src.dynamic;
src.dynamic = nullptr;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
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_any.hpp |
4,336 | Omega_h::any::vtable_dynamic<Omega_h::Vector<3>>::swap(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void swap(storage_union& lhs, storage_union& rhs) noexcept {
// just exchage the storage pointers.
std::swap(lhs.dynamic, rhs.dynamic);
} | 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 0x1e4030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,337 | Omega_h::any::any<Omega_h::Vector<2>, void>(Omega_h::Vector<2>&&) | any(ValueType&& value) {
static_assert(
std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
"T shall satisfy the CopyConstructible requirements.");
this->construct(std::forward<ValueType>(value));
} | 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 0x1d8f90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,338 | void Omega_h::any::construct<Omega_h::Vector<2>>(Omega_h::Vector<2>&&) | void construct(ValueType&& value) {
using T = typename std::decay<ValueType>::type;
this->vtable = vtable_for_type<T>();
do_construct<ValueType, T>(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1ce150
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1dadc0
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,339 | Omega_h::any::vtable_type* Omega_h::any::vtable_for_type<Omega_h::Vector<2>>() | static vtable_type* vtable_for_type() {
using VTableType = typename std::conditional<requires_allocation<T>::value,
vtable_dynamic<T>, vtable_stack<T>>::type;
static vtable_type table = {
VTableType::type,
VTableType::destroy,
VTableType::copy,
VTableType::move,
VTableType::swap,
};
return &table;
} | pushq %rbp
movq %rsp, %rbp
movq 0x3aef7d(%rip), %rax # 0x6f7f98
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_any.hpp |
4,340 | std::enable_if<!requires_allocation<Omega_h::Vector<2>>::value, void>::type Omega_h::any::do_construct<Omega_h::Vector<2>, Omega_h::Vector<2>>(Omega_h::Vector<2>&&) | typename std::enable_if<!requires_allocation<T>::value>::type do_construct(
ValueType&& value) {
new (&storage.stack) T(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,341 | Omega_h::any::vtable_stack<Omega_h::Vector<2>>::type() | static const std::type_info& type() noexcept { return typeid(T); } | pushq %rbp
movq %rsp, %rbp
movq 0x3aeb5d(%rip), %rax # 0x6f7bb8
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_any.hpp |
4,342 | Omega_h::any::vtable_stack<Omega_h::Vector<2>>::destroy(Omega_h::any::storage_union&) | static void destroy(storage_union& storage) noexcept {
reinterpret_cast<T*>(&storage.stack)->~T();
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,343 | Omega_h::any::vtable_stack<Omega_h::Vector<2>>::copy(Omega_h::any::storage_union const&, Omega_h::any::storage_union&) | static void copy(const storage_union& src, storage_union& dest) {
new (&dest.stack) T(reinterpret_cast<const T&>(src.stack));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,344 | Omega_h::any::vtable_stack<Omega_h::Vector<2>>::move(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void move(storage_union& src, storage_union& dest) noexcept {
// one of the conditions for using vtable_stack is a nothrow move
// constructor, so this move constructor will never throw a exception.
new (&dest.stack) T(std::move(reinterpret_cast<T&>(src.stack)));
destroy(src);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1bfed0
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,345 | Omega_h::any::vtable_stack<Omega_h::Vector<2>>::swap(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void swap(storage_union& lhs, storage_union& rhs) noexcept {
std::swap(
reinterpret_cast<T&>(lhs.stack), reinterpret_cast<T&>(rhs.stack));
} | 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 0x1db120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,346 | Omega_h::any::any<Omega_h::Vector<1>, void>(Omega_h::Vector<1>&&) | any(ValueType&& value) {
static_assert(
std::is_copy_constructible<typename std::decay<ValueType>::type>::value,
"T shall satisfy the CopyConstructible requirements.");
this->construct(std::forward<ValueType>(value));
} | 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 0x1d6be0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,347 | void Omega_h::any::construct<Omega_h::Vector<1>>(Omega_h::Vector<1>&&) | void construct(ValueType&& value) {
using T = typename std::decay<ValueType>::type;
this->vtable = vtable_for_type<T>();
do_construct<ValueType, T>(std::forward<ValueType>(value));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1cd2c0
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x1d0f70
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,348 | Omega_h::any::vtable_type* Omega_h::any::vtable_for_type<Omega_h::Vector<1>>() | static vtable_type* vtable_for_type() {
using VTableType = typename std::conditional<requires_allocation<T>::value,
vtable_dynamic<T>, vtable_stack<T>>::type;
static vtable_type table = {
VTableType::type,
VTableType::destroy,
VTableType::copy,
VTableType::move,
VTableType::swap,
};
return &table;
} | pushq %rbp
movq %rsp, %rbp
movq 0x3ae775(%rip), %rax # 0x6f7950
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_any.hpp |
4,349 | std::enable_if<!requires_allocation<Omega_h::Vector<1>>::value, void>::type Omega_h::any::do_construct<Omega_h::Vector<1>, Omega_h::Vector<1>>(Omega_h::Vector<1>&&) | typename std::enable_if<!requires_allocation<T>::value>::type do_construct(
ValueType&& value) {
new (&storage.stack) T(std::forward<ValueType>(value));
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,350 | Omega_h::any::vtable_stack<Omega_h::Vector<1>>::type() | static const std::type_info& type() noexcept { return typeid(T); } | pushq %rbp
movq %rsp, %rbp
movq 0x3ae85d(%rip), %rax # 0x6f7a68
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_any.hpp |
4,351 | Omega_h::any::vtable_stack<Omega_h::Vector<1>>::destroy(Omega_h::any::storage_union&) | static void destroy(storage_union& storage) noexcept {
reinterpret_cast<T*>(&storage.stack)->~T();
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,352 | Omega_h::any::vtable_stack<Omega_h::Vector<1>>::copy(Omega_h::any::storage_union const&, Omega_h::any::storage_union&) | static void copy(const storage_union& src, storage_union& dest) {
new (&dest.stack) T(reinterpret_cast<const T&>(src.stack));
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,353 | Omega_h::any::vtable_stack<Omega_h::Vector<1>>::move(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void move(storage_union& src, storage_union& dest) noexcept {
// one of the conditions for using vtable_stack is a nothrow move
// constructor, so this move constructor will never throw a exception.
new (&dest.stack) T(std::move(reinterpret_cast<T&>(src.stack)));
destroy(src);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1ca850
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_any.hpp |
4,354 | Omega_h::any::vtable_stack<Omega_h::Vector<1>>::swap(Omega_h::any::storage_union&, Omega_h::any::storage_union&) | static void swap(storage_union& lhs, storage_union& rhs) noexcept {
std::swap(
reinterpret_cast<T&>(lhs.stack), reinterpret_cast<T&>(rhs.stack));
} | 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 0x1e3a20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,355 | Omega_h::Read<double>& Omega_h::any_cast<Omega_h::Read<double>&>(Omega_h::any&) | inline ValueType any_cast(any& operand) {
auto p = any_cast<typename std::remove_reference<ValueType>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x34933d
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x18(%rbp), %rdi
callq 0x1d5260
movq -0x18(%rbp), %rdi
movq 0x3ae62f(%rip), %rsi # 0x6f7960
movq 0x3ae698(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,356 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::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,357 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d9c40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,358 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1c35f0
movq -0x10(%rbp), %rdi
callq 0x1c92b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,359 | std::allocator<Omega_h::any>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd550
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,360 | std::_Vector_base<Omega_h::any, std::allocator<Omega_h::any>>::_Vector_impl_data::_Vector_impl_data() | _Vector_impl_data() _GLIBCXX_NOEXCEPT
: _M_start(), _M_finish(), _M_end_of_storage()
{ } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,361 | _gnu_cxx::new_allocator<Omega_h::any>::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,362 | double Omega_h::any_cast<double>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0220
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x34948d
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x18(%rbp), %rdi
callq 0x1d5260
movq -0x18(%rbp), %rdi
movq 0x3ae4df(%rip), %rsi # 0x6f7960
movq 0x3ae548(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,363 | Omega_h::Vector<3> Omega_h::any_cast<Omega_h::Vector<3>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cad10
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x349505
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x28(%rbp), %rdi
callq 0x1d5260
movq -0x28(%rbp), %rdi
movq 0x3ae467(%rip), %rsi # 0x6f7960
movq 0x3ae4d0(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,364 | Omega_h::Matrix<3, 3> Omega_h::any_cast<Omega_h::Matrix<3, 3>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5010
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x349595
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x28(%rbp), %rdi
callq 0x1d5260
movq -0x28(%rbp), %rdi
movq 0x3ae3d7(%rip), %rsi # 0x6f7960
movq 0x3ae440(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x48, %edx
callq 0x1c98a0
movq -0x18(%rbp), %rax
addq $0x30, %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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,365 | Omega_h::Read<double> Omega_h::any_cast<Omega_h::Read<double>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c55f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x34962c
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x30(%rbp), %rdi
callq 0x1d5260
movq -0x30(%rbp), %rdi
movq 0x3ae340(%rip), %rsi # 0x6f7960
movq 0x3ae3a9(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cae10
movq -0x20(%rbp), %rax
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,366 | double const const* Omega_h::any_cast<double const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349681
movq -0x10(%rbp), %rdi
movq 0x3ae972(%rip), %rsi # 0x6f7fe0
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x349678
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x34968b
jmp 0x349681
movq $0x0, -0x8(%rbp)
jmp 0x349698
movq -0x10(%rbp), %rdi
callq 0x1d1620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,367 | double const const* Omega_h::any::cast<double const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,368 | Omega_h::Vector<3> const const* Omega_h::any_cast<Omega_h::Vector<3> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3496f1
movq -0x10(%rbp), %rdi
movq 0x3ae6b2(%rip), %rsi # 0x6f7d90
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x3496e8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3496fb
jmp 0x3496f1
movq $0x0, -0x8(%rbp)
jmp 0x349708
movq -0x10(%rbp), %rdi
callq 0x1c44f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,369 | Omega_h::Vector<3> const const* Omega_h::any::cast<Omega_h::Vector<3> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,370 | Omega_h::Matrix<3, 3> const const* Omega_h::any_cast<Omega_h::Matrix<3, 3> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349771
movq -0x10(%rbp), %rdi
movq 0x3ae5c2(%rip), %rsi # 0x6f7d20
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x349768
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x34977b
jmp 0x349771
movq $0x0, -0x8(%rbp)
jmp 0x349788
movq -0x10(%rbp), %rdi
callq 0x1ce2a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,371 | Omega_h::Matrix<3, 3> const const* Omega_h::any::cast<Omega_h::Matrix<3, 3> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,372 | Omega_h::Read<double> const const* Omega_h::any_cast<Omega_h::Read<double> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3497f1
movq -0x10(%rbp), %rdi
movq 0x3ae7d2(%rip), %rsi # 0x6f7fb0
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x3497e8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3497fb
jmp 0x3497f1
movq $0x0, -0x8(%rbp)
jmp 0x349808
movq -0x10(%rbp), %rdi
callq 0x1d7ea0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,373 | Omega_h::Read<double> const const* Omega_h::any::cast<Omega_h::Read<double> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,374 | Omega_h::Vector<2> Omega_h::any_cast<Omega_h::Vector<2>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1c3930
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x34989d
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x28(%rbp), %rdi
callq 0x1d5260
movq -0x28(%rbp), %rdi
movq 0x3ae0cf(%rip), %rsi # 0x6f7960
movq 0x3ae138(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x20(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,375 | Omega_h::Matrix<2, 2> Omega_h::any_cast<Omega_h::Matrix<2, 2>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c7f20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x349925
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x28(%rbp), %rdi
callq 0x1d5260
movq -0x28(%rbp), %rdi
movq 0x3ae047(%rip), %rsi # 0x6f7960
movq 0x3ae0b0(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rcx)
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,376 | Omega_h::Vector<2> const const* Omega_h::any_cast<Omega_h::Vector<2> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349991
movq -0x10(%rbp), %rdi
movq 0x3ae23a(%rip), %rsi # 0x6f7bb8
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x349988
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x34999b
jmp 0x349991
movq $0x0, -0x8(%rbp)
jmp 0x3499a8
movq -0x10(%rbp), %rdi
callq 0x1d56e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,377 | Omega_h::Vector<2> const const* Omega_h::any::cast<Omega_h::Vector<2> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,378 | Omega_h::Matrix<2, 2> const const* Omega_h::any_cast<Omega_h::Matrix<2, 2> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349a01
movq -0x10(%rbp), %rdi
movq 0x3ae1aa(%rip), %rsi # 0x6f7b98
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x3499f8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x349a0b
jmp 0x349a01
movq $0x0, -0x8(%rbp)
jmp 0x349a18
movq -0x10(%rbp), %rdi
callq 0x1d38f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,379 | Omega_h::Matrix<2, 2> const const* Omega_h::any::cast<Omega_h::Matrix<2, 2> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,380 | Omega_h::Vector<1> Omega_h::any_cast<Omega_h::Vector<1>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d7780
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x349aad
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x20(%rbp), %rdi
callq 0x1d5260
movq -0x20(%rbp), %rdi
movq 0x3adebf(%rip), %rsi # 0x6f7960
movq 0x3adf28(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,381 | Omega_h::Matrix<1, 1> Omega_h::any_cast<Omega_h::Matrix<1, 1>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c7fe0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x349b2d
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x20(%rbp), %rdi
callq 0x1d5260
movq -0x20(%rbp), %rdi
movq 0x3ade3f(%rip), %rsi # 0x6f7960
movq 0x3adea8(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,382 | Omega_h::Vector<1> const const* Omega_h::any_cast<Omega_h::Vector<1> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349b81
movq -0x10(%rbp), %rdi
movq 0x3adefa(%rip), %rsi # 0x6f7a68
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x349b78
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x349b8b
jmp 0x349b81
movq $0x0, -0x8(%rbp)
jmp 0x349b98
movq -0x10(%rbp), %rdi
callq 0x1bd930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,383 | Omega_h::Vector<1> const const* Omega_h::any::cast<Omega_h::Vector<1> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,384 | Omega_h::Matrix<1, 1> const const* Omega_h::any_cast<Omega_h::Matrix<1, 1> const>(Omega_h::any const*) | inline const T* any_cast(const any* operand) noexcept {
if (operand == nullptr || !operand->is_typed(typeid(T)))
return nullptr;
else
return operand->cast<T>();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x349bf1
movq -0x10(%rbp), %rdi
movq 0x3ae322(%rip), %rsi # 0x6f7f00
callq 0x1bbed0
movb %al, -0x11(%rbp)
jmp 0x349be8
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x349bfb
jmp 0x349bf1
movq $0x0, -0x8(%rbp)
jmp 0x349c08
movq -0x10(%rbp), %rdi
callq 0x1ba750
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
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_any.hpp |
4,385 | Omega_h::Matrix<1, 1> const const* Omega_h::any::cast<Omega_h::Matrix<1, 1> const>() const | const T* cast() const noexcept {
return requires_allocation<typename std::decay<T>::type>::value
? reinterpret_cast<const T*>(storage.dynamic)
: reinterpret_cast<const T*>(&storage.stack);
} | 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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,386 | std::shared_ptr<Omega_h::ExprOp>::shared_ptr() | constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d2bc0
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.h |
4,387 | std::__shared_ptr<Omega_h::ExprOp, (__gnu_cxx::_Lock_policy)2>::__shared_ptr() | constexpr __shared_ptr() noexcept
: _M_ptr(0), _M_refcount()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x1c5f70
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 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h |
4,388 | std::__shared_ptr<Omega_h::ExprOp, (__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,389 | std::__shared_ptr<Omega_h::ExprOp, (__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<Omega_h::ExprOp, (__gnu_cxx::_Lock_policy)2> const&) | __shared_ptr(const __shared_ptr&) noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %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,390 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dd840
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,391 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::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 0x1dd4e0
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,392 | std::vector<Omega_h::any, std::allocator<Omega_h::any>>::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 0x1dd4e0
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,393 | _gnu_cxx::__normal_iterator<Omega_h::any const*, std::vector<Omega_h::any, std::allocator<Omega_h::any>>>::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,394 | std::shared_ptr<Omega_h::ExprOp> Omega_h::any_cast<std::shared_ptr<Omega_h::ExprOp>>(Omega_h::any const&) | inline ValueType any_cast(const any& operand) {
auto p = any_cast<typename std::add_const<
typename std::remove_reference<ValueType>::type>::type>(&operand);
if (p == nullptr) throw bad_any_cast();
return *p;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c9c80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x349e4c
movl $0x8, %edi
callq 0x1c1200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1c2d80
movq -0x30(%rbp), %rdi
callq 0x1d5260
movq -0x30(%rbp), %rdi
movq 0x3adb20(%rip), %rsi # 0x6f7960
movq 0x3adb89(%rip), %rdx # 0x6f79d0
callq 0x1de5c0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d9100
movq -0x20(%rbp), %rax
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 | gahansen[P]omega_h/src/Omega_h_any.hpp |
4,395 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::push_back(std::shared_ptr<Omega_h::ExprOp> 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 0x349eb5
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x1c4a30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
jmp 0x349ed3
movq -0x20(%rbp), %rdi
callq 0x1c7500
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x1c9de0
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,396 | std::vector<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::~vector() | ~vector() _GLIBCXX_NOEXCEPT
{
std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
_M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_BEFORE_DEALLOC;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x1ca580
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x1d6b60
jmp 0x34a03a
movq -0x20(%rbp), %rdi
callq 0x1be090
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,397 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c4c40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,398 | std::_Vector_base<std::shared_ptr<Omega_h::ExprOp>, std::allocator<std::shared_ptr<Omega_h::ExprOp>>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1cdc40
movq -0x10(%rbp), %rdi
callq 0x1c7cd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
4,399 | std::allocator<std::shared_ptr<Omega_h::ExprOp>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5080
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.