address
string | name
string | code
string | asm
string | file
string | bin
string |
|---|---|---|---|---|---|
0x69d8a
|
std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::vector(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>> const&)
|
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rsi), %rcx
movq %rax, %r15
subq %rcx, %r15
sarq $0x4, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x69dc8
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6a1e8
jmp 0x69dca
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
shlq $0x4, %r15
addq %rax, %r15
movq %r15, 0x10(%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x69df8
movups (%rcx), %xmm0
movups %xmm0, (%rax)
addq $0x10, %rcx
addq $0x10, %rax
jmp 0x69de3
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x69ec6
|
std::pair<unsigned long, Catch::TestCaseHandle>& std::vector<std::pair<unsigned long, Catch::TestCaseHandle>, std::allocator<std::pair<unsigned long, Catch::TestCaseHandle>>>::emplace_back<unsigned int, Catch::TestCaseHandle const&>(unsigned int&&, Catch::TestCaseHandle const&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x69eed
movl (%rdx), %eax
movq %rax, (%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rsi)
addq $0x18, 0x8(%rbx)
jmp 0x69ef5
movq %rbx, %rdi
callq 0x6a22a
movq 0x8(%rbx), %rax
addq $-0x18, %rax
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a026
|
Catch::TestCaseHandle& std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::emplace_back<Catch::TestCaseInfo*, Catch::ITestInvoker*>(Catch::TestCaseInfo*&&, Catch::ITestInvoker*&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6a051
movq (%rdx), %rax
movq (%rcx), %rcx
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
addq $0x10, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a059
movq %rbx, %rdi
callq 0x6a57a
movq 0x8(%rbx), %rax
addq $-0x10, %rax
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a100
|
std::vector<Catch::Detail::unique_ptr<Catch::ITestInvoker>, std::allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>>::~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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x6a128
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6a122
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
jmp 0x6a10f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a141
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a148
|
std::vector<Catch::Detail::unique_ptr<Catch::TestCaseInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>>::~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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x6a16a
movq %r14, %rdi
callq 0x6a18a
addq $0x8, %r14
jmp 0x6a157
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a183
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a1e8
|
_gnu_cxx::new_allocator<Catch::TestCaseHandle>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3b, %rax
jne 0x6a1fd
shlq $0x4, %rdi
jmp 0x175e0
pushq %rax
callq 0x18806
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a204
|
_gnu_cxx::new_allocator<std::pair<unsigned long, Catch::TestCaseHandle>>::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)));
}
|
movabsq $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x6a220
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18817
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a22a
|
void std::vector<std::pair<unsigned long, Catch::TestCaseHandle>, std::allocator<std::pair<unsigned long, Catch::TestCaseHandle>>>::_M_realloc_insert<unsigned int, Catch::TestCaseHandle const&>(__gnu_cxx::__normal_iterator<std::pair<unsigned long, Catch::TestCaseHandle>*, std::vector<std::pair<unsigned long, Catch::TestCaseHandle>, std::allocator<std::pair<unsigned long, Catch::TestCaseHandle>>>>, unsigned int&&, Catch::TestCaseHandle 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2f2af(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6a348
movq %rax, %rsi
movq (%rbx), %r15
movq 0x8(%rbx), %rbp
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r14
testq %rsi, %rsi
movq %rsi, 0x10(%rsp)
je 0x6a293
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6a204
movq %rax, %r13
jmp 0x6a296
xorl %r13d, %r13d
leaq (%r14,%r14,2), %rax
movq (%rsp), %rcx
movl (%rcx), %ecx
movq %rcx, (%r13,%rax,8)
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x8(%r13,%rax,8)
movq %r13, %r14
cmpq %r12, %r15
je 0x6a2dd
movq %r13, %r14
movq %r15, %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r14)
movups (%rax), %xmm0
movups %xmm0, (%r14)
addq $0x18, %rax
addq $0x18, %r14
cmpq %r12, %rax
jne 0x6a2c1
addq $0x18, %r14
cmpq %r12, %rbp
je 0x6a305
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
addq $0x18, %r12
addq $0x18, %r14
cmpq %rbp, %r12
jne 0x6a2e6
testq %r15, %r15
je 0x6a319
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x17610
movq %r13, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a348
|
std::vector<std::pair<unsigned long, Catch::TestCaseHandle>, std::allocator<std::pair<unsigned long, Catch::TestCaseHandle>>>::_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;
}
|
movabsq $0x555555555555555, %rcx # imm = 0x555555555555555
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x6a390
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a39a
|
void std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::_M_realloc_insert<Catch::TestCaseHandle const&>(__gnu_cxx::__normal_iterator<Catch::TestCaseHandle*, std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>, Catch::TestCaseHandle 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2f147(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6a47a
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rbp
movq %r12, %r13
subq %rdi, %r13
sarq $0x4, %r13
testq %rax, %rax
je 0x6a3f1
movq %rdi, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6a1e8
movq %r15, %rdi
movq %rax, %r15
jmp 0x6a3f4
xorl %r15d, %r15d
shlq $0x4, %r13
movq (%rsp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r15,%r13)
movq %r15, %r13
cmpq %r12, %rdi
je 0x6a427
movq %r15, %r13
movq %rdi, %rax
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x10, %rax
addq $0x10, %r13
cmpq %r12, %rax
jne 0x6a412
addq $0x10, %r13
cmpq %r12, %rbp
je 0x6a447
movups (%r12), %xmm0
movups %xmm0, (%r13)
addq $0x10, %r12
addq $0x10, %r13
cmpq %rbp, %r12
jne 0x6a430
testq %rdi, %rdi
je 0x6a458
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r15, (%rbx)
movq %r13, 0x8(%rbx)
shlq $0x4, %r14
addq %r15, %r14
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a47a
|
std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::_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;
}
|
movabsq $0x7ffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x4, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x6a4b4
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a4be
|
std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::vector<__gnu_cxx::__normal_iterator<Catch::TestCaseHandle const*, std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>, void>(__gnu_cxx::__normal_iterator<Catch::TestCaseHandle const*, std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>, __gnu_cxx::__normal_iterator<Catch::TestCaseHandle const*, std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>, std::allocator<Catch::TestCaseHandle> const&)
|
vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__first, __last,
std::__iterator_category(__first));
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x6a500
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a4f7
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a57a
|
void std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::_M_realloc_insert<Catch::TestCaseInfo*, Catch::ITestInvoker*>(__gnu_cxx::__normal_iterator<Catch::TestCaseHandle*, std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>>, Catch::TestCaseInfo*&&, Catch::ITestInvoker*&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2ef5e(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6a47a
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rbp
movq %r12, %r13
subq %rdi, %r13
sarq $0x4, %r13
testq %rax, %rax
je 0x6a5da
movq %rdi, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6a1e8
movq %r15, %rdi
movq %rax, %r15
jmp 0x6a5dd
xorl %r15d, %r15d
shlq $0x4, %r13
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rax, (%r15,%r13)
movq %rcx, 0x8(%r15,%r13)
movq %r15, %r13
cmpq %r12, %rdi
je 0x6a61d
movq %r15, %r13
movq %rdi, %rax
movups (%rax), %xmm0
movups %xmm0, (%r13)
addq $0x10, %rax
addq $0x10, %r13
cmpq %r12, %rax
jne 0x6a608
addq $0x10, %r13
cmpq %r12, %rbp
je 0x6a63d
movups (%r12), %xmm0
movups %xmm0, (%r13)
addq $0x10, %r12
addq $0x10, %r13
cmpq %rbp, %r12
jne 0x6a626
testq %rdi, %rdi
je 0x6a64e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r15, (%rbx)
movq %r13, 0x8(%rbx)
shlq $0x4, %r14
addq %r15, %r14
movq %r14, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a670
|
Catch::TestCaseInfo*& std::vector<Catch::TestCaseInfo*, std::allocator<Catch::TestCaseInfo*>>::emplace_back<Catch::TestCaseInfo*>(Catch::TestCaseInfo*&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6a68e
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x6a696
movq %rbx, %rdi
callq 0x6a6a0
movq 0x8(%rbx), %rax
addq $-0x8, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a6a0
|
void std::vector<Catch::TestCaseInfo*, std::allocator<Catch::TestCaseInfo*>>::_M_realloc_insert<Catch::TestCaseInfo*>(__gnu_cxx::__normal_iterator<Catch::TestCaseInfo**, std::vector<Catch::TestCaseInfo*, std::allocator<Catch::TestCaseInfo*>>>, Catch::TestCaseInfo*&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x2ee3e(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6a77c
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq %r13, 0x8(%rsp)
subq %r12, %r13
movq %r13, %r14
sarq $0x3, %r14
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x6a6fb
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x6a7c0
movq %rax, %rbp
jmp 0x6a6fd
xorl %ebp, %ebp
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rbp,%r14,8)
testq %r13, %r13
jle 0x6a71c
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x17a30
addq %rbp, %r13
addq $0x8, %r13
movq 0x8(%rsp), %rsi
subq %rsi, %r15
testq %r15, %r15
jle 0x6a73b
movq %r13, %rdi
movq %r15, %rdx
callq 0x17a30
testq %r12, %r12
je 0x6a74f
movq 0x10(%rbx), %rsi
subq %r12, %rsi
movq %r12, %rdi
callq 0x17610
addq %r15, %r13
movq %rbp, (%rbx)
movq %r13, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
addq %rbp, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a77c
|
std::vector<Catch::TestCaseInfo*, std::allocator<Catch::TestCaseInfo*>>::_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;
}
|
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x6a7b6
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a7c0
|
_gnu_cxx::new_allocator<Catch::TestCaseInfo*>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x6a7d5
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18831
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a7dc
|
Catch::Detail::unique_ptr<Catch::TestCaseInfo>& std::vector<Catch::Detail::unique_ptr<Catch::TestCaseInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>>::emplace_back<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>(Catch::Detail::unique_ptr<Catch::TestCaseInfo>&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6a804
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a80c
movq %rbx, %rdi
callq 0x6a816
movq 0x8(%rbx), %rax
addq $-0x8, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a816
|
void std::vector<Catch::Detail::unique_ptr<Catch::TestCaseInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>*, std::vector<Catch::Detail::unique_ptr<Catch::TestCaseInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>>>, Catch::Detail::unique_ptr<Catch::TestCaseInfo>&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2ecc9(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6a926
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %r13
subq %rcx, %r13
sarq $0x3, %r13
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x6a871
movq %rcx, %r15
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x6a96a
movq %r15, %rcx
movq %rax, %r15
jmp 0x6a874
xorl %r15d, %r15d
movq (%rbp), %rax
movq %rax, (%r15,%r13,8)
movq $0x0, (%rbp)
movq %r15, %r13
movq %rcx, 0x8(%rsp)
cmpq %r12, %rcx
je 0x6a8be
movq %r15, %r13
movq 0x8(%rsp), %rbp
movq (%rbp), %rax
movq %rax, (%r13)
movq $0x0, (%rbp)
movq %rbp, %rdi
callq 0x6a18a
addq $0x8, %rbp
addq $0x8, %r13
cmpq %r12, %rbp
jne 0x6a899
addq $0x8, %r13
cmpq %r12, %r14
je 0x6a8ec
movq (%r12), %rax
movq %rax, (%r13)
movq $0x0, (%r12)
movq %r12, %rdi
callq 0x6a18a
addq $0x8, %r12
addq $0x8, %r13
cmpq %r14, %r12
jne 0x6a8c7
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6a902
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r15, (%rbx)
movq %r13, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (%r15,%rax,8), %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a926
|
std::vector<Catch::Detail::unique_ptr<Catch::TestCaseInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>>::_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;
}
|
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x6a960
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a96a
|
_gnu_cxx::new_allocator<Catch::Detail::unique_ptr<Catch::TestCaseInfo>>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x6a97f
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18842
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a986
|
Catch::Detail::unique_ptr<Catch::ITestInvoker>& std::vector<Catch::Detail::unique_ptr<Catch::ITestInvoker>, std::allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>>::emplace_back<Catch::Detail::unique_ptr<Catch::ITestInvoker>>(Catch::Detail::unique_ptr<Catch::ITestInvoker>&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6a9ae
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6a9b6
movq %rbx, %rdi
callq 0x6a9c0
movq 0x8(%rbx), %rax
addq $-0x8, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6a9c0
|
void std::vector<Catch::Detail::unique_ptr<Catch::ITestInvoker>, std::allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::ITestInvoker>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::ITestInvoker>*, std::vector<Catch::Detail::unique_ptr<Catch::ITestInvoker>, std::allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>>>, Catch::Detail::unique_ptr<Catch::ITestInvoker>&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2eb1d(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6aabc
movq (%rbx), %r15
movq 0x8(%rbx), %r14
movq %r12, %rbp
subq %r15, %rbp
sarq $0x3, %rbp
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x6aa17
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x6ab00
movq %rax, %r13
jmp 0x6aa1a
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%r13,%rbp,8)
movq $0x0, (%rcx)
movq %r13, %rbp
cmpq %r12, %r15
je 0x6aa57
movq %r13, %rbp
movq %r15, %rax
movq (%rax), %rcx
movq %rcx, (%rbp)
movq $0x0, (%rax)
addq $0x8, %rax
addq $0x8, %rbp
cmpq %r12, %rax
jne 0x6aa3c
addq $0x8, %rbp
cmpq %r12, %r14
je 0x6aa7d
movq (%r12), %rax
movq %rax, (%rbp)
movq $0x0, (%r12)
addq $0x8, %r12
addq $0x8, %rbp
cmpq %r14, %r12
jne 0x6aa60
testq %r15, %r15
je 0x6aa91
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x17610
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6aabc
|
std::vector<Catch::Detail::unique_ptr<Catch::ITestInvoker>, std::allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>>::_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;
}
|
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x6aaf6
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ab00
|
_gnu_cxx::new_allocator<Catch::Detail::unique_ptr<Catch::ITestInvoker>>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x6ab15
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18853
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ab1c
|
std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>::_M_move_assign(std::vector<Catch::TestCaseHandle, std::allocator<Catch::TestCaseHandle>>&&, std::integral_constant<bool, true>)
|
void
_M_move_assign(vector&& __x, true_type) noexcept
{
vector __tmp(get_allocator());
this->_M_impl._M_swap_data(__x._M_impl);
__tmp._M_impl._M_swap_data(__x._M_impl);
std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
}
|
movq %rsi, %rax
movq %rdi, %rcx
movq (%rdi), %rdi
movq 0x10(%rcx), %rsi
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x6ab52
subq %rdi, %rsi
jmp 0x17610
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ab54
|
Catch::TestCaseTracking::NameAndLocation::NameAndLocation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, Catch::SourceLineInfo const&)
|
pointer
_M_local_data()
{
#if __cplusplus >= 201103L
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
#else
return pointer(_M_local_buf);
#endif
}
|
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq (%rsi), %r8
leaq 0x10(%rsi), %rax
cmpq %rax, %r8
je 0x6ab73
movq %r8, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x6ab79
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movups (%rdx), %xmm0
movups %xmm0, 0x20(%rdi)
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b308
|
Catch::TestCaseTracking::SectionTracker::addNextFilters(std::vector<Catch::StringRef, std::allocator<Catch::StringRef>> const&)
|
size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
|
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
movq %rcx, %rax
subq %rdx, %rax
cmpq $0x11, %rax
jb 0x6b32c
movq 0x70(%rdi), %rsi
addq $0x68, %rdi
addq $0x10, %rdx
jmp 0x6bc2a
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b546
|
Catch::TestCaseTracking::SectionTracker::addInitialFilters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
|
explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { }
|
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
cmpq %rax, %rcx
je 0x6b621
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %r15
movq 0x70(%rdi), %rdx
subq 0x68(%rdi), %rdx
sarq $0x4, %rdx
subq %rcx, %rax
sarq $0x5, %rax
leaq (%rax,%rdx), %rsi
addq $0x2, %rsi
movq %r15, %rdi
callq 0x6b75e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x35d7a(%rip), %r12 # 0xa1316
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x70(%r14), %rsi
cmpq 0x78(%r14), %rsi
je 0x6b5c1
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x70(%r14)
jmp 0x6b5cc
movq %rsp, %rdx
movq %r15, %rdi
callq 0x6864c
movq 0x70(%r14), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
cmpq 0x78(%r14), %rsi
je 0x6b5f8
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x70(%r14)
jmp 0x6b603
movq %rsp, %rdx
movq %r15, %rdi
callq 0x6864c
movq 0x70(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r15, %rdi
callq 0x6ba1a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b664
|
std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>::~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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x6b68c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6b686
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x6b673
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6b6a5
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b884
|
Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>& std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>::emplace_back<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>(Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6b8ac
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6b8b4
movq %rbx, %rdi
callq 0x6b8be
movq 0x8(%rbx), %rax
addq $-0x8, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b8be
|
void std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>*, std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>>, Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2dc1f(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6b9ba
movq (%rbx), %r15
movq 0x8(%rbx), %r14
movq %r12, %rbp
subq %r15, %rbp
sarq $0x3, %rbp
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x6b915
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x6b9fe
movq %rax, %r13
jmp 0x6b918
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%r13,%rbp,8)
movq $0x0, (%rcx)
movq %r13, %rbp
cmpq %r12, %r15
je 0x6b955
movq %r13, %rbp
movq %r15, %rax
movq (%rax), %rcx
movq %rcx, (%rbp)
movq $0x0, (%rax)
addq $0x8, %rax
addq $0x8, %rbp
cmpq %r12, %rax
jne 0x6b93a
addq $0x8, %rbp
cmpq %r12, %r14
je 0x6b97b
movq (%r12), %rax
movq %rax, (%rbp)
movq $0x0, (%r12)
addq $0x8, %r12
addq $0x8, %rbp
cmpq %r14, %r12
jne 0x6b95e
testq %r15, %r15
je 0x6b98f
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x17610
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b9ba
|
std::vector<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>, std::allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>>::_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;
}
|
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x3, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x6b9f4
cmpq %rsi, %r8
cmovaq %r8, %rsi
leaq (%rsi,%r8), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %r8, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6b9fe
|
_gnu_cxx::new_allocator<Catch::Detail::unique_ptr<Catch::TestCaseTracking::ITracker>>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x6ba13
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x1887d
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ccd0
|
Catch::TextFlow::Columns::iterator::operator!=(Catch::TextFlow::Columns::iterator const&) const
|
size_type
size() const _GLIBCXX_NOEXCEPT
{ return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
|
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
movq %rcx, %rax
subq %rdx, %rax
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rsi
subq %rdi, %rsi
cmpq %rsi, %rax
jne 0x6cd3b
cmpq %rcx, %rdx
sete %al
je 0x6cd3d
movq 0x8(%rdx), %rsi
xorl %eax, %eax
cmpq 0x8(%rdi), %rsi
jne 0x6cd3d
movq (%rdi), %rsi
cmpq %rsi, (%rdx)
jne 0x6cd3d
addq $0x28, %rdx
addq $0x30, %rdi
cmpq %rcx, %rdx
sete %al
je 0x6cd3d
movq 0x8(%rdx), %rsi
xorl %eax, %eax
cmpq (%rdi), %rsi
jne 0x6cd3d
leaq 0x28(%rdx), %rsi
movq -0x8(%rdi), %r8
addq $0x28, %rdi
cmpq %r8, (%rdx)
movq %rsi, %rdx
je 0x6cd12
jmp 0x6cd3d
xorl %eax, %eax
xorb $0x1, %al
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6cd40
|
std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>::push_back(Catch::TextFlow::Column 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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq 0x10(%rdi), %r15
je 0x6cd8a
leaq 0x10(%r15), %rax
movq %rax, (%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x20f36
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r15)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x20(%r15)
addq $0x38, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x6d16c
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6cd9e
|
std::vector<Catch::TextFlow::Column::const_iterator, std::allocator<Catch::TextFlow::Column::const_iterator>>::vector(std::vector<Catch::TextFlow::Column::const_iterator, std::allocator<Catch::TextFlow::Column::const_iterator>> const&)
|
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rsi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x6cdea
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6ce36
jmp 0x6cdec
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,8), %rcx
movq %rcx, 0x10(%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x6ce2b
movq 0x20(%rcx), %rsi
movq %rsi, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x28, %rcx
addq $0x28, %rax
jmp 0x6ce06
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ce36
|
_gnu_cxx::new_allocator<Catch::TextFlow::Column::const_iterator>::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)));
}
|
movabsq $0x333333333333334, %rax # imm = 0x333333333333334
cmpq %rax, %rsi
jae 0x6ce52
shlq $0x3, %rsi
leaq (%rsi,%rsi,4), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x1889f
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ce5b
|
void std::_Destroy<Catch::TextFlow::Column*>(Catch::TextFlow::Column*, Catch::TextFlow::Column*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x6ce99
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x6ce82
movq (%r14), %rsi
incq %rsi
callq 0x17610
leaq 0x38(%r14), %rax
addq $0x28, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x6ce6e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_construct.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ce9a
|
std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>::vector(std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>> const&)
|
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{
this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq (%rsi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %r15 # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x6cee9
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6cf32
movq %rax, %rdx
jmp 0x6ceeb
xorl %edx, %edx
movq %rdx, (%rbx)
movq %rdx, 0x8(%rbx)
imulq $0x38, %r15, %rax
addq %rdx, %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x6cf54
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6cf2a
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6cf32
|
_gnu_cxx::new_allocator<Catch::TextFlow::Column>::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)));
}
|
movabsq $0x24924924924924a, %rax # imm = 0x24924924924924A
cmpq %rax, %rsi
jae 0x6cf4a
imulq $0x38, %rsi, %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x188b9
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6cfee
|
void std::vector<Catch::TextFlow::Column::const_iterator, std::allocator<Catch::TextFlow::Column::const_iterator>>::_M_realloc_insert<Catch::TextFlow::Column::const_iterator>(__gnu_cxx::__normal_iterator<Catch::TextFlow::Column::const_iterator*, std::vector<Catch::TextFlow::Column::const_iterator, std::allocator<Catch::TextFlow::Column::const_iterator>>>, Catch::TextFlow::Column::const_iterator&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2c4f4(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6d11a
movq %rax, %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %r14
movq %r12, %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r15
testq %rsi, %rsi
movq %rsi, (%rsp)
je 0x6d053
movq %rdi, %r13
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6ce36
movq %r13, %rdi
movq %rax, %r13
jmp 0x6d056
xorl %r13d, %r13d
leaq (%r15,%r15,4), %rax
movq 0x20(%rbp), %rcx
movq %rcx, 0x20(%r13,%rax,8)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%r13,%rax,8)
movups %xmm0, (%r13,%rax,8)
movq %r13, %rbp
cmpq %r12, %rdi
je 0x6d0a9
movq %r13, %rbp
movq %rdi, %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
addq $0x28, %rax
addq $0x28, %rbp
cmpq %r12, %rax
jne 0x6d085
addq $0x28, %rbp
cmpq %r12, %r14
je 0x6d0db
movq 0x20(%r12), %rax
movq %rax, 0x20(%rbp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
addq $0x28, %r12
addq $0x28, %rbp
cmpq %r14, %r12
jne 0x6d0b2
testq %rdi, %rdi
je 0x6d0ec
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq (%rsp), %rax
leaq (%rax,%rax,4), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6d11a
|
std::vector<Catch::TextFlow::Column::const_iterator, std::allocator<Catch::TextFlow::Column::const_iterator>>::_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;
}
|
movabsq $0x333333333333333, %rcx # imm = 0x333333333333333
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x6d162
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6d16c
|
void std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>::_M_realloc_insert<Catch::TextFlow::Column const&>(__gnu_cxx::__normal_iterator<Catch::TextFlow::Column*, std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>>, Catch::TextFlow::Column 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x2c373(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x6d39a
movq %rax, %rsi
movq (%r14), %rcx
movq 0x8(%r14), %r12
movq %r13, %rax
movq %rcx, 0x10(%rsp)
subq %rcx, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rbx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rbx
testq %rsi, %rsi
movq %rsi, (%rsp)
movq %r14, 0x8(%rsp)
je 0x6d1d8
movq %r14, %rdi
xorl %edx, %edx
callq 0x6cf32
movq %rax, %r14
jmp 0x6d1db
xorl %r14d, %r14d
imulq $0x38, %rbx, %rcx
leaq (%r14,%rcx), %rbx
leaq (%r14,%rcx), %r15
addq $0x10, %r15
movq %r15, -0x10(%r15)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x20f36
movq 0x30(%rbp), %rax
movq %rax, 0x30(%rbx)
movups 0x20(%rbp), %xmm0
movups %xmm0, 0x20(%rbx)
movq %r14, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
movq (%rsp), %rbp
movq 0x8(%rsp), %r15
je 0x6d28e
leaq 0x10(%r14), %rbx
leaq 0x10(%rdi), %rax
movq %rbx, -0x10(%rbx)
movq -0x10(%rax), %rcx
cmpq %rcx, %rax
je 0x6d249
movq %rcx, -0x10(%rbx)
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x6d24f
movups (%rax), %xmm0
movups %xmm0, (%rbx)
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%rbx)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbx)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x38, %rbx
leaq 0x38(%rax), %rcx
addq $0x28, %rax
cmpq %r13, %rax
movq %rcx, %rax
jne 0x6d230
addq $-0x10, %rbx
cmpq %r13, %r12
je 0x6d30e
xorl %eax, %eax
leaq (%rbx,%rax), %rdx
addq $0x48, %rdx
movq %rdx, -0x10(%rdx)
leaq (%rax,%r13), %rcx
addq $0x10, %rcx
movq -0x10(%rcx), %rsi
cmpq %rsi, %rcx
je 0x6d2c3
leaq (%rbx,%rax), %rdx
movq %rsi, 0x38(%rdx)
movq (%rcx), %rsi
movq %rsi, 0x48(%rdx)
jmp 0x6d2c9
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
leaq (%rax,%r13), %rdx
addq $0x38, %rdx
movq -0x30(%rdx), %rsi
movq %rsi, 0x40(%rbx,%rax)
movq %rcx, -0x38(%rdx)
movq $0x0, -0x30(%rdx)
movb $0x0, -0x28(%rdx)
movq -0x8(%rdx), %rcx
movq %rcx, 0x68(%rbx,%rax)
movups -0x18(%rdx), %xmm0
movups %xmm0, 0x58(%rbx,%rax)
addq $0x38, %rax
cmpq %r12, %rdx
jne 0x6d295
addq %rax, %rbx
addq $0x38, %rbx
jmp 0x6d312
addq $0x38, %rbx
testq %rdi, %rdi
je 0x6d323
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
imulq $0x38, %rbp, %rax
addq %r14, %rax
movq %rax, 0x10(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %r12
movq %rax, %rdi
callq 0x17210
movq %r14, %r15
testq %r14, %r14
jne 0x6d370
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6d36b
movq (%r12), %rsi
incq %rsi
callq 0x17610
testq %r15, %r15
je 0x6d37d
imulq $0x38, (%rsp), %rsi
movq %r15, %rdi
callq 0x17610
callq 0x17920
movq %rax, %rbx
callq 0x17a40
movq %rbx, %rdi
callq 0x17b40
movq %rax, %rdi
callq 0x1e8bf
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6d39a
|
std::vector<Catch::TextFlow::Column, std::allocator<Catch::TextFlow::Column>>::_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;
}
|
movabsq $0x249249249249249, %rcx # imm = 0x249249249249249
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x6d3e2
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6e9f0
|
Catch::Matchers::RegexMatcher::RegexMatcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::CaseSensitive)
|
pointer
_M_local_data()
{
#if __cplusplus >= 201103L
return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
#else
return pointer(_M_local_buf);
#endif
}
|
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x6565d(%rip), %rax # 0xd4068
movq %rax, (%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
movq (%rsi), %r8
leaq 0x10(%rsi), %rax
cmpq %rax, %r8
je 0x6ea2f
movq %r8, 0x28(%rdi)
movq (%rax), %rcx
movq %rcx, 0x38(%rdi)
jmp 0x6ea35
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movl %edx, 0x48(%rdi)
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ef34
|
std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>::basic_regex<std::char_traits<char>, std::allocator<char>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::regex_constants::syntax_option_type)
|
explicit
basic_regex(const std::basic_string<_Ch_type, _Ch_traits,
_Ch_alloc>& __s,
flag_type __f = ECMAScript)
{ _M_compile(__s.data(), __s.data() + __s.size(), __f); }
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x17c80
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
movl %ebp, %ecx
callq 0x6f100
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x6ef87
callq 0x1f554
movq %rbx, %rdi
callq 0x178d0
movq %r15, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6ef98
|
std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>::~basic_regex()
|
~basic_regex()
{ }
|
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x6efaa
callq 0x1f554
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x178d0
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f100
|
std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>>::_M_compile(char const*, char const*, std::regex_constants::syntax_option_type)
|
void
_M_compile(const _Ch_type* __first, const _Ch_type* __last,
flag_type __f)
{
__detail::_Compiler<_Rx_traits> __c(__first, __last, _M_loc, __f);
_M_automaton = __c._M_get_nfa();
_M_flags = __f;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x8(%rdi), %rcx
movq %rsp, %r15
movq %r15, %rdi
movl %ebx, %r8d
callq 0x6f1be
movups 0x100(%r15), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x100(%r15)
movq 0x18(%r14), %rdi
movups %xmm0, 0x10(%r14)
testq %rdi, %rdi
je 0x6f149
callq 0x1f554
movl %ebx, (%r14)
leaq 0x130(%rsp), %rbx
movq %rbx, %rdi
callq 0x79d6a
movq -0x20(%rbx), %rdi
leaq 0x120(%rsp), %rax
cmpq %rax, %rdi
je 0x6f17d
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x17610
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x6f18f
callq 0x1f554
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f1b0
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x17610
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f1be
|
std::__detail::_Compiler<std::__cxx11::regex_traits<char>>::_Compiler(char const*, char const*, std::locale const&, std::regex_constants::syntax_option_type)
|
_Compiler<_TraitsT>::
_Compiler(const _CharT* __b, const _CharT* __e,
const typename _TraitsT::locale_type& __loc, _FlagT __flags)
: _M_flags(_S_validate(__flags)),
_M_scanner(__b, __e, _M_flags, __loc),
_M_nfa(make_shared<_RegexT>(__loc, _M_flags)),
_M_traits(_M_nfa->_M_traits),
_M_ctype(std::use_facet<_CtypeT>(__loc))
{
_StateSeqT __r(*_M_nfa, _M_nfa->_M_start());
__r._M_append(_M_nfa->_M_insert_subexpr_begin());
this->_M_disjunction();
if (!_M_match_token(_ScannerT::_S_token_eof))
__throw_regex_error(regex_constants::error_paren);
__r._M_append(_M_pop());
__glibcxx_assert(_M_stack.empty());
__r._M_append(_M_nfa->_M_insert_subexpr_end());
__r._M_append(_M_nfa->_M_insert_accept());
_M_nfa->_M_eliminate_dummy();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %r8d, %edi
callq 0x6f42c
movl %eax, %ebp
movl %eax, (%rbx)
leaq 0x8(%rbx), %r12
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x173b0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
leaq 0x8(%rsp), %r8
callq 0x6f478
leaq 0x8(%rsp), %rdi
callq 0x178d0
leaq 0x100(%rbx), %r15
movq $0x0, 0x100(%rbx)
leaq 0x108(%rbx), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rcx
movq %rbx, %r8
callq 0x70990
leaq 0x120(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x110(%rbx)
movq $0x0, 0x118(%rbx)
movb $0x0, 0x120(%rbx)
leaq 0x130(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x140(%rbx)
movups %xmm0, 0x150(%rbx)
movups %xmm0, 0x160(%rbx)
movups %xmm0, 0x170(%rbx)
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movq %r14, 0x20(%rsp)
callq 0x70bd6
movq 0x100(%rbx), %rax
addq $0x50, %rax
movq %rax, 0x180(%rbx)
movq %r13, %rdi
callq 0x17220
movq %rax, 0x188(%rbx)
movq 0x100(%rbx), %r13
movq 0x20(%r13), %r14
movq %r13, %rdi
callq 0x6f52c
movq %rax, %rbp
movq 0x38(%r13), %rax
leaq (%r14,%r14,2), %rcx
shlq $0x4, %rcx
movq %rbp, 0x8(%rax,%rcx)
movq %rbx, %rdi
callq 0x6f602
movq %rbx, %rdi
movl $0x1b, %esi
callq 0x6f74e
testb %al, %al
jne 0x6f311
movl $0x5, %edi
callq 0x17190
movq 0x160(%rbx), %rax
cmpq 0x168(%rbx), %rax
jne 0x6f331
movq 0x178(%rbx), %rcx
movl $0x1f8, %eax # imm = 0x1F8
addq -0x8(%rcx), %rax
movq -0x10(%rax), %r12
movq -0x8(%rax), %r14
movq 0x18(%rsp), %rdi
callq 0x79d1e
movq 0x38(%r13), %rax
leaq (,%rbp,2), %rcx
addq %rbp, %rcx
shlq $0x4, %rcx
movq %r12, 0x8(%rax,%rcx)
movq (%r15), %rdi
callq 0x6f788
movq %rax, %rbp
movq 0x38(%r13), %rax
leaq (%r14,%r14,2), %rcx
shlq $0x4, %rcx
movq %rbp, 0x8(%rax,%rcx)
movq (%r15), %rdi
callq 0x6f828
movq 0x38(%r13), %rcx
leaq (,%rbp,2), %rdx
addq %rbp, %rdx
shlq $0x4, %rdx
movq %rax, 0x8(%rcx,%rdx)
movq (%r15), %rdi
callq 0x6f86a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f3c9
movq %rax, %r15
jmp 0x6f3d6
movq %rax, %r15
jmp 0x6f406
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x178d0
jmp 0x6f424
movq %rax, %r15
movq 0x18(%rsp), %rdi
callq 0x79d6a
movq 0x110(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x6f3f4
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x17610
movq 0x20(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6f406
callq 0x1f554
movq 0xd0(%rbx), %rdi
addq $0xe0, %rbx
cmpq %rbx, %rdi
je 0x6f424
movq (%rbx), %rsi
incq %rsi
callq 0x17610
movq %r15, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f42c
|
std::__detail::_Compiler<std::__cxx11::regex_traits<char>>::_S_validate(std::regex_constants::syntax_option_type)
|
constexpr inline syntax_option_type
operator&(syntax_option_type __a, syntax_option_type __b)
{
return (syntax_option_type)(static_cast<unsigned int>(__a)
& static_cast<unsigned int>(__b));
}
|
movl %edi, %eax
andl $0x3f0, %eax # imm = 0x3F0
cmpl $0x7f, %eax
jg 0x6f459
leal -0x10(%rax), %ecx
cmpl $0x30, %ecx
ja 0x6f450
movabsq $0x1000000010001, %rdx # imm = 0x1000000010001
btq %rcx, %rdx
jb 0x6f46e
testl %eax, %eax
jne 0x6f471
orl $0x10, %edi
jmp 0x6f46e
cmpl $0x80, %eax
je 0x6f46e
cmpl $0x100, %eax # imm = 0x100
je 0x6f46e
cmpl $0x200, %eax # imm = 0x200
jne 0x6f471
movl %edi, %eax
retq
pushq %rax
callq 0x188d6
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_constants.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f478
|
std::__detail::_Scanner<char>::_Scanner(char const*, char const*, std::regex_constants::syntax_option_type, std::locale)
|
_Scanner<_CharT>::
_Scanner(const _CharT* __begin, const _CharT* __end,
_FlagT __flags, std::locale __loc)
: _ScannerBase(__flags),
_M_current(__begin), _M_end(__end),
_M_ctype(std::use_facet<_CtypeT>(__loc)),
_M_eat_escape(_M_is_ecma()
? &_Scanner::_M_eat_escape_ecma
: &_Scanner::_M_eat_escape_posix)
{ _M_advance(); }
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, %esi
callq 0x6f960
movq %r12, 0xb0(%rbx)
movq %r15, 0xb8(%rbx)
movq %r14, %rdi
callq 0x6fa77
movq %rax, 0xc0(%rbx)
leaq 0xd8(%rbx), %r15
movq %r15, 0xc8(%rbx)
xorl %eax, %eax
movq %rax, 0xd0(%rbx)
movb $0x0, 0xd8(%rbx)
testb $0x10, 0x8c(%rbx)
leaq 0x97a(%rip), %rcx # 0x6fe56
leaq 0x5e1(%rip), %rdx # 0x6fac4
cmoveq %rcx, %rdx
movq %rdx, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movq %rbx, %rdi
callq 0x6ff94
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0xc8(%rbx), %rdi
cmpq %r15, %rdi
je 0x6f523
movq (%r15), %rsi
incq %rsi
callq 0x17610
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_scanner.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f52c
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_subexpr_begin()
|
_StateIdT
_M_insert_subexpr_begin()
{
auto __id = this->_M_subexpr_count++;
this->_M_paren_stack.push_back(__id);
_StateT __tmp(_S_opcode_subexpr_begin);
__tmp._M_subexpr = __id;
return _M_insert_state(std::move(__tmp));
}
|
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x6f55c
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6f569
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x63cf0
movl $0x8, 0x10(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x30(%rsp), %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl 0x10(%rsp), %eax
movl %eax, (%rsi)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsi)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x70d84
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x70b80
leaq 0x10(%rsp), %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x70b80
leaq 0x10(%rsp), %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f788
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_subexpr_end()
|
explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
|
pushq %rbx
subq $0x60, %rsp
movl $0x9, (%rsp)
movq $-0x1, 0x8(%rsp)
movq 0x8(%rdi), %rax
movq -0x8(%rax), %rcx
addq $-0x8, %rax
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rdi)
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movq %r8, 0x10(%rsi)
movq %r9, 0x18(%rsi)
movl %eax, (%rsi)
movl %ecx, 0x4(%rsi)
movq %rdx, 0x8(%rsi)
callq 0x70d84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f828
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_accept()
|
_StateIdT
_M_insert_accept()
{
auto __ret = _M_insert_state(_StateT(_S_opcode_accept));
return __ret;
}
|
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rsi
movl $0xc, (%rsi)
movq $-0x1, 0x8(%rsi)
callq 0x70d84
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f86a
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_eliminate_dummy()
|
explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { }
|
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rcx, %rax
je 0x6f8e6
movl $0x86, %edx
movq 0x8(%rax), %r8
testq %r8, %r8
js 0x6f8a8
movq 0x38(%rdi), %rsi
leaq (%r8,%r8,2), %r8
shlq $0x4, %r8
cmpl $0xa, (%rsi,%r8)
jne 0x6f8a8
addq %rsi, %r8
movq 0x8(%r8), %r8
movq %r8, 0x8(%rax)
testq %r8, %r8
jns 0x6f889
movl (%rax), %esi
cmpl $0x7, %esi
ja 0x6f8dd
btl %esi, %edx
jae 0x6f8dd
movq 0x10(%rax), %rsi
testq %rsi, %rsi
js 0x6f8dd
movq 0x38(%rdi), %r8
leaq (%rsi,%rsi,2), %rsi
shlq $0x4, %rsi
cmpl $0xa, (%r8,%rsi)
jne 0x6f8dd
addq %rsi, %r8
movq 0x8(%r8), %rsi
movq %rsi, 0x10(%rax)
jmp 0x6f8b8
addq $0x30, %rax
cmpq %rcx, %rax
jne 0x6f87c
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f8e7
|
std::__throw_regex_error(std::regex_constants::error_type, char const*)
|
inline void
__throw_regex_error(regex_constants::error_type __ecode
__attribute__((__unused__)),
const char* __what __attribute__((__unused__)))
{ _GLIBCXX_THROW_OR_ABORT(regex_error(__ecode, __what)); }
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x18, %edi
callq 0x172c0
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x6f934
movq 0x6667f(%rip), %rsi # 0xd5f90
movq 0x66610(%rip), %rdx # 0xd5f28
movq %rbx, %rdi
callq 0x17ae0
movq %rax, %r14
movq %rbx, %rdi
callq 0x17490
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_error.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f934
|
std::regex_error::regex_error(std::regex_constants::error_type, char const*)
|
regex_error(regex_constants::error_type __ecode, const char* __what)
: std::runtime_error(__what), _M_code(__ecode)
{ }
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x17bf0
movq 0x66564(%rip), %rax # 0xd5eb0
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_error.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6f960
|
std::__detail::_ScannerBase::_ScannerBase(std::regex_constants::syntax_option_type)
|
constexpr pair(_U1&& __x, _U2&& __y)
: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
|
movb $0x5e, (%rdi)
movl $0x16, 0x4(%rdi)
movb $0x24, 0x8(%rdi)
movl $0x17, 0xc(%rdi)
movb $0x2e, 0x10(%rdi)
xorl %r8d, %r8d
movl %r8d, 0x14(%rdi)
movb $0x2a, 0x18(%rdi)
movl $0x14, 0x1c(%rdi)
movb $0x2b, 0x20(%rdi)
movl $0x15, 0x24(%rdi)
movb $0x3f, 0x28(%rdi)
movl $0x12, 0x2c(%rdi)
movb $0x7c, 0x30(%rdi)
movl $0x13, %eax
movl %eax, 0x34(%rdi)
movb $0xa, 0x38(%rdi)
movl %eax, 0x3c(%rdi)
movb $0x0, 0x40(%rdi)
movl %eax, 0x44(%rdi)
leaq 0x48(%rdi), %r9
movaps 0x2f6ca(%rip), %xmm0 # 0x9f090
movups %xmm0, 0x48(%rdi)
leaq 0x58(%rdi), %r10
movaps 0x2f6cb(%rip), %xmm0 # 0x9f0a0
movups %xmm0, 0x58(%rdi)
movl $0xb760974, 0x68(%rdi) # imm = 0xB760974
movw $0x0, 0x6c(%rdi)
leaq 0x2f804(%rip), %rax # 0x9f1f1
movq %rax, 0x70(%rdi)
leaq 0x2f808(%rip), %rdx # 0x9f200
movq %rdx, 0x78(%rdi)
leaq 0x2f804(%rip), %rcx # 0x9f207
movq %rcx, 0x80(%rdi)
movl %r8d, 0x88(%rdi)
movl %esi, 0x8c(%rdi)
testb $0x10, %sil
cmoveq %r10, %r9
movq %r9, 0x98(%rdi)
jne 0x6fa68
movq %rdx, %rax
testb $0x20, %sil
jne 0x6fa68
movq %rcx, %rax
testb $0x40, %sil
jne 0x6fa68
btl $0x8, %esi
jb 0x6fa58
btl $0x9, %esi
jb 0x6fa61
xorl %eax, %eax
testb %sil, %sil
leaq 0x2f7b5(%rip), %rcx # 0x9f207
cmovsq %rcx, %rax
jmp 0x6fa68
leaq 0x2f7b5(%rip), %rax # 0x9f214
jmp 0x6fa68
leaq 0x2f7b4(%rip), %rax # 0x9f21c
movq %rax, 0xa0(%rdi)
movb $0x0, 0xa8(%rdi)
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x6fa77
|
std::ctype<char> const const& std::use_facet<std::ctype<char> const>(std::locale const&)
|
const _Facet&
use_facet(const locale& __loc)
{
const size_t __i = _Facet::id._M_id();
const locale::facet** __facets = __loc._M_impl->_M_facets;
if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
__throw_bad_cast();
#if __cpp_rtti
return dynamic_cast<const _Facet&>(*__facets[__i]);
#else
return static_cast<const _Facet&>(*__facets[__i]);
#endif
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x66526(%rip), %rdi # 0xd5fa8
callq 0x17300
movq (%rbx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x6fab9
movq 0x8(%rcx), %rcx
movq (%rcx,%rax,8), %rdi
testq %rdi, %rdi
je 0x6fab9
movq 0x6644c(%rip), %rsi # 0xd5ef0
movq 0x664c5(%rip), %rdx # 0xd5f70
xorl %ecx, %ecx
callq 0x176f0
testq %rax, %rax
je 0x6fabe
popq %rbx
retq
callq 0x177e0
callq 0x17c10
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/locale_classes.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70990
|
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<std::__detail::_NFA<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>, std::locale const&, std::regex_constants::syntax_option_type&>(std::__detail::_NFA<std::__cxx11::regex_traits<char>>*&, std::_Sp_alloc_shared_tag<std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>>, std::locale const&, std::regex_constants::syntax_option_type&)
|
__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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x68, %edi
callq 0x175e0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x63777(%rip), %rax # 0xd4140
movq %rax, (%r14)
movq %r14, %r12
addq $0x10, %r12
movl (%r13), %edx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x70a78
movq %r14, (%r15)
movq %r12, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70a10
|
std::_Sp_counted_ptr_inplace<std::__detail::_NFA<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70a12
|
std::_Sp_counted_ptr_inplace<std::__detail::_NFA<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>, (__gnu_cxx::_Lock_policy)2>::~_Sp_counted_ptr_inplace()
|
~_Sp_counted_ptr_inplace() noexcept { }
|
movl $0x68, %esi
jmp 0x17610
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70a1c
|
std::_Sp_counted_ptr_inplace<std::__detail::_NFA<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>, (__gnu_cxx::_Lock_policy)2>::_M_dispose()
|
virtual void
_M_dispose() noexcept
{
allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
}
|
addq $0x10, %rdi
movq %rdi, %rsi
jmp 0x70ba8
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70a32
|
std::_Sp_counted_ptr_inplace<std::__detail::_NFA<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>, (__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 %rbx
movq %rdi, %rbx
addq $0x10, %rbx
leaq 0x28ef7(%rip), %rax # 0x99938
cmpq %rax, %rsi
je 0x70a73
movq 0x8(%rsi), %rdi
leaq 0x28ecb(%rip), %rax # 0x9991c
cmpq %rax, %rdi
je 0x70a73
cmpb $0x2a, (%rdi)
jne 0x70a5f
xorl %ebx, %ebx
jmp 0x70a73
leaq 0x28eb6(%rip), %rsi # 0x9991c
callq 0x178b0
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/shared_ptr_base.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70a78
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_NFA(std::locale const&, std::regex_constants::syntax_option_type)
|
_NFA(const typename _TraitsT::locale_type& __loc, _FlagT __flags)
: _NFA_base(__flags)
{ _M_traits.imbue(__loc); }
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movl %edx, 0x18(%rdi)
movups %xmm0, 0x20(%rdi)
movb $0x0, 0x30(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rax, 0x48(%rdi)
leaq 0x50(%rdi), %r14
movq %r14, %rdi
callq 0x17c80
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x173b0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x70aea
movq %rbx, %rdi
callq 0x178d0
movq %r15, %rdi
callq 0x178d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70aea
|
std::__cxx11::regex_traits<char>::imbue(std::locale)
|
locale_type
imbue(locale_type __loc)
{
std::swap(_M_locale, __loc);
return __loc;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x173b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x176a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x176a0
movq %r12, %rdi
callq 0x178d0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x173b0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70b3e
|
std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>::~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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x70b60
movq %r14, %rdi
callq 0x70b80
addq $0x30, %r14
jmp 0x70b4d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x70b79
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70b80
|
std::__detail::_State<char>::~_State()
|
~_State()
{
if (_M_opcode() == _S_opcode_match)
_M_get_matcher().~_MatcherT();
}
|
pushq %rax
cmpl $0xb, (%rdi)
jne 0x70b9d
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x70b9d
addq $0x10, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
popq %rax
retq
movq %rax, %rdi
callq 0x1e8bf
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70ba8
|
void __gnu_cxx::new_allocator<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>::destroy<std::__detail::_NFA<std::__cxx11::regex_traits<char>>>(std::__detail::_NFA<std::__cxx11::regex_traits<char>>*)
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
pushq %rbx
movq %rsi, %rbx
leaq 0x50(%rsi), %rdi
callq 0x178d0
leaq 0x38(%rbx), %rdi
callq 0x70b3e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x70bd3
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x17610
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70d68
|
_gnu_cxx::new_allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>*>::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)));
}
|
movq %rsi, %rdi
movq %rsi, %rax
shrq $0x3c, %rax
jne 0x70d7d
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x188e6
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70d84
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_state(std::__detail::_State<char>)
|
_StateIdT
_M_insert_state(_StateT __s)
{
this->push_back(std::move(__s));
if (this->size() > _GLIBCXX_REGEX_STATE_LIMIT)
__throw_regex_error(
regex_constants::error_space,
"Number of NFA states exceeds limit. Please use shorter regex "
"string, or use smaller brace expression, or make "
"_GLIBCXX_REGEX_STATE_LIMIT larger.");
return this->size() - 1;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x70e0c
movq 0x40(%rbx), %rcx
subq 0x38(%rbx), %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq $0x186a1, %rax # imm = 0x186A1
jae 0x70dc1
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %edi
callq 0x172c0
movq %rax, %rbx
leaq 0x2e65d(%rip), %rdx # 0x9f432
movq %rax, %rdi
movl $0x9, %esi
callq 0x6f934
movq 0x651a7(%rip), %rsi # 0xd5f90
movq 0x65138(%rip), %rdx # 0xd5f28
movq %rbx, %rdi
callq 0x17ae0
movq %rax, %r14
movq %rbx, %rdi
callq 0x17490
movq %r14, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70e0c
|
std::__detail::_State<char>& std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>::emplace_back<std::__detail::_State<char>>(std::__detail::_State<char>&&)
|
vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x70e77
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
cmpl $0xb, (%rdx)
jne 0x70e70
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movq $0x0, 0x20(%rsi)
movq 0x28(%rdx), %rax
movq %rax, 0x28(%rsi)
cmpq $0x0, 0x20(%rdx)
je 0x70e70
leaq 0x10(%rsi), %rax
leaq 0x20(%rdx), %rcx
movups 0x10(%rdx), %xmm1
movups %xmm1, (%rax)
movq 0x20(%rdx), %rax
movq %rax, 0x20(%rsi)
movups %xmm0, (%rcx)
addq $0x30, 0x8(%rbx)
jmp 0x70e7f
movq %rbx, %rdi
callq 0x70e8a
movq 0x8(%rbx), %rax
addq $-0x30, %rax
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70e8a
|
void std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>::_M_realloc_insert<std::__detail::_State<char>>(__gnu_cxx::__normal_iterator<std::__detail::_State<char>*, std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>>, std::__detail::_State<char>&&)
|
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x28655(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x70fc2
movq (%rbx), %r15
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rsp)
movq %r12, %rcx
subq %r15, %rcx
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r14
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x70ef2
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x71014
movq %rax, %r13
jmp 0x70ef5
xorl %r13d, %r13d
leaq (%r14,%r14,2), %rax
shlq $0x4, %rax
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%r13,%rax)
movups %xmm1, 0x10(%r13,%rax)
movups %xmm0, (%r13,%rax)
cmpl $0xb, (%rbp)
jne 0x70f5c
addq %r13, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq 0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
cmpq $0x0, 0x20(%rbp)
je 0x70f5c
leaq 0x10(%rax), %rcx
leaq 0x20(%rbp), %rdx
movups 0x10(%rbp), %xmm1
movups %xmm1, (%rcx)
movq 0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movups %xmm0, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x7103a
leaq 0x30(%rax), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rcx
callq 0x7103a
movq %rax, %r12
testq %r15, %r15
je 0x70f98
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x17610
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %r13, %rax
movq %rax, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x70fc2
|
std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>::_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;
}
|
movabsq $0x2aaaaaaaaaaaaaa, %rcx # imm = 0x2AAAAAAAAAAAAAA
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x7100a
cmpq %rsi, %rdi
cmovaq %rdi, %rsi
leaq (%rsi,%rdi), %rax
cmpq %rcx, %rax
cmovaeq %rcx, %rax
addq %rdi, %rsi
cmovbq %rcx, %rax
retq
pushq %rax
movq %rdx, %rdi
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x71014
|
_gnu_cxx::new_allocator<std::__detail::_State<char>>::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)));
}
|
movabsq $0x2aaaaaaaaaaaaab, %rax # imm = 0x2AAAAAAAAAAAAAB
cmpq %rax, %rsi
jae 0x71030
shlq $0x4, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18908
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7103a
|
std::vector<std::__detail::_State<char>, std::allocator<std::__detail::_State<char>>>::_S_do_relocate(std::__detail::_State<char>*, std::__detail::_State<char>*, std::__detail::_State<char>*, std::allocator<std::__detail::_State<char>>&, 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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpq %rsi, %rdi
je 0x710bb
movq %rsi, %r14
movq %rdi, %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpl $0xb, (%r15)
jne 0x710a6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq 0x28(%r15), %rax
movq %rax, 0x28(%rbx)
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x710a6
leaq 0x10(%rbx), %rcx
leaq 0x20(%r15), %rdx
movups 0x10(%r15), %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq %r15, %rdi
callq 0x70b80
addq $0x30, %r15
addq $0x30, %rbx
cmpq %r14, %r15
jne 0x7104d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x711ec
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_dummy()
|
_StateIdT
_M_insert_dummy()
{ return _M_insert_state(_StateT(_S_opcode_dummy)); }
|
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rsi
movl $0xa, (%rsi)
movq $-0x1, 0x8(%rsi)
callq 0x70d84
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7122e
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_alt(long, long, bool)
|
explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
|
pushq %rbx
subq $0x60, %rsp
movl $0x1, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl (%rsp), %eax
movl %eax, (%rsi)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rsi)
callq 0x70d84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x720ae
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_line_begin()
|
_StateIdT
_M_insert_line_begin()
{ return _M_insert_state(_StateT(_S_opcode_line_begin_assertion)); }
|
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rsi
movl $0x4, (%rsi)
movq $-0x1, 0x8(%rsi)
callq 0x70d84
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x720f0
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_line_end()
|
_StateIdT
_M_insert_line_end()
{ return _M_insert_state(_StateT(_S_opcode_line_end_assertion)); }
|
pushq %rbx
subq $0x30, %rsp
movq %rsp, %rsi
movl $0x5, (%rsi)
movq $-0x1, 0x8(%rsi)
callq 0x70d84
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x72132
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_word_bound(bool)
|
explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
|
pushq %rbx
subq $0x60, %rsp
movl $0x6, (%rsp)
movq $-0x1, 0x8(%rsp)
movb %sil, 0x18(%rsp)
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl (%rsp), %eax
movl %eax, (%rsi)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movb 0x18(%rsp), %al
movb %al, 0x18(%rsi)
movl 0x19(%rsp), %eax
movl %eax, 0x19(%rsi)
movzwl 0x1d(%rsp), %eax
movw %ax, 0x1d(%rsi)
movb 0x1f(%rsp), %al
movb %al, 0x1f(%rsi)
callq 0x70d84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x721d6
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_lookahead(long, bool)
|
explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
|
pushq %rbx
subq $0x60, %rsp
movl $0x7, (%rsp)
movq $-0x1, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movb %dl, 0x18(%rsp)
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl (%rsp), %eax
movl %eax, (%rsi)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movb 0x18(%rsp), %al
movb %al, 0x18(%rsi)
movl 0x19(%rsp), %eax
movl %eax, 0x19(%rsi)
movzwl 0x1d(%rsp), %eax
movw %ax, 0x1d(%rsi)
movb 0x1f(%rsp), %al
movb %al, 0x1f(%rsi)
callq 0x70d84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x72b8c
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_backref(unsigned long)
|
_StateIdT
_NFA<_TraitsT>::_M_insert_backref(size_t __index)
{
if (this->_M_flags & regex_constants::__polynomial)
__throw_regex_error(regex_constants::error_complexity,
"Unexpected back-reference in polynomial mode.");
// To figure out whether a backref is valid, a stack is used to store
// unfinished sub-expressions. For example, when parsing
// "(a(b)(c\\1(d)))" at '\\1', _M_subexpr_count is 3, indicating that 3
// sub expressions are parsed or partially parsed(in the stack), aka,
// "(a..", "(b)" and "(c..").
// _M_paren_stack is {1, 3}, for incomplete "(a.." and "(c..". At this
// time, "\\2" is valid, but "\\1" and "\\3" are not.
if (__index >= _M_subexpr_count)
__throw_regex_error(
regex_constants::error_backref,
"Back-reference index exceeds current sub-expression count.");
for (auto __it : this->_M_paren_stack)
if (__index == __it)
__throw_regex_error(
regex_constants::error_backref,
"Back-reference referred to an opened sub-expression.");
this->_M_has_backref = true;
_StateT __tmp(_S_opcode_backref);
__tmp._M_backref_index = __index;
return _M_insert_state(std::move(__tmp));
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
testb $0x4, 0x19(%rdi)
jne 0x72c68
cmpq %rsi, 0x28(%rdi)
jbe 0x72c8b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rcx, %rax
je 0x72bbe
cmpq %rsi, (%rax)
je 0x72c31
addq $0x8, %rax
jmp 0x72bae
movb $0x1, 0x30(%rdi)
movl $0x3, (%rsp)
movq $-0x1, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movl (%rsp), %eax
movl %eax, (%rsi)
movl 0x4(%rsp), %eax
movl %eax, 0x4(%rsi)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rsi)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rsi)
callq 0x70d84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %edi
callq 0x172c0
movq %rax, %r14
leaq 0x2c902(%rip), %rdx # 0x9f547
movq %rax, %rdi
movl $0x3, %esi
callq 0x6f934
movq 0x63337(%rip), %rsi # 0xd5f90
movq 0x632c8(%rip), %rdx # 0xd5f28
movq %r14, %rdi
callq 0x17ae0
movl $0x18, %edi
callq 0x172c0
movq %rax, %r14
leaq 0x2c862(%rip), %rdx # 0x9f4de
movq %rax, %rdi
movl $0xb, %esi
callq 0x6f934
jmp 0x72c52
movl $0x18, %edi
callq 0x172c0
movq %rax, %r14
leaq 0x2c86d(%rip), %rdx # 0x9f50c
movq %rax, %rdi
movl $0x3, %esi
callq 0x6f934
jmp 0x72c52
jmp 0x72cc9
jmp 0x72cc9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x70b80
movq %rsp, %rdi
callq 0x70b80
jmp 0x72cd4
movq %rax, %rbx
movq %r14, %rdi
callq 0x17490
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.tcc
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x733a8
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_matcher(std::function<bool (char)>)
|
_StateIdT
_M_insert_matcher(_MatcherT __m)
{
_StateT __tmp(_S_opcode_match);
__tmp._M_get_matcher() = std::move(__m);
return _M_insert_state(std::move(__tmp));
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r14
movl $0xb, -0x10(%r14)
movq $-0x1, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movq %r14, %rdi
callq 0x73486
movups -0x10(%r14), %xmm0
movups (%r14), %xmm1
movups 0x10(%r14), %xmm2
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm2, 0x20(%rsp)
cmpl $0xb, -0x10(%r14)
jne 0x7343e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movq %rcx, 0x28(%rsp)
testq %rax, %rax
je 0x7343e
leaq 0x10(%rsp), %rcx
leaq 0x58(%rsp), %rdx
movups (%r14), %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x70d84
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
leaq 0x38(%rsp), %rdi
callq 0x70b80
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x70b80
leaq 0x38(%rsp), %rdi
callq 0x70b80
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_automaton.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73486
|
std::function<bool (char)>::operator=(std::function<bool (char)>&&)
|
function&
operator=(function&& __x) noexcept
{
function(std::move(__x)).swap(*this);
return *this;
}
|
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsi), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x734c3
movups (%rsi), %xmm1
addq $0x10, %rsi
movaps %xmm1, (%rsp)
movq %rcx, 0x10(%rsp)
movups %xmm0, (%rsi)
movaps (%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movups (%rbx), %xmm1
movaps %xmm1, (%rsp)
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rdx
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rdx, 0x10(%rbx)
movq 0x18(%rbx), %rdx
movq %rdx, 0x18(%rsp)
movq %rax, 0x18(%rbx)
testq %rcx, %rcx
je 0x73507
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rcx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x1e8bf
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73518
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, false>>::_M_invoke(std::_Any_data const&, char&&)
|
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
|
movsbl (%rsi), %esi
jmp 0x73546
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73520
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, false>>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation)
|
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#if __cpp_rtti
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#endif
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
|
cmpl $0x2, %edx
je 0x7353f
cmpl $0x1, %edx
je 0x7353a
testl %edx, %edx
jne 0x73543
leaq 0x60c4b(%rip), %rax # 0xd4180
movq %rax, (%rdi)
jmp 0x73543
movq %rsi, (%rdi)
jmp 0x73543
movb (%rsi), %al
movb %al, (%rdi)
xorl %eax, %eax
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73546
|
std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, false>::operator()(char) const
|
bool
operator()(_CharT __ch) const
{
static auto __nul = _M_translator._M_translate('\0');
return _M_translator._M_translate(__ch) != __nul;
}
|
pushq %rbx
movl %esi, %ebx
movb 0x638f9(%rip), %al # 0xd6e48
testb %al, %al
je 0x7355e
cmpb %bl, 0x638e8(%rip) # 0xd6e41
setne %al
popq %rbx
retq
callq 0x18922
jmp 0x73553
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73566
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, true>>::_M_invoke(std::_Any_data const&, char&&)
|
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
|
movsbl (%rsi), %esi
jmp 0x73594
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7356e
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, true>>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation)
|
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#if __cpp_rtti
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#endif
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
|
cmpl $0x2, %edx
je 0x7358a
cmpl $0x1, %edx
je 0x73585
testl %edx, %edx
jne 0x73590
leaq 0x60c0d(%rip), %rax # 0xd4190
jmp 0x7358d
movq %rsi, (%rdi)
jmp 0x73590
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73594
|
std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, false, true>::operator()(char) const
|
bool
operator()(_CharT __ch) const
{
static auto __nul = _M_translator._M_translate('\0');
return _M_translator._M_translate(__ch) != __nul;
}
|
pushq %rbx
movl %esi, %ebx
movb 0x638bb(%rip), %al # 0xd6e58
testb %al, %al
je 0x735ac
cmpb %bl, 0x638a9(%rip) # 0xd6e50
setne %al
popq %rbx
retq
callq 0x18949
jmp 0x735a1
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x735b4
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, false>>::_M_invoke(std::_Any_data const&, char&&)
|
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
|
movsbl (%rsi), %esi
jmp 0x735e2
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x735bc
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, false>>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation)
|
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#if __cpp_rtti
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#endif
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
|
cmpl $0x2, %edx
je 0x735d8
cmpl $0x1, %edx
je 0x735d3
testl %edx, %edx
jne 0x735de
leaq 0x60bcf(%rip), %rax # 0xd41a0
jmp 0x735db
movq %rsi, (%rdi)
jmp 0x735de
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x735e2
|
std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, false>::operator()(char) const
|
bool
operator()(_CharT __ch) const
{
static auto __nul = _M_translator._M_translate('\0');
return _M_translator._M_translate(__ch) != __nul;
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movb 0x63877(%rip), %al # 0xd6e68
testb %al, %al
je 0x7361a
movq (%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movsbl %bl, %esi
movq %rax, %rdi
callq *0x20(%rcx)
cmpb 0x63851(%rip), %al # 0xd6e60
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x63847(%rip), %rdi # 0xd6e68
callq 0x17b80
testl %eax, %eax
je 0x735f5
movq (%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movq %rax, %rdi
xorl %esi, %esi
callq *0x20(%rcx)
movb %al, 0x6381d(%rip) # 0xd6e60
leaq 0x6381e(%rip), %rdi # 0xd6e68
callq 0x173d0
jmp 0x735f5
movq %rax, %rbx
leaq 0x6380d(%rip), %rdi # 0xd6e68
callq 0x173c0
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73668
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, true>>::_M_invoke(std::_Any_data const&, char&&)
|
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
|
movsbl (%rsi), %esi
jmp 0x73696
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73670
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, true>>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation)
|
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#if __cpp_rtti
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#endif
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
|
cmpl $0x2, %edx
je 0x7368c
cmpl $0x1, %edx
je 0x73687
testl %edx, %edx
jne 0x73692
leaq 0x60b2b(%rip), %rax # 0xd41b0
jmp 0x7368f
movq %rsi, (%rdi)
jmp 0x73692
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x73696
|
std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, false, true, true>::operator()(char) const
|
bool
operator()(_CharT __ch) const
{
static auto __nul = _M_translator._M_translate('\0');
return _M_translator._M_translate(__ch) != __nul;
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movb 0x637d3(%rip), %al # 0xd6e78
testb %al, %al
je 0x736ce
movq (%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movsbl %bl, %esi
movq %rax, %rdi
callq *0x20(%rcx)
cmpb 0x637ad(%rip), %al # 0xd6e70
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x637a3(%rip), %rdi # 0xd6e78
callq 0x17b80
testl %eax, %eax
je 0x736a9
movq (%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movq %rax, %rdi
xorl %esi, %esi
callq *0x20(%rcx)
movb %al, 0x63779(%rip) # 0xd6e70
leaq 0x6377a(%rip), %rdi # 0xd6e78
callq 0x173d0
jmp 0x736a9
movq %rax, %rbx
leaq 0x63769(%rip), %rdi # 0xd6e78
callq 0x173c0
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_compiler.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7371c
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, true, false, false>>::_M_invoke(std::_Any_data const&, char&&)
|
constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
|
movb (%rsi), %al
cmpb $0xa, %al
setne %cl
cmpb $0xd, %al
setne %al
andb %cl, %al
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7372c
|
std::_Function_handler<bool (char), std::__detail::_AnyMatcher<std::__cxx11::regex_traits<char>, true, false, false>>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation)
|
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
_Manager_operation __op)
{
switch (__op)
{
#if __cpp_rtti
case __get_type_info:
__dest._M_access<const type_info*>() = &typeid(_Functor);
break;
#endif
case __get_functor_ptr:
__dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
break;
default:
_Base::_M_manager(__dest, __source, __op);
}
return false;
}
|
cmpl $0x2, %edx
je 0x7374b
cmpl $0x1, %edx
je 0x73746
testl %edx, %edx
jne 0x7374f
leaq 0x60a7f(%rip), %rax # 0xd41c0
movq %rax, (%rdi)
jmp 0x7374f
movq %rsi, (%rdi)
jmp 0x7374f
movb (%rsi), %al
movb %al, (%rdi)
xorl %eax, %eax
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_function.h
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.