idx int64 0 2.11M | name stringlengths 1 118k | code stringlengths 6 516k | asm stringlengths 21 4.64M | file stringlengths 39 143 | opt stringclasses 1 value | path stringlengths 20 133 |
|---|---|---|---|---|---|---|
11,900 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>& std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::emplace_back<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | vector<_Tp, _Alloc>::
emplace_back(_Args&&... __args)
{
if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
{
_GLIBCXX_ASAN_ANNOTATE_GROW(1);
_Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
std::forward<_Args>(__args)...);
++this->_M_impl._M_finish;
_GLIBCXX_ASAN_ANNOTATE_GREW(1);
}
else
_M_realloc_insert(end(), std::forward<_Args>(__args)...);
#if __cplusplus > 201402L
return back();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0x5c695
movq -0x20(%rbp), %rdi
movq 0x8(%rdi), %rsi
movq -0x10(%rbp), %rdx
callq 0x5c6d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
jmp 0x5c6b3
movq -0x20(%rbp), %rdi
callq 0x5c880
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
callq 0x5c700
movq -0x20(%rbp), %rdi
callq 0x5c8b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
11,901 | void std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::construct<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | static _GLIBCXX20_CONSTEXPR void
construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
_Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{
#if __cplusplus <= 201703L
__a.construct(__p, std::forward<_Args>(__args)...);
#else
std::construct_at(__p, std::forward<_Args>(__args)...);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5c8f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,902 | void std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_M_realloc_insert<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | void
vector<_Tp, _Alloc>::
_M_realloc_insert(iterator __position, const _Tp& __x)
#endif
{
const size_type __len =
_M_check_len(size_type(1), "vector::_M_realloc_insert");
pointer __old_start = this->_M_impl._M_start;
pointer __old_finish = this->_M_impl._M_finish;
const size_type __elems_before = __position - begin();
pointer __new_start(this->_M_allocate(__len));
pointer __new_finish(__new_start);
__try
{
// The order of the three operations is dictated by the C++11
// case, where the moves could alter a new element belonging
// to the existing vector. This is an issue only for callers
// taking the element by lvalue ref (see last bullet of C++11
// [res.on.arguments]).
_Alloc_traits::construct(this->_M_impl,
__new_start + __elems_before,
#if __cplusplus >= 201103L
std::forward<_Args>(__args)...);
#else
__x);
#endif
__new_finish = pointer();
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (_S_use_relocate())
{
__new_finish = _S_relocate(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish = _S_relocate(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
else
#endif
{
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__old_start, __position.base(),
__new_start, _M_get_Tp_allocator());
++__new_finish;
__new_finish
= std::__uninitialized_move_if_noexcept_a
(__position.base(), __old_finish,
__new_finish, _M_get_Tp_allocator());
}
}
__catch(...)
{
if (!__new_finish)
_Alloc_traits::destroy(this->_M_impl,
__new_start + __elems_before);
else
std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
_M_deallocate(__new_start, __len);
__throw_exception_again;
}
#if __cplusplus >= 201103L
if _GLIBCXX17_CONSTEXPR (!_S_use_relocate())
#endif
std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
_GLIBCXX_ASAN_ANNOTATE_REINIT;
_M_deallocate(__old_start,
this->_M_impl._M_end_of_storage - __old_start);
this->_M_impl._M_start = __new_start;
this->_M_impl._M_finish = __new_finish;
this->_M_impl._M_end_of_storage = __new_start + __len;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x1, %esi
leaq 0xd4a6(%rip), %rdx # 0x69bd1
callq 0x5c960
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0x5ca90
movq %rax, -0x40(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5ca40
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x5bc00
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rsi
imulq $0x28, -0x38(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x5c6d0
movq $0x0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5cb00
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x5ba60
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
callq 0x5cac0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x50(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x5cb00
movq -0x58(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x5ba60
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
callq 0x5cac0
movq -0x58(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq 0x10(%rdi), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movq %rax, %rdx
callq 0x5bfd0
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
imulq $0x28, -0x20(%rbp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/vector.tcc |
11,903 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::end() | iterator
end() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x5cbc0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,904 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::back() | reference
back() _GLIBCXX_NOEXCEPT
{
__glibcxx_requires_nonempty();
return *(end() - 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5c880
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5cd80
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5cdc0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,905 | void __gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::construct<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | void
construct(_Up* __p, _Args&&... __args)
noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5c920
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,906 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pair(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | constexpr pair(pair&&) = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x15140
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_pair.h |
11,907 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, 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;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5cb10
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x375c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jae 0x5c9a7
movq -0x18(%rbp), %rdi
callq 0x15120
movq -0x38(%rbp), %rdi
callq 0x375c0
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x375c0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x5c2d0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x375c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jb 0x5ca16
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x5cb10
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5ca25
movq -0x38(%rbp), %rdi
callq 0x5cb10
movq %rax, -0x58(%rbp)
jmp 0x5ca2d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,908 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::begin() | iterator
begin() _GLIBCXX_NOEXCEPT
{ return iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x5cbc0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,909 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_S_relocate(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | static pointer
_S_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc) noexcept
{
using __do_it = __bool_constant<_S_use_relocate()>;
return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5cbe0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,910 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::max_size() const | size_type
max_size() const _GLIBCXX_NOEXCEPT
{ return _S_max_size(_M_get_Tp_allocator()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5b930
movq %rax, %rdi
callq 0x5cb40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,911 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_S_max_size(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static size_type
_S_max_size(const _Tp_alloc_type& __a) _GLIBCXX_NOEXCEPT
{
// std::distance(begin(), end()) cannot be greater than PTRDIFF_MAX,
// and realistically we can't store more than PTRDIFF_MAX/sizeof(T)
// (even if std::allocator_traits::max_size says we can).
const size_t __diffmax
= __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
const size_t __allocmax = _Alloc_traits::max_size(__a);
return (std::min)(__diffmax, __allocmax);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x333333333333333, %rax # imm = 0x333333333333333
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cb80
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x55160
movq (%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,912 | std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::max_size(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | static _GLIBCXX20_CONSTEXPR size_type
max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
{
#if __cplusplus <= 201703L
return __a.max_size();
#else
return size_t(-1) / sizeof(value_type);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cba0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,913 | _gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::max_size() const | size_type
max_size() const _GLIBCXX_USE_NOEXCEPT
{ return _M_max_size(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5bce0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,914 | _gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::__normal_iterator(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,915 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_S_do_relocate(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::integral_constant<bool, true>) | static pointer
_S_do_relocate(pointer __first, pointer __last, pointer __result,
_Tp_alloc_type& __alloc, true_type) noexcept
{
return std::__relocate_a(__first, __last, __result, __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5cc20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,916 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* std::__relocate_a<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | inline _ForwardIterator
__relocate_a(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc)))
{
return __relocate_a_1(std::__niter_base(__first),
std::__niter_base(__last),
std::__niter_base(__result), __alloc);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5cce0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cce0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5cce0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x5cc80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,917 | std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* std::__relocate_a_1<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | inline _ForwardIterator
__relocate_a_1(_InputIterator __first, _InputIterator __last,
_ForwardIterator __result, _Allocator& __alloc)
noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
std::addressof(*__first),
__alloc)))
{
typedef typename iterator_traits<_InputIterator>::value_type
_ValueType;
typedef typename iterator_traits<_ForwardIterator>::value_type
_ValueType2;
static_assert(std::is_same<_ValueType, _ValueType2>::value,
"relocation is only possible for values of the same type");
_ForwardIterator __cur = __result;
for (; __first != __last; ++__first, (void)++__cur)
std::__relocate_object_a(std::__addressof(*__cur),
std::__addressof(*__first), __alloc);
return __cur;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5ccd5
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5ccf0
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
jmp 0x5cca0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,918 | void std::__relocate_object_a<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | inline void
__relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
_Allocator& __alloc)
noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
__dest, std::move(*__orig)))
&& noexcept(std::allocator_traits<_Allocator>::destroy(
__alloc, std::__addressof(*__orig))))
{
typedef std::allocator_traits<_Allocator> __traits;
__traits::construct(__alloc, __dest, std::move(*__orig));
__traits::destroy(__alloc, std::__addressof(*__orig));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5c6d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5cd30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_uninitialized.h |
11,919 | void std::allocator_traits<std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5cd60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,920 | void __gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b350
addq $0x10, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,921 | _gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::operator-(long) const | _GLIBCXX20_CONSTEXPR
const _Iterator&
base() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq -0x18(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5cbc0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,922 | _gnu_cxx::__normal_iterator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,923 | UnitTest::DeferredTestResult::DeferredTestResult() | DeferredTestResult::DeferredTestResult()
: suiteName("")
, testName("")
, failureFile("")
, timeElapsed(0.0f)
, failed(false)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x15430
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xd044(%rip), %rsi # 0x69e58
callq 0x36c80
jmp 0x5ce1b
leaq -0x9(%rbp), %rdi
callq 0x152a0
movq -0x38(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x15430
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0xd00c(%rip), %rsi # 0x69e58
callq 0x36c80
jmp 0x5ce53
leaq -0x1d(%rbp), %rdi
callq 0x152a0
movq -0x38(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x15430
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xcfd4(%rip), %rsi # 0x69e58
callq 0x36c80
jmp 0x5ce8b
leaq -0x1e(%rbp), %rdi
callq 0x152a0
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x5d0c0
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x78(%rax)
movb $0x0, 0x7c(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x152a0
jmp 0x5cf0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x152a0
jmp 0x5cf03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x152a0
movq -0x48(%rbp), %rdi
callq 0x15150
movq -0x30(%rbp), %rdi
callq 0x15150
movq -0x18(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
11,924 | UnitTest::DeferredTestResult::DeferredTestResult(char const*, char const*) | DeferredTestResult::DeferredTestResult(char const* suite, char const* test)
: suiteName(suite)
, testName(test)
, failureFile("")
, timeElapsed(0.0f)
, failed(false)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x15430
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x36c80
jmp 0x5cf6b
leaq -0x19(%rbp), %rdi
callq 0x152a0
movq -0x50(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x15430
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x36c80
jmp 0x5cfa8
leaq -0x2d(%rbp), %rdi
callq 0x152a0
movq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
leaq -0x2e(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x15430
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xce7f(%rip), %rsi # 0x69e58
callq 0x36c80
jmp 0x5cfe0
leaq -0x2e(%rbp), %rdi
callq 0x152a0
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
callq 0x5d0c0
movq -0x50(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x78(%rax)
movb $0x0, 0x7c(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x152a0
jmp 0x5d064
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x152a0
jmp 0x5d05b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2e(%rbp), %rdi
callq 0x152a0
movq -0x68(%rbp), %rdi
callq 0x15150
movq -0x48(%rbp), %rdi
callq 0x15150
movq -0x28(%rbp), %rdi
callq 0x15420
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
11,925 | UnitTest::DeferredTestResult::~DeferredTestResult() | DeferredTestResult::~DeferredTestResult()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x60, %rdi
callq 0x5d0e0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x15150
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x15150
movq -0x10(%rbp), %rdi
callq 0x15150
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
11,926 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::vector() | vector() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,927 | std::vector<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0x5ba60
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq %rax, %rdx
callq 0x5d1c0
jmp 0x5d11a
movq -0x20(%rbp), %rdi
callq 0x5ba70
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,928 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_base() | _Vector_base() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,929 | std::_Vector_base<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::_Vector_impl::_Vector_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Tp_alloc_type>::value)
: _Tp_alloc_type()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5d190
movq -0x10(%rbp), %rdi
callq 0x5bbd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,930 | std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5d1b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
11,931 | _gnu_cxx::new_allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
11,932 | void std::_Destroy<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, std::allocator<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&) | inline void
_Destroy(_ForwardIterator __first, _ForwardIterator __last,
allocator<_Tp>&)
{
_Destroy(__first, __last);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bed0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
11,933 | UnitTest::MemoryOutStream::GetText() const | char const* MemoryOutStream::GetText() const
{
m_text = this->str();
return m_text.c_str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x15280
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
leaq -0x28(%rbp), %rsi
callq 0x152e0
leaq -0x28(%rbp), %rdi
callq 0x15150
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x150e0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/MemoryOutStream.cpp |
11,934 | UnitTest::ReportAssert(char const*, char const*, int) | void ReportAssert(char const* description, char const* filename, int lineNumber)
{
throw AssertException(description, filename, lineNumber);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x310, %edi # imm = 0x310
callq 0x15110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x5ace0
jmp 0x5d279
movq -0x30(%rbp), %rdi
leaq 0x2897c(%rip), %rsi # 0x85c00
leaq -0x253b(%rip), %rdx # 0x5ad50
callq 0x15400
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x151b0
movq -0x20(%rbp), %rdi
callq 0x15420
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/ReportAssert.cpp |
11,935 | UnitTest::Test::GetTestList() | TestList& Test::GetTestList()
{
static TestList s_list;
return s_list;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x2be39(%rip) # 0x890f8
jne 0x5d2ec
leaq 0x2be30(%rip), %rdi # 0x890f8
callq 0x15470
cmpl $0x0, %eax
je 0x5d2ec
leaq 0x2be0f(%rip), %rdi # 0x890e8
callq 0x5d800
jmp 0x5d2e0
leaq 0x2be11(%rip), %rdi # 0x890f8
callq 0x15170
leaq 0x2bdf5(%rip), %rax # 0x890e8
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x2bdec(%rip), %rdi # 0x890f8
callq 0x15160
movq -0x8(%rbp), %rdi
callq 0x15420
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,936 | UnitTest::Test::Test(char const*, char const*, char const*, int) | Test::Test(char const* testName, char const* suiteName, char const* filename, int lineNumber)
: m_details(testName, suiteName, filename, lineNumber)
, next(0)
, m_timeConstraintExempt(false)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x28925(%rip), %rax # 0x85c70
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0x5d780
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movb $0x0, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,937 | UnitTest::Test::~Test() | Test::~Test()
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,938 | UnitTest::Test::~Test() | Test::~Test()
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5d390
movq -0x10(%rbp), %rdi
movl $0x38, %esi
callq 0x15270
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,939 | UnitTest::Test::Run() | void Test::Run()
{
ExecuteTest(*this, m_details);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x5d410
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,940 | UnitTest::Test::RunImpl() const | void Test::RunImpl() const
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Test.cpp |
11,941 | void UnitTest::ExecuteTest<UnitTest::Test>(UnitTest::Test&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.Filename(), e.LineNumber()), e.what());
}
catch (std::exception const& e)
{
MemoryOutStream stream;
stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}
catch (...)
{
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: Crash!");
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6c0, %rsp # imm = 0x6C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x650(%rbp)
callq 0x5b070
movq -0x650(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x470(%rbp), %rdi
callq 0x5ed70
jmp 0x5d44b
leaq 0x2bcb6(%rip), %rax # 0x89108
movq (%rax), %rdi
movl $0x1, %esi
callq 0x15390
cmpl $0x0, %eax
je 0x5d6d5
movl $0x8, %edi
callq 0x15110
movq %rax, %rdi
leaq 0x68e1(%rip), %rax # 0x63d5d
movq %rax, (%rdi)
movq 0x28b3a(%rip), %rsi # 0x85fc0
xorl %eax, %eax
movl %eax, %edx
callq 0x15400
jmp 0x5d77a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x5d4c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x5ee90
movl -0x47c(%rbp), %eax
movl %eax, -0x654(%rbp)
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x5d5b3
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x628(%rbp)
callq 0x5b060
movq %rax, -0x660(%rbp)
jmp 0x5d500
movq -0x660(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x678(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x670(%rbp)
movq -0x628(%rbp), %rdi
callq 0x5adc0
movq %rax, -0x668(%rbp)
jmp 0x5d53f
movq -0x628(%rbp), %rdi
callq 0x5ade0
movl %eax, -0x684(%rbp)
jmp 0x5d553
movl -0x684(%rbp), %r8d
movq -0x668(%rbp), %rcx
movq -0x678(%rbp), %rdx
movq -0x670(%rbp), %rsi
leaq -0x648(%rbp), %rdi
callq 0x5d780
jmp 0x5d57d
movq -0x628(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x680(%rbp), %rdi
movq %rax, %rdx
leaq -0x648(%rbp), %rsi
callq 0x5d9a0
jmp 0x5d5a5
callq 0x153e0
addq $0x6c0, %rsp # imm = 0x6C0
popq %rbp
retq
movl -0x654(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x5d695
movq -0x478(%rbp), %rdi
callq 0x150d0
movq %rax, -0x488(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1ab50
jmp 0x5d5e7
leaq 0x6705(%rip), %rsi # 0x63cf3
leaq -0x620(%rbp), %rdi
callq 0x15250
movq %rax, -0x690(%rbp)
jmp 0x5d603
movq -0x488(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x690(%rbp), %rdi
movq %rax, %rsi
callq 0x15250
jmp 0x5d624
callq 0x5b060
movq %rax, -0x698(%rbp)
jmp 0x5d632
movq -0x698(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x6b0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x6a8(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x6a0(%rbp)
jmp 0x5d663
movq -0x6a0(%rbp), %rdx
movq -0x6a8(%rbp), %rsi
movq -0x6b0(%rbp), %rdi
callq 0x5d9a0
jmp 0x5d67f
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5d5aa
movq -0x478(%rbp), %rdi
callq 0x150d0
callq 0x5b060
movq %rax, -0x6b8(%rbp)
jmp 0x5d6af
movq -0x6b8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq 0x66b4(%rip), %rdx # 0x63d78
callq 0x5d9a0
jmp 0x5d6cb
callq 0x153e0
jmp 0x5d5aa
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x5d6e4
leaq -0x470(%rbp), %rdi
callq 0x5ee90
jmp 0x5d5aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x5d70e
jmp 0x5d766
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
jmp 0x5d742
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
leaq -0x620(%rbp), %rdi
callq 0x1abe0
callq 0x153e0
jmp 0x5d749
jmp 0x5d766
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x478(%rbp)
movl %eax, -0x47c(%rbp)
callq 0x153e0
jmp 0x5d764
jmp 0x5d766
movq -0x478(%rbp), %rdi
callq 0x15420
movq %rax, %rdi
callq 0x1aa00
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/ExecuteTest.h |
11,942 | UnitTest::TestDetails::TestDetails(char const*, char const*, char const*, int) | TestDetails::TestDetails(char const* testName_, char const* suiteName_, char const* filename_, int lineNumber_)
: suiteName(suiteName_)
, testName(testName_)
, filename(filename_)
, lineNumber(lineNumber_)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestDetails.cpp |
11,943 | UnitTest::TestDetails::TestDetails(UnitTest::TestDetails const&, int) | TestDetails::TestDetails(const TestDetails& details, int lineNumber_)
: suiteName(details.suiteName)
, testName(details.testName)
, filename(details.filename)
, lineNumber(lineNumber_)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestDetails.cpp |
11,944 | UnitTest::TestList::TestList() | TestList::TestList()
: m_head(0)
, m_tail(0)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestList.cpp |
11,945 | UnitTest::TestList::Add(UnitTest::Test*) | void TestList::Add(Test* test)
{
if (m_tail == 0)
{
assert(m_head == 0);
m_head = test;
m_tail = test;
}
else
{
m_tail->next = test;
m_tail = test;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x5d87f
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5d84b
jmp 0x5d86a
leaq 0xc3aa(%rip), %rdi # 0x69bfc
leaq 0xc3af(%rip), %rsi # 0x69c08
movl $0x12, %edx
leaq 0xc409(%rip), %rcx # 0x69c6e
callq 0x15180
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5d897
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x28(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestList.cpp |
11,946 | UnitTest::TestList::GetHead() const | Test* TestList::GetHead() const
{
return m_head;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestList.cpp |
11,947 | UnitTest::ListAdder::ListAdder(UnitTest::TestList&, UnitTest::Test*) | ListAdder::ListAdder(TestList& list, Test* test)
{
list.Add(test);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestList.cpp |
11,948 | UnitTest::TestReporter::~TestReporter() | TestReporter::~TestReporter()
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporter.cpp |
11,949 | UnitTest::TestReporter::~TestReporter() | TestReporter::~TestReporter()
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
ud2
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporter.cpp |
11,950 | UnitTest::TestResults::TestResults(UnitTest::TestReporter*) | TestResults::TestResults(TestReporter* testReporter)
: m_testReporter(testReporter)
, m_totalTestCount(0)
, m_failedTestCount(0)
, m_failureCount(0)
, m_currentTestFailed(false)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movb $0x0, 0x14(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,951 | UnitTest::TestResults::OnTestStart(UnitTest::TestDetails const&) | void TestResults::OnTestStart(TestDetails const& test)
{
++m_totalTestCount;
m_currentTestFailed = false;
if (m_testReporter)
m_testReporter->ReportTestStart(test);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x0, 0x14(%rax)
cmpq $0x0, (%rax)
je 0x5d98c
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,952 | UnitTest::TestResults::OnTestFailure(UnitTest::TestDetails const&, char const*) | void TestResults::OnTestFailure(TestDetails const& test, char const* failure)
{
++m_failureCount;
if (!m_currentTestFailed)
{
++m_failedTestCount;
m_currentTestFailed = true;
}
if (m_testReporter)
m_testReporter->ReportFailure(test, failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
testb $0x1, 0x14(%rax)
jne 0x5d9dc
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movb $0x1, 0x14(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5d9fb
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,953 | UnitTest::TestResults::OnTestFinish(UnitTest::TestDetails const&, float) | void TestResults::OnTestFinish(TestDetails const& test, float secondsElapsed)
{
if (m_testReporter)
m_testReporter->ReportTestFinish(test, secondsElapsed);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x5da49
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movss -0x14(%rbp), %xmm0
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,954 | UnitTest::TestResults::GetTotalTestCount() const | int TestResults::GetTotalTestCount() const
{
return m_totalTestCount;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,955 | UnitTest::TestResults::GetFailedTestCount() const | int TestResults::GetFailedTestCount() const
{
return m_failedTestCount;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,956 | UnitTest::TestResults::GetFailureCount() const | int TestResults::GetFailureCount() const
{
return m_failureCount;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestResults.cpp |
11,957 | UnitTest::RunAllTests() | int RunAllTests()
{
TestReporterStdout reporter;
TestRunner runner(reporter);
return runner.RunTestsIf(Test::GetTestList(), NULL, True(), 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5df60
movq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5db50
jmp 0x5dad4
callq 0x5d2b0
movq %rax, -0x40(%rbp)
jmp 0x5dadf
movq -0x40(%rbp), %rsi
xorl %r8d, %r8d
movl %r8d, %edx
leaq -0x20(%rbp), %rdi
leaq -0x2d(%rbp), %rcx
callq 0x501f0
movl %eax, -0x44(%rbp)
jmp 0x5dafb
leaq -0x20(%rbp), %rdi
callq 0x5dc30
leaq -0x8(%rbp), %rdi
callq 0x5dfa0
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x5db39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5dc30
leaq -0x8(%rbp), %rdi
callq 0x5dfa0
movq -0x28(%rbp), %rdi
callq 0x15420
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,958 | UnitTest::TestRunner::TestRunner(UnitTest::TestReporter&) | TestRunner::TestRunner(TestReporter& reporter)
: m_reporter(&reporter)
, m_result(new TestResults(&reporter))
, m_timer(new Timer)
{
m_timer->Start();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movl $0x18, %edi
callq 0x15260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5d910
jmp 0x5db96
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, (%rcx)
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movl $0x10, %edi
callq 0x15260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x5ef40
jmp 0x5dbc8
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rdi
callq 0x5ef60
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x15270
jmp 0x5dc1c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x15270
movq -0x18(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,959 | UnitTest::TestRunner::~TestRunner() | TestRunner::~TestRunner()
{
delete m_result;
delete m_timer;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5dc60
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x15270
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5dc80
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x15270
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,960 | UnitTest::TestRunner::Finish() const | int TestRunner::Finish() const
{
float const secondsElapsed = static_cast<float>(m_timer->GetTimeInMs() / 1000.0);
m_reporter->ReportSummary(m_result->GetTotalTestCount(),
m_result->GetFailedTestCount(),
m_result->GetFailureCount(),
secondsElapsed);
return m_result->GetFailureCount();
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
callq 0x5ef80
movq -0x18(%rbp), %rax
movsd 0xbff7(%rip), %xmm1 # 0x69cb0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rdi
callq 0x5da50
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x5da70
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
callq 0x5da90
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl %eax, %ecx
movss -0xc(%rbp), %xmm0
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5da90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,961 | UnitTest::TestRunner::IsTestInSuite(UnitTest::Test const*, char const*) const | bool TestRunner::IsTestInSuite(const Test* const curTest, char const* suiteName) const
{
using namespace std;
return (suiteName == NULL) || !strcmp(curTest->m_details.suiteName, suiteName);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x5dd6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x15370
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,962 | UnitTest::TestRunner::RunTest(UnitTest::TestResults*, UnitTest::Test*, int) const | void TestRunner::RunTest(TestResults* const result, Test* const curTest, int const maxTestTimeInMs) const
{
CurrentTest::Results() = result;
Timer testTimer;
testTimer.Start();
result->OnTestStart(curTest->m_details);
curTest->Run();
double const testTimeInMs = testTimer.GetTimeInMs();
if (maxTestTimeInMs > 0 && testTimeInMs > maxTestTimeInMs && !curTest->m_timeConstraintExempt)
{
MemoryOutStream stream;
stream << "Global time constraint failed. Expected under " << maxTestTimeInMs <<
"ms but took " << testTimeInMs << "ms.";
result->OnTestFailure(curTest->m_details, stream.GetText());
}
result->OnTestFinish(curTest->m_details, static_cast<float>(testTimeInMs/1000.0));
} | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
callq 0x5b060
movq -0x1e8(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x5ef40
leaq -0x30(%rbp), %rdi
callq 0x5ef60
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x5d950
movq -0x18(%rbp), %rdi
callq 0x5d3d0
leaq -0x30(%rbp), %rdi
callq 0x5ef80
movsd %xmm0, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x5df25
movsd -0x38(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5df25
movq -0x18(%rbp), %rax
testb $0x1, 0x30(%rax)
jne 0x5df25
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x1ab50
movq -0x1f8(%rbp), %rdi
leaq 0xbe7d(%rip), %rsi # 0x69cb8
callq 0x15250
movq %rax, -0x1f0(%rbp)
jmp 0x5de49
movq -0x1f0(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15410
movq %rax, -0x200(%rbp)
jmp 0x5de61
movq -0x200(%rbp), %rdi
leaq 0xbe78(%rip), %rsi # 0x69ce7
callq 0x15250
movq %rax, -0x208(%rbp)
jmp 0x5de7d
movq -0x208(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x154a0
movq %rax, -0x210(%rbp)
jmp 0x5de97
movq -0x210(%rbp), %rdi
leaq 0xbe4f(%rip), %rsi # 0x69cf4
callq 0x15250
jmp 0x5deac
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x220(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x218(%rbp)
jmp 0x5dedb
movq -0x218(%rbp), %rdx
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rdi
callq 0x5d9a0
jmp 0x5def7
leaq -0x1d0(%rbp), %rdi
callq 0x1abe0
jmp 0x5df25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x1abe0
jmp 0x5df54
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movsd -0x38(%rbp), %xmm0
movsd 0xbd72(%rip), %xmm1 # 0x69cb0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x5da10
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
movq -0x1d8(%rbp), %rdi
callq 0x15420
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestRunner.cpp |
11,963 | UnitTest::TimeConstraint::TimeConstraint(int, UnitTest::TestDetails const&) | TimeConstraint::TimeConstraint(int ms, TestDetails const& details)
: m_details(details)
, m_maxMs(ms)
{
m_timer.Start();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5ef40
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x10(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x18(%rdi)
callq 0x5ef60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TimeConstraint.cpp |
11,964 | UnitTest::TimeConstraint::~TimeConstraint() | TimeConstraint::~TimeConstraint()
{
double const totalTimeInMs = m_timer.GetTimeInMs();
if (totalTimeInMs > m_maxMs)
{
MemoryOutStream stream;
stream << "Time constraint failed. Expected to run test under " << m_maxMs <<
"ms but took " << totalTimeInMs << "ms.";
UnitTest::CurrentTest::Results()->OnTestFailure(m_details, stream.GetText());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x5ef80
movsd %xmm0, -0x1b0(%rbp)
jmp 0x5e029
movq -0x1b8(%rbp), %rax
movsd -0x1b0(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsi2sdl 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5e153
leaq -0x1a8(%rbp), %rdi
callq 0x1ab50
jmp 0x5e05f
leaq 0xbc92(%rip), %rsi # 0x69cf8
leaq -0x1a8(%rbp), %rdi
callq 0x15250
movq %rax, -0x1c0(%rbp)
jmp 0x5e07b
movq -0x1c0(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x15410
movq %rax, -0x1c8(%rbp)
jmp 0x5e09a
movq -0x1c8(%rbp), %rdi
leaq 0xbc3f(%rip), %rsi # 0x69ce7
callq 0x15250
movq %rax, -0x1d0(%rbp)
jmp 0x5e0b6
movq -0x1d0(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x154a0
movq %rax, -0x1d8(%rbp)
jmp 0x5e0d0
movq -0x1d8(%rbp), %rdi
leaq 0xbc16(%rip), %rsi # 0x69cf4
callq 0x15250
jmp 0x5e0e5
callq 0x5b060
movq %rax, -0x1e0(%rbp)
jmp 0x5e0f3
movq -0x1b8(%rbp), %rax
movq -0x1e0(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x1f8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x5d1f0
movq %rax, -0x1e8(%rbp)
jmp 0x5e12b
movq -0x1e8(%rbp), %rdx
movq -0x1f0(%rbp), %rsi
movq -0x1f8(%rbp), %rdi
callq 0x5d9a0
jmp 0x5e147
leaq -0x1a8(%rbp), %rdi
callq 0x1abe0
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
movq %rax, %rdi
callq 0x1aa00
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TimeConstraint.cpp |
11,965 | UnitTest::XmlTestReporter::XmlTestReporter(std::ostream&) | XmlTestReporter::XmlTestReporter(ostream& ostream)
: m_ostream(ostream)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x36d30
movq -0x18(%rbp), %rax
leaq 0x27b60(%rip), %rcx # 0x85cf8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,966 | UnitTest::XmlTestReporter::ReportSummary(int, int, int, float) | void XmlTestReporter::ReportSummary(int totalTestCount, int failedTestCount,
int failureCount, float secondsElapsed)
{
AddXmlElement(m_ostream, NULL);
BeginResults(m_ostream, totalTestCount, failedTestCount, failureCount, secondsElapsed);
DeferredTestResultList const& results = GetResults();
for (DeferredTestResultList::const_iterator i = results.begin(); i != results.end(); ++i)
{
BeginTest(m_ostream, *i);
if (i->failed)
AddFailure(m_ostream, *i);
EndTest(m_ostream, *i);
}
EndResults(m_ostream);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x20(%rdi), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5e2e0
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
movss -0x18(%rbp), %xmm0
callq 0x5e350
movq -0x38(%rbp), %rdi
callq 0x5b210
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5ebf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5ec60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5ec20
testb $0x1, %al
jne 0x5e238
jmp 0x5e2c4
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ec90
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x5e440
leaq -0x28(%rbp), %rdi
callq 0x5ecb0
testb $0x1, 0x7c(%rax)
je 0x5e291
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ec90
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x5e500
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ec90
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x5e6a0
leaq -0x28(%rbp), %rdi
callq 0x5ecd0
jmp 0x5e215
movq -0x38(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x5e6f0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,967 | UnitTest::XmlTestReporter::AddXmlElement(std::ostream&, char const*) | void XmlTestReporter::AddXmlElement(ostream& os, char const* encoding)
{
os << "<?xml version=\"1.0\"";
if (encoding != NULL)
os << " encoding=\"" << encoding << "\"";
os << "?>";
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xba2d(%rip), %rsi # 0x69d2c
callq 0x15250
cmpq $0x0, -0x18(%rbp)
je 0x5e336
movq -0x10(%rbp), %rdi
leaq 0xba2a(%rip), %rsi # 0x69d40
callq 0x15250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x15250
movq %rax, %rdi
leaq 0xba0d(%rip), %rsi # 0x69d3e
callq 0x15250
movq -0x10(%rbp), %rdi
leaq 0xba0b(%rip), %rsi # 0x69d4c
callq 0x15250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,968 | UnitTest::XmlTestReporter::BeginResults(std::ostream&, int, int, int, float) | void XmlTestReporter::BeginResults(std::ostream& os, int totalTestCount, int failedTestCount,
int failureCount, float secondsElapsed)
{
os << "<unittest-results"
<< " tests=\"" << totalTestCount << "\""
<< " failedtests=\"" << failedTestCount << "\""
<< " failures=\"" << failureCount << "\""
<< " time=\"" << secondsElapsed << "\""
<< ">";
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb9d5(%rip), %rsi # 0x69d4f
callq 0x15250
movq %rax, %rdi
leaq 0xb9d8(%rip), %rsi # 0x69d61
callq 0x15250
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x15410
movq %rax, %rdi
leaq 0xb99b(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb9b8(%rip), %rsi # 0x69d6a
callq 0x15250
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x15410
movq %rax, %rdi
leaq 0xb972(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb99e(%rip), %rsi # 0x69d79
callq 0x15250
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x15410
movq %rax, %rdi
leaq 0xb949(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb981(%rip), %rsi # 0x69d85
callq 0x15250
movq %rax, %rdi
movss -0x20(%rbp), %xmm0
callq 0x151c0
movq %rax, %rdi
leaq 0xb91e(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb97e(%rip), %rsi # 0x69dad
callq 0x15250
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,969 | UnitTest::XmlTestReporter::BeginTest(std::ostream&, UnitTest::DeferredTestResult const&) | void XmlTestReporter::BeginTest(std::ostream& os, DeferredTestResult const& result)
{
os << "<test"
<< " suite=\"" << result.suiteName << "\""
<< " name=\"" << result.testName << "\""
<< " time=\"" << result.timeElapsed << "\"";
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb92e(%rip), %rsi # 0x69d8d
callq 0x15250
movq %rax, %rdi
leaq 0xb925(%rip), %rsi # 0x69d93
callq 0x15250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x15230
movq %rax, %rdi
leaq 0xb8b5(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb904(%rip), %rsi # 0x69d9c
callq 0x15250
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x15230
movq %rax, %rdi
leaq 0xb887(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, %rdi
leaq 0xb8bf(%rip), %rsi # 0x69d85
callq 0x15250
movq %rax, %rdi
movq -0x18(%rbp), %rax
movss 0x78(%rax), %xmm0
callq 0x151c0
movq %rax, %rdi
leaq 0xb858(%rip), %rsi # 0x69d3e
callq 0x15250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,970 | UnitTest::XmlTestReporter::AddFailure(std::ostream&, UnitTest::DeferredTestResult const&) | void XmlTestReporter::AddFailure(std::ostream& os, DeferredTestResult const& result)
{
os << ">"; // close <test> element
for (DeferredTestResult::FailureVec::const_iterator it = result.failures.begin();
it != result.failures.end();
++it)
{
string const escapedMessage = XmlEscape(it->second);
string const message = BuildFailureMessage(result.failureFile, it->first, escapedMessage);
os << "<failure" << " message=\"" << message << "\"" << "/>";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb88b(%rip), %rsi # 0x69dad
callq 0x15250
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x5ba00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0x5ba30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5be20
testb $0x1, %al
jne 0x5e55f
jmp 0x5e683
leaq -0x20(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5ecf0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5e720
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x88(%rbp)
callq 0x5ecf0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
movl (%rax), %edx
leaq -0x68(%rbp), %rdi
callq 0x5ea60
jmp 0x5e5b6
movq -0x10(%rbp), %rdi
leaq 0xb7ee(%rip), %rsi # 0x69daf
callq 0x15250
movq %rax, -0x98(%rbp)
jmp 0x5e5cf
movq -0x98(%rbp), %rdi
leaq 0xb7db(%rip), %rsi # 0x69db8
callq 0x15250
movq %rax, -0xa0(%rbp)
jmp 0x5e5eb
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15230
movq %rax, -0xa8(%rbp)
jmp 0x5e604
movq -0xa8(%rbp), %rdi
leaq 0xb72c(%rip), %rsi # 0x69d3e
callq 0x15250
movq %rax, -0xb0(%rbp)
jmp 0x5e620
movq -0xb0(%rbp), %rdi
leaq 0xb77e(%rip), %rsi # 0x69dac
callq 0x15250
jmp 0x5e635
leaq -0x68(%rbp), %rdi
callq 0x15150
leaq -0x48(%rbp), %rdi
callq 0x15150
leaq -0x20(%rbp), %rdi
callq 0x5beb0
jmp 0x5e538
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x5e678
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x15150
leaq -0x48(%rbp), %rdi
callq 0x15150
jmp 0x5e68c
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,971 | UnitTest::XmlTestReporter::EndTest(std::ostream&, UnitTest::DeferredTestResult const&) | void XmlTestReporter::EndTest(std::ostream& os, DeferredTestResult const& result)
{
if (result.failed)
os << "</test>";
else
os << "/>";
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x7c(%rax)
je 0x5e6d0
movq -0x10(%rbp), %rdi
leaq 0xb6db(%rip), %rsi # 0x69da4
callq 0x15250
jmp 0x5e6e0
movq -0x10(%rbp), %rdi
leaq 0xb6d1(%rip), %rsi # 0x69dac
callq 0x15250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,972 | UnitTest::XmlTestReporter::EndResults(std::ostream&) | void XmlTestReporter::EndResults(std::ostream& os)
{
os << "</unittest-results>";
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xacc6(%rip), %rsi # 0x693d1
callq 0x15250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,973 | (anonymous namespace)::XmlEscape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string XmlEscape(string const& value)
{
string escaped = value;
ReplaceChar(escaped, '&', "&");
ReplaceChar(escaped, '<', "<");
ReplaceChar(escaped, '>', ">");
ReplaceChar(escaped, '\'', "'");
ReplaceChar(escaped, '\"', """);
return escaped;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x150f0
leaq -0x39(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x15430
movq -0xf8(%rbp), %rdx
leaq 0xb654(%rip), %rsi # 0x69dc3
leaq -0x38(%rbp), %rdi
callq 0x36c80
jmp 0x5e77a
movq -0x108(%rbp), %rdi
movl $0x26, %esi
leaq -0x38(%rbp), %rdx
callq 0x5eb80
jmp 0x5e791
leaq -0x38(%rbp), %rdi
callq 0x15150
leaq -0x39(%rbp), %rdi
callq 0x152a0
leaq -0x71(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x15430
movq -0x110(%rbp), %rdx
leaq 0xb608(%rip), %rsi # 0x69dc9
leaq -0x70(%rbp), %rdi
callq 0x36c80
jmp 0x5e7cc
movq -0x108(%rbp), %rdi
movl $0x3c, %esi
leaq -0x70(%rbp), %rdx
callq 0x5eb80
jmp 0x5e7e3
leaq -0x70(%rbp), %rdi
callq 0x15150
leaq -0x71(%rbp), %rdi
callq 0x152a0
leaq -0x99(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x15430
movq -0x118(%rbp), %rdx
leaq 0xb5b8(%rip), %rsi # 0x69dce
leaq -0x98(%rbp), %rdi
callq 0x36c80
jmp 0x5e824
movq -0x108(%rbp), %rdi
movl $0x3e, %esi
leaq -0x98(%rbp), %rdx
callq 0x5eb80
jmp 0x5e83e
leaq -0x98(%rbp), %rdi
callq 0x15150
leaq -0x99(%rbp), %rdi
callq 0x152a0
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x15430
movq -0x120(%rbp), %rdx
leaq 0xb55c(%rip), %rsi # 0x69dd3
leaq -0xc0(%rbp), %rdi
callq 0x36c80
jmp 0x5e885
movq -0x108(%rbp), %rdi
movl $0x27, %esi
leaq -0xc0(%rbp), %rdx
callq 0x5eb80
jmp 0x5e89f
leaq -0xc0(%rbp), %rdi
callq 0x15150
leaq -0xc1(%rbp), %rdi
callq 0x152a0
leaq -0xe9(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x15430
movq -0x128(%rbp), %rdx
leaq 0xb502(%rip), %rsi # 0x69dda
leaq -0xe8(%rbp), %rdi
callq 0x36c80
jmp 0x5e8e6
movq -0x108(%rbp), %rdi
movl $0x22, %esi
leaq -0xe8(%rbp), %rdx
callq 0x5eb80
jmp 0x5e900
leaq -0xe8(%rbp), %rdi
callq 0x15150
leaq -0xe9(%rbp), %rdi
callq 0x152a0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5ea38
jmp 0x5ea2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e94e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15150
leaq -0x39(%rbp), %rdi
callq 0x152a0
jmp 0x5ea48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e97f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x15150
leaq -0x71(%rbp), %rdi
callq 0x152a0
jmp 0x5ea48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e9b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x15150
leaq -0x99(%rbp), %rdi
callq 0x152a0
jmp 0x5ea48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5e9ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x15150
leaq -0xc1(%rbp), %rdi
callq 0x152a0
jmp 0x5ea48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5ea1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x15150
leaq -0xe9(%rbp), %rdi
callq 0x152a0
jmp 0x5ea48
movq -0x108(%rbp), %rdi
callq 0x15150
movq -0x100(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x15150
movq -0x48(%rbp), %rdi
callq 0x15420
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,974 | (anonymous namespace)::BuildFailureMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | string BuildFailureMessage(string const& file, int line, string const& message)
{
ostringstream failureMessage;
failureMessage << file << "(" << line << ") : " << message;
return failureMessage.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x15340
movq -0x1b8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x15230
movq %rax, -0x1b0(%rbp)
jmp 0x5eab7
movq -0x1b0(%rbp), %rdi
leaq 0xb31c(%rip), %rsi # 0x69de1
callq 0x15250
movq %rax, -0x1d0(%rbp)
jmp 0x5ead3
movq -0x1d0(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x15410
movq %rax, -0x1d8(%rbp)
jmp 0x5eaeb
movq -0x1d8(%rbp), %rdi
leaq 0xb2ea(%rip), %rsi # 0x69de3
callq 0x15250
movq %rax, -0x1e0(%rbp)
jmp 0x5eb07
movq -0x1e0(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15230
jmp 0x5eb19
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x15280
jmp 0x5eb2e
leaq -0x198(%rbp), %rdi
callq 0x15070
movq -0x1c0(%rbp), %rax
addq $0x1e0, %rsp # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x15070
movq -0x1a0(%rbp), %rdi
callq 0x15420
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,975 | (anonymous namespace)::ReplaceChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReplaceChar(string& str, char c, string const& replacement)
{
for (size_t pos = str.find(c); pos != string::npos; pos = str.find(c, pos + 1))
str.replace(pos, 1, replacement);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x9(%rbp), %esi
callq 0x15320
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x5ebe5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x150b0
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movsbl %al, %esi
callq 0x15320
movq %rax, -0x20(%rbp)
jmp 0x5ebab
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/XmlTestReporter.cpp |
11,976 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x5ed40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,977 | std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x5ed40
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
11,978 | _gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult const*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>::operator*() const | _GLIBCXX20_CONSTEXPR
pointer
operator->() const _GLIBCXX_NOEXCEPT
{ return _M_current; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,979 | _gnu_cxx::__normal_iterator<UnitTest::DeferredTestResult const*, std::vector<UnitTest::DeferredTestResult, std::allocator<UnitTest::DeferredTestResult>>>::__normal_iterator(UnitTest::DeferredTestResult const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
11,980 | UnitTest::SignalTranslator::SignalTranslator() | SignalTranslator::SignalTranslator()
{
m_oldJumpTarget = s_jumpTarget;
s_jumpTarget = &m_currentJumpTarget;
struct sigaction action;
action.sa_flags = 0;
action.sa_handler = SignalHandler;
sigemptyset( &action.sa_mask );
sigaction( SIGSEGV, &action, &m_old_SIGSEGV_action );
sigaction( SIGFPE , &action, &m_old_SIGFPE_action );
sigaction( SIGTRAP, &action, &m_old_SIGTRAP_action );
sigaction( SIGBUS , &action, &m_old_SIGBUS_action );
sigaction( SIGILL , &action, &m_old_SIGBUS_action );
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x2a377(%rip), %rcx # 0x89108
movq %rcx, 0xc8(%rax)
movq %rax, 0x2a369(%rip) # 0x89108
movl $0x0, -0x18(%rbp)
leaq 0xc3(%rip), %rax # 0x5ee70
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x15300
movq -0xa8(%rbp), %rdx
addq $0x200, %rdx # imm = 0x200
movl $0xb, %edi
leaq -0xa0(%rbp), %rsi
callq 0x15310
movq -0xa8(%rbp), %rdx
addq $0xd0, %rdx
movl $0x8, %edi
leaq -0xa0(%rbp), %rsi
callq 0x15310
movq -0xa8(%rbp), %rdx
addq $0x168, %rdx # imm = 0x168
movl $0x5, %edi
leaq -0xa0(%rbp), %rsi
callq 0x15310
movq -0xa8(%rbp), %rdx
addq $0x298, %rdx # imm = 0x298
movl $0x7, %edi
leaq -0xa0(%rbp), %rsi
callq 0x15310
movq -0xa8(%rbp), %rdx
addq $0x298, %rdx # imm = 0x298
movl $0x4, %edi
leaq -0xa0(%rbp), %rsi
callq 0x15310
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/SignalTranslator.cpp |
11,981 | UnitTest::(anonymous namespace)::SignalHandler(int) | void SignalHandler(int sig)
{
siglongjmp(*SignalTranslator::s_jumpTarget, sig );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x2a286(%rip), %rdi # 0x89108
movl -0x4(%rbp), %esi
callq 0x152d0
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/SignalTranslator.cpp |
11,982 | UnitTest::SignalTranslator::~SignalTranslator() | SignalTranslator::~SignalTranslator()
{
sigaction( SIGILL , &m_old_SIGBUS_action , 0 );
sigaction( SIGBUS , &m_old_SIGBUS_action , 0 );
sigaction( SIGTRAP, &m_old_SIGTRAP_action, 0 );
sigaction( SIGFPE , &m_old_SIGFPE_action , 0 );
sigaction( SIGSEGV, &m_old_SIGSEGV_action, 0 );
s_jumpTarget = m_oldJumpTarget;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x10(%rbp)
addq $0x298, %rsi # imm = 0x298
movl $0x4, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x15310
movq -0x10(%rbp), %rsi
addq $0x298, %rsi # imm = 0x298
movl $0x7, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x15310
movq -0x10(%rbp), %rsi
addq $0x168, %rsi # imm = 0x168
movl $0x5, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x15310
movq -0x10(%rbp), %rsi
addq $0xd0, %rsi
movl $0x8, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x15310
movq -0x10(%rbp), %rsi
addq $0x200, %rsi # imm = 0x200
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x15310
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, 0x2a1d9(%rip) # 0x89108
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/SignalTranslator.cpp |
11,983 | UnitTest::Timer::Timer() | Timer::Timer()
{
m_startTime.tv_sec = 0;
m_startTime.tv_usec = 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/TimeHelpers.cpp |
11,984 | UnitTest::Timer::Start() | void Timer::Start()
{
gettimeofday(&m_startTime, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x153d0
addq $0x10, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/TimeHelpers.cpp |
11,985 | UnitTest::Timer::GetTimeInMs() const | double Timer::GetTimeInMs() const
{
struct timeval currentTime;
gettimeofday(¤tTime, 0);
double const dsecs = currentTime.tv_sec - m_startTime.tv_sec;
double const dus = currentTime.tv_usec - m_startTime.tv_usec;
return (dsecs * 1000.0) + (dus / 1000.0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x153d0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd 0xacd6(%rip), %xmm2 # 0x69cb0
divsd %xmm2, %xmm1
movsd 0xacca(%rip), %xmm2 # 0x69cb0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/TimeHelpers.cpp |
11,986 | UnitTest::TimeHelpers::SleepMs(int) | void TimeHelpers::SleepMs(int ms)
{
usleep(ms * 1000);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
imull $0x3e8, -0x4(%rbp), %edi # imm = 0x3E8
callq 0x15380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/Posix/TimeHelpers.cpp |
11,987 | UnitTest::TestReporterStdout::ReportFailure(UnitTest::TestDetails const&, char const*) | void TestReporterStdout::ReportFailure(TestDetails const& details, char const* failure)
{
#if defined(__APPLE__) || defined(__GNUG__)
char const* const errorFormat = "%s:%d: error: Failure in %s: %s\n";
#else
char const* const errorFormat = "%s(%d): error: Failure in %s: %s\n";
#endif
using namespace std;
printf(errorFormat, details.filename, details.lineNumber, details.testName, failure);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xadca(%rip), %rax # 0x69e05
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0xada4(%rip), %rdi # 0x69e05
movb $0x0, %al
callq 0x15030
addq $0x20, %rsp
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporterStdout.cpp |
11,988 | UnitTest::TestReporterStdout::ReportTestStart(UnitTest::TestDetails const&) | void TestReporterStdout::ReportTestStart(TestDetails const& /*test*/)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporterStdout.cpp |
11,989 | UnitTest::TestReporterStdout::ReportTestFinish(UnitTest::TestDetails const&, float) | void TestReporterStdout::ReportTestFinish(TestDetails const& /*test*/, float)
{
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporterStdout.cpp |
11,990 | UnitTest::TestReporterStdout::ReportSummary(int, int, int, float) | void TestReporterStdout::ReportSummary(int const totalTestCount, int const failedTestCount,
int const failureCount, float secondsElapsed)
{
using namespace std;
if (failureCount > 0)
printf("FAILURE: %d out of %d tests failed (%d failures).\n", failedTestCount, totalTestCount, failureCount);
else
printf("Success: %d tests passed.\n", totalTestCount);
printf("Test time: %.2f seconds.\n", secondsElapsed);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x5f0d9
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0xad56(%rip), %rdi # 0x69e26
movb $0x0, %al
callq 0x15030
jmp 0x5f0ea
movl -0xc(%rbp), %esi
leaq 0xad76(%rip), %rdi # 0x69e59
movb $0x0, %al
callq 0x15030
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xad7a(%rip), %rdi # 0x69e74
movb $0x1, %al
callq 0x15030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| marlowa[P]quickfix[P]build_O0[P]UnitTest++[P]TestUnitTest++.asm_src.json | O0 | marlowa[P]quickfix/UnitTest++/src/TestReporterStdout.cpp |
11,991 | operator>>(std::istream&, std::tuple<int, int>&) | std::istream& operator>>(std::istream& is, std::tuple<int, int>& ints)
{
is >> std::get<0>(ints);
is.get();
is >> std::get<1>(ints);
return is;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0c40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1f490
movq -0x8(%rbp), %rdi
callq 0x1f8f0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0c60
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1f490
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/test.cxx |
11,992 | Catch::Detail::Approx::Approx(double) | Approx::Approx ( double value )
: m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
m_margin( 0.0 ),
m_scale( 0.0 ),
m_value( value )
{} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xd0c80
movq -0x18(%rbp), %rax
movss 0x194f6a(%rip), %xmm1 # 0x1b8004
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,993 | Catch::Detail::Approx::custom() | Approx Approx::custom() {
return Approx( 0 );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
leaq -0x4(%rbp), %rsi
callq 0xd0c90
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,994 | Catch::Detail::Approx::operator-() const | Approx Approx::operator-() const {
auto temp(*this);
temp.m_value = -temp.m_value;
return temp;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rdi)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rdi)
movsd 0x18(%rdi), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x18(%rdi)
popq %rbp
retq
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,995 | Catch::Detail::Approx::toString[abi:cxx11]() const | std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x37400
movq -0x68(%rbp), %rdi
leaq 0x196b82(%rip), %rsi # 0x1b9d10
callq 0xd0cc0
movq %rax, -0x60(%rbp)
jmp 0x23199
movq -0x70(%rbp), %rsi
addq $0x18, %rsi
leaq -0x58(%rbp), %rdi
callq 0xd0d20
jmp 0x231ac
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xd0cf0
movq %rax, -0x88(%rbp)
jmp 0x231c2
movq -0x88(%rbp), %rdi
leaq 0x196b49(%rip), %rsi # 0x1b9d19
callq 0xd0d50
jmp 0x231d7
leaq -0x58(%rbp), %rdi
callq 0x1ff08
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x23240
jmp 0x231ef
leaq -0x28(%rbp), %rdi
callq 0x374c0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x23228
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1ff08
leaq -0x28(%rbp), %rdi
callq 0x374c0
movq -0x30(%rbp), %rdi
callq 0x1fd40
nopw (%rax,%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,996 | Catch::ReusableStringStream::str[abi:cxx11]() const | auto ReusableStringStream::str() const -> std::string {
return static_cast<std::ostringstream*>( m_oss )->str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1f7b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,997 | Catch::Detail::Approx::equalityComparisonImpl(double) const | bool Approx::equalityComparisonImpl(const double other) const {
// First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
// Thanks to Richard Harris for his help refining the scaled margin value
return marginComparison(m_value, other, m_margin)
|| marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd 0x18(%rax), %xmm0
movsd -0x10(%rbp), %xmm1
movsd 0x8(%rax), %xmm2
callq 0x23340
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x23334
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x18(%rax), %xmm0
callq 0xd0d80
testb $0x1, %al
jne 0x232e8
jmp 0x232f2
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x23300
movq -0x20(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x48(%rbp), %xmm4
movaps 0x194d00(%rip), %xmm5 # 0x1b8020
pand %xmm5, %xmm4
addsd %xmm4, %xmm3
mulsd %xmm3, %xmm2
callq 0x23340
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,998 | (anonymous namespace)::marginComparison(double, double, double) | bool marginComparison(double lhs, double rhs, double margin) {
return (lhs + margin >= rhs) && (rhs + margin >= lhs);
} | pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomisd -0x10(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x2337e
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
ucomisd -0x8(%rbp), %xmm0
setae %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
11,999 | Catch::Detail::Approx::setMargin(double) | void Approx::setMargin(double newMargin) {
CATCH_ENFORCE(newMargin >= 0,
"Invalid Approx::margin: " << newMargin << '.'
<< " Approx::Margin has to be non-negative.");
m_margin = newMargin;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x2346f
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37400
movq -0x70(%rbp), %rdi
leaq 0x196946(%rip), %rsi # 0x1b9d1c
callq 0xd0dc0
movq %rax, -0x68(%rbp)
jmp 0x233e1
movq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xd0df0
movq %rax, -0x78(%rbp)
jmp 0x233f4
movq -0x78(%rbp), %rdi
movb $0x2e, -0x55(%rbp)
leaq -0x55(%rbp), %rsi
callq 0xd0e30
movq %rax, -0x80(%rbp)
jmp 0x2340b
movq -0x80(%rbp), %rdi
leaq 0x19691f(%rip), %rsi # 0x1b9d35
callq 0xd0e70
movq %rax, -0x88(%rbp)
jmp 0x23424
movq -0x88(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x23240
jmp 0x23436
leaq -0x30(%rbp), %rdi
callq 0x234a0
jmp 0x23441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x23464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ff08
leaq -0x48(%rbp), %rdi
callq 0x374c0
jmp 0x23488
jmp 0x23471
movq -0x60(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1fd40
nopw %cs:(%rax,%rax)
| cjuub[P]geemuboi[P]build_O0[P]_deps[P]args-build[P]argstest.asm_src.json | O0 | cjuub[P]geemuboi/build_O0/_deps/args-src/catch.hpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.