name string | code string | asm string | file string |
|---|---|---|---|
void storeA2RGB30PMFromARGB32PM_sse4<(QtPixelOrder)0>(unsigned char*, unsigned int const*, int, int, QList<unsigned int> const*, QDitherInfo*) | void QT_FASTCALL storeA2RGB30PMFromARGB32PM_sse4(uchar *dest, const uint *src, int index, int count,
const QList<QRgb> *, QDitherInfo *)
{
uint *d = reinterpret_cast<uint *>(dest) + index;
for (int i = 0; i < count; ++i)
d[i] = qConvertArgb32ToA2rgb30_sse... | endbr64
testl %ecx, %ecx
jle 0x4ad425
pushq %rbx
movslq %edx, %rax
leaq (%rdi,%rax,4), %rax
movl %ecx, %ecx
xorl %edx, %edx
movl (%rsi,%rdx,4), %edi
movl %edi, %r8d
shrl $0x18, %r8d
je 0x4ad414
cmpl $0xff, %r8d
jne 0x4ad398
movl %edi, %r8d
shll $0x6, %r8d
andl $0x3fc00000, %r8d # imm = 0x3FC00000
movl %edi, %r9d
... | /qt[P]qtbase/src/gui/painting/qdrawhelper_sse4.cpp |
void qt_qimageScaleAARGBA_up_x_down_y_sse4<false>(QImageScale::QImageScaleInfo*, unsigned int*, int, int, int, int) | void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
int dw, int dh, int dow, int sow)
{
const unsigned int **ypoints = isi->ypoints;
const int *xpoints = isi->xpoints;
const int *xapoints = isi->xapoints;
const int *yapoints = i... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %ecx, %r15d
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
leaq 0xa0(%rsp), %rax
movq %rsi, (%rax)
leaq 0x9c(%rsp), %rcx
movl %edx, (%rcx)
leaq 0x98(%rsp), %rdx
movl %r8d, (%rdx)
leaq 0x94(%rsp), %rsi
movl %r9d, (%rsi)
movq 0x8(%... | /qt[P]qtbase/src/gui/painting/qimagescale_sse4.cpp |
void qt_qimageScaleAARGBA_down_xy_sse4<false>(QImageScale::QImageScaleInfo*, unsigned int*, int, int, int, int) | void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
int dw, int dh, int dow, int sow)
{
const unsigned int **ypoints = isi->ypoints;
int *xpoints = isi->xpoints;
int *xapoints = isi->xapoints;
int *yapoints = isi->yapoints;
auto sc... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %r15d
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
leaq 0x90(%rsp), %rax
movq %rsi, (%rax)
leaq 0x8c(%rsp), %rcx
movl %edx, (%rcx)
leaq 0x88(%rsp), %rdx
movl %r8d, (%rdx)
leaq 0x84(%rsp), %rsi
movl %r9d, (%rsi)
movq 0x8(%... | /qt[P]qtbase/src/gui/painting/qimagescale_sse4.cpp |
comp_func_Source_rgbafp_avx2(QRgbaFloat<float>*, QRgbaFloat<float> const*, int, unsigned int) | void QT_FASTCALL comp_func_Source_rgbafp_avx2(QRgbaFloat32 *dst, const QRgbaFloat32 *src, int length, uint const_alpha)
{
Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
if (const_alpha == 255) {
::memcpy(dst, src, length * sizeof(QRgbaFloat32));
} else {
const float ca = const_alp... | endbr64
cmpl $0xff, %ecx
jne 0x4b1015
movslq %edx, %rdx
shlq $0x4, %rdx
jmp 0x137aa0
movl %ecx, %eax
vcvtsi2ss %rax, %xmm0, %xmm0
vdivss 0xc4f04(%rip), %xmm0, %xmm0 # 0x575f28
vmovss 0xc4ef4(%rip), %xmm1 # 0x575f20
vsubss %xmm0, %xmm1, %xmm1
vbroadcastss %xmm0, %ymm0
vbroadcastss %xmm1, %ymm1
xorl %eax, %eax
cmpl $0... | /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
comp_func_solid_Source_rgbafp_avx2(QRgbaFloat<float>*, int, QRgbaFloat<float>, unsigned int) | void QT_FASTCALL comp_func_solid_Source_rgbafp_avx2(QRgbaFloat32 *dst, int length, QRgbaFloat32 color, uint const_alpha)
{
Q_ASSERT(const_alpha < 256); // const_alpha is in [0-255]
if (const_alpha == 255) {
for (int i = 0; i < length; ++i)
dst[i] = color;
} else {
const float a =... | endbr64
vmovlhps %xmm1, %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[0]
cmpl $0xff, %edx
jne 0x4b1643
testl %esi, %esi
jle 0x4b163f
movl %esi, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
vmovaps %xmm1, (%rdi,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x4b1631
vzeroupper
retq
movl %edx, %eax
vcvtsi2ss %rax, %xmm2, %xmm0
vdivss 0xc48... | /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
storeRGBX16FFromRGBA32F_avx2(unsigned char*, QRgbaFloat<float> const*, int, int, QList<unsigned int> const*, QDitherInfo*) | void QT_FASTCALL storeRGBX16FFromRGBA32F_avx2(uchar *dest, const QRgbaFloat32 *src, int index, int count,
const QList<QRgb> *, QDitherInfo *)
{
quint64 *d = reinterpret_cast<quint64 *>(dest) + index;
const __m128 *s = reinterpret_cast<const __m128 *>(src);
const... | endbr64
testl %ecx, %ecx
jle 0x4b330b
movslq %edx, %rax
leaq (%rdi,%rax,8), %rax
movl %ecx, %ecx
shlq $0x3, %rcx
xorl %edx, %edx
vmovss 0xc2c79(%rip), %xmm0 # 0x575f20
vmovaps 0xdc821(%rip), %xmm1 # 0x58fad0
vxorps %xmm2, %xmm2, %xmm2
vmovups (%rsi,%rdx,2), %xmm3
vbroadcastss 0xc(%rsi,%rdx,2), %xmm4
vucomiss %xmm... | /qt[P]qtbase/src/gui/painting/qdrawhelper_avx2.cpp |
hb_qt_font_get_glyph_h_advance(hb_font_t*, void*, unsigned int, void*) | static hb_position_t
_hb_qt_font_get_glyph_h_advance(hb_font_t *font, void *font_data,
hb_codepoint_t glyph,
void * /*user_data*/)
{
QFontEngine *fe = static_cast<QFontEngine *>(font_data);
Q_ASSERT(fe);
QFixed advance;
QGlyphLayout g;
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %r15
movl $0x0, (%r15)
movaps 0xc0f21(%rip), %xmm0 # 0x574680
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, (%r14)
movaps %xmm0, 0x... | /qt[P]qtbase/src/gui/text/qharfbuzzng.cpp |
hb_unicode_funcs_t::_hb_unicode_funcs_t() | _hb_unicode_funcs_t()
{
funcs = hb_unicode_funcs_create(NULL);
hb_unicode_funcs_set_combining_class_func(funcs, _hb_qt_unicode_combining_class, NULL, NULL);
hb_unicode_funcs_set_general_category_func(funcs, _hb_qt_unicode_general_category, NULL, NULL);
hb_unicode_funcs_set_mirroring_... | endbr64
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x138b30
movq %rax, (%rbx)
leaq -0x4e1(%rip), %rsi # 0x4b396e
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x13ffe0
movq (%rbx), %rdi
leaq -0x4e6(%rip), %rsi # 0x4b397f
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1383d0
movq (%rbx), %rdi
leaq -0x4d... | /qt[P]qtbase/src/gui/text/qharfbuzzng.cpp |
QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter&, QTextFragment const&) const | void QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter &writer, const QTextFragment &fragment) const
{
writer.writeStartElement(drawNS, QString::fromLatin1("frame"));
if (m_strategy == nullptr) {
// don't do anything.
}
else if (fragment.charFormat().isImageFormat()) {
QTextImageForm... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x190(%rsp)
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
movq 0x80(%rdi), %r12
movq %rdi, 0x18(%rsp)
movq 0x88(%rdi), %r13
... | /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QTextOdfWriter::writeFormats(QXmlStreamWriter&, QSet<int> const&) const | void QTextOdfWriter::writeFormats(QXmlStreamWriter &writer, const QSet<int> &formats) const
{
writer.writeStartElement(officeNS, QString::fromLatin1("automatic-styles"));
QList<QTextFormat> allStyles = m_document->allFormats();
for (int formatIndex : formats) {
QTextFormat textFormat = allStyles.at(... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
movq 0x8(%rdi), %r12
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %rdi, (%rsp)
movq 0x10(%rdi), %rbp
orq %r13, %rbp
leaq 0x107bd0(%ri... | /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QTextOdfWriter::tableCellStyleElement(QXmlStreamWriter&, int const&, QTextTableCellFormat const&, bool, int, QTextTableFormat) const | void QTextOdfWriter::tableCellStyleElement(QXmlStreamWriter &writer, const int &formatIndex,
const QTextTableCellFormat &format,
bool hasBorder, int tableId,
const QTextTableFormat tableForma... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movl %r9d, 0x40(%rsp)
movl %r8d, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x290(%rsp)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
... | /qt[P]qtbase/src/gui/text/qtextodfwriter.cpp |
QHash<int, QList<int>>::value(int const&) const | T value(const Key &key) const noexcept
{
if (T *v = valueImpl(key))
return *v;
else
return T();
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x4becee
movq %rdx, %rsi
callq 0x4bf964
testq %rax, %rax
je 0x4becee
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq 0x10(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x4becfc
lock
incl (%rcx)
jmp 0x... | /qt[P]qtbase/src/corelib/tools/qhash.h |
void QConcatenable<QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QString, QLatin1String>, QString>, QLatin1String>, QString>>::appendTo<QChar>(QStringBuilder<QStringBuilder<QStringBuilder<QStringBuilder<QString, QLatin1String>, QString>, QLatin1String>, QString> const&, QChar*&) | static inline void appendTo(const type &p, T *&out)
{
QConcatenableEx<A>::appendTo(p.a, out);
QConcatenableEx<B>::appendTo(p.b, out);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
testq %r12, %r12
je 0x4bf4fb
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x4bf4f2
movq 0x22fa56(%rip), %rsi # 0x6eef48
leaq (%r12,%r12), %rdx
callq 0x137aa0
addq %r12, %r12
addq (%rbx)... | /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QHash<int, QList<int>>::iterator QHash<int, QList<int>>::emplace_helper<QList<int>>(int&&, QList<int>&&) | iterator emplace_helper(Key &&key, Args &&... args)
{
auto result = d->findOrInsert(key);
if (!result.initialized)
Node::createInPlace(result.it.node(), std::move(key), std::forward<Args>(args)...);
else
result.it.node()->emplaceValue(std::forward<Args>(args)...);
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r15
movq %rax, 0x10(%r15)
movaps 0xb43cd(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r15)
movq (%rdi), %rsi
movq %r... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Span<QHashPrivate::Node<int, QList<int>>>::insert(unsigned long) | Node *insert(size_t i)
{
Q_ASSERT(i < SpanConstants::NEntries);
Q_ASSERT(offsets[i] == SpanConstants::UnusedEntry);
if (nextFree == allocated)
addStorage();
unsigned char entry = nextFree;
Q_ASSERT(entry < allocated);
nextFree = entries[entry].nextFree();
... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x89(%rdi), %al
cmpb 0x88(%rdi), %al
jne 0x4c0864
movq %rbx, %rdi
callq 0x4c0890
movb 0x89(%rbx), %al
movq 0x80(%rbx), %rcx
movzbl %al, %edx
movl %edx, %eax
shll $0x5, %eax
movb (%rcx,%rax), %cl
movb %cl, 0x89(%rbx)
movb %dl, (%rbx,%r14)
addq... | /qt[P]qtbase/src/corelib/tools/qhash.h |
CbDebugLog(char const*, void*) | static void CbDebugLog(const char *msg, void *userdata)
{
Q_UNUSED(userdata);
qCDebug(lcMD) << msg;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
callq 0x4c19a3
movb 0x24b839(%rip), %al # 0x70d108
testb $0x1, %al
je 0x4c1984
movq 0x24b822(%rip), %rax # 0x70d100
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)... | /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QTextMarkdownImporter::cbLeaveSpan(int, void*) | int QTextMarkdownImporter::cbLeaveSpan(int spanType, void *detail)
{
Q_UNUSED(detail);
QTextCharFormat charFmt;
if (!m_spanFormatStack.isEmpty()) {
m_spanFormatStack.pop();
if (!m_spanFormatStack.isEmpty())
charFmt = m_spanFormatStack.top();
}
m_cursor.setCharFormat(charF... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x90(%rsp)
movaps 0xb0df2(%rip), %xmm0 # 0x574680
leaq 0x80(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x13c710
cmpq $0x0, 0x80(%rbx)
je 0x4c38e7
leaq 0x70(%rbx), %r14
leaq 0x70(%rsp), %r15... | /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QTextMarkdownImporter::insertBlock() | void QTextMarkdownImporter::insertBlock()
{
QTextCharFormat charFormat;
if (!m_spanFormatStack.isEmpty())
charFormat = m_spanFormatStack.top();
QTextBlockFormat blockFormat;
if (!m_listStack.isEmpty() && !m_needsInsertList && m_listItem) {
QTextList *list = m_listStack.top();
if ... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x68(%rsp)
movaps 0xafa85(%rip), %xmm0 # 0x574680
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
callq 0x13c710
cmpq $0x0, 0x80(%rbx)
je 0x4c4c29
leaq 0x70(%rbx), %rdi
callq 0x4c5820
leaq -0x10(... | /qt[P]qtbase/src/gui/text/qtextmarkdownimporter.cpp |
QArrayDataPointer<QPointer<QTextList>>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QPointer<QTextList> const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x4c5384
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x4, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x4c538d
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x4c53a9... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QList<QTextCharFormat>::end() | iterator end() { detach(); return iterator(d->end()); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4c5837
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4c5845
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3b94b8
movq 0x10(%rbx), %rax
shlq $0x4, %rax
addq 0x8(%rbx), %rax
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QArrayDataPointer<QTextCharFormat>::detachAndGrow(QArrayData::GrowthPosition, long long, QTextCharFormat const**, QArrayDataPointer<QTextCharFormat>*) | 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
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x4c5a07
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x4c5a21
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QTextCharFormat, long long>(QTextCharFormat*, long long, QTextCharFormat*) | 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
movq %rsi, %rax
testq %rsi, %rsi
je 0x4c5c15
testq %rdx, %rdx
je 0x4c5c15
movq %rdi, %rsi
testq %rdi, %rdi
je 0x4c5c15
cmpq %rdx, %rsi
je 0x4c5c15
shlq $0x4, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QString QStringBuilder<QStringBuilder<char16_t, QString const&>, char16_t>::convertTo<QString>() const | T convertTo() const
{
if (isNull()) {
// appending two null strings must give back a null string,
// so we're special casing this one out, QTBUG-114206
return T();
}
const qsizetype len = Concatenable::size(*this);
T s(len, Qt::Uninitialized);
... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rsi
addq $0x2, %rsi
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%rdi)
movaps 0xa04c5(%rip), %xmm0 # 0x574680
movups %xmm0, (%rdi)
xorl %edx, %edx
cal... | /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QCss::ValueExtractor::extractPosition(int*, int*, int*, int*, QCss::Origin*, QFlags<Qt::AlignmentFlag>*, QCss::PositionMode*, QFlags<Qt::AlignmentFlag>*) | bool ValueExtractor::extractPosition(int *left, int *top, int *right, int *bottom, QCss::Origin *origin,
Qt::Alignment *position, QCss::PositionMode *mode, Qt::Alignment *textAlignment)
{
extractFont();
bool hit = false;
for (int i = 0; i < declarations.size(); i++) {
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x2c(%rdi)
jne 0x4d8ab4
leaq 0x1c(%rsp), %rdx
movl $0xffffff01, (%rdx... | /qt[P]qtbase/src/gui/text/qcssparser.cpp |
QList<QFontVariableAxis>::end() | iterator end() { detach(); return iterator(d->end()); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4f9425
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4f9433
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4f95e4
movq 0x10(%rbx), %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
popq %rbx
retq
nop
| /qt[P]qtbase/src/corelib/tools/qlist.h |
QUndoStack::redoText() const | QString QUndoStack::redoText() const
{
Q_D(const QUndoStack);
if (!d->macro_stack.isEmpty())
return QString();
if (d->index < d->command_list.size())
return d->command_list.at(d->index)->actionText();
return QString();
} | endbr64
movq %rdi, %rax
movq 0x8(%rsi), %rcx
cmpq $0x0, 0xa0(%rcx)
jne 0x503532
movslq 0xa8(%rcx), %rdx
cmpq %rdx, 0x88(%rcx)
jle 0x503532
movq 0x80(%rcx), %rcx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rcx), %rdx
movq 0x30(%rdx), %rcx
movq %rcx, (%rax)
movq 0x38(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0x40(%rdx), %rdx
movq %rd... | /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoStackPrivate::checkUndoLimit() | bool QUndoStackPrivate::checkUndoLimit()
{
if (undo_limit <= 0 || !macro_stack.isEmpty() || undo_limit >= command_list.size())
return false;
int del_count = command_list.size() - undo_limit;
for (int i = 0; i < del_count; ++i)
delete command_list.takeFirst();
index -= del_count;
i... | endbr64
movslq 0xb8(%rdi), %rax
testq %rax, %rax
jle 0x50363c
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0xa0(%rdi)
jne 0x50362f
movq 0x88(%rbx), %r15
cmpq %rax, %r15
jbe 0x50362f
subl %eax, %r15d
testl %r15d, %r15d
jle 0x503608
leaq 0x78(%rbx), %r14
movl %r15d, %ebp
movq %r14, %r... | /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoStack::~QUndoStack() | QUndoStack::~QUndoStack()
{
#if QT_CONFIG(undogroup)
Q_D(QUndoStack);
if (d->group != nullptr)
d->group->removeStack(this);
#endif
clear();
} | endbr64
pushq %rbx
movq %rdi, %rbx
callq 0x1462d0
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
nop
| /qt[P]qtbase/src/gui/util/qundostack.cpp |
QUndoGroup::~QUndoGroup() | QUndoGroup::~QUndoGroup()
{
// Ensure all QUndoStacks no longer refer to this group.
Q_D(QUndoGroup);
QList<QUndoStack *>::iterator it = d->stack_list.begin();
QList<QUndoStack *>::iterator end = d->stack_list.end();
while (it != end) {
(*it)->d_func()->group = nullptr;
++it;
}
} | endbr64
pushq %rbx
movq %rdi, %rbx
callq 0x144080
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x137fb0
nop
| /qt[P]qtbase/src/gui/util/qundogroup.cpp |
QUndoGroup::createUndoAction(QObject*, QString const&) const | QAction *QUndoGroup::createUndoAction(QObject *parent, const QString &prefix) const
{
QAction *action = new QAction(parent);
action->setEnabled(canUndo());
QString effectivePrefix = prefix;
QString defaultText;
if (prefix.isEmpty()) {
effectivePrefix = tr("Undo %1");
defaultText = t... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0xb0(%rsp)
movl $0x10, %edi
callq 0x1387d0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x148d90
movq %rbx, 0x8(%rsp)
movq 0x8(%rbx), %rax
mo... | /qt[P]qtbase/src/gui/util/qundogroup.cpp |
QMetaTypeIdQObject<QUndoStack*, 8>::qt_metatype_id() | static int qt_metatype_id()
{
Q_CONSTINIT static QBasicAtomicInt metatype_id = Q_BASIC_ATOMIC_INITIALIZER(0);
if (const int id = metatype_id.loadAcquire())
return id;
const char *const cName = T::staticMetaObject.className();
QByteArray typeName;
typeName.reserve(... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movl 0x205919(%rip), %ebx # 0x70d208
testl %ebx, %ebx
je 0x507913
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x5079c7
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1e7956(%rip), %rdi ... | /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QArrayDataPointer<QUndoStack*>::detachAndGrow(QArrayData::GrowthPosition, long long, QUndoStack* const**, QArrayDataPointer<QUndoStack*>*) | 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
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x507e37
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x507e51
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QUndoStack*>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QUndoStack* const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x507f48
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x3, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x507f51
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x507f6d... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
auto QtPrivate::sequential_erase_if<QList<QUndoStack*>, auto QtPrivate::sequential_erase<QList<QUndoStack*>, QUndoStack*>(QList<QUndoStack*>&, QUndoStack* const&)::'lambda'(QList<QUndoStack*> const&)>(QList<QUndoStack*>&, QUndoStack*&) | auto sequential_erase_if(Container &c, Predicate &pred)
{
// This is remove_if() modified to perform the find_if step on
// const_iterators to avoid shared container detaches if nothing needs to
// be removed. We cannot run remove_if after find_if: doing so would apply
// the predicate to the first matc... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
leaq (%r15,%rax,8), %rsi
movq (%r14), %rdx
movq %r15, %rdi
callq 0x50814f
movq %rax, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x3, %rax
cmpq 0x10(%rbx), %rax
jne 0x50808b
xorl %r14... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QList<QUndoStack*>::erase(QList<QUndoStack*>::const_iterator, QList<QUndoStack*>::const_iterator) | typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
Q_ASSE... | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %r15
subq %rsi, %r15
subq %rax, %r14
je 0x50813e
sarq $0x3, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x50811e
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x508130
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QtPrivate::QPodArrayOps<QUndoStack*>::erase(QUndoStack**, long long) | void erase(T *b, qsizetype n)
{
T *e = b + n;
Q_ASSERT(this->isMutable());
Q_ASSERT(b < e);
Q_ASSERT(b >= this->begin() && b < this->end());
Q_ASSERT(e > this->begin() && e <= this->end());
// Comply with std::vector::erase(): erased elements and all after them
... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq (%rsi,%rdx,8), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
cmpq %rax, %rdx
setne %dil
leaq (%rdx,%rcx,8), %rdx
cmpq %rdx, %rsi
sete %r8b
orb %dil, %r8b
je 0x508248
cmpq %rdx, %rsi
je 0x50824c
subq %rsi, %rdx
movq %rax, %rd... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
qglx_buildSpec(QSurfaceFormat const&, int, int) | QList<int> qglx_buildSpec(const QSurfaceFormat &format, int drawableBit, int flags)
{
QList<int> spec;
spec << GLX_LEVEL
<< 0
<< GLX_RENDER_TYPE
<< GLX_RGBA_BIT
<< GLX_RED_SIZE
<< qMax(1, format.redBufferSize())
<< GLX_GREEN_SIZE
<< qMax(1, form... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r12
movl $0x3, (%r12)
xorl %r13d, %r13... | /qt[P]qtbase/src/gui/opengl/platform/unix/qglxconvenience.cpp |
qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat*, _XDisplay*, __GLXFBConfigRec*, int) | void qglx_surfaceFormatFromGLXFBConfig(QSurfaceFormat *format, Display *display, GLXFBConfig config, int flags)
{
int redSize = 0;
int greenSize = 0;
int blueSize = 0;
int alphaSize = 0;
int depthSize = 0;
int stencilSize = 0;
int sampleBuffers = 0;
int sampleCount = 0;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
xorl %eax, %eax
leaq 0x3c(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x38(%rsp), %rbp
movl %eax, (%rbp)
leaq 0x34(%rsp), %r12
... | /qt[P]qtbase/src/gui/opengl/platform/unix/qglxconvenience.cpp |
QEGLPlatformContext::QEGLPlatformContext(QSurfaceFormat const&, QPlatformOpenGLContext*, void*, void**, QFlags<QEGLPlatformContext::Flag>) | QEGLPlatformContext::QEGLPlatformContext(const QSurfaceFormat &format, QPlatformOpenGLContext *share, EGLDisplay display,
EGLConfig *config, Flags flags)
: m_eglDisplay(display)
, m_flags(flags)
, m_ownsContext(true)
{
m_eglConfig = config ? *config : q_configFro... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %r14d
movq %r8, %rbp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x80(%rsp)
callq 0x144dc0
movq 0x1e631c(%rip), %rax # 0x6efc20
leaq 0x10(%rax), %rcx
movq %rcx, (%r... | /qt[P]qtbase/src/gui/opengl/platform/egl/qeglplatformcontext.cpp |
QMap<QString, QVariant>::value(QString const&, QVariant const&) const | T value(const Key &key, const T &defaultValue = T()) const
{
if (!d)
return defaultValue;
const auto i = d->m.find(key);
if (i != d->m.cend())
return i->second;
return defaultValue;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x525332
movq %rsi, %r15
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x525346
movq (%r15), %rcx
addq $0x10, %rcx
leaq 0x38(%rax), %rdx
cmpq %rcx, %rax
cmovneq %rdx, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13d0f... | /qt[P]qtbase/src/corelib/tools/qmap.h |
QtPrivate::QMetaTypeForType<QDBusObjectPath>::getDtor()::'lambda'(QtPrivate::QMetaTypeInterface const*, void*)::__invoke(QtPrivate::QMetaTypeInterface const*, void*) | bool deref() noexcept { return !d || d->deref(); } | endbr64
movq (%rsi), %rax
testq %rax, %rax
je 0x525629
lock
decl (%rax)
jne 0x525629
movq (%rsi), %rdi
movl $0x2, %esi
movl $0x10, %edx
jmp 0x143f00
retq
| /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QLessThanOperatorForType<QDBusObjectPath, true>::lessThan(QtPrivate::QMetaTypeInterface const*, void const*, void const*) | static bool lessThan(const QMetaTypeInterface *, const void *a, const void *b)
{ return *reinterpret_cast<const T *>(a) < *reinterpret_cast<const T *>(b); } | endbr64
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq (%rsi), %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rax), %rdi
testq %rbx, %rbx
je 0x5256ce
lock
incl (%rbx)
movq (%rdx), %r14
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdx
testq %r14, %r14
je 0x525709
lock
incl (%r14)
movl $0x1, %r8d
callq 0x13a6c0
movl %eax, %ebp
lo... | /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QDBusObjectPath qdbus_cast<QDBusObjectPath>(QVariant const&) | inline T qdbus_cast(const QVariant &v)
{
if (v.metaType() == QMetaType::fromType<QDBusArgument>())
return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v));
else
return qvariant_cast<T>(v);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movq %rsi, %rdi
callq 0x139130
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x1d3089(%rip), %r15 # 0x6f89d0
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
callq 0x16a00a
testb %al, %al
je 0x525... | /qt[P]qtbase/src/dbus/qdbusargument.h |
QtPrivate::QExplicitlySharedDataPointerV2<QMapData<std::map<QString, QVariant, std::less<QString>, std::allocator<std::pair<QString const, QVariant>>>>>::reset(QMapData<std::map<QString, QVariant, std::less<QString>, std::allocator<std::pair<QString const, QVariant>>>>*) | void reset(T *t = nullptr) noexcept
{
if (d && !d->ref.deref())
delete d.get();
d.reset(t);
if (d)
d->ref.ref();
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x525d6a
lock
decl (%rax)
jne 0x525d6a
movq (%r14), %r15
testq %r15, %r15
je 0x525d5d
leaq 0x8(%r15), %rdi
movq 0x18(%r15), %rsi
callq 0x525f8e
movl $0x38, %esi
movq %r15, %rdi
callq 0x137fb0
movq %rbx, (%r14)... | /qt[P]qtbase/src/corelib/tools/qshareddata_impl.h |
void QtPrivate::QMovableArrayOps<QDBusUnixFileDescriptor>::emplace<QDBusUnixFileDescriptor const&>(long long, QDBusUnixFileDescriptor const&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x52643a
movl (%rax), %ecx
cmpl $0x1, %ecx
jg 0x52643a
cmpq %r14, 0x10(%rbx)
jne 0x526420
movq 0x8(%rbx), %rcx
leaq 0... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
int qRegisterNormalizedMetaTypeImplementation<QList<QDBusUnixFileDescriptor>>(QByteArray const&) | int qRegisterNormalizedMetaTypeImplementation(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName)
{
#ifndef QT_NO_QOBJECT
Q_ASSERT_X(normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData()),
"qRegisterNormalizedMetaType",
"qRegisterNormalizedMetaType wa... | endbr64
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x1d1c74(%rip), %ebx # 0x6f8b2c
testl %ebx, %ebx
jne 0x526eca
leaq 0x1d1c5d(%rip), %rdi # 0x6f8b20
callq 0x139f90
movl %eax, %ebx
leaq 0x1d1c4f(%rip), %rdi # 0x6f8b20
callq 0x146e70
testb %al, %al
jne ... | /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QList<QDBusUnixFileDescriptor>::clear() | void clear() {
if (!size())
return;
if (d->needsDetach()) {
// must allocate memory
DataPointer detached(d.allocatedCapacity());
d.swap(detached);
} else {
d->truncate(0);
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x5273b2
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x527324
movl (%rax), %ecx
cmpl $0x2, %ecx
jl 0x527390
movaps 0x4d367(%rip), %xmm0 # 0x574680
movups %xmm0, 0x10... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QDBusUnixFileDescriptor>::pop_back() | void pop_back() noexcept { removeLast(); } | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x52747b
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x527489
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x52671c
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq (%rax,%rcx,8), %rdi
addq $-0x8, %rdi
callq 0x143db0
decq 0x10(%rb... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QDBusUnixFileDescriptor>::erase(QList<QDBusUnixFileDescriptor>::const_iterator, QList<QDBusUnixFileDescriptor>::const_iterator) | typename QList<T>::iterator QList<T>::erase(const_iterator abegin, const_iterator aend)
{
Q_ASSERT_X(isValidIterator(abegin), "QList::erase", "The specified iterator argument 'abegin' is invalid");
Q_ASSERT_X(isValidIterator(aend), "QList::erase", "The specified iterator argument 'aend' is invalid");
Q_ASSE... | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %r15
subq %rsi, %r15
subq %rax, %r14
je 0x52762e
sarq $0x3, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x52760e
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x527620
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx... | /qt[P]qtbase/src/corelib/tools/qlist.h |
bool QMetaType::registerMutableView<QList<QDBusUnixFileDescriptor>, QIterable<QMetaSequence>, QtPrivate::QSequentialIterableMutableViewFunctor<QList<QDBusUnixFileDescriptor>>>(QtPrivate::QSequentialIterableMutableViewFunctor<QList<QDBusUnixFileDescriptor>>) | static bool registerMutableView(UnaryFunction function)
{
static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn),
"QMetaType::registerMutableView: At least one of the types must be a custom type.");
const QMetaType fromType = QMetaType::fromType<From>();
... | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movb $-0x56, (%r14)
leaq 0xb0(%rip), %rax # 0x5277ae
movq %rax, 0x18(%r14)
leaq 0xcb(%rip), %rax # 0x5277d4
movq %rax, 0x10(%r14)
leaq 0x1d140c(%rip), %rsi # ... | /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QString QStringBuilder<QStringBuilder<QString, QString>, QString>::convertTo<QString>() const | T convertTo() const
{
if (isNull()) {
// appending two null strings must give back a null string,
// so we're special casing this one out, QTBUG-114206
return T();
}
const qsizetype len = Concatenable::size(*this);
T s(len, Qt::Uninitialized);
... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
jne 0x527a86
cmpq $0x0, 0x20(%r14)
jne 0x527a86
cmpq $0x0, 0x38(%r14)
jne 0x527a86
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x527b2b
movq 0x28(%r14), %rsi
addq 0x10(%r14), %rsi
ad... | /qt[P]qtbase/src/corelib/text/qstringbuilder.h |
QX11Info::appUserTime() | quint32 QX11Info::appUserTime()
{
if (!qApp)
return 0;
QPlatformNativeInterface *native = qApp->platformNativeInterface();
if (!native)
return 0;
QScreen* screen = QGuiApplication::primaryScreen();
return static_cast<xcb_timestamp_t>(reinterpret_cast<quintptr>(native->nativeResourceF... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movq 0x1c6828(%rip), %rax # 0x6ee968
xorl %ebx, %ebx
cmpq $0x0, (%rax)
je 0x5281a8
callq 0x13d240
testq %rax, %rax
je 0x5281a8
movq %rax, %r14
callq 0x137ee0
movq %rax, %rbx
leaq 0x9fe0b(%rip), %rsi # 0x5c7f6f
mov... | /qt[P]qtbase/src/gui/platform/unix/qtx11extras.cpp |
bool QMetaType::registerConverter<QList<QXdgDBusImageStruct>, QIterable<QMetaSequence>, QtPrivate::QSequentialIterableConvertFunctor<QList<QXdgDBusImageStruct>>>(QtPrivate::QSequentialIterableConvertFunctor<QList<QXdgDBusImageStruct>>) | static bool registerConverter(UnaryFunction function)
{
static_assert((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn),
"QMetaType::registerConverter: At least one of the types must be a custom type.");
const QMetaType fromType = QMetaType::fromType<From>();
cons... | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movb $-0x56, (%r14)
leaq 0xb0(%rip), %rax # 0x54d0aa
movq %rax, 0x18(%r14)
leaq 0xc7(%rip), %rax # 0x54d0cc
movq %rax, 0x10(%r14)
leaq 0x1ac5b0(%rip), %rsi # ... | /qt[P]qtbase/src/corelib/kernel/qmetatype.h |
QArrayDataPointer<QXdgDBusImageStruct>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QXdgDBusImageStruct const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x54da40
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x5, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x54da49
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x54da65... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QGenericArrayOps<QXdgDBusImageStruct>::eraseFirst() | void eraseFirst() noexcept
{
Q_ASSERT(this->isMutable());
Q_ASSERT(this->size);
this->begin()->~T();
++this->ptr;
--this->size;
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x54dbd1
lock
decl (%rcx)
jne 0x54dbd1
movq 0x8(%rax), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
addq $0x20, 0x8(%rbx)
decq 0x10(%rbx)
popq %rbx
retq
| /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QStatusNotifierItemAdaptor::ProvideXdgActivationToken(QString const&) | void QStatusNotifierItemAdaptor::ProvideXdgActivationToken(const QString &token)
{
qCDebug(qLcTray) << token;
qputenv("XDG_ACTIVATION_TOKEN", token.toUtf8());
} | endbr64
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
callq 0x5489f0
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x54e666
movq 0x8(%rax), %rax
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq... | /qt[P]qtbase/src/gui/platform/unix/dbustray/qstatusnotifieritemadaptor.cpp |
QXkbCommon::lookupStringNoKeysymTransformations(unsigned int) | QString QXkbCommon::lookupStringNoKeysymTransformations(xkb_keysym_t keysym)
{
QVarLengthArray<char, 32> chars(32);
const int size = xkb_keysym_to_utf8(keysym, chars.data(), chars.size());
if (size == 0)
return QString(); // the keysym does not have a Unicode representation
if (Q_UNLIKELY(size ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x20(%rsp), %r14
movaps 0x24351(%rip), %xmm0 # 0x574680
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movl $0x20, %eax
movq %rax, -0x18(%r14)
movq ... | /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
QXkbCommon::possibleKeyCombinations(xkb_state*, QKeyEvent const*, bool, bool) | QList<QKeyCombination> QXkbCommon::possibleKeyCombinations(xkb_state *state, const QKeyEvent *event,
bool superAsMeta, bool hyperAsMeta)
{
QList<QKeyCombination> result;
quint32 keycode = event->nativeScanCode();
if (!keycode)
return result;
Qt::KeyboardModif... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rdi)
movl 0x44(%rdx), %ebp
testl %ebp, %ebp
je 0x5511bf
movl %r8d, %r13d
movq %rsi, %rbx
movl %ecx, 0x14(%rs... | /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
QXkbCommon::setXkbContext(QPlatformInputContext*, xkb_context*) | void QXkbCommon::setXkbContext(QPlatformInputContext *inputContext, struct xkb_context *context)
{
if (!inputContext || !context)
return;
const char *const inputContextClassName = "QComposeInputContext";
const char *const normalizedSignature = "setXkbContext(xkb_context*)";
if (inputContext->o... | endbr64
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %fs:0x28, %rcx
movq %rcx, 0x50(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x551551
movq %rdi, %rax
leaq 0x7cd74(%rip), %rcx # 0x5ce1dd
movq %rcx, 0x8(%rsp)
leaq 0x7cd7d(%rip), %rcx # 0... | /qt[P]qtbase/src/gui/platform/unix/qxkbcommon.cpp |
qt_alphamapblit_generic(QRasterBuffer*, int, int, QRgba64 const&, unsigned char const*, int, int, int, QClipData const*, bool) | static void qt_alphamapblit_generic(QRasterBuffer *rasterBuffer,
int x, int y, const QRgba64 &color,
const uchar *map,
int mapWidth, int mapHeight, int mapStride,
const QClipDa... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4078, %rsp # imm = 0x4078
movl %r9d, 0x4(%rsp)
movq %r8, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, (%rsp)
movq %fs:0x28, %rax
movq %rax, 0x4070(%rsp)
movq %rcx, 0x48(%rsp)
movq (%rcx), %rcx
movq %rcx, %rax
shrq $0x30, %rax
je 0... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_color_argb(int, QT_FT_Span_ const*, void*) | static void blend_color_argb(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, nullptr, 0);
const uint color = data->solidColor.rgba();
if (op.mode == QPainter::CompositionMode_Source) {
// inl... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x7b01c(%rip), %rsi # 0x5ce8d0
leaq 0x30(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
mo... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_color_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_color_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
#if QT_CONFIG(raster_64bit)
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, nullptr, 0);
if (!op.funcSolid64) {
qCDebug(lcQtGuiDrawHelper, "blend_color_generic... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x794e2(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r15
movl $0xb0, %edx
movq %r15, %rdi
callq 0x137aa0
mo... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_rectfill_fp32x4(QRasterBuffer*, int, int, int, int, QRgba64 const&) | static void qt_rectfill_fp32x4(QRasterBuffer *rasterBuffer,
int x, int y, int width, int height,
const QRgba64 &color)
{
const auto store = qStoreFromRGBA64PM[rasterBuffer->format];
QRgbaFloat32 c;
store(reinterpret_cast<uchar *>(&c), &color, 0, ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x10(%rdi), %eax
leaq 0x19fbc0(%rip), %rcx # 0x6f5bd0
movq (%rcx,%rax,8), %rax
pcmpeqd %xmm0, %xm... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_untransformed_argb(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_argb(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
if (data->texture.format != QImage::Format_ARGB32_Premultiplied
&& data->texture.format != QImage::Format_RGB32) {
blend_untransformed_generic(cou... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq %fs:0x28, %rax
movq %rax, 0x120(%rsp)
movl 0xd0(%rdx), %eax
orl $0x2, %eax
cmpl $0x6, %eax
jne 0x5565b6
movabsq $-0x5555555555555556, %r13 # imm = 0x... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_untransformed_generic(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_generic(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
const int image_width = data->texture.width;
const int image_height = data->texture.height;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
movabsq $-0x5555555555555556, %r13 # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x77d7e(%rip), %rsi # 0x5ce8d0
leaq 0x50(... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
getLinearGradientValues(LinearGradientValues*, QSpanData const*) | static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
{
v->dx = data->gradient.linear.end.x - data->gradient.linear.origin.x;
v->dy = data->gradient.linear.end.y - data->gradient.linear.origin.y;
v->l = v->dx * v->dx + v->dy * v->dy;
v->off = 0;
if (v->l != ... | movsd 0xc0(%rsi), %xmm0
subsd 0xb0(%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0xc8(%rsi), %xmm1
subsd 0xb8(%rsi), %xmm1
movsd %xmm1, 0x8(%rdi)
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_fetch_conical_gradient_rgb64(QRgba64*, Operator const*, QSpanData const*, int, int, int) | static const QRgba64 * QT_FASTCALL qt_fetch_conical_gradient_rgb64(QRgba64 *buffer, const Operator *, const QSpanData *data,
int y, int x, int length)
{
return qt_fetch_conical_gradient_template<GradientBase64, QRgba64>(buffer, data, y, x, length);
... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cvtsi2sd %ecx, %xmm0
movsd 0x1c6cb(%rip), %xmm2 # 0x574c50
addsd %xmm2, %xmm0
cvtsi2sd %r8d, %xmm5
addsd %xmm2, %xmm5
movupd 0x50(%rdx), %xmm2
movupd 0x70(%rdx), %xmm3
movapd %xmm0, %xmm4
unpcklpd %xmm0, %... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_gradient_pixel_fixed(QGradientData const*, int) | static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
{
int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
return data->colorTable32[qt_gradient_clamp(data, ipos)];
} | subl $-0x80, %esi
sarl $0x8, %esi
movq 0x40(%rdi), %rax
cmpl $0x400, %esi # imm = 0x400
jb 0x558a66
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x558a46
cmpl $0x2, %ecx
jne 0x558a5a
andl $0x3ff, %esi # imm = 0x3FF
jmp 0x558a66
movl $0x7ff, %ecx # imm = 0x7FF
andl %ecx, %esi
xorl %esi, %ecx
cmp... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformed_fetcher<(TextureBlendType)2, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, QSpanData const*, int, int, int) | static void QT_FASTCALL fetchTransformed_fetcher(T *buffer, const QSpanData *data,
int y, int x, int length)
{
static_assert(blendType == BlendTransformed || blendType == BlendTransformedTiled);
const QTextureData &image = data->texture;
const qreal cx = x +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r8d, %ebp
movq %rsi, %rbx
cvtsi2sd %ecx, %xmm2
movq %rdi, %r14
movsd 0x1aae8(%rip), %xmm0 # 0x574c50
cvtsi2sd %edx, %xmm4
addsd %xmm0, %xmm2
addsd %xmm0, %xmm4
testb $0x1, 0x8a(%rsi)
movapd %xmm2, 0x70(%rsp)
movapd %xmm4, 0x60(%... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinearARGB32PM_fast_rotate_helper<(TextureBlendType)4>(unsigned int*, unsigned int*, QTextureData const&, int&, int&, int, int) | static void QT_FASTCALL fetchTransformedBilinearARGB32PM_fast_rotate_helper(uint *b, uint *end, const QTextureData &image,
int &fx, int &fy, int fdx, int fdy)
{
//we are zooming less than 8x, use 4bit precision
if (blendType != BlendTra... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r10
movslq 0x10(%rdx), %rax
movq %rax, -0x10(%rsp)
movslq 0x18(%rdx), %rax
movq %rax, -0x20(%rsp)
movslq 0x14(%rdx), %rax
movq %rax, -0x8(%rsp)
movslq 0x1c(%rdx), %rax
movq %rax, -0x18(%rsp)
cmpq %rsi, %rdi
movq %rsi, -0x28(%rsp)
jae ... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)4, unsigned int>(unsigned int*, unsigned int*, int, QTextureData const&, int, int, int, int) | static void QT_FASTCALL fetchTransformedBilinear_fetcher(T *buf1, T *buf2, const int len, const QTextureData &image,
int fx, int fy, const int fdx, const int fdy)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r10d
movl 0x40(%rsp), %r15d
movl 0x38(%rsp), %r12d
testl %r15d, %r15d
je 0x55e959
testl %r10d, %r10d
jle 0x55ea00
movq (%rcx), %rax
movq %rax, -0x8(%rsp)
movq 0x20(%rcx), %rax
movq %rax, -0x10(%rsp)
movl %r10d, %eax
movq %rax, -0x18(%rsp)
xor... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
unsigned int const* fetchTransformedBilinear<(TextureBlendType)5, (QPixelLayout::BPP)6>(unsigned int*, Operator const*, QSpanData const*, int, int, int) | static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *,
const QSpanData *data, int y, int x, int length)
{
const QPixelLayout *layout = &qPixelLayouts[data->texture.format];
const QList<QRgb> *clut = data->texture.colorTable... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50f8, %rsp # imm = 0x50F8
movl %r9d, %r15d
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x50f0(%rsp)
leaq 0xa8(%rdx), %rax
movq %rax, 0x28(%rsp)
movl 0xd0(%rdx), %eax
shlq $0x6, %rax
movq 0xd8(%rdx), %rdx
... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)4, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, unsigned int*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
... | endbr64
testl %r8d, %r8d
jle 0x560152
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %rbx
movq %rcx, %r13
movq %rdi, %rbp
movq 0xc0(%rsp), %rax
movq (%r9), %r9
movq %r9, 0x20(%rsp)
movq 0x20(%rbx), %r9
movq %r9, 0x18(%rsp)
movl %r8d, %r8d
movq %r8, 0x10(%rsp)
movsd (%rax), ... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)6, unsigned int>(unsigned int*, unsigned int*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
testl %r8d, %r8d
jle 0x560541
movq %rdx, %r11
movq %rsi, %r14
movq 0xc0(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %r9
movq %r9, 0x28(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movl %r8d, %eax
movq %... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
unsigned int const* fetchTransformedBilinear<(TextureBlendType)5, (QPixelLayout::BPP)0>(unsigned int*, Operator const*, QSpanData const*, int, int, int) | static const uint *QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *,
const QSpanData *data, int y, int x, int length)
{
const QPixelLayout *layout = &qPixelLayouts[data->texture.format];
const QList<QRgb> *clut = data->texture.colorTable... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50f8, %rsp # imm = 0x50F8
movl %r9d, %r15d
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x50f0(%rsp)
leaq 0xa8(%rdx), %rax
movq %rax, 0x28(%rsp)
movl 0xd0(%rdx), %eax
shlq $0x6, %rax
movq 0xd8(%rdx), %rdx
... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)7, QRgba64>(QRgba64*, QRgba64*, int, QTextureData const&, int, int, int, int) | static void QT_FASTCALL fetchTransformedBilinear_fetcher(T *buf1, T *buf2, const int len, const QTextureData &image,
int fx, int fy, const int fdx, const int fdy)
{
const QPixelLayout &layout = qPixelLayouts[image.format];
constexpr bool useFetch = (bpp <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r10d
movq %rsi, -0x10(%rsp)
movl 0x40(%rsp), %r12d
movl 0x38(%rsp), %r13d
testl %r12d, %r12d
je 0x567d48
testl %r10d, %r10d
movq %rcx, -0x18(%rsp)
jle 0x567dfa
movq -0x18(%rsp), %rax
movl 0x8(%rax), %ebp
movl 0xc(%rax), %r14d
movq (%rax), %rs... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void fetchTransformedBilinear_slow_fetcher<(TextureBlendType)5, (QPixelLayout::BPP)9, QRgbaFloat<float>>(QRgbaFloat<float>*, QRgbaFloat<float>*, unsigned short*, unsigned short*, int, QTextureData const&, double&, double&, double&, double, double, double) | static void QT_FASTCALL fetchTransformedBilinear_slow_fetcher(T *buf1, T *buf2, ushort *distxs, ushort *distys,
const int len, const QTextureData &image,
qreal &fx, qreal &fy, qreal &fw,
... | testl %r8d, %r8d
jle 0x56820f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq 0xb0(%rsp), %rax
movl %r8d, %edx
movq %rdx, 0x8(%rsp)
movsd (%rax), %xmm4
movl $0x8, %r15d
xorl %r14d, %r14d
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, ... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
convertRGBA64PMToRGBA32F(QRgbaFloat<float>*, unsigned long long const*, int) | static void QT_FASTCALL convertRGBA64PMToRGBA32F(QRgbaFloat32 *buffer, const quint64 *src, int count)
{
const auto *in = reinterpret_cast<const QRgba64 *>(src);
for (int i = 0; i < count; ++i) {
auto c = in[i];
buffer[i] = QRgbaFloat32::fromRgba64(c.red(), c.green(), c.blue(), c.alpha()).premult... | endbr64
testl %edx, %edx
jle 0x56b845
movl %edx, %eax
shlq $0x3, %rax
xorl %ecx, %ecx
movl $0xffff, %edx # imm = 0xFFFF
movss 0x2d167(%rip), %xmm0 # 0x598940
movaps 0x2df50(%rip), %xmm1 # 0x599730
movq (%rsi,%rcx), %r8
movl %r8d, %r9d
shrl $0x10, %r9d
movq %r8, %r10
shrq $0x20, %r10
movq %r8, %r11
shrq ... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
destStoreMonoLsb(QRasterBuffer*, int, int, unsigned int const*, int) | static void QT_FASTCALL destStoreMonoLsb(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
{
uchar *Q_DECL_RESTRICT data = (uchar *)rasterBuffer->scanLine(y);
if (rasterBuffer->monoDestinationWithClut) {
for (int i = 0; i < length; ++i) {
if (buffer[i] == rasterBuffe... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rax
movslq %edx, %r9
imulq 0x28(%rdi), %r9
addq 0x38(%rdi), %r9
cmpb $0x0, (%rdi)
je 0x56bf69
testl %r8d, %r8d
jle 0x56bffc
movl %r8d, %edx
movl %esi, %esi
xorl %r8d, %r8d
movq %rdx, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
leaq (%rsi,%r8),... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
destStoreGray8(QRasterBuffer*, int, int, unsigned int const*, int) | static void QT_FASTCALL destStoreGray8(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
{
uchar *data = rasterBuffer->scanLine(y) + x;
bool failed = false;
for (int k = 0; k < length; ++k) {
if (!qIsGray(buffer[k])) {
failed = true;
break;
}... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
testl %r8d, %r8d
jle 0x56c1a0
movq %rcx, %rbx
movq %rdi, %r12
movslq %edx, %rax
imulq 0x28(%rdi), %rax
addq 0x38(%rdi), %rax
movslq %esi, %r14
addq %rax, %r14
movl %r8d, %r15d
xorl %eax, %eax
movl $... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QRunnable::QGenericRunnable::Helper<blend_tiled_argb(int, QT_FT_Span_ const*, void*)::$_0>::impl(QRunnable::QGenericRunnable::HelperBase::Op, QRunnable::QGenericRunnable::HelperBase*, void*) | static void *impl(Op op, HelperBase *that, [[maybe_unused]] void *arg)
{
const auto _this = static_cast<Helper*>(that);
switch (op) {
case Op::Run: _this->object()(); break;
case Op::Destroy: delete _this; break;
}
return nullptr;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
cmpl $0x1, %edi
je 0x56ccf3
testl %edi, %edi
jne 0x56cd00
movq %rax, 0x10(%rsp)
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
jle 0x56ccde
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r12
movslq 0x8(%rax),... | /qt[P]qtbase/src/corelib/thread/qrunnable.h |
blend_untransformed_rgb565(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_rgb565(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData*>(userData);
QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
if (data->texture.format != QImage::Format_RGB16
|| (mode != QPainter::Com... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl %edi, %ebx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
cmpl $0x7, 0xd0(%rdx)
jne 0x56ce2c
movq (%r12), %rax
movl 0xc(%rax), %eax
testl %eax, %eax
je 0x56cd57
cmpl $0x3, %eax
jne 0x56ce2c
movq %rsi, 0x20(%rsp)
m... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_untransformed_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_untransformed_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.func64) {
qCDebug(lcQtGuiDrawHelper, "blend_untransformed_generic_rgb64: unsupp... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x61106(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
mo... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_tiled_generic_rgb64(int, QT_FT_Span_ const*, void*) | static void blend_tiled_generic_rgb64(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.func64) {
qCDebug(lcQtGuiDrawHelper, "blend_tiled_generic_rgb64: unsupported 64-bit ble... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4128, %rsp # imm = 0x4128
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %fs:0x28, %rax
movq %rax, 0x4120(%rsp)
leaq 0x60e3f(%rip), %rsi # 0x5ce8d0
leaq 0x70(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
blend_tiled_generic_fp(int, QT_FT_Span_ const*, void*) | static void blend_tiled_generic_fp(int count, const QT_FT_Span *spans, void *userData)
{
QSpanData *data = reinterpret_cast<QSpanData *>(userData);
const Operator op = getOperator(data, spans, count);
if (!op.funcFP) {
qCDebug(lcQtGuiDrawHelper, "blend_tiled_generic_fp: unsupported 4xFP blend attem... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r13d
movq %fs:0x28, %rax
movq %rax, 0x100(%rsp)
leaq 0x60231(%rip), %rsi # 0x5ce8d0
leaq 0x50(%rsp), %r12
movl $0xb0, %edx
movq %r12, %rdi
callq 0x137aa0
m... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QRunnable::QGenericRunnable::Helper<blend_color_argb(int, QT_FT_Span_ const*, void*)::$_0>::impl(QRunnable::QGenericRunnable::HelperBase::Op, QRunnable::QGenericRunnable::HelperBase*, void*) | static void *impl(Op op, HelperBase *that, [[maybe_unused]] void *arg)
{
const auto _this = static_cast<Helper*>(that);
switch (op) {
case Op::Run: _this->object()(); break;
case Op::Destroy: delete _this; break;
}
return nullptr;
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x56f993
testl %edi, %edi
jne 0x56f9a0
movl 0xc(%rbx), %ebp
testl %ebp, %ebp
jle 0x56f983
movq 0x10(%rbx), %r14
movslq 0x8(%rbx), %r15
shlq $0x4, %r15
orq $0xc, %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax... | /qt[P]qtbase/src/corelib/thread/qrunnable.h |
void qt_bitmapblit_template<unsigned int>(QRasterBuffer*, int, int, unsigned int, unsigned char const*, int, int, int) | static
inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer,
int x, int y, DST color,
const uchar *map,
int mapWidth, int mapHeight, int mapStride)
{
DST *dest = reinterpret_cast<DST *>(rasterBuffer->s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %r8d, 0xc(%rsp)
movl 0x80(%rsp), %eax
movl 0x78(%rsp), %r12d
movslq %ecx, %rcx
imulq %rdi, %rcx
addq %rsi, %rcx
movslq %edx, %rdx
leaq (%rcx,%rdx,4), %r15
shrq $0x2, %rdi
cmpl $0x8, 0x70(%rsp)
jle 0x56fae1
testl %r12d... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
qt_alphamapblit_argb32_oneline(unsigned char const*, int, QRgba64 const&, unsigned int*, unsigned int, QColorTrcLut const*) | static void qt_alphamapblit_argb32_oneline(const uchar *map,
int mapWidth, const QRgba64 &srcColor,
quint32 *dest, const quint32 c,
const QColorTrcLut *colorProfile)
{
for (int i = 0; i <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
testl %esi, %esi
jle 0x56ffca
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdi, %r12
movabsq $0xff00ff00ff00ff, %rdi # imm = 0xFF00FF00FF00FF
movabsq $0x80008000800080, %r8 # imm = 0x80008000800080
movl %eb... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
alphargbblend_argb32(unsigned int*, unsigned int, QRgba64 const&, unsigned int, QColorTrcLut const*) | static inline void alphargbblend_argb32(quint32 *dst, uint coverage, const QRgba64 &srcLinear, quint32 src, const QColorTrcLut *colorProfile)
{
if (coverage == 0xff000000) {
// nothing
} else if (coverage == 0xffffffff && qAlpha(src) == 255) {
blend_pixel(*dst, src);
} else if (*dst < 0xff00... | pushq %rbx
cmpl $0xff000000, %esi # imm = 0xFF000000
je 0x570431
movq %rdi, %rbx
cmpl $-0x1, %esi
jne 0x570004
cmpl $0xfeffffff, %ecx # imm = 0xFEFFFFFF
ja 0x57042f
movl (%rbx), %eax
movl %eax, %edi
shrl $0x18, %edi
cmpl $0xfe, %edi
ja 0x5700ad
movl %esi, %edx
shrl $0x10, %edx
movl $0xff, %edi
andl %edi, %e... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
GradientBase32::fetchSingle(QGradientData const&, double) | static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
{
int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + qreal(0.5));
return data->colorTable32[qt_gradient_clamp(data, ipos)];
} | endbr64
mulsd 0x2cc6e(%rip), %xmm0 # 0x59da48
addsd 0x3e6e(%rip), %xmm0 # 0x574c50
movq 0x40(%rdi), %rax
cvttsd2si %xmm0, %ecx
cmpl $0x400, %ecx # imm = 0x400
jb 0x570e26
movl (%rdi), %edx
cmpl $0x1, %edx
je 0x570e06
cmpl $0x2, %edx
jne 0x570e1a
andl $0x3ff, %ecx # imm = 0x3FF
jmp 0x570e26
... | /qt[P]qtbase/src/gui/painting/qdrawhelper_p.h |
GradientBaseFP::fetchSingle(QGradientData const&, int) | static Type fetchSingle(const QGradientData& gradient, int v)
{
return qt_gradient_pixelFP_fixed(&gradient, v);
} | endbr64
movq 0x38(%rdi), %rax
subl $-0x80, %esi
sarl $0x8, %esi
cmpl $0x400, %esi # imm = 0x400
jb 0x570ed6
movl (%rdi), %ecx
cmpl $0x1, %ecx
je 0x570eb6
cmpl $0x2, %ecx
jne 0x570eca
andl $0x3ff, %esi # imm = 0x3FF
jmp 0x570ed6
movl $0x7ff, %ecx # imm = 0x7FF
andl %ecx, %esi
xorl %esi, ... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
void QThreadPool::start<void handleSpans<BlendSrcGenericRGB64>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'(), true>(void handleSpans<BlendSrcGenericRGB64>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'()&&, int) | void QThreadPool::start(Callable &&functionToRun, int priority)
{
start(QRunnable::create(std::forward<Callable>(functionToRun)), priority);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r12
movb $0x1, 0x8(%rax)
movq 0x17d890(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, (%r12)
movl $0x20, %edi
callq 0x1387d0
leaq 0x28d(%rip), %rcx # 0x... | /qt[P]qtbase/src/corelib/thread/qthreadpool.h |
void QThreadPool::start<void handleSpans<BlendSrcGenericRGBFP>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'(), true>(void handleSpans<BlendSrcGenericRGBFP>(int, QT_FT_Span_ const*, QSpanData const*, Operator const&)::'lambda'()&&, int) | void QThreadPool::start(Callable &&functionToRun, int priority)
{
start(QRunnable::create(std::forward<Callable>(functionToRun)), priority);
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x1387d0
movq %rax, %r12
movb $0x1, 0x8(%rax)
movq 0x17d36a(%rip), %rax # 0x6ef0c0
addq $0x10, %rax
movq %rax, (%r12)
movl $0x20, %edi
callq 0x1387d0
leaq 0x28d(%rip), %rcx # 0x... | /qt[P]qtbase/src/corelib/thread/qthreadpool.h |
RadialFetchPlain<GradientBase32>::fetch(unsigned int*, unsigned int*, Operator const*, QSpanData const*, double, double, double, double, double) | static void fetch(BlendType *buffer, BlendType *end,
const Operator *op, const QSpanData *data, qreal det,
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
{
if (op->radial.extended) {
while (buffer < end) {
BlendType res... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movapd %xmm0, %xmm6
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xa8(%rdx)
movsd %xmm4, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
je 0x572231
cmpq %r14, %r15
jae 0x5722bc
movq %rdx, %r12
leaq 0xa8(%rbx), %r13
xorpd %xmm7,... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
RadialFetchPlain<GradientBase64>::fetch(QRgba64*, QRgba64*, Operator const*, QSpanData const*, double, double, double, double, double) | static void fetch(BlendType *buffer, BlendType *end,
const Operator *op, const QSpanData *data, qreal det,
qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
{
if (op->radial.extended) {
while (buffer < end) {
BlendType res... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xa8(%rdx)
movsd %xmm4, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
je 0x5723b8
cmpq %r14, %r15
jae 0x572441
movq %rdx, %r12
leaq 0xa8(%rbx), %r13
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jae... | /qt[P]qtbase/src/gui/painting/qdrawhelper.cpp |
QEdidParser::parseEdidString(unsigned char const*) | QString QEdidParser::parseEdidString(const quint8 *data)
{
QByteArray buffer(reinterpret_cast<const char *>(data), 13);
for (int i = 0; i < buffer.size(); ++i) {
// If there are less than 13 characters in the string, the string
// is terminated with the ASCII code ‘0Ah’ (line feed) and padded
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rsi
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r14
movq %rax, 0x10(%r14)
movaps 0x1671(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r14)
movl $0xd, %edx
movq %r14... | /qt[P]qtbase/src/gui/util/qedidparser.cpp |
QList<unsigned short>::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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x5731ae
movq 0x8(%rax), %rcx
movq 0x8(%rbx), %rdx
leaq 0x1f(%rax), %rdi
andq $-0x10, %rdi
subq %rdi, %rdx
sarq %rdx
subq %rdx, %rcx
cmpq %rsi, %rcx
jge 0x... | /qt[P]qtbase/src/corelib/tools/qlist.h |
void QtPrivate::QMovableArrayOps<QList<unsigned short>>::emplace<QList<unsigned short> const&>(long long, QList<unsigned short> const&) | void emplace(qsizetype i, Args &&... args)
{
bool detach = this->needsDetach();
if (!detach) {
if (i == this->size && this->freeSpaceAtEnd()) {
new (this->end()) T(std::forward<Args>(args)...);
++this->size;
return;
}
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x5732e5
movl (%rcx), %eax
cmpl $0x1, %eax
jg 0x5732e5
leaq 0x10(%r14), %r12
movq 0x10(%r14), %rax
cmpq %rbx, %rax
jne 0x5732cb
movq 0x8(%rcx), %rdi
movq 0x8(%r14), ... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QList<unsigned short>>::detachAndGrow(QArrayData::GrowthPosition, long long, QList<unsigned short> const**, QArrayDataPointer<QList<unsigned short>>*) | 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
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq (%rdi), %rax
testq %rax, %rax
je 0x573459
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x573473
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QList<unsigned short>>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QList<unsigned short>>*) | 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
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ecx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
testl %esi, %esi
setne %al
testq %r14, %r14
setne %dl
orb %al, %dl
jne 0x573652
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x573652
movl (%rdi), %eax
testq %r15,... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.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.