name string | code string | asm string | file string |
|---|---|---|---|
operator==(QColorVector const&, QColorVector const&) | inline bool comparesEqual(const QColorVector &v1, const QColorVector &v2) noexcept
{
return (std::abs(v1.x - v2.x) < (1.0f / 2048.0f))
&& (std::abs(v1.y - v2.y) < (1.0f / 2048.0f))
&& (std::abs(v1.z - v2.z) < (1.0f / 2048.0f))
&& (std::abs(v1.w - v2.w) < (1.0f / 2048.0f));
} | endbr64
movss (%rdi), %xmm1
subss (%rsi), %xmm1
andps 0x310d36(%rip), %xmm1 # 0x577d50
movss 0x331ef6(%rip), %xmm0 # 0x598f18
ucomiss %xmm1, %xmm0
jbe 0x26706b
movss 0x4(%rdi), %xmm1
subss 0x4(%rsi), %xmm1
andps 0x310d18(%rip), %xmm1 # 0x577d50
ucomiss %xmm1, %xmm0
jbe 0x26706b
movss 0x8(%rdi), %xmm1
subss 0x8(%r... | /qt[P]qtbase/src/gui/painting/qcolormatrix_p.h |
comp_func_XOR_rgb64(QRgba64*, QRgba64 const*, int, unsigned int) | inline static void comp_func_XOR_template(typename Ops::Type *Q_DECL_RESTRICT dest,
const typename Ops::Type *Q_DECL_RESTRICT src,
int length, uint const_alpha)
{
if (const_alpha == 255) {
for (int i = 0; i < length; ++i) {
... | endbr64
cmpl $0xff, %ecx
jne 0x2782d9
testl %edx, %edx
jle 0x2783ac
movl %edx, %eax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
pxor %xmm1, %xmm1
movdqa 0x321853(%rip), %xmm2 # 0x599ab0
movq (%rdi,%rcx,8), %xmm5
movq (%rsi,%rcx,8), %xmm6
pshuflw $0xff, %xmm6, %xmm3 # xmm3 = xmm6[3,3,3,3,4,5,6,7]
pxor %xmm0, %xmm3
pshufl... | /qt[P]qtbase/src/gui/painting/qcompositionfunctions.cpp |
QRasterPaintEngine::fillPath(QPainterPath const&, QSpanData*) | void QRasterPaintEngine::fillPath(const QPainterPath &path, QSpanData *fillData)
{
#ifdef QT_DEBUG_DRAW
qDebug() << " --- fillPath, bounds=" << path.boundingRect();
#endif
if (!fillData->blend)
return;
Q_D(QRasterPaintEngine);
const QRectF controlPointRect = path.controlPointRect();
QRas... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x8(%rdx)
je 0x2ba386
movq %rdx, %r14
movq %rdi, %r12
movq 0x18(%rdi), %rbp
pcmpeqd %xmm0, %xmm0
leaq 0x40(%rsp), %rbx
movdqa %xmm0, 0x10(%rbx)
movdqa %xmm0, (%rbx)
movq %rbx, ... | /qt[P]qtbase/src/gui/painting/qpaintengine_raster.cpp |
QRasterPaintEngine::fillRect(QRectF const&, QSpanData*) | void QRasterPaintEngine::fillRect(const QRectF &r, QSpanData *data)
{
Q_D(QRasterPaintEngine);
QRasterPaintEngineState *s = state();
if (!s->flags.antialiased) {
uint txop = s->matrix.type();
if (txop == QTransform::TxNone) {
fillRect_normalized(toNormalizedFillRect(r), data, d)... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, 0x50(%rsp)
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rbx
leaq -0x8(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
testb $0x8, 0x414(%r15)
jne 0x2bc076
le... | /qt[P]qtbase/src/gui/painting/qpaintengine_raster.cpp |
void QtPrivate::q_relocate_overlap_n_left_move<QPdfEnginePrivate::AttachmentInfo*, long long>(QPdfEnginePrivate::AttachmentInfo*, long long, QPdfEnginePrivate::AttachmentInfo*) | void q_relocate_overlap_n_left_move(iterator first, N n, iterator d_first)
{
// requires: [first, n) is a valid range
// requires: d_first + n is reachable from d_first
// requires: iterator is at least a random access iterator
// requires: value_type(iterator) has a non-throwing destructor
Q_ASSER... | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, -0x10(%rcx)
movq %rdx, -0x8(%rcx)
leaq (%rsi,%rsi,8), %rax
leaq (%rdx,%rax,8), %rax
cmpq %rdi, %rax
movq %rax, %rsi
cmov... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
void QtPrivate::q_relocate_overlap_n_left_move<QPdfEnginePrivate::AttachmentInfo*, long long>(QPdfEnginePrivate::AttachmentInfo*, long long, QPdfEnginePrivate::AttachmentInfo*)::Destructor::~Destructor() | ~Destructor() noexcept
{
for (const int step = *iter < end ? 1 : -1; *iter != end;) {
std::advance(*iter, step);
(*iter)->~T();
}
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq (%rax), %rcx
cmpq %rdx, %rcx
je 0x30924a
movq %rdi, %rbx
xorl %esi, %esi
cmpq %rdx, %rcx
adcq $-0x1, %rsi
orq $0x1, %rsi
leaq (%rsi,%rsi,8), %r14
leaq (%rcx,%r14,8), %rcx
movq %rcx, (%rax)
movq (%rbx), %rax
movq (%rax), %r15
movq 0x30(... | /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<QPdfEnginePrivate::AttachmentInfo>::allocateGrow(QArrayDataPointer<QPdfEnginePrivate::AttachmentInfo> 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
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x309369
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movq %rsi, %rcx
subq %ra... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QGenericArrayOps<QPdfEnginePrivate::AttachmentInfo>::moveAppend(QPdfEnginePrivate::AttachmentInfo*, QPdfEnginePrivate::AttachmentInfo*) | 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
cmpq %rdx, %rsi
je 0x3095c7
jae 0x3095c7
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r8
xorl %ecx, %ecx
leaq (%r8,%r8,8), %r8
movq (%rsi), %r9
movq %rcx, (%rsi)
movq %r9, (%rax,%r8,8)
movq 0x8(%rsi), %r9
movq %rcx, 0x8(%rsi)
movq %r9, 0x8(%rax,%r8,8)
movq 0x10(%rsi), %r9
movq %rcx, 0x10(%rsi)
movq %r9, 0x10(%rax,%r8... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QHashPrivate::Data<QHashPrivate::Node<QFontEngine::FaceId, QFontSubset*>>::Data(QHashPrivate::Data<QHashPrivate::Node<QFontEngine::FaceId, QFontSubset*>> const&) | Data(const Data &other) : size(other.size), numBuckets(other.numBuckets), seed(other.seed)
{
auto r = allocateSpans(numBuckets);
spans = r.spans;
reallocationHelper<false>(other, r.nSpans);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x1, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rdi
movq %rsi, 0x8(%rsp)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
callq 0x309b7e
movq %rbx, 0x20(%rsp)
m... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QMap<QFont::Tag, float>::keys() const | QList<Key> keys() const
{
if (!d)
return {};
return d->keys();
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
xorps %xmm0, %xmm0
testq %r14, %r14
je 0x309fc2
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x30a11a
movq 0x20(%r14), %rdi
addq $0x10, %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30a226
jmp 0x309fcd
mo... | /qt[P]qtbase/src/corelib/tools/qmap.h |
unsigned long qHash<QFont::Tag>(QList<QFont::Tag> const&, unsigned long) | size_t qHash(const QList<T> &key, size_t seed = 0)
noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
{
return qHashRange(key.cbegin(), key.cend(), seed);
} | endbr64
movq %rsi, %rax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x30a09d
movq 0x8(%rdi), %rdx
movabsq $-0x2917014799a6026d, %rsi # imm = 0xD6E8FEB86659FD93
shlq $0x2, %rcx
xorl %edi, %edi
movl $0x9e3779b9, %r8d # imm = 0x9E3779B9
movl (%rdx,%rdi), %r9d
imulq %rsi, %r9
movq %r9, %r10
shrq $0x20, %r10
xorq %r9, %... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QFont::Tag>::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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x30a160
movq 0x8(%rax), %rdx
movq 0x8(%rbx), %rsi
leaq 0x1f(%rax), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
sarq $0x2, %rsi
subq %rsi, %rdx
cmpq %rcx, %rdx
jge 0x... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QArrayDataPointer<QFont::Tag>::detachAndGrow(QArrayData::GrowthPosition, long long, QFont::Tag const**, QArrayDataPointer<QFont::Tag>*) | 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 0x30a405
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x30a41f
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<QFont::Tag>::tryReadjustFreeSpace(QArrayData::GrowthPosition, long long, QFont::Tag const**) | qsizetype constAllocatedCapacity() const noexcept { return d ? d->constAllocatedCapacity() : 0; } | endbr64
movq (%rdi), %rax
testq %rax, %rax
je 0x30a4be
movq 0x8(%rax), %r9
movq 0x8(%rdi), %r8
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %r8
sarq $0x2, %r8
movq 0x10(%rdi), %rax
addq %r8, %rax
movq %r9, %r10
subq %rax, %r10
jmp 0x30a4c7
xorl %r8d, %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %esi, %esi
jne 0x30a4e3... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QFont::Tag>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QFont::Tag>*) | 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 0x30a5b6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x30a5b6
movl (%rdi), %eax
testq %r15,... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QFont::Tag, long long>(QFont::Tag*, long long, QFont::Tag*) | 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 0x30a789
testq %rdx, %rdx
je 0x30a789
movq %rdi, %rsi
testq %rdi, %rdi
je 0x30a789
cmpq %rdx, %rsi
je 0x30a789
shlq $0x2, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<QFont::Tag>::allocateGrow(QArrayDataPointer<QFont::Tag> 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
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x30a809
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
cmpq %rax, %rsi
movq %ra... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::QPodArrayOps<float>::emplace<float&>(long long, float&) | 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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x30aaeb
movl (%rcx), %eax
cmpl $0x1, %eax
jg 0x30aaeb
movq 0x10(%rbx), %rax
cmpq %r14, %rax
jne 0x30aad5
movq 0x8(%rbx), %rsi
leaq 0x1f(%rcx), %rdi
andq $-0x10, %rdi
movq %rsi, %r8
subq %rdi,... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<float>::detachAndGrow(QArrayData::GrowthPosition, long long, float const**, QArrayDataPointer<float>*) | 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 0x30abc7
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x30abe1
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 |
QHashPrivate::Data<QHashPrivate::Node<int, QTextObjectHandler>>::detached(QHashPrivate::Data<QHashPrivate::Node<int, QTextObjectHandler>>*) | static Data *detached(Data *d)
{
if (!d)
return new Data;
Data *dd = new Data(*d);
if (!d->ref.deref())
delete d;
return dd;
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x28, %edi
callq 0x1387d0
movq %rax, %rbx
testq %r14, %r14
je 0x375f27
movq %rbx, %rdi
movq %r14, %rsi
callq 0x375fa6
movl (%r14), %eax
cmpl $-0x1, %eax
je 0x375f9a
lock
decl (%r14)
jne 0x375f9a
movq %r14, %rdi
callq 0x374e1c
movl $0x28, %esi
movq %r14, %rd... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Data<QHashPrivate::Node<int, QTextObjectHandler>>::Data(QHashPrivate::Data<QHashPrivate::Node<int, QTextObjectHandler>> const&) | Data(const Data &other) : size(other.size), numBuckets(other.numBuckets), seed(other.seed)
{
auto r = allocateSpans(numBuckets);
spans = r.spans;
reallocationHelper<false>(other, r.nSpans);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x1, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rdi
movq %rsi, 0x8(%rsp)
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
callq 0x3755ec
movq %rbx, 0x20(%rsp)
m... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHash<int, QTextObjectHandler>::const_iterator QHash<int, QTextObjectHandler>::constFindImpl<int>(int const&) const | const_iterator constFindImpl(const K &key) const noexcept
{
if (isEmpty())
return end();
auto it = d->findBucket(key);
if (it.isUnused())
return end();
return const_iterator({d, it.toBucketIndex(d)});
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x376131
cmpq $0x0, 0x8(%rdi)
je 0x376131
movslq (%rsi), %rax
xorq 0x18(%rdi), %rax
movq %rax, %rcx
shrq $0x20, %rcx
xorq %rax, %rcx
movabsq $-0x2917014799a6026d, %rax # imm = 0xD6E8FEB86659FD93
imulq %rax, %rcx
movq %rcx, %r8
shrq $0x20, %r8
xorq... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QColrPaintGraphRenderer::setRadialGradient(QPointF, double, QPointF, double, QGradient::Spread, QList<std::pair<double, QColor>> const&) | void QColrPaintGraphRenderer::setRadialGradient(QPointF c0, qreal r0,
QPointF c1, qreal r1,
QGradient::Spread spread,
const QGradientStops &gradientStops)
{
if (m_painter !... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %fs:0x28, %rax
movq %rax, 0x170(%rsp)
movsd %xmm0, 0x140(%rsp)
movsd %xmm1, 0x148(%rsp)
movsd %xmm3, 0x130(%rsp)
movsd %xmm4, 0x138(%rsp)
cmpq $0x0, 0x18(%rdi)
je 0x378b3d
movq %rdx, %r12
movl %esi,... | /qt[P]qtbase/src/gui/text/qcolrpaintgraphrenderer.cpp |
QArrayDataPointer<QTransform>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QTransform>*) | 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 0x379e1c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x379e1c
movl (%rdi), %eax
testq %r15,... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QTransform>::relocate(long long, QTransform 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq (%rsi,%rsi,4), %r12
shlq $0x4, %r12
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq (%rdi,%r12), %r15
movq %r15, %rdx
callq 0x37a00f
testq %r14, %r14
je 0x379fff
movq (%r14), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb ... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QTransform, long long>(QTransform*, long long, QTransform*) | 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
testq %rsi, %rsi
je 0x37a040
testq %rdx, %rdx
je 0x37a040
movq %rdi, %rax
testq %rdi, %rdi
je 0x37a040
cmpq %rdx, %rax
je 0x37a040
shlq $0x4, %rsi
leaq (%rsi,%rsi,4), %rcx
movq %rdx, %rdi
movq %rax, %rsi
movq %rcx, %rdx
jmp 0x138810
retq
nop
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
initialDistanceFieldFactor() | static void initialDistanceFieldFactor()
{
static bool initialized = false;
if (initialized)
return;
initialized = true;
if (qEnvironmentVariableIsSet("QT_DISTANCEFIELD_DEFAULT_BASEFONTSIZE")) {
QT_DISTANCEFIELD_DEFAULT_BASEFONTSIZE = qEnvironmentVariableIntValue("QT_DISTANCEFIELD_DEFAU... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
cmpb $0x0, 0x3915f4(%rip) # 0x70b948
jne 0x37a739
movb $0x1, 0x3915e7(%rip) # 0x70b948
leaq 0x22ba08(%rip), %rdi # 0x5a5d70
callq 0x1452a0
testb %al, %al
je 0x37a457
leaq 0x22b9f4(%rip), %rdi # 0x5a5d70
xorl %esi, %esi
callq 0x... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
imageHasNarrowOutlines(QImage const&) | static bool imageHasNarrowOutlines(const QImage &im)
{
if (im.isNull() || im.width() < 1 || im.height() < 1)
return false;
else if (im.width() == 1 || im.height() == 1)
return true;
int minHThick = 999;
int minVThick = 999;
int thick = 0;
bool in = false;
int y = (im.height... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1469a0
testb %al, %al
jne 0x37a8ca
movq %rbx, %rdi
callq 0x141250
testl %eax, %eax
jle 0x37a8ca
movq %rbx, %rdi
callq 0x147520
testl %eax, %eax
jle 0x37a8ca
movq %rbx, %rdi
callq 0x141250
movb $0x1, %bpl
cmpl $0x1, %eax... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
QDistanceFieldData::QDistanceFieldData(QDistanceFieldData const&) | QDistanceFieldData::QDistanceFieldData(const QDistanceFieldData &other)
: QSharedData(other)
, glyph(other.glyph)
, width(other.width)
, height(other.height)
, nbytes(other.nbytes)
{
if (nbytes && other.data)
data = (uchar *)memcpy(malloc(nbytes), other.data, nbytes);
else
da... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, (%rdi)
movups 0x4(%rsi), %xmm0
movl 0x10(%rsi), %eax
movups %xmm0, 0x4(%rdi)
testl %eax, %eax
je 0x37ab35
movq 0x18(%rsi), %r15
testq %r15, %r15
je 0x37ab35
movslq %eax, %r12
movq %r12, %rdi
callq 0x1440f0
movq %rax, %r14
movq %ra... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
QDistanceFieldData::create(QSize const&) | QDistanceFieldData *QDistanceFieldData::create(const QSize &size)
{
QDistanceFieldData *data = new QDistanceFieldData;
if (size.isValid()) {
data->width = size.width();
data->height = size.height();
// pixel data stored as a 1-byte alpha value
data->nbytes = data->width * data->... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x20, %edi
callq 0x1387d0
movq %rax, %rbx
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movl (%r14), %eax
movl 0x4(%r14), %edi
movl %eax, %ecx
orl %edi, %ecx
js 0x37abab
movl %eax, 0x8(%rbx)
movl %edi, 0xc(%rbx)
imull %... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
QDistanceFieldData::create(QSize, QPainterPath const&, bool) | QDistanceFieldData *QDistanceFieldData::create(QSize size, const QPainterPath &path, bool doubleResolution)
{
QDistanceFieldData *data = create(size);
makeDistanceField(data,
path,
QT_DISTANCEFIELD_SCALE(doubleResolution),
QT_DISTANCEFIELD_RADIUS... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3088, %rsp # imm = 0x3088
movl %edx, %ebx
movq %rsi, %r12
movq %fs:0x28, %rax
movq %rax, 0x3080(%rsp)
leaq 0x160(%rsp), %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0x149630
movq %rax, 0xd0(%rsp)
callq 0x37a338
movl 0x37b6f5(%ri... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
QDistanceField::setGlyph(QFontEngine*, unsigned int, bool) | void QDistanceField::setGlyph(QFontEngine *fontEngine, glyph_t glyph, bool doubleResolution)
{
QFixedPoint position;
QPainterPath path;
fontEngine->addGlyphsToPath(&glyph, &position, 1, &path, { });
path.translate(-path.boundingRect().topLeft());
path.setFillRule(Qt::WindingFill);
d = QDistance... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x3c(%rsp), %r14
movl %edx, (%r14)
leaq 0x34(%rsp), %r13
movq $0x0, (%r13)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAA... | /qt[P]qtbase/src/gui/text/qdistancefield.cpp |
findAtNxFileOrResource(QString const&, double, double*, QString*) | static inline QUrl findAtNxFileOrResource(const QString &baseFileName,
qreal targetDevicePixelRatio,
qreal *sourceDevicePixelRatio,
QString *name)
{
// qt_findAtNxFile expects a file name th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r15
movsd %xmm0, (%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0x... | /qt[P]qtbase/src/gui/text/qtextimagehandler.cpp |
QTextBlock::end() const | QTextBlock::iterator QTextBlock::end() const
{
if (!p || !n)
return iterator();
int pos = position();
int len = length() - 1; // exclude the fragment that holds the paragraph separator
int b = p->fragmentMap().findNode(pos);
int e = p->fragmentMap().findNode(pos+len);
return iterator(p,... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
sete %cl
movl 0x8(%rsi), %eax
testl %eax, %eax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x42a958
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x42a9c1
movq %rsi, %... | /qt[P]qtbase/src/gui/text/qtextobject.cpp |
QTextFragment::position() const | int QTextFragment::position() const
{
if (!p || !n)
return 0; // ### -1 instead?
return p->fragmentMap().position(n);
} | endbr64
movq (%rdi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x42ad93
movl 0x8(%rdi), %ecx
testq %rcx, %rcx
je 0x42ad93
movq 0x158(%rdx), %rdx
movq %rcx, %rax
shlq $0x5, %rax
movl (%rdx,%rax), %esi
movl 0x10(%rdx,%rax), %eax
testl %esi, %esi
je 0x42ad93
movl %ecx, %edi
movl %esi, %ecx
movl %esi, %r8d
shlq $0x5, %r8
le... | /qt[P]qtbase/src/gui/text/qtextobject.cpp |
QtPrivate::QMovableArrayOps<QTextBlock>::insert(long long, long long, QTextBlock const&) | void insert(qsizetype i, qsizetype n, parameter_type t)
{
T copy(t);
const bool growsAtBegin = this->size != 0 && i == 0;
const auto pos = growsAtBegin ? Data::GrowsAtBeginning : Data::GrowsAtEnd;
this->detachAndGrow(pos, n, nullptr, nullptr);
Q_ASSERT((pos == Data::GrowsAt... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq (%rcx), %r13
movl 0x8(%rcx), %r15d
cmpq $0x0, 0x10(%rdi)
setne %al
testq %rsi, %rsi
sete %cl
andb %al, %cl
movzbl %cl, %ebp
movl %ebp,... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QTextBlock>::relocate(long long, QTextBlock 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
shlq $0x4, %r15
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq (%rdi,%r15), %r12
movq %r12, %rdx
callq 0x42b9ea
testq %r14, %r14
je 0x42b9da
movq (%r14), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x42b9da
... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QMovableArrayOps<QTextBlock>::erase(QTextBlock*, 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
movq %rdx, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rcx
cmpq %rax, %rdi
setne %r8b
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdi, %rdx
cmpq %rdx, %rsi
sete %dil
orb %r8b, %dil
je 0x42bc6e
cmpq %rdx, %... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QTextOption::setTabArray(QList<double> const&) | void QTextOption::setTabArray(const QList<qreal> &tabStops)
{
if (!d)
d = new QTextOptionPrivate;
QList<QTextOption::Tab> tabs;
QTextOption::Tab tab;
tabs.reserve(tabStops.size());
for (qreal pos : tabStops) {
tab.position = pos;
tabs.append(tab);
}
d->tabStops = tabs... | 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)
cmpq $0x0, 0x10(%rdi)
jne 0x42c077
movl $0x18, %edi
callq 0x1387d0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x10(%rbx)
xorp... | /qt[P]qtbase/src/gui/text/qtextoption.cpp |
QTextTableCell::tableCellFormatIndex() const | int QTextTableCell::tableCellFormatIndex() const
{
const QTextDocumentPrivate *p = QTextDocumentPrivate::get(table);
return QTextDocumentPrivate::FragmentIterator(&p->fragmentMap(), fragment)->format;
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x139e80
movq 0x8(%rax), %rax
movl 0x8(%rbx), %ecx
movq 0x158(%rax), %rax
shlq $0x5, %rcx
movl 0x1c(%rax,%rcx), %eax
popq %rbx
retq
| /qt[P]qtbase/src/gui/text/qtexttable.cpp |
QTextTablePrivate::update() const | void QTextTablePrivate::update() const
{
Q_Q(const QTextTable);
nCols = q->format().columns();
nRows = (cells.size() + nCols-1)/nCols;
// qDebug(">>>> QTextTablePrivate::update, nRows=%d, nCols=%d", nRows, nCols);
grid.assign(nRows * nCols, 0);
QTextDocumentPrivate *p = pieceTable;
QTextFo... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq 0x8(%rdi), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x3ccfe6
movq %r14, %rdi
movl $0x4100, %esi # imm = 0x4100
callq 0x138f70
cmpl $0x1, %eax
adcl $... | /qt[P]qtbase/src/gui/text/qtexttable.cpp |
QTextTablePrivate::createTable(QTextDocumentPrivate*, int, int, int, QTextTableFormat const&) | QTextTable *QTextTablePrivate::createTable(QTextDocumentPrivate *pieceTable, int pos, int rows, int cols, const QTextTableFormat &tableFormat)
{
QTextTableFormat fmt = tableFormat;
fmt.setColumns(cols);
QTextTable *table = qobject_cast<QTextTable *>(pieceTable->createObject(fmt));
Q_ASSERT(table);
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movl %edx, 0x14(%rsp)
movl %esi, %ebp
movq %rdi, %r13
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movaps 0x147729(%rip), %xmm0 # 0x574680
leaq 0x40(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r8, %rsi
... | /qt[P]qtbase/src/gui/text/qtexttable.cpp |
QTextTable::insertColumns(int, int) | void QTextTable::insertColumns(int pos, int num)
{
Q_D(QTextTable);
if (num <= 0)
return;
if (d->dirty)
d->update();
if (pos > d->nCols || pos < 0)
pos = d->nCols;
// qDebug() << "-------- insertCols" << pos << num;
QTextDocumentPrivate *p = d->pieceTable;
QTextFor... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %fs:0x28, %rax
movq %rax, 0xa0(%rsp)
testl %edx, %edx
jle 0x42dec0
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, 0x28(%rsp)
movq 0x8(%rdi), %r15
cmpb $0x1, 0x108(%r15)
jne 0x42d879
movq %r15, %rdi
callq 0x42c7e0
movl 0x104(%r15... | /qt[P]qtbase/src/gui/text/qtexttable.cpp |
QHashPrivate::Span<QHashPrivate::Node<QString, QOpenUrlHandlerRegistry::Handler>>::addStorage() | void addStorage()
{
Q_ASSERT(allocated < SpanConstants::NEntries);
Q_ASSERT(nextFree == allocated);
// the hash table should always be between 25 and 50% full
// this implies that we on average have between 32 and 64 entries
// in here. More exactly, we have a binominal distr... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movzbl 0x88(%rdi), %eax
cmpl $0x30, %eax
je 0x43234f
testl %eax, %eax
jne 0x43235f
movl $0xa80, %edi # imm = 0xA80
callq 0x13cd50
movq %rax, %r14
movl $0x30, %r15d
xorl %ecx, %ecx
jmp 0x432455
movl $0x5... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QGridLayoutRowData::stealBox(int, int, int, double*, double*) | void QGridLayoutRowData::stealBox(int start, int end, int which, qreal *positions, qreal *sizes)
{
qreal offset = 0.0;
qreal nextSpacing = 0.0;
for (int i = start; i < end; ++i) {
qreal avail = 0.0;
if (!ignore.testBit(i)) {
const QGridLayoutBox &box = boxes.at(i);
... | endbr64
cmpl %edx, %esi
jge 0x434a0f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %r10
movslq %esi, %r11
movl %esi, %esi
leaq (%r11,%r11,4), %rbx
leaq (%r10,%rbx,8), %rbx
leaq (,%r11,8), %r14
addq 0x58(%rdi), %r14
negl %edx
addq %rsi, %rdx
xorpd %xmm0, %xmm0
xo... | /qt[P]qtbase/src/gui/util/qgridlayoutengine.cpp |
QGridLayoutItem::effectiveMaxSize(QSizeF const&) const | QSizeF QGridLayoutItem::effectiveMaxSize(const QSizeF &constraint) const
{
QSizeF size = constraint;
bool vGrow = (sizePolicy(Qt::Vertical) & QLayoutPolicy::GrowFlag) == QLayoutPolicy::GrowFlag;
bool hGrow = (sizePolicy(Qt::Horizontal) & QLayoutPolicy::GrowFlag) == QLayoutPolicy::GrowFlag;
if (!vGrow ||... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rax
movl $0x2, %esi
callq *0x10(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x10(%rax... | /qt[P]qtbase/src/gui/util/qgridlayoutengine.cpp |
QGridLayoutItem::insertOrRemoveRows(int, int, Qt::Orientation) | constexpr const T &operator[](Qt::Orientation o) const { return m_data[map(o)]; } | endbr64
movslq %ecx, %rcx
movl 0x4(%rdi,%rcx,4), %eax
cmpl %esi, %eax
jge 0x4351cb
decq %rcx
movl 0x10(%rdi,%rcx,4), %r8d
addl %r8d, %eax
decl %eax
cmpl %esi, %eax
jl 0x4351d7
leaq (%rdi,%rcx,4), %rcx
addq $0x10, %rcx
movl %r8d, %eax
jmp 0x4351d3
leaq (%rdi,%rcx,4), %rcx
addq $0x4, %rcx
addl %edx, %eax
movl %eax, (%rcx... | /qt[P]qtbase/src/gui/util/qgridlayoutengine_p.h |
QGridLayoutRowInfo::insertOrRemoveRows(int, int) | void QGridLayoutRowInfo::insertOrRemoveRows(int row, int delta)
{
count += delta;
insertOrRemoveItems(stretches, row, delta);
insertOrRemoveItems(spacings, row, delta);
insertOrRemoveItems(alignments, row, delta);
insertOrRemoveItems(boxes, row, delta);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
addl %edx, (%rdi)
movl %esi, %r14d
movl 0x18(%rdi), %eax
subl %esi, %eax
jle 0x435231
leaq 0x8(%rbx), %r15
testl %ebp, %ebp
jle 0x435270
movslq %r14d, %rsi... | /qt[P]qtbase/src/gui/util/qgridlayoutengine.cpp |
QGridLayoutEngine::QGridLayoutEngine(QFlags<Qt::AlignmentFlag>, bool) | QGridLayoutEngine::QGridLayoutEngine(Qt::Alignment defaultAlignment, bool snapToPixelGrid)
{
m_visualDirection = Qt::LeftToRight;
m_defaultAlignment = defaultAlignment;
m_snapToPixelGrid = snapToPixelGrid;
m_uniformCellWidths = false;
m_uniformCellHeights = false;
invalidate();
} | endbr64
xorl %eax, %eax
movq %rax, 0x40(%rdi)
movl %eax, 0x48(%rdi)
movl %eax, 0x50(%rdi)
pxor %xmm0, %xmm0
movdqu %xmm0, 0xc0(%rdi)
movdqu %xmm0, 0xd0(%rdi)
movdqu %xmm0, 0xe0(%rdi)
movdqu %xmm0, 0xf0(%rdi)
movdqu %xmm0, 0x100(%rdi)
movdqu %xmm0, 0x110(%rdi)
movdqu %xmm0, 0x58(%rdi)
movdqu %xmm0, 0x68(%rdi)
movdqu %xm... | /qt[P]qtbase/src/gui/util/qgridlayoutengine.cpp |
QBitArray::fill(bool, long long) | bool fill(bool aval, qsizetype asize = -1)
{ *this = QBitArray((asize < 0 ? this->size() : asize), aval); return true; } | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
testq %rdx, %rdx
jns 0x438858
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
shlq $0x3, %rdx
testq %rax, %rax
jne 0x438851
movq 0x2b6cdf(%rip), %rax # 0x6ef530
movsbq (%rax), %rax
subq %rax, %rdx
movzbl %sil, %eax
mo... | /qt[P]qtbase/src/corelib/tools/qbitarray.h |
QList<QGridLayoutBox>::fill(QGridLayoutBox const&, long long) | inline QList<T> &QList<T>::fill(parameter_type t, qsizetype newSize)
{
if (newSize == -1)
newSize = size();
if (d->needsDetach() || newSize > capacity()) {
// must allocate memory
DataPointer detached(d->detachCapacity(newSize));
detached->copyAppend(newSize, t);
d.swap(d... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
cmpq $-0x1, %rdx
jne 0x4388fe
movq 0x10(%rbx), %r14
movq (%rbx), %rax
movq %r14, %rcx
testq %rax, %rax
je 0x438938
movl (%rax), %ecx
cmpl $0x2, %ecx
setge %dl
mo... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QList<QGridLayoutItem*>::fill(QGridLayoutItem*, long long) | inline QList<T> &QList<T>::fill(parameter_type t, qsizetype newSize)
{
if (newSize == -1)
newSize = size();
if (d->needsDetach() || newSize > capacity()) {
// must allocate memory
DataPointer detached(d->detachCapacity(newSize));
detached->copyAppend(newSize, t);
d.swap(d... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
cmpq $-0x1, %rdx
jne 0x43938a
movq 0x10(%rbx), %r15
movq (%rbx), %rax
movq %r15, %rcx
testq %rax, %rax
je 0x4393c4
movl (%rax), %ecx
cmpl $0x2, %ecx
setge %dl
mo... | /qt[P]qtbase/src/corelib/tools/qlist.h |
QArrayDataPointer<QStretchParameter>::detachAndGrow(QArrayData::GrowthPosition, long long, QStretchParameter const**, QArrayDataPointer<QStretchParameter>*) | 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 0x43a1bd
movl (%rax), %edx
cmpl $0x1, %edx
jle 0x43a1d7
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<QStretchParameter>::reallocateAndGrow(QArrayData::GrowthPosition, long long, QArrayDataPointer<QStretchParameter>*) | 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 0x43a36e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x43a36e
movl (%rdi), %eax
testq %r15,... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QArrayDataPointer<QStretchParameter>::relocate(long long, QStretchParameter 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq (%rdi,%r15,8), %r12
movq %r12, %rdx
callq 0x43a520
testq %r14, %r14
je 0x43a510
movq (%r14), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x43a510
movq 0x10(%rbx... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
void QtPrivate::q_relocate_overlap_n<QStretchParameter, long long>(QStretchParameter*, long long, QStretchParameter*) | 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 0x43a54d
testq %rdx, %rdx
je 0x43a54d
movq %rdi, %rsi
testq %rdi, %rdi
je 0x43a54d
cmpq %rdx, %rsi
je 0x43a54d
shlq $0x3, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<QLayoutParameter<double>>::allocateGrow(QArrayDataPointer<QLayoutParameter<double>> 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
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x43acb7
movq 0x8(%rdx), %rax
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rsi
cmpq %rax, %rsi
movq %ra... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QMovableArrayOps<QLayoutParameter<double>>::erase(QLayoutParameter<double>*, 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
movq %rdx, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rcx
cmpq %rax, %rdi
setne %r8b
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rdi, %rdx
cmpq %rdx, %rsi
sete %dil
orb %r8b, %dil
je 0x43adfa
cmpq %rdx, %... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
void QtPrivate::q_relocate_overlap_n<QFlags<Qt::AlignmentFlag>, long long>(QFlags<Qt::AlignmentFlag>*, long long, QFlags<Qt::AlignmentFlag>*) | 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 0x43b347
testq %rdx, %rdx
je 0x43b347
movq %rdi, %rsi
testq %rdi, %rdi
je 0x43b347
cmpq %rdx, %rsi
je 0x43b347
shlq $0x2, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QArrayDataPointer<QFlags<Qt::AlignmentFlag>>::allocateGrow(QArrayDataPointer<QFlags<Qt::AlignmentFlag>> 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
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x43b3c7
movq 0x8(%rdx), %rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
cmpq %rax, %rsi
movq %ra... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QtPrivate::QPodArrayOps<QFlags<Qt::AlignmentFlag>>::erase(QFlags<Qt::AlignmentFlag>*, 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,4), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
cmpq %rax, %rdx
setne %dil
leaq (%rdx,%rcx,4), %rdx
cmpq %rdx, %rsi
sete %r8b
orb %dil, %r8b
je 0x43b4f8
cmpq %rdx, %rsi
je 0x43b4fc
subq %rsi, %rdx
movq %rax, %rd... | /qt[P]qtbase/src/corelib/tools/qarraydataops.h |
QArrayDataPointer<QGridLayoutBox>::relocate(long long, QGridLayoutBox 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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq (%rsi,%rsi,4), %r12
movq 0x8(%rdi), %rdi
movq 0x10(%rbx), %rsi
leaq (%rdi,%r12,8), %r15
movq %r15, %rdx
callq 0x43b80b
testq %r14, %r14
je 0x43b7fb
movq (%r14), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x43b7fb
movq ... | /qt[P]qtbase/src/corelib/tools/qarraydatapointer.h |
QHashPrivate::Data<QHashPrivate::Node<QByteArray, QHashDummyValue>>::detached(QHashPrivate::Data<QHashPrivate::Node<QByteArray, QHashDummyValue>>*, unsigned long) | static Data *detached(Data *d, size_t size)
{
if (!d)
return new Data(size);
Data *dd = new Data(*d, size);
if (!d->ref.deref())
delete d;
return dd;
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x28, %edi
callq 0x1387d0
movq %rax, %rbx
movq %rax, %rdi
testq %r14, %r14
je 0x45ad9c
movq %r14, %rsi
movq %r15, %rdx
callq 0x45b664
movl (%r14), %eax
cmpl $-0x1, %eax
je 0x45ada4
lock
decl (%r14)
jne 0x45ada4
movq %r14, %rdi
callq 0x4543f6... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Data<QHashPrivate::Node<QByteArray, QHashDummyValue>>::allocateSpans(unsigned long) | static auto allocateSpans(size_t numBuckets)
{
struct R {
Span *spans;
size_t nSpans;
};
constexpr qptrdiff MaxSpanCount = (std::numeric_limits<qptrdiff>::max)() / sizeof(Span);
constexpr size_t MaxBucketCount = MaxSpanCount << SpanConstants::SpanShift;
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rdi, %rbx
shrq $0x7, %rbx
movq %rbx, %r15
shlq $0x4, %r15
leaq (%r15,%r15,8), %rdi
addq $0x8, %rdi
callq 0x13cd50
movq %rbx, (%rax)
leaq 0x8(%rax), %rcx
cmpq $0x80, %r14
jb 0x45ae44
addq $0x91, %rax
leaq (%r15,%r15,8), %rdx
xorl %esi, %esi
pcmpeqd %xmm0, %x... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHash<QByteArray, QHashDummyValue>::iterator QHash<QByteArray, QHashDummyValue>::emplace<QHashDummyValue const&>(QByteArray const&, QHashDummyValue const&) | iterator emplace(const Key &key, Args &&... args)
{
Key copy = key; // Needs to be explicit for MSVC 2019
return emplace(std::move(copy), std::forward<Args>(args)...);
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rsp)
testq %rax, %rax
je 0x45b7fc
lock
incl (%rax)
movq %rsp, %r15
movq %r15, %rsi
callq 0x45b852
movq ... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHash<QByteArray, QHashDummyValue>::iterator QHash<QByteArray, QHashDummyValue>::emplace_helper<QHashDummyValue const&>(QByteArray&&, QHashDummyValue const&) | 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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r14
movq %rax, 0x10(%r14)
movaps 0x118c2e(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r14)
movq (%rdi), %rsi
movq %r14, %rdi
movq %rbx, %rdx
ca... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHash<QByteArray, QHashDummyValue>::iterator QHash<QByteArray, QHashDummyValue>::emplace<QHashDummyValue>(QByteArray&&, QHashDummyValue&&) | iterator emplace(Key &&key, Args &&... args)
{
if (isDetached()) {
if (d->shouldGrow()) // Construct the value now so that no dangling references are used
return emplace_helper(std::move(key), T(std::forward<Args>(args)...));
return emplace_helper(std::move(key), std:... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x45be15
movl (%rdi), %eax
cmpl $0x1, %eax
ja 0x45be21
movq 0x10(%rdi), %rax
shrq %rax
cmpq %rax, 0x8(%rdi)
jae 0x45be82
movq %fs:0x28,... | /qt[P]qtbase/src/corelib/tools/qhash.h |
qt_gl_resolve_features() | static int qt_gl_resolve_features()
{
QOpenGLContext *ctx = QOpenGLContext::currentContext();
QOpenGLExtensionMatcher extensions;
int features = 0;
if ((extensions.match("GL_KHR_blend_equation_advanced")
|| extensions.match("GL_NV_blend_equation_advanced")) &&
(extensions.match("GL_KHR_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %fs:0x28, %rax
movq %rax, 0x70(%rsp)
movabsq $-0x5555555555555556, %r15 # imm = 0xAAAAAAAAAAAAAAAA
callq 0x148a80
movq %rax, %rbx
leaq 0x68(%rsp), %r14
movq %r15, (%r14)
movq %r14, %rdi
callq 0x142130
leaq 0x1577e5(%rip), %rsi # 0x5b37bb
leaq 0x50(%rs... | /qt[P]qtbase/src/gui/opengl/qopenglfunctions.cpp |
QOpenGLExtensions::openGLExtensions() | QOpenGLExtensions::OpenGLExtensions QOpenGLExtensions::openGLExtensions()
{
QOpenGLFunctionsPrivateEx *d = static_cast<QOpenGLFunctionsPrivateEx *>(d_ptr);
if (!d)
return { };
if (d->m_extensions == -1)
d->m_extensions = qt_gl_resolve_extensions();
return QOpenGLExtensions::OpenGLExtensi... | endbr64
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x45c9f7
movl 0xb60(%rbx), %eax
cmpl $-0x1, %eax
jne 0x45c9f9
callq 0x45c9fb
movl %eax, 0xb60(%rbx)
jmp 0x45c9f9
xorl %eax, %eax
popq %rbx
retq
| /qt[P]qtbase/src/gui/opengl/qopenglfunctions.cpp |
QOpenGLExtensions::hasOpenGLExtension(QOpenGLExtensions::OpenGLExtension) const | bool QOpenGLExtensions::hasOpenGLExtension(QOpenGLExtensions::OpenGLExtension extension) const
{
QOpenGLFunctionsPrivateEx *d = static_cast<QOpenGLFunctionsPrivateEx *>(d_ptr);
if (!d)
return false;
if (d->m_extensions == -1)
d->m_extensions = qt_gl_resolve_extensions();
return (d->m_ext... | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x45dd67
movl %esi, %ebx
movl 0xb60(%r14), %eax
cmpl $-0x1, %eax
jne 0x45dd60
callq 0x45c9fb
movl %eax, 0xb60(%r14)
testl %ebx, %eax
setne %al
jmp 0x45dd69
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /qt[P]qtbase/src/gui/opengl/qopenglfunctions.cpp |
(anonymous namespace)::getProcAddress(QOpenGLContext*, char const*) | static QFunctionPointer getProcAddress(QOpenGLContext *context, const char *funcName)
{
QFunctionPointer function = context->getProcAddress(funcName);
static const struct {
const char *name;
int len; // includes trailing \0
} extensions[] = {
{ "ARB", 4 },
{ "OES", 4 },
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x208(%rsp)
callq 0x144ff0
testq %rax, %rax
jne 0x45dfcf
movq %rsp, %r14
movl $0x200, %edx # imm = 0x200
movq %r14, %rdi
movl $0xaa, %esi
callq 0x13... | /qt[P]qtbase/src/gui/opengl/qopenglfunctions.cpp |
QOpenGLExtensions::flushShared() | void QOpenGLExtensions::flushShared()
{
Q_D(QOpenGLExtensions);
if (!d->flushVendorChecked) {
d->flushVendorChecked = true;
// It is not quite clear if glFlush() is sufficient to synchronize access to
// resources between sharing contexts in the same thread. On most platforms this
... | endbr64
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
cmpb $0x0, 0xb58(%r15)
jne 0x45e17d
movw $0x1, 0xb58(%r15)
movl $0x1f00, %edi # imm = 0x1F00
callq *0xd0(%r15)
testq %rax, %rax
je 0x45e17d
movq %rax, %r14
xorl %r12d, %r12d
leaq 0x15766b(%rip), %r13 # 0x5b57c0... | /qt[P]qtbase/src/gui/opengl/qopenglfunctions.cpp |
QOpenGLFunctionsPrivateEx* QOpenGLMultiGroupSharedResource::value<QOpenGLFunctionsPrivateEx>(QOpenGLContext*) | T *value(QOpenGLContext *context) {
QOpenGLContextGroup *group = context->shareGroup();
// Have to use our own mutex here, not the group's, since
// m_groups has to be protected too against any concurrent access.
QMutexLocker locker(&m_mutex);
T *resource = static_cast<T *>(group... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movq %rsi, %rdi
callq 0x146a00
movq %rax, %r12
leaq 0x20(%r15), %r14
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movabsq $0x100000000, %rdx # imm = 0x10000... | /qt[P]qtbase/src/gui/kernel/qopenglcontext_p.h |
QCache<QByteArray, QOpenGLProgramBinaryCache::MemCacheEntry>::unlink(QCache<QByteArray, QOpenGLProgramBinaryCache::MemCacheEntry>::Node*) | void unlink(Node *n) noexcept(std::is_nothrow_destructible_v<Node>)
{
Q_ASSERT(n->prev);
Q_ASSERT(n->next);
n->prev->next = n->next;
n->next->prev = n->prev;
total -= n->value.cost;
auto it = d.findBucket(n->key);
d.erase(it);
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq 0x30(%rsi), %rax
subq %rax, 0x40(%rdi)
leaq 0x10(%rsi), %r14
movq 0x28(%rdi), %rdx
addq $0x10, %rbx
movq 0x18(%rsi), %rax
movq 0x20(%rsi), %rdi
movq %rax, %rsi
callq 0x13d6f0
movq ... | /qt[P]qtbase/src/corelib/tools/qcache.h |
QRhiGles2InitParams::newFallbackSurface(QSurfaceFormat const&) | QOffscreenSurface *QRhiGles2InitParams::newFallbackSurface(const QSurfaceFormat &format)
{
QSurfaceFormat fmt = format;
// To resolve all fields in the format as much as possible, create a context.
// This may be heavy, but allows avoiding BAD_MATCH on some systems.
QOpenGLContext tempContext;
temp... | endbr64
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1435a0
movaps 0x112be9(%rip), %xmm0 # 0x574680
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r1... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QRhiGles2::evaluateFallbackSurface() const | QSurface *QRhiGles2::evaluateFallbackSurface() const
{
// With Apple's deprecated OpenGL support we need to minimize the usage of
// QOffscreenSurface since delicate problems can pop up with
// NSOpenGLContext and drawables.
#if defined(Q_OS_MACOS)
return maybeWindow && maybeWindow->handle() ? static_ca... | endbr64
movq 0x168(%rdi), %rax
retq
| /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QRhiGles2::releaseCachedResources() | void QRhiGles2::releaseCachedResources()
{
if (!ensureContext())
return;
for (uint shader : m_shaderCache)
f->glDeleteShader(shader);
m_shaderCache.clear();
m_pipelineCache.clear();
} | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x461de6
testb %al, %al
je 0x464547
leaq 0x868(%rbx), %r14
movq 0x868(%rbx), %r15
testq %r15, %r15
je 0x464553
movl (%r15), %eax
cmpl $0x2, %eax
jb 0x464539
movq %r15, %rdi
callq 0x476eca
movq %rax, %r15
movq %rax, (%r1... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QRhiGles2::setPipelineCacheData(QByteArray const&) | void QRhiGles2::setPipelineCacheData(const QByteArray &data)
{
if (data.isEmpty())
return;
const size_t headerSize = sizeof(QGles2PipelineCacheDataHeader);
if (data.size() < qsizetype(headerSize)) {
qCDebug(QRHI_LOG_INFO, "setPipelineCacheData: Invalid blob size (header incomplete)");
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %fs:0x28, %rax
movq %rax, 0x160(%rsp)
movq 0x10(%rsi), %r12
testq %r12, %r12
je 0x464ca4
cmpq $0xff, %r12
ja 0x464b57
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), ... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QRhiGles2::beginOffscreenFrame(QRhiCommandBuffer**, QFlags<QRhi::BeginFrameFlag>) | QRhi::FrameOpResult QRhiGles2::beginOffscreenFrame(QRhiCommandBuffer **cb, QRhi::BeginFrameFlags)
{
if (!ensureContext())
return contextLost ? QRhi::FrameOpDeviceLost : QRhi::FrameOpError;
ofr.active = true;
executeDeferredReleases();
ofr.cbWrapper.resetState();
if (rhiFlags.testFlag(QRhi... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x461de6
testb %al, %al
je 0x468cdb
movb $0x1, %bpl
movb %bpl, 0x2d8(%r14)
movq %r14, %rdi
callq 0x463cee
leaq 0x2e0(%r14), %r13
movl %ebx, 0x3bc(%r14)
movb %b... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QRhiGles2::beginComputePass(QRhiCommandBuffer*, QRhiResourceUpdateBatch*, QFlags<QRhiCommandBuffer::BeginPassFlag>) | void QRhiGles2::beginComputePass(QRhiCommandBuffer *cb,
QRhiResourceUpdateBatch *resourceUpdates,
QRhiCommandBuffer::BeginPassFlags)
{
QGles2CommandBuffer *cbD = QRHI_RES(QGles2CommandBuffer, cb);
Q_ASSERT(cbD->recordingPass == QGles2CommandBuffe... | endbr64
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x46d7db
movq %rbx, %rsi
callq 0x469da2
movq %rbx, %rsi
callq 0x46831e
movl $0x2, 0xdc(%rbx)
leaq 0x350(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
movl $0x0, 0x108(%rbx)
movups %xmm0, 0x110(%rbx)
movq $0x0, 0x11d(%rbx)
callq 0x4751a2
addq $0x358, %rbx ... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2Buffer::fullDynamicBufferUpdateForCurrentFrame(void const*, unsigned int) | void QGles2Buffer::fullDynamicBufferUpdateForCurrentFrame(const void *bufferData, quint32 size)
{
const quint32 copySize = size > 0 ? size : m_size;
if (!m_usage.testFlag(UniformBuffer)) {
QRHI_RES_RHI(QRhiGles2);
rhiD->f->glBindBuffer(targetForDataOps, buffer);
rhiD->f->glBufferSubData(... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jne 0x4702d7
movl 0x38(%r14), %ebp
testb $0x4, 0x34(%r14)
jne 0x470322
movq 0x8(%r14), %r15
movq 0x190(%r15), %rax
movl 0x44(%r14), %edi
movl 0x40(%r14), %esi
movq (%rax), %rax
callq *0x190(%r... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2RenderBuffer::createFrom(QRhiRenderBuffer::NativeRenderBuffer) | bool QGles2RenderBuffer::createFrom(NativeRenderBuffer src)
{
if (!src.object)
return false;
if (renderbuffer)
destroy();
QRHI_RES_RHI(QRhiGles2);
samples = rhiD->effectiveSampleCount(m_sampleCount);
if (m_flags.testFlag(UsedWithSwapChainOnly))
qWarning("RenderBuffer: Used... | endbr64
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
testq %rsi, %rsi
je 0x4708e2
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x48(%rdi)
je 0x47088d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x8(%rbx), %r15
movl 0x3c(%rbx), %esi
movq %r15, %rdi
cal... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2GraphicsPipeline::QGles2GraphicsPipeline(QRhiImplementation*) | QGles2GraphicsPipeline::QGles2GraphicsPipeline(QRhiImplementation *rhi)
: QRhiGraphicsPipeline(rhi)
{
} | endbr64
pushq %rbx
movq %rdi, %rbx
callq 0x1471a0
leaq 0x26c512(%rip), %rax # 0x6dec08
movq %rax, (%rbx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x360(%rbx)
movq $0x8, 0x368(%rbx)
xorl %eax, %eax
movq %rax, 0x370(%rbx)
leaq 0x380(%rbx), %rcx
movq %rcx, 0x378(%rbx)
movq $0x4, 0x440(%rbx)
movq %... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2ComputePipeline::destroy() | void QGles2ComputePipeline::destroy()
{
if (!program)
return;
QRhiGles2::DeferredReleaseEntry e;
e.type = QRhiGles2::DeferredReleaseEntry::Pipeline;
e.pipeline.program = program;
program = 0;
uniforms.clear();
samplers.clear();
QRHI_RES_RHI(QRhiGles2);
if (rhiD) {
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %fs:0x28, %rax
movq %rax, 0x18(%rsp)
movl 0x58(%rdi), %eax
testl %eax, %eax
je 0x473257
movq %rdi, %rbx
movl $0xaaaaaaaa, 0xc(%rsp) # imm = 0xAAAAAAAA
movl $0x1, 0x4(%rsp)
movl %eax, 0x8(%rsp)
movl $0x0, 0x58(%rdi)
xorl %eax, %eax
movq %rax, 0x68(%rdi)
mov... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2CommandBuffer::~QGles2CommandBuffer() | QGles2CommandBuffer::~QGles2CommandBuffer()
{
destroy();
} | endbr64
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x26b485(%rip), %rax # 0x6dec78
movq %rax, (%rdi)
movq 0x510(%rdi), %r15
movq 0x518(%rdi), %r14
testq %r15, %r15
jle 0x473828
incq %r15
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
addq $0x18, %r14
decq %r15
cmpq $0x1, %r15
ja 0x47380c
movq 0x518(%rbx)... | /qt[P]qtbase/src/gui/rhi/qrhigles2.cpp |
QGles2CommandBuffer::retainData(QByteArray const&) | const void *retainData(const QByteArray &data) {
dataRetainPool.append(data);
return dataRetainPool.last().constData();
} | endbr64
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
addq $0x458, %rdi # imm = 0x458
movq 0x460(%rbx), %rax
cmpq 0x458(%rbx), %rax
jne 0x4747e4
movq (%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x10(%rcx)... | /qt[P]qtbase/src/gui/rhi/qrhigles2_p.h |
QRhiPassResourceTracker::cbeginTextures() const | inline const_iterator cbegin() const noexcept { return d ? const_iterator(d->begin()): const_iterator(); } | endbr64
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4749b0
movq 0x20(%rax), %rcx
cmpb $-0x1, (%rcx)
jne 0x4749b2
movq 0x10(%rax), %rdi
movl $0x1, %esi
xorl %edx, %edx
cmpq %rsi, %rdi
je 0x4749b5
movq %rsi, %r8
shrq $0x7, %r8
leaq (%r8,%r8,8), %r8
shlq $0x4, %r8
addq %rcx, %r8
movl %esi, %r9d
andl $0x7f, %r9d
incq %rsi
c... | /qt[P]qtbase/src/corelib/tools/qhash.h |
void QtPrivate::q_relocate_overlap_n<QAccessible::ActivationObserver*, long long>(QAccessible::ActivationObserver**, long long, QAccessible::ActivationObserver**) | 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 0x485089
testq %rdx, %rdx
je 0x485089
movq %rdi, %rsi
testq %rdi, %rdi
je 0x485089
cmpq %rdx, %rsi
je 0x485089
shlq $0x3, %rax
movq %rdx, %rdi
movq %rax, %rdx
jmp 0x138810
retq
| /qt[P]qtbase/src/corelib/tools/qcontainertools_impl.h |
QAccessibleBridgeUtils::performEffectiveAction(QAccessibleInterface*, QString const&) | bool performEffectiveAction(QAccessibleInterface *iface, const QString &actionName)
{
if (!iface)
return false;
if (performAction(iface, actionName))
return true;
if (actionName != QAccessibleActionInterface::increaseAction()
&& actionName != QAccessibleActionInterface::decreaseActio... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, 0x68(%rsp)
testq %rdi, %rdi
je 0x486dea
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl $0x3, %esi
callq *0xa0(%rax)
testq %rax, %rax
je 0x486c4c
movq %rax, %r15
movq (%rax), %rax
leaq 0x40(%rsp), %r12
... | /qt[P]qtbase/src/gui/accessible/qaccessiblebridgeutils.cpp |
QAccessibleCache::idForObject(QObject*) const | QAccessible::Id QAccessibleCache::idForObject(QObject *obj) const
{
if (obj) {
const QMetaObject *mo = obj->metaObject();
for (auto pair : objectToId.values(obj)) {
if (pair.second == mo) {
return pair.first;
}
}
}
return 0;
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %fs:0x28, %rax
movq %rax, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
testq %rsi, %rsi
je 0x4875d3
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %rax, %rbx
addq $0x20, %r14
movq %rsp, %r15
leaq 0x18(%rsp), %rdx
movq %r15, %rdi
movq %r... | /qt[P]qtbase/src/gui/accessible/qaccessiblecache.cpp |
QMultiHash<QObject*, std::pair<unsigned int, QMetaObject const*>>::iterator QMultiHash<QObject*, std::pair<unsigned int, QMetaObject const*>>::emplace_helper<std::pair<unsigned int, QMetaObject const*>>(QObject*&&, std::pair<unsigned int, QMetaObject const*>&&) | 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()->insertMulti(std::forward<Args>(args)...);
... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x10(%rsp), %r13
movq %rax, 0x10(%r13)
movaps 0xeba... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Data<QHashPrivate::Node<unsigned int, QAccessibleInterface*>>::rehash(unsigned long) | void rehash(size_t sizeHint = 0)
{
if (sizeHint == 0)
sizeHint = size;
size_t newBucketCount = GrowthPolicy::bucketsForCapacity(sizeHint);
Span *oldSpans = spans;
size_t oldBucketCount = numBuckets;
spans = allocateSpans(newBucketCount).spans;
numBuckets ... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x489f6e
movq 0x8(%rbx), %rsi
movl $0x80, %r14d
cmpq $0x41, %rsi
jb 0x489f9e
movq %rsi, %rax
shrq $0x3e, %rax
movq $-0x1, %r14
jne 0x489f9e
bsrq %rsi, %rax
xorl $0x3f, %eax
movb $0x41, %cl
sub... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QHashPrivate::Data<QHashPrivate::Node<QAccessibleInterface*, unsigned int>>::detached(QHashPrivate::Data<QHashPrivate::Node<QAccessibleInterface*, unsigned int>>*) | static Data *detached(Data *d)
{
if (!d)
return new Data;
Data *dd = new Data(*d);
if (!d->ref.deref())
delete d;
return dd;
} | endbr64
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x28, %edi
callq 0x1387d0
movq %rax, %rbx
testq %r14, %r14
je 0x48b8fb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x48b97a
movl (%r14), %eax
cmpl $-0x1, %eax
je 0x48b96e
lock
decl (%r14)
jne 0x48b96e
movq %r14, %rdi
callq 0x487fc2
movl $0x28, %esi
movq %r14, %rd... | /qt[P]qtbase/src/corelib/tools/qhash.h |
QtGlobalStatic::Holder<(anonymous namespace)::Q_QGS_bridgeloader>::Holder() | Holder() noexcept(ConstructionIsNoexcept)
{
QGS::innerFunction(pointer());
guard.storeRelaxed(QtGlobalStatic::Initialized);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %fs:0x28, %rax
movq %rax, 0x40(%rsp)
leaq 0x12cdbf(%rip), %rdx # 0x5b9ba7
leaq 0x20(%rsp), %rbx
movl $0x11, %esi
movq %rbx, %rdi
callq 0x143140
movaps (%rbx), %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
leaq 0x27f9b5(%rip), %rdi ... | /qt[P]qtbase/src/corelib/global/qglobalstatic.h |
QAction::shortcut() const | QKeySequence QAction::shortcut() const
{
Q_D(const QAction);
if (d->shortcuts.isEmpty())
return QKeySequence();
return d->shortcuts.first();
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq $0x0, 0x118(%rax)
je 0x48decb
movq 0x110(%rax), %rsi
movq %rbx, %rdi
callq 0x13fb60
jmp 0x48ded3
movq %rbx, %rdi
callq 0x145840
movq %rbx, %rax
popq %rbx
retq
| /qt[P]qtbase/src/gui/kernel/qaction.cpp |
QBasicDrag::cancel() | void QBasicDrag::cancel()
{
disableEventFilter();
restoreCursor();
m_drag_icon_window->setVisible(false);
} | endbr64
pushq %rbx
movq %rdi, %rbx
movq 0x25907b(%rip), %rax # 0x6ee968
movq (%rax), %rdi
leaq 0x10(%rbx), %rsi
callq 0x1451f0
cmpb $0x1, 0x38(%rbx)
jne 0x495908
callq 0x13fc80
movb $0x0, 0x38(%rbx)
movq 0x58(%rbx), %rdi
xorl %esi, %esi
popq %rbx
jmp 0x1396f0
| /qt[P]qtbase/src/gui/kernel/qsimpledrag.cpp |
operator>>(QDataStream&, QKeySequence&) | QDataStream &operator>>(QDataStream &s, QKeySequence &keysequence)
{
const quint32 MaxKeys = QKeySequencePrivate::MaxKeyCount;
quint32 c;
s >> c;
quint32 keys[MaxKeys] = {0};
for (uint i = 0; i < qMin(c, MaxKeys); ++i) {
if (s.atEnd()) {
qWarning("Premature EOF while reading QKey... | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x28(%rsp)
leaq 0xc(%rsp), %r15
movl $0xaaaaaaaa, (%r15) # imm = 0xAAAAAAAA
movq %r15, %rsi
callq 0x13f5f0
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
cmpl $0x0, (%r15)
je 0... | /qt[P]qtbase/src/gui/kernel/qkeysequence.cpp |
QObjectCompatProperty<QMoviePrivate, int, &QMoviePrivate::_qt_property_speed_offset(), &QMoviePrivate::setSpeed(int), nullptr, nullptr>::setValue(int) | void setValue(parameter_type t)
{
QBindingStorage *storage = qGetBindingStorage(owner());
if (auto *bd = storage->bindingData(this)) {
// make sure we don't remove the binding if called from the bindingWrapper
if (bd->hasBinding() && !inBindingWrapper(storage))
... | endbr64
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
cmpq $0x0, -0x40(%rdi)
je 0x4a30f2
leaq -0x40(%r14), %rdi
movq %r14, %rsi
callq 0x13b740
testq %rax, %rax
je 0x4a30f2
movq %rax, %r15
testb $0x1, (%rax)
je 0x4a30f2
movq -0x38(%r14), %rax
testq %rax, %rax
je 0x4a30ea
cmpq $0x0, 0x8(%rax)
je 0x4a30... | /qt[P]qtbase/src/corelib/kernel/qproperty_p.h |
QPngHandler::supportsOption(QImageIOHandler::ImageOption) const | bool QPngHandler::supportsOption(ImageOption option) const
{
return option == Gamma
|| option == Description
|| option == ImageFormat
|| option == Quality
|| option == CompressionRatio
|| option == Size;
} | endbr64
movl %esi, %ecx
cmpl $0xf, %esi
setb %dl
movl $0x40e5, %eax # imm = 0x40E5
shrl %cl, %eax
andb %dl, %al
retq
| /qt[P]qtbase/src/gui/image/qpnghandler.cpp |
storeRGBx64FromRGBA64PM_sse4(unsigned char*, QRgba64 const*, int, int, QList<unsigned int> const*, QDitherInfo*) | void QT_FASTCALL storeRGBx64FromRGBA64PM_sse4(uchar *dest, const QRgba64 *src, int index, int count,
const QList<QRgb> *, QDitherInfo *)
{
QRgba64 *d = (QRgba64 *)dest + index;
convertRGBA64FromRGBA64PM_sse4<true>(d, src, count);
} | endbr64
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
stmxcsr 0xc(%rsp)
movq %rdi, %rbx
movslq %edx, %rax
testb $-0x80, 0xc(%rsp)
jne 0x4aceac
testl %ecx, %ecx
jle 0x4ad09f
leaq (%rbx,%rax,8), %rbx
movabsq $-0x1000000000000, ... | /qt[P]qtbase/src/gui/painting/qdrawhelper_sse4.cpp |
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.