name string | code string | asm string | file string |
|---|---|---|---|
main | int main(int, char* [])
{
auto employees = std::vector<Employee>{
{"Fatih", Male, 35, 8500},
{"Elif", Female, 28, 6350},
{"Erkin", Male, 43, 9500},
{"Mehmet", Male, 46, 10500},
{"Melis", Female, 48, 12500},
};
// Q1) (5pts) Make employee directly sendable to the ... | pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp # imm = 0x430
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x149(%rbp)
leaq -0x128(%rbp), %rax
movq %rax, -0x320(%rbp)
movq %rax, -0x130(%rbp)
leaq -0x131(%rbp), %rdi
movq %rdi, -0x318(%rbp)
callq 0x10240
movq -0x320(%rbp), %rdi
m... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
auto filter<std::vector<Employee, std::allocator<Employee>>, main::$_1>(std::vector<Employee, std::allocator<Employee>> const&, main::$_1) | auto filter(const Container& container, Func func)
{
auto c = Container();
for(const auto& item : container)
if(func(item))
c.push_back(item);
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x100c0
leaq -0x30(%rbp), %rdi
callq 0x12020
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp)... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
auto transform<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Employee, std::allocator<Employee>>, main::$_3>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Employee, std::allocator<Employee>>, std::less<std::__cxx11::bas... | auto transform(const std::map<Key, Value>& container, Func func)
{
using Pair = decltype(func(*container.begin()));
using NewKey = decltype(Pair().first);
using NewValue = decltype(Pair().second);
auto c = std::map<NewKey, NewValue>();
for(const auto& item : container)
{
auto pair = fun... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x100c0
leaq -0x48(%rbp), %rdi
callq 0x15e80
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp)... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::vector<Employee, std::allocator<Employee>>>(std::vector<Employee, std::allocator<Employee>> const&) | void print(const Container& c)
{
auto sz = c.size();
auto i = decltype(sz)(0);
for(const auto& item : c)
{
std::cout << "[" << item << "]";
if(i++ != sz-1)
std::cout << "; ";
}
std::cout << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12f80
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12040
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12070
movq %rax, -0x30(%rbp)
leaq -0... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Employee, std::allocator<Employee>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Employee, std::allocator<Employee>>, std::less<std::__cxx11::basic_string<char,... | void print(const std::map<Key, Value>& m)
{
for(const auto& [key, value] : m)
{
std::cout << "<" << key << ">: ";
print(value);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15ea0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15ed0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x15f00
xorb $-0x1, %al
testb $0x1, %... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std:... | void print(const std::map<Key, Value>& m)
{
for(const auto& [key, value] : m)
{
std::cout << "<" << key << ">: ";
print(value);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18870
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x188a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x188d0
xorb $-0x1, %al
testb $0x1, %... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
auto reverse<std::array<float, 4ul>>(std::array<float, 4ul> const&) | auto reverse(const Container& container)
{
auto c = container;
auto sz = c.size();
for(auto i=0; i<sz/2; ++i)
{
auto t = c[i];
c[i] = c[sz-i-1];
c[sz-i-1] = t;
}
return c;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x17670
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq %rcx
cmpq... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::array<int, 3ul>>(std::array<int, 3ul> const&) | void print(const Container& c)
{
auto sz = c.size();
auto i = decltype(sz)(0);
for(const auto& item : c)
{
std::cout << "[" << item << "]";
if(i++ != sz-1)
std::cout << "; ";
}
std::cout << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18b60
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18b70
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18b90
movq %rax, -0x30(%rbp)
movq -0... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::array<float, 4ul>>(std::array<float, 4ul> const&) | void print(const Container& c)
{
auto sz = c.size();
auto i = decltype(sz)(0);
for(const auto& item : c)
{
std::cout << "[" << item << "]";
if(i++ != sz-1)
std::cout << "; ";
}
std::cout << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17670
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18cc0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18ce0
movq %rax, -0x30(%rbp)
movq -0... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
void print<std::vector<float, std::allocator<float>>>(std::vector<float, std::allocator<float>> const&) | void print(const Container& c)
{
auto sz = c.size();
auto i = decltype(sz)(0);
for(const auto& item : c)
{
std::cout << "[" << item << "]";
if(i++ != sz-1)
std::cout << "; ";
}
std::cout << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x178c0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17a10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17a40
movq %rax, -0x30(%rbp)
leaq -0... | /furkankirac[P]cs321-2020-21-fall/week8-midterm.cpp |
server::gobang::quit(server::player*) | int quit(player* role) {
assert(players_.find(role->userid_) != players_.end());
role->set_game(nullptr);
players_.erase(role->userid_);
quit_ntf ntf = { 0 };
ntf.userid = role->userid_;
strcpy(ntf.name, role->name_);
broadcast(MSG_QUI... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
movq 0x138(%rdi), %rdx
leaq 0x130(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x605e
movl (%rsi), %edi
movq %rax, %rcx
xorl %r8d, %r8d
cmpl %edi, 0x20(%rdx)
setl %r8b
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%r8,8), %rdx
tes... | /jinjiazhang[P]protonet/sample/server.cpp |
QTestEventLoop::qt_static_metacall(QObject*, QMetaObject::Call, int, void**) | void QTestEventLoop::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QTestEventLoop *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->exitLoop(); break;
default: ;
}
}
(void)_a;
} | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x1ab15
movl 0x18(%rsp), %eax
testl %eax, %eax
jne 0x1ab11
jmp 0x1ab05
movq 0x8(%rsp), %rdi
callq 0x1acf0
jmp 0x1ab13
jmp 0x1ab13
jmp 0x1a... | /qt[P]qtbase/build_O0/src/testlib/Test_autogen/EWIEGA46WW/moc_qtesteventloop.cpp |
QTestEventLoop::qt_metacall(QMetaObject::Call, int, void**) | int QTestEventLoop::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 1)
qt_static_metacall(this, _c, _id, _a);
_id -= 1;
}
if (_c == QMeta... | endbr64
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0x1a7f0
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rs... | /qt[P]qtbase/build_O0/src/testlib/Test_autogen/EWIEGA46WW/moc_qtesteventloop.cpp |
auto QtPrivate::invokeMethodHelper<>(QMetaMethodReturnArgument) | inline auto invokeMethodHelper(QMetaMethodReturnArgument r, const Args &... arguments)
{
std::array params = { const_cast<const void *>(r.data), Invoke::dataHelper(arguments)... };
std::array names = { r.name, Invoke::typenameHelper(arguments)... };
std::array types = { r.metaType, Invoke::metaTypeHelper(ar... | endbr64
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rax
movq %fs:0x28, %rcx
movq %rcx, 0x20(%rsp)
movabsq $-0x5555555555555556, %rcx # imm = 0xAAAAAAAAAAAAAAAA
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq... | /qt[P]qtbase/src/corelib/kernel/qobjectdefs.h |
QAbstractTestLogger::filterUnprintable(char*) const | void QAbstractTestLogger::filterUnprintable(char *str) const
{
unsigned char *idx = reinterpret_cast<unsigned char *>(str);
while (*idx) {
if (((*idx < 0x20 && *idx != '\n' && *idx != '\t') || *idx == 0x7f))
*idx = '?';
++idx;
}
} | endbr64
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1b65e
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jge 0x1b639
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x1b639
movq -0x18(%rsp), %rax
movz... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QAbstractTestLogger::outputString(char const*) | void QAbstractTestLogger::outputString(const char *msg)
{
QTEST_ASSERT(stream);
QTEST_ASSERT(msg);
char *filtered = new char[strlen(msg) + 1];
strcpy(filtered, msg);
filterUnprintable(filtered);
::fputs(filtered, stream);
::fflush(stream);
delete [] filtered;
} | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x1b685
jmp 0x1b69d
leaq 0x95af0(%rip), %rdi # 0xb117c
leaq 0x95af0(%rip), %rsi # 0xb1183
movl $0xc6, %edx
callq 0x18830
cmpq $0x0, 0x18(%rsp)
je 0x1b6a7
jmp 0x1b6bf
leaq 0x95b... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QAbstractTestLogger::addMessage(QtMsgType, QMessageLogContext const&, QString const&) | void QAbstractTestLogger::addMessage(QtMsgType type, const QMessageLogContext &context,
const QString &message)
{
QAbstractTestLogger::MessageTypes messageType = [=]() {
switch (type) {
case QtDebugMsg: return QAbstractTestLogger::QDebug;
case QtInfoMsg: ... | endbr64
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x6c(%rsp)
leaq 0x6c(%rsp), %rdi
callq 0x1b960
movl %eax, 0x2c(%rsp)
movabsq $-0x55555555... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QTest::qt_asprintf(QTestCharBuffer*, char const*, ...) | int qt_asprintf(QTestCharBuffer *str, const char *format, ...)
{
Q_ASSERT(str);
int size = str->size();
Q_ASSERT(size > 0);
va_list ap;
int res = 0;
do {
va_start(ap, format);
res = std::vsnprintf(str->data(), size, format, ap);
va_end(ap);
// vsnprintf() reliab... | endbr64
subq $0x108, %rsp # imm = 0x108
testb %al, %al
je 0x1ba13
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
m... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QTestPrivate::generateTestIdentifier(QTestCharBuffer*, int) | void generateTestIdentifier(QTestCharBuffer *identifier, int parts)
{
const char *testObject = parts & TestObject ? QTestResult::currentTestObjectName() : "";
const char *testFunction = parts & TestFunction ? (QTestResult::currentTestFunction() ? QTestResult::currentTestFunction() : "UnknownTestFunc") : "";
... | endbr64
pushq %rbx
subq $0xb0, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1bbd6
callq 0x19640
movq %rax, 0x58(%rsp)
jmp 0x1bbe4
leaq 0x9ac3c(%rip), %rax # 0xb6819
movq %rax, 0x58(%rsp)
jmp 0x1bbe4
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movl 0xa4(... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QTestPrivate::appendCharBuffer(QTestCharBuffer*, QTestCharBuffer const&) | bool appendCharBuffer(QTestCharBuffer *accumulator, const QTestCharBuffer &more)
{
const auto bufsize = [](const QTestCharBuffer &buf) -> int {
const int max = buf.size();
return max > 0 ? int(qstrnlen(buf.constData(), max)) : 0;
};
const int extra = bufsize(more);
if (extra <= 0)
... | endbr64
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb 0x95302(%rip), %al # 0xb1128
movb %al, 0x3f(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x3f(%rsp), %rdi
callq 0x1bf10
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jg 0x1be4e
movb $0x1, 0x3e(%rsp)
jmp 0x1bee3
mo... | /qt[P]qtbase/src/testlib/qabstracttestlogger.cpp |
QTestCharBuffer::reset(int, bool) | bool reset(int newSize, bool copy = false)
{
char *newBuf = nullptr;
if (buf == staticBuf) {
// if we point to our internal buffer, we need to malloc first
newBuf = reinterpret_cast<char *>(malloc(newSize));
if (copy && newBuf)
qstrncpy(newBuf, buf... | endbr64
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x1c19d
movslq 0x14(%rsp), %rdi
callq 0x19ec0
movq %rax, 0x8(%rsp)
testb $0x1, 0x1... | /qt[P]qtbase/src/testlib/qabstracttestlogger_p.h |
QBenchmarkGlobalData::createMeasurer() | QBenchmarkMeasurerBase * QBenchmarkGlobalData::createMeasurer()
{
QBenchmarkMeasurerBase *measurer = nullptr;
if (0) {
#if QT_CONFIG(valgrind)
} else if (mode_ == CallgrindChildProcess || mode_ == CallgrindParentProcess) {
measurer = new QBenchmarkCallgrindMeasurer;
#endif
#ifdef QTESTLIB_USE_PERF_E... | endbr64
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x48(%rsp)
cmpl $0x2, 0x6c(%rax)
je 0x1eec1
movq 0x30(%rsp), %rax
cmpl $0x1, 0x6c(%rax)
jne 0x1eee7
movl $0x8, %edi
callq 0x18850
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
callq 0x1f850
movq 0x28(%rsp), %rax
movq %rax, 0x4... | /qt[P]qtbase/src/testlib/qbenchmark.cpp |
QBenchmarkTestMethodData::setResults(QList<QBenchmarkMeasurerBase::Measurement> const&, bool) | void QBenchmarkTestMethodData::setResults(const QList<QBenchmarkMeasurerBase::Measurement> &list,
bool setByMacro)
{
bool accepted = false;
QBenchmarkMeasurerBase::Measurement firstMeasurement = {};
if (!list.isEmpty())
firstMeasurement = list.constFirst();
... | endbr64
subq $0x88, %rsp
movb %dl, %al
movq %fs:0x28, %rcx
movq %rcx, 0x80(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x1f(%rsp)
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x18d10
movq 0x20(%rsp), %rdi
cal... | /qt[P]qtbase/src/testlib/qbenchmark.cpp |
bool QtPrivate::q_points_into_range<QArrayDataPointer<QBenchmarkResult>, QBenchmarkResult const*>(QBenchmarkResult const* const&, QArrayDataPointer<QBenchmarkResult> const&) | static constexpr bool q_points_into_range(const T &p, const C &c) noexcept
{
static_assert(std::is_same_v<decltype(std::data(c)), T>);
// std::distance because QArrayDataPointer has a "qsizetype size"
// member but no size() function
return q_points_into_range(p, std::data(c),
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22160
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22160
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22200
movq %rax, 0x28(%rsp)
jmp 0x1f6ca
movq 0x38(%... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QList<QBenchmarkResult>::~QList() | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x200c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QBenchmarkResult>::reserve(long long) | void QList<T>::reserve(qsizetype asize)
{
// capacity() == 0 for immutable data, so this will force a detaching below
if (asize <= capacity() - d.freeSpaceAtBegin()) {
if (d->flags() & Data::CapacityReserved)
return; // already reserved, don't shrink
if (!d->isShared()) {
... | endbr64
subq $0xa8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
callq 0x207a0
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x207c0
movq 0x38(%rsp), %rcx
movq %rax, %rdx
movq 0x40(%... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QtPrivate::QMovableArrayOps<QBenchmarkResult>::Inserter::~Inserter() | ~Inserter() {
auto inserts = nInserts;
if constexpr (!std::is_nothrow_copy_constructible_v<T>) {
if (displaceFrom != displaceTo) {
::memmove(static_cast<void *>(displaceFrom), static_cast<void *>(displaceTo), bytes);
inserts -= qAbs(displac... | endbr64
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq (%rax), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
retq
nopl (%rax,%rax)
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QBenchmarkResult>::allocateGrow(QArrayDataPointer<QBenchmarkResult> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax bel... | endbr64
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x20c00
movq 0x3... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QBenchmarkPerfEventsMeasurer::listCounters() | void QBenchmarkPerfEventsMeasurer::listCounters()
{
if (!isAvailable()) {
printf("Performance counters are not available on this system\n");
return;
}
printf("The following performance counters are available:\n");
for (const Events &ev : eventlist) {
printf(" %-30s [%s]\n", eve... | endbr64
subq $0x48, %rsp
callq 0x234a0
testb $0x1, %al
jne 0x238a4
leaq 0x8f213(%rip), %rdi # 0xb2aab
movb $0x0, %al
callq 0x18620
jmp 0x239b5
leaq 0x8f237(%rip), %rdi # 0xb2ae2
movb $0x0, %al
callq 0x18620
leaq 0x8e367(%rip), %rax # 0xb1c20
movq %rax, 0x40(%rsp)
leaq 0x8e35b(%rip), %rax # 0xb1c20
movq ... | /qt[P]qtbase/src/testlib/qbenchmarkperfevents.cpp |
QBenchmarkPerfEventsMeasurer::~QBenchmarkPerfEventsMeasurer() | QBenchmarkPerfEventsMeasurer::~QBenchmarkPerfEventsMeasurer()
{
for (int fd : std::as_const(fds))
qt_safe_close(fd);
} | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xc330c(%rip), %rcx # 0xe6d38
addq $0x10, %rcx
movq %rcx, (%rax)
movabsq $-0x5555555555555556, %rcx # imm = 0xAAAAAAAAAAAAAAAA
movq %rcx, 0x28(%rsp)
addq $0x8, %rax
movq %rax, 0x... | /qt[P]qtbase/src/testlib/qbenchmarkperfevents.cpp |
QBenchmarkPerfEventsMeasurer::start() | void QBenchmarkPerfEventsMeasurer::start()
{
QT_WARNING_DISABLE_GCC("-Wmissing-field-initializers")
QT_WARNING_DISABLE_CLANG("-Wmissing-field-initializers")
perf_event_attr attr = {
.size = sizeof attr,
.read_format = PERF_FORMAT_TOTAL_TIME_ENABLED | PERF_FORMAT_TOTAL_TIME_RUNNING,
.... | endbr64
subq $0x138, %rsp # imm = 0x138
movq %fs:0x28, %rax
movq %rax, 0x130(%rsp)
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x18d10
movl $0x88, 0xac(%rsp)
movq $0x3, 0xc8(%rsp)
movb $0x7, 0xd0(%rsp)
movb $0x28, 0xd1(%rsp)
mo... | /qt[P]qtbase/src/testlib/qbenchmarkperfevents.cpp |
QBenchmarkPerfEventsMeasurer::stop() | QList<QBenchmarkMeasurerBase::Measurement> QBenchmarkPerfEventsMeasurer::stop()
{
// disable the counters
prctl(PR_TASK_PERF_EVENTS_DISABLE);
const QList<PerfEvent> &counters = *eventTypes;
QList<Measurement> result(counters.size(), {});
for (qsizetype i = 0; i < counters.size(); ++i) {
res... | endbr64
subq $0x98, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x1f, %edi
movb $0x0, %al
callq 0x19e70
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAA... | /qt[P]qtbase/src/testlib/qbenchmarkperfevents.cpp |
rawReadValue(int) | static quint64 rawReadValue(int fd)
{
/* from the kernel docs:
* struct read_format {
* { u64 value;
* { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
* { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
* { u64 id; } && PER... | subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movl %edi, 0x2c(%rsp)
movq 0x8e6eb(%rip), %rax # 0xb29e8
movq %rax, 0x38(%rsp)
movq 0x8e6e7(%rip), %rax # 0xb29f0
movq %rax, 0x40(%rsp)
movq 0x8e6e3(%rip), %rax # 0xb29f8
movq %rax, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x18, 0x20(%rsp)
jae 0x24386... | /qt[P]qtbase/src/testlib/qbenchmarkperfevents.cpp |
QtGlobalStatic::Holder<(anonymous namespace)::Q_QGS_eventTypes>::~Holder() | ~Holder()
{
// TSAN does not support atomic_thread_fence and GCC complains:
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97868
// https://github.com/google/sanitizers/issues/1352
// QTBUG-134415
QT_WARNING_PUSH
#if defined(Q_CC_GNU_ONLY) && Q_CC_GNU >= 1100
QT_WARNING_DISABLE_GCC(... | endbr64
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x24660
movq 0x10(%rsp), %rax
leaq 0x8d5b3(%rip), %rcx # 0xb1c00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%... | /qt[P]qtbase/src/corelib/global/qglobalstatic.h |
bool QtPrivate::q_points_into_range<QArrayDataPointer<int>, int const*>(int const* const&, QArrayDataPointer<int> const&) | static constexpr bool q_points_into_range(const T &p, const C &c) noexcept
{
static_assert(std::is_same_v<decltype(std::data(c)), T>);
// std::distance because QArrayDataPointer has a "qsizetype size"
// member but no size() function
return q_points_into_range(p, std::data(c),
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x28c70
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x28c70
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x28d10
movq %rax, 0x28(%rsp)
jmp 0x2485a
movq 0x38(%... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QList<PerfEvent>::clear() | void clear() {
if (!size())
return;
if (d->needsDetach()) {
// must allocate memory
DataPointer detached(d.allocatedCapacity());
d.swap(detached);
} else {
d->truncate(0);
}
} | endbr64
subq $0x38, %rsp
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x25250
cmpq $0x0, %rax
jne 0x24985
jmp 0x24a12
movq 0x8(%rsp), %rdi
callq 0x25be0
movq %rax, %rdi
callq 0x26610
testb $0x1, %al
jne 0x2499d
jmp 0x249fc
movq 0x8(%rsp), %rdi
movq 0x8... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<int>::~QList() | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x259d0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<PerfEvent>::~QList() | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x26060
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QtPrivate::QPodArrayOps<PerfEvent>::copyAppend(PerfEvent const*, PerfEvent const*) | void copyAppend(const T *b, const T *e) noexcept
{
Q_ASSERT(this->isMutable() || b == e);
Q_ASSERT(!this->isShared() || b == e);
Q_ASSERT(b <= e);
Q_ASSERT((e - b) <= this->freeSpaceAtEnd());
if (b == e)
return;
::memcpy(static_cast<void *>(this->end()),... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x25c1f
jmp 0x25c69
movq 0x8(%rsp), %rdi
callq 0x25e00
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
s... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QTypedArrayData<PerfEvent>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x10, %edx
movq %rdx, %rsi
call... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
void QAtomicOps<signed char>::storeRelaxed<signed char>(std::atomic<signed char>&, signed char) | static inline
void storeRelaxed(std::atomic<T> &_q_value, T newValue) noexcept
{
_q_value.store(newValue, std::memory_order_relaxed);
} | endbr64
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rcx
movb 0x17(%rsp), %al
movq %rcx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x20e70
movl %... | /qt[P]qtbase/src/corelib/thread/qatomic_cxx11.h |
void QAtomicOps<signed char>::storeRelease<signed char>(std::atomic<signed char>&, signed char) | static inline
void storeRelease(std::atomic<T> &_q_value, T newValue) noexcept
{
_q_value.store(newValue, std::memory_order_release);
} | endbr64
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rcx
movb 0x17(%rsp), %al
movq %rcx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl $0x3, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x28(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x20e70
movl %... | /qt[P]qtbase/src/corelib/thread/qatomic_cxx11.h |
QArrayDataPointer<PerfEvent>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, PerfEvent const**) | bool tryReadjustFreeSpace(QArrayData::GrowthPosition pos, qsizetype n, const T **data = nullptr)
{
Q_ASSERT(!this->needsDetach());
Q_ASSERT(n > 0);
Q_ASSERT((pos == QArrayData::GrowsAtEnd && this->freeSpaceAtEnd() < n)
|| (pos == QArrayData::GrowsAtBeginning && this->freeSpa... | endbr64
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x27140
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x26ac0
movq 0x10(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<PerfEvent>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<PerfEvent>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old &... | endbr64
subq $0x98, %rsp
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x26f34
cmpq $0x0, 0x58(%rsp)
jne 0x26f34
movq 0x38(%rsp), %rdi
callq 0x26610
testb $0x1, %al
j... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<PerfEvent>::relocate(long long, PerfEvent const**) | void relocate(qsizetype offset, const T **data = nullptr)
{
T *res = this->ptr + offset;
QtPrivate::q_relocate_overlap_n(this->ptr, this->size, res);
// first update data pointer, then this->ptr
if (data && QtPrivate::q_points_into_range(*data, *this))
*data += offset;
... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x27220
cmpq $0x0, 0x10... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<PerfEvent, long long>(PerfEvent*, long long, PerfEvent*) | void q_relocate_overlap_n(T *first, N n, T *d_first)
{
static_assert(std::is_nothrow_destructible_v<T>,
"This algorithm requires that T has a non-throwing destructor");
if (n == N(0) || first == d_first || first == nullptr || d_first == nullptr)
return;
if constexpr (QTypeInfo<T>... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27258
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
je 0x27258
cmpq $0x0, 0x10(%rsp)
je 0x27258
cmpq $0x0, (%rsp)
jne 0x2725a
jmp 0x27271
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<PerfEvent>::allocateGrow(QArrayDataPointer<PerfEvent> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax bel... | endbr64
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x27140
movq 0x3... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QPodArrayOps<int>::copyAppend(int const*, int const*) | void copyAppend(const T *b, const T *e) noexcept
{
Q_ASSERT(this->isMutable() || b == e);
Q_ASSERT(!this->isShared() || b == e);
Q_ASSERT(b <= e);
Q_ASSERT((e - b) <= this->freeSpaceAtEnd());
if (b == e)
return;
::memcpy(static_cast<void *>(this->end()),... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x27dff
jmp 0x27e49
movq 0x8(%rsp), %rdi
callq 0x27e70
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
s... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QTypedArrayData<int>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x4, %esi
movl $0x10, %edx
call... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
QPlainTestLogger::outputMessage(char const*) | void QPlainTestLogger::outputMessage(const char *str)
{
#if defined(Q_OS_WIN)
// Log to system log only if output is not redirected and stderr not preferred
if (stream == stdout && !QtPrivate::shouldLogToStderr()) {
OutputDebugStringA(str);
return;
}
#elif defined(Q_OS_ANDROID)
__android... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x19c20
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
QPlainTestLogger::printBenchmarkResultsHeader(QBenchmarkResult const&) | void QPlainTestLogger::printBenchmarkResultsHeader(const QBenchmarkResult &result)
{
FixedBufString<1022> buf;
buf.appendf("%s: %s::%s", QTest::benchmarkResult2String(),
QTestResult::currentTestObjectName(), result.context.slotName.toLatin1().data());
QByteArray tag = QTestResult::currentDa... | endbr64
subq $0x4e8, %rsp # imm = 0x4E8
movq %fs:0x28, %rax
movq %rax, 0x4e0(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0xaa, %esi
movl $0x408, %edx # imm = 0x408
callq 0x18d10
movq 0x38(%rsp), %rd... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
QPlainTestLogger::printBenchmarkResults(QList<QBenchmarkResult> const&) | void QPlainTestLogger::printBenchmarkResults(const QList<QBenchmarkResult> &results)
{
using namespace std::chrono;
FixedBufString<1022> buf;
auto findResultFor = [&results](QTest::QBenchmarkMetric metric) -> std::optional<qreal> {
for (const QBenchmarkResult &result : results) {
if (res... | endbr64
subq $0x518, %rsp # imm = 0x518
movq %fs:0x28, %rax
movq %rax, 0x510(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x108(%rsp), %rdi
movl $0xaa, %esi
movl $0x408, %edx # imm = 0x408
callq 0x18d10
leaq 0x108(%rsp), %rdi
callq 0x2fab0
movq... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
int QTest::countSignificantDigits<double>(double) | static int countSignificantDigits(T num)
{
if (num <= 0)
return 0;
int digits = 0;
qreal divisor = 1;
while (num / divisor >= 1) {
divisor *= 10;
++digits;
}
return digits;
} | movsd %xmm0, -0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jb 0x3040b
movl $0x0, -0x4(%rsp)
jmp 0x30464
movl $0x0, -0x14(%rsp)
movsd 0x82bad(%rip), %xmm0 # 0xb2fc8
movsd %xmm0, -0x20(%rsp)
movsd -0x10(%rsp), %xmm0
divsd -0x20(%rsp), %xmm0
movsd 0x82b93(%rip), %xmm1 # 0xb2fc8
ucomisd %xmm1, %xmm0
jb 0x... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
void (anonymous namespace)::FixedBufString<1022>::appendScaled<1000>(double, char const*) | void appendScaled(qreal value, const char *unit)
{
char prefix[2] = {};
qreal v = qAbs(value);
qint64 ratio;
if (v < 1 && Power == 1000) {
const char *prefixes = submultiplePrefixes;
ratio = qreal(std::atto::num) / qreal(std::atto::den);
while (val... | subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4e(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x18d10
leaq 0x40(%rsp), %rdi
callq 0x323e0
movsd %xmm0, 0x28(%rsp)
movabsq $-0x5555555555... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
void (anonymous namespace)::FixedBufString<1022>::appendScaled<1024>(double, char const*) | void appendScaled(qreal value, const char *unit)
{
char prefix[2] = {};
qreal v = qAbs(value);
qint64 ratio;
if (v < 1 && Power == 1000) {
const char *prefixes = submultiplePrefixes;
ratio = qreal(std::atto::num) / qreal(std::atto::den);
while (val... | subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x40(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4e(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x18d10
leaq 0x40(%rsp), %rdi
callq 0x323e0
movsd %xmm0, 0x28(%rsp)
movabsq $-0x5555555555... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
QPlainTestLogger::stopLogging() | void QPlainTestLogger::stopLogging()
{
char buf[1024];
const int timeMs = qRound(QTestLog::msecsTotalTime());
if (QTestLog::verboseLevel() < 0) {
std::snprintf(buf, sizeof(buf),
"Totals: %d passed, %d failed, %d skipped, %d blacklisted, %dms\n",
QTestLog::... | endbr64
subq $0x478, %rsp # imm = 0x478
movq %fs:0x28, %rax
movq %rax, 0x470(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x70(%rsp), %rdi
movl $0xaa, %esi
movl $0x400, %edx # imm = 0x400
callq 0x18d10
callq 0x2c680
callq 0x318d0
movl %eax, 0x64(%rsp)
callq 0x18ef0
... | /qt[P]qtbase/src/testlib/qplaintestlogger.cpp |
long long QtPrivate::lengthHelperPointer<char>(char const*) | static constexpr qsizetype lengthHelperPointer(const Char *data) noexcept
{
// std::char_traits can only be used with one of the regular char types
// (char, char16_t, wchar_t, but not uchar or QChar), so we roll the loop
// out by ourselves.
qsizetype i = 0;
if (!data)
return i;
while (... | movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x311a2
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x311d1
jmp 0x311a4
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x311c7
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x311a... | /qt[P]qtbase/src/corelib/text/qbytearrayview.h |
int QtPrivate::qCheckedFPConversionToInteger<int, double, true, true>(double) | constexpr inline Result qCheckedFPConversionToInteger(FP value)
{
#ifdef QT_SUPPORTS_IS_CONSTANT_EVALUATED
if (!q20::is_constant_evaluated())
Q_ASSERT(!std::isnan(value));
#endif
constexpr Result minimal = (std::numeric_limits<Result>::min)();
constexpr Result maximal = (std::numeric_limits<Result>... | endbr64
movsd %xmm0, -0x8(%rsp)
movl $0x80000000, -0xc(%rsp) # imm = 0x80000000
movl $0x7fffffff, -0x10(%rsp) # imm = 0x7FFFFFFF
movsd 0x811e6(%rip), %xmm0 # 0xb2fd8
movsd %xmm0, -0x18(%rsp)
cvttsd2si -0x8(%rsp), %eax
retq
nop
| /qt[P]qtbase/src/corelib/global/qnumeric.h |
QSignalSpy::QSignalSpy(QSignalSpy::ObjectSignal) | QSignalSpy::QSignalSpy(ObjectSignal os)
: sig(os.sig.methodSignature()),
args(os.obj ? makeArgs(os.sig) : QList<int>{})
{
if (!os.obj)
return;
auto i = std::make_unique<QSignalSpyPrivate>(this);
const auto signalIndex = os.sig.methodIndex();
const auto slotIndex = QObject::staticMeta... | endbr64
subq $0xe8, %rsp
leaq 0xf0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xe0(%rsp)
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x37e30
movq 0x60(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x58(%rsp)
callq 0x37e50
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
addq $0x20... | /qt[P]qtbase/src/testlib/qsignalspy.cpp |
QSignalSpy::appendArgs(void**) | void QSignalSpy::appendArgs(void **a)
{
QList<QVariant> list;
list.reserve(args.size());
for (qsizetype i = 0; i < args.size(); ++i) {
const QMetaType::Type type = static_cast<QMetaType::Type>(args.at(i));
if (type == QMetaType::QVariant)
list << *reinterpret_cast<QVariant *>(a[i... | endbr64
subq $0xb8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x70(%rsp)
movups 0x7c332(%rip), %xmm0 # 0xb38c8
movaps %xmm0, 0x60(%rsp)
leaq 0x60(%rsp)... | /qt[P]qtbase/src/testlib/qsignalspy.cpp |
QSignalSpyPrivate::qt_metacall(QMetaObject::Call, int, void**) | int QSignalSpyPrivate::qt_metacall(QMetaObject::Call call, int methodId, void **a)
{
methodId = QObject::qt_metacall(call, methodId, a);
if (methodId < 0)
return methodId;
if (call == QMetaObject::InvokeMetaMethod) {
if (methodId == 0) {
q->appendArgs(a);
}
--met... | endbr64
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rcx
callq 0x1a7f0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x3781a
movl 0x10(%rsp), %eax
movl %eax, ... | /qt[P]qtbase/src/testlib/qsignalspy.cpp |
QList<QVariant>::reserve(long long) | void QList<T>::reserve(qsizetype asize)
{
// capacity() == 0 for immutable data, so this will force a detaching below
if (asize <= capacity() - d.freeSpaceAtBegin()) {
if (d->flags() & Data::CapacityReserved)
return; // already reserved, don't shrink
if (!d->isShared()) {
... | endbr64
subq $0xa8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
callq 0x39300
movq 0x30(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x39320
movq 0x38(%rsp), %rcx
movq %rax, %rdx
movq 0x40(%... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QArrayDataPointer<QList<QVariant>>::detachAndGrow(QArrayData::GrowthPosition, long long, QList<QVariant> const**, QArrayDataPointer<QList<QVariant>>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= ... | endbr64
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3b710
andb $0x1, %al
movb %al, 0xf(%rsp)
movb $0x0, 0xe(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x3b8f5
cmpq $0x0, 0x20(%rsp)
je 0x3b8d6
cmpl $0x1... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QTypedArrayData<QList<QVariant>>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x18, %esi
movl $0x10, %edx
cal... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
QTapTestLogger::endYamlish() | void QTapTestLogger::endYamlish()
{
// Flush any accumulated messages:
if (!m_messages.isEmpty()) {
outputString(YAML_INDENT "extensions:\n");
outputString(YAML_INDENT YAML_INDENT "messages:\n");
outputString(m_messages.constData());
m_messages.clear();
}
outputString(YAM... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x430, %rdi # imm = 0x430
callq 0x402c0
testb $0x1, %al
jne 0x3d708
movq 0x8(%rsp), %rdi
leaq 0x764bc(%rip), %rsi # 0xb3b7f
callq 0x19c20
movq 0x8(%rsp), %rdi
leaq 0x764ba(%rip), %rsi # 0xb3b8e
callq 0x19c... | /qt[P]qtbase/src/testlib/qtaptestlogger.cpp |
QTapTestLogger::addIncident(QAbstractTestLogger::IncidentTypes, char const*, char const*, int) | void QTapTestLogger::addIncident(IncidentTypes type, const char *description,
const char *file, int line)
{
const bool isExpectedFail = type == XFail || type == BlacklistedXFail;
const bool ok = (m_firstExpectedFail.isEmpty()
&& (type == Pass || type == Blac... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x13a8, %rsp # imm = 0x13A8
movq %fs:0x28, %rax
movq %rax, 0x13a0(%rsp)
movq %rdi, 0x2d8(%rsp)
movl %esi, 0x2d4(%rsp)
movq %rdx, 0x948(%rsp)
movq %rcx, 0x2c8(%rsp)
movl %r8d, 0x2c4(%rsp)
movq 0x2d8(%rsp), %rax
movq %rax, 0x248(%rsp)
movb $0x1, %al
cmpl... | /qt[P]qtbase/src/testlib/qtaptestlogger.cpp |
QTest::tcIncidentType2String(QAbstractTestLogger::IncidentTypes) | static const char *tcIncidentType2String(QAbstractTestLogger::IncidentTypes type)
{
switch (type) {
case QAbstractTestLogger::Skip:
return "SKIP";
case QAbstractTestLogger::Pass:
return "PASS";
case QAbstractTestLogger::XFail:
return "XFAIL";
... | movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x8, %rax
ja 0x42f8b
movq -0x18(%rsp), %rax
leaq 0x71211(%rip), %rcx # 0xb4114
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x70ded(%rip), %rax # 0xb3d01
movq %rax, -0x8(%rsp)
jmp 0x42f97
leaq 0x7141c(%rip), %rax # 0xb433... | /qt[P]qtbase/src/testlib/qteamcitylogger.cpp |
QTeamCityLogger::addMessage(QAbstractTestLogger::MessageTypes, QString const&, char const*, int) | void QTeamCityLogger::addMessage(MessageTypes type, const QString &message,
const char *file, int line)
{
// suppress non-fatal messages in silent mode
if (type != QFatal && QTestLog::verboseLevel() < 0)
return;
QTestCharBuffer escapedMessage;
tcEscapedString(&e... | endbr64
subq $0x298, %rsp # imm = 0x298
movq %fs:0x28, %rax
movq %rax, 0x290(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x4, 0x5c(%rsp)
je 0x43004
callq 0x18ef0
cmpl $0x0, %eax
jge 0x430... | /qt[P]qtbase/src/testlib/qteamcitylogger.cpp |
QTest::tcMessageType2String(QAbstractTestLogger::MessageTypes) | static const char *tcMessageType2String(QAbstractTestLogger::MessageTypes type)
{
switch (type) {
case QAbstractTestLogger::QDebug:
return "QDEBUG";
case QAbstractTestLogger::QInfo:
return "QINFO";
case QAbstractTestLogger::QWarning:
return "QWARN"... | movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x6, %rax
ja 0x431db
movq -0x18(%rsp), %rax
leaq 0x70fc9(%rip), %rcx # 0xb4138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x711de(%rip), %rax # 0xb435e
movq %rax, -0x8(%rsp)
jmp 0x431e7
leaq 0x711d7(%rip), %rax # 0xb436... | /qt[P]qtbase/src/testlib/qteamcitylogger.cpp |
QHashPrivate::Data<QHashPrivate::Node<QByteArray, QHashDummyValue>>::InsertionResult QHashPrivate::Data<QHashPrivate::Node<QByteArray, QHashDummyValue>>::findOrInsert<QByteArray>(QByteArray const&) | InsertionResult findOrInsert(const K &key) noexcept
{
Bucket it(static_cast<Span *>(nullptr), 0);
size_t hash = QHashPrivate::calculateHash(key, seed);
if (numBuckets > 0) {
it = findBucketWithHash(key, hash);
if (!it.isUnused())
return { it.toIterator... | endbr64
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x69b4e(%rip), %rax # 0xb1698
movq %rax, 0x50(%rsp)
movq 0x69b4a(%rip), %rax # 0xb16a0
movq %rax, 0x58(%rsp)
leaq... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QTest::TestMethods::invokeTestOnData(int) const | void TestMethods::invokeTestOnData(int index) const
{
/* Benchmarking: for each median iteration*/
bool isBenchmark = false;
int i = (QBenchmarkGlobalData::current->measurer->needsWarmupIteration()) ? -1 : 0;
QList<QList<QBenchmarkResult>> resultsList;
bool minimumTotalReached = false;
do {
... | endbr64
subq $0x1a8, %rsp # imm = 0x1A8
movq %fs:0x28, %rax
movq %rax, 0x1a0(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x70(%rsp)
movb $0x0, 0xcb(%rsp)
movq 0x9b7c1(%rip), %rax # 0xe8f08
movq (%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movb ... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::invokeTestMethodIfValid(QMetaMethod, QObject*) | static bool invokeTestMethodIfValid(QMetaMethod m, QObject *obj = QTest::currentTestObject)
{
if (!m.isValid())
return false;
bool ok = true;
try { ok = m.invoke(obj, Qt ::DirectConnection); }
catch (const TestFailedException &) {} // ignore (used for control flow)
catch (const TestSkippedE... | subq $0x68, %rsp
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x348e0
testb $0x1, %al
jne 0x4e029
movb $0x0, 0x4f(%rsp)
jmp 0x4e0ba
movb $0x1, 0x3f(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x1, %edx
callq 0x5ec80
m... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::qMedian(QList<QList<QBenchmarkResult>> const&) | static QList<QBenchmarkResult> qMedian(const QList<QList<QBenchmarkResult>> &container)
{
const int count = container.size();
if (count == 0)
return {};
if (count == 1)
return container.front();
QList<QList<QBenchmarkResult>> containerCopy = container;
std::sort(containerCopy.begin... | subq $0x98, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5ee90
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jne 0x4e224
movq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x18... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::TestMethods::invokeTest(int, QLatin1String, std::optional<QTest::WatchDog>&) const | bool TestMethods::invokeTest(int index, QLatin1StringView tag, std::optional<WatchDog> &watchDog) const
{
QBenchmarkTestMethodData benchmarkData;
QBenchmarkTestMethodData::current = &benchmarkData;
const QByteArray &name = m_methods[index].name();
QBenchmarkGlobalData::current->context.slotName = QLati... | endbr64
subq $0x568, %rsp # imm = 0x568
movq %fs:0x28, %rax
movq %rax, 0x560(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x298(%rsp)
movq %rdi, 0x110(%rsp)
movl %esi, 0x10c(%rsp)
movq %r8, 0x100(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xc0(%rsp)
movups 0x68e16(%rip), %xmm0 # 0xb71e0
movaps %xmm0, 0x280(%rsp)
... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::fetchData(QTestData*, char const*, int) | void *fetchData(QTestData *data, const char *tagName, int typeId)
{
QTEST_ASSERT(typeId);
QTEST_ASSERT_X(data, "QTest::fetchData()", "Test data requested, but no testdata available.");
QTEST_ASSERT(data->parent());
int idx = data->parent()->indexOf(tagName);
if (Q_UNLIKELY(idx == -1 || idx >= data... | endbr64
subq $0x98, %rsp
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x4f363
jmp 0x4f37b
leaq 0x672cf(%rip), %rdi # 0xb6639
leaq 0x671d3(%rip), %rsi # 0xb6544
movl $0x573, %edx # imm = 0x573
callq 0x18830
cmpq $0... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
toStringFp(double, int) | static char *toStringFp(double t, int digits10)
{
char *msg = new char[128];
switch (qFpClassify(t)) {
case FP_INFINITE:
qstrncpy(msg, (t < 0 ? "-inf" : "inf"), 128);
break;
case FP_NAN:
qstrncpy(msg, "nan", 128);
break;
default:
std::snprintf(msg, 128, "%.*g ... | subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
movl $0x80, %edi
callq 0x190b0
movq %rax, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x190c0
movl %eax, %ecx
movl %ecx, 0xc(%rsp)
testl %eax, %eax
je 0x577ef
jmp 0x577b4
movl 0xc(%rsp), %eax
subl $0x1, %eax
jne 0x57807
jmp 0x577bf
movq 0x10(%rsp), %rdi
movsd ... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
char* QTest::toString<double>(double const&) | Q_TESTLIB_EXPORT char *QTest::toString<char>(const char &t)
{
unsigned char c = static_cast<unsigned char>(t);
char *msg = new char[16];
switch (c) {
case 0x00:
qstrcpy(msg, "'\\0'");
break;
case 0x07:
qstrcpy(msg, "'\\a'");
break;
case 0x08:
qstrcpy(msg, ... | endbr64
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movsd (%rax), %xmm0
movl $0x10, %edi
callq 0x57780
popq %rcx
retq
nopl (%rax)
| /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::toString(char const*) | char *QTest::toString(const char *str)
{
if (!str) {
char *msg = new char[1];
*msg = '\0';
return msg;
}
char *msg = new char[strlen(str) + 1];
return qstrcpy(msg, str);
} | endbr64
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x57a68
movl $0x1, %edi
callq 0x190b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x57a97
movq 0x18(%rsp), %rdi
callq 0x18f80
movq %rax, %rdi
addq $0x1, %rdi
callq 0x190b0
movq %rax... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::toString(QObject const*) | char *QTest::toString(const QObject *o)
{
if (o == nullptr)
return qstrdup("<null>");
const QString &name = o->objectName();
const char *className = o->metaObject()->className();
char *msg = new char[256];
if (name.isEmpty())
std::snprintf(msg, 256, "%s/%p", className, o);
else
... | endbr64
subq $0xb8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movq %rdi, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x57b8f
leaq 0x5f150(%rip), %rdi # 0xb6cd0
callq 0x1a810
movq %rax, 0x78(%rsp)
jmp 0x57cee
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rsi
leaq... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
bool QtPrivate::q_points_into_range<QArrayDataPointer<QString>, QString const*>(QString const* const&, QArrayDataPointer<QString> const&) | static constexpr bool q_points_into_range(const T &p, const C &c) noexcept
{
static_assert(std::is_same_v<decltype(std::data(c)), T>);
// std::distance because QArrayDataPointer has a "qsizetype size"
// member but no size() function
return q_points_into_range(p, std::data(c),
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x5e3a0
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x5e3a0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x5e440
movq %rax, 0x28(%rsp)
jmp 0x5801a
movq 0x38(%... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QTypedArrayData<QString>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x18, %esi
movl $0x10, %edx
cal... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
QArrayDataPointer<QString>::detachAndGrow(QArrayData::GrowthPosition, long long, QString const**, QArrayDataPointer<QString>*) | void detachAndGrow(QArrayData::GrowthPosition where, qsizetype n, const T **data,
QArrayDataPointer *old)
{
const bool detach = needsDetach();
bool readjusted = false;
if (!detach) {
if (!n || (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= ... | endbr64
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5dc20
andb $0x1, %al
movb %al, 0xf(%rsp)
movb $0x0, 0xe(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x5dd65
cmpq $0x0, 0x20(%rsp)
je 0x5dd46
cmpl $0x1... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QString>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QString>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old &... | endbr64
subq $0x98, %rsp
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x5e0a4
cmpq $0x0, 0x58(%rsp)
jne 0x5e0a4
movq 0x38(%rsp), %rdi
callq 0x5dc20
testb $0x1, %al
j... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QString>::relocate(long long, QString const**) | void relocate(qsizetype offset, const T **data = nullptr)
{
T *res = this->ptr + offset;
QtPrivate::q_relocate_overlap_n(this->ptr, this->size, res);
// first update data pointer, then this->ptr
if (data && QtPrivate::q_points_into_range(*data, *this))
*data += offset;
... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rcx
imulq $0x18, 0x18(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x5e340
cmpq $0x0, 0x10(%rsp)
j... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QString, long long>(QString*, long long, QString*) | void q_relocate_overlap_n(T *first, N n, T *d_first)
{
static_assert(std::is_nothrow_destructible_v<T>,
"This algorithm requires that T has a non-throwing destructor");
if (n == N(0) || first == d_first || first == nullptr || d_first == nullptr)
return;
if constexpr (QTypeInfo<T>... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5e378
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
je 0x5e378
cmpq $0x0, 0x10(%rsp)
je 0x5e378
cmpq $0x0, (%rsp)
jne 0x5e37a
jmp 0x5e38e
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
imulq $0x18, 0x8(%rsp), %rdx
callq 0... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<QString>::allocateGrow(QArrayDataPointer<QString> const&, long long, QArrayData::GrowthPosition) | static QArrayDataPointer allocateGrow(const QArrayDataPointer &from, qsizetype n, QArrayData::GrowthPosition position)
{
// calculate new capacity. We keep the free capacity at the side that does not have to grow
// to avoid quadratic behavior with mixed append/prepend cases
// use qMax bel... | endbr64
subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movl %ecx, 0x74(%rsp)
movq 0x80(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
callq 0x5d560
movq 0x3... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QGenericArrayOps<QString>::moveAppend(QString*, QString*) | void moveAppend(T *b, T *e)
{
Q_ASSERT(this->isMutable() || b == e);
Q_ASSERT(!this->isShared() || b == e);
Q_ASSERT(b <= e);
Q_ASSERT((e - b) <= this->freeSpaceAtEnd());
if (b == e)
return;
T *data = this->begin();
while (b < e) {
ne... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x5e99e
jmp 0x5e9f3
movq (%rsp), %rdi
callq 0x5c880
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x5e9f3
movq (%rsp),... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QList<QBenchmarkResult>::QList(QList<QBenchmarkResult> const&) | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5f0f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QList<QBenchmarkResult>>::QList(QList<QList<QBenchmarkResult>> const&) | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5f170
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QBenchmarkResult>::QList(QList<QBenchmarkResult>&&) | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5f3b0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QBenchmarkResult>::operator=(QList<QBenchmarkResult>&&) | class QList
#ifndef Q_QDOC
: public QListSpecialMethods<T>
#endif
{
using Data = QTypedArrayData<T>;
using DataOps = QArrayDataOps<T>;
using DataPointer = QArrayDataPointer<T>;
class DisableRValueRefs {};
friend class ::tst_QList;
DataPointer d;
template <typename V, typename U> frien... | endbr64
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x5f5a0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QTest::WatchDog::setExpectation(QTest::WatchDog::Expectation) | void setExpectation(Expectation e)
{
Q_ASSERT(generation(e) == 0); // no embedded generation allowed
const auto locker = qt_scoped_lock(mutex);
auto cur = expecting.load(std::memory_order_relaxed);
auto gen = generation(cur);
if (e == TestFunctionStart)
++gen;
... | endbr64
subq $0x38, %rsp
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x50aa8(%rip), %rax # 0xb10d8
movq %rax, 0x28(%rsp)
addq $0x10, %rsi
leaq 0x28(%rsp), %rdi
callq 0x59c00
movq (%rsp), %rdi
addq $0x68, %rdi
xorl %esi, %esi
call... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::WatchDog::run() | void run() override
{
CrashHandler::blockUnixSignals();
auto locker = qt_unique_lock(mutex);
expecting.store(TestFunctionStart, std::memory_order_release);
waitCondition.notify_all();
while (true) {
Expectation e = expecting.load(std::memory_order_acquire);
... | endbr64
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x69680
movq 0x18(%rsp), %rsi
movq 0x5145a(%rip), %rax # 0xb1be0
movq %rax, 0x60(%rsp)
movq 0x51456(%rip), %rax # 0xb1be8
movq %rax, 0x68(%rsp)
addq $0x10, %rsi
leaq 0x60(%r... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
QTest::WatchDog::waitFor(std::unique_lock<std::mutex>&, QTest::WatchDog::Expectation) | bool waitFor(std::unique_lock<std::mutex> &m, Expectation e)
{
auto expectationChanged = [this, e] { return expecting.load(std::memory_order_relaxed) != e; };
switch (state(e)) {
case TestFunctionEnd:
return waitCondition.wait_for(m, defaultTimeout(), expectationChanged);
... | endbr64
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movups 0x51034(%rip), %xmm0 # 0xb1be0
movaps %xmm0, 0x70(%rsp)
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x28(%... | /qt[P]qtbase/src/testlib/qtestcase.cpp |
int QAtomicOps<int>::fetchAndAddRelaxed<int>(std::atomic<int>&, QAtomicAdditiveType<int>::AdditiveT) | static inline
T fetchAndAddRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
{
return _q_value.fetch_add(valueToAdd, std::memory_order_relaxed);
} | endbr64
movq %rdi, -0x20(%rsp)
movl %esi, -0x24(%rsp)
movq -0x20(%rsp), %rcx
movl -0x24(%rsp), %eax
movq %rcx, -0x8(%rsp)
movl %eax, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x38(%rsp)
movl -0x10(%rsp), %eax
movl -0xc(%rsp), %ecx
movl %ecx, -0x14(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x... | /qt[P]qtbase/src/corelib/thread/qatomic_cxx11.h |
bool QAnyStringView::isAsciiOnlyCharsAtCompileTime<char const>(char const*, long long) | static constexpr bool isAsciiOnlyCharsAtCompileTime(Char *str, qsizetype sz) noexcept
{
// do not perform check if not at compile time
if (!q20::is_constant_evaluated())
return false;
if constexpr (sizeof(Char) != sizeof(char)) {
Q_UNUSED(str);
Q_UNUSED(sz... | endbr64
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorl %eax, %eax
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /qt[P]qtbase/src/corelib/text/qanystringview.h |
bool QAnyStringView::isAsciiOnlyCharsAtCompileTime<QChar const>(QChar const*, long long) | static constexpr bool isAsciiOnlyCharsAtCompileTime(Char *str, qsizetype sz) noexcept
{
// do not perform check if not at compile time
if (!q20::is_constant_evaluated())
return false;
if constexpr (sizeof(Char) != sizeof(char)) {
Q_UNUSED(str);
Q_UNUSED(sz... | endbr64
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorl %eax, %eax
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /qt[P]qtbase/src/corelib/text/qanystringview.h |
QArrayDataPointer<QList<QBenchmarkResult>>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QList<QBenchmarkResult>>*) | Q_NEVER_INLINE void reallocateAndGrow(QArrayData::GrowthPosition where, qsizetype n,
QArrayDataPointer *old = nullptr)
{
if constexpr (QTypeInfo<T>::isRelocatable && alignof(T) <= alignof(std::max_align_t)) {
if (where == QArrayData::GrowsAtEnd && !old &... | endbr64
subq $0x98, %rsp
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x63c04
cmpq $0x0, 0x58(%rsp)
jne 0x63c04
movq 0x38(%rsp), %rdi
callq 0x63b20
testb $0x1, %al
j... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QGenericArrayOps<QList<QBenchmarkResult>>::moveAppend(QList<QBenchmarkResult>*, QList<QBenchmarkResult>*) | void moveAppend(T *b, T *e)
{
Q_ASSERT(this->isMutable() || b == e);
Q_ASSERT(!this->isShared() || b == e);
Q_ASSERT(b <= e);
Q_ASSERT((e - b) <= this->freeSpaceAtEnd());
if (b == e)
return;
T *data = this->begin();
while (b < e) {
ne... | endbr64
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x6433e
jmp 0x64393
movq (%rsp), %rdi
callq 0x5fe50
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x64393
movq (%rsp),... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QTypedArrayData<QList<QBenchmarkResult>>::allocate(long long, QArrayData::AllocationOption) | [[nodiscard]] static std::pair<QTypedArrayData *, T *> allocate(qsizetype capacity, AllocationOption option = QArrayData::KeepSize)
{
static_assert(sizeof(QTypedArrayData) == sizeof(QArrayData));
QArrayData *d;
void *result;
if constexpr (sizeof(T) == 1) {
// necessarily,... | endbr64
subq $0x58, %rsp
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
leaq 0x38(%rsp), %rdi
movl $0x18, %esi
movl $0x10, %edx
cal... | /qt[P]qtbase/src/corelib/tools/qarraydata.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.