address
string | name
string | code
string | asm
string | file
string | bin
string |
|---|---|---|---|---|---|
0x788e6
|
std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_char(char)
|
void
_M_add_char(_CharT __c)
{
_M_char_set.push_back(_M_translator._M_translate(__c));
_GLIBCXX_DEBUG_ONLY(_M_is_ready = false);
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x68(%rdi), %rdi
callq 0x17220
movq (%rax), %rcx
movq %rax, %rdi
movl %ebx, %esi
callq *0x20(%rcx)
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x7740c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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
|
0x7891a
|
std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_collate_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
_StringT
_M_add_collate_element(const _StringT& __s)
{
auto __st = _M_traits.lookup_collatename(__s.data(),
__s.data() + __s.size());
if (__st.empty())
__throw_regex_error(regex_constants::error_collate,
"Invalid collate element.");
_M_char_set.push_back(_M_translator._M_translate(__st[0]));
_GLIBCXX_DEBUG_ONLY(_M_is_ready = false);
return __st;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rsi), %rsi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
addq %rax, %rcx
movq %rax, %rdx
callq 0x772b2
cmpq $0x0, 0x8(%rbx)
je 0x7897d
movq (%rbx), %rax
movb (%rax), %bpl
movq 0x68(%r14), %rdi
callq 0x17220
movq (%rax), %rcx
movsbl %bpl, %esi
movq %rax, %rdi
callq *0x20(%rcx)
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0x7740c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x172c0
movq %rax, %r15
leaq 0x26d02(%rip), %rsi # 0x9f693
movq %rax, %rdi
callq 0x17bf0
movq 0x5d510(%rip), %rax # 0xd5eb0
addq $0x10, %rax
movq %rax, (%r15)
movl $0x0, 0x10(%r15)
movq 0x5d5da(%rip), %rsi # 0xd5f90
movq 0x5d56b(%rip), %rdx # 0xd5f28
movq %r15, %rdi
callq 0x17ae0
jmp 0x789d4
movq %rax, %r14
movq %r15, %rdi
callq 0x17490
jmp 0x789d7
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x789ee
movq (%rbx), %rsi
incq %rsi
callq 0x17610
movq %r14, %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
|
0x789f6
|
std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_add_equivalence_class(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void
_M_add_equivalence_class(const _StringT& __s)
{
auto __st = _M_traits.lookup_collatename(__s.data(),
__s.data() + __s.size());
if (__st.empty())
__throw_regex_error(regex_constants::error_collate,
"Invalid equivalence class.");
__st = _M_traits.transform_primary(__st.data(),
__st.data() + __st.size());
_M_equiv_set.push_back(__st);
_GLIBCXX_DEBUG_ONLY(_M_is_ready = false);
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rax
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
addq %rdx, %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x772b2
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x78a9d
movq 0x70(%rbx), %rsi
movq 0x8(%rsp), %rdx
addq %rdx, %rcx
leaq 0x28(%rsp), %rdi
callq 0x7752a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x177a0
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x78a69
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17610
addq $0x18, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x523fa
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78a95
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %edi
callq 0x172c0
movq %rax, %r14
leaq 0x26e67(%rip), %rsi # 0x9f918
movq %rax, %rdi
callq 0x17bf0
movq 0x5d3f0(%rip), %rax # 0xd5eb0
addq $0x10, %rax
movq %rax, (%r14)
movl $0x0, 0x10(%r14)
movq 0x5d4ba(%rip), %rsi # 0xd5f90
movq 0x5d44b(%rip), %rdx # 0xd5f28
movq %r14, %rdi
callq 0x17ae0
movq %rax, %rbx
movq %r14, %rdi
callq 0x17490
jmp 0x78af7
jmp 0x78af4
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78b12
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
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
|
0x78b1a
|
std::__detail::_BracketMatcher<std::__cxx11::regex_traits<char>, true, true>::_M_make_range(char, char)
|
void
_M_make_range(_CharT __l, _CharT __r)
{
if (__l > __r)
__throw_regex_error(regex_constants::error_range,
"Invalid range in bracket expression.");
_M_range_set.push_back(make_pair(_M_translator._M_transform(__l),
_M_translator._M_transform(__r)));
_GLIBCXX_DEBUG_ONLY(_M_is_ready = false);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
cmpb %bpl, %sil
jg 0x78c79
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movsbl %sil, %edx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x76272
movsbl %bpl, %edx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x76272
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x38(%rsp), %r14
movq -0x10(%r14), %rax
cmpq %r14, %rax
je 0x78b87
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
jmp 0x78b8f
movups (%r14), %xmm0
movups %xmm0, (%r15)
addq $0x30, %rbx
movq 0x30(%rsp), %rax
leaq 0x78(%rsp), %r13
movq %rax, -0x28(%r13)
movq %r14, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movq %r13, -0x10(%r13)
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rax
cmpq %r12, %rax
je 0x78bd8
movq %rax, 0x68(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0x78be2
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq 0x10(%rsp), %rax
leaq 0x48(%rsp), %rsi
movq %rax, 0x28(%rsi)
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
callq 0x77e8e
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x78c22
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x17610
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x78c39
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x17610
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x78c50
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x78c67
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17610
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0x172c0
movq %rax, %r14
leaq 0x26ca6(%rip), %rdx # 0x9f933
movq %rax, %rdi
movl $0x8, %esi
callq 0x6f934
movq 0x5d2ef(%rip), %rsi # 0xd5f90
movq 0x5d280(%rip), %rdx # 0xd5f28
movq %r14, %rdi
callq 0x17ae0
movq %rax, %rbx
movq %r14, %rdi
callq 0x17490
jmp 0x78d01
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x74eb0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x78ce6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17610
jmp 0x78ce6
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78d01
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
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
|
0x78d0a
|
std::__detail::_NFA<std::__cxx11::regex_traits<char>>::_M_insert_repeat(long, long, bool)
|
explicit _State_base(_Opcode __opcode) noexcept
: _M_opcode(__opcode), _M_next(_S_invalid_state_id)
{ }
|
pushq %rbx
subq $0x60, %rsp
movl $0x2, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movb %cl, 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
|
0x78dae
|
std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>::_M_clone()
|
_StateSeq<_TraitsT>
_StateSeq<_TraitsT>::_M_clone()
{
std::map<_StateIdT, _StateIdT> __m;
std::stack<_StateIdT> __stack;
__stack.push(_M_start);
while (!__stack.empty())
{
auto __u = __stack.top();
__stack.pop();
auto __dup = _M_nfa[__u];
// _M_insert_state() never return -1
auto __id = _M_nfa._M_insert_state(std::move(__dup));
__m[__u] = __id;
if (__dup._M_has_alt())
if (__dup._M_alt != _S_invalid_state_id
&& __m.count(__dup._M_alt) == 0)
__stack.push(__dup._M_alt);
if (__u == _M_end)
continue;
if (__dup._M_next != _S_invalid_state_id
&& __m.count(__dup._M_next) == 0)
__stack.push(__dup._M_next);
}
for (auto __it : __m)
{
auto __v = __it.second;
auto& __ref = _M_nfa[__v];
if (__ref._M_next != _S_invalid_state_id)
__ref._M_next = __m.find(__ref._M_next)->second;
if (__ref._M_has_alt() && __ref._M_alt != _S_invalid_state_id)
__ref._M_alt = __m.find(__ref._M_alt)->second;
}
return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa8(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x795d8
movq %rbx, 0x90(%rsp)
leaq 0x8(%r14), %rsi
movq 0x70(%rsp), %rax
movq 0x80(%rsp), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
movq %rsi, 0x98(%rsp)
je 0x78e43
movq (%rsi), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x70(%rsp)
jmp 0x78e4d
leaq 0x40(%rsp), %rdi
callq 0x7974e
movq 0x70(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x79107
leaq 0x20(%rsp), %r12
leaq 0xe0(%rsp), %rbx
leaq 0xd0(%rsp), %rbp
movq 0x78(%rsp), %rdi
cmpq %rdi, %rax
je 0x78e8b
movq -0x8(%rax), %rcx
addq $-0x8, %rax
movq %rcx, 0x8(%rsp)
jmp 0x78ee1
movq 0x88(%rsp), %rax
movq -0x8(%rax), %rax
movq 0x1f8(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x200, %esi # imm = 0x200
callq 0x17610
movq 0x88(%rsp), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x88(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x78(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x80(%rsp)
movl $0x1f8, %ecx # imm = 0x1F8
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq (%r14), %rax
movq 0x8(%rsp), %rcx
movq 0x38(%rax), %rsi
leaq (%rcx,%rcx,2), %rax
shlq $0x4, %rax
movups (%rsi,%rax), %xmm0
movups 0x10(%rsi,%rax), %xmm1
movups 0x20(%rsi,%rax), %xmm2
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
cmpl $0xb, (%rsi,%rax)
jne 0x78f2c
addq %rax, %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0x79316
movq (%r14), %rdi
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movaps %xmm2, 0xf0(%rsp)
movaps %xmm1, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
cmpl $0xb, 0x10(%rsp)
jne 0x78f9b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0xf8(%rsp)
testq %rax, %rax
je 0x78f9b
movups (%r12), %xmm0
movups %xmm0, (%rbx)
movq %rax, 0xf0(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %rbp, %rsi
callq 0x70d84
movq %rax, %r13
movq %rbp, %rdi
callq 0x70b80
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x792b0
movq %r13, (%rax)
movl 0x10(%rsp), %ecx
cmpl $0x8, %ecx
setb %dl
movb $-0x7a, %sil
shrb %cl, %sil
movq 0x20(%rsp), %rax
cmpq $-0x1, %rax
setne %cl
andb %dl, %cl
andb %sil, %cl
cmpb $0x1, %cl
jne 0x7905d
movq 0xb0(%rsp), %rdx
movq %r15, %rcx
testq %rdx, %rdx
je 0x79014
movq %r15, %rcx
xorl %esi, %esi
cmpq %rax, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x78ffc
movq %r15, %rdx
cmpq %r15, %rcx
je 0x79027
cmpq 0x20(%rcx), %rax
cmovlq %r15, %rcx
movq %rcx, %rdx
cmpq %r15, %rdx
jne 0x7905d
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x79050
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x70(%rsp)
jmp 0x7905d
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x7974e
movq 0x8(%rsp), %rax
cmpq 0x10(%r14), %rax
je 0x790ed
movq 0x18(%rsp), %rax
cmpq $-0x1, %rax
je 0x790ed
movq 0xb0(%rsp), %rdx
movq %r15, %rcx
testq %rdx, %rdx
je 0x790a2
movq %r15, %rcx
xorl %esi, %esi
cmpq %rax, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x7908a
movq %r15, %rdx
cmpq %r15, %rcx
je 0x790b5
cmpq 0x20(%rcx), %rax
cmovlq %r15, %rcx
movq %rcx, %rdx
cmpq %r15, %rdx
jne 0x790ed
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x790de
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x70(%rsp)
jmp 0x790ed
leaq 0x40(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x7974e
leaq 0x10(%rsp), %rdi
callq 0x70b80
movq 0x70(%rsp), %rax
cmpq 0x50(%rsp), %rax
jne 0x78e72
movq 0xb8(%rsp), %rax
cmpq %r15, %rax
je 0x791f4
movl $0x86, %ebx
movq 0x28(%rax), %rcx
movq (%r14), %rdx
movq 0x38(%rdx), %rdx
leaq (%rcx,%rcx,2), %rsi
shlq $0x4, %rsi
leaq (%rdx,%rsi), %rcx
movq 0x8(%rdx,%rsi), %rdx
cmpq $-0x1, %rdx
je 0x79186
movq 0xb0(%rsp), %rdi
movq %r15, %rsi
testq %rdi, %rdi
je 0x7916b
movq %r15, %rsi
xorl %r8d, %r8d
cmpq %rdx, 0x20(%rdi)
setl %r8b
cmovgeq %rdi, %rsi
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x79152
movq %r15, %rdi
cmpq %r15, %rsi
je 0x7917e
cmpq 0x20(%rsi), %rdx
cmovlq %r15, %rsi
movq %rsi, %rdi
movq 0x28(%rdi), %rdx
movq %rdx, 0x8(%rcx)
movl (%rcx), %edx
cmpl $0x7, %edx
ja 0x791e3
btl %edx, %ebx
jae 0x791e3
movq 0x10(%rcx), %rdx
cmpq $-0x1, %rdx
je 0x791e3
movq 0xb0(%rsp), %rdi
movq %r15, %rsi
testq %rdi, %rdi
je 0x791c8
movq %r15, %rsi
xorl %r8d, %r8d
cmpq %rdx, 0x20(%rdi)
setl %r8b
cmovgeq %rdi, %rsi
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x791af
movq %r15, %rdi
cmpq %r15, %rsi
je 0x791db
cmpq 0x20(%rsi), %rdx
cmovlq %r15, %rsi
movq %rsi, %rdi
movq 0x28(%rdi), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, %rdi
callq 0x17450
cmpq %r15, %rax
jne 0x7911d
movq (%r14), %rbx
leaq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x792b0
movq (%rax), %r15
addq $0x10, %r14
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
callq 0x792b0
movq (%rax), %rax
movq 0x90(%rsp), %r14
movq %rbx, (%r14)
movq %r15, 0x8(%r14)
movq %rax, 0x10(%r14)
leaq 0x40(%rsp), %rdi
callq 0x79962
leaq 0xa0(%rsp), %rdi
callq 0x79588
movq %r14, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7929a
jmp 0x7926c
movq %rax, %rbx
jmp 0x79290
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x70b80
jmp 0x79286
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x70b80
leaq 0x40(%rsp), %rdi
callq 0x79962
leaq 0xa0(%rsp), %rdi
callq 0x79588
movq %rbx, %rdi
callq 0x17b40
nop
|
/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
|
0x792b0
|
std::map<long, long, std::less<long>, std::allocator<std::pair<long const, long>>>::operator[](long const&)
|
mapped_type&
operator[](const key_type& __k)
{
// concept requirements
__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
iterator __i = lower_bound(__k);
// __i->first is greater than or equivalent to __k.
if (__i == end() || key_comp()(__k, (*__i).first))
#if __cplusplus >= 201103L
__i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
std::tuple<const key_type&>(__k),
std::tuple<>());
#else
__i = insert(__i, value_type(__k, mapped_type()));
#endif
return (*__i).second;
}
|
subq $0x18, %rsp
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rcx
movq %rcx, %rax
testq %rdx, %rdx
je 0x792e3
movq (%rsi), %r8
movq %rcx, %rax
xorl %r9d, %r9d
cmpq %r8, 0x20(%rdx)
setl %r9b
cmovgeq %rdx, %rax
movq 0x10(%rdx,%r9,8), %rdx
testq %rdx, %rdx
jne 0x792ca
cmpq %rcx, %rax
je 0x792f1
movq (%rsi), %rcx
cmpq 0x20(%rax), %rcx
jge 0x7930d
leaq 0x10(%rsp), %rcx
movq %rsi, (%rcx)
leaq 0x2069a(%rip), %rdx # 0x9999a
leaq 0xf(%rsp), %r8
movq %rax, %rsi
callq 0x79374
addq $0x28, %rax
addq $0x18, %rsp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.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
|
0x79316
|
std::function<bool (char)>::function(std::function<bool (char)> const&)
|
~_Function_base()
{
if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
}
|
pushq %r14
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x79343
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %edx
callq *%rax
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x79364
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x17b40
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
|
0x79588
|
std::_Rb_tree<long, std::pair<long const, long>, std::_Select1st<std::pair<long const, long>>, std::less<long>, std::allocator<std::pair<long const, long>>>::~_Rb_tree()
|
~_Rb_tree() _GLIBCXX_NOEXCEPT
{ _M_erase(_M_begin()); }
|
pushq %rax
movq 0x10(%rdi), %rsi
callq 0x7959c
popq %rax
retq
movq %rax, %rdi
callq 0x1e8bf
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.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
|
0x79732
|
_gnu_cxx::new_allocator<long*>::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 0x79747
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x189b3
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
|
0x7974e
|
void std::deque<long, std::allocator<long>>::_M_push_back_aux<long const&>(long const&)
|
void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if __cplusplus >= 201103L
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
#else
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
#endif
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+ 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
}
__catch(...)
{
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
__throw_exception_again;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x6, %rcx
movq 0x20(%rdi), %rdx
movq 0x30(%rdi), %rsi
subq 0x38(%rdi), %rsi
sarq $0x3, %rsi
subq 0x10(%rdi), %rdx
sarq $0x3, %rdx
addq %rsi, %rdx
addq %rcx, %rdx
movabsq $0xfffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFFF
cmpq %rcx, %rdx
je 0x7980a
movq %rdi, %rbx
subq (%rdi), %rax
movq 0x8(%rdi), %rcx
sarq $0x3, %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x797c3
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x79816
movl $0x200, %edi # imm = 0x200
callq 0x175e0
movq 0x48(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x30(%rbx), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0x200(%rax), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x261db(%rip), %rdi # 0x9f9ec
callq 0x17320
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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
|
0x79962
|
std::_Deque_base<long, std::allocator<long>>::~_Deque_base()
|
_Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
}
|
cmpq $0x0, (%rdi)
je 0x799b1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x7999c
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x200, %esi # imm = 0x200
callq 0x17610
cmpq %r15, %r14
jb 0x79985
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
shlq $0x3, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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
|
0x799b2
|
void std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::_M_push_back_aux<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>> const&>(std::__detail::_StateSeq<std::__cxx11::regex_traits<char>> const&)
|
void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if __cplusplus >= 201103L
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
#else
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
#endif
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+ 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
}
__catch(...)
{
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
__throw_exception_again;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x30(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq 0x20(%rdi), %rsi
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
subq 0x10(%rbx), %rsi
sarq $0x3, %rsi
imulq %rdi, %rsi
addq %rdx, %rsi
addq %rcx, %rsi
movabsq $0x555555555555555, %rcx # imm = 0x555555555555555
cmpq %rcx, %rsi
je 0x79a8d
subq (%rbx), %rax
movq 0x8(%rbx), %rcx
sarq $0x3, %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x79a3d
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x79a9a
movl $0x1f8, %edi # imm = 0x1F8
callq 0x175e0
movq 0x48(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x30(%rbx), %rax
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0x1f8(%rax), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x25f58(%rip), %rdi # 0x9f9ec
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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
|
0x79be6
|
std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>& std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::emplace_back<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>(std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>&&)
|
deque<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_last - 1)
{
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish._M_cur;
}
else
_M_push_back_aux(std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
addq $-0x18, %rcx
cmpq %rcx, %rax
je 0x79c10
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups %xmm0, (%rax)
addq $0x18, 0x30(%rbx)
jmp 0x79c18
movq %rbx, %rdi
callq 0x79c36
movq 0x30(%rbx), %rax
cmpq 0x38(%rbx), %rax
jne 0x79c2f
movq 0x48(%rbx), %rcx
movl $0x1f8, %eax # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x18, %rax
popq %rbx
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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
|
0x79c36
|
void std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::_M_push_back_aux<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>(std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>&&)
|
void
deque<_Tp, _Alloc>::
_M_push_back_aux(const value_type& __t)
#endif
{
if (size() == max_size())
__throw_length_error(
__N("cannot create std::deque larger than max_size()"));
_M_reserve_map_at_back();
*(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
__try
{
#if __cplusplus >= 201103L
_Alloc_traits::construct(this->_M_impl,
this->_M_impl._M_finish._M_cur,
std::forward<_Args>(__args)...);
#else
this->_M_impl.construct(this->_M_impl._M_finish._M_cur, __t);
#endif
this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+ 1);
this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
}
__catch(...)
{
_M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
__throw_exception_again;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, %rcx
subq 0x28(%rdi), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,4), %rdx
leaq (%rcx,%rdx,4), %rcx
movq 0x30(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq 0x20(%rdi), %rsi
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
subq 0x10(%rbx), %rsi
sarq $0x3, %rsi
imulq %rdi, %rsi
addq %rdx, %rsi
addq %rcx, %rsi
movabsq $0x555555555555555, %rcx # imm = 0x555555555555555
cmpq %rcx, %rsi
je 0x79d11
subq (%rbx), %rax
movq 0x8(%rbx), %rcx
sarq $0x3, %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x79cc1
movl $0x1, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x79a9a
movl $0x1f8, %edi # imm = 0x1F8
callq 0x175e0
movq 0x48(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x30(%rbx), %rax
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x48(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0x1f8(%rax), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x25cd4(%rip), %rdi # 0x9f9ec
callq 0x17320
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/deque.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
|
0x79d1e
|
std::deque<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::pop_back()
|
void
pop_back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
if (this->_M_impl._M_finish._M_cur
!= this->_M_impl._M_finish._M_first)
{
--this->_M_impl._M_finish._M_cur;
_Alloc_traits::destroy(_M_get_Tp_allocator(),
this->_M_impl._M_finish._M_cur);
}
else
_M_pop_back_aux();
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rdi
cmpq %rdi, %rax
je 0x79d35
addq $-0x18, %rax
jmp 0x79d64
movl $0x1f8, %esi # imm = 0x1F8
callq 0x17610
movq 0x48(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x48(%rbx)
movq -0x8(%rax), %rax
movq %rax, 0x38(%rbx)
leaq 0x1f8(%rax), %rcx
movq %rcx, 0x40(%rbx)
addq $0x1e0, %rax # imm = 0x1E0
movq %rax, 0x30(%rbx)
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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
|
0x79d6a
|
std::_Deque_base<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>, std::allocator<std::__detail::_StateSeq<std::__cxx11::regex_traits<char>>>>::~_Deque_base()
|
_Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
}
|
cmpq $0x0, (%rdi)
je 0x79db9
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x79da4
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x1f8, %esi # imm = 0x1F8
callq 0x17610
cmpq %r15, %r14
jb 0x79d8d
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
shlq $0x3, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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
|
0x79f50
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Executor(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&, std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, std::regex_constants::match_flag_type)
|
_Executor(_BiIter __begin,
_BiIter __end,
_ResultsVec& __results,
const _RegexT& __re,
_FlagT __flags)
: _M_begin(__begin),
_M_end(__end),
_M_re(__re),
_M_nfa(*__re._M_automaton),
_M_results(__results),
_M_rep_count(_M_nfa.size()),
_M_states(_M_nfa._M_start(), _M_nfa.size()),
_M_flags(__flags)
{
using namespace regex_constants;
if (__flags & match_prev_avail) // ignore not_bol and not_bow
_M_flags &= ~(match_not_bol | match_not_bow);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq 0x10(%r8), %rax
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq 0x40(%rax), %rsi
subq 0x38(%rax), %rsi
leaq 0x48(%rdi), %r14
sarq $0x4, %rsi
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r15, %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x7a35e
leaq 0x60(%rbx), %rdi
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rsi
movq 0x40(%rax), %rdx
subq 0x38(%rax), %rdx
sarq $0x4, %rdx
imulq %r15, %rdx
callq 0x7a3de
movl %ebp, %eax
andl $-0x6, %eax
testb %bpl, %bpl
cmovnsl %ebp, %eax
movl %eax, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7a003
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
jmp 0x7a003
movq %rax, %r15
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7a017
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r15, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7a082
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Executor(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&, std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, std::regex_constants::match_flag_type)
|
_Executor(_BiIter __begin,
_BiIter __end,
_ResultsVec& __results,
const _RegexT& __re,
_FlagT __flags)
: _M_begin(__begin),
_M_end(__end),
_M_re(__re),
_M_nfa(*__re._M_automaton),
_M_results(__results),
_M_rep_count(_M_nfa.size()),
_M_states(_M_nfa._M_start(), _M_nfa.size()),
_M_flags(__flags)
{
using namespace regex_constants;
if (__flags & match_prev_avail) // ignore not_bol and not_bow
_M_flags &= ~(match_not_bol | match_not_bow);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
movq %r8, 0x30(%rdi)
movq 0x10(%r8), %rax
movq %rax, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq 0x40(%rax), %rcx
subq 0x38(%rax), %rcx
addq $0x48, %rdi
sarq $0x4, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
leaq 0xf(%rsp), %rdx
callq 0x7a35e
movq 0x38(%rbx), %rax
movq 0x20(%rax), %rax
movq %rax, 0x60(%rbx)
movq $0x0, 0x68(%rbx)
movl %ebp, %eax
andl $-0x6, %eax
testb %bpl, %bpl
cmovnsl %ebp, %eax
movl %eax, 0x70(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7a11c
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/regex_executor.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
|
0x7a124
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_match()
|
bool
_M_match()
{
_M_current = _M_begin;
return _M_main(_Match_mode::_Exact);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rsi
movq %rax, 0x18(%rdi)
movb $0x0, 0x74(%rdi)
movq $0x0, 0x68(%rdi)
callq 0x7b2c6
movq 0x60(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7b486
movb 0x74(%rbx), %al
popq %rbx
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7a2b0
|
std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::vector(unsigned long, std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
|
vector(size_type __n, const value_type& __value,
const allocator_type& __a = allocator_type())
: _Base(_S_check_init_len(__n, __a), __a)
{ _M_fill_initialize(__n, __value); }
|
pushq %r15
pushq %r14
pushq %rbx
movabsq $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x7a32b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x7a2ef
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7a338
jmp 0x7a2f1
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq %rcx, 0x10(%rbx)
testq %r15, %r15
je 0x7a321
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movups (%r14), %xmm0
movups %xmm0, (%rax)
addq $0x18, %rax
decq %r15
jne 0x7a309
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1aae8(%rip), %rdi # 0x94e1a
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
|
0x7a338
|
_gnu_cxx::new_allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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 $0x555555555555556, %rax # imm = 0x555555555555556
cmpq %rax, %rsi
jae 0x7a354
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x189c4
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
|
0x7a35e
|
std::vector<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>, std::allocator<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>>>::vector(unsigned long, std::allocator<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>> const&)
|
static size_type
_S_check_init_len(size_type __n, const allocator_type& __a)
{
if (__n > _S_max_size(_Tp_alloc_type(__a)))
__throw_length_error(
__N("cannot create std::vector larger than max_size()"));
return __n;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x3b, %rax
jne 0x7a3d2
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x7a393
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7a43c
jmp 0x7a395
xorl %eax, %eax
movq %r14, %rcx
shlq $0x4, %rcx
addq %rax, %rcx
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
testq %r14, %r14
je 0x7a3c6
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
addq $0x10, %rax
decq %r14
jne 0x7a3af
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1aa41(%rip), %rdi # 0x94e1a
callq 0x17320
|
/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
|
0x7a3de
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_State_info<std::integral_constant<bool, false>, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>::_State_info(long, unsigned long)
|
explicit
_State_info(_StateIdT __start, size_t __n)
: _M_visited_states(new bool[__n]()), _M_start(__start)
{ }
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x17030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x17350
movq %r12, 0x18(%rbx)
movq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a458
movq %r14, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7a43c
|
_gnu_cxx::new_allocator<std::pair<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, int>>::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 0x7a451
shlq $0x4, %rdi
jmp 0x175e0
pushq %rax
callq 0x189de
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
|
0x7a458
|
std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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 0x7a487
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x7a481
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x17610
addq $0x20, %r14
jmp 0x7a467
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7a4a0
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
|
0x7a4a6
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_main_dispatch(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, std::integral_constant<bool, false>)
|
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_main_dispatch(_Match_mode __match_mode, __bfs)
{
_M_states._M_queue(_M_states._M_start, _M_results);
bool __ret = false;
while (1)
{
_M_has_sol = false;
if (_M_states._M_match_queue.empty())
break;
std::fill_n(_M_states._M_visited_states.get(), _M_nfa.size(), false);
auto __old_queue = std::move(_M_states._M_match_queue);
for (auto& __task : __old_queue)
{
_M_cur_results = std::move(__task.second);
_M_dfs(__match_mode, __task.first);
}
if (__match_mode == _Match_mode::_Prefix)
__ret |= _M_has_sol;
if (_M_current == _M_end)
break;
++_M_current;
}
if (__match_mode == _Match_mode::_Exact)
__ret = _M_has_sol;
_M_states._M_match_queue.clear();
return __ret;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movq 0x40(%rdi), %rdx
movq 0x80(%rdi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x7a78a
movb $0x0, 0x8c(%r14)
movq 0x60(%r14), %r15
movq 0x68(%r14), %rbp
cmpq %rbp, %r15
movl %r12d, 0xc(%rsp)
je 0x7a5b8
xorl %r13d, %r13d
movzbl %r12b, %r12d
movq 0x38(%r14), %rax
movq 0x40(%rax), %rdx
subq 0x38(%rax), %rdx
je 0x7a529
sarq $0x4, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
movq 0x78(%r14), %rdi
xorl %esi, %esi
callq 0x17350
movq %r15, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
movq 0x70(%r14), %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
cmpq %rbp, %r15
je 0x7a56f
leaq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x7aa54
movq (%r15), %rdx
movq %r14, %rdi
movl %r12d, %esi
callq 0x7a612
addq $0x20, %r15
jmp 0x7a54a
xorl %eax, %eax
cmpb $0x1, 0xc(%rsp)
jne 0x7a57f
movl 0x8c(%r14), %eax
orb %al, %r13b
movq 0x18(%r14), %rax
cmpq 0x28(%r14), %rax
je 0x7a5bd
incq %rax
movq %rax, 0x18(%r14)
leaq 0x10(%rsp), %rdi
callq 0x7a458
movb $0x0, 0x8c(%r14)
movq 0x60(%r14), %r15
movq 0x68(%r14), %rbp
cmpq %rbp, %r15
jne 0x7a4fe
jmp 0x7a5c7
xorl %r13d, %r13d
jmp 0x7a5c7
leaq 0x10(%rsp), %rdi
callq 0x7a458
cmpb $0x0, 0xc(%rsp)
jne 0x7a5d7
movl 0x8c(%r14), %ebp
jmp 0x7a5db
movzbl %r13b, %ebp
movq 0x60(%r14), %rsi
movq %rbx, %rdi
callq 0x7b43c
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7a458
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7a612
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_dfs(_Match_mode __match_mode, _StateIdT __i)
{
if (_M_states._M_visited(__i))
return;
switch (_M_nfa[__i]._M_opcode())
{
case _S_opcode_repeat:
_M_handle_repeat(__match_mode, __i); break;
case _S_opcode_subexpr_begin:
_M_handle_subexpr_begin(__match_mode, __i); break;
case _S_opcode_subexpr_end:
_M_handle_subexpr_end(__match_mode, __i); break;
case _S_opcode_line_begin_assertion:
_M_handle_line_begin_assertion(__match_mode, __i); break;
case _S_opcode_line_end_assertion:
_M_handle_line_end_assertion(__match_mode, __i); break;
case _S_opcode_word_boundary:
_M_handle_word_boundary(__match_mode, __i); break;
case _S_opcode_subexpr_lookahead:
_M_handle_subexpr_lookahead(__match_mode, __i); break;
case _S_opcode_match:
_M_handle_match(__match_mode, __i); break;
case _S_opcode_backref:
_M_handle_backref(__match_mode, __i); break;
case _S_opcode_accept:
_M_handle_accept(__match_mode, __i); break;
case _S_opcode_alternative:
_M_handle_alternative(__match_mode, __i); break;
default:
__glibcxx_assert(false);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x24adf(%rip), %r14 # 0x9f108
movq 0x78(%rbx), %rax
cmpb $0x0, (%rax,%rdx)
jne 0x7a760
movb $0x1, (%rax,%rdx)
movq 0x38(%rbx), %rax
movq 0x38(%rax), %r15
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
movl (%r15,%rax), %ecx
decl %ecx
cmpl $0xb, %ecx
ja 0x7a760
addq %rax, %r15
movslq (%r14,%rcx,4), %rax
addq %r14, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x7ae52
jmp 0x7a68b
movq %rbx, %rdi
callq 0x7af66
cmpb %al, 0x18(%r15)
jne 0x7a693
jmp 0x7a760
movq %rbx, %rdi
callq 0x7af30
testb %al, %al
je 0x7a760
movq 0x8(%r15), %rdx
jmp 0x7a629
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ab86
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ab24
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ad18
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7abdc
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ac44
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7aa8c
movq 0x10(%r15), %rax
leaq (%rax,%rax,2), %r14
movq (%rbx), %r12
movq 0x18(%rbx), %rax
movq (%r12,%r14,8), %r13
movq %rax, (%r12,%r14,8)
movq 0x8(%r15), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x7a612
movq %r13, (%r12,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ad58
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7a78a
|
std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>& std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>::emplace_back<long&, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&>(long&, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> 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 0x7a7ba
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x7a964
addq $0x20, 0x8(%rbx)
jmp 0x7a7c2
movq %rbx, %rdi
callq 0x7a7cc
movq 0x8(%rbx), %rax
addq $-0x20, %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
|
0x7a7cc
|
void std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>::_M_realloc_insert<long&, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&>(__gnu_cxx::__normal_iterator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>*, std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>>, long&, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> 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, 0x10(%rsp)
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
leaq 0x1ed0e(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7a9f4
movq (%r15), %r12
movq 0x8(%r15), %r14
movq %r13, %rbp
subq %r12, %rbp
sarq $0x5, %rbp
testq %rax, %rax
movq %rax, (%rsp)
je 0x7a822
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7aa38
jmp 0x7a824
xorl %eax, %eax
shlq $0x5, %rbp
leaq (%rax,%rbp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rbx), %rcx
addq %rax, %rbp
addq $0x8, %rbp
movq %rcx, -0x8(%rbp)
movq %rax, %rbx
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x7a964
movq %rbx, %rbp
cmpq %r13, %r12
je 0x7a890
xorps %xmm0, %xmm0
movq %rbx, %rbp
movq %r12, %rax
movq (%rax), %rcx
movq %rcx, (%rbp)
movups 0x8(%rax), %xmm1
movups %xmm1, 0x8(%rbp)
movq 0x18(%rax), %rcx
movq %rcx, 0x18(%rbp)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
addq $0x20, %rax
addq $0x20, %rbp
cmpq %r13, %rax
jne 0x7a860
addq $0x20, %rbp
cmpq %r13, %r14
je 0x7a8cf
xorps %xmm0, %xmm0
movq (%r13), %rax
movq %rax, (%rbp)
movups 0x8(%r13), %xmm1
movups %xmm1, 0x8(%rbp)
movq 0x18(%r13), %rax
movq %rax, 0x18(%rbp)
movups %xmm0, 0x8(%r13)
movq $0x0, 0x18(%r13)
addq $0x20, %r13
addq $0x20, %rbp
cmpq %r14, %r13
jne 0x7a89c
testq %r12, %r12
je 0x7a8e3
movq 0x10(%r15), %rsi
subq %r12, %rsi
movq %r12, %rdi
callq 0x17610
movq %rbx, (%r15)
movq %rbp, 0x8(%r15)
movq (%rsp), %rax
shlq $0x5, %rax
addq %rbx, %rax
movq %rax, 0x10(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r15
movq %rax, %rdi
callq 0x17210
movq %rbx, %r14
testq %rbx, %rbx
jne 0x7a937
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x7a932
movq 0x18(%r15), %rsi
subq %rdi, %rsi
callq 0x17610
testq %r14, %r14
je 0x7a947
movq (%rsp), %rsi
shlq $0x5, %rsi
movq %r14, %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
|
0x7a964
|
std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::vector(std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> 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 $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7a9b0
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x7a338
jmp 0x7a9b2
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq (%r15,%r15,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq %rcx, 0x10(%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
je 0x7a9e9
movq 0x10(%rcx), %rsi
movq %rsi, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
addq $0x18, %rcx
addq $0x18, %rax
jmp 0x7a9cc
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
|
0x7a9f4
|
std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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 $0x3ffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFF
movq 0x8(%rdi), %r8
subq (%rdi), %r8
sarq $0x5, %r8
movq %rcx, %rax
subq %r8, %rax
cmpq %rsi, %rax
jb 0x7aa2e
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
|
0x7aa38
|
_gnu_cxx::new_allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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 $0x3a, %rax
jne 0x7aa4d
shlq $0x5, %rdi
jmp 0x175e0
pushq %rax
callq 0x189ef
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
|
0x7aa54
|
std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::_M_move_assign(std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&&, 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 0x7aa8a
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
|
0x7aa8c
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_handle_repeat(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
// Greedy.
if (!__state._M_neg)
{
_M_rep_once_more(__match_mode, __i);
// If it's DFS executor and already accepted, we're done.
if (!__dfs_mode || !_M_has_sol)
_M_dfs(__match_mode, __state._M_next);
}
else // Non-greedy mode
{
if (__dfs_mode)
{
// vice-versa.
_M_dfs(__match_mode, __state._M_next);
if (!_M_has_sol)
_M_rep_once_more(__match_mode, __i);
}
else
{
// DON'T attempt anything, because there's already another
// state with higher priority accepted. This state cannot
// be better by attempting its next node.
if (!_M_has_sol)
{
_M_dfs(__match_mode, __state._M_next);
// DON'T attempt anything if it's already accepted. An
// accepted state *must* be better than a solution that
// matches a non-greedy quantifier one more time.
if (!_M_has_sol)
_M_rep_once_more(__match_mode, __i);
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r15
cmpb $0x0, 0x18(%rax,%rcx)
je 0x7aae3
cmpb $0x0, 0x8c(%rbx)
jne 0x7aad8
movq 0x8(%r15), %rdx
movzbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7a612
cmpb $0x0, 0x8c(%rbx)
je 0x7ab0c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7adda
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a612
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7adda
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ab24
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_handle_subexpr_end(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
auto& __res = _M_cur_results[__state._M_subexpr];
auto __back = __res;
__res.second = _M_current;
__res.matched = true;
_M_dfs(__match_mode, __state._M_next);
__res = __back;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rdx
leaq (%rdx,%rdx,2), %rbx
movq (%rdi), %r14
movq 0x18(%rdi), %r8
movb 0x10(%r14,%rbx,8), %bpl
movb $0x1, 0x10(%r14,%rbx,8)
movq 0x8(%rax,%rcx), %rdx
movups (%r14,%rbx,8), %xmm0
movaps %xmm0, (%rsp)
movq %r8, 0x8(%r14,%rbx,8)
callq 0x7a612
movaps (%rsp), %xmm0
movups %xmm0, (%r14,%rbx,8)
movb %bpl, 0x10(%r14,%rbx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ab86
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_handle_subexpr_lookahead(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_lookahead(__state._M_alt) == !__state._M_neg)
_M_dfs(__match_mode, __state._M_next);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %r14
leaq (%rdx,%rdx,2), %r15
shlq $0x4, %r15
movq 0x10(%r14,%r15), %rsi
callq 0x7b040
cmpb %al, 0x18(%r14,%r15)
jne 0x7abbe
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %r14
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7a612
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ad18
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_handle_accept(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_accept(_Match_mode __match_mode, _StateIdT)
{
if (__dfs_mode)
{
__glibcxx_assert(!_M_has_sol);
if (__match_mode == _Match_mode::_Exact)
_M_has_sol = _M_current == _M_end;
else
_M_has_sol = true;
if (_M_current == _M_begin
&& (_M_flags & regex_constants::match_not_null))
_M_has_sol = false;
if (_M_has_sol)
{
if (_M_nfa._M_flags & regex_constants::ECMAScript)
_M_results = _M_cur_results;
else // POSIX
{
__glibcxx_assert(_M_states._M_get_sol_pos());
// Here's POSIX's logic: match the longest one. However
// we never know which one (lhs or rhs of "|") is longer
// unless we try both of them and compare the results.
// The member variable _M_sol_pos records the end
// position of the last successful match. It's better
// to be larger, because POSIX regex is always greedy.
// TODO: This could be slow.
if (*_M_states._M_get_sol_pos() == _BiIter()
|| std::distance(_M_begin,
*_M_states._M_get_sol_pos())
< std::distance(_M_begin, _M_current))
{
*_M_states._M_get_sol_pos() = _M_current;
_M_results = _M_cur_results;
}
}
}
}
else
{
if (_M_current == _M_begin
&& (_M_flags & regex_constants::match_not_null))
return;
if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end)
if (!_M_has_sol)
{
_M_has_sol = true;
_M_results = _M_cur_results;
}
}
}
|
movq %rdi, %rax
movq 0x18(%rdi), %rcx
cmpq 0x20(%rdi), %rcx
jne 0x7ad2e
testb $0x20, 0x88(%rax)
jne 0x7ad43
cmpb $0x1, %sil
je 0x7ad3a
cmpq 0x28(%rax), %rcx
jne 0x7ad43
cmpb $0x0, 0x8c(%rax)
je 0x7ad44
retq
movb $0x1, 0x8c(%rax)
movq 0x40(%rax), %rdi
movq %rax, %rsi
jmp 0x7b2c6
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ad58
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_handle_alternative(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_nfa._M_flags & regex_constants::ECMAScript)
{
// TODO: Fix BFS support. It is wrong.
_M_dfs(__match_mode, __state._M_alt);
// Pick lhs if it matches. Only try rhs if it doesn't.
if (!_M_has_sol)
_M_dfs(__match_mode, __state._M_next);
}
else
{
// Try both and compare the result.
// See "case _S_opcode_accept:" handling above.
_M_dfs(__match_mode, __state._M_alt);
auto __has_sol = _M_has_sol;
_M_has_sol = false;
_M_dfs(__match_mode, __state._M_next);
_M_has_sol |= __has_sol;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rcx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r14
movb 0x18(%rax), %r12b
movq 0x10(%rcx,%rdx), %rdx
callq 0x7a612
movb 0x8c(%rbx), %r15b
testb $0x10, %r12b
jne 0x7adb4
movb $0x0, 0x8c(%rbx)
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x7a612
orb %r15b, 0x8c(%rbx)
jmp 0x7adb9
testb %r15b, %r15b
je 0x7adc2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7a612
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ae8e
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_is_line_terminator(char) const
|
bool
_M_is_line_terminator(_CharT __c) const
{
const auto& __traits = _M_re._M_automaton->_M_traits;
const auto& __ct = use_facet<ctype<_CharT>>(__traits.getloc());
const char __n{ __ct.narrow(__c, ' ') };
if (__n == '\n')
return true;
if (_M_re._M_automaton->_M_options() & regex_constants::ECMAScript)
{
if (__n == '\r')
return true;
// FIXME: U+2028 (line separator) and U+2029 (paragraph separator)
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x10(%rax), %rsi
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x173b0
movq %r14, %rdi
callq 0x17220
movq %rax, %r14
movq %rsp, %rdi
callq 0x178d0
movzbl %bpl, %r15d
movb 0x139(%r14,%r15), %al
testb %al, %al
jne 0x7aef2
movq (%r14), %rax
movsbl %bpl, %esi
movq %r14, %rdi
movl $0x20, %edx
callq *0x40(%rax)
cmpb $0x20, %al
je 0x7aef2
movb %al, 0x139(%r14,%r15)
movb $0x1, %cl
cmpb $0xa, %al
je 0x7af10
movq 0x30(%rbx), %rcx
movq 0x10(%rcx), %rcx
movb 0x18(%rcx), %dl
andb $0x10, %dl
shrb $0x4, %dl
cmpb $0xd, %al
sete %cl
andb %dl, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x178d0
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7af66
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_word_boundary() const
|
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_word_boundary() const
{
if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow))
return false;
if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow))
return false;
bool __left_is_word = false;
if (_M_current != _M_begin
|| (_M_flags & regex_constants::match_prev_avail))
{
auto __prev = _M_current;
if (_M_is_word(*std::prev(__prev)))
__left_is_word = true;
}
bool __right_is_word =
_M_current != _M_end && _M_is_word(*_M_current);
return __left_is_word != __right_is_word;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jne 0x7af87
testb $0x4, 0x88(%rbx)
jne 0x7b02f
cmpq 0x28(%rbx), %rax
jne 0x7af9a
testb $0x8, 0x88(%rbx)
jne 0x7b02f
cmpq %rcx, %rax
jne 0x7afab
xorl %r14d, %r14d
testb $-0x80, 0x88(%rbx)
je 0x7afe8
movsbl -0x1(%rax), %ebp
movq 0x30(%rbx), %rax
movq 0x10(%rax), %r14
addq $0x50, %r14
leaq 0x25053(%rip), %rsi # 0xa0015
leaq 0x2504d(%rip), %rdx # 0xa0016
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x73cb4
andl $0xffffff, %eax # imm = 0xFFFFFF
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x744b4
movzbl %al, %r14d
movq 0x18(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x7b033
movsbl (%rax), %ebp
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rbx
addq $0x50, %rbx
leaq 0x2500d(%rip), %rsi # 0xa0015
leaq 0x25007(%rip), %rdx # 0xa0016
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x73cb4
andl $0xffffff, %eax # imm = 0xFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x744b4
movzbl %al, %eax
jmp 0x7b035
xorl %eax, %eax
jmp 0x7b03b
xorl %eax, %eax
cmpl %eax, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b040
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, false>::_M_lookahead(long)
|
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_lookahead(_StateIdT __next)
{
// Backreferences may refer to captured content.
// We may want to make this faster by not copying,
// but let's not be clever prematurely.
_ResultsVec __what(_M_cur_results);
_Executor __sub(_M_current, _M_end, __what, _M_re, _M_flags);
__sub._M_states._M_start = __next;
if (__sub._M_search_from_first())
{
for (size_t __i = 0; __i < __what.size(); __i++)
if (__what[__i].matched)
_M_cur_results[__i] = __what[__i];
return true;
}
return false;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7a964
movq 0x18(%r14), %rsi
movq 0x28(%r14), %rdx
movq 0x30(%r14), %r8
movl 0x88(%r14), %r9d
leaq 0x20(%rsp), %rdi
movq %r15, %rcx
callq 0x79f50
leaq 0x20(%rsp), %rdi
movq %rbx, 0x80(%rdi)
movq 0x20(%rdi), %rax
movq %rax, 0x18(%rdi)
movl $0x1, %esi
callq 0x7a4a6
movl %eax, %ebx
testb %al, %al
je 0x7b109
movq 0x8(%rsp), %rcx
cmpq %rcx, 0x10(%rsp)
je 0x7b109
movl $0x10, %eax
xorl %edx, %edx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
movb (%rcx,%rax), %dil
cmpb $0x1, %dil
jne 0x7b0e8
movq (%r14), %r8
movq -0x10(%rcx,%rax), %r9
movq %r9, -0x10(%r8,%rax)
movq -0x8(%rcx,%rax), %rcx
movq %rcx, -0x8(%r8,%rax)
movb %dil, (%r8,%rax)
incq %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
imulq %rsi, %rdi
addq $0x18, %rax
cmpq %rdi, %rdx
jb 0x7b0c3
leaq 0x80(%rsp), %r14
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x7b11f
callq 0x177f0
movq $0x0, 0x98(%rsp)
movq %r14, %rdi
callq 0x7a458
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x7b14a
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7b161
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b178
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7a020
jmp 0x7b199
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b1b0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b1b8
|
std::__detail::_Backref_matcher<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::regex_traits<char>>::_M_apply(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
|
bool
_M_apply(_BiIter __expected_begin,
_BiIter __expected_end, _BiIter __actual_begin,
_BiIter __actual_end)
{
if (!_M_icase)
return _GLIBCXX_STD_A::__equal4(__expected_begin, __expected_end,
__actual_begin, __actual_end);
typedef std::ctype<_CharT> __ctype_type;
const auto& __fctyp = use_facet<__ctype_type>(_M_traits.getloc());
return _GLIBCXX_STD_A::__equal4(__expected_begin, __expected_end,
__actual_begin, __actual_end,
[this, &__fctyp](_CharT __lhs, _CharT __rhs)
{
return __fctyp.tolower(__lhs)
== __fctyp.tolower(__rhs);
});
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
cmpb $0x0, (%rdi)
je 0x7b278
movq 0x8(%rdi), %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x173b0
movq %r12, %rdi
callq 0x17220
movq %rax, %r12
movq %rsp, %rdi
callq 0x178d0
movq %r15, %rax
subq %r14, %rax
subq %rbx, %r13
cmpq %r13, %rax
jne 0x7b29d
cmpq %r15, %r14
sete %al
je 0x7b29f
movsbl (%r14), %esi
movsbl (%rbx), %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
movl %eax, %r13d
movq (%r12), %rax
movq %r12, %rdi
movl %ebp, %esi
callq *0x20(%rax)
cmpb %al, %r13b
jne 0x7b29d
incq %rbx
incq %r14
cmpq %r15, %r14
sete %al
je 0x7b29f
movsbl (%r14), %esi
movsbl (%rbx), %ebp
movq (%r12), %rax
movq %r12, %rdi
callq *0x20(%rax)
movl %eax, %r13d
movq (%r12), %rax
movq %r12, %rdi
movl %ebp, %esi
callq *0x20(%rax)
incq %rbx
incq %r14
cmpb %al, %r13b
je 0x7b243
jmp 0x7b29d
movq %r15, %rdx
subq %r14, %rdx
subq %rbx, %r13
cmpq %r13, %rdx
jne 0x7b29d
cmpq %r14, %r15
je 0x7b2ae
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17650
testl %eax, %eax
sete %al
jmp 0x7b29f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x7b29f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x178d0
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b43c
|
std::vector<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>, std::allocator<std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>>>::_M_erase_at_end(std::pair<long, std::vector<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>*)
|
void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
je 0x7b47a
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r12
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x7b46d
movq 0x18(%r12), %rsi
subq %rdi, %rsi
callq 0x17610
addq $0x20, %r12
cmpq %r15, %r12
jne 0x7b456
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
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
|
0x7b486
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_dfs(_Match_mode __match_mode, _StateIdT __i)
{
if (_M_states._M_visited(__i))
return;
switch (_M_nfa[__i]._M_opcode())
{
case _S_opcode_repeat:
_M_handle_repeat(__match_mode, __i); break;
case _S_opcode_subexpr_begin:
_M_handle_subexpr_begin(__match_mode, __i); break;
case _S_opcode_subexpr_end:
_M_handle_subexpr_end(__match_mode, __i); break;
case _S_opcode_line_begin_assertion:
_M_handle_line_begin_assertion(__match_mode, __i); break;
case _S_opcode_line_end_assertion:
_M_handle_line_end_assertion(__match_mode, __i); break;
case _S_opcode_word_boundary:
_M_handle_word_boundary(__match_mode, __i); break;
case _S_opcode_subexpr_lookahead:
_M_handle_subexpr_lookahead(__match_mode, __i); break;
case _S_opcode_match:
_M_handle_match(__match_mode, __i); break;
case _S_opcode_backref:
_M_handle_backref(__match_mode, __i); break;
case _S_opcode_accept:
_M_handle_accept(__match_mode, __i); break;
case _S_opcode_alternative:
_M_handle_alternative(__match_mode, __i); break;
default:
__glibcxx_assert(false);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x23c9b(%rip), %r14 # 0x9f138
movq 0x38(%rbx), %rax
movq 0x38(%rax), %r15
leaq (%rdx,%rdx,2), %rax
shlq $0x4, %rax
movl (%r15,%rax), %ecx
decl %ecx
cmpl $0xb, %ecx
ja 0x7b5c2
addq %rax, %r15
movslq (%r14,%rcx,4), %rax
addq %r14, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x7b9ce
jmp 0x7b4ed
movq %rbx, %rdi
callq 0x7badc
cmpb %al, 0x18(%r15)
jne 0x7b4f5
jmp 0x7b5c2
movq %rbx, %rdi
callq 0x7baaa
testb %al, %al
je 0x7b5c2
movq 0x8(%r15), %rdx
jmp 0x7b49d
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b67e
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b6e0
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b876
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b5ec
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b8dc
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b7a2
movq 0x10(%r15), %rax
leaq (%rax,%rax,2), %r14
movq (%rbx), %r12
movq 0x18(%rbx), %rax
movq (%r12,%r14,8), %r13
movq %rax, (%r12,%r14,8)
movq 0x8(%r15), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x7b486
movq %r13, (%r12,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b736
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b5ec
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_handle_repeat(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_repeat(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
// Greedy.
if (!__state._M_neg)
{
_M_rep_once_more(__match_mode, __i);
// If it's DFS executor and already accepted, we're done.
if (!__dfs_mode || !_M_has_sol)
_M_dfs(__match_mode, __state._M_next);
}
else // Non-greedy mode
{
if (__dfs_mode)
{
// vice-versa.
_M_dfs(__match_mode, __state._M_next);
if (!_M_has_sol)
_M_rep_once_more(__match_mode, __i);
}
else
{
// DON'T attempt anything, because there's already another
// state with higher priority accepted. This state cannot
// be better by attempting its next node.
if (!_M_has_sol)
{
_M_dfs(__match_mode, __state._M_next);
// DON'T attempt anything if it's already accepted. An
// accepted state *must* be better than a solution that
// matches a non-greedy quantifier one more time.
if (!_M_has_sol)
_M_rep_once_more(__match_mode, __i);
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r15
cmpb $0x0, 0x18(%rax,%rcx)
je 0x7b643
movq 0x8(%r15), %rdx
movzbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7b486
cmpb $0x0, 0x74(%rbx)
jne 0x7b65a
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7b956
movzbl %sil, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7b956
cmpb $0x0, 0x74(%rbx)
je 0x7b665
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7b486
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b67e
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_handle_subexpr_end(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_end(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
auto& __res = _M_cur_results[__state._M_subexpr];
auto __back = __res;
__res.second = _M_current;
__res.matched = true;
_M_dfs(__match_mode, __state._M_next);
__res = __back;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rax
leaq (%rdx,%rdx,2), %rcx
shlq $0x4, %rcx
movq 0x10(%rax,%rcx), %rdx
leaq (%rdx,%rdx,2), %rbx
movq (%rdi), %r14
movq 0x18(%rdi), %r8
movb 0x10(%r14,%rbx,8), %bpl
movb $0x1, 0x10(%r14,%rbx,8)
movq 0x8(%rax,%rcx), %rdx
movups (%r14,%rbx,8), %xmm0
movaps %xmm0, (%rsp)
movq %r8, 0x8(%r14,%rbx,8)
callq 0x7b486
movaps (%rsp), %xmm0
movups %xmm0, (%r14,%rbx,8)
movb %bpl, 0x10(%r14,%rbx,8)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b6e0
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_handle_subexpr_lookahead(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_subexpr_lookahead(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_lookahead(__state._M_alt) == !__state._M_neg)
_M_dfs(__match_mode, __state._M_next);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %r14
leaq (%rdx,%rdx,2), %r15
shlq $0x4, %r15
movq 0x10(%r14,%r15), %rsi
callq 0x7bbae
cmpb %al, 0x18(%r14,%r15)
jne 0x7b718
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %r14
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7b486
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b876
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_handle_accept(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_accept(_Match_mode __match_mode, _StateIdT)
{
if (__dfs_mode)
{
__glibcxx_assert(!_M_has_sol);
if (__match_mode == _Match_mode::_Exact)
_M_has_sol = _M_current == _M_end;
else
_M_has_sol = true;
if (_M_current == _M_begin
&& (_M_flags & regex_constants::match_not_null))
_M_has_sol = false;
if (_M_has_sol)
{
if (_M_nfa._M_flags & regex_constants::ECMAScript)
_M_results = _M_cur_results;
else // POSIX
{
__glibcxx_assert(_M_states._M_get_sol_pos());
// Here's POSIX's logic: match the longest one. However
// we never know which one (lhs or rhs of "|") is longer
// unless we try both of them and compare the results.
// The member variable _M_sol_pos records the end
// position of the last successful match. It's better
// to be larger, because POSIX regex is always greedy.
// TODO: This could be slow.
if (*_M_states._M_get_sol_pos() == _BiIter()
|| std::distance(_M_begin,
*_M_states._M_get_sol_pos())
< std::distance(_M_begin, _M_current))
{
*_M_states._M_get_sol_pos() = _M_current;
_M_results = _M_cur_results;
}
}
}
}
else
{
if (_M_current == _M_begin
&& (_M_flags & regex_constants::match_not_null))
return;
if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end)
if (!_M_has_sol)
{
_M_has_sol = true;
_M_results = _M_cur_results;
}
}
}
|
movq %rdi, %rax
testl %esi, %esi
je 0x7b883
movb $0x1, 0x74(%rax)
jmp 0x7b88f
movq 0x18(%rax), %rcx
cmpq 0x28(%rax), %rcx
sete 0x74(%rax)
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
subq %rdx, %rcx
jne 0x7b8a6
testb $0x20, 0x70(%rax)
je 0x7b8a6
movb $0x0, 0x74(%rax)
cmpb $0x1, 0x74(%rax)
jne 0x7b8db
movq 0x38(%rax), %rsi
testb $0x10, 0x18(%rsi)
jne 0x7b8cf
movq 0x68(%rax), %rsi
testq %rsi, %rsi
je 0x7b8c7
subq %rdx, %rsi
cmpq %rcx, %rsi
jge 0x7b8db
movq 0x18(%rax), %rcx
movq %rcx, 0x68(%rax)
movq 0x40(%rax), %rdi
movq %rax, %rsi
jmp 0x7b2c6
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7b8dc
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_handle_alternative(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_Match_mode, long)
|
void _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_handle_alternative(_Match_mode __match_mode, _StateIdT __i)
{
const auto& __state = _M_nfa[__i];
if (_M_nfa._M_flags & regex_constants::ECMAScript)
{
// TODO: Fix BFS support. It is wrong.
_M_dfs(__match_mode, __state._M_alt);
// Pick lhs if it matches. Only try rhs if it doesn't.
if (!_M_has_sol)
_M_dfs(__match_mode, __state._M_next);
}
else
{
// Try both and compare the result.
// See "case _S_opcode_accept:" handling above.
_M_dfs(__match_mode, __state._M_alt);
auto __has_sol = _M_has_sol;
_M_has_sol = false;
_M_dfs(__match_mode, __state._M_next);
_M_has_sol |= __has_sol;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x38(%rax), %rcx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r14
movb 0x18(%rax), %r12b
movq 0x10(%rcx,%rdx), %rdx
callq 0x7b486
movb 0x74(%rbx), %r15b
testb $0x10, %r12b
jne 0x7b92f
movb $0x0, 0x74(%rbx)
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x7b486
orb %r15b, 0x74(%rbx)
jmp 0x7b934
testb %r15b, %r15b
je 0x7b93d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdx
movzbl %bpl, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7b486
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7ba08
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_is_line_terminator(char) const
|
bool
_M_is_line_terminator(_CharT __c) const
{
const auto& __traits = _M_re._M_automaton->_M_traits;
const auto& __ct = use_facet<ctype<_CharT>>(__traits.getloc());
const char __n{ __ct.narrow(__c, ' ') };
if (__n == '\n')
return true;
if (_M_re._M_automaton->_M_options() & regex_constants::ECMAScript)
{
if (__n == '\r')
return true;
// FIXME: U+2028 (line separator) and U+2029 (paragraph separator)
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x10(%rax), %rsi
addq $0x50, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x173b0
movq %r14, %rdi
callq 0x17220
movq %rax, %r14
movq %rsp, %rdi
callq 0x178d0
movzbl %bpl, %r15d
movb 0x139(%r14,%r15), %al
testb %al, %al
jne 0x7ba6c
movq (%r14), %rax
movsbl %bpl, %esi
movq %r14, %rdi
movl $0x20, %edx
callq *0x40(%rax)
cmpb $0x20, %al
je 0x7ba6c
movb %al, 0x139(%r14,%r15)
movb $0x1, %cl
cmpb $0xa, %al
je 0x7ba8a
movq 0x30(%rbx), %rcx
movq 0x10(%rcx), %rcx
movb 0x18(%rcx), %dl
andb $0x10, %dl
shrb $0x4, %dl
cmpb $0xd, %al
sete %cl
andb %dl, %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x178d0
movq %rbx, %rdi
callq 0x17b40
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7badc
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_word_boundary() const
|
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_word_boundary() const
{
if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_bow))
return false;
if (_M_current == _M_end && (_M_flags & regex_constants::match_not_eow))
return false;
bool __left_is_word = false;
if (_M_current != _M_begin
|| (_M_flags & regex_constants::match_prev_avail))
{
auto __prev = _M_current;
if (_M_is_word(*std::prev(__prev)))
__left_is_word = true;
}
bool __right_is_word =
_M_current != _M_end && _M_is_word(*_M_current);
return __left_is_word != __right_is_word;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
jne 0x7bafa
testb $0x4, 0x70(%rbx)
jne 0x7bb9c
cmpq 0x28(%rbx), %rax
jne 0x7bb0a
testb $0x8, 0x70(%rbx)
jne 0x7bb9c
cmpq %rcx, %rax
jne 0x7bb18
xorl %r14d, %r14d
testb $-0x80, 0x70(%rbx)
je 0x7bb55
movsbl -0x1(%rax), %ebp
movq 0x30(%rbx), %rax
movq 0x10(%rax), %r14
addq $0x50, %r14
leaq 0x244e8(%rip), %rsi # 0xa0017
leaq 0x244e2(%rip), %rdx # 0xa0018
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x73cb4
andl $0xffffff, %eax # imm = 0xFFFFFF
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x744b4
movzbl %al, %r14d
movq 0x18(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x7bba0
movsbl (%rax), %ebp
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rbx
addq $0x50, %rbx
leaq 0x244a2(%rip), %rsi # 0xa0017
leaq 0x2449c(%rip), %rdx # 0xa0018
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x73cb4
andl $0xffffff, %eax # imm = 0xFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %edx
callq 0x744b4
movzbl %al, %eax
jmp 0x7bba2
xorl %eax, %eax
jmp 0x7bba8
xorl %eax, %eax
cmpl %eax, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7bbae
|
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, std::__cxx11::regex_traits<char>, true>::_M_lookahead(long)
|
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
_M_lookahead(_StateIdT __next)
{
// Backreferences may refer to captured content.
// We may want to make this faster by not copying,
// but let's not be clever prematurely.
_ResultsVec __what(_M_cur_results);
_Executor __sub(_M_current, _M_end, __what, _M_re, _M_flags);
__sub._M_states._M_start = __next;
if (__sub._M_search_from_first())
{
for (size_t __i = 0; __i < __what.size(); __i++)
if (__what[__i].matched)
_M_cur_results[__i] = __what[__i];
return true;
}
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7a964
movq 0x18(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %r8
movl 0x70(%rbx), %r9d
leaq 0x20(%rsp), %rdi
movq %r15, %rcx
callq 0x7a082
leaq 0x20(%rsp), %rdi
movq %r14, 0x60(%rdi)
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rsi
movq %rax, 0x18(%rdi)
movb $0x0, 0x74(%rdi)
movq $0x0, 0x68(%rdi)
callq 0x7b2c6
leaq 0x20(%rsp), %rdi
movq 0x60(%rdi), %rdx
movl $0x1, %esi
callq 0x7b486
movb 0x94(%rsp), %bpl
cmpb $0x1, %bpl
jne 0x7bc98
movq 0x8(%rsp), %rcx
cmpq %rcx, 0x10(%rsp)
je 0x7bc98
movl $0x10, %eax
xorl %edx, %edx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
movb (%rcx,%rax), %dil
cmpb $0x1, %dil
jne 0x7bc77
movq (%rbx), %r8
movq -0x10(%rcx,%rax), %r9
movq %r9, -0x10(%r8,%rax)
movq -0x8(%rcx,%rax), %rcx
movq %rcx, -0x8(%r8,%rax)
movb %dil, (%r8,%rax)
incq %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
imulq %rsi, %rdi
addq $0x18, %rax
cmpq %rdi, %rdx
jb 0x7bc52
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x7bcaf
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7bcc6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7bcdd
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7bcff
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7a158
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7bd16
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x17610
movq %rbx, %rdi
callq 0x17b40
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/regex_executor.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
|
0x7c60e
|
void std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_M_insert_aux<Catch::Detail::unique_ptr<Catch::IEventListener>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::IEventListener>*, std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>>, Catch::Detail::unique_ptr<Catch::IEventListener>&&)
|
void
vector<_Tp, _Alloc>::
_M_insert_aux(iterator __position, const _Tp& __x)
#endif
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
_GLIBCXX_MOVE(*(this->_M_impl._M_finish - 1)));
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
#if __cplusplus < 201103L
_Tp __x_copy = __x;
#endif
_GLIBCXX_MOVE_BACKWARD3(__position.base(),
this->_M_impl._M_finish - 2,
this->_M_impl._M_finish - 1);
#if __cplusplus < 201103L
*__position = __x_copy;
#else
*__position = std::forward<_Arg>(__arg);
#endif
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x8(%rdi), %rax
leaq -0x8(%rax), %r15
movq -0x8(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rax)
addq $0x8, %rax
movq %rax, 0x8(%rdi)
movq %r15, %r12
subq %rsi, %r12
sarq $0x3, %r12
testq %r12, %r12
jle 0x7c678
incq %r12
movq -0x8(%r15), %r13
movq (%r15), %rdi
movq $0x0, -0x8(%r15)
testq %rdi, %rdi
je 0x7c668
movq (%rdi), %rax
callq *0x8(%rax)
movq %r13, (%r15)
addq $-0x8, %r15
decq %r12
cmpq $0x1, %r12
jg 0x7c64e
movq (%r14), %r15
movq $0x0, (%r14)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7c690
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
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
|
0x7c69e
|
void std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::IEventListener>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::IEventListener>*, std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>>, Catch::Detail::unique_ptr<Catch::IEventListener>&&)
|
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 0x1ce3f(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7c79a
movq (%rbx), %r15
movq 0x8(%rbx), %r14
movq %r12, %rbp
subq %r15, %rbp
sarq $0x3, %rbp
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x7c6f5
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7c7de
movq %rax, %r13
jmp 0x7c6f8
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 0x7c735
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 0x7c71a
addq $0x8, %rbp
cmpq %r12, %r14
je 0x7c75b
movq (%r12), %rax
movq %rax, (%rbp)
movq $0x0, (%r12)
addq $0x8, %r12
addq $0x8, %rbp
cmpq %r14, %r12
jne 0x7c73e
testq %r15, %r15
je 0x7c76f
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
|
0x7c79a
|
std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::_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 0x7c7d4
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
|
0x7c7de
|
_gnu_cxx::new_allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>::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 0x7c7f3
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18a00
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
|
0x7c7fa
|
Catch::Detail::unique_ptr<Catch::IEventListener>& std::vector<Catch::Detail::unique_ptr<Catch::IEventListener>, std::allocator<Catch::Detail::unique_ptr<Catch::IEventListener>>>::emplace_back<Catch::Detail::unique_ptr<Catch::IEventListener>>(Catch::Detail::unique_ptr<Catch::IEventListener>&&)
|
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 0x7c822
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7c82a
movq %rbx, %rdi
callq 0x7c69e
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
|
0x7cb18
|
Catch::SectionStats::SectionStats(Catch::SectionInfo&&, Catch::Counts const&, double, bool)
|
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), %r8
movq %r8, (%rdi)
movq (%rsi), %r9
leaq 0x10(%rsi), %rax
cmpq %rax, %r9
je 0x7cb37
movq %r9, (%rdi)
movq (%rax), %r8
movq %r8, 0x10(%rdi)
jmp 0x7cb3e
movups (%rax), %xmm1
movups %xmm1, (%r8)
movq 0x8(%rsi), %r8
movq %r8, 0x8(%rdi)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movups 0x20(%rsi), %xmm1
movups %xmm1, 0x20(%rdi)
movups (%rdx), %xmm1
movups 0x10(%rdx), %xmm2
movups %xmm1, 0x30(%rdi)
movups %xmm2, 0x40(%rdi)
movsd %xmm0, 0x50(%rdi)
movb %cl, 0x58(%rdi)
retq
nop
|
/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
|
0x7cc4c
|
std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::vector(std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> 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 $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7cc9b
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x673c8
movq %rax, %rdx
jmp 0x7cc9d
xorl %edx, %edx
movq %rdx, (%rbx)
movq %rdx, 0x8(%rbx)
leaq (%r15,%r15,8), %rax
leaq (%rdx,%rax,8), %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x7cd5a
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7ccdd
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
|
0x7cdff
|
void std::_Destroy<Catch::MessageInfo*>(Catch::MessageInfo*, Catch::MessageInfo*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x7ce3d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x20, %r14
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x7ce26
movq (%r14), %rsi
incq %rsi
callq 0x17610
leaq 0x48(%r14), %rax
addq $0x28, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x7ce12
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
|
0x7ce3e
|
Catch::MessageInfo& std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::emplace_back<Catch::MessageInfo>(Catch::MessageInfo&&)
|
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 0x7ce77
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
leaq 0x20(%rsi), %rcx
movq %rcx, 0x10(%rsi)
movq 0x10(%rdx), %rdi
leaq 0x20(%rdx), %rax
cmpq %rax, %rdi
je 0x7ce81
movq %rdi, 0x10(%rsi)
movq (%rax), %rcx
movq %rcx, 0x20(%rsi)
jmp 0x7ce87
movq %rbx, %rdi
callq 0x7cebe
jmp 0x7ceb4
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rdx), %rcx
movq %rcx, 0x18(%rsi)
movq %rax, 0x10(%rdx)
movq $0x0, 0x18(%rdx)
movb $0x0, 0x20(%rdx)
movq 0x40(%rdx), %rax
movq %rax, 0x40(%rsi)
movups 0x30(%rdx), %xmm0
movups %xmm0, 0x30(%rsi)
addq $0x48, 0x8(%rbx)
movq 0x8(%rbx), %rax
addq $-0x48, %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
|
0x7cebe
|
void std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::_M_realloc_insert<Catch::MessageInfo>(__gnu_cxx::__normal_iterator<Catch::MessageInfo*, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>>, Catch::MessageInfo&&)
|
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 0x1c621(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x67376
movq %rax, %rsi
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %rax
movq %rcx, 0x8(%rsp)
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r15 # imm = 0x8E38E38E38E38E39
imulq %rax, %r15
testq %rsi, %rsi
movq %rsi, 0x10(%rsp)
je 0x7cf26
movq %rbx, %rdi
xorl %edx, %edx
callq 0x673c8
movq %rax, %r13
jmp 0x7cf29
xorl %r13d, %r13d
leaq (%r15,%r15,8), %rcx
leaq (,%rcx,8), %rax
addq %r13, %rax
movups (%rbp), %xmm0
movups %xmm0, (%rax)
leaq 0x20(%r13,%rcx,8), %rdx
movq %rdx, -0x10(%rdx)
movq 0x10(%rbp), %rsi
leaq 0x20(%rbp), %rcx
cmpq %rcx, %rsi
je 0x7cf62
movq %rsi, 0x10(%rax)
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
jmp 0x7cf68
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rsp), %rdi
movq 0x18(%rbp), %rdx
movq %rdx, 0x18(%rax)
movq %rcx, 0x10(%rbp)
movq $0x0, 0x18(%rbp)
movb $0x0, 0x20(%rbp)
movq 0x40(%rbp), %rcx
movq %rcx, 0x40(%rax)
movups 0x30(%rbp), %xmm0
movups %xmm0, 0x30(%rax)
movq %r13, %rbp
cmpq %r12, %rdi
je 0x7d00d
leaq 0x20(%r13), %rbp
leaq 0x20(%rdi), %rax
movups -0x20(%rax), %xmm0
movups %xmm0, -0x20(%rbp)
movq %rbp, -0x10(%rbp)
movq -0x10(%rax), %rcx
cmpq %rcx, %rax
je 0x7cfc7
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, (%rbp)
jmp 0x7cfce
movups (%rax), %xmm0
movups %xmm0, (%rbp)
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbp)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%rbp)
addq $0x48, %rbp
leaq 0x48(%rax), %rcx
addq $0x28, %rax
cmpq %r12, %rax
movq %rcx, %rax
jne 0x7cfa5
addq $-0x20, %rbp
cmpq %r12, %r14
je 0x7d097
xorl %eax, %eax
leaq (%r12,%rax), %rcx
addq $0x20, %rcx
movups -0x20(%rcx), %xmm0
leaq 0x68(%rbp,%rax), %rdx
movups %xmm0, -0x20(%rdx)
movq %rdx, -0x10(%rdx)
movq -0x10(%rcx), %rsi
cmpq %rsi, %rcx
je 0x7d049
movq %rsi, 0x58(%rbp,%rax)
movq (%rcx), %rdx
movq %rdx, 0x68(%rbp,%rax)
jmp 0x7d04f
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
leaq (%r12,%rax), %rdx
addq $0x48, %rdx
movq -0x30(%rdx), %rsi
movq %rsi, 0x60(%rbp,%rax)
movq %rcx, -0x38(%rdx)
movq $0x0, -0x30(%rdx)
movb $0x0, -0x28(%rdx)
movq -0x8(%rdx), %rcx
movq %rcx, 0x88(%rbp,%rax)
movups -0x18(%rdx), %xmm0
movups %xmm0, 0x78(%rbp,%rax)
addq $0x48, %rax
cmpq %r14, %rdx
jne 0x7d018
addq %rax, %rbp
addq $0x48, %rbp
jmp 0x7d09b
addq $0x48, %rbp
testq %rdi, %rdi
je 0x7d0ac
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x17610
movq %r13, (%rbx)
movq %rbp, 0x8(%rbx)
movq 0x10(%rsp), %rax
leaq (%rax,%rax,8), %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
|
0x7d0e4
|
Catch::AssertionResultData::AssertionResultData(Catch::ResultWas::OfType, Catch::LazyExpression 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), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x40(%rdi)
movl %esi, 0x50(%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
|
0x7d2bc
|
Catch::AssertionResult::hasMessage() const
|
_GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return this->size() == 0; }
|
cmpq $0x0, 0x40(%rdi)
setne %al
retq
nop
|
/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
|
0x7d56a
|
Catch::AssertionResult::getMessage() const
|
pointer
_M_data() const
{ return _M_dataplus._M_p; }
|
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rdx
retq
nop
|
/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
|
0x7e5ca
|
Catch::Config::name() const
|
_GLIBCXX_NODISCARD bool
empty() const _GLIBCXX_NOEXCEPT
{ return this->size() == 0; }
|
xorl %ecx, %ecx
cmpq $0x0, 0x98(%rdi)
sete %cl
shll $0x5, %ecx
movq 0x90(%rdi,%rcx), %rax
movq 0x98(%rdi,%rcx), %rdx
retq
nop
|
/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
|
0x7e646
|
Catch::Config::benchmarkWarmupTime() const
|
constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { }
|
movq 0x40(%rdi), %rax
retq
nop
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono
|
njoy[P]ENDFtk[P]build_O1[P]src[P]ENDFtk[P]section[P]10[P]ReactionProduct[P]test[P]ENDFtk.section.10.ReactionProduct.test
|
0x7e8c4
|
std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::~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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x7ea3e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e8e9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x17610
popq %rbx
retq
movq %rax, %rdi
callq 0x1e8bf
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
|
0x7e8f4
|
std::vector<Catch::ReporterSpec, std::allocator<Catch::ReporterSpec>>::vector(std::vector<Catch::ReporterSpec, std::allocator<Catch::ReporterSpec>> 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 $-0xf0f0f0f0f0f0f0f, %r15 # imm = 0xF0F0F0F0F0F0F0F1
imulq %rdx, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq %rcx, %rax
je 0x7e943
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4a144
movq %rax, %rdx
jmp 0x7e945
xorl %edx, %edx
movq %rdx, (%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rax
shlq $0x7, %rax
leaq (%rax,%r15,8), %rax
addq %rdx, %rax
movq %rax, 0x10(%rbx)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x4a16c
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e98b
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
|
0x7e994
|
std::vector<Catch::TestSpec::Filter, std::allocator<Catch::TestSpec::Filter>>::~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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x7e9c4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e9b9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x17610
popq %rbx
retq
movq %rax, %rdi
callq 0x1e8bf
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
|
0x7e9c4
|
void std::_Destroy_aux<false>::__destroy<Catch::TestSpec::Filter*>(Catch::TestSpec::Filter*, Catch::TestSpec::Filter*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x7e9f4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%r14), %rdi
callq 0x7e9f6
movq %r14, %rdi
callq 0x7e9f6
addq $0x30, %r14
cmpq %rbx, %r14
jne 0x7e9d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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
|
0x7e9f6
|
std::vector<Catch::Detail::unique_ptr<Catch::TestSpec::Pattern>, std::allocator<Catch::Detail::unique_ptr<Catch::TestSpec::Pattern>>>::~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 0x7ea1e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7ea18
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x7ea05
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7ea37
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
|
0x7ea3e
|
void std::_Destroy_aux<false>::__destroy<Catch::ProcessedReporterSpec*>(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*)
|
static _GLIBCXX20_CONSTEXPR void
__destroy(_ForwardIterator __first, _ForwardIterator __last)
{
for (; __first != __last; ++__first)
std::_Destroy(std::__addressof(*__first));
}
|
cmpq %rsi, %rdi
je 0x7ea9d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x30, %r14
leaq 0x18(%r14), %rdi
callq 0x49ce8
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x7ea6e
movq (%r14), %rsi
incq %rsi
callq 0x17610
movq -0x30(%r14), %rdi
leaq -0x20(%r14), %rax
cmpq %rdi, %rax
je 0x7ea86
movq (%rax), %rsi
incq %rsi
callq 0x17610
leaq 0x78(%r14), %rax
addq $0x48, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x7ea51
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
|
0x7ea9e
|
Catch::ProcessedReporterSpec& std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::emplace_back<Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec&&)
|
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 0x7eabe
movq %rbx, %rdi
callq 0x7ebac
addq $0x78, 0x8(%rbx)
jmp 0x7eac6
movq %rbx, %rdi
callq 0x7ead0
movq 0x8(%rbx), %rax
addq $-0x78, %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
|
0x7ead0
|
void std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_M_realloc_insert<Catch::ProcessedReporterSpec>(__gnu_cxx::__normal_iterator<Catch::ProcessedReporterSpec*, std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>>, Catch::ProcessedReporterSpec&&)
|
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 0x1aa0d(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x7ec42
movq %rax, %r14
movq (%rbx), %r15
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rbp # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rbp
testq %r14, %r14
je 0x7eb38
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7ec94
movq %rax, %r13
jmp 0x7eb3b
xorl %r13d, %r13d
imulq $0x78, %rbp, %rsi
addq %r13, %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq 0x7ebac
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x7ecb6
leaq 0x78(%rax), %rdx
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rcx
callq 0x7ecb6
movq %rax, %r12
testq %r15, %r15
je 0x7eb8b
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x17610
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
imulq $0x78, %r14, %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
|
0x7ebac
|
void __gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::construct<Catch::ProcessedReporterSpec, Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec&&)
|
void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
|
movq %rsi, %rdi
leaq 0x10(%rsi), %rcx
movq %rcx, (%rsi)
movq (%rdx), %rsi
leaq 0x10(%rdx), %rax
cmpq %rax, %rsi
je 0x7ebce
movq %rsi, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x7ebd4
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq 0x20(%rdx), %rsi
leaq 0x30(%rdx), %rax
cmpq %rax, %rsi
je 0x7ec0d
movq %rsi, 0x20(%rdi)
movq (%rax), %rcx
movq %rcx, 0x30(%rdi)
jmp 0x7ec13
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x28(%rdx), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x20(%rdx)
movq $0x0, 0x28(%rdx)
movb $0x0, 0x30(%rdx)
movb 0x40(%rdx), %al
movb %al, 0x40(%rdi)
addq $0x50, %rdi
addq $0x50, %rdx
movq %rdx, %rsi
jmp 0x5e930
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
|
0x7ec42
|
std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_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 $0x111111111111111, %rcx # imm = 0x111111111111111
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rdi # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rdi
movq %rcx, %rax
subq %rdi, %rax
cmpq %rsi, %rax
jb 0x7ec8a
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
|
0x7ec94
|
_gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::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 $0x111111111111112, %rax # imm = 0x111111111111112
cmpq %rax, %rsi
jae 0x7ecac
imulq $0x78, %rsi, %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18a56
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
|
0x7ecb6
|
std::vector<Catch::ProcessedReporterSpec, std::allocator<Catch::ProcessedReporterSpec>>::_S_do_relocate(Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*, Catch::ProcessedReporterSpec*, std::allocator<Catch::ProcessedReporterSpec>&, 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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpq %rsi, %rdi
je 0x7ecf5
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7ebac
movq %r14, %rdi
movq %r12, %rsi
callq 0x7ed04
addq $0x78, %r12
addq $0x78, %rbx
cmpq %r15, %r12
jne 0x7eccf
movq %rbx, %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/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
|
0x7ed04
|
void __gnu_cxx::new_allocator<Catch::ProcessedReporterSpec>::destroy<Catch::ProcessedReporterSpec>(Catch::ProcessedReporterSpec*)
|
void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); }
|
pushq %rbx
movq %rsi, %rbx
leaq 0x48(%rsi), %rdi
callq 0x49ce8
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x7ed29
movq (%rax), %rsi
incq %rsi
callq 0x17610
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x7ed41
movq (%rbx), %rsi
incq %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
|
0x7ed44
|
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>>>>::_M_erase_at_end(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
|
void
_M_erase_at_end(pointer __pos) _GLIBCXX_NOEXCEPT
{
if (size_type __n = this->_M_impl._M_finish - __pos)
{
std::_Destroy(__pos, this->_M_impl._M_finish,
_M_get_Tp_allocator());
this->_M_impl._M_finish = __pos;
_GLIBCXX_ASAN_ANNOTATE_SHRINK(__n);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
je 0x7ed8a
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x7ed75
movq (%r12), %rsi
incq %rsi
callq 0x17610
leaq 0x20(%r12), %rax
addq $0x10, %r12
cmpq %r15, %r12
movq %rax, %r12
jne 0x7ed5f
movq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
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
|
0x7f476
|
Catch::MessageInfo& std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::emplace_back<Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&>(Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&)
|
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 %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x7f4a6
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movl (%r8), %r8d
movq %rax, %rdi
callq 0x815a8
addq $0x48, 0x8(%rbx)
jmp 0x7f4b1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f88c
movq 0x8(%rbx), %rax
addq $-0x48, %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
|
0x7f4bc
|
std::_Deque_base<char, std::allocator<char>>::~_Deque_base()
|
_Deque_base<_Tp, _Alloc>::
~_Deque_base() _GLIBCXX_NOEXCEPT
{
if (this->_M_impl._M_map)
{
_M_destroy_nodes(this->_M_impl._M_start._M_node,
this->_M_impl._M_finish._M_node + 1);
_M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
}
}
|
cmpq $0x0, (%rdi)
je 0x7f50b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x8(%r15), %rax
cmpq %rax, %r14
jae 0x7f4f6
addq $-0x8, %r14
movq 0x8(%r14), %rdi
addq $0x8, %r14
movl $0x200, %esi # imm = 0x200
callq 0x17610
cmpq %r15, %r14
jb 0x7f4df
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
shlq $0x3, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
retq
|
/usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_deque.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
|
0x7f668
|
_gnu_cxx::new_allocator<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 0x7f67d
shlq $0x3, %rdi
jmp 0x175e0
pushq %rax
callq 0x18a70
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
|
0x7f88c
|
void std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>::_M_realloc_insert<Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&>(__gnu_cxx::__normal_iterator<Catch::MessageInfo*, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>>>, Catch::StringRef&, Catch::SourceLineInfo const&, Catch::ResultWas::OfType&)
|
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 %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r15
leaq 0x19c49(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x67376
movq %rax, %rsi
movq (%r15), %r12
movq 0x8(%r15), %rbx
movq %r13, %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r14 # imm = 0x8E38E38E38E38E39
imulq %rax, %r14
testq %rsi, %rsi
movq %rsi, (%rsp)
je 0x7f8f5
movq %r15, %rdi
xorl %edx, %edx
callq 0x673c8
jmp 0x7f8f7
xorl %eax, %eax
leaq (%r14,%r14,8), %rcx
leaq (%rax,%rcx,8), %r14
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq 0x8(%rsp), %rcx
movl (%rcx), %r8d
movq %rax, %rbp
movq %r14, %rdi
movq 0x10(%rsp), %rcx
callq 0x815a8
movq %rbp, %r14
cmpq %r13, %r12
movq %rbp, %rdi
je 0x7f99c
leaq 0x20(%rdi), %r14
leaq 0x20(%r12), %rax
movups -0x20(%rax), %xmm0
movups %xmm0, -0x20(%r14)
movq %r14, -0x10(%r14)
movq -0x10(%rax), %rcx
cmpq %rcx, %rax
je 0x7f955
movq %rcx, -0x10(%r14)
movq (%rax), %rcx
movq %rcx, (%r14)
jmp 0x7f95c
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%r14)
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%r14)
movups 0x10(%rax), %xmm0
movups %xmm0, 0x10(%r14)
addq $0x48, %r14
leaq 0x48(%rax), %rcx
addq $0x28, %rax
cmpq %r13, %rax
movq %rcx, %rax
jne 0x7f933
addq $-0x20, %r14
cmpq %r13, %rbx
je 0x7fa27
xorl %eax, %eax
leaq (%rax,%r13), %rcx
addq $0x20, %rcx
movups -0x20(%rcx), %xmm0
leaq 0x68(%r14,%rax), %rdx
movups %xmm0, -0x20(%rdx)
movq %rdx, -0x10(%rdx)
movq -0x10(%rcx), %rsi
cmpq %rsi, %rcx
je 0x7f9d8
movq %rsi, 0x58(%r14,%rax)
movq (%rcx), %rdx
movq %rdx, 0x68(%r14,%rax)
jmp 0x7f9de
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
leaq (%rax,%r13), %rdx
addq $0x48, %rdx
movq -0x30(%rdx), %rsi
movq %rsi, 0x60(%r14,%rax)
movq %rcx, -0x38(%rdx)
movq $0x0, -0x30(%rdx)
movb $0x0, -0x28(%rdx)
movq -0x8(%rdx), %rcx
movq %rcx, 0x88(%r14,%rax)
movups -0x18(%rdx), %xmm0
movups %xmm0, 0x78(%r14,%rax)
addq $0x48, %rax
cmpq %rbx, %rdx
jne 0x7f9a7
addq %rax, %r14
addq $0x48, %r14
jmp 0x7fa2b
addq $0x48, %r14
testq %r12, %r12
movq (%rsp), %rbx
je 0x7fa49
movq 0x10(%r15), %rsi
subq %r12, %rsi
movq %rdi, %r13
movq %r12, %rdi
callq 0x17610
movq %r13, %rdi
movq %rdi, (%r15)
movq %r14, 0x8(%r15)
leaq (%rbx,%rbx,8), %rax
leaq (%rdi,%rax,8), %rax
movq %rax, 0x10(%r15)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x17210
movq %rbp, %rbx
testq %rbp, %rbp
jne 0x7fa98
movq 0x10(%r14), %rdi
addq $0x20, %r14
cmpq %r14, %rdi
je 0x7fa93
movq (%r14), %rsi
incq %rsi
callq 0x17610
testq %rbx, %rbx
je 0x7faac
movq (%rsp), %rax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rsi
movq %rbx, %rdi
callq 0x17610
callq 0x17920
movq %rax, %rbx
callq 0x17a40
movq %rbx, %rdi
callq 0x17b40
movq %rax, %rdi
callq 0x1e8bf
nopl (%rax)
|
/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
|
0x8058a
|
std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::~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 0x805ac
movq %r14, %rdi
callq 0x805cc
addq $0x8, %r14
jmp 0x80599
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x805c5
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
|
0x805ee
|
std::vector<std::__exception_ptr::exception_ptr, std::allocator<std::__exception_ptr::exception_ptr>>::~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 0x80616
cmpq $0x0, (%r14)
je 0x80610
movq %r14, %rdi
callq 0x17520
addq $0x8, %r14
jmp 0x805fd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8062f
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x17610
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
|
/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
|
0x8083e
|
Catch::Detail::EnumInfo::lookup(int) const
|
explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { }
|
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdi
leaq 0x1fb93(%rip), %rax # 0xa03e0
movl $0x1d, %edx
cmpq %rdi, %rcx
je 0x8086e
cmpl %esi, (%rcx)
jne 0x80863
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %r9
je 0x8086f
addq $0x18, %rcx
cmpq %rdi, %rcx
jne 0x80857
retq
movq %r9, %rdx
movq %r8, %rax
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
|
0x80aaa
|
std::pair<int, Catch::StringRef>& std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::emplace_back<int&, Catch::StringRef const&>(int&, Catch::StringRef 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 0x80ad0
movl (%rdx), %eax
movl %eax, (%rsi)
movups (%rcx), %xmm0
movups %xmm0, 0x8(%rsi)
addq $0x18, 0x8(%rbx)
jmp 0x80ad8
movq %rbx, %rdi
callq 0x80b42
movq 0x8(%rbx), %rax
addq $-0x18, %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
|
0x80b1c
|
_gnu_cxx::new_allocator<std::pair<int, Catch::StringRef>>::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 0x80b38
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rdi
jmp 0x175e0
pushq %rax
movq %rsi, %rdi
callq 0x18aac
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
|
0x80b42
|
void std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::_M_realloc_insert<int&, Catch::StringRef const&>(__gnu_cxx::__normal_iterator<std::pair<int, Catch::StringRef>*, std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>>, int&, Catch::StringRef 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 0x18997(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x80c60
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 0x80bab
movq %rbx, %rdi
xorl %edx, %edx
callq 0x80b1c
movq %rax, %r13
jmp 0x80bae
xorl %r13d, %r13d
leaq (%r14,%r14,2), %rax
movq (%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%r13,%rax,8)
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, 0x8(%r13,%rax,8)
movq %r13, %r14
cmpq %r12, %r15
je 0x80bf5
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 0x80bd9
addq $0x18, %r14
cmpq %r12, %rbp
je 0x80c1d
movq 0x10(%r12), %rax
movq %rax, 0x10(%r14)
movups (%r12), %xmm0
movups %xmm0, (%r14)
addq $0x18, %r12
addq $0x18, %r14
cmpq %rbp, %r12
jne 0x80bfe
testq %r15, %r15
je 0x80c31
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
|
0x80c60
|
std::vector<std::pair<int, Catch::StringRef>, std::allocator<std::pair<int, Catch::StringRef>>>::_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 0x80ca8
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
|
0x80cb2
|
Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>& std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::emplace_back<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>(Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>&&)
|
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 0x80cda
movq (%rdx), %rax
movq %rax, (%rsi)
movq $0x0, (%rdx)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x80ce2
movq %rbx, %rdi
callq 0x80cec
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
|
0x80cec
|
void std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::_M_realloc_insert<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>(__gnu_cxx::__normal_iterator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>*, std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>>, Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>&&)
|
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 0x187f3(%rip), %rdx # 0x994fd
movl $0x1, %esi
callq 0x80dfc
movq (%rbx), %rcx
movq 0x8(%rbx), %r14
movq %r12, %r13
subq %rcx, %r13
sarq $0x3, %r13
testq %rax, %rax
movq %rax, 0x10(%rsp)
je 0x80d47
movq %rcx, %r15
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x80e40
movq %r15, %rcx
movq %rax, %r15
jmp 0x80d4a
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 0x80d94
movq %r15, %r13
movq 0x8(%rsp), %rbp
movq (%rbp), %rax
movq %rax, (%r13)
movq $0x0, (%rbp)
movq %rbp, %rdi
callq 0x805cc
addq $0x8, %rbp
addq $0x8, %r13
cmpq %r12, %rbp
jne 0x80d6f
addq $0x8, %r13
cmpq %r12, %r14
je 0x80dc2
movq (%r12), %rax
movq %rax, (%r13)
movq $0x0, (%r12)
movq %r12, %rdi
callq 0x805cc
addq $0x8, %r12
addq $0x8, %r13
cmpq %r14, %r12
jne 0x80d9d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x80dd8
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
|
0x80dfc
|
std::vector<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>, std::allocator<Catch::Detail::unique_ptr<Catch::Detail::EnumInfo>>>::_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 0x80e36
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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.