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 |
|---|---|---|---|---|---|---|
10,000 | std::chrono::duration<long, std::ratio<1l, 1000l>> std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000l>>, std::ratio<1l, 1000000l>, long, true, false>::__cast<long, std::ratio<1l, 1000000000l>>(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | static constexpr _ToDur
__cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(
static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d20
movl $0xf4240, %ecx # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3d40
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,001 | std::chrono::duration<long, std::ratio<1l, 1000000000l>>::count() const | constexpr rep
count() const
{ return __r; } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,002 | std::chrono::duration<long, std::ratio<1l, 1000l>>::duration<long, void>(long const&) | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,003 | std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::time_since_epoch() const | constexpr duration
time_since_epoch() const
{ return __d; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,004 | std::chrono::duration<long, std::ratio<1l, 1000000000l>>::duration<long, void>(long const&) | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,005 | std::thread::joinable() const | bool
joinable() const noexcept
{ return !(_M_id == id()); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3e70
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e50
xorb $-0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,006 | std::operator==(std::thread::id, std::thread::id) | inline bool
operator==(thread::id __x, thread::id __y) noexcept
{
// pthread_equal is undefined if either thread ID is not valid, so we
// can't safely use __gthread_equal on default-constructed values (nor
// the non-zero value returned by this_thread::get_id() for
// single-threaded programs using GNU libc). Assume EqualityComparable.
return __x._M_thread == __y._M_thread;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,007 | std::thread::id::id() | id() noexcept : _M_thread() { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,008 | std::mutex::mutex() | mutex() noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3eb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,009 | std::__mutex_base::__mutex_base() | constexpr __mutex_base() noexcept = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x20e0
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,010 | std::lock_guard<std::mutex>::lock_guard(std::mutex&) | explicit lock_guard(mutex_type& __m) : _M_device(__m)
{ _M_device.lock(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x3f50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,011 | std::lock_guard<std::mutex>::~lock_guard() | ~lock_guard()
{ _M_device.unlock(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3f80
jmp 0x3f3a
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,012 | std::mutex::lock() | void
lock()
{
int __e = __gthread_mutex_lock(&_M_mutex);
// EINVAL, EAGAIN, EBUSY, EINVAL, EDEADLK(may)
if (__e)
__throw_system_error(__e);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3210
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3f76
movl -0xc(%rbp), %edi
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,013 | std::mutex::unlock() | void
unlock()
{
// XXX EINVAL, EAGAIN, EPERM
__gthread_mutex_unlock(&_M_mutex);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,014 | std::unique_lock<std::mutex>::unique_lock(std::mutex&) | explicit unique_lock(mutex_type& __m)
: _M_device(std::__addressof(__m)), _M_owns(false)
{
lock();
_M_owns = true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x4020
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_lock.h |
10,015 | std::unique_lock<std::mutex>::~unique_lock() | ~unique_lock()
{
if (_M_owns)
unlock();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x8(%rax)
je 0x4007
movq -0x10(%rbp), %rdi
callq 0x4080
jmp 0x4005
jmp 0x4007
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_lock.h |
10,016 | std::unique_lock<std::mutex>::lock() | void
lock()
{
if (!_M_device)
__throw_system_error(int(errc::operation_not_permitted));
else if (_M_owns)
__throw_system_error(int(errc::resource_deadlock_would_occur));
else
{
_M_device->lock();
_M_owns = true;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x4044
movl $0x1, %edi
callq 0x2100
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x4058
movl $0x23, %edi
callq 0x2100
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3f50
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x406e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_lock.h |
10,017 | std::unique_lock<std::mutex>::unlock() | void
unlock()
{
if (!_M_owns)
__throw_system_error(int(errc::operation_not_permitted));
else if (_M_device)
{
_M_device->unlock();
_M_owns = false;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x8(%rax)
jne 0x40a4
movl $0x1, %edi
callq 0x2100
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x40c2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3f80
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0x40c4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_lock.h |
10,018 | std::cv_status std::condition_variable::wait_for<long, std::ratio<1l, 1000l>>(std::unique_lock<std::mutex>&, std::chrono::duration<long, std::ratio<1l, 1000l>> const&) | cv_status
wait_for(unique_lock<mutex>& __lock,
const chrono::duration<_Rep, _Period>& __rtime)
{
using __dur = typename steady_clock::duration;
return wait_until(__lock,
steady_clock::now() +
chrono::__detail::ceil<__dur>(__rtime));
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x21c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4190
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x4160
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/condition_variable |
10,019 | std::chrono::duration<long, std::ratio<1l, 1000l>>::duration<int, void>(int const&) | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,020 | std::cv_status std::condition_variable::wait_until<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>(std::unique_lock<std::mutex>&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) | cv_status
wait_until(unique_lock<mutex>& __lock,
const chrono::time_point<steady_clock, _Duration>& __atime)
{ return __wait_until_impl(__lock, __atime); } | 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 0x4260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/condition_variable |
10,021 | std::enable_if<__is_duration<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::value, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::type std::chrono::ceil<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, long, std::ratio<1l, 1000l>>(std::chrono::duration<long, std::ratio<1l, 1000l>> const&) | constexpr __enable_if_is_duration<_ToDur>
ceil(const duration<_Rep, _Period>& __d)
{
auto __to = chrono::duration_cast<_ToDur>(__d);
if (__to < __d)
return __to + _ToDur{1};
return __to;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4850
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x4880
movb %al, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4510
movzbl -0x19(%rbp), %edi
callq 0x44a0
testb $0x1, %al
jne 0x4225
jmp 0x424c
movl $0x1, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4910
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x47c0
movq %rax, -0x8(%rbp)
jmp 0x4254
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,022 | std::cv_status std::condition_variable::__wait_until_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>(std::unique_lock<std::mutex>&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) | cv_status
__wait_until_impl(unique_lock<mutex>& __lock,
const chrono::time_point<steady_clock, _Dur>& __atime)
{
auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);
__gthread_time_t __ts =
{
static_cast<std::time_t>(__s.time_since_epoch().count()),
static_cast<long>(__ns.count())
};
_M_cond.wait_until(*__lock.mutex(), CLOCK_MONOTONIC, __ts);
return (steady_clock::now() < __atime
? cv_status::no_timeout : cv_status::timeout);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4330
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x43a0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4370
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43f0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4410
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3d20
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4480
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
leaq -0x40(%rbp), %rcx
callq 0x4430
callq 0x21c0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x44c0
movb %al, -0x49(%rbp)
leaq -0x59(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4510
movzbl -0x49(%rbp), %edi
callq 0x44a0
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x70, %rsp
popq %rbp
retq
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/condition_variable |
10,023 | std::enable_if<__is_duration<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::value, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, long, std::ratio<1l, 1000000000l>>(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | constexpr __enable_if_is_duration<_ToDur>
duration_cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::period __to_period;
typedef typename _ToDur::rep __to_rep;
typedef ratio_divide<_Period, __to_period> __cf;
typedef typename common_type<__to_rep, _Rep, intmax_t>::type
__cr;
typedef __duration_cast_impl<_ToDur, __cf, __cr,
__cf::num == 1, __cf::den == 1> __dc;
return __dc::__cast(__d);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x45d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,024 | std::common_type<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::chrono::duration<long, std::ratio<1l, 1l>>>::type std::chrono::operator-<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::chrono::duration<long, std::ratio<1l, 1l>>>(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&) | constexpr typename common_type<_Dur1, _Dur2>::type
operator-(const time_point<_Clock, _Dur1>& __lhs,
const time_point<_Clock, _Dur2>& __rhs)
{ return __lhs.time_since_epoch() - __rhs.time_since_epoch(); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3dd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x43f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4600
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,025 | std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1l>>>::time_since_epoch() const | constexpr duration
time_since_epoch() const
{ return __d; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,026 | std::chrono::duration<long, std::ratio<1l, 1l>>::count() const | constexpr rep
count() const
{ return __r; } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,027 | std::__condvar::wait_until(std::mutex&, int, timespec&) | void
wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time) noexcept
{
pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock,
&__abs_time);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4720
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x20c0
jmp 0x446d
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,028 | std::unique_lock<std::mutex>::mutex() const | mutex_type*
mutex() const noexcept
{ return _M_device; } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_lock.h |
10,029 | std::operator<(std::strong_ordering, std::__cmp_cat::__unspec) | constexpr bool
operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
{ return __v._M_value < 0; } | pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x0, %eax
setl %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/compare |
10,030 | auto std::chrono::operator<=><std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>(std::chrono::time_point<std::chrono::_V2::steady_clock, T0> const&, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const&) | constexpr auto
operator<=>(const time_point<_Clock, _Dur1>& __lhs,
const time_point<_Clock, _Dur2>& __rhs)
{ return __lhs.time_since_epoch() <=> __rhs.time_since_epoch(); } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3dd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3dd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4730
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,031 | std::__cmp_cat::__unspec::__unspec(std::__cmp_cat::__unspec*) | constexpr __unspec(__unspec*) noexcept { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/compare |
10,032 | std::enable_if<__is_duration<std::chrono::duration<long, std::ratio<1l, 1l>>>::value, std::chrono::duration<long, std::ratio<1l, 1l>>>::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1l>>, long, std::ratio<1l, 1000000000l>>(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | constexpr __enable_if_is_duration<_ToDur>
duration_cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::period __to_period;
typedef typename _ToDur::rep __to_rep;
typedef ratio_divide<_Period, __to_period> __cf;
typedef typename common_type<__to_rep, _Rep, intmax_t>::type
__cr;
typedef __duration_cast_impl<_ToDur, __cf, __cr,
__cf::num == 1, __cf::den == 1> __dc;
return __dc::__cast(__d);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,033 | std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1l>>>::time_point(std::chrono::duration<long, std::ratio<1l, 1l>> const&) | constexpr explicit time_point(const duration& __dur)
: __d(__dur)
{ } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,034 | std::chrono::duration<long, std::ratio<1l, 1l>> std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1l>>, std::ratio<1l, 1000000000l>, long, true, false>::__cast<long, std::ratio<1l, 1000000000l>>(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | static constexpr _ToDur
__cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(
static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d20
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x45b0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,035 | std::chrono::duration<long, std::ratio<1l, 1l>>::duration<long, void>(long const&) | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,036 | std::chrono::duration<long, std::ratio<1l, 1000000000l>> std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::ratio<1l, 1l>, long, true, true>::__cast<long, std::ratio<1l, 1000000000l>>(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | static constexpr _ToDur
__cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(__d.count()));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d20
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3df0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,037 | std::chrono::duration<long, std::ratio<1l, 1000000000l>>::duration<long, std::ratio<1l, 1l>, void>(std::chrono::duration<long, std::ratio<1l, 1l>> const&) | constexpr duration(const duration<_Rep2, _Period2>& __d)
: __r(duration_cast<duration>(__d).count()) { } | 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 0x46b0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3d20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,038 | std::enable_if<__is_duration<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::value, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, long, std::ratio<1l, 1l>>(std::chrono::duration<long, std::ratio<1l, 1l>> const&) | constexpr __enable_if_is_duration<_ToDur>
duration_cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::period __to_period;
typedef typename _ToDur::rep __to_rep;
typedef ratio_divide<_Period, __to_period> __cf;
typedef typename common_type<__to_rep, _Rep, intmax_t>::type
__cr;
typedef __duration_cast_impl<_ToDur, __cf, __cr,
__cf::num == 1, __cf::den == 1> __dc;
return __dc::__cast(__d);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,039 | std::chrono::duration<long, std::ratio<1l, 1000000000l>> std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::ratio<1000000000l, 1l>, long, false, true>::__cast<long, std::ratio<1l, 1l>>(std::chrono::duration<long, std::ratio<1l, 1l>> const&) | static constexpr _ToDur
__cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(
static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4410
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3df0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,040 | std::mutex::native_handle() | native_handle_type
native_handle() noexcept
{ return &_M_mutex; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_mutex.h |
10,041 | auto std::chrono::operator<=><long, std::ratio<1l, 1000000000l>, long, std::ratio<1l, 1000000000l>>(std::chrono::duration<T, std::ratio<1l, 1000000000l>> const&, std::chrono::duration<T1, std::ratio<1l, 1000000000l>> const&) | constexpr auto
operator<=>(const duration<_Rep1, _Period1>& __lhs,
const duration<_Rep2, _Period2>& __rhs)
{
using __ct = common_type_t<duration<_Rep1, _Period1>,
duration<_Rep2, _Period2>>;
return __ct(__lhs).count() <=> __ct(__rhs).count();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3d20
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3d20
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq %rdx, -0x38(%rbp)
movb $-0x1, %al
movb $0x1, %sil
movb %sil, -0x2a(%rbp)
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jl 0x478e
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movb -0x29(%rbp), %al
movb %al, -0x42(%rbp)
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x41(%rbp)
je 0x47ac
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,042 | std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::time_point(std::chrono::duration<long, std::ratio<1l, 1000000000l>> const&) | constexpr explicit time_point(const duration& __dur)
: __d(__dur)
{ } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,043 | std::enable_if<__is_duration<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::value, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>::type std::chrono::duration_cast<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, long, std::ratio<1l, 1000l>>(std::chrono::duration<long, std::ratio<1l, 1000l>> const&) | constexpr __enable_if_is_duration<_ToDur>
duration_cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::period __to_period;
typedef typename _ToDur::rep __to_rep;
typedef ratio_divide<_Period, __to_period> __cf;
typedef typename common_type<__to_rep, _Rep, intmax_t>::type
__cr;
typedef __duration_cast_impl<_ToDur, __cf, __cr,
__cf::num == 1, __cf::den == 1> __dc;
return __dc::__cast(__d);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,044 | auto std::chrono::operator<=><long, std::ratio<1l, 1000000000l>, long, std::ratio<1l, 1000l>>(std::chrono::duration<T, std::ratio<1l, 1000000000l>> const&, std::chrono::duration<T1, std::ratio<1l, 1000l>> const&) | constexpr auto
operator<=>(const duration<_Rep1, _Period1>& __lhs,
const duration<_Rep2, _Period2>& __rhs)
{
using __ct = common_type_t<duration<_Rep1, _Period1>,
duration<_Rep2, _Period2>>;
return __ct(__lhs).count() <=> __ct(__rhs).count();
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3d20
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4970
leaq -0x28(%rbp), %rdi
callq 0x3d20
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq %rdx, -0x38(%rbp)
movb $-0x1, %al
movb $0x1, %sil
movb %sil, -0x2a(%rbp)
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jl 0x48e0
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdx
movb -0x29(%rbp), %al
movb %al, -0x42(%rbp)
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x41(%rbp)
je 0x48fe
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,045 | std::chrono::duration<long, std::ratio<1l, 1000000000l>>::duration<int, void>(int const&) | constexpr explicit duration(const _Rep2& __rep)
: __r(static_cast<rep>(__rep)) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,046 | std::chrono::duration<long, std::ratio<1l, 1000000000l>> std::chrono::__duration_cast_impl<std::chrono::duration<long, std::ratio<1l, 1000000000l>>, std::ratio<1000000l, 1l>, long, false, true>::__cast<long, std::ratio<1l, 1000l>>(std::chrono::duration<long, std::ratio<1l, 1000l>> const&) | static constexpr _ToDur
__cast(const duration<_Rep, _Period>& __d)
{
typedef typename _ToDur::rep __to_rep;
return _ToDur(static_cast<__to_rep>(
static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b10
imulq $0xf4240, %rax, %rax # imm = 0xF4240
movq %rax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3df0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,047 | std::chrono::duration<long, std::ratio<1l, 1000000000l>>::duration<long, std::ratio<1l, 1000l>, void>(std::chrono::duration<long, std::ratio<1l, 1000l>> const&) | constexpr duration(const duration<_Rep2, _Period2>& __d)
: __r(duration_cast<duration>(__d).count()) { } | 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 0x4850
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3d20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/chrono |
10,048 | std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (*)(int), int>>>::_State_impl<void (&)(int), int&>(void (&)(int), int&) | _State_impl(_Args&&... __args)
: _M_func(std::forward<_Args>(__args)...)
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4ab0
movq -0x30(%rbp), %rdi
leaq 0x539c(%rip), %rax # 0x9d78
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4ad0
jmp 0x49f2
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x20b0
movq -0x20(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,049 | std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State>>::unique_ptr<std::default_delete<std::thread::_State>, void>(std::thread::_State*) | explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
{ } | 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 0x4e10
jmp 0x4a3f
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,050 | std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State>>::~unique_ptr() | ~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
"unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
get_deleter()(std::move(__ptr));
__ptr = pointer();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4eb0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4a93
movq -0x18(%rbp), %rdi
callq 0x4fc0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x4ff0
jmp 0x4a91
jmp 0x4a93
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,051 | std::thread::_Invoker<std::tuple<void (*)(int), int>>::_Invoker<void (&)(int), int&>(void (&)(int), int&) | explicit
_Invoker(_Args&&... __args)
: _M_t(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 -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4b70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,052 | std::thread::_State_impl<std::thread::_Invoker<std::tuple<void (*)(int), int>>>::_M_run() | void
_M_run() { _M_func(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4c70
addq $0x10, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,053 | std::tuple<void (*)(int), int>::tuple<void (&)(int), int&, true>(void (&)(int), int&) | constexpr
tuple(_U1&& __a1, _U2&& __a2)
noexcept(__nothrow_constructible<_U1, _U2>())
: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } | 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 0x4bb0
jmp 0x4b97
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,054 | std::_Tuple_impl<0ul, void (*)(int), int>::_Tuple_impl<void (&)(int), int&, void>(void (&)(int), int&) | explicit constexpr
_Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...),
_Base(std::forward<_UHead>(__head))
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4c00
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x4c30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,055 | std::_Tuple_impl<1ul, int>::_Tuple_impl<int&>(int&) | explicit constexpr
_Tuple_impl(_UHead&& __head)
: _Base(std::forward<_UHead>(__head))
{ } | 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 0x4c50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,056 | std::_Head_base<0ul, void (*)(int), false>::_Head_base(void (* const&)(int)) | constexpr _Head_base(const _Head& __h)
: _M_head_impl(__h) { } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,057 | std::_Head_base<1ul, int, false>::_Head_base<int&>(int&) | constexpr _Head_base(_UHead&& __h)
: _M_head_impl(std::forward<_UHead>(__h)) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,058 | std::thread::_Invoker<std::tuple<void (*)(int), int>>::operator()() | typename __result<_Tuple>::type
operator()()
{
using _Indices
= typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type;
return _M_invoke(_Indices());
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4c90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,059 | void std::thread::_Invoker<std::tuple<void (*)(int), int>>::_M_invoke<0ul, 1ul>(std::_Index_tuple<0ul, 1ul>) | typename __result<_Tuple>::type
_M_invoke(_Index_tuple<_Ind...>)
{ return std::__invoke(std::get<_Ind>(std::move(_M_t))...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4d00
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x4d20
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x4cd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/std_thread.h |
10,060 | std::__invoke_result<void (*)(int), int>::type std::__invoke<void (*)(int), int>(void (*&&)(int), int&&) | constexpr typename __invoke_result<_Callable, _Args...>::type
__invoke(_Callable&& __fn, _Args&&... __args)
noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
{
using __result = __invoke_result<_Callable, _Args...>;
using __type = typename __result::type;
using __tag = typename __result::__invoke_type;
return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
std::forward<_Args>(__args)...);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h |
10,061 | std::tuple_element<0ul, std::tuple<void (*)(int), int>>::type&& std::get<0ul, void (*)(int), int>(std::tuple<void (*)(int), int>&&) | constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type>(std::__get_helper<__i>(__t));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4d70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,062 | std::tuple_element<1ul, std::tuple<void (*)(int), int>>::type&& std::get<1ul, void (*)(int), int>(std::tuple<void (*)(int), int>&&) | constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
get(tuple<_Elements...>&& __t) noexcept
{
typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
return std::forward<__element_type>(std::__get_helper<__i>(__t));
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4dc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,063 | void std::__invoke_impl<void, void (*)(int), int>(std::__invoke_other, void (*&&)(int), int&&) | constexpr _Res
__invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
{ return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/invoke.h |
10,064 | void (*&std::__get_helper<0ul, void (*)(int), int>(std::_Tuple_impl<0ul, void (*)(int), int>&))(int) | constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4d90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,065 | std::_Tuple_impl<0ul, void (*)(int), int>::_M_head(std::_Tuple_impl<0ul, void (*)(int), int>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x4db0
addq $0x10, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,066 | std::_Head_base<0ul, void (*)(int), false>::_M_head(std::_Head_base<0ul, void (*)(int), false>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,067 | int& std::__get_helper<1ul, int>(std::_Tuple_impl<1ul, int>&) | constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4de0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,068 | std::_Tuple_impl<1ul, int>::_M_head(std::_Tuple_impl<1ul, int>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,069 | std::_Head_base<1ul, int, false>::_M_head(std::_Head_base<1ul, int, false>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,070 | std::__uniq_ptr_data<std::thread::_State, std::default_delete<std::thread::_State>, true, true>::__uniq_ptr_data(std::thread::_State*) | __uniq_ptr_data(__uniq_ptr_data&&) = default; | 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 0x4e40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,071 | std::__uniq_ptr_impl<std::thread::_State, std::default_delete<std::thread::_State>>::__uniq_ptr_impl(std::thread::_State*) | __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4e80
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x4eb0
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,072 | std::tuple<std::thread::_State*, std::default_delete<std::thread::_State>>::tuple<true, true>() | constexpr
tuple()
noexcept(__nothrow_default_constructible())
: _Inherited() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ed0
jmp 0x4e97
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,073 | std::__uniq_ptr_impl<std::thread::_State, std::default_delete<std::thread::_State>>::_M_ptr() | pointer& _M_ptr() { return std::get<0>(_M_t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,074 | std::_Tuple_impl<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>::_Tuple_impl() | constexpr _Tuple_impl()
: _Inherited(), _Base() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4f00
movq -0x10(%rbp), %rdi
callq 0x4f20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,075 | std::_Tuple_impl<1ul, std::default_delete<std::thread::_State>>::_Tuple_impl() | constexpr
_Tuple_impl()
: _Base() { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,076 | std::_Head_base<0ul, std::thread::_State*, false>::_Head_base() | constexpr _Head_base()
: _M_head_impl() { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,077 | std::_Head_base<1ul, std::default_delete<std::thread::_State>, true>::_Head_base() | constexpr _Head_base()
: _M_head_impl() { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,078 | std::tuple_element<0ul, std::tuple<std::thread::_State*, std::default_delete<std::thread::_State>>>::type& std::get<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>(std::tuple<std::thread::_State*, std::default_delete<std::thread::_State>>&) | constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,079 | std::thread::_State*& std::__get_helper<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>(std::_Tuple_impl<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>&) | constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4f90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,080 | std::_Tuple_impl<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>::_M_head(std::_Tuple_impl<0ul, std::thread::_State*, std::default_delete<std::thread::_State>>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4fb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,081 | std::_Head_base<0ul, std::thread::_State*, false>::_M_head(std::_Head_base<0ul, std::thread::_State*, false>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,082 | std::unique_ptr<std::thread::_State, std::default_delete<std::thread::_State>>::get_deleter() | deleter_type&
get_deleter() noexcept
{ return _M_t._M_deleter(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5020
movq %rax, -0x10(%rbp)
jmp 0x4fdb
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,083 | std::default_delete<std::thread::_State>::operator()(std::thread::_State*) const | void
operator()(_Tp* __ptr) const
{
static_assert(!is_void<_Tp>::value,
"can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
"can't delete pointer to incomplete type");
delete __ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5018
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,084 | std::__uniq_ptr_impl<std::thread::_State, std::default_delete<std::thread::_State>>::_M_deleter() | _Dp& _M_deleter() { return std::get<1>(_M_t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h |
10,085 | std::tuple_element<1ul, std::tuple<std::thread::_State*, std::default_delete<std::thread::_State>>>::type& std::get<1ul, std::thread::_State*, std::default_delete<std::thread::_State>>(std::tuple<std::thread::_State*, std::default_delete<std::thread::_State>>&) | constexpr __tuple_element_t<__i, tuple<_Elements...>>&
get(tuple<_Elements...>& __t) noexcept
{ return std::__get_helper<__i>(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,086 | std::default_delete<std::thread::_State>& std::__get_helper<1ul, std::default_delete<std::thread::_State>>(std::_Tuple_impl<1ul, std::default_delete<std::thread::_State>>&) | constexpr _Head&
__get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
{ return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,087 | std::_Tuple_impl<1ul, std::default_delete<std::thread::_State>>::_M_head(std::_Tuple_impl<1ul, std::default_delete<std::thread::_State>>&) | static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,088 | std::_Head_base<1ul, std::default_delete<std::thread::_State>, true>::_M_head(std::_Head_base<1ul, std::default_delete<std::thread::_State>, true>&) | static constexpr _Head&
_M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/tuple |
10,089 | std::operator&(std::memory_order, std::__memory_order_modifier) | constexpr memory_order
operator&(memory_order __m, __memory_order_modifier __mod)
{
return memory_order(int(__m) & int(__mod));
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/atomic_base.h |
10,090 | pr_set_level(int) | int pr_set_level(int level)
{
if(level > PR_LEVEL_DEBUG)
{
level = PR_LEVEL_DEBUG;
}
else if(level < PR_LEVEL_ERROR)
{
level = PR_LEVEL_ERROR;
}
int old_level = pr_level;
pr_level = level;
return old_level;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jle 0x50e6
movl $0x3, -0x4(%rbp)
jmp 0x50f5
cmpl $0x0, -0x4(%rbp)
jge 0x50f3
movl $0x0, -0x4(%rbp)
jmp 0x50f5
movl 0x5055(%rip), %eax # 0xa150
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x5049(%rip) # 0xa150
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | AlberTTreblA[P]HighPerformanceConcurrentServer/log/pr.cpp |
10,091 | tid_to_string[abi:cxx11](std::thread::id const&) | string tid_to_string(const thread::id& tid)
{
ostringstream oss;
oss << tid << endl;
return oss.str();
} | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x21d0
movq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rsi
callq 0x5240
movq %rax, -0x1a8(%rbp)
jmp 0x5171
movq -0x1a8(%rbp), %rdi
movq 0x4e41(%rip), %rsi # 0x9fc0
callq 0x21a0
jmp 0x5186
movq -0x1c0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x2230
jmp 0x519b
leaq -0x188(%rbp), %rdi
callq 0x2070
movq -0x1b8(%rbp), %rax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2070
movq -0x198(%rbp), %rdi
callq 0x2240
nopw %cs:(%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | AlberTTreblA[P]HighPerformanceConcurrentServer/log/pr.cpp |
10,092 | tid_to_ll(std::thread::id const&) | long long tid_to_ll(const thread::id& tid)
{
return atoll(tid_to_string(tid).c_str());
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5110
leaq -0x28(%rbp), %rdi
callq 0x52b0
movq %rax, %rdi
callq 0x2130
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52e0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | AlberTTreblA[P]HighPerformanceConcurrentServer/log/pr.cpp |
10,093 | std::basic_ostream<char, std::char_traits<char>>& std::operator<<<char, std::char_traits<char>>(std::basic_ostream<char, std::char_traits<char>>&, std::thread::id) | inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
{
if (__id == thread::id())
return __out << "thread::id of a non-executing thread";
else
return __out << __id._M_thread;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3e70
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3e50
testb $0x1, %al
jne 0x5274
jmp 0x528a
movq -0x18(%rbp), %rdi
leaq 0x1417(%rip), %rsi # 0x6696
callq 0x2170
movq %rax, -0x8(%rbp)
jmp 0x529b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/thread |
10,094 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::c_str() const | const _CharT*
c_str() const _GLIBCXX_NOEXCEPT
{ return _M_data(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5320
movq %rax, -0x10(%rbp)
jmp 0x52cb
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,095 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::~basic_string() | ~basic_string()
{ _M_dispose(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5340
jmp 0x52fb
movq -0x10(%rbp), %rdi
callq 0x5370
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3cd0
nopw %cs:(%rax,%rax)
nopl (%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,096 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_data() const | pointer
_M_data() const
{ return _M_dataplus._M_p; } | 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)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,097 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_dispose() | void
_M_dispose()
{
if (!_M_is_local())
_M_destroy(_M_allocated_capacity);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5390
testb $0x1, %al
jne 0x536a
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x53d0
addq $0x10, %rsp
popq %rbp
retq
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,098 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_Alloc_hider::~_Alloc_hider() | _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
: allocator_type(__a), _M_p(__dat) { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
10,099 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>::_M_is_local() const | bool
_M_is_local() const
{ return _M_data() == _M_local_data(); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5320
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x5420
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| AlberTTreblA[P]HighPerformanceConcurrentServer[P]build_O0[P]log[P]tests[P]q_test.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/basic_string.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.