name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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(%rsi), %xmm1
andps 0x310d02(%rip), %xmm1 # 0x577d50
ucomiss %xmm1, %xmm0
jbe 0x26706b
movss 0xc(%rdi), %xmm1
subss 0xc(%rsi), %xmm1
andps 0x310cec(%rip), %xmm1 # 0x577d50
ucomiss %xmm1, %xmm0
seta %al
retq
xorl %eax, %eax
retq
| /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) {
auto d = Ops::load(&dest[i]);
auto s = Ops::load(&src[i]);
Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, Ops::invAlpha(s)));
}
} else {
for (int i = 0; i < length; ++i) {
auto d = Ops::load(&dest[i]);
auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, Ops::invAlpha(s)));
}
}
} | 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
pshuflw $0xff, %xmm5, %xmm4 # xmm4 = xmm5[3,3,3,3,4,5,6,7]
pxor %xmm0, %xmm4
movdqa %xmm4, %xmm7
pmullw %xmm6, %xmm7
pmulhuw %xmm6, %xmm4
punpcklwd %xmm4, %xmm7 # xmm7 = xmm7[0],xmm4[0],xmm7[1],xmm4[1],xmm7[2],xmm4[2],xmm7[3],xmm4[3]
punpcklwd %xmm1, %xmm4 # xmm4 = xmm4[0],xmm1[0],xmm4[1],xmm1[1],xmm4[2],xmm1[2],xmm4[3],xmm1[3]
paddd %xmm7, %xmm4
paddd %xmm2, %xmm4
psrad $0x10, %xmm4
packssdw %xmm4, %xmm4
movdqa %xmm3, %xmm6
pmullw %xmm5, %xmm6
pmulhuw %xmm5, %xmm3
punpcklwd %xmm3, %xmm6 # xmm6 = xmm6[0],xmm3[0],xmm6[1],xmm3[1],xmm6[2],xmm3[2],xmm6[3],xmm3[3]
punpcklwd %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1],xmm3[2],xmm1[2],xmm3[3],xmm1[3]
paddd %xmm6, %xmm3
paddd %xmm2, %xmm3
psrad $0x10, %xmm3
packssdw %xmm3, %xmm3
paddw %xmm4, %xmm3
movq %xmm3, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x27825d
jmp 0x2783ac
testl %edx, %edx
jle 0x2783ac
movzbl %cl, %eax
movl %eax, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movd %ecx, %xmm0
pshuflw $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0,4,5,6,7]
movl %edx, %eax
xorl %ecx, %ecx
pxor %xmm1, %xmm1
movdqa 0x3217ac(%rip), %xmm2 # 0x599ab0
pcmpeqd %xmm3, %xmm3
movq (%rdi,%rcx,8), %xmm4
movq (%rsi,%rcx,8), %xmm7
movdqa %xmm0, %xmm5
pmullw %xmm7, %xmm5
pmulhuw %xmm0, %xmm7
punpcklwd %xmm7, %xmm5 # xmm5 = xmm5[0],xmm7[0],xmm5[1],xmm7[1],xmm5[2],xmm7[2],xmm5[3],xmm7[3]
punpcklwd %xmm1, %xmm7 # xmm7 = xmm7[0],xmm1[0],xmm7[1],xmm1[1],xmm7[2],xmm1[2],xmm7[3],xmm1[3]
paddd %xmm5, %xmm7
paddd %xmm2, %xmm7
psrad $0x10, %xmm7
packssdw %xmm7, %xmm7
pshuflw $0xff, %xmm7, %xmm5 # xmm5 = xmm7[3,3,3,3,4,5,6,7]
pxor %xmm3, %xmm5
pshuflw $0xff, %xmm4, %xmm6 # xmm6 = xmm4[3,3,3,3,4,5,6,7]
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm8
pmullw %xmm7, %xmm8
pmulhuw %xmm7, %xmm6
punpcklwd %xmm6, %xmm8 # xmm8 = xmm8[0],xmm6[0],xmm8[1],xmm6[1],xmm8[2],xmm6[2],xmm8[3],xmm6[3]
punpcklwd %xmm1, %xmm6 # xmm6 = xmm6[0],xmm1[0],xmm6[1],xmm1[1],xmm6[2],xmm1[2],xmm6[3],xmm1[3]
paddd %xmm8, %xmm6
paddd %xmm2, %xmm6
psrad $0x10, %xmm6
packssdw %xmm6, %xmm6
movdqa %xmm5, %xmm7
pmullw %xmm4, %xmm7
pmulhuw %xmm4, %xmm5
punpcklwd %xmm5, %xmm7 # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1],xmm7[2],xmm5[2],xmm7[3],xmm5[3]
punpcklwd %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1],xmm5[2],xmm1[2],xmm5[3],xmm1[3]
paddd %xmm7, %xmm5
paddd %xmm2, %xmm5
psrad $0x10, %xmm5
packssdw %xmm5, %xmm5
paddw %xmm6, %xmm5
movq %xmm5, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x278308
retq
| /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();
QRasterPaintEngineState *s = state();
const QRect deviceRect = s->matrix.mapRect(controlPointRect).toRect();
ProcessSpans blend = d->getBrushFunc(deviceRect, fillData);
const bool do_clip = (deviceRect.left() < -QT_RASTER_COORD_LIMIT
|| deviceRect.right() > QT_RASTER_COORD_LIMIT
|| deviceRect.top() < -QT_RASTER_COORD_LIMIT
|| deviceRect.bottom() > QT_RASTER_COORD_LIMIT);
if (!s->flags.antialiased && !do_clip) {
d->initializeRasterizer(fillData);
d->rasterizer->rasterize(path * s->matrix, path.fillRule());
return;
}
ensureOutlineMapper();
d->rasterize(d->outlineMapper->convertPath(path), blend, fillData, d->rasterBuffer.data());
} | 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, %rdi
movq %rsi, (%rsp)
callq 0x13faa0
movq 0x8(%r12), %rax
leaq -0x8(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
movaps 0x2ba5cc(%rip), %xmm0 # 0x574680
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0xd8(%r15), %rsi
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %rsi, 0x8(%rsp)
movq %rbx, %rdx
movq %rbp, %rbx
callq 0x147920
movsd (%r13), %xmm5
movapd 0x2ba687(%rip), %xmm0 # 0x574770
movapd %xmm5, %xmm4
andpd %xmm0, %xmm4
movapd 0x2ba687(%rip), %xmm3 # 0x574780
orpd %xmm3, %xmm4
addsd %xmm5, %xmm4
movsd 0x2baa97(%rip), %xmm2 # 0x574ba0
movsd 0x2baa97(%rip), %xmm1 # 0x574ba8
movapd %xmm1, %xmm7
cmpltsd %xmm4, %xmm7
maxsd %xmm2, %xmm4
movapd %xmm7, %xmm6
andnpd %xmm4, %xmm6
andpd %xmm1, %xmm7
orpd %xmm6, %xmm7
cvttsd2si %xmm7, %eax
movsd 0x8(%r13), %xmm4
movapd %xmm4, %xmm8
andpd %xmm0, %xmm8
orpd %xmm3, %xmm8
addsd %xmm4, %xmm8
movapd %xmm1, %xmm6
cmpltsd %xmm8, %xmm6
maxsd %xmm2, %xmm8
movapd %xmm6, %xmm9
andnpd %xmm8, %xmm9
andpd %xmm1, %xmm6
orpd %xmm9, %xmm6
cvttsd2si %xmm6, %ecx
cvttpd2dq %xmm7, %xmm7
cvtdq2pd %xmm7, %xmm7
subsd %xmm7, %xmm5
movsd 0x2baaca(%rip), %xmm7 # 0x574c50
mulsd %xmm7, %xmm5
addsd 0x10(%r13), %xmm5
movapd %xmm5, %xmm8
andpd %xmm0, %xmm8
orpd %xmm3, %xmm8
addsd %xmm5, %xmm8
movapd %xmm1, %xmm5
cmpltsd %xmm8, %xmm5
maxsd %xmm2, %xmm8
movapd %xmm5, %xmm9
andnpd %xmm8, %xmm9
andpd %xmm1, %xmm5
orpd %xmm9, %xmm5
cvttsd2si %xmm5, %edx
cvttpd2dq %xmm6, %xmm5
cvtdq2pd %xmm5, %xmm5
subsd %xmm5, %xmm4
mulsd %xmm7, %xmm4
addsd 0x18(%r13), %xmm4
andpd %xmm4, %xmm0
orpd %xmm3, %xmm0
addsd %xmm4, %xmm0
movapd %xmm1, %xmm3
cmpltsd %xmm0, %xmm3
maxsd %xmm2, %xmm0
movapd %xmm3, %xmm2
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm3
orpd %xmm2, %xmm3
cvttsd2si %xmm3, %esi
addl %eax, %edx
decl %edx
addl %ecx, %esi
decl %esi
shlq $0x20, %rcx
orq %rcx, %rax
shlq $0x20, %rsi
orq %rsi, %rdx
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbp, %rdi
movq %rsi, %rbp
xorl %edx, %edx
callq 0x2c1e7c
movzbl %al, %eax
movq 0x8(%r14,%rax,8), %r13
cmpl $0xff800001, (%rbp) # imm = 0xFF800001
jl 0x2ba2c5
cmpl $0x7fffff, 0x38(%rsp) # imm = 0x7FFFFF
jg 0x2ba2c5
cmpl $0xff800001, 0x34(%rsp) # imm = 0xFF800001
jl 0x2ba2c5
cmpl $0x7fffff, 0x3c(%rsp) # imm = 0x7FFFFF
jg 0x2ba2c5
movzwl 0x414(%r15), %eax
andl $0x8, %eax
jne 0x2ba2c5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ba3aa
movq 0x660(%rbx), %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %r15
movq %r15, %rdx
callq 0x149280
movq %r15, %rdi
callq 0x13d2b0
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x327778
movq %r14, %rdi
callq 0x144320
jmp 0x2ba386
movq 0x18(%r12), %rax
testb $0x2, 0x65c(%rax)
je 0x2ba365
movq 0x228(%rax), %r15
movq 0x8(%r12), %rax
leaq -0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rax, %rdx
leaq 0xd8(%rdx), %rax
leaq 0xf8(%r15), %rdi
movl $0x9, %ecx
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
movzwl 0x120(%rdx), %ecx
movw %cx, 0x140(%r15)
movq %rbx, %r12
leaq 0x10(%rsp), %rbx
movq $-0x1, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x143cf0
movsd (%rbx), %xmm0
movq %r12, %rbx
movsd 0x2d60c1(%rip), %xmm1 # 0x590400
xorpd %xmm2, %xmm2
cmpeqsd %xmm0, %xmm2
movapd %xmm2, %xmm3
andpd %xmm1, %xmm2
divsd %xmm0, %xmm1
andnpd %xmm1, %xmm3
orpd %xmm3, %xmm2
movlpd %xmm2, 0x148(%r15)
movq 0x228(%rbx), %rdi
movq (%rsp), %rsi
callq 0x2a795c
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x2ba4ae
movq %fs:0x28, %rax
cmpq 0x60(%rsp), %rax
jne 0x2ba3a5
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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);
return;
} else if (txop == QTransform::TxTranslate) {
const QRect rr = toNormalizedFillRect(r.translated(s->matrix.dx(), s->matrix.dy()));
fillRect_normalized(rr, data, d);
return;
} else if (txop == QTransform::TxScale) {
const QRect rr = toNormalizedFillRect(s->matrix.mapRect(r));
fillRect_normalized(rr, data, d);
return;
}
}
ensureRasterState();
if (s->flags.tx_noshear) {
d->initializeRasterizer(data);
QRectF nr = r.normalized();
if (!nr.isEmpty()) {
const QPointF a = s->matrix.map((nr.topLeft() + nr.bottomLeft()) * 0.5f);
const QPointF b = s->matrix.map((nr.topRight() + nr.bottomRight()) * 0.5f);
d->rasterizer->rasterizeLine(a, b, nr.height() / nr.width());
}
return;
}
QPainterPath path;
path.addRect(r);
ensureOutlineMapper();
fillPath(path, data);
} | 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
leaq 0xd8(%r15), %rbp
movq %rbp, %rdi
callq 0x13d090
testl %eax, %eax
je 0x2bc04d
cmpl $0x1, %eax
je 0x2bc01a
cmpl $0x2, %eax
jne 0x2bc071
movapd 0x2b8697(%rip), %xmm0 # 0x574680
leaq 0x40(%rsp), %r15
movapd %xmm0, (%r15)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x147920
movq %r12, %rsi
callq 0x1380f0
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r15, %rdi
jmp 0x2bc061
movupd 0x108(%r15), %xmm0
movupd (%r13), %xmm1
addpd %xmm0, %xmm1
leaq 0x20(%rsp), %rsi
movapd %xmm1, (%rsi)
movupd 0x10(%r13), %xmm0
movapd %xmm0, 0x10(%rsi)
callq 0x1380f0
leaq 0x40(%rsp), %rdi
jmp 0x2bc05a
movq %r13, %rsi
callq 0x1380f0
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2ba9b1
jmp 0x2bc296
movq 0x8(%r12), %rax
leaq -0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
cmpl $0x0, 0x410(%rcx)
je 0x2bc092
movq %r12, %rdi
callq 0x13c970
testb $0x40, 0x414(%r15)
jne 0x2bc184
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x40(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x13f210
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1402f0
movq 0x18(%r12), %rax
testb $0x2, 0x65c(%rax)
je 0x2bc15f
movq 0x228(%rax), %r15
movq 0x8(%r12), %rax
leaq -0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rax, %rdx
leaq 0xd8(%rdx), %rax
leaq 0xf8(%r15), %rdi
movl $0x9, %ecx
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
movzwl 0x120(%rdx), %ecx
movw %cx, 0x140(%r15)
leaq 0x20(%rsp), %rbx
movq $-0x1, (%rbx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x143cf0
movsd (%rbx), %xmm0
movsd 0x2d42c7(%rip), %xmm1 # 0x590400
xorpd %xmm2, %xmm2
cmpeqsd %xmm0, %xmm2
movapd %xmm2, %xmm3
andpd %xmm1, %xmm2
divsd %xmm0, %xmm1
andnpd %xmm1, %xmm3
orpd %xmm3, %xmm2
movlpd %xmm2, 0x148(%r15)
movq (%r12), %rax
leaq 0x40(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x1b0(%rax)
movq %rbx, %rdi
callq 0x144320
jmp 0x2bc296
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ba3aa
pcmpeqd %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movdqa %xmm0, 0x10(%r14)
movdqa %xmm0, (%r14)
movq %r14, %rdi
movq %r13, %rsi
callq 0x146590
xorpd %xmm1, %xmm1
ucomisd 0x10(%r14), %xmm1
jae 0x2bc296
movsd 0x38(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jae 0x2bc296
addq $0xd8, %r15
pcmpeqd %xmm1, %xmm1
leaq 0x40(%rsp), %r14
movdqa %xmm1, (%r14)
movapd 0x20(%rsp), %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addsd %xmm2, %xmm0
movapd %xmm1, %xmm2
unpcklpd %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
addpd %xmm1, %xmm2
mulpd 0x2b8577(%rip), %xmm2 # 0x574780
leaq 0x10(%rsp), %r12
movapd %xmm2, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x147ad0
movsd %xmm0, (%r14)
movsd %xmm1, 0x8(%r14)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, (%r12)
movapd 0x20(%rsp), %xmm0
movapd 0x30(%rsp), %xmm1
movapd %xmm0, %xmm2
addpd %xmm1, %xmm2
addsd %xmm1, %xmm0
addpd %xmm2, %xmm0
mulpd 0x2b8528(%rip), %xmm0 # 0x574780
movq %rsp, %rsi
movapd %xmm0, (%rsi)
movq %r15, %rdi
callq 0x147ad0
movsd %xmm0, (%r12)
movsd %xmm1, 0x8(%r12)
movq 0x660(%rbx), %rdi
movsd 0x38(%rsp), %xmm0
divsd 0x30(%rsp), %xmm0
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3255e6
movq %fs:0x28, %rax
cmpq 0x50(%rsp), %rax
jne 0x2bc2b5
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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_ASSERT(n);
Q_ASSERT(d_first < first); // only allow moves to the "left"
using T = typename std::iterator_traits<iterator>::value_type;
// Watches passed iterator. Unless commit() is called, all the elements that
// the watched iterator passes through are deleted at the end of object
// lifetime. freeze() could be used to stop watching the passed iterator and
// remain at current place.
//
// requires: the iterator is expected to always point to an invalid object
// (to uninitialized memory)
struct Destructor
{
iterator *iter;
iterator end;
iterator intermediate;
Destructor(iterator &it) noexcept : iter(std::addressof(it)), end(it) { }
void commit() noexcept { iter = std::addressof(end); }
void freeze() noexcept
{
intermediate = *iter;
iter = std::addressof(intermediate);
}
~Destructor() noexcept
{
for (const int step = *iter < end ? 1 : -1; *iter != end;) {
std::advance(*iter, step);
(*iter)->~T();
}
}
} destroyer(d_first);
const iterator d_last = d_first + n;
// Note: use pair and explicitly copy iterators from it to prevent
// accidental reference semantics instead of copy. equivalent to:
//
// auto [overlapBegin, overlapEnd] = std::minmax(d_last, first);
auto pair = std::minmax(d_last, first);
// overlap area between [d_first, d_first + n) and [first, first + n) or an
// uninitialized memory area between the two ranges
iterator overlapBegin = pair.first;
iterator overlapEnd = pair.second;
// move construct elements in uninitialized region
while (d_first != overlapBegin) {
// account for std::reverse_iterator, cannot use new(d_first) directly
new (std::addressof(*d_first)) T(std::move_if_noexcept(*first));
++d_first;
++first;
}
// cannot commit but have to stop - there might be an overlap region
// which we don't want to delete (because it's part of existing data)
destroyer.freeze();
// move assign elements in overlap region
while (d_first != d_last) {
*d_first = std::move_if_noexcept(*first);
++d_first;
++first;
}
Q_ASSERT(d_first == destroyer.end + n);
destroyer.commit(); // can commit here as ~T() below does not throw
while (first != overlapEnd)
(--first)->~T();
} | 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
cmovaq %rdi, %rsi
movq %rdi, %r14
cmovaq %rax, %r14
cmpq %rdx, %rsi
je 0x308e0c
xorl %edi, %edi
movq (%rbx), %r8
movq %rdi, (%rbx)
movq %r8, (%rdx)
movq 0x8(%rbx), %r8
movq %rdi, 0x8(%rbx)
movq %r8, 0x8(%rdx)
movq 0x10(%rbx), %r8
movq %rdi, 0x10(%rbx)
movq %r8, 0x10(%rdx)
movq 0x18(%rbx), %r8
movq %rdi, 0x18(%rbx)
movq %r8, 0x18(%rdx)
movq 0x20(%rbx), %r8
movq %rdi, 0x20(%rbx)
movq %r8, 0x20(%rdx)
movq 0x28(%rbx), %r8
movq %rdi, 0x28(%rbx)
movq %r8, 0x28(%rdx)
movq 0x30(%rbx), %r8
movq %rdi, 0x30(%rbx)
movq %r8, 0x30(%rdx)
movq 0x38(%rbx), %r8
movq %rdi, 0x38(%rbx)
movq %r8, 0x38(%rdx)
movq 0x40(%rbx), %r8
movq %rdi, 0x40(%rbx)
movq %r8, 0x40(%rdx)
addq $0x48, %rdx
addq $0x48, %rbx
cmpq %rsi, %rdx
jne 0x308d96
leaq 0x10(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, -0x8(%rsi)
cmpq %rax, %rdx
je 0x308ebb
movq (%rdx), %rcx
movq (%rbx), %rdi
movq %rdi, (%rdx)
movq %rcx, (%rbx)
movq 0x8(%rdx), %rcx
movq 0x8(%rbx), %rdi
movq %rdi, 0x8(%rdx)
movq %rcx, 0x8(%rbx)
movq 0x10(%rdx), %rcx
movq 0x10(%rbx), %rdi
movq %rdi, 0x10(%rdx)
movq %rcx, 0x10(%rbx)
movq 0x18(%rdx), %rcx
movq 0x18(%rbx), %rdi
movq %rdi, 0x18(%rdx)
movq %rcx, 0x18(%rbx)
movq 0x20(%rdx), %rcx
movq 0x20(%rbx), %rdi
movq %rdi, 0x20(%rdx)
movq %rcx, 0x20(%rbx)
movq 0x28(%rdx), %rcx
movq 0x28(%rbx), %rdi
movq %rdi, 0x28(%rdx)
movq %rcx, 0x28(%rbx)
movq 0x30(%rdx), %rcx
movq 0x30(%rbx), %rdi
movq %rdi, 0x30(%rdx)
movq %rcx, 0x30(%rbx)
movq 0x38(%rdx), %rcx
movq 0x38(%rbx), %rdi
movq %rdi, 0x38(%rdx)
movq %rcx, 0x38(%rbx)
movq 0x40(%rdx), %rcx
movq 0x40(%rbx), %rdi
movq %rdi, 0x40(%rdx)
movq %rcx, 0x40(%rbx)
addq $0x48, %rdx
addq $0x48, %rbx
jmp 0x308e19
movq %rsi, 0x8(%rsp)
cmpq %r14, %rbx
je 0x308f2c
movq -0x18(%rbx), %rax
testq %rax, %rax
je 0x308ee6
lock
decl (%rax)
jne 0x308ee6
movq -0x18(%rbx), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq -0x30(%rbx), %rax
testq %rax, %rax
je 0x308f07
lock
decl (%rax)
jne 0x308f07
movq -0x30(%rbx), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
addq $-0x48, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x308ec0
lock
decl (%rax)
jne 0x308ec0
movq (%rbx), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x308ec0
leaq 0x8(%rsp), %rdi
callq 0x3091a0
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x308f4e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /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(%r15), %rax
testq %rax, %rax
je 0x3091fe
lock
decl (%rax)
jne 0x3091fe
movq 0x30(%r15), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x18(%r15), %rax
testq %rax, %rax
je 0x30921f
lock
decl (%rax)
jne 0x30921f
movq 0x18(%r15), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq (%r15), %rax
testq %rax, %rax
je 0x30923e
lock
decl (%rax)
jne 0x30923e
movq (%r15), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq (%rbx), %rax
movq (%rax), %rcx
cmpq 0x8(%rbx), %rcx
jne 0x3091d0
popq %rbx
popq %r14
popq %r15
retq
| /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 below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | 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 %rax, %rcx
cmovleq %rax, %rsi
addq %r15, %rsi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rdi
sarq $0x3, %rdi
testl %ebp, %ebp
je 0x30937b
movabsq $0x71c71c71c71c71c7, %rcx # imm = 0x71C71C71C71C71C7
imulq %rdi, %rcx
jmp 0x30938c
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
jmp 0x3093a1
movabsq $-0x71c71c71c71c71c7, %r8 # imm = 0x8E38E38E38E38E39
imulq %rdi, %r8
addq %r8, %rcx
addq %rcx, %rsi
cmpq %rsi, %rax
movq %rsi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rsi, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x48, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x30944b
cmpl $0x1, %ebp
jne 0x309427
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rdi,%rdi,8), %rdi
leaq (%rax,%rdi,8), %rax
leaq (%r15,%r15,8), %rdi
leaq (%rax,%rdi,8), %rax
testq %rdx, %rdx
jne 0x309441
jmp 0x309448
movq (%r14), %rdx
testq %rdx, %rdx
je 0x309446
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x309448
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x30947a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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) {
new (data + this->size) T(std::move(*b));
++b;
++this->size;
}
} | 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,8)
movq 0x18(%rsi), %r9
movq %rcx, 0x18(%rsi)
movq %r9, 0x18(%rax,%r8,8)
movq 0x20(%rsi), %r9
movq %rcx, 0x20(%rsi)
movq %r9, 0x20(%rax,%r8,8)
movq 0x28(%rsi), %r9
movq %rcx, 0x28(%rsi)
movq %r9, 0x28(%rax,%r8,8)
movq 0x30(%rsi), %r9
movq %rcx, 0x30(%rsi)
movq %r9, 0x30(%rax,%r8,8)
movq 0x38(%rsi), %r9
movq %rcx, 0x38(%rsi)
movq %r9, 0x38(%rax,%r8,8)
movq 0x40(%rsi), %r9
movq %rcx, 0x40(%rsi)
movq %r9, 0x40(%rax,%r8,8)
addq $0x48, %rsi
movq 0x10(%rdi), %r8
incq %r8
movq %r8, 0x10(%rdi)
cmpq %rdx, %rsi
jb 0x309539
retq
| /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)
movq %rax, 0x20(%rbx)
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x309b6f
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rbx
movq %rdx, 0x10(%rsp)
leaq (%rdx,%rdx,8), %r15
shlq $0x4, %r15
leaq (%rbx,%r15), %r13
movq %rcx, 0x18(%rsp)
addq %rcx, %rbx
xorl %r12d, %r12d
movzbl (%rbx,%r12), %eax
cmpq $0xff, %rax
je 0x309b41
movq 0x80(%r13), %rbp
leaq (%rax,%rax,4), %r14
shll $0x4, %r14d
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
addq %r15, %rdi
movq %r12, %rsi
callq 0x30b204
movq (%rbp,%r14), %rcx
movq %rcx, (%rax)
movq 0x8(%rbp,%r14), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rbp,%r14), %rdx
movq %rdx, 0x10(%rax)
testq %rcx, %rcx
je 0x309af8
lock
incl (%rcx)
addq %r14, %rbp
movq 0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rbp), %rdx
movq %rdx, 0x20(%rax)
movq 0x28(%rbp), %rdx
movq %rdx, 0x28(%rax)
testq %rcx, %rcx
je 0x309b1b
lock
incl (%rcx)
movl 0x38(%rbp), %ecx
movl %ecx, 0x38(%rax)
movq 0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x40(%rbp), %rcx
movq %rcx, 0x40(%rax)
testq %rcx, %rcx
je 0x309b39
lock
incl (%rcx)
movq 0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
incq %r12
cmpq $0x80, %r12
jne 0x309aa2
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x18(%rsp), %rcx
addq $0x90, %rcx
cmpq (%rsp), %rdx
jne 0x309a7d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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, %r10
imulq %rsi, %r10
movq %r10, %r9
shrq $0x20, %r9
xorq %r10, %r9
movq %rax, %r10
shlq $0x6, %r10
movq %rax, %r11
shrq $0x2, %r11
addq %r10, %r11
addq %r8, %r11
addq %r9, %r11
xorq %r11, %rax
addq $0x4, %rdi
cmpq %rdi, %rcx
jne 0x30a05a
retq
| /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()) {
// accept current allocation, don't shrink
d->setFlag(Data::CapacityReserved);
return;
}
}
DataPointer detached(qMax(asize, size()));
detached->copyAppend(d->begin(), d->end());
if (detached.d_ptr())
detached->setFlag(Data::CapacityReserved);
d.swap(detached);
} | 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 0x30a1c0
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl $0x4, %esi
movl $0x10, %edx
movq %r14, %rdi
movl $0x1, %r8d
callq 0x138b60
movq (%r14), %rcx
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
jle 0x30a1d7
movq 0x8(%rbx), %rsi
leaq (%rsi,%rdx,4), %rdi
xorl %edx, %edx
movl (%rsi), %r8d
movl %r8d, (%rax,%rdx,4)
addq $0x4, %rsi
incq %rdx
cmpq %rdi, %rsi
jb 0x30a1ab
jmp 0x30a1d9
movl 0x4(%rax), %edx
testb $0x1, %dl
jne 0x30a209
movl (%rax), %esi
cmpl $0x1, %esi
jne 0x30a160
orl $0x1, %edx
movl %edx, 0x4(%rax)
jmp 0x30a209
xorl %edx, %edx
testq %rcx, %rcx
je 0x30a1e2
orb $0x1, 0x4(%rcx)
movq (%rbx), %rdi
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
testq %rdi, %rdi
je 0x30a209
lock
decl (%rdi)
jne 0x30a209
movl $0x4, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x30a221
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /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() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n))
return;
readjusted = tryReadjustFreeSpace(where, n, data);
Q_ASSERT(!readjusted
|| (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n));
}
if (!readjusted)
reallocateAndGrow(where, n, old);
} | 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
popq %r15
popq %rbp
jmp 0x30a534
testq %r14, %r14
je 0x30a480
testl %ebp, %ebp
je 0x30a44c
cmpl $0x1, %ebp
jne 0x30a445
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jge 0x30a480
movq %r15, %rdi
movl %ebp, %esi
jmp 0x30a474
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x2, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x30a480
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x30a48c
testb %al, %al
je 0x30a405
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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
cmpq %rdx, %r8
jl 0x30a4e3
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rdx
addq %r9, %r9
xorl %eax, %eax
cmpq %r9, %rdx
jl 0x30a51b
retq
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x30a4e2
cmpq %rdx, %r10
jl 0x30a4e2
movq 0x10(%rdi), %rax
leaq (%rax,%rax,2), %rsi
cmpq %r9, %rsi
jge 0x30a531
addq %rdx, %rax
subq %rax, %r9
movq %r9, %rsi
shrq $0x3f, %rsi
addq %r9, %rsi
sarq %rsi
xorl %eax, %eax
testq %rsi, %rsi
cmovgq %rsi, %rax
addq %rdx, %rax
pushq %rax
subq %r8, %rax
movq %rax, %rsi
movq %rcx, %rdx
callq 0x30a6fe
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
| /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 && !needsDetach() && n > 0) {
(*this)->reallocate(constAllocatedCapacity() - freeSpaceAtEnd() + n, QArrayData::Grow); // fast path
return;
}
}
QArrayDataPointer dp(allocateGrow(*this, n, where));
if (n > 0)
Q_CHECK_PTR(dp.data());
if (where == QArrayData::GrowsAtBeginning) {
Q_ASSERT(dp.freeSpaceAtBegin() >= n);
} else {
Q_ASSERT(dp.freeSpaceAtEnd() >= n);
}
if (size) {
qsizetype toCopy = size;
if (n < 0)
toCopy += n;
if (needsDetach() || old)
dp->copyAppend(begin(), begin() + toCopy);
else
dp->moveAppend(begin(), begin() + toCopy);
Q_ASSERT(dp.size == toCopy);
}
swap(dp);
if (old)
old->swap(dp);
} | 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, %r15
jle 0x30a5b6
cmpl $0x1, %eax
jg 0x30a5b6
movq 0x8(%rbx), %rsi
leaq 0x1f(%rdi), %rax
andq $-0x10, %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x2, %rcx
addq 0x10(%rbx), %r15
addq %rcx, %r15
movl $0x4, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x30a6df
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps 0x26a0b2(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30a78a
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x30a671
movq %r15, %rdx
sarq $0x3f, %rdx
andq %r15, %rdx
addq %rax, %rdx
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x30a63b
movl (%rcx), %ecx
testq %r14, %r14
jne 0x30a63b
cmpl $0x2, %ecx
jge 0x30a63b
movq 0x8(%rbx), %rcx
testq %rdx, %rdx
je 0x30a675
jle 0x30a675
leaq (%rcx,%rdx,4), %rdx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rcx, %r8
movl (%r8), %r9d
movl %r9d, (%rdi,%rsi,4)
addq $0x4, %r8
incq %rsi
cmpq %rdx, %r8
jb 0x30a626
jmp 0x30a66a
movq 0x8(%rbx), %rcx
testq %rdx, %rdx
je 0x30a675
jle 0x30a675
leaq (%rcx,%rdx,4), %rdx
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rcx, %r8
movl (%r8), %r9d
movl %r9d, (%rdi,%rsi,4)
addq $0x4, %r8
incq %rsi
cmpq %rdx, %r8
jb 0x30a657
movq %rsi, 0x10(%rsp)
jmp 0x30a675
movq 0x8(%rbx), %rcx
movq (%rbx), %rdx
movaps (%rsp), %xmm0
movq %rdx, (%rsp)
movups %xmm0, (%rbx)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x10(%rbx)
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x30a6c2
movq (%r14), %rsi
movq %rdx, (%r14)
movq %rsi, (%rsp)
movq 0x8(%r14), %rdx
movq %rcx, 0x8(%r14)
movq %rdx, 0x8(%rsp)
movq 0x10(%r14), %rcx
movq %rax, 0x10(%r14)
movq %rcx, 0x10(%rsp)
movq %rsi, %rdx
testq %rdx, %rdx
je 0x30a6df
lock
decl (%rdx)
jne 0x30a6df
movq (%rsp), %rdi
movl $0x4, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x30a6f9
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | 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 below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | 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 %rax, %rdi
cmovgq %rsi, %rdi
addq %r15, %rdi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rcx
sarq $0x2, %rcx
addq %rcx, %rsi
movq %rax, %r8
subq %rsi, %r8
testl %ebp, %ebp
cmovneq %rcx, %r8
subq %r8, %rdi
cmpq %rdi, %rax
movq %rdi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rdi, %rcx
jmp 0x30a819
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x4, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x30a8bb
cmpl $0x1, %ebp
jne 0x30a897
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rax,%rdi,4), %rax
leaq (%rax,%r15,4), %rax
testq %rdx, %rdx
jne 0x30a8b1
jmp 0x30a8b8
movq (%r14), %rdx
testq %rdx, %rdx
je 0x30a8b6
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x30a8b8
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x30a8ea
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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;
}
if (i == 0 && this->freeSpaceAtBegin()) {
new (this->begin() - 1) T(std::forward<Args>(args)...);
--this->ptr;
++this->size;
return;
}
}
T tmp(std::forward<Args>(args)...);
typename QArrayData::GrowthPosition pos = QArrayData::GrowsAtEnd;
if (this->size != 0 && i == 0)
pos = QArrayData::GrowsAtBeginning;
this->detachAndGrow(pos, 1, nullptr, nullptr);
T *where = createHole(pos, i, 1);
new (where) T(std::move(tmp));
} | 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, %r8
sarq $0x2, %r8
addq %r14, %r8
cmpq %r8, 0x8(%rcx)
jne 0x30ab41
testq %r14, %r14
jne 0x30aaeb
movq 0x8(%rbx), %rsi
addq $0x1f, %rcx
andq $-0x10, %rcx
cmpq %rsi, %rcx
jne 0x30ab54
movss (%rdx), %xmm0
movss %xmm0, 0xc(%rsp)
cmpq $0x0, 0x10(%rbx)
setne %al
testq %r14, %r14
sete %cl
andb %al, %cl
movzbl %cl, %ebp
movl $0x1, %edx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x30aba2
movl $0x1, %ecx
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x30ac4e
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movss (%rdx), %xmm0
movss %xmm0, (%rsi,%r14,4)
incq %r14
movq %r14, 0x10(%rbx)
jmp 0x30ab38
movss (%rdx), %xmm0
movss %xmm0, -0x4(%rsi)
addq $-0x4, %rsi
movq %rsi, 0x8(%rbx)
incq %rax
movq %rax, 0x10(%rbx)
jmp 0x30ab38
| /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() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n))
return;
readjusted = tryReadjustFreeSpace(where, n, data);
Q_ASSERT(!readjusted
|| (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n));
}
if (!readjusted)
reallocateAndGrow(where, n, old);
} | 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
popq %r15
popq %rbp
jmp 0x30ad4e
testq %r14, %r14
je 0x30ac42
testl %ebp, %ebp
je 0x30ac0e
cmpl $0x1, %ebp
jne 0x30ac07
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jge 0x30ac42
movq %r15, %rdi
movl %ebp, %esi
jmp 0x30ac36
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x2, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x30ac42
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x30aca6
testb %al, %al
je 0x30abc7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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, %rdi
callq 0x137fb0
jmp 0x375f9a
movl $0x1, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq $0x80, 0x10(%rbx)
movl $0x98, %edi
callq 0x13cd50
movq $0x1, (%rax)
leaq 0x8(%rax), %rcx
movq %r14, 0x88(%rax)
movw $0x0, 0x90(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rax)
movdqu %xmm0, 0x18(%rax)
movdqu %xmm0, 0x28(%rax)
movdqu %xmm0, 0x38(%rax)
movdqu %xmm0, 0x48(%rax)
movdqu %xmm0, 0x58(%rax)
movdqu %xmm0, 0x68(%rax)
movdqu %xmm0, 0x78(%rax)
movq %rcx, 0x20(%rbx)
callq 0x13fbc0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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)
movq %rax, 0x20(%rbx)
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x3760a5
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rbx
movq %rdx, 0x10(%rsp)
leaq (%rdx,%rdx,8), %r15
shlq $0x4, %r15
leaq (%rbx,%r15), %r13
movq %rcx, 0x18(%rsp)
addq %rcx, %rbx
xorl %r12d, %r12d
movzbl (%rbx,%r12), %ebp
cmpq $0xff, %rbp
je 0x37607b
movq 0x80(%r13), %r14
shll $0x5, %ebp
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
addq %r15, %rdi
movq %r12, %rsi
callq 0x37568e
movl (%r14,%rbp), %ecx
movl %ecx, (%rax)
movq 0x8(%r14,%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%r14,%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x18(%r14,%rbp), %rdx
movq %rdx, 0x18(%rax)
testq %rcx, %rcx
je 0x37607b
lock
incl (%rcx)
incq %r12
cmpq $0x80, %r12
jne 0x376026
movq 0x10(%rsp), %rdx
incq %rdx
movq 0x18(%rsp), %rcx
addq $0x90, %rcx
cmpq (%rsp), %rdx
jne 0x376001
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 %rcx, %r8
imulq %rax, %r8
movq %r8, %rdx
shrq $0x20, %rdx
xorq %r8, %rdx
callq 0x375392
cmpb $-0x1, (%rax,%rdx)
je 0x376131
movq %rax, %rsi
movq %rdx, %rcx
movq (%rbx), %rax
subq 0x20(%rax), %rsi
shrq $0x4, %rsi
movabsq $0x1c71c71c71c71c80, %rdx # imm = 0x1C71C71C71C71C80
imulq %rsi, %rdx
orq %rcx, %rdx
jmp 0x376135
xorl %edx, %edx
xorl %eax, %eax
popq %rbx
retq
nop
| /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 != nullptr) {
qCDebug(lcColrv1).noquote().nospace()
<< QByteArray().fill(' ', m_oldPaths.size() * 2)
<< "[radial gradient " << c0
<< ", rad=" << r0
<< ", " << c1
<< ", rad=" << r1
<< ", spread: " << spread
<< ", stop count: " << gradientStops.size()
<< "]";
QPointF c0e(c0 + QPointF(r0, 0.0));
QPointF c1e(c1 + QPointF(r1, 0.0));
c0 = m_currentTransform.map(c0);
c0e = m_currentTransform.map(c0e);
c1 = m_currentTransform.map(c1);
c1e = m_currentTransform.map(c1e);
const QVector2D d0(c0e - c0);
const QVector2D d1(c1e - c1);
QRadialGradient gradient(c1, d1.length(), c0, d0.length());
gradient.setCoordinateMode(QGradient::LogicalMode);
gradient.setSpread(spread);
gradient.setStops(gradientStops);
m_painter->setBrush(gradient);
}
} | 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, %ebp
movq %rdi, %r14
movaps %xmm1, 0x50(%rsp)
movaps %xmm4, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm3, 0x30(%rsp)
movaps %xmm2, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
callq 0x39dbfc
movb 0x10(%rax), %cl
testb $0x1, %cl
movq %r12, 0x48(%rsp)
movl %ebp, 0xc(%rsp)
je 0x3789a0
movq 0x8(%rax), %rax
leaq 0x88(%rsp), %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0xf8(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ecf0
movq (%rbx), %rax
movw $0x100, 0x30(%rax) # imm = 0x100
leaq 0xe0(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xa8(%r14), %rdx
addq %rdx, %rdx
movl $0x20, %esi
callq 0x148980
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
testq %rsi, %rsi
jne 0x3784ec
movq 0x377044(%rip), %rsi # 0x6ef530
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x1497f0
movq 0xf8(%rsp), %rbx
cmpb $0x1, 0x30(%rbx)
jne 0x378519
movq %rbx, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0xf8(%rsp), %rbx
leaq 0x22d68a(%rip), %rdx # 0x5a5baa
leaq 0x150(%rsp), %r15
movl $0x11, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x378564
lock
decl (%rax)
jne 0x378564
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0xf8(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x378584
movl $0x20, %esi
callq 0x13d680
movq 0xf8(%rsp), %rdi
leaq 0x100(%rsp), %rsi
movq %rdi, (%rsi)
incl 0x28(%rdi)
leaq 0x108(%rsp), %rbx
leaq 0x140(%rsp), %rdx
movq %rbx, %rdi
callq 0x13ffc0
movq (%rbx), %rbx
leaq 0x22d608(%rip), %rdx # 0x5a5bbc
leaq 0x150(%rsp), %r15
movl $0x6, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x3785f8
lock
decl (%rax)
jne 0x3785f8
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x108(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x378618
movl $0x20, %esi
callq 0x13d680
movq 0x108(%rsp), %rdi
movaps 0x10(%rsp), %xmm0
callq 0x13e670
movq 0x108(%rsp), %rbx
cmpb $0x1, 0x30(%rbx)
jne 0x378645
movq %rbx, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0x108(%rsp), %rbx
leaq 0x222792(%rip), %rdx # 0x59adde
leaq 0x150(%rsp), %r15
movl $0x2, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x378690
lock
decl (%rax)
jne 0x378690
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x108(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x3786b0
movl $0x20, %esi
callq 0x13d680
movq 0x108(%rsp), %rdi
leaq 0x110(%rsp), %rsi
movq %rdi, (%rsi)
incl 0x28(%rdi)
leaq 0x118(%rsp), %rbx
leaq 0x130(%rsp), %rdx
movq %rbx, %rdi
callq 0x13ffc0
movq (%rbx), %rbx
leaq 0x22d4dc(%rip), %rdx # 0x5a5bbc
leaq 0x150(%rsp), %r15
movl $0x6, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x378724
lock
decl (%rax)
jne 0x378724
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x118(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x378744
movl $0x20, %esi
callq 0x13d680
movq 0x118(%rsp), %rdi
movaps 0x20(%rsp), %xmm0
callq 0x13e670
movq 0x118(%rsp), %rbx
cmpb $0x1, 0x30(%rbx)
jne 0x378771
movq %rbx, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0x118(%rsp), %rbx
leaq 0x22d3b8(%rip), %rdx # 0x5a5b30
leaq 0x150(%rsp), %r15
movl $0xa, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x3787bc
lock
decl (%rax)
jne 0x3787bc
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x118(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x3787dc
movl $0x20, %esi
callq 0x13d680
movq 0x118(%rsp), %rdi
leaq 0x120(%rsp), %rsi
movq %rdi, (%rsi)
incl 0x28(%rdi)
movl %ebp, %edx
movq 0x376975(%rip), %rcx # 0x6ef168
leaq 0x21ebf5(%rip), %r8 # 0x5973ef
leaq 0x128(%rsp), %rbx
movq %rbx, %rdi
callq 0x13d820
movq (%rbx), %rbx
leaq 0x22d327(%rip), %rdx # 0x5a5b3b
leaq 0x150(%rsp), %r15
movl $0xe, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x378858
lock
decl (%rax)
jne 0x378858
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x128(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x378878
movl $0x20, %esi
callq 0x13d680
movq 0x128(%rsp), %rdi
movq 0x10(%r12), %rsi
callq 0x1384c0
movq 0x128(%rsp), %rbx
cmpb $0x1, 0x30(%rbx)
jne 0x3788a5
movq %rbx, %rdi
movl $0x20, %esi
callq 0x13d680
movq 0x128(%rsp), %rbx
leaq 0x248b8d(%rip), %rdx # 0x5c1439
leaq 0x150(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1455b0
movq (%r15), %rax
testq %rax, %rax
je 0x3788f0
lock
decl (%rax)
jne 0x3788f0
movq 0x150(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x128(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x378908
movl $0x20, %esi
callq 0x13d680
leaq 0x128(%rsp), %rdi
callq 0x1391b0
leaq 0x120(%rsp), %rdi
callq 0x1391b0
leaq 0x118(%rsp), %rdi
callq 0x1391b0
leaq 0x110(%rsp), %rdi
callq 0x1391b0
leaq 0x108(%rsp), %rdi
callq 0x1391b0
leaq 0x100(%rsp), %rdi
callq 0x1391b0
movq 0xe0(%rsp), %rax
testq %rax, %rax
je 0x37897f
lock
decl (%rax)
jne 0x37897f
movq 0xe0(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0xf8(%rsp), %rdi
callq 0x1391b0
movapd 0x140(%rsp), %xmm2
movapd 0x130(%rsp), %xmm1
jmp 0x3789b8
movapd 0x70(%rsp), %xmm2
unpcklpd 0x50(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm1
unpcklpd 0x60(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0]
movsd 0x10(%rsp), %xmm0
addpd %xmm2, %xmm0
leaq 0x150(%rsp), %r12
movapd %xmm0, (%r12)
movsd 0x20(%rsp), %xmm0
addpd %xmm1, %xmm0
leaq 0xe0(%rsp), %rbx
movapd %xmm0, (%rbx)
leaq 0x20(%r14), %rbp
leaq 0x140(%rsp), %r15
movq %rbp, %rdi
movq %r15, %rsi
callq 0x147ad0
movsd %xmm0, (%r15)
movsd %xmm1, 0x8(%r15)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x147ad0
movsd %xmm0, (%r12)
movsd %xmm1, 0x8(%r12)
leaq 0x130(%rsp), %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x147ad0
movsd %xmm0, (%r13)
movsd %xmm1, 0x8(%r13)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x147ad0
movsd %xmm0, (%rbx)
movsd %xmm1, 0x8(%rbx)
movsd (%r12), %xmm2
movsd 0x8(%r12), %xmm3
subsd (%r15), %xmm2
subsd 0x8(%r15), %xmm3
cvtsd2ss %xmm2, %xmm2
movss %xmm2, 0x20(%rsp)
xorps %xmm2, %xmm2
cvtsd2ss %xmm3, %xmm2
movss %xmm2, 0x10(%rsp)
subsd (%r13), %xmm0
subsd 0x8(%r13), %xmm1
cvtsd2ss %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm1
leaq 0x22d263(%rip), %rsi # 0x5a5d00
leaq 0x88(%rsp), %r12
movl $0xb, %ecx
movq %r12, %rdi
rep movsq (%rsi), %es:(%rdi)
callq 0x148e40
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movss 0x20(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
callq 0x148e40
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movq %r12, %rdi
movq %r13, %rsi
movsd 0x30(%rsp), %xmm0
movq %r15, %rdx
callq 0x139870
movq %r12, %rdi
xorl %esi, %esi
callq 0x13ae90
movl 0xc(%rsp), %eax
movl %eax, 0x4(%r12)
movq %r12, %rdi
movq 0x48(%rsp), %rsi
callq 0x138190
movq 0x18(%r14), %rbx
leaq 0x128(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x144430
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13a060
movq %r14, %rdi
callq 0x138860
movq %r12, %rdi
callq 0x13f970
movq %fs:0x28, %rax
cmpq 0x170(%rsp), %rax
jne 0x378b62
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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 && !needsDetach() && n > 0) {
(*this)->reallocate(constAllocatedCapacity() - freeSpaceAtEnd() + n, QArrayData::Grow); // fast path
return;
}
}
QArrayDataPointer dp(allocateGrow(*this, n, where));
if (n > 0)
Q_CHECK_PTR(dp.data());
if (where == QArrayData::GrowsAtBeginning) {
Q_ASSERT(dp.freeSpaceAtBegin() >= n);
} else {
Q_ASSERT(dp.freeSpaceAtEnd() >= n);
}
if (size) {
qsizetype toCopy = size;
if (n < 0)
toCopy += n;
if (needsDetach() || old)
dp->copyAppend(begin(), begin() + toCopy);
else
dp->moveAppend(begin(), begin() + toCopy);
Q_ASSERT(dp.size == toCopy);
}
swap(dp);
if (old)
old->swap(dp);
} | 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, %r15
jle 0x379e1c
cmpl $0x1, %eax
jg 0x379e1c
movq 0x8(%rbx), %rsi
leaq 0x1f(%rdi), %rax
andq $-0x10, %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rax
addq 0x10(%rbx), %r15
addq %rax, %r15
movl $0x50, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x379f86
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps 0x1fa84c(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x37a042
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x379f0b
movq %r15, %rax
sarq $0x3f, %rax
andq %r15, %rax
addq %rax, %rcx
movq (%rbx), %rax
testq %rax, %rax
je 0x379ebd
movl (%rax), %eax
testq %r14, %r14
jne 0x379ebd
cmpl $0x2, %eax
jge 0x379ebd
movq 0x8(%rsp), %r8
testq %rcx, %rcx
jle 0x379f10
movq 0x8(%rbx), %rax
leaq (%rcx,%rcx,4), %r9
shlq $0x4, %r9
addq %rax, %r9
movq 0x10(%rsp), %r10
leaq (%r10,%r10,4), %rdx
shlq $0x4, %rdx
addq %r8, %rdx
movl $0xa, %ecx
movq %rdx, %rdi
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
addq $0x50, %rax
incq %r10
addq $0x50, %rdx
cmpq %r9, %rax
jb 0x379e9d
jmp 0x379f04
movq 0x8(%rsp), %r8
testq %rcx, %rcx
jle 0x379f10
movq 0x8(%rbx), %rax
leaq (%rcx,%rcx,4), %r9
shlq $0x4, %r9
addq %rax, %r9
movq 0x10(%rsp), %r10
leaq (%r10,%r10,4), %rdx
shlq $0x4, %rdx
addq %r8, %rdx
movl $0xa, %ecx
movq %rdx, %rdi
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
addq $0x50, %rax
incq %r10
addq $0x50, %rdx
cmpq %r9, %rax
jb 0x379ee6
movq %r10, 0x10(%rsp)
jmp 0x379f10
movq 0x8(%rsp), %r8
movq (%rbx), %rax
movq (%rsp), %rcx
movq %rcx, (%rbx)
movq %rax, (%rsp)
movq 0x8(%rbx), %rcx
movq %r8, 0x8(%rbx)
movq %rcx, 0x8(%rsp)
movq 0x10(%rbx), %rdx
movq 0x10(%rsp), %rsi
movq %rsi, 0x10(%rbx)
movq %rdx, 0x10(%rsp)
testq %r14, %r14
je 0x379f69
movq (%r14), %rsi
movq %rax, (%r14)
movq %rsi, (%rsp)
movq 0x8(%r14), %rax
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
movq 0x10(%r14), %rax
movq %rdx, 0x10(%r14)
movq %rax, 0x10(%rsp)
movq %rsi, %rax
testq %rax, %rax
je 0x379f86
lock
decl (%rax)
jne 0x379f86
movq (%rsp), %rdi
movl $0x50, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x379fa0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /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;
this->ptr = res;
} | 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 0x379fff
movq 0x10(%rbx), %rdx
leaq (%rdx,%rdx,4), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rax, %rcx
jbe 0x379fff
addq %r12, %rax
movq %rax, (%r14)
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | 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_DEFAULT_BASEFONTSIZE");
qCDebug(lcDistanceField) << "set the QT_DISTANCEFIELD_DEFAULT_BASEFONTSIZE:" << QT_DISTANCEFIELD_DEFAULT_BASEFONTSIZE;
}
if (qEnvironmentVariableIsSet("QT_DISTANCEFIELD_DEFAULT_SCALE")) {
QT_DISTANCEFIELD_DEFAULT_SCALE = qEnvironmentVariableIntValue("QT_DISTANCEFIELD_DEFAULT_SCALE");
qCDebug(lcDistanceField) << "set the QT_DISTANCEFIELD_DEFAULT_SCALE:" << QT_DISTANCEFIELD_DEFAULT_SCALE;
}
if (qEnvironmentVariableIsSet("QT_DISTANCEFIELD_DEFAULT_RADIUS")) {
QT_DISTANCEFIELD_DEFAULT_RADIUS = qEnvironmentVariableIntValue("QT_DISTANCEFIELD_DEFAULT_RADIUS");
qCDebug(lcDistanceField) << "set the QT_DISTANCEFIELD_DEFAULT_RADIUS:" << QT_DISTANCEFIELD_DEFAULT_RADIUS;
}
if (qEnvironmentVariableIsSet("QT_DISTANCEFIELD_DEFAULT_HIGHGLYPHCOUNT")) {
QT_DISTANCEFIELD_DEFAULT_HIGHGLYPHCOUNT = qEnvironmentVariableIntValue("QT_DISTANCEFIELD_DEFAULT_HIGHGLYPHCOUNT");
qCDebug(lcDistanceField) << "set the QT_DISTANCEFIELD_DEFAULT_HIGHGLYPHCOUNT:" << QT_DISTANCEFIELD_DEFAULT_HIGHGLYPHCOUNT;
}
} | 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 0x1421e0
movl %eax, 0x37bf6f(%rip) # 0x6f62f8
callq 0x37e80e
movb 0x3915cc(%rip), %al # 0x70b960
testb $0x1, %al
je 0x37a457
movq 0x3915b5(%rip), %rax # 0x70b958
movq %rsp, %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ecf0
movq (%rbx), %rbx
leaq 0x22b9c1(%rip), %rdx # 0x5a5d96
leaq 0x28(%rsp), %r14
movl $0x2e, %esi
movq %r14, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1455b0
movq (%r14), %rax
testq %rax, %rax
je 0x37a413
lock
decl (%rax)
jne 0x37a413
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a42d
movl $0x20, %esi
callq 0x13d680
movq 0x20(%rsp), %rdi
movl 0x37bec5(%rip), %esi # 0x6f62f8
callq 0x147670
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a44d
movl $0x20, %esi
callq 0x13d680
leaq 0x20(%rsp), %rdi
callq 0x1391b0
leaq 0x22b967(%rip), %rdi # 0x5a5dc5
callq 0x1452a0
testb %al, %al
je 0x37a54d
leaq 0x22b953(%rip), %rdi # 0x5a5dc5
xorl %esi, %esi
callq 0x1421e0
movl %eax, 0x37be7d(%rip) # 0x6f62fc
callq 0x37e80e
movb 0x3914d6(%rip), %al # 0x70b960
testb $0x1, %al
je 0x37a54d
movq 0x3914bf(%rip), %rax # 0x70b958
movq %rsp, %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ecf0
movq (%rbx), %rbx
leaq 0x22b919(%rip), %rdx # 0x5a5de4
leaq 0x28(%rsp), %r14
movl $0x27, %esi
movq %r14, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1455b0
movq (%r14), %rax
testq %rax, %rax
je 0x37a509
lock
decl (%rax)
jne 0x37a509
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a523
movl $0x20, %esi
callq 0x13d680
movq 0x20(%rsp), %rdi
movl 0x37bdd3(%rip), %esi # 0x6f62fc
callq 0x147670
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a543
movl $0x20, %esi
callq 0x13d680
leaq 0x20(%rsp), %rdi
callq 0x1391b0
leaq 0x22b8b8(%rip), %rdi # 0x5a5e0c
callq 0x1452a0
testb %al, %al
je 0x37a643
leaq 0x22b8a4(%rip), %rdi # 0x5a5e0c
xorl %esi, %esi
callq 0x1421e0
movl %eax, 0x37bd8b(%rip) # 0x6f6300
callq 0x37e80e
movb 0x3913e0(%rip), %al # 0x70b960
testb $0x1, %al
je 0x37a643
movq 0x3913c9(%rip), %rax # 0x70b958
movq %rsp, %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ecf0
movq (%rbx), %rbx
leaq 0x22b86b(%rip), %rdx # 0x5a5e2c
leaq 0x28(%rsp), %r14
movl $0x28, %esi
movq %r14, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1455b0
movq (%r14), %rax
testq %rax, %rax
je 0x37a5ff
lock
decl (%rax)
jne 0x37a5ff
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a619
movl $0x20, %esi
callq 0x13d680
movq 0x20(%rsp), %rdi
movl 0x37bce1(%rip), %esi # 0x6f6300
callq 0x147670
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a639
movl $0x20, %esi
callq 0x13d680
leaq 0x20(%rsp), %rdi
callq 0x1391b0
leaq 0x22b80b(%rip), %rdi # 0x5a5e55
callq 0x1452a0
testb %al, %al
je 0x37a739
leaq 0x22b7f7(%rip), %rdi # 0x5a5e55
xorl %esi, %esi
callq 0x1421e0
movl %eax, 0x37bc99(%rip) # 0x6f6304
callq 0x37e80e
movb 0x3912ea(%rip), %al # 0x70b960
testb $0x1, %al
je 0x37a739
movq 0x3912d3(%rip), %rax # 0x70b958
movq %rsp, %rsi
movl $0x2, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ecf0
movq (%rbx), %rbx
leaq 0x22b7c6(%rip), %rdx # 0x5a5e7d
leaq 0x28(%rsp), %r14
movl $0x30, %esi
movq %r14, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1455b0
movq (%r14), %rax
testq %rax, %rax
je 0x37a6f5
lock
decl (%rax)
jne 0x37a6f5
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a70f
movl $0x20, %esi
callq 0x13d680
movq 0x20(%rsp), %rdi
movl 0x37bbef(%rip), %esi # 0x6f6304
callq 0x147670
movq 0x20(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37a72f
movl $0x20, %esi
callq 0x13d680
leaq 0x20(%rsp), %rdi
callq 0x1391b0
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x37a751
addq $0x48, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /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() + 1) / 2;
for (int x = 0; x < im.width(); ++x) {
int a = qAlpha(im.pixel(x, y));
if (a > 127) {
in = true;
++thick;
} else if (in) {
in = false;
minHThick = qMin(minHThick, thick);
thick = 0;
}
}
thick = 0;
in = false;
int x = (im.width() + 1) / 2;
for (int y = 0; y < im.height(); ++y) {
int a = qAlpha(im.pixel(x, y));
if (a > 127) {
in = true;
++thick;
} else if (in) {
in = false;
minVThick = qMin(minVThick, thick);
thick = 0;
}
}
return minHThick == 1 || minVThick == 1;
} | 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
je 0x37a8cc
movq %rbx, %rdi
callq 0x147520
cmpl $0x1, %eax
je 0x37a8cc
movq %rbx, %rdi
callq 0x147520
movl %eax, %r14d
movq %rbx, %rdi
callq 0x141250
xorl %ebp, %ebp
testl %eax, %eax
jle 0x37a839
movl %r14d, %eax
incl %eax
shrl $0x1f, %eax
addl %eax, %r14d
incl %r14d
sarl %r14d
movl $0x3e7, (%rsp) # imm = 0x3E7
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x139020
movl %eax, %r15d
testl %eax, %eax
js 0x37a819
testb $0x1, %r12b
je 0x37a81c
movl (%rsp), %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
movl %eax, (%rsp)
xorl %r13d, %r13d
jmp 0x37a81c
incl %r13d
shrl $0x1f, %r15d
incl %ebp
movq %rbx, %rdi
callq 0x141250
movl %r15d, %r12d
cmpl %eax, %ebp
jl 0x37a7ed
cmpl $0x1, (%rsp)
sete %bpl
movq %rbx, %rdi
callq 0x141250
movl %eax, %r15d
movq %rbx, %rdi
callq 0x147520
xorl %r14d, %r14d
testl %eax, %eax
jle 0x37a8c5
movl %r15d, %eax
incl %eax
shrl $0x1f, %eax
addl %r15d, %eax
incl %eax
sarl %eax
movl %eax, (%rsp)
movl $0x3e7, 0x4(%rsp) # imm = 0x3E7
xorl %r15d, %r15d
xorl %r13d, %r13d
movq %rbx, %rdi
movl (%rsp), %esi
movl %r14d, %edx
callq 0x139020
movl %eax, %r12d
testl %eax, %eax
js 0x37a8a2
testb $0x1, %r15b
je 0x37a8a5
movl 0x4(%rsp), %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
jmp 0x37a8a5
incl %r13d
shrl $0x1f, %r12d
incl %r14d
movq %rbx, %rdi
callq 0x147520
movl %r12d, %r15d
cmpl %eax, %r14d
jl 0x37a873
cmpl $0x1, 0x4(%rsp)
sete %r14b
orb %r14b, %bpl
jmp 0x37a8cc
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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
data = nullptr;
} | 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 %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x137aa0
jmp 0x37ab38
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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->height; // tightly packed
data->data = (uchar *)malloc(data->nbytes);
}
return 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 %eax, %edi
movl %edi, 0x10(%rbx)
callq 0x1440f0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /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(doubleResolution) / QT_DISTANCEFIELD_SCALE(doubleResolution));
return data;
} | 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(%rip), %ebp # 0x6f62fc
testl %ebx, %ebx
jne 0x37dc03
callq 0x37a338
movl 0x37b6e6(%rip), %ebx # 0x6f6300
callq 0x37a338
movl 0x37b6d7(%rip), %ecx # 0x6f62fc
movl %ebx, %eax
cltd
idivl %ecx
movl %eax, %r14d
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %r13
testq %r13, %r13
je 0x37daea
movq %r12, %rdi
callq 0x13c650
testb %al, %al
je 0x37ac69
movq 0xd0(%rsp), %rax
movslq 0x10(%rax), %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x13ad10
jmp 0x37daea
movq 0xd0(%rsp), %rax
movl 0x8(%rax), %ecx
movq %rcx, 0x10(%rsp)
movslq 0xc(%rax), %r15
leaq 0x22b2b4(%rip), %rsi # 0x5a5f38
leaq 0x1418(%rsp), %rbx
movl $0xa, %ecx
movq %rbx, %rdi
rep movsq (%rsi), %es:(%rdi)
leaq 0x22b252(%rip), %rsi # 0x5a5ef0
movl $0x9, %ecx
movq %rbx, %rdi
rep movsq (%rsi), %es:(%rdi)
movw $0xa800, 0x48(%rbx) # imm = 0xA800
movl %r14d, 0x20(%rsp)
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
movapd %xmm0, %xmm1
callq 0x136ed0
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0x1f9a8c(%rip), %xmm0 # 0x574760
divsd %xmm1, %xmm0
movq %rbx, %rdi
movapd %xmm0, %xmm1
callq 0x1446d0
xorl %r14d, %r14d
leaq 0x190(%rsp), %rdx
movq %r14, 0x10(%rdx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rdx)
leaq 0x170(%rsp), %rbp
movq %r14, 0x10(%rbp)
movapd %xmm0, (%rbp)
movq %r12, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0x2f5e26
cmpq %r14, 0x8(%rbp)
je 0x37da85
movq %r15, 0xc8(%rsp)
movl %r15d, %ebx
movq 0x10(%rsp), %r13
imull %r13d, %ebx
movslq %ebx, %r14
leaq (,%r14,4), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x13cd50
movq %rax, %r12
testl %r14d, %r14d
jle 0x37ae5c
movl %ebx, %eax
addl $0x3, %ebx
andl $-0x4, %ebx
decq %rax
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x1f9ab1(%rip), %xmm1 # 0x574830
movdqa 0x1f9ab9(%rip), %xmm2 # 0x574840
xorl %eax, %eax
movdqa 0x1f9abf(%rip), %xmm3 # 0x574850
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x21fe7f(%rip), %xmm5 # 0x59ac20
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ecx
notl %ecx
testb $0x1, %cl
je 0x37addd
movl $0x7f80, (%r12,%rax,4) # imm = 0x7F80
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x37adf4
movl $0x7f80, 0x4(%r12,%rax,4) # imm = 0x7F80
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %ecx
testb $0x1, %cl
je 0x37ae34
movl $0x7f80, 0x8(%r12,%rax,4) # imm = 0x7F80
pextrw $0x4, %xmm6, %ecx
testb $0x1, %cl
je 0x37ae47
movl $0x7f80, 0xc(%r12,%rax,4) # imm = 0x7F80
addq $0x4, %rax
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
cmpq %rax, %rbx
jne 0x37ada1
movq 0x1a0(%rsp), %rax
movq %rax, 0x108(%rsp)
leaq 0xc18(%rsp), %r15
movl $0x800, %edx # imm = 0x800
movq %r15, %rdi
movl $0xaa, %esi
callq 0x13ad10
movl $0x100, %r14d # imm = 0x100
movq %r14, -0x18(%r15)
xorl %ebx, %ebx
movq %rbx, -0x10(%r15)
movq %r15, -0x8(%r15)
leaq 0x400(%rsp), %r15
movl $0x800, %edx # imm = 0x800
movq %r15, %rdi
movl $0xaa, %esi
callq 0x13ad10
movq %r14, -0x18(%r15)
movq %rbx, -0x10(%r15)
movq %r15, -0x8(%r15)
leaq 0x2e8(%rsp), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
movl $0xaa, %esi
callq 0x13ad10
movq %r14, -0x18(%r15)
movq %rbx, -0x10(%r15)
movq %r15, -0x8(%r15)
leaq 0x1d0(%rsp), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
movl $0xaa, %esi
callq 0x13ad10
movq %r14, -0x18(%r15)
movq %rbx, -0x10(%r15)
movq %r15, -0x8(%r15)
movq 0x180(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x198(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x1480(%rsp), %r14
movl $0x1c00, %edx # imm = 0x1C00
movq %r14, %rdi
movl $0xaa, %esi
callq 0x13ad10
movq $0x80, -0x18(%r14)
movq %rbx, -0x10(%r14)
movq %r14, -0x8(%r14)
movq 0xc8(%rsp), %r15
cmpl $0x81, %r15d
movq %r12, 0x30(%rsp)
jge 0x37db1b
testl %r15d, %r15d
jle 0x37af95
leaq 0x1(%r15), %rcx
movq $0x10, (%r14)
movq $0x0, 0x8(%r14)
leaq 0x18(%r14), %rdx
movq %rdx, 0x10(%r14)
decq %rcx
addq $0x38, %r14
cmpq $0x1, %rcx
ja 0x37af71
movq %r15, 0x1470(%rsp)
cmpl $0x2, 0x28(%rsp)
jl 0x37b0d4
movl $0x1, %r12d
leaq 0x1b0(%rsp), %rbp
movl $0x0, 0xb0(%rsp)
movslq %r12d, %rax
movq 0x108(%rsp), %rdx
movl (%rdx,%rax,4), %ecx
cmpl $-0x1, %ecx
jne 0x37afea
movslq 0xb0(%rsp), %rcx
movl (%rdx,%rcx,4), %ecx
incl %r12d
movl %r12d, 0xb0(%rsp)
movl -0x4(%rdx,%rax,4), %eax
movq 0x8(%rsp), %rdx
leaq (%rdx,%rax,8), %rax
movl %ecx, %ecx
leaq (%rdx,%rcx,8), %rdx
movl 0x4(%rdx), %ecx
cmpl 0x4(%rax), %ecx
movq %rdx, %rcx
cmovlq %rax, %rcx
cmovlq %rdx, %rax
movl 0x4(%rax), %edx
movl %edx, %esi
sarl $0x8, %esi
testl %esi, %esi
movl $0x0, %edi
cmovlel %edi, %esi
movl 0x4(%rcx), %r8d
movl %r8d, %edi
sarl $0x8, %edi
cmpl %r15d, %edi
cmovgel %r15d, %edi
cmpl %edi, %esi
jge 0x37b0b9
movl (%rcx), %r10d
movl (%rax), %r9d
subl %r9d, %r10d
movl %esi, %ecx
shll $0x8, %ecx
subl %edx, %ecx
addl $0xff, %ecx
imull %r10d, %ecx
movl %r10d, %eax
shll $0x8, %eax
subl %edx, %r8d
cltd
idivl %r8d
movl %eax, %r13d
movl %ecx, %eax
cltd
idivl %r8d
movl %eax, %ebx
addl %r9d, %ebx
movl %esi, %eax
movl %edi, %r15d
imulq $0x38, %rax, %r14
subq %rax, %r15
movl %ebx, %eax
sarl $0x8, %eax
cmpl 0x10(%rsp), %eax
jae 0x37b0ad
movq 0x1478(%rsp), %rdi
movw %ax, 0x1b0(%rsp)
leaq (%rdi,%r14), %rdx
addq $0x18, %rdx
addq %r14, %rdi
movl $0x10, %esi
movq %rbp, %rcx
callq 0x38008c
addl %r13d, %ebx
addq $0x38, %r14
decq %r15
jne 0x37b07a
incl %r12d
cmpl 0x28(%rsp), %r12d
movq 0x10(%rsp), %r13
movq 0xc8(%rsp), %r15
jl 0x37afc1
movslq %r13d, %rax
movq %rax, 0xa8(%rsp)
movq 0x1478(%rsp), %rdi
testl %r15d, %r15d
movq 0x30(%rsp), %r12
jle 0x37b3e4
leaq 0x8(%r12), %rax
movq 0xa8(%rsp), %rcx
leaq (,%rcx,4), %rcx
leaq 0xc(%r12), %rdx
xorl %esi, %esi
movdqa 0x1f9717(%rip), %xmm0 # 0x574830
movdqa 0x1f971f(%rip), %xmm1 # 0x574840
movdqa 0x1f9727(%rip), %xmm2 # 0x574850
pcmpeqd %xmm3, %xmm3
imulq $0x38, %rsi, %r8
movq 0x8(%rdi,%r8), %r9
movq 0x10(%rdi,%r8), %r8
cmpl $0x1, %r9d
jle 0x37b2b1
movl %r9d, %r10d
andl $0x7fffffff, %r10d # imm = 0x7FFFFFFF
movl $0x1, %r11d
movzwl (%r8,%r11,2), %ebx
movq %r11, %r14
movzwl -0x2(%r8,%r14,2), %ebp
cmpw %bp, %bx
jae 0x37b175
movw %bp, (%r8,%r14,2)
decq %r14
jne 0x37b15d
xorl %r14d, %r14d
movslq %r14d, %r14
movw %bx, (%r8,%r14,2)
incq %r11
cmpq %r10, %r11
jne 0x37b155
movq %rsi, %r11
imulq 0xa8(%rsp), %r11
xorl %ebx, %ebx
movzwl (%r8,%rbx,2), %r15d
movzwl 0x2(%r8,%rbx,2), %r12d
cmpw %r12w, %r15w
jae 0x37b28e
subq %r15, %r12
leaq 0x3(%r12), %r14
andq $-0x4, %r14
decq %r12
movq %r12, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
leaq (%rax,%r15,4), %r15
pxor %xmm2, %xmm4
xorl %r12d, %r12d
movq %r12, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ebp
notl %ebp
testb $0x1, %bpl
je 0x37b218
movl $0xffff8080, -0x8(%r15,%r12,4) # imm = 0xFFFF8080
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %ebp
testb $0x1, %bpl
je 0x37b230
movl $0xffff8080, -0x4(%r15,%r12,4) # imm = 0xFFFF8080
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm4, %xmm6
pcmpeqd %xmm4, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm3, %xmm5
pextrw $0x0, %xmm5, %ebp
testb $0x1, %bpl
je 0x37b26d
movl $0xffff8080, (%r15,%r12,4) # imm = 0xFFFF8080
pextrw $0x4, %xmm5, %ebp
testb $0x1, %bpl
je 0x37b281
movl $0xffff8080, 0x4(%r15,%r12,4) # imm = 0xFFFF8080
addq $0x4, %r12
cmpq %r12, %r14
jne 0x37b1cc
leaq 0x2(%rbx), %r14
addq $0x3, %rbx
cmpq %r10, %rbx
movq %r14, %rbx
jb 0x37b193
movq 0xc8(%rsp), %r15
movq 0x30(%rsp), %r12
jmp 0x37b2c0
movq %rsi, %r11
imulq 0xa8(%rsp), %r11
xorl %r14d, %r14d
cmpl %r9d, %r14d
jge 0x37b3d5
movl %r14d, %r9d
movzwl (%r8,%r9,2), %r9d
cmpl %r9d, %r13d
jle 0x37b3d5
movq %r13, %r10
subq %r9, %r10
leaq 0x3(%r10), %r8
andq $-0x4, %r8
decq %r10
movq %r10, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
shlq $0x2, %r9
leaq (%r9,%r11,4), %r9
addq %rdx, %r9
xorl %r10d, %r10d
movq %r10, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm7
por %xmm1, %xmm7
movdqa %xmm4, %xmm6
pxor %xmm2, %xmm6
pxor %xmm2, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm6, %xmm8
pcmpeqd %xmm6, %xmm7
pshufd $0xf5, %xmm7, %xmm9 # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7 # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r11d
notl %r11d
testb $0x1, %r11b
je 0x37b35c
movl $0xffff8080, -0xc(%r9,%r10,4) # imm = 0xFFFF8080
pxor %xmm3, %xmm7
pextrw $0x4, %xmm7, %r11d
testb $0x1, %r11b
je 0x37b375
movl $0xffff8080, -0x8(%r9,%r10,4) # imm = 0xFFFF8080
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm7
pcmpgtd %xmm6, %xmm7
pcmpeqd %xmm6, %xmm5
pshufd $0xf5, %xmm5, %xmm6 # xmm6 = xmm5[1,1,3,3]
pand %xmm7, %xmm6
pshufd $0xf5, %xmm7, %xmm5 # xmm5 = xmm7[1,1,3,3]
por %xmm6, %xmm5
pxor %xmm3, %xmm5
pextrw $0x0, %xmm5, %r11d
testb $0x1, %r11b
je 0x37b3b4
movl $0xffff8080, -0x4(%r9,%r10,4) # imm = 0xFFFF8080
pextrw $0x4, %xmm5, %r11d
testb $0x1, %r11b
je 0x37b3c8
movl $0xffff8080, (%r9,%r10,4) # imm = 0xFFFF8080
addq $0x4, %r10
cmpq %r10, %r8
jne 0x37b303
incq %rsi
addq %rcx, %rax
cmpq %r15, %rsi
jne 0x37b12d
movq 0x1470(%rsp), %rsi
callq 0x3801e0
movq 0x1478(%rsp), %rdi
leaq 0x1480(%rsp), %rax
cmpq %rax, %rdi
je 0x37b414
imulq $0x38, 0x1468(%rsp), %rsi
callq 0x1387a0
cmpq $0x0, 0x198(%rsp)
movq 0x108(%rsp), %rdi
movl 0x20(%rsp), %ecx
jle 0x37d9ac
movl %ecx, %eax
shll $0x10, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x148(%rsp)
movl %ecx, %eax
shll $0x8, %eax
movl %eax, 0xf8(%rsp)
movl %r13d, %eax
subl %ecx, %eax
shll $0x8, %eax
movl %eax, 0x12c(%rsp)
movq 0xc8(%rsp), %rax
subl %ecx, %eax
shll $0x8, %eax
movl %eax, 0x128(%rsp)
movq 0xa8(%rsp), %rax
leaq (,%rax,4), %rax
movq %rax, 0x28(%rsp)
leaq -0x4(%r12), %rax
movq %rax, 0xe8(%rsp)
leaq 0x1468(%rsp), %rbp
xorl %ecx, %ecx
xorl %eax, %eax
movq %rax, 0xc08(%rsp)
movq %rax, 0x3f0(%rsp)
movq %rax, 0x1c0(%rsp)
movslq %ecx, %rax
movl %eax, %esi
negl %esi
leaq -0x2(%rax), %r14
xorl %edx, %edx
leaq 0xc18(%rsp), %r13
movl %edx, %ebx
decl %esi
cmpl $-0x1, 0x8(%rdi,%r14,4)
leaq 0x1(%r14), %r14
leal 0x1(%rbx), %edx
jne 0x37b4ce
movl %esi, 0x124(%rsp)
movl %esi, %edx
notl %edx
cmpl %edx, %ecx
jge 0x37b6f1
movslq %r14d, %rcx
movq %rax, %r14
movl (%rdi,%rcx,4), %esi
movl (%rdi,%rax,4), %r15d
movq 0x180(%rsp), %r12
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x1b0(%rsp)
movl (%r12,%r15,8), %edx
movl 0x4(%r12,%r15,8), %ecx
movl (%r12,%rsi,8), %eax
subl 0x4(%r12,%rsi,8), %ecx
jne 0x37b537
cmpl %edx, %eax
je 0x37b6db
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
subl %edx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
movsd 0x148(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
andpd 0x1f9200(%rip), %xmm0 # 0x574770
orpd 0x1f9208(%rip), %xmm0 # 0x574780
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
imull %edx, %ecx
sarl $0x8, %ecx
movl %ecx, 0x1b0(%rsp)
imull %edx, %eax
sarl $0x8, %eax
movl %eax, 0x1b4(%rsp)
movq 0xc08(%rsp), %rax
cmpq 0xc00(%rsp), %rax
jne 0x37b5d6
movq 0x1b0(%rsp), %rax
movq %rax, 0x1468(%rsp)
movl $0x100, %esi # imm = 0x100
leaq 0xc00(%rsp), %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x2f8154
jmp 0x37b5f3
movl $0x100, %esi # imm = 0x100
leaq 0xc00(%rsp), %rdi
movq %r13, %rdx
leaq 0x1b0(%rsp), %rcx
callq 0x2f82ae
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x168(%rsp)
movq (%r12,%r15,8), %xmm0
paddd 0x22a74d(%rip), %xmm0 # 0x5a5d60
movq %xmm0, 0x168(%rsp)
movq 0x3f0(%rsp), %rax
cmpq 0x3e8(%rsp), %rax
jne 0x37b65d
movq 0x168(%rsp), %rax
movq %rax, 0x1468(%rsp)
movl $0x100, %esi # imm = 0x100
leaq 0x3e8(%rsp), %rdi
leaq 0x400(%rsp), %rdx
movq %rbp, %rcx
callq 0x2f8154
jmp 0x37b67f
movl $0x100, %esi # imm = 0x100
leaq 0x3e8(%rsp), %rdi
leaq 0x400(%rsp), %rdx
leaq 0x168(%rsp), %rcx
callq 0x2f82ae
movl (%r12,%r15,8), %ecx
movb $0x1, %al
cmpl 0xf8(%rsp), %ecx
jl 0x37b6af
cmpl 0x12c(%rsp), %ecx
jge 0x37b6af
movl 0x4(%r12,%r15,8), %ecx
cmpl 0xf8(%rsp), %ecx
jl 0x37b6af
cmpl 0x128(%rsp), %ecx
setge %al
movb %al, 0x1468(%rsp)
movl $0x100, %esi # imm = 0x100
leaq 0x1b8(%rsp), %rdi
leaq 0x1d0(%rsp), %rdx
movq %rbp, %rcx
callq 0x380226
movq 0x108(%rsp), %rdi
leaq 0x1(%r14), %rax
decl %ebx
jne 0x37b4f4
movq 0xc08(%rsp), %r13
jmp 0x37b6f4
xorl %r13d, %r13d
movq 0x2d0(%rsp), %r8
cmpq %r13, %r8
cmovleq %r13, %r8
movl $0x100, %esi # imm = 0x100
leaq 0x2d0(%rsp), %rdi
leaq 0x2e8(%rsp), %rdx
movq %r13, %rcx
callq 0x380274
movq %r13, 0x2d8(%rsp)
movq 0xc08(%rsp), %rcx
testq %rcx, %rcx
movq 0x10(%rsp), %r13
movq 0x30(%rsp), %r12
leaq 0x1b0(%rsp), %r15
jle 0x37d98a
leal -0x1(%rcx), %eax
movq 0xc10(%rsp), %rdx
movq 0x2e0(%rsp), %rsi
xorl %edi, %edi
movl %eax, %r8d
movslq %r8d, %r8
movl (%rdx,%rdi,8), %r9d
movl 0x4(%rdx,%rdi,8), %r10d
imull (%rdx,%r8,8), %r10d
imull 0x4(%rdx,%r8,8), %r9d
cmpl %r9d, %r10d
setl (%rsi,%r8)
movl %edi, %r8d
leaq 0x1(%rdi), %r9
movq %r9, %rdi
cmpq %r9, %rcx
jne 0x37b763
xorl %r10d, %r10d
movq 0xc10(%rsp), %rbx
movq (%rbx,%r10,8), %r11
movq %r11, %r14
shrq $0x20, %r14
movslq %eax, %r8
movq %r8, 0xb0(%rsp)
movq 0x3f8(%rsp), %rax
leaq (%rax,%r8,8), %rbp
movq (%rbp), %rcx
leaq (%rax,%r10,8), %r12
movl (%r12), %r13d
movl 0x4(%r12), %edi
movq %rcx, %rax
leal (%rcx,%r11), %esi
movl %ecx, %edx
subl %r11d, %edx
movl %edx, 0x1b0(%rsp)
shrq $0x20, %rax
movl %eax, %ecx
subl %r14d, %ecx
movl %ecx, 0x4(%rsp)
movl %ecx, 0x1b4(%rsp)
movl %esi, 0x1468(%rsp)
leal (%rax,%r14), %ecx
movl %ecx, 0x146c(%rsp)
movl %r13d, %esi
subl %r11d, %esi
movl %esi, 0xbc(%rsp)
movl %edi, %r9d
subl %r14d, %r9d
movl %r9d, 0xb8(%rsp)
addl %r11d, %r13d
movl %r13d, 0xfc(%rsp)
movq %rdi, 0x48(%rsp)
leal (%rdi,%r14), %esi
movl %esi, 0xe4(%rsp)
movq 0x1c8(%rsp), %rdi
movb (%rdi,%r8), %r8b
testb %r8b, %r8b
movq %r10, 0x118(%rsp)
movq %rbx, 0x138(%rsp)
movq %r11, 0x158(%rsp)
movq %r14, 0x150(%rsp)
movb %r8b, 0x5b(%rsp)
jne 0x37b87f
cmpb $0x1, (%rdi,%r10)
jne 0x37bca4
movq %r12, 0x68(%rsp)
movl $0x7f80, %edi # imm = 0x7F80
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %r8
cmpl %eax, %r8d
jge 0x37b910
movl $0xffff8080, %edx # imm = 0xFFFF8080
movq %rdx, 0x20(%rsp)
movl %ecx, %r12d
movl %esi, %r11d
movl %eax, %edx
leaq 0x146c(%rsp), %rax
movq %rax, 0xc0(%rsp)
leaq 0x1468(%rsp), %rax
movq %rax, 0x80(%rsp)
movq %rbp, 0x70(%rsp)
leaq 0xe4(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0xfc(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0xbc(%rsp), %rdi
movq %r8, %rsi
movl 0x4(%rsp), %ebx
jmp 0x37b984
movl %edx, %r13d
movl %r9d, %r12d
movl 0x4(%rsp), %r11d
movl %esi, %ebx
movl %ecx, %r9d
movl %r8d, %edx
movl %eax, %esi
leaq 0xb8(%rsp), %rax
movq %rax, 0xc0(%rsp)
leaq 0xbc(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x1b4(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %r15, 0x98(%rsp)
movq %rbp, 0x68(%rsp)
leaq 0x146c(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x1468(%rsp), %rdi
movl %esi, %r14d
sarl $0x8, %r14d
movq 0xc8(%rsp), %rax
cmpl %r14d, %eax
cmovll %eax, %r14d
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
movl %edx, 0x44(%rsp)
sarl $0x8, %edx
cmpl %edx, %eax
cmovll %eax, %edx
testl %edx, %edx
cmovlel %ecx, %edx
movl %edx, 0x88(%rsp)
movl %r9d, %edx
sarl $0x8, %edx
cmpl %edx, %eax
cmovll %eax, %edx
testl %edx, %edx
cmovlel %ecx, %edx
movl %edx, 0x48(%rsp)
movl %ebx, 0x4(%rsp)
sarl $0x8, %ebx
cmpl %ebx, %eax
cmovll %eax, %ebx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movl %r11d, %edx
sarl $0x8, %edx
cmpl %edx, %eax
cmovll %eax, %edx
testl %edx, %edx
cmovlel %ecx, %edx
movl %edx, 0x54(%rsp)
movl %r12d, %r10d
sarl $0x8, %r10d
cmpl %r10d, %eax
cmovll %eax, %r10d
testl %r10d, %r10d
cmovlel %ecx, %r10d
movl %r11d, %r15d
movl $0x0, 0x38(%rsp)
movl $0x0, 0x8(%rsp)
subl %r9d, %r15d
je 0x37ba41
movl %r13d, %eax
subl (%rdi), %eax
shll $0x8, %eax
cltd
idivl %r15d
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
shll $0x9, %eax
cltd
idivl %r15d
movl %eax, 0x38(%rsp)
movl %r11d, %r8d
movq 0x80(%rsp), %rax
movl (%rax), %ebp
subl %r12d, %r8d
je 0x37ba61
movl %r13d, %eax
subl %ebp, %eax
shll $0x8, %eax
cltd
idivl %r8d
movl %eax, %ecx
movq %rdi, 0xd8(%rsp)
movl (%rdi), %edx
movl %ebp, %edi
movl %r13d, %ebp
subl %edx, %ebp
movl %r12d, %eax
subl %r9d, %eax
imull %ebp, %eax
movl %edx, 0x64(%rsp)
movl %edi, 0x5c(%rsp)
subl %edi, %edx
imull %r15d, %edx
addl %eax, %edx
movl %r13d, 0x1c(%rsp)
movl %r12d, 0x60(%rsp)
movl %r8d, 0x78(%rsp)
je 0x37bab9
subl %r11d, %r12d
imull 0x20(%rsp), %r12d
movslq %r12d, %rax
shlq $0x9, %rax
movslq %edx, %rdi
cqto
idivq %rdi
movq %rax, %rdi
jmp 0x37babb
xorl %edi, %edi
movl %r14d, %r13d
shll $0x8, %r13d
subl %esi, %r13d
movl $0xff, %r8d
addl %r8d, %r13d
movl 0x88(%rsp), %esi
shll $0x8, %esi
subl 0x44(%rsp), %esi
addl %r8d, %esi
movl 0x48(%rsp), %edx
shll $0x8, %edx
subl %r9d, %edx
addl %r8d, %edx
movl %edx, 0x44(%rsp)
movl 0x54(%rsp), %eax
shll $0x8, %eax
subl %r11d, %eax
addl %r8d, %eax
movq 0x70(%rsp), %rdx
movl (%rdx), %r8d
movq 0x68(%rsp), %rdx
movl (%rdx), %r12d
cmpl %r12d, %r8d
jge 0x37bb6a
cmpl %r9d, 0x60(%rsp)
jle 0x37bd2e
movl %esi, 0x4(%rsp)
movl 0x1c(%rsp), %r11d
movl %r11d, %r8d
subl 0x5c(%rsp), %r8d
imull %r8d, %eax
cltd
movl 0x78(%rsp), %esi
idivl %esi
movl %eax, %r9d
addl %r11d, %r9d
imull 0x44(%rsp), %r8d
movl %r8d, %eax
cltd
idivl %esi
movl %eax, %r8d
movl 0x48(%rsp), %r11d
movl 0x54(%rsp), %esi
cmpl %r11d, %esi
jne 0x37bf06
movq 0x10(%rsp), %r13
jmp 0x37bfd9
cmpl 0x4(%rsp), %r11d
jge 0x37bd76
movl %esi, 0x4(%rsp)
movl 0x1c(%rsp), %r8d
subl 0x5c(%rsp), %r8d
imull %r8d, %eax
cltd
movl 0x78(%rsp), %esi
idivl %esi
movl %eax, %r9d
imull 0x44(%rsp), %r8d
movl %r8d, %eax
cltd
idivl %esi
movl %eax, %r8d
addl 0x64(%rsp), %r8d
movl 0x48(%rsp), %r11d
movl 0x54(%rsp), %esi
cmpl %esi, %r11d
je 0x37bc89
imull %r13d, %ebp
movl %ebp, %eax
cltd
idivl %r15d
movl %r11d, %edx
subl %r14d, %edx
imull 0x8(%rsp), %edx
addl %edx, %r12d
addl %eax, %r12d
movl %esi, %eax
subl %r11d, %eax
imull 0x10(%rsp), %r11d
movslq %r11d, %rdx
movq 0xe8(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
movq 0x20(%rsp), %rsi
addl %edi, %esi
negl %esi
movl %esi, 0x38(%rsp)
movl %r12d, %ebp
sarl $0x8, %ebp
testl %ebp, %ebp
movl $0x0, %esi
cmovlel %esi, %ebp
movl %r8d, %r13d
sarl $0x8, %r13d
movq 0x10(%rsp), %rsi
cmpl %esi, %r13d
cmovgel %esi, %r13d
cmpl %ebp, %r13d
jle 0x37bc74
movl %r13d, %r14d
shll $0x8, %r14d
subl %r8d, %r14d
addl $0xff, %r14d
imull %edi, %r14d
sarl $0x8, %r14d
addl 0x38(%rsp), %r14d
movslq %r13d, %rsi
leaq (%rdx,%rsi,4), %r15
subl %r13d, %ebp
movl %r14d, %esi
negl %esi
cmovsl %r14d, %esi
movl (%r15), %r11d
movl %r11d, %r13d
negl %r13d
cmovsl %r11d, %r13d
cmpl %r13d, %esi
cmovbl %r14d, %r11d
movl %r11d, (%r15)
addq $-0x4, %r15
subl %edi, %r14d
incl %ebp
jne 0x37bc49
addl 0x8(%rsp), %r12d
addl %ecx, %r8d
addq 0x28(%rsp), %rdx
decl %eax
jne 0x37bbf9
addl 0x1c(%rsp), %r9d
movl 0x54(%rsp), %eax
cmpl %ebx, %eax
jne 0x37c1b3
movq 0x10(%rsp), %r13
jmp 0x37c283
movl $0x7f80, %edi # imm = 0x7F80
movq %rdi, 0x38(%rsp)
movq 0x48(%rsp), %rdi
cmpl %eax, %edi
jge 0x37bdbf
movl %r13d, 0x1c(%rsp)
movl $0xffff8080, %edx # imm = 0xFFFF8080
movq %rdx, 0x38(%rsp)
movl %ecx, %r14d
movl %esi, %r13d
movl %eax, 0x68(%rsp)
leaq 0xb8(%rsp), %rax
movq %rax, 0xf0(%rsp)
leaq 0xbc(%rsp), %rcx
movq %r12, 0xa0(%rsp)
leaq 0xe4(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0xfc(%rsp), %r15
leaq 0x1b4(%rsp), %rsi
leaq 0x146c(%rsp), %rax
movq %rax, 0x100(%rsp)
leaq 0x1468(%rsp), %r12
jmp 0x37be2b
movl %eax, 0x68(%rsp)
imull %ebp, %esi
movl %esi, %eax
cltd
idivl %r15d
movl %eax, 0x4(%rsp)
imull %ebp, %r13d
movl %r13d, %eax
cltd
idivl %r15d
movl 0x54(%rsp), %r11d
movl %r11d, %edx
subl %r14d, %edx
imull 0x8(%rsp), %edx
addl %edx, %r12d
addl %eax, %r12d
movl %r10d, %r9d
subl %r11d, %r9d
jne 0x37c388
movq 0x10(%rsp), %r13
jmp 0x37c451
movl %eax, 0x68(%rsp)
imull %ebp, %r13d
movl %r13d, %eax
cltd
idivl %r15d
movl %eax, %r13d
imull %ebp, %esi
movl %esi, %eax
cltd
idivl %r15d
movl %eax, 0x60(%rsp)
movl 0x48(%rsp), %esi
movl %esi, %eax
subl %r14d, %eax
imull 0x8(%rsp), %eax
addl %eax, %r12d
addl %r13d, %r12d
movl %ebx, %r9d
subl %esi, %r9d
jne 0x37c64f
movq 0x10(%rsp), %r13
jmp 0x37c71e
movl %edx, 0x1c(%rsp)
movl %r9d, %r14d
movl 0x4(%rsp), %r13d
movl %esi, 0x4(%rsp)
movl %ecx, %r9d
movl %edi, 0x68(%rsp)
movq %rax, 0x48(%rsp)
leaq 0x146c(%rsp), %rax
movq %rax, 0xf0(%rsp)
leaq 0x1468(%rsp), %rcx
movq %rbp, 0xa0(%rsp)
leaq 0x1b4(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0xe4(%rsp), %rsi
movq %r12, %rbp
leaq 0xb8(%rsp), %rax
movq %rax, 0x100(%rsp)
leaq 0xbc(%rsp), %r12
movl $0x0, 0x8(%rsp)
movl %r13d, %r11d
movl $0x0, 0x54(%rsp)
movl $0x0, 0x20(%rsp)
subl %r9d, %r11d
je 0x37be6c
movl 0x1c(%rsp), %eax
subl (%rcx), %eax
shll $0x8, %eax
cltd
idivl %r11d
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
shll $0x9, %eax
cltd
idivl %r11d
movl %eax, 0x54(%rsp)
movq %rbp, 0x88(%rsp)
movl %r13d, %edi
movl (%r12), %edx
subl %r14d, %edi
movl %edx, 0x44(%rsp)
je 0x37be98
movl 0x1c(%rsp), %eax
subl %edx, %eax
shll $0x8, %eax
cltd
idivl %edi
movl 0x44(%rsp), %edx
movl %eax, 0x8(%rsp)
movl %edi, 0x90(%rsp)
movq %rcx, 0x110(%rsp)
movl (%rcx), %ecx
movl 0x1c(%rsp), %ebp
subl %ecx, %ebp
movl %r14d, %eax
subl %r9d, %eax
imull %ebp, %eax
movl %ecx, 0xd8(%rsp)
subl %edx, %ecx
imull %r11d, %ecx
addl %eax, %ecx
movq %r15, 0xc0(%rsp)
movq %r12, 0x130(%rsp)
movq %rsi, 0x140(%rsp)
je 0x37c90a
movl %r14d, %eax
subl %r13d, %eax
imull 0x38(%rsp), %eax
cltq
shlq $0x9, %rax
movslq %ecx, %rcx
cqto
idivq %rcx
movq %rax, %rdi
jmp 0x37c90c
imull %r13d, %ebp
movl %ebp, %eax
cltd
idivl %r15d
movl %esi, %edx
subl %r14d, %edx
imull 0x8(%rsp), %edx
addl %edx, %r12d
addl %eax, %r12d
movl %r11d, %eax
subl %esi, %eax
movq 0x10(%rsp), %r13
imull %r13d, %esi
movslq %esi, %rdx
movq 0x30(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
movl %r9d, %r11d
sarl $0x8, %r11d
testl %r11d, %r11d
movl $0x0, %esi
cmovlel %esi, %r11d
movl %r12d, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
movl %r13d, %r14d
cmovll %ebp, %r14d
cmpl %r11d, %r14d
jle 0x37bfbf
movl %r11d, %r14d
shll $0x8, %r11d
subl %r9d, %r11d
addl $0xff, %r11d
imull %edi, %r11d
sarl $0x8, %r11d
addl 0x20(%rsp), %r11d
movslq %ebp, %r15
movq 0xa8(%rsp), %rsi
cmpq %r15, %rsi
cmovlq %rsi, %r15
movl %r11d, %ebp
negl %ebp
cmovsl %r11d, %ebp
movl (%rdx,%r14,4), %esi
movl %esi, %r13d
negl %r13d
cmovsl %esi, %r13d
cmpl %r13d, %ebp
cmovbl %r11d, %esi
movl %esi, (%rdx,%r14,4)
addl %edi, %r11d
incq %r14
cmpl %r14d, %r15d
jne 0x37bf92
addl %ecx, %r9d
addl 0x8(%rsp), %r12d
addq 0x28(%rsp), %rdx
decl %eax
movq 0x10(%rsp), %r13
jne 0x37bf3a
addl 0x64(%rsp), %r8d
movl 0x48(%rsp), %eax
cmpl %r10d, %eax
je 0x37c0af
movl %r10d, %ebp
subl %eax, %ebp
imull %r13d, %eax
movslq %eax, %rdx
movq 0x30(%rsp), %rax
leaq (%rax,%rdx,4), %rdx
movl %r8d, %r11d
movl %ebp, 0x38(%rsp)
movl %r9d, %r14d
sarl $0x8, %r14d
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
movl %r11d, %r12d
sarl $0x8, %r12d
cmpl %r13d, %r12d
movl %r13d, %esi
cmovll %r12d, %esi
cmpl %r14d, %esi
jle 0x37c08d
movl %r14d, %r15d
shll $0x8, %r14d
subl %r9d, %r14d
addl $0xff, %r14d
imull %edi, %r14d
sarl $0x8, %r14d
addl 0x20(%rsp), %r14d
movslq %r12d, %r12
movq 0xa8(%rsp), %rax
cmpq %r12, %rax
cmovlq %rax, %r12
movl %r14d, %esi
negl %esi
cmovsl %r14d, %esi
movl (%rdx,%r15,4), %eax
movl %eax, %r13d
negl %r13d
cmovsl %eax, %r13d
cmpl %r13d, %esi
cmovbl %r14d, %eax
movl %eax, (%rdx,%r15,4)
addl %edi, %r14d
incq %r15
cmpl %r15d, %r12d
jne 0x37c060
addl %ecx, %r9d
addl %ecx, %r11d
addq 0x28(%rsp), %rdx
decl %ebp
movq 0x10(%rsp), %r13
jne 0x37c007
movl 0x38(%rsp), %eax
imull %ecx, %eax
addl %eax, %r8d
cmpl %ebx, %r10d
movq 0x20(%rsp), %r12
movl 0x4(%rsp), %esi
je 0x37d422
movq 0x98(%rsp), %rax
movl (%rax), %eax
movq 0xd8(%rsp), %rdx
subl (%rdx), %eax
imull %esi, %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %esi
movq 0x90(%rsp), %rdx
subl (%rdx), %esi
cltd
idivl %esi
movl %r10d, %edx
subl 0x88(%rsp), %edx
imull 0x8(%rsp), %edx
movq 0x70(%rsp), %rsi
addl (%rsi), %edx
addl %eax, %edx
subl %r10d, %ebx
imull %r13d, %r10d
movslq %r10d, %rax
movq 0xe8(%rsp), %rsi
leaq (%rsi,%rax,4), %rax
addl %edi, %r12d
negl %r12d
movl %edx, %r9d
sarl $0x8, %r9d
testl %r9d, %r9d
movl $0x0, %esi
cmovlel %esi, %r9d
movl %r8d, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
cmovgel %r13d, %ebp
cmpl %r9d, %ebp
jle 0x37c19a
movl %ebp, %r10d
shll $0x8, %r10d
subl %r8d, %r10d
addl $0xff, %r10d
imull %edi, %r10d
sarl $0x8, %r10d
addl %r12d, %r10d
movslq %ebp, %rsi
leaq (%rax,%rsi,4), %r11
subl %ebp, %r9d
movl %r10d, %esi
negl %esi
cmovsl %r10d, %esi
movl (%r11), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %esi
cmovbl %r10d, %ebp
movl %ebp, (%r11)
addq $-0x4, %r11
subl %edi, %r10d
incl %r9d
jne 0x37c16e
addl 0x8(%rsp), %edx
addl %ecx, %r8d
addq 0x28(%rsp), %rax
decl %ebx
jne 0x37c123
jmp 0x37d422
movl %ebx, %r14d
subl %eax, %r14d
movq 0x10(%rsp), %r13
imull %r13d, %eax
cltq
movq 0xe8(%rsp), %rdx
leaq (%rdx,%rax,4), %rdx
movq 0x20(%rsp), %rax
addl %edi, %eax
negl %eax
movl %eax, 0x38(%rsp)
movl %r9d, %ebp
movl %r14d, 0x48(%rsp)
movl %ebp, %r15d
sarl $0x8, %r15d
testl %r15d, %r15d
movl $0x0, %eax
cmovlel %eax, %r15d
movl %r8d, %r11d
sarl $0x8, %r11d
cmpl %r13d, %r11d
cmovgel %r13d, %r11d
cmpl %r15d, %r11d
jle 0x37c261
movl %r11d, %r12d
shll $0x8, %r12d
subl %r8d, %r12d
addl $0xff, %r12d
imull %edi, %r12d
sarl $0x8, %r12d
addl 0x38(%rsp), %r12d
movslq %r11d, %rsi
leaq (%rdx,%rsi,4), %r13
subl %r11d, %r15d
movl %r12d, %esi
negl %esi
cmovsl %r12d, %esi
movl (%r13), %eax
movl %eax, %r11d
negl %r11d
cmovsl %eax, %r11d
cmpl %r11d, %esi
cmovbl %r12d, %eax
movl %eax, (%r13)
addq $-0x4, %r13
subl %edi, %r12d
incl %r15d
jne 0x37c233
addl %ecx, %ebp
addl %ecx, %r8d
addq 0x28(%rsp), %rdx
decl %r14d
movq 0x10(%rsp), %r13
jne 0x37c1e5
movl 0x48(%rsp), %eax
imull %ecx, %eax
addl %eax, %r9d
movq 0x20(%rsp), %r12
cmpl %r10d, %ebx
movl 0x4(%rsp), %esi
je 0x37d422
movq 0x98(%rsp), %rax
movl (%rax), %eax
movq 0xd8(%rsp), %rdx
subl (%rdx), %eax
imull %esi, %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %esi
movq 0x90(%rsp), %rdx
subl (%rdx), %esi
cltd
idivl %esi
movl %ebx, %edx
subl 0x88(%rsp), %edx
imull 0x8(%rsp), %edx
movq 0x70(%rsp), %rsi
addl (%rsi), %edx
addl %eax, %edx
subl %ebx, %r10d
imull %r13d, %ebx
movslq %ebx, %rax
movq 0x30(%rsp), %rsi
leaq (%rsi,%rax,4), %rax
movl %r9d, %r8d
sarl $0x8, %r8d
testl %r8d, %r8d
movl $0x0, %esi
cmovlel %esi, %r8d
movl %edx, %ebx
sarl $0x8, %ebx
cmpl %r13d, %ebx
movl %r13d, %esi
cmovll %ebx, %esi
cmpl %r8d, %esi
jle 0x37c36e
movl %r8d, %r11d
shll $0x8, %r8d
subl %r9d, %r8d
addl $0xff, %r8d
imull %edi, %r8d
sarl $0x8, %r8d
addl %r12d, %r8d
movslq %ebx, %rbx
movq 0xa8(%rsp), %rsi
cmpq %rbx, %rsi
cmovlq %rsi, %rbx
movl %r8d, %esi
negl %esi
cmovsl %r8d, %esi
movl (%rax,%r11,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %esi
cmovbl %r8d, %ebp
movl %ebp, (%rax,%r11,4)
addl %edi, %r8d
incq %r11
cmpl %r11d, %ebx
jne 0x37c341
addl %ecx, %r9d
addl 0x8(%rsp), %edx
addq 0x28(%rsp), %rax
decl %r10d
jne 0x37c2ed
jmp 0x37d422
movl 0x1c(%rsp), %esi
movl %esi, %eax
subl 0x5c(%rsp), %eax
imull 0x68(%rsp), %eax
cltd
idivl 0x78(%rsp)
addl %esi, %eax
movq 0x10(%rsp), %r13
imull %r13d, %r11d
movslq %r11d, %rdx
movq 0x30(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
movl %eax, %r11d
sarl $0x8, %r11d
testl %r11d, %r11d
movl $0x0, %esi
cmovlel %esi, %r11d
movl %r12d, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
movl %r13d, %esi
cmovll %ebp, %esi
cmpl %r11d, %esi
jle 0x37c437
movl %r11d, %r14d
shll $0x8, %r11d
subl %eax, %r11d
addl $0xff, %r11d
imull %edi, %r11d
sarl $0x8, %r11d
addl 0x20(%rsp), %r11d
movslq %ebp, %r15
movq 0xa8(%rsp), %rsi
cmpq %r15, %rsi
cmovlq %rsi, %r15
movl %r11d, %esi
negl %esi
cmovsl %r11d, %esi
movl (%rdx,%r14,4), %ebp
movl %ebp, %r13d
negl %r13d
cmovsl %ebp, %r13d
cmpl %r13d, %esi
cmovbl %r11d, %ebp
movl %ebp, (%rdx,%r14,4)
addl %edi, %r11d
incq %r14
cmpl %r14d, %r15d
jne 0x37c40a
addl %ecx, %eax
addl 0x8(%rsp), %r12d
addq 0x28(%rsp), %rdx
decl %r9d
movq 0x10(%rsp), %r13
jne 0x37c3b3
movl %r10d, %eax
subl 0x88(%rsp), %eax
imull 0x8(%rsp), %eax
addl %eax, %r8d
addl 0x4(%rsp), %r8d
movl 0x48(%rsp), %r9d
cmpl %r9d, %r10d
je 0x37c55a
movl %r10d, %eax
shll $0x8, %eax
orl $0xff, %eax
movq 0x70(%rsp), %rdx
subl 0x4(%rdx), %eax
imull 0x20(%rsp), %eax
addl %eax, %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %esi
movq 0x90(%rsp), %rdx
subl (%rdx), %esi
cltd
idivl %esi
movl %r9d, %edx
subl %r10d, %edx
imull %r13d, %r10d
movslq %r10d, %rsi
movq 0x30(%rsp), %r9
leaq (%r9,%rsi,4), %r9
movl %r8d, %r10d
sarl $0x8, %r10d
testl %r10d, %r10d
movl $0x0, %esi
cmovlel %esi, %r10d
movl %r12d, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
movl %r13d, %esi
cmovll %ebp, %esi
cmpl %r10d, %esi
jle 0x37c53f
movl %r10d, %r11d
shll $0x8, %r10d
subl %r8d, %r10d
addl $0xff, %r10d
imull %edi, %r10d
sarl $0x8, %r10d
addl %eax, %r10d
movslq %ebp, %r14
movq 0xa8(%rsp), %rsi
cmpq %r14, %rsi
cmovlq %rsi, %r14
movl %r10d, %esi
negl %esi
cmovsl %r10d, %esi
movl (%r9,%r11,4), %ebp
movl %ebp, %r15d
negl %r15d
cmovsl %ebp, %r15d
cmpl %r15d, %esi
cmovbl %r10d, %ebp
movl %ebp, (%r9,%r11,4)
addl %edi, %r10d
incq %r11
cmpl %r11d, %r14d
jne 0x37c512
movl 0x8(%rsp), %esi
addl %esi, %r8d
addl 0x38(%rsp), %eax
addl %esi, %r12d
addq 0x28(%rsp), %r9
decl %edx
jne 0x37c4bd
movl 0x48(%rsp), %r9d
subl %r9d, %ebx
movq 0x20(%rsp), %r12
je 0x37d422
movq 0x98(%rsp), %rax
movl (%rax), %eax
movq 0x80(%rsp), %rdx
subl (%rdx), %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %esi
movq 0xc0(%rsp), %rdx
subl (%rdx), %esi
imull 0x44(%rsp), %eax
cltd
idivl %esi
movq 0xd8(%rsp), %rdx
addl (%rdx), %eax
imull %r13d, %r9d
movslq %r9d, %rdx
movq 0xe8(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
addl %edi, %r12d
negl %r12d
movl %r8d, %r9d
sarl $0x8, %r9d
testl %r9d, %r9d
movl $0x0, %esi
cmovlel %esi, %r9d
movl %eax, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
cmovgel %r13d, %ebp
cmpl %r9d, %ebp
jle 0x37c636
movl %ebp, %r10d
shll $0x8, %r10d
subl %eax, %r10d
addl $0xff, %r10d
imull %edi, %r10d
sarl $0x8, %r10d
addl %r12d, %r10d
movslq %ebp, %rsi
leaq (%rdx,%rsi,4), %r11
subl %ebp, %r9d
movl %r10d, %esi
negl %esi
cmovsl %r10d, %esi
movl (%r11), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %esi
cmovbl %r10d, %ebp
movl %ebp, (%r11)
addq $-0x4, %r11
subl %edi, %r10d
incl %r9d
jne 0x37c60a
addl 0x8(%rsp), %r8d
addl %ecx, %eax
addq 0x28(%rsp), %rdx
decl %ebx
jne 0x37c5c0
jmp 0x37d422
movl 0x1c(%rsp), %eax
subl 0x5c(%rsp), %eax
imull 0x44(%rsp), %eax
cltd
idivl 0x78(%rsp)
movl %eax, %ebp
addl 0x64(%rsp), %ebp
movq 0x10(%rsp), %r13
imull %r13d, %esi
movslq %esi, %rax
movq 0xe8(%rsp), %rdx
leaq (%rdx,%rax,4), %rdx
movq 0x20(%rsp), %rax
addl %edi, %eax
negl %eax
movl %eax, 0x4(%rsp)
movl %r12d, %r14d
sarl $0x8, %r14d
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
movl %ebp, %eax
sarl $0x8, %eax
cmpl %r13d, %eax
cmovgel %r13d, %eax
cmpl %r14d, %eax
jle 0x37c704
movl %eax, %r15d
shll $0x8, %r15d
subl %ebp, %r15d
addl $0xff, %r15d
imull %edi, %r15d
sarl $0x8, %r15d
addl 0x4(%rsp), %r15d
movslq %eax, %rsi
leaq (%rdx,%rsi,4), %r13
subl %eax, %r14d
movl %r15d, %eax
negl %eax
cmovsl %r15d, %eax
movl (%r13), %r11d
movl %r11d, %esi
negl %esi
cmovsl %r11d, %esi
cmpl %esi, %eax
cmovbl %r15d, %r11d
movl %r11d, (%r13)
addq $-0x4, %r13
subl %edi, %r15d
incl %r14d
jne 0x37c6d8
addl 0x8(%rsp), %r12d
addl %ecx, %ebp
addq 0x28(%rsp), %rdx
decl %r9d
movq 0x10(%rsp), %r13
jne 0x37c68c
movl %ebx, %eax
subl 0x88(%rsp), %eax
imull 0x8(%rsp), %eax
addl %eax, %r8d
addl 0x60(%rsp), %r8d
movl 0x54(%rsp), %r9d
cmpl %r9d, %ebx
je 0x37c814
movl %ebx, %eax
shll $0x8, %eax
orl $0xff, %eax
movq 0x70(%rsp), %rdx
subl 0x4(%rdx), %eax
imull 0x20(%rsp), %eax
addl %eax, %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %esi
movq 0x90(%rsp), %rdx
subl (%rdx), %esi
cltd
idivl %esi
movl %r9d, %edx
subl %ebx, %edx
imull %r13d, %ebx
movslq %ebx, %rsi
movq 0xe8(%rsp), %r9
leaq (%r9,%rsi,4), %r9
subl %edi, %eax
movl %r12d, %r11d
sarl $0x8, %r11d
testl %r11d, %r11d
movl $0x0, %esi
cmovlel %esi, %r11d
movl %r8d, %ebp
sarl $0x8, %ebp
cmpl %r13d, %ebp
cmovgel %r13d, %ebp
cmpl %r11d, %ebp
jle 0x37c7f9
movl %ebp, %ebx
shll $0x8, %ebx
subl %r8d, %ebx
addl $0xff, %ebx
imull %edi, %ebx
sarl $0x8, %ebx
movslq %ebp, %rsi
leaq (%r9,%rsi,4), %r14
subl %ebp, %r11d
addl %eax, %ebx
movl %ebx, %esi
negl %esi
cmovsl %ebx, %esi
movl (%r14), %ebp
movl %ebp, %r15d
negl %r15d
cmovsl %ebp, %r15d
cmpl %r15d, %esi
cmovbl %ebx, %ebp
movl %ebp, (%r14)
addq $-0x4, %r14
subl %edi, %ebx
incl %r11d
jne 0x37c7d1
movl 0x8(%rsp), %esi
addl %esi, %r12d
addl %esi, %r8d
addq 0x28(%rsp), %r9
addl 0x38(%rsp), %eax
decl %edx
jne 0x37c78c
movl 0x54(%rsp), %r11d
subl %r11d, %r10d
movq 0x20(%rsp), %r12
je 0x37d422
movq 0x98(%rsp), %rax
movl (%rax), %esi
movl %esi, %eax
movq 0x80(%rsp), %rdx
subl (%rdx), %eax
imull 0x68(%rsp), %eax
movq 0xa0(%rsp), %rdx
movl (%rdx), %r9d
movq 0xc0(%rsp), %rdx
subl (%rdx), %r9d
cltd
idivl %r9d
addl %esi, %eax
imull %r13d, %r11d
movslq %r11d, %rdx
movq 0x30(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
movl %eax, %r9d
sarl $0x8, %r9d
testl %r9d, %r9d
movl $0x0, %esi
cmovlel %esi, %r9d
movl %r8d, %ebx
sarl $0x8, %ebx
cmpl %r13d, %ebx
movl %r13d, %esi
cmovll %ebx, %esi
cmpl %r9d, %esi
jle 0x37c8f0
movl %r9d, %r11d
shll $0x8, %r9d
subl %eax, %r9d
addl $0xff, %r9d
imull %edi, %r9d
sarl $0x8, %r9d
addl %r12d, %r9d
movslq %ebx, %rbx
movq 0xa8(%rsp), %rsi
cmpq %rbx, %rsi
cmovlq %rsi, %rbx
movl %r9d, %esi
negl %esi
cmovsl %r9d, %esi
movl (%rdx,%r11,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %esi
cmovbl %r9d, %ebp
movl %ebp, (%rdx,%r11,4)
addl %edi, %r9d
incq %r11
cmpl %r11d, %ebx
jne 0x37c8c3
addl %ecx, %eax
addl 0x8(%rsp), %r8d
addq 0x28(%rsp), %rdx
decl %r10d
jne 0x37c86e
jmp 0x37d422
xorl %edi, %edi
movq 0x48(%rsp), %r8
movl %r8d, %eax
sarl $0x8, %eax
movl %eax, 0x60(%rsp)
notl %r8d
movl 0x68(%rsp), %edx
movl %edx, %eax
sarl $0x8, %eax
movl %eax, 0x5c(%rsp)
notl %edx
movl %r9d, %eax
sarl $0x8, %eax
movl %eax, 0x80(%rsp)
movl %r9d, %r12d
notl %r12d
movl 0x4(%rsp), %ebx
movl %ebx, %esi
sarl $0x8, %esi
movl %r13d, %eax
sarl $0x8, %eax
movl %eax, 0x70(%rsp)
movl %r13d, %r15d
notl %r15d
movl %r14d, %ecx
sarl $0x8, %ecx
movl $0xff, %eax
andl %eax, %r8d
movq %r8, 0x48(%rsp)
andl %eax, %edx
movl %edx, 0x68(%rsp)
andl %eax, %r12d
movl %r12d, 0x64(%rsp)
andl %eax, %r15d
movl %r15d, 0x98(%rsp)
movq 0x88(%rsp), %rax
movl (%rax), %r8d
movq 0xa0(%rsp), %rax
movl (%rax), %r12d
cmpl %r12d, %r8d
jge 0x37cc2c
cmpl %r9d, %r14d
movq 0x10(%rsp), %r14
jle 0x37cedf
movl 0x1c(%rsp), %r9d
movl %r9d, %r8d
subl 0x44(%rsp), %r8d
movl 0x98(%rsp), %eax
imull %r8d, %eax
cltd
movl 0x90(%rsp), %ebx
idivl %ebx
movl %eax, %r10d
addl %r9d, %r10d
imull 0x64(%rsp), %r8d
movl %r8d, %eax
cltd
idivl %ebx
movl %eax, %r8d
movl 0x70(%rsp), %r9d
movl 0x80(%rsp), %r13d
cmpl %r13d, %r9d
movl 0x20(%rsp), %ebx
je 0x37caa1
imull 0x48(%rsp), %ebp
movl %ebp, %eax
cltd
idivl %r11d
movl %r9d, %edx
subl 0x60(%rsp), %edx
imull %ebx, %edx
addl %edx, %r12d
addl %eax, %r12d
movl %r13d, %eax
subl %r9d, %eax
imull %r14d, %r9d
movslq %r9d, %rdx
movq 0x30(%rsp), %r9
leaq (%r9,%rdx,4), %rdx
movl %r10d, %r11d
sarl $0x8, %r11d
movl %r12d, %ebp
sarl $0x8, %ebp
cmpl %r11d, %ebp
jle 0x37ca90
movl %r10d, %r9d
notl %r9d
movzbl %r9b, %r9d
imull %edi, %r9d
sarl $0x8, %r9d
addl 0x38(%rsp), %r9d
movslq %r11d, %r11
movl %ebp, %r14d
movl %r9d, %ebp
negl %ebp
cmovsl %r9d, %ebp
movl (%rdx,%r11,4), %r15d
movl %r15d, %r13d
negl %r13d
cmovsl %r15d, %r13d
cmpl %r13d, %ebp
cmovbl %r9d, %r15d
movl %r15d, (%rdx,%r11,4)
addl %edi, %r9d
incq %r11
cmpl %r11d, %r14d
jne 0x37ca63
addl 0x8(%rsp), %r10d
addl %ebx, %r12d
addq 0x28(%rsp), %rdx
decl %eax
jne 0x37ca34
addl 0xd8(%rsp), %r8d
movl 0x80(%rsp), %eax
cmpl %ecx, %eax
je 0x37cb4f
movl %ecx, %r11d
subl %eax, %r11d
imull 0x10(%rsp), %eax
movslq %eax, %rdx
movq 0x30(%rsp), %rax
leaq (%rax,%rdx,4), %rdx
movl %r8d, %r9d
movl %r11d, 0x4(%rsp)
movl %r10d, %r14d
sarl $0x8, %r14d
movl %r9d, %r15d
sarl $0x8, %r15d
cmpl %r14d, %r15d
jle 0x37cb2f
movl %r10d, %ebp
notl %ebp
movzbl %bpl, %ebp
imull %edi, %ebp
sarl $0x8, %ebp
addl 0x38(%rsp), %ebp
movslq %r14d, %r14
movl %r15d, %r15d
movl %ebp, %r12d
negl %r12d
cmovsl %ebp, %r12d
movl (%rdx,%r14,4), %eax
movl %eax, %r13d
negl %r13d
cmovsl %eax, %r13d
cmpl %r13d, %r12d
cmovbl %ebp, %eax
movl %eax, (%rdx,%r14,4)
addl %edi, %ebp
incq %r14
cmpl %r14d, %r15d
jne 0x37cb03
movl 0x8(%rsp), %eax
addl %eax, %r10d
addl %eax, %r9d
addq 0x28(%rsp), %rdx
decl %r11d
jne 0x37cad7
movl 0x4(%rsp), %eax
imull 0x8(%rsp), %eax
addl %eax, %r8d
movq 0x10(%rsp), %r13
cmpl %esi, %ecx
movq 0x38(%rsp), %r15
movq 0x88(%rsp), %r10
je 0x37d422
movq 0xc0(%rsp), %rax
movl (%rax), %eax
movq 0x110(%rsp), %rdx
subl (%rdx), %eax
imull 0x68(%rsp), %eax
movq 0x78(%rsp), %rdx
movl (%rdx), %r9d
movq 0xf0(%rsp), %rdx
subl (%rdx), %r9d
cltd
idivl %r9d
movl %ecx, %edx
subl 0x5c(%rsp), %edx
imull %ebx, %edx
addl (%r10), %edx
addl %eax, %edx
subl %ecx, %esi
imull %r13d, %ecx
movslq %ecx, %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rax,4), %rax
addl %edi, %r15d
negl %r15d
movl %edx, %r10d
sarl $0x8, %r10d
movl %r8d, %r9d
sarl $0x8, %r9d
cmpl %r10d, %r9d
jle 0x37cc17
movl %r8d, %ecx
notl %ecx
movzbl %cl, %ecx
imull %edi, %ecx
sarl $0x8, %ecx
addl %r15d, %ecx
movslq %r9d, %r9
movl %r10d, %r10d
movl %ecx, %r11d
negl %r11d
cmovsl %ecx, %r11d
movl -0x4(%rax,%r9,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %r11d
cmovbl %ecx, %ebp
movl %ebp, -0x4(%rax,%r9,4)
decq %r9
subl %edi, %ecx
cmpl %r9d, %r10d
jne 0x37cbe9
addl %ebx, %edx
addl 0x8(%rsp), %r8d
addq 0x28(%rsp), %rax
decl %esi
jne 0x37cbbf
jmp 0x37d422
cmpl %ebx, %r13d
jge 0x37cfe5
movl %esi, 0x4(%rsp)
movl 0x1c(%rsp), %r8d
subl 0x44(%rsp), %r8d
movl 0x98(%rsp), %eax
imull %r8d, %eax
cltd
movl 0x90(%rsp), %r9d
idivl %r9d
movl %eax, %r10d
imull 0x64(%rsp), %r8d
movl %r8d, %eax
cltd
idivl %r9d
movl %eax, %r13d
addl 0xd8(%rsp), %r13d
movl 0x70(%rsp), %r8d
movl 0x80(%rsp), %r9d
cmpl %r8d, %r9d
movl 0x20(%rsp), %r14d
je 0x37cd42
imull 0x48(%rsp), %ebp
movl %ebp, %eax
cltd
idivl %r11d
movl %r9d, %edx
subl 0x60(%rsp), %edx
imull %r14d, %edx
addl %edx, %r12d
addl %eax, %r12d
movl %r8d, %eax
subl %r9d, %eax
imull 0x10(%rsp), %r9d
movslq %r9d, %rdx
movq 0x30(%rsp), %r8
leaq (%r8,%rdx,4), %rdx
movq 0x38(%rsp), %r8
leal (%r8,%rdi), %ebx
negl %ebx
movl %r14d, %esi
movl %r12d, %ebp
sarl $0x8, %ebp
movl %r13d, %r11d
sarl $0x8, %r11d
cmpl %ebp, %r11d
jle 0x37cd2e
movl %r13d, %r9d
notl %r9d
movzbl %r9b, %r9d
imull %edi, %r9d
sarl $0x8, %r9d
addl %ebx, %r9d
movslq %r11d, %r11
movl %ebp, %r14d
movl %r9d, %ebp
negl %ebp
cmovsl %r9d, %ebp
movl -0x4(%rdx,%r11,4), %r8d
movl %r8d, %r15d
negl %r15d
cmovsl %r8d, %r15d
cmpl %r15d, %ebp
cmovbl %r9d, %r8d
movl %r8d, -0x4(%rdx,%r11,4)
decq %r11
subl %edi, %r9d
cmpl %r11d, %r14d
jne 0x37ccff
movl %esi, %r14d
addl %esi, %r12d
addl 0x8(%rsp), %r13d
addq 0x28(%rsp), %rdx
decl %eax
jne 0x37cccf
addl 0x1c(%rsp), %r10d
movl 0x70(%rsp), %eax
movl 0x4(%rsp), %esi
cmpl %esi, %eax
je 0x37ce02
movl %r14d, 0x20(%rsp)
movl %esi, %r11d
subl %eax, %r11d
imull 0x10(%rsp), %eax
movslq %eax, %rdx
movq 0x30(%rsp), %rax
leaq (%rax,%rdx,4), %rdx
movq 0x38(%rsp), %rax
leal (%rax,%rdi), %ebx
negl %ebx
movl %r10d, %r9d
movl %r11d, 0x48(%rsp)
movl %r9d, %r15d
sarl $0x8, %r15d
movl %r13d, %r14d
sarl $0x8, %r14d
cmpl %r15d, %r14d
jle 0x37cddd
movl %r13d, %ebp
notl %ebp
movzbl %bpl, %ebp
imull %edi, %ebp
sarl $0x8, %ebp
addl %ebx, %ebp
movslq %r14d, %r14
movl %r15d, %r15d
movl %ebp, %r12d
negl %r12d
cmovsl %ebp, %r12d
movl -0x4(%rdx,%r14,4), %r8d
movl %r8d, %eax
negl %eax
cmovsl %r8d, %eax
cmpl %eax, %r12d
cmovbl %ebp, %r8d
movl %r8d, -0x4(%rdx,%r14,4)
decq %r14
subl %edi, %ebp
cmpl %r14d, %r15d
jne 0x37cdaf
movl 0x8(%rsp), %eax
addl %eax, %r9d
addl %eax, %r13d
addq 0x28(%rsp), %rdx
decl %r11d
jne 0x37cd85
movl 0x48(%rsp), %eax
imull 0x8(%rsp), %eax
addl %eax, %r10d
movl 0x20(%rsp), %r14d
cmpl %ecx, %esi
movq 0x10(%rsp), %r13
movq 0x38(%rsp), %r15
movq 0x88(%rsp), %r9
je 0x37d422
movq 0xc0(%rsp), %rax
movl (%rax), %eax
movq 0x110(%rsp), %rdx
subl (%rdx), %eax
imull 0x68(%rsp), %eax
movq 0x78(%rsp), %rdx
movl (%rdx), %r8d
movq 0xf0(%rsp), %rdx
subl (%rdx), %r8d
cltd
idivl %r8d
movl %esi, %edx
subl 0x5c(%rsp), %edx
imull %r14d, %edx
addl (%r9), %edx
addl %eax, %edx
subl %esi, %ecx
imull %r13d, %esi
movslq %esi, %rax
movq 0x30(%rsp), %r8
leaq (%r8,%rax,4), %rax
movl %r10d, %r9d
sarl $0x8, %r9d
movl %edx, %r11d
sarl $0x8, %r11d
cmpl %r9d, %r11d
jle 0x37cec8
movl %r10d, %r8d
notl %r8d
movzbl %r8b, %r8d
imull %edi, %r8d
sarl $0x8, %r8d
addl %r15d, %r8d
movslq %r9d, %r9
movl %r11d, %r11d
movl %r8d, %ebx
negl %ebx
cmovsl %r8d, %ebx
movl (%rax,%r9,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %ebx
cmovbl %r8d, %ebp
movl %ebp, (%rax,%r9,4)
addl %edi, %r8d
incq %r9
cmpl %r9d, %r11d
jne 0x37ce9b
addl 0x8(%rsp), %r10d
addl 0x20(%rsp), %edx
addq 0x28(%rsp), %rax
decl %ecx
jne 0x37ce6d
jmp 0x37d422
movl 0x68(%rsp), %eax
imull %ebp, %eax
cltd
idivl %r11d
movl %eax, 0x4(%rsp)
movq 0x48(%rsp), %rax
imull %ebp, %eax
cltd
idivl %r11d
movl 0x70(%rsp), %ebp
movl %ebp, %edx
subl 0x60(%rsp), %edx
movl 0x20(%rsp), %ebx
imull %ebx, %edx
addl %edx, %r12d
addl %eax, %r12d
movl %ecx, %r9d
subl %ebp, %r9d
movl 0x1c(%rsp), %r11d
je 0x37cfb9
movl %r11d, %eax
subl 0x44(%rsp), %eax
imull 0x98(%rsp), %eax
cltd
idivl 0x90(%rsp)
addl %r11d, %eax
imull %r14d, %ebp
movslq %ebp, %rdx
movq 0x30(%rsp), %r10
leaq (%r10,%rdx,4), %rdx
movl %eax, %r11d
sarl $0x8, %r11d
movl %r12d, %ebp
sarl $0x8, %ebp
cmpl %r11d, %ebp
jle 0x37cfa8
movl %eax, %r10d
notl %r10d
movzbl %r10b, %r10d
imull %edi, %r10d
sarl $0x8, %r10d
addl 0x38(%rsp), %r10d
movslq %r11d, %r11
movl %ebp, %r14d
movl %r10d, %ebp
negl %ebp
cmovsl %r10d, %ebp
movl (%rdx,%r11,4), %r15d
movl %r15d, %r13d
negl %r13d
cmovsl %r15d, %r13d
cmpl %r13d, %ebp
cmovbl %r10d, %r15d
movl %r15d, (%rdx,%r11,4)
addl %edi, %r10d
incq %r11
cmpl %r11d, %r14d
jne 0x37cf7b
addl 0x8(%rsp), %eax
addl %ebx, %r12d
addq 0x28(%rsp), %rdx
decl %r9d
jne 0x37cf4c
movl %ecx, %eax
subl 0x5c(%rsp), %eax
imull %ebx, %eax
addl %eax, %r8d
addl 0x4(%rsp), %r8d
movl 0x80(%rsp), %r10d
cmpl %r10d, %ecx
jne 0x37d0ff
movq 0x10(%rsp), %r13
jmp 0x37d1c1
movq 0x48(%rsp), %rax
imull %ebp, %eax
cltd
idivl %r11d
movl %eax, %r9d
movl 0x68(%rsp), %eax
imull %ebp, %eax
cltd
idivl %r11d
movl %eax, 0x48(%rsp)
movl 0x80(%rsp), %r11d
movl %r11d, %eax
subl 0x60(%rsp), %eax
movl 0x20(%rsp), %ebx
imull %ebx, %eax
addl %eax, %r12d
addl %r9d, %r12d
movl %esi, %r9d
subl %r11d, %r9d
movl 0x1c(%rsp), %eax
je 0x37d0d6
subl 0x44(%rsp), %eax
imull 0x64(%rsp), %eax
cltd
idivl 0x90(%rsp)
addl 0xd8(%rsp), %eax
imull 0x10(%rsp), %r11d
movslq %r11d, %rdx
movq 0x30(%rsp), %r10
leaq (%r10,%rdx,4), %rdx
movq 0x38(%rsp), %r10
addl %edi, %r10d
negl %r10d
movl %r10d, 0x4(%rsp)
movl %r12d, %r13d
sarl $0x8, %r13d
movl %eax, %r15d
sarl $0x8, %r15d
cmpl %r13d, %r15d
jle 0x37d0c5
movl %eax, %r14d
notl %r14d
movzbl %r14b, %ebp
imull %edi, %ebp
sarl $0x8, %ebp
addl 0x4(%rsp), %ebp
movslq %r15d, %r15
movl %r13d, %r13d
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
movl -0x4(%rdx,%r15,4), %r11d
movl %r11d, %r10d
negl %r10d
cmovsl %r11d, %r10d
cmpl %r10d, %r14d
cmovbl %ebp, %r11d
movl %r11d, -0x4(%rdx,%r15,4)
decq %r15
subl %edi, %ebp
cmpl %r15d, %r13d
jne 0x37d096
addl %ebx, %r12d
addl 0x8(%rsp), %eax
addq 0x28(%rsp), %rdx
decl %r9d
jne 0x37d069
movl %esi, %eax
subl 0x5c(%rsp), %eax
imull %ebx, %eax
addl %eax, %r8d
addl 0x48(%rsp), %r8d
movl 0x70(%rsp), %r10d
cmpl %r10d, %esi
jne 0x37d290
movq 0x10(%rsp), %r13
jmp 0x37d358
movq 0x100(%rsp), %rax
movl (%rax), %eax
movl $0xff, %edx
orl %edx, %eax
movq 0x88(%rsp), %rdx
subl 0x4(%rdx), %eax
imull 0x38(%rsp), %eax
addl %eax, %eax
movq 0x78(%rsp), %rdx
movl (%rdx), %r9d
movq 0xf0(%rsp), %rdx
subl (%rdx), %r9d
cltd
idivl %r9d
movl %r10d, %edx
subl %ecx, %edx
movq 0x10(%rsp), %r13
imull %r13d, %ecx
movslq %ecx, %rcx
movq 0x30(%rsp), %r9
leaq (%r9,%rcx,4), %rcx
movl %r8d, %r10d
sarl $0x8, %r10d
movl %r12d, %r11d
sarl $0x8, %r11d
cmpl %r10d, %r11d
jle 0x37d1ae
movl %r8d, %r9d
notl %r9d
movzbl %r9b, %r9d
imull %edi, %r9d
sarl $0x8, %r9d
addl %eax, %r9d
movslq %r10d, %r10
movl %r11d, %r11d
movl %r9d, %ebp
negl %ebp
cmovsl %r9d, %ebp
movl (%rcx,%r10,4), %r14d
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
cmpl %r15d, %ebp
cmovbl %r9d, %r14d
movl %r14d, (%rcx,%r10,4)
addl %edi, %r9d
incq %r10
cmpl %r10d, %r11d
jne 0x37d181
addl %ebx, %r8d
addl 0x54(%rsp), %eax
addl %ebx, %r12d
addq 0x28(%rsp), %rcx
decl %edx
jne 0x37d153
movl 0x80(%rsp), %r9d
subl %r9d, %esi
movq 0x38(%rsp), %r15
je 0x37d422
movq 0xc0(%rsp), %rax
movl (%rax), %eax
movq 0x130(%rsp), %rcx
subl (%rcx), %eax
movq 0x78(%rsp), %rcx
movl (%rcx), %ecx
movq 0x100(%rsp), %rdx
subl (%rdx), %ecx
imull 0x64(%rsp), %eax
cltd
idivl %ecx
movq 0x110(%rsp), %rcx
addl (%rcx), %eax
imull %r13d, %r9d
movslq %r9d, %rcx
movq 0x30(%rsp), %rdx
leaq (%rdx,%rcx,4), %rcx
addl %edi, %r15d
negl %r15d
movl %r8d, %r10d
sarl $0x8, %r10d
movl %eax, %r9d
sarl $0x8, %r9d
cmpl %r10d, %r9d
jle 0x37d27b
movl %eax, %edx
notl %edx
movzbl %dl, %edx
imull %edi, %edx
sarl $0x8, %edx
addl %r15d, %edx
movslq %r9d, %r9
movl %r10d, %r10d
movl %edx, %r11d
negl %r11d
cmovsl %edx, %r11d
movl -0x4(%rcx,%r9,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %r11d
cmovbl %edx, %ebp
movl %ebp, -0x4(%rcx,%r9,4)
decq %r9
subl %edi, %edx
cmpl %r9d, %r10d
jne 0x37d24d
addl %ebx, %r8d
addl 0x8(%rsp), %eax
addq 0x28(%rsp), %rcx
decl %esi
jne 0x37d224
jmp 0x37d422
movq 0x140(%rsp), %rax
movl (%rax), %eax
movl $0xff, %edx
orl %edx, %eax
movq 0x88(%rsp), %rdx
subl 0x4(%rdx), %eax
imull 0x38(%rsp), %eax
addl %eax, %eax
movq 0x78(%rsp), %rdx
movl (%rdx), %r9d
movq 0xf0(%rsp), %rdx
subl (%rdx), %r9d
cltd
idivl %r9d
movl %r10d, %edx
subl %esi, %edx
movq 0x10(%rsp), %r13
imull %r13d, %esi
movslq %esi, %r9
movq 0x30(%rsp), %r10
leaq (%r10,%r9,4), %r9
subl %edi, %eax
movl %r12d, %ebp
sarl $0x8, %ebp
movl %r8d, %ebx
sarl $0x8, %ebx
cmpl %ebp, %ebx
jle 0x37d341
movl %r8d, %r10d
notl %r10d
movzbl %r10b, %r11d
imull %edi, %r11d
sarl $0x8, %r11d
movslq %ebx, %rbx
movl %ebp, %r14d
addl %eax, %r11d
movl %r11d, %r10d
negl %r10d
cmovsl %r11d, %r10d
movl -0x4(%r9,%rbx,4), %ebp
movl %ebp, %r15d
negl %r15d
cmovsl %ebp, %r15d
cmpl %r15d, %r10d
cmovbl %r11d, %ebp
movl %ebp, -0x4(%r9,%rbx,4)
decq %rbx
subl %edi, %r11d
cmpl %ebx, %r14d
jne 0x37d311
movl 0x20(%rsp), %esi
addl %esi, %r12d
addl %esi, %r8d
addq 0x28(%rsp), %r9
addl 0x54(%rsp), %eax
decl %edx
jne 0x37d2e6
movl 0x70(%rsp), %r11d
subl %r11d, %ecx
movq 0x38(%rsp), %r15
je 0x37d422
movq 0xc0(%rsp), %rax
movl (%rax), %r9d
movl %r9d, %eax
movq 0x130(%rsp), %rdx
subl (%rdx), %eax
imull 0x98(%rsp), %eax
movq 0x78(%rsp), %rdx
movl (%rdx), %r10d
movq 0x100(%rsp), %rdx
subl (%rdx), %r10d
cltd
idivl %r10d
addl %r9d, %eax
imull %r13d, %r11d
movslq %r11d, %rdx
movq 0x30(%rsp), %r9
leaq (%r9,%rdx,4), %rdx
movl %eax, %r10d
sarl $0x8, %r10d
movl %r8d, %r11d
sarl $0x8, %r11d
cmpl %r10d, %r11d
jle 0x37d410
movl %eax, %r9d
notl %r9d
movzbl %r9b, %r9d
imull %edi, %r9d
sarl $0x8, %r9d
addl %r15d, %r9d
movslq %r10d, %r10
movl %r11d, %r11d
movl %r9d, %ebx
negl %ebx
cmovsl %r9d, %ebx
movl (%rdx,%r10,4), %ebp
movl %ebp, %r14d
negl %r14d
cmovsl %ebp, %r14d
cmpl %r14d, %ebx
cmovbl %r9d, %ebp
movl %ebp, (%rdx,%r10,4)
addl %edi, %r9d
incq %r10
cmpl %r10d, %r11d
jne 0x37d3e3
addl 0x8(%rsp), %eax
addl 0x20(%rsp), %r8d
addq 0x28(%rsp), %rdx
decl %ecx
jne 0x37d3b5
movq 0x2e0(%rsp), %rcx
movq 0x158(%rsp), %rdx
imull $0x3dd2, %edx, %eax # imm = 0x3DD2
movq 0x150(%rsp), %rsi
imull $0x3dd2, %esi, %ebx # imm = 0x3DD2
movq 0xb0(%rsp), %r8
cmpb $0x1, (%rcx,%r8)
jne 0x37d5da
movq 0x1b0(%rsp), %rcx
movq %rcx, 0x168(%rsp)
imull $0xffffef70, %esi, %ebp # imm = 0xFFFFEF70
addl %eax, %ebp
sarl $0xe, %ebp
imull $0x1090, %edx, %eax # imm = 0x1090
addl %eax, %ebx
sarl $0xe, %ebx
movq 0x138(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %ecx
imull %ebp, %ecx
movl %esi, %edx
imull %ebx, %edx
cmpb $0x0, 0x5b(%rsp)
je 0x37d74d
cmpl %edx, %ecx
movq 0xc8(%rsp), %r12
movq 0x30(%rsp), %r15
leaq 0x1b0(%rsp), %r14
jle 0x37d574
movq 0x3f8(%rsp), %rax
movl (%rax,%r8,8), %ecx
movl %ecx, %edx
subl %ebp, %edx
movl %edx, 0x168(%rsp)
movq 0xb0(%rsp), %rdx
movl 0x4(%rax,%rdx,8), %r8d
movl %r8d, %eax
subl %ebx, %eax
movl %eax, 0x16c(%rsp)
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r14, %r9
pushq $0x7f80 # imm = 0x7F80
leaq 0x170(%rsp), %rax
pushq %rax
callq 0x37e824
movq 0xc0(%rsp), %r8
addq $0x10, %rsp
movq 0x168(%rsp), %rax
movq %rax, 0x1b0(%rsp)
imull $0x3dd2, %ebp, %eax # imm = 0x3DD2
imull $0xffffef70, %ebx, %ecx # imm = 0xFFFFEF70
addl %eax, %ecx
sarl $0xe, %ecx
imull $0x3dd2, %ebx, %eax # imm = 0x3DD2
imull $0x1090, %ebp, %ebx # imm = 0x1090
addl %eax, %ebx
sarl $0xe, %ebx
movq 0xc10(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %edx
imull %ecx, %edx
movl %esi, %edi
imull %ebx, %edi
movl %ecx, %ebp
cmpl %edi, %edx
jg 0x37d4c2
movq 0x3f8(%rsp), %rdx
movl (%rdx,%r8,8), %ecx
movl %ecx, %edi
subl %esi, %edi
movl %edi, 0x168(%rsp)
movl 0x4(%rdx,%r8,8), %r8d
movl %r8d, %edx
subl %eax, %edx
movl %edx, 0x16c(%rsp)
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r14, %r9
pushq $0x7f80 # imm = 0x7F80
leaq 0x170(%rsp), %rax
pushq %rax
callq 0x37e824
addq $0x10, %rsp
leaq 0x1468(%rsp), %rbp
movq 0x118(%rsp), %rcx
movq %r15, %r12
movq %r14, %r15
jmp 0x37d974
movq 0x1468(%rsp), %rcx
movq %rcx, 0x168(%rsp)
imull $0x1090, %esi, %r14d # imm = 0x1090
addl %eax, %r14d
sarl $0xe, %r14d
imull $0xffffef70, %edx, %eax # imm = 0xFFFFEF70
addl %eax, %ebx
sarl $0xe, %ebx
movq 0x138(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %ecx
imull %r14d, %ecx
movl %esi, %edx
imull %ebx, %edx
cmpb $0x0, 0x5b(%rsp)
je 0x37d860
cmpl %edx, %ecx
leaq 0x168(%rsp), %r15
movq 0xc8(%rsp), %r12
movq 0x30(%rsp), %rbp
jge 0x37d6fb
movq 0x3f8(%rsp), %rax
movl (%rax,%r8,8), %ecx
leal (%rcx,%r14), %edx
movl %edx, 0x168(%rsp)
movq 0xb0(%rsp), %rdx
movl 0x4(%rax,%rdx,8), %r8d
leal (%r8,%rbx), %eax
movl %eax, 0x16c(%rsp)
movq %rbp, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r15, %r9
pushq $-0x7f80 # imm = 0x8080
leaq 0x1470(%rsp), %rax
pushq %rax
callq 0x37e824
movq 0xc0(%rsp), %r8
addq $0x10, %rsp
movq 0x168(%rsp), %rax
movq %rax, 0x1468(%rsp)
imull $0x3dd2, %r14d, %eax # imm = 0x3DD2
imull $0x1090, %ebx, %ecx # imm = 0x1090
addl %eax, %ecx
sarl $0xe, %ecx
imull $0x3dd2, %ebx, %eax # imm = 0x3DD2
imull $0xffffef70, %r14d, %ebx # imm = 0xFFFFEF70
addl %eax, %ebx
sarl $0xe, %ebx
movq 0xc10(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %edx
imull %ecx, %edx
movl %esi, %edi
imull %ebx, %edi
movl %ecx, %r14d
cmpl %edi, %edx
jl 0x37d647
movq 0x3f8(%rsp), %rdx
movl (%rdx,%r8,8), %ecx
addl %ecx, %esi
movl %esi, 0x168(%rsp)
movl 0x4(%rdx,%r8,8), %r8d
addl %r8d, %eax
movl %eax, 0x16c(%rsp)
movq %rbp, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r15, %r9
pushq $-0x7f80 # imm = 0x8080
leaq 0x1470(%rsp), %rbx
pushq %rbx
callq 0x37e824
addq $0x10, %rsp
movq %rbp, %r12
movq %rbx, %rbp
jmp 0x37d964
cmpl %edx, %ecx
leaq 0x168(%rsp), %r14
movq 0x30(%rsp), %r12
leaq 0x1b0(%rsp), %r15
jle 0x37d80e
movq 0x3f8(%rsp), %rax
movl (%rax,%r8,8), %edx
movl %edx, %ecx
subl %ebp, %ecx
movl %ecx, 0x168(%rsp)
movl 0x4(%rax,%r8,8), %ecx
movl %ecx, %eax
subl %ebx, %eax
movl %eax, 0x16c(%rsp)
subq $0x8, %rsp
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %r8
movq %r14, %r9
pushq $0x7f80 # imm = 0x7F80
callq 0x37f59c
movq 0xc0(%rsp), %r8
addq $0x10, %rsp
movq 0x168(%rsp), %rax
movq %rax, 0x1b0(%rsp)
imull $0x3dd2, %ebp, %eax # imm = 0x3DD2
imull $0xffffef70, %ebx, %ecx # imm = 0xFFFFEF70
addl %eax, %ecx
sarl $0xe, %ecx
imull $0x3dd2, %ebx, %eax # imm = 0x3DD2
imull $0x1090, %ebp, %ebx # imm = 0x1090
addl %eax, %ebx
sarl $0xe, %ebx
movq 0xc10(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %edx
imull %ecx, %edx
movl %esi, %edi
imull %ebx, %edi
movl %ecx, %ebp
cmpl %edi, %edx
jg 0x37d76a
movq 0x3f8(%rsp), %rcx
movl (%rcx,%r8,8), %edx
movl %edx, %edi
subl %esi, %edi
movl %edi, 0x168(%rsp)
movl 0x4(%rcx,%r8,8), %ecx
movl %ecx, %esi
subl %eax, %esi
movl %esi, 0x16c(%rsp)
subq $0x8, %rsp
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %r8
movq %r14, %r9
pushq $0x7f80 # imm = 0x7F80
callq 0x37f59c
addq $0x10, %rsp
leaq 0x1468(%rsp), %rbp
jmp 0x37d96c
cmpl %edx, %ecx
leaq 0x1468(%rsp), %rbp
leaq 0x168(%rsp), %r15
movq 0x30(%rsp), %r12
jge 0x37d923
movq 0x3f8(%rsp), %rax
movl (%rax,%r8,8), %edx
leal (%rdx,%r14), %ecx
movl %ecx, 0x168(%rsp)
movl 0x4(%rax,%r8,8), %ecx
leal (%rcx,%rbx), %eax
movl %eax, 0x16c(%rsp)
subq $0x8, %rsp
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %r8
movq %rbp, %r9
pushq $-0x7f80 # imm = 0x8080
callq 0x37f59c
movq 0xc0(%rsp), %r8
addq $0x10, %rsp
movq 0x168(%rsp), %rax
movq %rax, 0x1468(%rsp)
imull $0x3dd2, %r14d, %eax # imm = 0x3DD2
imull $0x1090, %ebx, %ecx # imm = 0x1090
addl %eax, %ecx
sarl $0xe, %ecx
imull $0x3dd2, %ebx, %eax # imm = 0x3DD2
imull $0xffffef70, %r14d, %ebx # imm = 0xFFFFEF70
addl %eax, %ebx
sarl $0xe, %ebx
movq 0xc10(%rsp), %rax
movl (%rax,%r8,8), %esi
movl 0x4(%rax,%r8,8), %eax
movl %eax, %edx
imull %ecx, %edx
movl %esi, %edi
imull %ebx, %edi
movl %ecx, %r14d
cmpl %edi, %edx
jl 0x37d87d
movq 0x3f8(%rsp), %rcx
movl (%rcx,%r8,8), %edx
addl %edx, %esi
movl %esi, 0x168(%rsp)
movl 0x4(%rcx,%r8,8), %ecx
addl %ecx, %eax
movl %eax, 0x16c(%rsp)
subq $0x8, %rsp
movq %r12, %rdi
movl %r13d, %esi
movq %r15, %r8
movq %rbp, %r9
pushq $-0x7f80 # imm = 0x8080
callq 0x37f59c
addq $0x10, %rsp
leaq 0x1b0(%rsp), %r15
movq 0x118(%rsp), %rcx
movl %ecx, %eax
incq %rcx
movq %rcx, %r10
cmpq %rcx, 0xc08(%rsp)
jg 0x37b794
movl 0x124(%rsp), %ecx
negl %ecx
movslq %ecx, %rax
cmpq %rax, 0x198(%rsp)
movq 0x108(%rsp), %rdi
jg 0x37b49f
movq 0xc8(%rsp), %rdi
testl %edi, %edi
jle 0x37d9eb
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %rax
xorl %ecx, %ecx
movq %r12, %rdx
movl %r13d, %esi
testl %r13d, %r13d
jle 0x37d9e5
movl $0x7f80, %ebx # imm = 0x7F80
subl (%rdx), %ebx
movb %bh, (%rax)
addq $0x4, %rdx
incq %rax
decl %esi
jne 0x37d9d1
incl %ecx
cmpl %edi, %ecx
jne 0x37d9c9
movq 0x1c8(%rsp), %rdi
leaq 0x1d0(%rsp), %rax
cmpq %rax, %rdi
je 0x37da0d
movq 0x1b8(%rsp), %rsi
callq 0x1387a0
movq 0x2e0(%rsp), %rdi
leaq 0x2e8(%rsp), %rax
cmpq %rax, %rdi
leaq 0xc18(%rsp), %rbx
je 0x37da37
movq 0x2d0(%rsp), %rsi
callq 0x1387a0
movq 0x3f8(%rsp), %rdi
leaq 0x400(%rsp), %rax
cmpq %rax, %rdi
je 0x37da5d
movq 0x3e8(%rsp), %rsi
shlq $0x3, %rsi
callq 0x1387a0
movq 0xc10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x37da7b
movq 0xc00(%rsp), %rsi
shlq $0x3, %rsi
callq 0x1387a0
movq %r12, %rdi
callq 0x13bae0
jmp 0x37daae
callq 0x37e80e
movb 0x38ded1(%rip), %al # 0x70b961
testb $0x1, %al
jne 0x37db46
movq 0xd0(%rsp), %rax
movslq 0x10(%rax), %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x13ad10
movq 0x180(%rsp), %rdi
testq %rdi, %rdi
je 0x37dacc
movq 0x170(%rsp), %rsi
shlq $0x3, %rsi
callq 0x1387a0
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x37daea
movq 0x190(%rsp), %rsi
shlq $0x2, %rsi
callq 0x1387a0
movq %fs:0x28, %rax
cmpq 0x3080(%rsp), %rax
jne 0x37dc40
movq 0xd0(%rsp), %rax
addq $0x3088, %rsp # imm = 0x3088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1478(%rsp), %rdx
leaq 0x1468(%rsp), %rsi
leaq 0x1b0(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x15946f
movq (%rbx), %r14
jmp 0x37af6d
movq 0x38de0b(%rip), %rax # 0x70b958
leaq 0x1468(%rsp), %rsi
movl $0x2, (%rsi)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x4(%rsi)
movl $0x0, 0x14(%rsi)
movq %rax, 0x18(%rsi)
leaq 0x3e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x144250
movq (%rbx), %rbx
leaq 0x228336(%rip), %rdx # 0x5a5ebf
leaq 0xc00(%rsp), %r14
movl $0x2c, %esi
movq %r14, %rdi
callq 0x1457d0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1455b0
movq (%r14), %rax
testq %rax, %rax
je 0x37dbcd
lock
decl (%rax)
jne 0x37dbcd
movq 0xc00(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x3e8(%rsp), %rdi
cmpb $0x1, 0x30(%rdi)
jne 0x37dbe5
movl $0x20, %esi
callq 0x13d680
leaq 0x3e8(%rsp), %rdi
callq 0x1391b0
movq 0xd0(%rsp), %rax
movq 0x18(%rax), %r13
jmp 0x37da98
movl %ebp, %r14d
shrl $0x1f, %r14d
addl %ebp, %r14d
sarl %r14d
callq 0x37a338
movl 0x3786e5(%rip), %eax # 0x6f6300
movl %eax, %ebx
shrl $0x1f, %ebx
addl %eax, %ebx
sarl %ebx
callq 0x37a338
movl 0x3786cd(%rip), %eax # 0x6f62fc
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %r14d, %ebp
jmp 0x37ac25
callq 0x13a8c0
nop
| /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 = QDistanceFieldData::create(path, doubleResolution);
d->glyph = glyph;
} | 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 = 0xAAAAAAAAAAAAAAAA
leaq 0x28(%rsp), %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0x13f210
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x1, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq *0x78(%rax)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x142e30
movaps 0x1f673f(%rip), %xmm2 # 0x574770
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
xorps %xmm2, %xmm0
xorps %xmm2, %xmm1
movq %r15, %rdi
callq 0x148af0
movq %r15, %rdi
movl $0x1, %esi
callq 0x1488b0
movq %r15, %rdi
movl %ebp, %esi
callq 0x1459d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x380350
movl (%r14), %ebp
movq (%rbx), %rax
movl (%rax), %ecx
cmpl $0x1, %ecx
je 0x37e086
movq %rbx, %rdi
callq 0x38038e
movq (%rbx), %rax
movl %ebp, 0x4(%rax)
leaq 0x28(%rsp), %rdi
callq 0x144320
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x37e0b2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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 that can be tested with QFile::exists.
// so if the format.name() is a file:/ or qrc:/ URL, then we need to strip away the schema.
QString localFile;
const QUrl url(baseFileName);
bool hasFileScheme = false;
bool isResource = false;
if (url.isLocalFile()) {
localFile = url.toLocalFile();
hasFileScheme = true;
} else if (baseFileName.startsWith("qrc:/"_L1)) {
// QFile::exists() can only handle ":/file.txt"
localFile = baseFileName.sliced(3);
isResource = true;
} else {
localFile = baseFileName;
isResource = baseFileName.startsWith(":/"_L1);
}
*name = qt_findAtNxFile(localFile, targetDevicePixelRatio, sourceDevicePixelRatio);
if (hasFileScheme)
return QUrl::fromLocalFile(*name);
if (isResource)
return QUrl("qrc"_L1 + *name);
return QUrl(*name);
} | 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 = 0xAAAAAAAAAAAAAAAA
leaq 0x38(%rsp), %r13
movq %rax, (%r13)
movq %r13, %rdi
xorl %edx, %edx
callq 0x145b50
movq %r13, %rdi
callq 0x13e8b0
movl %eax, %ebp
testb %al, %al
je 0x41c644
leaq 0x20(%rsp), %r12
leaq 0x38(%rsp), %rsi
movq %r12, %rdi
callq 0x146920
movq 0x40(%rsp), %rax
movups 0x48(%rsp), %xmm0
movaps (%r12), %xmm1
movq %rax, (%r12)
movaps %xmm1, 0x40(%rsp)
movq 0x10(%r12), %rcx
movups %xmm0, 0x8(%r12)
movq %rcx, 0x50(%rsp)
testq %rax, %rax
je 0x41c63c
lock
decl (%rax)
jne 0x41c63c
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
xorl %r12d, %r12d
jmp 0x41c6f4
leaq 0x193240(%rip), %rdx # 0x5af88b
movl $0x5, %esi
movq %r12, %rdi
movl $0x1, %ecx
callq 0x13dbb0
testb %al, %al
je 0x41c6cb
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq $-0x3, %rdx
addq $0x6, %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x13dc00
movq 0x40(%rsp), %rax
movups 0x48(%rsp), %xmm0
movaps (%r12), %xmm1
movq %rax, (%r12)
movaps %xmm1, 0x40(%rsp)
movq 0x10(%r12), %rcx
movups %xmm0, 0x8(%r12)
movq %rcx, 0x50(%rsp)
testq %rax, %rax
je 0x41c6c6
lock
decl (%rax)
jne 0x41c6c6
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movb $0x1, %r12b
jmp 0x41c6f4
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x148720
leaq 0x1931af(%rip), %rdx # 0x5af88e
movl $0x2, %esi
movq %r12, %rdi
movl $0x1, %ecx
callq 0x13dbb0
movl %eax, %r12d
leaq 0x20(%rsp), %r13
leaq 0x40(%rsp), %rsi
movq %r13, %rdi
movsd (%rsp), %xmm0
movq %r15, %rdx
callq 0x137250
movq (%r14), %rax
movq 0x8(%r14), %rcx
movaps (%r13), %xmm0
movq %rax, (%r13)
movups %xmm0, (%r14)
movq %rcx, 0x8(%r13)
movq 0x10(%r14), %rcx
movq 0x10(%r13), %rdx
movq %rdx, 0x10(%r14)
movq %rcx, 0x10(%r13)
testq %rax, %rax
je 0x41c754
lock
decl (%rax)
jne 0x41c754
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
testb %bpl, %bpl
je 0x41c766
movq %rbx, %rdi
movq %r14, %rsi
callq 0x146000
jmp 0x41c7d0
testb %r12b, %r12b
je 0x41c7c3
leaq 0x8(%rsp), %rsi
movq $0x3, (%rsi)
leaq 0x193113(%rip), %rax # 0x5af891
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1bcaaa
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x145b50
movq (%r14), %rax
testq %rax, %rax
je 0x41c7d0
lock
decl (%rax)
jne 0x41c7d0
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x41c7d0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x145b50
leaq 0x38(%rsp), %rdi
callq 0x138880
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x41c7fd
lock
decl (%rax)
jne 0x41c7fd
movq 0x40(%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x60(%rsp), %rax
jne 0x41c81c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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, b, e, e);
} | 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, %r14
movl %eax, %r13d
movq %rsi, %rdi
callq 0x1442f0
movl %eax, %r12d
movq 0x160(%r15), %rax
leaq (,%r13,8), %rcx
addq %r13, %rcx
movl 0x1c(%rax,%rcx,8), %eax
movq %rax, (%rsp)
movl $0x158, %r13d # imm = 0x158
addq %r13, %r15
movq %r15, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x374d40
movl %eax, %ebp
addq (%r14), %r13
movq (%rsp), %rax
leal (%r12,%rax), %esi
decl %esi
movq %r13, %rdi
xorl %edx, %edx
callq 0x374d40
movq (%r14), %rcx
movq %rcx, (%rbx)
movl %ebp, 0x8(%rbx)
movl %eax, 0xc(%rbx)
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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
leaq (%rdx,%r8), %rsi
cmpl %edi, 0x8(%rdx,%r8)
jne 0x42ad8f
addl 0x10(%rsi), %eax
addl 0x14(%rsi), %eax
movl (%rsi), %esi
jmp 0x42ad6f
retq
| /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::GrowsAtBeginning && this->freeSpaceAtBegin() >= n) ||
(pos == Data::GrowsAtEnd && this->freeSpaceAtEnd() >= n));
if (growsAtBegin) {
// copy construct items in reverse order at the begin
Q_ASSERT(this->freeSpaceAtBegin() >= n);
while (n--) {
new (this->begin() - 1) T(copy);
--this->ptr;
++this->size;
}
} else {
Inserter(this, i, n).insertFill(copy, n);
}
} | 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, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x42b7e4
cmpb $0x1, %bpl
jne 0x42b759
testq %rbx, %rbx
je 0x42b7c0
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
movq %rbx, %rdx
movq %r13, -0x10(%rcx)
movl %r15d, -0x8(%rcx)
addq $-0x10, %rcx
decq %rdx
jne 0x42b73b
addq %rbx, %rax
movq %rcx, 0x8(%r14)
movq %rax, 0x10(%r14)
jmp 0x42b7c0
movq %r14, 0x8(%rsp)
movq %r12, %rax
shlq $0x4, %r12
addq 0x8(%r14), %r12
movq %r12, 0x10(%rsp)
movq %rbx, %rdi
shlq $0x4, %rdi
addq %r12, %rdi
movq %rdi, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq 0x10(%r14), %rdx
subq %rax, %rdx
shlq $0x4, %rdx
movq %rdx, 0x28(%rsp)
movq %r12, %rsi
callq 0x138810
testq %rbx, %rbx
je 0x42b7b6
movq %r13, (%r12)
movl %r15d, 0x8(%r12)
addq $0x10, %r12
decq %rbx
jne 0x42b79f
movq %r12, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x42b890
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x42b7df
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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;
this->ptr = res;
} | 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
movq 0x10(%rbx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rax, %rcx
jbe 0x42b9da
addq %r15, %rax
movq %rax, (%r14)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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
// are invalidated. However, erasing from the beginning effectively
// means that all iterators are invalidated. We can use this freedom to
// erase by moving towards the end.
std::destroy(b, e);
if (b == this->begin() && e != this->end()) {
this->ptr = e;
} else if (e != this->end()) {
memmove(static_cast<void *>(b), static_cast<const void *>(e), (static_cast<const T *>(this->end()) - e)*sizeof(T));
}
this->size -= n;
} | 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, %rsi
je 0x42bc72
subq %rsi, %rdx
movq %rax, %rdi
callq 0x138810
movq 0x10(%r14), %rcx
jmp 0x42bc72
movq %rsi, 0x8(%r14)
subq %rbx, %rcx
movq %rcx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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)
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x28(%rsp)
movabsq $0x4054000000000000, %rax # imm = 0x4054000000000000
movq %rax, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movw $0x0, 0x2c(%rsp)
movq 0x10(%r14), %rsi
callq 0x40adaa
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x42c107
movq 0x8(%r14), %r13
shlq $0x3, %r12
xorl %ebp, %ebp
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movsd (%r13,%rbp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x42c35e
movq %r14, %rdi
callq 0x40451e
addq $0x8, %rbp
cmpq %rbp, %r12
jne 0x42c0d9
movq 0x10(%rbx), %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x42c316
movq (%rbx), %rax
testq %rax, %rax
je 0x42c136
lock
decl (%rax)
jne 0x42c136
movq (%rsp), %rdi
movl $0x10, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x42c155
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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;
QTextFormatCollection *c = p->formatCollection();
cellIndices.resize(cells.size());
int cell = 0;
for (int i = 0; i < cells.size(); ++i) {
int fragment = cells.at(i);
QTextCharFormat fmt = c->charFormat(QTextDocumentPrivate::FragmentIterator(&p->fragmentMap(), fragment)->format);
int rowspan = fmt.tableCellRowSpan();
int colspan = fmt.tableCellColumnSpan();
// skip taken cells
while (cell < nRows*nCols && grid[cell])
++cell;
int r = cell/nCols;
int c = cell%nCols;
cellIndices[i] = cell;
if (r + rowspan > nRows) {
grid.resize((r + rowspan) * nCols, 0);
nRows = r + rowspan;
}
Q_ASSERT(c + colspan <= nCols);
for (int ii = 0; ii < rowspan; ++ii) {
for (int jj = 0; jj < colspan; ++jj) {
Q_ASSERT(grid[(r+ii)*nCols + c+jj] == 0);
grid[(r+ii)*nCols + c+jj] = fragment;
// qDebug(" setting cell %d span=%d/%d at %d/%d", fragment, rowspan, colspan, r+ii, c+jj);
}
}
}
// qDebug("<<<< end: nRows=%d, nCols=%d", nRows, nCols);
dirty = false;
} | 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 $0x0, %eax
movl %eax, 0x104(%rbx)
movq %r14, %rdi
callq 0x13c1a0
movq 0xc8(%rbx), %rax
movslq 0x104(%rbx), %rcx
addq %rcx, %rax
decq %rax
cqto
idivq %rcx
movl %eax, 0x100(%rbx)
movl $0xe8, %esi
movl $0xe8, %edx
movq %rdx, 0x18(%rsp)
leaq (%rbx,%rsi), %rdi
movslq %eax, %rsi
imulq %rcx, %rsi
movl $0x0, (%r14)
leaq 0x50(%rsp), %rdx
movq %rdi, 0x30(%rsp)
callq 0x430800
movq 0x78(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0xc8(%rbx), %rsi
leaq 0xd0(%rbx), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2f15c8
cmpq $0x0, 0xc8(%rbx)
je 0x42ca72
movq 0x10(%rsp), %rax
addq %rax, 0x18(%rsp)
xorl %r13d, %r13d
leaq 0x40(%rsp), %rbp
xorl %r15d, %r15d
movq 0xc0(%rbx), %rax
movl (%rax,%r13,4), %r12d
movaps 0x147da6(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq 0x158(%rax), %rax
movq %r12, %rcx
shlq $0x5, %rcx
movl 0x1c(%rax,%rcx), %edx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq 0x18(%rsp), %rsi
callq 0x141e80
movq %rbp, %rdi
movq %r14, %rsi
callq 0x143950
movq %r14, %rdi
callq 0x140170
movq %rbp, %rdi
movl $0x4810, %esi # imm = 0x4810
callq 0x138f70
cmpl $0x1, %eax
adcl $0x0, %eax
movq %rax, 0x20(%rsp)
movq %rbp, %rdi
movl $0x4811, %esi # imm = 0x4811
callq 0x138f70
movl %eax, %r14d
cmpl $0x1, %eax
adcl $0x0, %r14d
movslq 0x100(%rbx), %rax
movslq 0x104(%rbx), %rcx
imulq %rcx, %rax
cmpl %eax, %r15d
movq %r13, 0x28(%rsp)
jge 0x42c999
movq 0xe8(%rbx), %rdx
movq 0xf0(%rbx), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
movslq %r15d, %r15
cmpq %r15, %rsi
jbe 0x42ca9d
cmpl $0x0, (%rdx,%r15,4)
je 0x42c999
incq %r15
cmpq %r15, %rax
jne 0x42c97e
movl %eax, %r15d
movl %r15d, %eax
cltd
idivl %ecx
movl %edx, %r13d
movl %eax, %ebp
movq 0x38(%rsp), %rdi
callq 0x20723c
movq 0x28(%rsp), %rcx
movl %r15d, (%rax,%rcx,4)
movq 0x20(%rsp), %r9
leal (%r9,%rbp), %ecx
cmpl 0x100(%rbx), %ecx
jle 0x42ca00
movslq 0x104(%rbx), %rax
movslq %ecx, %rsi
imulq %rax, %rsi
movl $0x0, 0x50(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl %ecx, 0xc(%rsp)
callq 0x430338
movq 0x20(%rsp), %r9
movl 0xc(%rsp), %eax
movl %eax, 0x100(%rbx)
testl %r9d, %r9d
jle 0x42ca50
movq 0xe8(%rbx), %rax
movq 0xf0(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %edx, %edx
movl %r13d, %esi
movl %r14d, %edi
testl %r14d, %r14d
jle 0x42ca47
movl 0x104(%rbx), %r8d
imull %ebp, %r8d
addl %esi, %r8d
movslq %r8d, %r8
cmpq %r8, %rcx
jbe 0x42ca98
movl %r12d, (%rax,%r8,4)
incl %esi
decl %edi
jne 0x42ca27
incl %edx
incl %ebp
cmpl %r9d, %edx
jne 0x42ca1c
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
callq 0x13c1a0
movq 0x28(%rsp), %r13
incq %r13
cmpq %r13, 0xc8(%rbx)
ja 0x42c8c8
movb $0x0, 0x108(%rbx)
movq %fs:0x28, %rax
cmpq 0x60(%rsp), %rax
jne 0x42caa2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x15e85d
callq 0x15e83d
callq 0x13a8c0
nop
| /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);
pieceTable->beginEditBlock();
// qDebug("---> createTable: rows=%d, cols=%d at %d", rows, cols, pos);
// add block after table
QTextCharFormat charFmt;
charFmt.setObjectIndex(table->objectIndex());
charFmt.setObjectType(QTextFormat::TableCellObject);
int charIdx = pieceTable->formatCollection()->indexForFormat(charFmt);
int cellIdx = pieceTable->formatCollection()->indexForFormat(QTextBlockFormat());
QTextTablePrivate *d = table->d_func();
d->blockFragmentUpdates = true;
d->fragment_start = pieceTable->insertBlock(QTextBeginningOfFrame, pos, cellIdx, charIdx);
d->cells.append(d->fragment_start);
++pos;
for (int i = 1; i < rows*cols; ++i) {
d->cells.append(pieceTable->insertBlock(QTextBeginningOfFrame, pos, cellIdx, charIdx));
// qDebug(" addCell at %d", pos);
++pos;
}
d->fragment_end = pieceTable->insertBlock(QTextEndOfFrame, pos, cellIdx, charIdx);
// qDebug(" addEOR at %d", pos);
++pos;
d->blockFragmentUpdates = false;
d->dirty = true;
pieceTable->endEditBlock();
return 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
callq 0x13c480
xorl %esi, %esi
cmpl $0x1, %r14d
cmovnel %r14d, %esi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x137320
movq %rbx, %rdi
movl $0x4100, %esi # imm = 0x4100
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
movq %r13, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x13b7d0
movq 0x2c2ac0(%rip), %rdi # 0x6efa70
movq %rax, %rsi
callq 0x13d9f0
movq %rax, %r15
movl 0xcc(%r13), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xcc(%r13)
testl %eax, %eax
jne 0x42cfd7
incl 0xc0(%r13)
leaq 0x30(%rsp), %rbx
movaps 0x14769d(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rbx)
movq %rbx, %rdi
callq 0x13c710
movq %r15, %rdi
callq 0x13c870
movq %rbx, %rdi
movl %eax, %esi
callq 0x13ad20
movq %r15, 0x20(%rsp)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
callq 0x137320
movq %rbx, %rdi
movl $0x2f00, %esi # imm = 0x2F00
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
leaq 0xe8(%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13dca0
movl %eax, %r12d
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x139640
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13dca0
movq %r13, %r15
movl %eax, %ebx
leaq 0x50(%rsp), %rdi
callq 0x13c1a0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %r13
movb $0x1, 0x109(%r13)
movq %r15, 0x18(%rsp)
movq %r15, %rdi
movl $0xfdd0, %esi # imm = 0xFDD0
movl %ebp, %edx
movl %ebx, 0xc(%rsp)
movl %ebx, %ecx
movl %r12d, 0x10(%rsp)
movl %r12d, %r8d
movl $0x1, %r9d
callq 0x1399c0
movl %eax, 0x84(%r13)
leaq 0xb8(%r13), %r15
leaq 0x50(%rsp), %rcx
movl %eax, (%rcx)
movq %r13, 0x28(%rsp)
movq 0xc8(%r13), %rsi
leaq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x1a1b70
movq %r15, %rdi
callq 0x1a18ba
imull 0x14(%rsp), %r14d
incl %ebp
cmpl $0x2, %r14d
jl 0x42d141
decl %r14d
movq 0x18(%rsp), %r13
movl 0x10(%rsp), %r12d
movl 0xc(%rsp), %ebx
movq %r13, %rdi
movl $0xfdd0, %esi # imm = 0xFDD0
movl %ebp, %edx
movl %ebx, %ecx
movl %r12d, %r8d
movl $0x1, %r9d
callq 0x1399c0
movl %eax, 0x50(%rsp)
movq 0x28(%rsp), %rax
movq 0xc8(%rax), %rsi
movq %r15, %rdi
leaq 0x50(%rsp), %rdx
callq 0x1a1b70
movq %r15, %rdi
callq 0x1a18ba
incl %ebp
decl %r14d
jne 0x42d0f9
jmp 0x42d14f
movq 0x18(%rsp), %r13
movl 0x10(%rsp), %r12d
movl 0xc(%rsp), %ebx
movq %r13, %rdi
movl $0xfdd1, %esi # imm = 0xFDD1
movl %ebp, %edx
movl %ebx, %ecx
movl %r12d, %r8d
movl $0x1, %r9d
callq 0x1399c0
movq 0x28(%rsp), %rcx
movl %eax, 0x88(%rcx)
movw $0x1, 0x108(%rcx)
movq %r13, %rdi
callq 0x141c80
leaq 0x30(%rsp), %rdi
callq 0x13c1a0
leaq 0x40(%rsp), %rdi
callq 0x13c1a0
movq %fs:0x28, %rax
cmpq 0x70(%rsp), %rax
jne 0x42d1bd
movq 0x20(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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;
QTextFormatCollection *c = p->formatCollection();
p->beginEditBlock();
QList<int> extendedSpans;
for (int i = 0; i < d->nRows; ++i) {
int cell;
if (i == d->nRows - 1 && pos == d->nCols) {
cell = d->fragment_end;
} else {
int logicalGridIndexBeforePosition = pos > 0
? d->findCellIndex(d->grid[i*d->nCols + pos - 1])
: -1;
// Search for the logical insertion point by skipping past cells which are not the first
// cell in a rowspan. This means any cell for which the logical grid index is
// less than the logical cell index of the cell before the insertion.
int logicalGridIndex;
int gridArrayOffset = i*d->nCols + pos;
do {
cell = d->grid[gridArrayOffset];
logicalGridIndex = d->findCellIndex(cell);
gridArrayOffset++;
} while (logicalGridIndex < logicalGridIndexBeforePosition
&& gridArrayOffset < d->nRows*d->nCols);
if (logicalGridIndex < logicalGridIndexBeforePosition
&& gridArrayOffset == d->nRows*d->nCols)
cell = d->fragment_end;
}
if (pos > 0 && pos < d->nCols && cell == d->grid[i*d->nCols + pos - 1]) {
// cell spans the insertion place, extend it
if (!extendedSpans.contains(cell)) {
QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), cell);
QTextCharFormat fmt = c->charFormat(it->format);
fmt.setTableCellColumnSpan(fmt.tableCellColumnSpan() + num);
p->setCharFormat(it.position(), 1, fmt);
d->dirty = true;
extendedSpans << cell;
}
} else {
/* If the next cell is spanned from the row above, we need to find the right position
to insert to */
if (i > 0 && pos < d->nCols && cell == d->grid[(i-1) * d->nCols + pos]) {
int gridIndex = i*d->nCols + pos;
const int gridEnd = d->nRows * d->nCols - 1;
while (gridIndex < gridEnd && cell == d->grid[gridIndex]) {
++gridIndex;
}
if (gridIndex == gridEnd)
cell = d->fragment_end;
else
cell = d->grid[gridIndex];
}
QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), cell);
QTextCharFormat fmt = c->charFormat(it->format);
fmt.setTableCellRowSpan(1);
fmt.setTableCellColumnSpan(1);
Q_ASSERT(fmt.objectIndex() == objectIndex());
int position = it.position();
int cfmt = p->formatCollection()->indexForFormat(fmt);
int bfmt = p->formatCollection()->indexForFormat(QTextBlockFormat());
for (int i = 0; i < num; ++i)
p->insertBlock(QTextBeginningOfFrame, position, bfmt, cfmt, QTextUndoCommand::MoveCursor);
}
}
QTextTableFormat tfmt = format();
tfmt.setColumns(tfmt.columns()+num);
QList<QTextLength> columnWidths = tfmt.columnWidthConstraints();
if (! columnWidths.isEmpty()) {
for (int i = num; i > 0; --i)
columnWidths.insert(pos, columnWidths.at(qMax(0, pos - 1)));
}
tfmt.setColumnWidthConstraints (columnWidths);
QTextObject::setFormat(tfmt);
// qDebug() << "-------- end insertCols" << pos << num;
p->endEditBlock();
} | 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), %eax
cmpl %ebx, %eax
movl %ebx, %r13d
cmovll %eax, %r13d
testl %ebx, %ebx
cmovsl %eax, %r13d
movq 0x78(%r15), %r14
movl 0xcc(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xcc(%r14)
testl %eax, %eax
jne 0x42d8af
incl 0xc0(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movl 0x100(%r15), %eax
testl %eax, %eax
jle 0x42dd5e
leaq 0xe8(%r14), %rcx
movq %rcx, 0x38(%rsp)
leal -0x1(%r13), %ecx
movl %ecx, 0x8(%rsp)
leaq 0x88(%r15), %rcx
movq %rcx, 0x18(%rsp)
leaq 0x158(%r14), %rcx
movq %rcx, 0x30(%rsp)
xorl %r12d, %r12d
movq %r13, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
decl %eax
xorl %r12d, %eax
movl 0x104(%r15), %ecx
movl %r13d, %edx
xorl %ecx, %edx
orl %eax, %edx
movq %r12, 0x10(%rsp)
jne 0x42d92d
movq 0x18(%rsp), %rax
movl (%rax), %ebx
jmp 0x42d9ed
testl %r13d, %r13d
jle 0x42d972
imull %r12d, %ecx
addl 0x8(%rsp), %ecx
movslq %ecx, %rax
movq 0xe8(%r15), %rcx
movq 0xf0(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x42deef
movl (%rcx,%rax,4), %esi
movq %r15, %rdi
callq 0x42caa8
movl %eax, %r12d
movl 0x104(%r15), %ecx
jmp 0x42d978
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
imull 0x10(%rsp), %ecx
addl %r13d, %ecx
movslq %ecx, %r13
movq 0xe8(%r15), %rax
movq 0xf0(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x42dee5
movl (%rax,%r13,4), %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x42caa8
cmpl %r12d, %eax
jge 0x42d9e3
incq %r13
movslq 0x100(%r15), %rcx
movslq 0x104(%r15), %rax
imulq %rcx, %rax
cmpq %rax, %r13
jl 0x42d983
cmpl %eax, %r13d
movq 0x20(%rsp), %r13
movq 0x10(%rsp), %r12
je 0x42d921
jmp 0x42d9ed
movq 0x20(%rsp), %r13
movq 0x10(%rsp), %r12
testl %r13d, %r13d
jle 0x42dafe
movl 0x104(%r15), %eax
cmpl %eax, %r13d
jge 0x42dafe
imull %r12d, %eax
addl 0x8(%rsp), %eax
cltq
movq 0xe8(%r15), %rcx
movq 0xf0(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x42def4
cmpl (%rcx,%rax,4), %ebx
jne 0x42dafe
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x42da66
movq 0x48(%rsp), %rcx
shlq $0x2, %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x42da66
leaq 0x4(%rdx), %rsi
cmpl %ebx, (%rcx,%rdx)
movq %rsi, %rdx
jne 0x42da4c
testq %rsi, %rsi
jne 0x42dc87
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x78(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movl %ebx, 0x78(%rsp)
movaps 0x146bf6(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x60(%rsp)
movq (%rax), %rax
movl %ebx, %ecx
shlq $0x5, %rcx
movl 0x1c(%rax,%rcx), %edx
leaq 0x80(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x141e80
leaq 0x60(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x143950
leaq 0x80(%rsp), %rdi
callq 0x140170
leaq 0x60(%rsp), %rdi
movl $0x4811, %esi # imm = 0x4811
callq 0x138f70
cmpl $0x1, %eax
adcl %ebp, %eax
cmpl $0x1, %eax
jg 0x42dcc7
leaq 0x60(%rsp), %rdi
movl $0x4811, %esi # imm = 0x4811
callq 0x13e2f0
jmp 0x42dcfa
testl %r12d, %r12d
je 0x42db91
movl 0x104(%r15), %eax
cmpl %eax, %r13d
jge 0x42db91
leal -0x1(%r12), %ecx
imull %eax, %ecx
addl %r13d, %ecx
movslq %ecx, %rsi
movq 0xe8(%r15), %rcx
movq 0xf0(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rsi, %rdx
jbe 0x42def9
cmpl (%rcx,%rsi,4), %ebx
jne 0x42db91
movl %eax, %esi
imull %r12d, %esi
addl %r13d, %esi
imull 0x100(%r15), %eax
decl %eax
cmpl %eax, %esi
jge 0x42dc9f
movslq %esi, %rsi
movslq %eax, %rdi
leaq 0x80(%rsp), %r12
cmpq %rsi, %rdx
jbe 0x42deea
cmpl (%rcx,%rsi,4), %ebx
jne 0x42dca7
incq %rsi
cmpq %rdi, %rsi
jl 0x42db6d
movq 0x18(%rsp), %rdi
jmp 0x42dcc0
leaq 0x80(%rsp), %r12
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x78(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movl %ebx, 0x78(%rsp)
movaps 0x146ac3(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x60(%rsp)
movq (%rax), %rax
movl %ebx, %ecx
shlq $0x5, %rcx
movl 0x1c(%rax,%rcx), %edx
movq %r12, %rdi
movq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x141e80
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x143950
movq %r12, %rdi
callq 0x140170
movq %rbp, %rdi
movl $0x4810, %esi # imm = 0x4810
callq 0x13e2f0
movq %rbp, %rdi
movl $0x4811, %esi # imm = 0x4811
callq 0x13e2f0
leaq 0x70(%rsp), %rdi
callq 0x3befb8
movl %eax, %ebx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x13dca0
movq %r12, %rbp
movl %eax, %r12d
movq %rbp, %rdi
callq 0x139640
movq %r13, %rdi
movq %rbp, %rsi
callq 0x13dca0
movl %eax, %r13d
movq %rbp, %rdi
callq 0x13c1a0
movl 0xc(%rsp), %ebp
movq %r14, %rdi
movl $0xfdd0, %esi # imm = 0xFDD0
movl %ebx, %edx
movl %r13d, %ecx
movl %r12d, %r8d
movl $0x1, %r9d
callq 0x1399c0
decl %ebp
jne 0x42dc50
leaq 0x60(%rsp), %rdi
callq 0x13c1a0
movl 0xc(%rsp), %ebp
movq 0x20(%rsp), %r13
movq 0x10(%rsp), %r12
incl %r12d
movl 0x100(%r15), %eax
cmpl %eax, %r12d
jl 0x42d907
jmp 0x42dd5e
leaq 0x80(%rsp), %r12
movq 0x18(%rsp), %rdi
cmpl %eax, %esi
je 0x42dcc0
movslq %esi, %rax
cmpq %rax, %rdx
jbe 0x42defe
leaq (%rcx,%rax,4), %rdi
movl (%rdi), %ebx
jmp 0x42db99
leaq 0x80(%rsp), %rdi
movl %eax, %esi
callq 0x137320
leaq 0x60(%rsp), %rdi
movl $0x4811, %esi # imm = 0x4811
leaq 0x80(%rsp), %rdx
callq 0x148430
leaq 0x80(%rsp), %rdi
callq 0x13e600
leaq 0x70(%rsp), %rdi
callq 0x3befb8
movq %r14, %rdi
movl %eax, %esi
movl $0x1, %edx
leaq 0x60(%rsp), %rcx
movl $0x1, %r8d
callq 0x149320
movb $0x1, 0x108(%r15)
movl %ebx, 0x80(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
leaq 0x80(%rsp), %rdx
callq 0x1a1b70
movq %rbx, %rdi
callq 0x1a18ba
leaq 0x60(%rsp), %rdi
callq 0x13c1a0
jmp 0x42dc87
movaps 0x14691b(%rip), %xmm0 # 0x574680
leaq 0x70(%rsp), %rbx
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
callq 0x3ccfe6
movq %rbx, %rdi
movl $0x4100, %esi # imm = 0x4100
callq 0x138f70
cmpl $0x1, %eax
adcl %ebp, %eax
xorl %esi, %esi
cmpl $0x1, %eax
cmovnel %eax, %esi
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0x137320
movq %rbx, %rdi
movl $0x4100, %esi # imm = 0x4100
movq %r15, %rdx
callq 0x148430
movq %r15, %rdi
callq 0x13e600
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%r15)
movaps 0x1468af(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r15)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x4101, %edx # imm = 0x4101
callq 0x1425d0
cmpq $0x0, 0x10(%r15)
je 0x42de3d
cmpl $0x2, %r13d
movl $0x1, %r12d
cmovgel %r13d, %r12d
movslq %r13d, %rbx
incl %ebp
shlq $0x4, %r12
leaq 0x80(%rsp), %r15
movq 0x88(%rsp), %rax
leaq (%rax,%r12), %rdx
addq $-0x10, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x431300
movq %r15, %rdi
callq 0x4313da
decl %ebp
cmpl $0x1, %ebp
jg 0x42de13
leaq 0x70(%rsp), %rbx
leaq 0x80(%rsp), %r15
movq %rbx, %rdi
movl $0x4101, %esi # imm = 0x4101
movq %r15, %rdx
callq 0x13bef0
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x138cb0
movq %r14, %rdi
callq 0x141c80
movq (%r15), %rax
testq %rax, %rax
je 0x42de93
lock
decl (%rax)
jne 0x42de93
movq 0x80(%rsp), %rdi
movl $0x10, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x70(%rsp), %rdi
callq 0x13c1a0
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x42dec0
lock
decl (%rax)
jne 0x42dec0
movq 0x40(%rsp), %rdi
movl $0x4, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0xa0(%rsp), %rax
jne 0x42df03
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x15e8bd
callq 0x15e91d
callq 0x15e89d
callq 0x15e8dd
callq 0x15e8fd
callq 0x15e93d
callq 0x13a8c0
| /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 distribution of the amount of
// occupied entries.
// For a 25% filled table, the average is 32 entries, with a 95% chance that we have between
// 23 and 41 entries.
// For a 50% filled table, the average is 64 entries, with a 95% chance that we have between
// 53 and 75 entries.
// Since we only resize the table once it's 50% filled and we want to avoid copies of
// data where possible, we initially allocate 48 entries, then resize to 80 entries, after that
// resize by increments of 16. That way, we usually only get one resize of the table
// while filling it.
size_t alloc;
static_assert(SpanConstants::NEntries % 8 == 0);
if (!allocated)
alloc = SpanConstants::NEntries / 8 * 3;
else if (allocated == SpanConstants::NEntries / 8 * 3)
alloc = SpanConstants::NEntries / 8 * 5;
else
alloc = allocated + SpanConstants::NEntries/8;
Entry *newEntries = new Entry[alloc];
// we only add storage if the previous storage was fully filled, so
// simply copy the old data over
if constexpr (isRelocatable<Node>()) {
if (allocated)
memcpy(newEntries, entries, allocated * sizeof(Entry));
} else {
for (size_t i = 0; i < allocated; ++i) {
new (&newEntries[i].node()) Node(std::move(entries[i].node()));
entries[i].node().~Node();
}
}
for (size_t i = allocated; i < alloc; ++i) {
newEntries[i].nextFree() = uchar(i + 1);
}
delete[] entries;
entries = newEntries;
allocated = uchar(alloc);
} | 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 $0x50, %eax
movq %rax, (%rsp)
movl $0x1180, %edi # imm = 0x1180
jmp 0x43236b
addq $0x10, %rax
movq %rax, (%rsp)
imulq $0x38, %rax, %rdi
callq 0x13cd50
movq %rax, %r14
movl $0x20, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x80(%rbx), %rax
movq -0x20(%rax,%r12), %rcx
movq %r13, -0x20(%rax,%r12)
movq %rcx, -0x20(%r14,%r12)
movq -0x18(%rax,%r12), %rcx
movq %r13, -0x18(%rax,%r12)
movq %rcx, -0x18(%r14,%r12)
movq -0x10(%rax,%r12), %rcx
movq %r13, -0x10(%rax,%r12)
movq %rcx, -0x10(%r14,%r12)
movq -0x8(%rax,%r12), %rcx
movq %rcx, -0x8(%r14,%r12)
movq (%rax,%r12), %rcx
movq %r13, (%rax,%r12)
movq %rcx, (%r14,%r12)
movq 0x8(%rax,%r12), %rcx
movq %r13, 0x8(%rax,%r12)
movq %rcx, 0x8(%r14,%r12)
movq 0x10(%rax,%r12), %rcx
movq %r13, 0x10(%rax,%r12)
movq %rcx, 0x10(%r14,%r12)
movq 0x80(%rbx), %r15
movq (%r15,%r12), %rax
testq %rax, %rax
je 0x43240e
lock
decl (%rax)
jne 0x43240e
movq (%r15,%r12), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq -0x20(%r15,%r12), %rax
testq %rax, %rax
je 0x432431
lock
decl (%rax)
jne 0x432431
movq -0x20(%r15,%r12), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
incq %rbp
movzbl 0x88(%rbx), %ecx
addq $0x38, %r12
cmpq %rcx, %rbp
jb 0x43237e
movq (%rsp), %r15
cmpl %ecx, %r15d
jbe 0x432afd
movq %r15, %rdx
subq %rcx, %rdx
leaq 0xf(%rdx), %rax
andq $-0x10, %rax
decq %rdx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
movdqa 0x142357(%rip), %xmm14 # 0x5747d0
paddq %xmm0, %xmm14
movdqa 0x14235a(%rip), %xmm2 # 0x5747e0
paddq %xmm0, %xmm2
movdqa 0x14235e(%rip), %xmm3 # 0x5747f0
paddq %xmm0, %xmm3
movdqa 0x142362(%rip), %xmm4 # 0x574800
paddq %xmm0, %xmm4
movdqa 0x142366(%rip), %xmm5 # 0x574810
paddq %xmm0, %xmm5
movdqa 0x14236a(%rip), %xmm6 # 0x574820
paddq %xmm0, %xmm6
movdqa 0x14236d(%rip), %xmm15 # 0x574830
paddq %xmm0, %xmm15
paddq 0x142370(%rip), %xmm0 # 0x574840
movq %rdx, %xmm7
pshufd $0x44, %xmm7, %xmm1 # xmm1 = xmm7[0,1,0,1]
movdqa %xmm1, 0x10(%rsp)
imulq $0x38, %rcx, %rcx
addq %r14, %rcx
xorl %edx, %edx
pcmpeqd %xmm11, %xmm11
movdqa %xmm14, (%rsp)
movq %rdx, %xmm7
pshufd $0x44, %xmm7, %xmm13 # xmm13 = xmm7[0,1,0,1]
movdqa %xmm13, %xmm7
por 0x142334(%rip), %xmm7 # 0x574840
movdqa 0x10(%rsp), %xmm8
movdqa 0x142335(%rip), %xmm1 # 0x574850
pxor %xmm1, %xmm8
pxor %xmm1, %xmm7
movdqa %xmm7, %xmm9
pcmpgtd %xmm8, %xmm9
pshufd $0xa0, %xmm9, %xmm14 # xmm14 = xmm9[0,0,2,2]
pshuflw $0xe8, %xmm14, %xmm12 # xmm12 = xmm14[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm7
pshufd $0xf5, %xmm7, %xmm7 # xmm7 = xmm7[1,1,3,3]
pshuflw $0xe8, %xmm7, %xmm10 # xmm10 = xmm7[0,2,2,3,4,5,6,7]
pand %xmm12, %xmm10
pshufd $0xf5, %xmm9, %xmm12 # xmm12 = xmm9[1,1,3,3]
pshuflw $0xe8, %xmm12, %xmm1 # xmm1 = xmm12[0,2,2,3,4,5,6,7]
por %xmm10, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
movdqa %xmm0, %xmm9
psubq %xmm11, %xmm9
movd %xmm1, %esi
testb $0x1, %sil
je 0x432585
movd %xmm9, %esi
movb %sil, (%rcx)
pand %xmm14, %xmm7
por %xmm12, %xmm7
packssdw %xmm7, %xmm7
pxor %xmm11, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
movd %xmm7, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x4325b7
pextrw $0x4, %xmm9, %esi
movb %sil, 0x38(%rcx)
movdqa %xmm13, %xmm1
por 0x14226c(%rip), %xmm1 # 0x574830
movdqa %xmm15, %xmm7
psubq %xmm11, %xmm7
pxor 0x14227a(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm9 # xmm9 = xmm10[0,0,2,2]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm14 # xmm14 = xmm1[1,1,3,3]
movdqa %xmm14, %xmm1
pand %xmm9, %xmm1
pshufd $0xf5, %xmm10, %xmm12 # xmm12 = xmm10[1,1,3,3]
por %xmm12, %xmm1
packssdw %xmm1, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
movd %xmm1, %esi
shrl $0x10, %esi
testb $0x1, %sil
je 0x43262c
movd %xmm7, %esi
movb %sil, 0x70(%rcx)
pshufhw $0x84, %xmm9, %xmm1 # xmm1 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm14, %xmm9 # xmm9 = xmm14[0,1,2,3,4,5,4,6]
pand %xmm1, %xmm9
pshufhw $0x84, %xmm12, %xmm1 # xmm1 = xmm12[0,1,2,3,4,5,4,6]
por %xmm9, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
movd %xmm1, %esi
shrl $0x18, %esi
testb $0x1, %sil
je 0x43266e
pextrw $0x4, %xmm7, %esi
movb %sil, 0xa8(%rcx)
movdqa %xmm13, %xmm1
por 0x1421a5(%rip), %xmm1 # 0x574820
movdqa %xmm6, %xmm7
psubq %xmm11, %xmm7
pxor 0x1421c4(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm14 # xmm14 = xmm10[0,0,2,2]
pshuflw $0xe8, %xmm14, %xmm12 # xmm12 = xmm14[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm9 # xmm9 = xmm1[1,1,3,3]
pshuflw $0xe8, %xmm9, %xmm1 # xmm1 = xmm9[0,2,2,3,4,5,6,7]
pand %xmm12, %xmm1
pshufd $0xf5, %xmm10, %xmm12 # xmm12 = xmm10[1,1,3,3]
pshuflw $0xe8, %xmm12, %xmm10 # xmm10 = xmm12[0,2,2,3,4,5,6,7]
por %xmm1, %xmm10
pxor %xmm11, %xmm10
packssdw %xmm10, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x2, %xmm1, %esi
testb $0x1, %sil
je 0x4326ed
movd %xmm7, %esi
movb %sil, 0xe0(%rcx)
pand %xmm14, %xmm9
por %xmm12, %xmm9
packssdw %xmm9, %xmm9
pxor %xmm11, %xmm9
packssdw %xmm9, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x2, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x432724
pextrw $0x4, %xmm7, %esi
movb %sil, 0x118(%rcx)
movdqa %xmm13, %xmm1
por 0x1420df(%rip), %xmm1 # 0x574810
movdqa %xmm5, %xmm7
psubq %xmm11, %xmm7
pxor 0x14210e(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm9 # xmm9 = xmm10[0,0,2,2]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm12 # xmm12 = xmm1[1,1,3,3]
movdqa %xmm12, %xmm1
pand %xmm9, %xmm1
pshufd $0xf5, %xmm10, %xmm14 # xmm14 = xmm10[1,1,3,3]
por %xmm14, %xmm1
packssdw %xmm1, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x3, %xmm1, %esi
testb $0x1, %sil
je 0x432799
movd %xmm7, %esi
movb %sil, 0x150(%rcx)
pshufhw $0x84, %xmm9, %xmm1 # xmm1 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm12, %xmm9 # xmm9 = xmm12[0,1,2,3,4,5,4,6]
pand %xmm1, %xmm9
pshufhw $0x84, %xmm14, %xmm1 # xmm1 = xmm14[0,1,2,3,4,5,4,6]
por %xmm9, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x3, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x4327dc
pextrw $0x4, %xmm7, %esi
movb %sil, 0x188(%rcx)
movdqa %xmm13, %xmm1
por 0x142017(%rip), %xmm1 # 0x574800
movdqa %xmm4, %xmm7
psubq %xmm11, %xmm7
pxor 0x142056(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm14 # xmm14 = xmm10[0,0,2,2]
pshuflw $0xe8, %xmm14, %xmm12 # xmm12 = xmm14[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm9 # xmm9 = xmm1[1,1,3,3]
pshuflw $0xe8, %xmm9, %xmm1 # xmm1 = xmm9[0,2,2,3,4,5,6,7]
pand %xmm12, %xmm1
pshufd $0xf5, %xmm10, %xmm12 # xmm12 = xmm10[1,1,3,3]
pshuflw $0xe8, %xmm12, %xmm10 # xmm10 = xmm12[0,2,2,3,4,5,6,7]
por %xmm1, %xmm10
pxor %xmm11, %xmm10
packssdw %xmm10, %xmm10
packsswb %xmm10, %xmm1
pextrw $0x4, %xmm1, %esi
testb $0x1, %sil
je 0x43285c
movd %xmm7, %esi
movb %sil, 0x1c0(%rcx)
pand %xmm14, %xmm9
por %xmm12, %xmm9
packssdw %xmm9, %xmm9
pxor %xmm11, %xmm9
packssdw %xmm9, %xmm9
packsswb %xmm9, %xmm1
pextrw $0x4, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x432894
pextrw $0x4, %xmm7, %esi
movb %sil, 0x1f8(%rcx)
movdqa %xmm13, %xmm1
por 0x141f4f(%rip), %xmm1 # 0x5747f0
movdqa %xmm3, %xmm7
psubq %xmm11, %xmm7
pxor 0x141f9e(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm9 # xmm9 = xmm10[0,0,2,2]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm12 # xmm12 = xmm1[1,1,3,3]
movdqa %xmm12, %xmm1
pand %xmm9, %xmm1
pshufd $0xf5, %xmm10, %xmm14 # xmm14 = xmm10[1,1,3,3]
por %xmm14, %xmm1
packssdw %xmm1, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x5, %xmm1, %esi
testb $0x1, %sil
je 0x432909
movd %xmm7, %esi
movb %sil, 0x230(%rcx)
pshufhw $0x84, %xmm9, %xmm1 # xmm1 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm12, %xmm9 # xmm9 = xmm12[0,1,2,3,4,5,4,6]
pand %xmm1, %xmm9
pshufhw $0x84, %xmm14, %xmm1 # xmm1 = xmm14[0,1,2,3,4,5,4,6]
por %xmm9, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x5, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x43294c
pextrw $0x4, %xmm7, %esi
movb %sil, 0x268(%rcx)
movdqa %xmm13, %xmm1
por 0x141e87(%rip), %xmm1 # 0x5747e0
movdqa %xmm2, %xmm7
psubq %xmm11, %xmm7
pxor 0x141ee6(%rip), %xmm1 # 0x574850
movdqa %xmm1, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm14 # xmm14 = xmm10[0,0,2,2]
pshuflw $0xe8, %xmm14, %xmm12 # xmm12 = xmm14[0,2,2,3,4,5,6,7]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm9 # xmm9 = xmm1[1,1,3,3]
pshuflw $0xe8, %xmm9, %xmm1 # xmm1 = xmm9[0,2,2,3,4,5,6,7]
pand %xmm12, %xmm1
pshufd $0xf5, %xmm10, %xmm12 # xmm12 = xmm10[1,1,3,3]
pshuflw $0xe8, %xmm12, %xmm10 # xmm10 = xmm12[0,2,2,3,4,5,6,7]
por %xmm1, %xmm10
pxor %xmm11, %xmm10
packssdw %xmm10, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x6, %xmm1, %esi
testb $0x1, %sil
je 0x4329cb
movd %xmm7, %esi
movb %sil, 0x2a0(%rcx)
pand %xmm14, %xmm9
por %xmm12, %xmm9
packssdw %xmm9, %xmm9
pxor %xmm11, %xmm9
packssdw %xmm9, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x6, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x432a02
pextrw $0x4, %xmm7, %esi
movb %sil, 0x2d8(%rcx)
por 0x141dc5(%rip), %xmm13 # 0x5747d0
movdqa (%rsp), %xmm14
movdqa %xmm14, %xmm7
psubq %xmm11, %xmm7
pxor 0x141e2c(%rip), %xmm13 # 0x574850
movdqa %xmm13, %xmm1
pcmpgtd %xmm8, %xmm1
pshufd $0xa0, %xmm1, %xmm9 # xmm9 = xmm1[0,0,2,2]
pcmpeqd %xmm8, %xmm13
pshufd $0xf5, %xmm13, %xmm8 # xmm8 = xmm13[1,1,3,3]
movdqa %xmm8, %xmm10
pand %xmm9, %xmm10
pshufd $0xf5, %xmm1, %xmm12 # xmm12 = xmm1[1,1,3,3]
por %xmm12, %xmm10
packssdw %xmm10, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x7, %xmm1, %esi
testb $0x1, %sil
je 0x432a7c
movd %xmm7, %esi
movb %sil, 0x310(%rcx)
pshufhw $0x84, %xmm9, %xmm1 # xmm1 = xmm9[0,1,2,3,4,5,4,6]
pshufhw $0x84, %xmm8, %xmm8 # xmm8 = xmm8[0,1,2,3,4,5,4,6]
pand %xmm1, %xmm8
pshufhw $0x84, %xmm12, %xmm1 # xmm1 = xmm12[0,1,2,3,4,5,4,6]
por %xmm8, %xmm1
pxor %xmm11, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pextrw $0x7, %xmm1, %esi
shrl $0x8, %esi
testb $0x1, %sil
je 0x432abf
pextrw $0x4, %xmm7, %esi
movb %sil, 0x348(%rcx)
addq $0x10, %rdx
movdqa 0x141d95(%rip), %xmm1 # 0x574860
paddq %xmm1, %xmm0
paddq %xmm1, %xmm15
paddq %xmm1, %xmm6
paddq %xmm1, %xmm5
paddq %xmm1, %xmm4
paddq %xmm1, %xmm3
paddq %xmm1, %xmm2
paddq %xmm1, %xmm14
addq $0x380, %rcx # imm = 0x380
cmpq %rdx, %rax
jne 0x4324ee
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x432b0e
callq 0x13bae0
movq %r14, 0x80(%rbx)
movb %r15b, 0x88(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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);
avail = box.q_sizes(which);
offset += nextSpacing;
nextSpacing = spacings.at(i);
}
*positions++ = offset;
*sizes++ = avail;
offset += avail;
}
} | 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
xorl %edi, %edi
movl %ecx, %ecx
leaq 0x17b663(%rip), %r15 # 0x5affe4
movq %r11, %r12
xorpd %xmm1, %xmm1
leaq (%r11,%rdi), %r13
sarq $0x3, %r13
leal (%rsi,%rdi), %ebp
movzbl 0x1(%rax,%r13), %r13d
andl $0x7, %ebp
btl %ebp, %r13d
jae 0x4349a8
xorpd %xmm2, %xmm2
jmp 0x4349e5
leaq (%r12,%r12,4), %r13
leaq (%r10,%r13,8), %r13
movslq (%r15,%rcx,4), %rbp
addq %r15, %rbp
jmpq *%rbp
movq %rbx, %r13
jmp 0x4349d5
addq $0x20, %r13
jmp 0x4349d5
addq $0x10, %r13
jmp 0x4349d5
addq $0x18, %r13
jmp 0x4349d5
addq $0x8, %r13
movsd (%r13), %xmm2
addsd %xmm0, %xmm1
movsd (%r14,%rdi,8), %xmm0
movsd %xmm1, (%r8,%rdi,8)
movsd %xmm2, (%r9,%rdi,8)
addsd %xmm2, %xmm1
incq %r12
incq %rdi
addq $0x28, %rbx
movl %edx, %ebp
addl %edi, %ebp
jne 0x434988
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 || !hGrow) {
QSizeF pref = sizeHint(Qt::PreferredSize, constraint);
if (!vGrow)
size.setHeight(pref.height());
if (!hGrow)
size.setWidth(pref.width());
}
if (!size.isValid()) {
QSizeF maxSize = sizeHint(Qt::MaximumSize, size);
if (size.width() == -1)
size.setWidth(maxSize.width());
if (size.height() == -1)
size.setHeight(maxSize.height());
}
return size;
} | 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)
movl %eax, %ebp
movl %r15d, %eax
andl %ebp, %eax
testb $0x1, %al
jne 0x4350ef
andl $0x1, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq *0x18(%rax)
testl %r15d, %r15d
jne 0x4350e4
movsd %xmm1, 0x8(%rsp)
testb $0x1, %bpl
jne 0x4350ef
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x43510a
movsd 0x8(%rsp), %xmm1
ucomisd %xmm2, %xmm1
jae 0x43515a
movq (%rbx), %rax
movq %rsp, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq *0x18(%rax)
movapd %xmm0, %xmm3
movapd %xmm1, %xmm2
movsd (%r14), %xmm4
movsd 0x8(%r14), %xmm1
movsd 0x13fb27(%rip), %xmm5 # 0x574c60
movapd %xmm4, %xmm0
cmpeqsd %xmm5, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm4, %xmm0
orpd %xmm3, %xmm0
ucomisd %xmm5, %xmm1
jne 0x43515a
jp 0x43515a
movapd %xmm2, %xmm1
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x435175
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /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)
retq
| /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
movl %ebp, %edx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movq %rsp, %rcx
movq %rax, (%rcx)
movq %r15, %rdi
callq 0x43a02a
movq %r15, %rdi
callq 0x43a16c
movl 0x30(%rbx), %eax
subl %r14d, %eax
jle 0x435301
leaq 0x20(%rbx), %r15
testl %ebp, %ebp
jle 0x4352bd
movslq %r14d, %rsi
movl %ebp, %edx
movq %rsp, %rcx
movq $0x0, (%rcx)
movl $0x0, 0x8(%rcx)
movq %r15, %rdi
callq 0x43a712
movq %r15, %rdi
callq 0x43a83c
jmp 0x435301
jns 0x435301
movl %ebp, %ecx
negl %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %r14d, %r13
movslq %ecx, %r12
movq (%r15), %rax
testq %rax, %rax
je 0x435294
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4352a2
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43a2ec
shlq $0x3, %r13
addq 0x10(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43a6b4
jmp 0x435231
jns 0x435301
movl %ebp, %ecx
negl %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %r14d, %r13
movslq %ecx, %r12
movq (%r15), %rax
testq %rax, %rax
je 0x4352dd
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4352eb
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43a9bc
shlq $0x4, %r13
addq 0x28(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43ada4
movl 0x48(%rbx), %eax
subl %r14d, %eax
jle 0x43532f
leaq 0x38(%rbx), %r15
testl %ebp, %ebp
jle 0x435383
movslq %r14d, %rsi
movl %ebp, %edx
movq %rsp, %rcx
movl $0x0, (%rcx)
movq %r15, %rdi
callq 0x43ae0e
movq %r15, %rdi
callq 0x43af50
movl 0x60(%rbx), %eax
subl %r14d, %eax
jle 0x435413
leaq 0x50(%rbx), %r15
testl %ebp, %ebp
jle 0x4353d0
movslq %r14d, %rsi
movl %ebp, %edx
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movaps 0x17ac64(%rip), %xmm0 # 0x5affc0
movaps %xmm0, 0x10(%rcx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x20(%rcx)
movq %r15, %rdi
callq 0x43b50c
movq %r15, %rdi
callq 0x4396a6
jmp 0x435413
jns 0x435413
movl %ebp, %ecx
negl %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %r14d, %r13
movslq %ecx, %r12
movq (%r15), %rax
testq %rax, %rax
je 0x4353a7
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4353b5
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43b128
shlq $0x2, %r13
addq 0x40(%rbx), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x43b4ae
jmp 0x43532f
jns 0x435413
negl %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
movslq %r14d, %r12
movslq %ebp, %r14
movq (%r15), %rax
testq %rax, %rax
je 0x4353ee
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x4353fc
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x439c88
leaq (%r12,%r12,4), %rsi
shlq $0x3, %rsi
addq 0x58(%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x43b83e
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x435432
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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 %xmm0, 0x78(%rdi)
movdqu %xmm0, 0x88(%rdi)
movdqu %xmm0, 0x98(%rdi)
movdqu %xmm0, 0xa8(%rdi)
movl %eax, 0xb8(%rdi)
movdqu %xmm0, (%rdi)
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, 0x20(%rdi)
movdqu %xmm0, 0x2c(%rdi)
movdqu %xmm0, 0x140(%rdi)
movaps 0x17aaf5(%rip), %xmm1 # 0x5affc0
movups %xmm1, 0x150(%rdi)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x160(%rdi)
movdqu %xmm0, 0x168(%rdi)
movups %xmm1, 0x178(%rdi)
movq %rcx, 0x188(%rdi)
movdqu %xmm0, 0x1a0(%rdi)
movdqu %xmm0, 0x1b0(%rdi)
movdqu %xmm0, 0x1c0(%rdi)
movdqu %xmm0, 0x1d0(%rdi)
movdqu %xmm0, 0x1e0(%rdi)
movdqu %xmm0, 0x1f0(%rdi)
movq %rax, 0x200(%rdi)
movq %rax, 0x270(%rdi)
movdqu %xmm0, 0x260(%rdi)
movdqu %xmm0, 0x250(%rdi)
movdqu %xmm0, 0x240(%rdi)
movdqu %xmm0, 0x230(%rdi)
movdqu %xmm0, 0x220(%rdi)
movdqu %xmm0, 0x210(%rdi)
movl %eax, 0x120(%rdi)
movq %rax, 0x300(%rdi)
movdqu %xmm0, 0x2f0(%rdi)
movdqu %xmm0, 0x2e0(%rdi)
movdqu %xmm0, 0x2d0(%rdi)
movdqu %xmm0, 0x2c0(%rdi)
movdqu %xmm0, 0x2b0(%rdi)
movdqu %xmm0, 0x2a0(%rdi)
movdqu %xmm0, 0x290(%rdi)
movl %esi, 0x124(%rdi)
movb 0x128(%rdi), %al
andb $-0x8, %al
orb %dl, %al
movb %al, 0x128(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x12c(%rdi)
movaps 0x14ae7b(%rip), %xmm0 # 0x580450
movups %xmm0, 0x190(%rdi)
movaps 0x13f58d(%rip), %xmm0 # 0x574b70
movups %xmm0, 0x280(%rdi)
movb 0x13c(%rdi), %al
andb $-0x8, %al
orb $0x3, %al
movb %al, 0x13c(%rdi)
retq
nop
| /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
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x1476e0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movaps (%r14), %xmm0
movq %rax, (%r14)
movups %xmm0, (%rbx)
movq %rcx, 0x8(%r14)
movq 0x10(%rbx), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rbx)
movq %rcx, 0x10(%r14)
testq %rax, %rax
je 0x4388ae
lock
decl (%rax)
jne 0x4388ae
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x4388c8
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /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(detached);
} else {
// we're detached
const T copy(t);
d->assign(d.begin(), d.begin() + qMin(size(), newSize), t);
if (newSize > size()) {
d->copyAppend(newSize - size(), copy);
} else if (newSize < size()) {
d->truncate(newSize);
}
}
return *this;
} | 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
movq 0x8(%rax), %rcx
cmpq %rcx, %r14
setg %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x4389c7
cmpq %r14, %rcx
cmovleq %r14, %rcx
testb $0x1, 0x4(%rax)
cmoveq %r14, %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl $0x28, %esi
movl $0x10, %edx
movq %r12, %rdi
movl $0x1, %r8d
callq 0x138b60
movq (%r12), %rcx
testq %r14, %r14
je 0x438993
movq %rax, %rdx
movq %r14, %rsi
movq 0x20(%r15), %rdi
movq %rdi, 0x20(%rdx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
addq $0x28, %rdx
decq %rsi
jne 0x438972
movq (%rbx), %rdi
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
testq %rdi, %rdi
je 0x438a5a
lock
decl (%rdi)
jne 0x438a5a
movl $0x28, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x438a5a
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movsd 0x20(%r15), %xmm2
movq 0x10(%rbx), %rax
cmpq %r14, %rax
movq %r14, %rcx
cmovlq %rax, %rcx
testq %rcx, %rcx
je 0x438a1f
movq 0x8(%rbx), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorl %edx, %edx
movq 0x20(%r15), %rsi
movq %rsi, 0x20(%rax,%rdx)
movups (%r15), %xmm3
movups 0x10(%r15), %xmm4
movups %xmm4, 0x10(%rax,%rdx)
movups %xmm3, (%rax,%rdx)
addq $0x28, %rdx
cmpq %rdx, %rcx
jne 0x4389f7
movq 0x10(%rbx), %rax
cmpq %rax, %r14
jle 0x438a54
je 0x438a5a
movq 0x8(%rbx), %rcx
leaq (%rax,%rax,4), %rdx
leaq (%rcx,%rdx,8), %rcx
addq $0x20, %rcx
movups %xmm0, -0x20(%rcx)
movups %xmm1, -0x10(%rcx)
movsd %xmm2, (%rcx)
incq %rax
addq $0x28, %rcx
cmpq %rax, %r14
jne 0x438a36
movq %rax, 0x10(%rbx)
jmp 0x438a5a
jge 0x438a5a
movq %r14, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x438a79
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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(detached);
} else {
// we're detached
const T copy(t);
d->assign(d.begin(), d.begin() + qMin(size(), newSize), t);
if (newSize > size()) {
d->copyAppend(newSize - size(), copy);
} else if (newSize < size()) {
d->truncate(newSize);
}
}
return *this;
} | 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
movq 0x8(%rax), %rcx
cmpq %rcx, %r15
setg %sil
orb %dl, %sil
cmpb $0x1, %sil
jne 0x4394bd
cmpq %r15, %rcx
cmovleq %r15, %rcx
testb $0x1, 0x4(%rax)
cmoveq %r15, %rcx
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movl $0x8, %esi
movl $0x10, %edx
movq %r12, %rdi
movl $0x1, %r8d
callq 0x138b60
movq (%r12), %rcx
testq %r15, %r15
je 0x439489
leaq 0x1(%r15), %rdx
andq $-0x2, %rdx
leaq -0x1(%r15), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %esi, %esi
movdqa 0x13b424(%rip), %xmm1 # 0x574840
movdqa 0x13b42c(%rip), %xmm2 # 0x574850
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rsi, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %edi
notl %edi
testb $0x1, %dil
je 0x43946c
movq %r14, (%rax,%rsi,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %edi
testb $0x1, %dil
je 0x439480
movq %r14, 0x8(%rax,%rsi,8)
addq $0x2, %rsi
cmpq %rsi, %rdx
jne 0x43942c
movq (%rbx), %rdi
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
testq %rdi, %rdi
je 0x43959b
lock
decl (%rdi)
jne 0x43959b
movl $0x8, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x43959b
movq 0x10(%rbx), %rcx
cmpq %r15, %rcx
movq %r15, %rax
cmovlq %rcx, %rax
testq %rax, %rax
je 0x4394eb
movq 0x8(%rbx), %rcx
shlq $0x3, %rax
xorl %edx, %edx
movq %r14, (%rcx,%rdx)
addq $0x8, %rdx
cmpq %rdx, %rax
jne 0x4394da
movq 0x10(%rbx), %rcx
movq %r15, %rdx
subq %rcx, %rdx
jle 0x439595
movq 0x8(%rbx), %rsi
movq %r15, 0x10(%rbx)
leaq 0x1(%rdx), %rax
andq $-0x2, %rax
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
leaq (%rsi,%rcx,8), %rcx
addq $0x8, %rcx
xorl %edx, %edx
movdqa 0x13b31a(%rip), %xmm1 # 0x574840
movdqa 0x13b322(%rip), %xmm2 # 0x574850
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x439577
movq %r14, -0x8(%rcx,%rdx,8)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x43958a
movq %r14, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x439536
jmp 0x43959b
jge 0x43959b
movq %r15, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x4395ba
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /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() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n))
return;
readjusted = tryReadjustFreeSpace(where, n, data);
Q_ASSERT(!readjusted
|| (where == QArrayData::GrowsAtBeginning && freeSpaceAtBegin() >= n)
|| (where == QArrayData::GrowsAtEnd && freeSpaceAtEnd() >= n));
}
if (!readjusted)
reallocateAndGrow(where, n, old);
} | 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
popq %r15
popq %rbp
jmp 0x43a2ec
testq %r14, %r14
je 0x43a238
testl %ebp, %ebp
je 0x43a204
cmpl $0x1, %ebp
jne 0x43a1fd
movq 0x8(%r15), %rdx
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jge 0x43a238
movq %r15, %rdi
movl %ebp, %esi
jmp 0x43a22c
movq 0x8(%rax), %rdx
movq 0x8(%r15), %rsi
addq $0x1f, %rax
andq $-0x10, %rax
subq %rax, %rsi
sarq $0x3, %rsi
addq 0x10(%r15), %rsi
subq %rsi, %rdx
cmpq %r14, %rdx
jge 0x43a238
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x43a244
testb %al, %al
je 0x43a1bd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 && !needsDetach() && n > 0) {
(*this)->reallocate(constAllocatedCapacity() - freeSpaceAtEnd() + n, QArrayData::Grow); // fast path
return;
}
}
QArrayDataPointer dp(allocateGrow(*this, n, where));
if (n > 0)
Q_CHECK_PTR(dp.data());
if (where == QArrayData::GrowsAtBeginning) {
Q_ASSERT(dp.freeSpaceAtBegin() >= n);
} else {
Q_ASSERT(dp.freeSpaceAtEnd() >= n);
}
if (size) {
qsizetype toCopy = size;
if (n < 0)
toCopy += n;
if (needsDetach() || old)
dp->copyAppend(begin(), begin() + toCopy);
else
dp->moveAppend(begin(), begin() + toCopy);
Q_ASSERT(dp.size == toCopy);
}
swap(dp);
if (old)
old->swap(dp);
} | 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, %r15
jle 0x43a36e
cmpl $0x1, %eax
jg 0x43a36e
movq 0x8(%rbx), %rsi
leaq 0x1f(%rdi), %rax
andq $-0x10, %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq 0x10(%rbx), %r15
addq %rcx, %r15
movl $0x8, %edx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x149770
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x43a4a2
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %rdi
movq %rax, 0x10(%rdi)
movaps 0x13a2fa(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rdi)
movq %rbx, %rsi
movq %r15, %rdx
callq 0x43a54e
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x43a430
movq %r15, %rcx
sarq $0x3f, %rcx
andq %r15, %rcx
addq %rcx, %rax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x43a3fa
movl (%rcx), %ecx
testq %r14, %r14
jne 0x43a3fa
cmpl $0x2, %ecx
jge 0x43a3fa
testq %rax, %rax
je 0x43a430
jle 0x43a430
movq 0x8(%rbx), %rcx
leaq (%rcx,%rax,8), %rax
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq (%rcx), %rdi
movq %rdi, (%rdx,%rsi,8)
addq $0x8, %rcx
movq 0x10(%rsp), %rsi
incq %rsi
movq %rsi, 0x10(%rsp)
cmpq %rax, %rcx
jb 0x43a3db
jmp 0x43a430
testq %rax, %rax
je 0x43a430
jle 0x43a430
movq 0x8(%rbx), %rcx
leaq (%rcx,%rax,8), %rax
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq (%rcx), %rdi
movq %rdi, (%rdx,%rsi,8)
addq $0x8, %rcx
movq 0x10(%rsp), %rsi
incq %rsi
movq %rsi, 0x10(%rsp)
cmpq %rax, %rcx
jb 0x43a413
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movaps (%rsp), %xmm0
movq %rax, (%rsp)
movups %xmm0, (%rbx)
movq %rcx, 0x8(%rsp)
movq 0x10(%rbx), %rdx
movq 0x10(%rsp), %rsi
movq %rsi, 0x10(%rbx)
movq %rdx, 0x10(%rsp)
testq %r14, %r14
je 0x43a485
movq (%r14), %rsi
movq %rax, (%r14)
movq %rsi, (%rsp)
movq 0x8(%r14), %rax
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rsp)
movq 0x10(%r14), %rax
movq %rdx, 0x10(%r14)
movq %rax, 0x10(%rsp)
movq %rsi, %rax
testq %rax, %rax
je 0x43a4a2
lock
decl (%rax)
jne 0x43a4a2
movq (%rsp), %rdi
movl $0x8, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x43a4bc
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
nop
| /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;
this->ptr = res;
} | 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), %rdx
leaq (%rcx,%rdx,8), %rcx
cmpq %rax, %rcx
jbe 0x43a510
leaq (%rax,%r15,8), %rax
movq %rax, (%r14)
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | 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 below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | 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 %rax, %rdi
cmovgq %rsi, %rdi
addq %r14, %rdi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rcx
sarq $0x4, %rcx
addq %rcx, %rsi
movq %rax, %r8
subq %rsi, %r8
testl %ebp, %ebp
cmovneq %rcx, %r8
subq %r8, %rdi
cmpq %rdi, %rax
movq %rdi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rdi, %rcx
jmp 0x43acc7
movq 0x10(%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r14, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x10, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x43ad6f
cmpl $0x1, %ebp
jne 0x43ad4b
movq 0x8(%rcx), %rdx
movq 0x10(%r15), %rsi
addq %r14, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r15), %rdx
shlq $0x4, %rdi
shlq $0x4, %r14
addq %rdi, %r14
addq %r14, %rax
testq %rdx, %rdx
jne 0x43ad65
jmp 0x43ad6c
movq (%r15), %rdx
testq %rdx, %rdx
je 0x43ad6a
movq 0x8(%r15), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x43ad6c
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x43ad9e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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
// are invalidated. However, erasing from the beginning effectively
// means that all iterators are invalidated. We can use this freedom to
// erase by moving towards the end.
std::destroy(b, e);
if (b == this->begin() && e != this->end()) {
this->ptr = e;
} else if (e != this->end()) {
memmove(static_cast<void *>(b), static_cast<const void *>(e), (static_cast<const T *>(this->end()) - e)*sizeof(T));
}
this->size -= n;
} | 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, %rsi
je 0x43adfe
subq %rsi, %rdx
movq %rax, %rdi
callq 0x138810
movq 0x10(%r14), %rcx
jmp 0x43adfe
movq %rsi, 0x8(%r14)
subq %rbx, %rcx
movq %rcx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | 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 below, because constAllocatedCapacity() can be 0 when using fromRawData()
qsizetype minimalCapacity = qMax(from.size, from.constAllocatedCapacity()) + n;
// subtract the free space at the side we want to allocate. This ensures that the total size requested is
// the existing allocation at the other side + size + n.
minimalCapacity -= (position == QArrayData::GrowsAtEnd) ? from.freeSpaceAtEnd() : from.freeSpaceAtBegin();
qsizetype capacity = from.detachCapacity(minimalCapacity);
const bool grows = capacity > from.constAllocatedCapacity();
auto [header, dataPtr] = Data::allocate(capacity, grows ? QArrayData::Grow : QArrayData::KeepSize);
const bool valid = header != nullptr && dataPtr != nullptr;
if (!valid)
return QArrayDataPointer(header, dataPtr);
// Idea: * when growing backwards, adjust pointer to prepare free space at the beginning
// * when growing forward, adjust by the previous data pointer offset
dataPtr += (position == QArrayData::GrowsAtBeginning)
? n + qMax(0, (header->alloc - from.size - n) / 2)
: from.freeSpaceAtBegin();
header->flags = from.flags();
return QArrayDataPointer(header, dataPtr);
} | 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 %rax, %rdi
cmovgq %rsi, %rdi
addq %r15, %rdi
leaq 0x1f(%rdx), %r8
andq $-0x10, %r8
subq %r8, %rcx
sarq $0x2, %rcx
addq %rcx, %rsi
movq %rax, %r8
subq %rsi, %r8
testl %ebp, %ebp
cmovneq %rcx, %r8
subq %r8, %rdi
cmpq %rdi, %rax
movq %rdi, %rcx
cmovgq %rax, %rcx
testb $0x1, 0x4(%rdx)
cmoveq %rdi, %rcx
jmp 0x43b3d7
movq 0x10(%r14), %rcx
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
addq %r15, %rcx
xorl %r8d, %r8d
cmpq %rax, %rcx
setle %r8b
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rsp, %r12
movq %rax, (%r12)
movl $0x4, %esi
movl $0x10, %edx
movq %r12, %rdi
callq 0x138b60
movq (%r12), %rcx
testq %rcx, %rcx
sete %dl
testq %rax, %rax
sete %sil
orb %dl, %sil
jne 0x43b479
cmpl $0x1, %ebp
jne 0x43b455
movq 0x8(%rcx), %rdx
movq 0x10(%r14), %rsi
addq %r15, %rsi
subq %rsi, %rdx
movq %rdx, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
sarq %rdi
xorl %esi, %esi
testq %rdi, %rdi
cmovleq %rsi, %rdi
movq (%r14), %rdx
leaq (%rax,%rdi,4), %rax
leaq (%rax,%r15,4), %rax
testq %rdx, %rdx
jne 0x43b46f
jmp 0x43b476
movq (%r14), %rdx
testq %rdx, %rdx
je 0x43b474
movq 0x8(%r14), %rsi
leaq 0x1f(%rdx), %rdi
andq $-0x10, %rdi
subq %rdi, %rsi
addq %rsi, %rax
movl 0x4(%rdx), %esi
jmp 0x43b476
xorl %esi, %esi
movl %esi, 0x4(%rcx)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x43b4a8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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
// are invalidated. However, erasing from the beginning effectively
// means that all iterators are invalidated. We can use this freedom to
// erase by moving towards the end.
if (b == this->begin() && e != this->end()) {
this->ptr = e;
} else if (e != this->end()) {
::memmove(static_cast<void *>(b), static_cast<void *>(e),
(static_cast<T *>(this->end()) - e) * sizeof(T));
}
this->size -= n;
} | 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, %rdi
callq 0x138810
movq 0x10(%r14), %rcx
jmp 0x43b4fc
movq %rsi, 0x8(%r14)
subq %rbx, %rcx
movq %rcx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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;
this->ptr = res;
} | 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 0x10(%rbx), %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rcx,%rdx,8), %rcx
cmpq %rax, %rcx
jbe 0x43b7fb
leaq (%rax,%r12,8), %rax
movq %rax, (%r14)
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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
movl $0x28, %esi
movq %r14, %rdi
callq 0x137fb0
jmp 0x45ada4
movq %r15, %rsi
callq 0x45b604
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| /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;
if (numBuckets > MaxBucketCount) {
Q_CHECK_PTR(false);
Q_UNREACHABLE(); // no exceptions and no assertions -> no error reporting
}
size_t nSpans = numBuckets >> SpanConstants::SpanShift;
return R{ new Span[nSpans], nSpans };
} | 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, %xmm0
movq $0x0, -0x9(%rax,%rsi)
movw $0x0, -0x1(%rax,%rsi)
movdqu %xmm0, -0x89(%rax,%rsi)
movdqu %xmm0, -0x79(%rax,%rsi)
movdqu %xmm0, -0x69(%rax,%rsi)
movdqu %xmm0, -0x59(%rax,%rsi)
movdqu %xmm0, -0x49(%rax,%rsi)
movdqu %xmm0, -0x39(%rax,%rsi)
movdqu %xmm0, -0x29(%rax,%rsi)
movdqu %xmm0, -0x19(%rax,%rsi)
addq $0x90, %rsi
cmpq %rsi, %rdx
jne 0x45adf5
movq %rcx, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
retq
| /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 %rax, %rbx
movq %rdx, %r14
movq (%r15), %rax
testq %rax, %rax
je 0x45b82d
lock
decl (%rax)
jne 0x45b82d
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x45b84d
movq %rbx, %rax
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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)...);
return iterator(result.it);
} | 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
callq 0x45baea
cmpb $0x0, 0x10(%r14)
jne 0x45bac4
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rax), %rax
movq %rcx, %rdx
shrq $0x7, %rdx
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rsi
andl $0x7f, %ecx
movq 0x80(%rax,%rdx), %rax
movzbl (%rcx,%rsi), %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movq %rsi, (%rbx)
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rbx), %rdx
movq %rsi, 0x8(%rbx)
movq %rdx, 0x8(%rax,%rcx,8)
movq 0x10(%rbx), %rdx
movq %rsi, 0x10(%rbx)
movq %rdx, 0x10(%rax,%rcx,8)
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
movq %fs:0x28, %rcx
cmpq 0x20(%rsp), %rcx
jne 0x45bae5
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
| /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::forward<Args>(args)...);
}
// else: we must detach
const auto copy = *this; // keep 'args' alive across the detach/growth
detach();
return emplace_helper(std::move(key), std::forward<Args>(args)...);
} | 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, %rax
cmpq 0x8(%rsp), %rax
jne 0x45bea0
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x45b952
movq $0x0, (%rsp)
xorl %edi, %edi
jmp 0x45be3e
movq %rdi, (%rsp)
movl (%rdi), %eax
cmpl $-0x1, %eax
je 0x45be37
lock
incl (%rdi)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x45be1d
movl (%rdi), %eax
cmpl $0x2, %eax
jb 0x45be46
callq 0x45bbca
movq %rax, (%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x45b952
movq %rax, %rbx
movq %rdx, %r14
movq %rsp, %rdi
callq 0x4543be
movq %fs:0x28, %rax
cmpq 0x8(%rsp), %rax
jne 0x45bea0
movq %rbx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsp, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x45b952
movq %fs:0x28, %rcx
cmpq 0x8(%rsp), %rcx
je 0x45be78
callq 0x13a8c0
nopl (%rax)
| /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_blend_equation_advanced_coherent")
|| extensions.match("GL_NV_blend_equation_advanced_coherent"))) {
// We need both the advanced equations and the coherency for us
// to be able to easily use the new blend equations
features |= QOpenGLFunctions::BlendEquationAdvanced;
}
if (ctx->isOpenGLES()) {
// OpenGL ES
features |= QOpenGLFunctions::Multitexture |
QOpenGLFunctions::Shaders |
QOpenGLFunctions::Buffers |
QOpenGLFunctions::Framebuffers |
QOpenGLFunctions::BlendColor |
QOpenGLFunctions::BlendEquation |
QOpenGLFunctions::BlendEquationSeparate |
QOpenGLFunctions::BlendFuncSeparate |
QOpenGLFunctions::BlendSubtract |
QOpenGLFunctions::CompressedTextures |
QOpenGLFunctions::Multisample |
QOpenGLFunctions::StencilSeparate;
if (extensions.match("GL_IMG_texture_npot"))
features |= QOpenGLFunctions::NPOTTextures;
if (extensions.match("GL_OES_texture_npot"))
features |= QOpenGLFunctions::NPOTTextures |
QOpenGLFunctions::NPOTTextureRepeat;
if (ctx->format().majorVersion() >= 3 || extensions.match("GL_EXT_texture_rg"))
features |= QOpenGLFunctions::TextureRGFormats;
if (ctx->format().majorVersion() >= 3) {
features |= QOpenGLFunctions::MultipleRenderTargets;
if (ctx->format().minorVersion() >= 2 && extensions.match("GL_KHR_blend_equation_advanced_coherent")) {
// GL_KHR_blend_equation_advanced is included in OpenGL ES/3.2
features |= QOpenGLFunctions::BlendEquationAdvanced;
}
}
return features;
} else {
// OpenGL
features |= QOpenGLFunctions::TextureRGFormats;
QSurfaceFormat format = QOpenGLContext::currentContext()->format();
if (format.majorVersion() >= 3)
features |= QOpenGLFunctions::Framebuffers | QOpenGLFunctions::MultipleRenderTargets;
else if (extensions.match("GL_EXT_framebuffer_object") || extensions.match("GL_ARB_framebuffer_object"))
features |= QOpenGLFunctions::Framebuffers | QOpenGLFunctions::MultipleRenderTargets;
if (format.majorVersion() >= 2) {
features |= QOpenGLFunctions::BlendColor |
QOpenGLFunctions::BlendEquation |
QOpenGLFunctions::BlendSubtract |
QOpenGLFunctions::Multitexture |
QOpenGLFunctions::CompressedTextures |
QOpenGLFunctions::Multisample |
QOpenGLFunctions::BlendFuncSeparate |
QOpenGLFunctions::Buffers |
QOpenGLFunctions::Shaders |
QOpenGLFunctions::StencilSeparate |
QOpenGLFunctions::BlendEquationSeparate |
QOpenGLFunctions::NPOTTextures |
QOpenGLFunctions::NPOTTextureRepeat;
} else {
// Recognize features by extension name.
if (extensions.match("GL_ARB_multitexture"))
features |= QOpenGLFunctions::Multitexture;
if (extensions.match("GL_ARB_shader_objects"))
features |= QOpenGLFunctions::Shaders;
if (extensions.match("GL_EXT_blend_color"))
features |= QOpenGLFunctions::BlendColor;
if (extensions.match("GL_EXT_blend_equation_separate"))
features |= QOpenGLFunctions::BlendEquationSeparate;
if (extensions.match("GL_EXT_blend_subtract"))
features |= QOpenGLFunctions::BlendSubtract;
if (extensions.match("GL_EXT_blend_func_separate"))
features |= QOpenGLFunctions::BlendFuncSeparate;
if (extensions.match("GL_ARB_texture_compression"))
features |= QOpenGLFunctions::CompressedTextures;
if (extensions.match("GL_ARB_multisample"))
features |= QOpenGLFunctions::Multisample;
if (extensions.match("GL_ARB_texture_non_power_of_two"))
features |= QOpenGLFunctions::NPOTTextures |
QOpenGLFunctions::NPOTTextureRepeat;
}
const std::pair<int, int> version = format.version();
if (version < std::pair(3, 0)
|| (version == std::pair(3, 0) && format.testOption(QSurfaceFormat::DeprecatedFunctions))
|| (version == std::pair(3, 1) && extensions.match("GL_ARB_compatibility"))
|| (version >= std::pair(3, 2) && format.profile() == QSurfaceFormat::CompatibilityProfile)) {
features |= QOpenGLFunctions::FixedFunctionPipeline;
}
return features;
}
} | 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(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq (%r14), %rdi
testq %rdi, %rdi
je 0x45c003
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
je 0x45c003
xorl %r14d, %r14d
jmp 0x45c037
leaq 0x1577d0(%rip), %rsi # 0x5b37da
leaq 0x38(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c0a0
leaq 0x38(%rsp), %rsi
callq 0x4545aa
movb $0x1, %r14b
testq %rax, %rax
je 0x45c0a0
leaq 0x1577ba(%rip), %rsi # 0x5b37f8
leaq 0x20(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c06b
leaq 0x20(%rsp), %rsi
callq 0x4545aa
movb $0x1, %bpl
testq %rax, %rax
jne 0x45c0c9
leaq 0x1577ae(%rip), %rsi # 0x5b3820
leaq 0x8(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c0a4
leaq 0x8(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %bpl
jmp 0x45c0a6
xorl %ebp, %ebp
jmp 0x45c0f1
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x45c0c9
lock
decl (%rax)
jne 0x45c0c9
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x45c0ec
lock
decl (%rax)
jne 0x45c0ec
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
testb %r14b, %r14b
je 0x45c114
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x45c114
lock
decl (%rax)
jne 0x45c114
movq 0x38(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c137
lock
decl (%rax)
jne 0x45c137
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movzbl %bpl, %r14d
shll $0x11, %r14d
movq %rbx, %rdi
callq 0x141d00
testb %al, %al
je 0x45c192
leaq 0x1576f5(%rip), %rsi # 0x5b3847
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c245
leaq 0x50(%rsp), %rsi
callq 0x4545aa
xorl %ebp, %ebp
testq %rax, %rax
setne %bpl
shll $0xc, %ebp
orl $0xfff, %ebp # imm = 0xFFF
jmp 0x45c24a
leaq 0x8(%rsp), %rbx
movq %r15, (%rbx)
callq 0x148a80
movq %rbx, %rdi
movq %rax, %rsi
callq 0x141760
movq %rbx, %rdi
callq 0x138460
cmpl $0x3, %eax
jl 0x45c1c6
orl $0x18008, %r14d # imm = 0x18008
movl %r14d, %ebp
jmp 0x45c466
leaq 0x1576b4(%rip), %rsi # 0x5b3881
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c200
leaq 0x50(%rsp), %rsi
callq 0x4545aa
movl $0x18008, %ebp # imm = 0x18008
testq %rax, %rax
jne 0x45c440
leaq 0x157694(%rip), %rsi # 0x5b389b
leaq 0x20(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c418
leaq 0x20(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
movl $0x8000, %eax # imm = 0x8000
movl $0x18008, %ebp # imm = 0x18008
cmovel %eax, %ebp
jmp 0x45c41d
movl $0xfff, %ebp # imm = 0xFFF
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c26d
lock
decl (%rax)
jne 0x45c26d
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x1575e7(%rip), %rsi # 0x5b385b
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c2a2
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r15b
jmp 0x45c2a5
xorl %r15d, %r15d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c2c8
lock
decl (%rax)
jne 0x45c2c8
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
testb %r15b, %r15b
movl $0x3fff, %eax # imm = 0x3FFF
cmovnel %eax, %ebp
orl %r14d, %ebp
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x141760
movq %r14, %rdi
callq 0x138460
cmpl $0x3, %eax
jge 0x45c328
leaq 0x157575(%rip), %rsi # 0x5b386f
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c33d
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c340
leaq 0x20(%rsp), %rdi
callq 0x143510
orl $0x8000, %ebp # imm = 0x8000
movl %ebp, %r15d
jmp 0x45c37e
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c363
lock
decl (%rax)
jne 0x45c363
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x20(%rsp), %rdi
callq 0x143510
movl %ebp, %r15d
orl $0x8000, %r15d # imm = 0x8000
testb %r14b, %r14b
cmovel %ebp, %r15d
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x141760
movq %r14, %rdi
callq 0x138460
movl %eax, %ebp
movq %r14, %rdi
callq 0x143510
cmpl $0x3, %ebp
jl 0x45c406
movl %r15d, %ebp
orl $0x10000, %ebp # imm = 0x10000
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x141760
movq %r14, %rdi
callq 0x13d390
cmpl $0x1, %eax
jle 0x45c40e
leaq 0x157426(%rip), %rsi # 0x5b37f8
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c8a5
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %bl
jmp 0x45c8a7
movl %r15d, %ebp
jmp 0x45c87a
leaq 0x20(%rsp), %rdi
jmp 0x45c875
movl $0x8000, %ebp # imm = 0x8000
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x45c440
lock
decl (%rax)
jne 0x45c440
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c463
lock
decl (%rax)
jne 0x45c463
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
orl %r14d, %ebp
leaq 0x8(%rsp), %rdi
callq 0x138460
cmpl $0x2, %eax
jl 0x45c480
orl $0x3ff7, %ebp # imm = 0x3FF7
jmp 0x45c81d
leaq 0x15742e(%rip), %rsi # 0x5b38b5
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c4b6
leaq 0x50(%rsp), %rsi
callq 0x4545aa
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
jmp 0x45c4b8
xorl %ebx, %ebx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c4db
lock
decl (%rax)
jne 0x45c4db
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x1573e7(%rip), %rsi # 0x5b38c9
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c510
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c513
xorl %r14d, %r14d
orl %ebp, %ebx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c538
lock
decl (%rax)
jne 0x45c538
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebx, %ebp
orl $0x2, %ebp
testb %r14b, %r14b
cmovel %ebx, %ebp
leaq 0x157395(%rip), %rsi # 0x5b38df
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c578
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c57b
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c59e
lock
decl (%rax)
jne 0x45c59e
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebp, %ebx
orl $0x10, %ebx
testb %r14b, %r14b
cmovel %ebp, %ebx
leaq 0x157342(%rip), %rsi # 0x5b38f2
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c5de
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c5e1
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c604
lock
decl (%rax)
jne 0x45c604
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebx, %ebp
orl $0x40, %ebp
testb %r14b, %r14b
cmovel %ebx, %ebp
leaq 0x1572fb(%rip), %rsi # 0x5b3911
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c644
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c647
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c66a
lock
decl (%rax)
jne 0x45c66a
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebp, %ebx
orl $0x100, %ebx # imm = 0x100
testb %r14b, %r14b
cmovel %ebp, %ebx
leaq 0x1572a8(%rip), %rsi # 0x5b3927
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c6ad
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c6b0
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c6d3
lock
decl (%rax)
jne 0x45c6d3
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebx, %ebp
orl $0x80, %ebp
testb %r14b, %r14b
cmovel %ebx, %ebp
leaq 0x15725a(%rip), %rsi # 0x5b3942
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c716
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %r14b
jmp 0x45c719
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c73c
lock
decl (%rax)
jne 0x45c73c
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebp, %ebx
orl $0x200, %ebx # imm = 0x200
testb %r14b, %r14b
cmovel %ebp, %ebx
leaq 0x15720c(%rip), %rsi # 0x5b395d
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c77f
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %bpl
jmp 0x45c781
xorl %ebp, %ebp
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c7a4
lock
decl (%rax)
jne 0x45c7a4
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %ebx, %r14d
orl $0x400, %r14d # imm = 0x400
testb %bpl, %bpl
cmovel %ebx, %r14d
leaq 0x1571b4(%rip), %rsi # 0x5b3970
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c7e9
leaq 0x50(%rsp), %rsi
callq 0x4545aa
testq %rax, %rax
setne %bl
jmp 0x45c7eb
xorl %ebx, %ebx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c80e
lock
decl (%rax)
jne 0x45c80e
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movl %r14d, %ebp
orl $0x3000, %ebp # imm = 0x3000
testb %bl, %bl
cmovel %r14d, %ebp
leaq 0x8(%rsp), %rdi
callq 0x1392f0
movq %rax, %rbx
shrq $0x20, %rbx
cmpl $0x3, %eax
jl 0x45c86a
jne 0x45c85b
testq %rax, %rax
js 0x45c86a
testq %rbx, %rbx
jne 0x45c8e3
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x140b90
testb %al, %al
jne 0x45c86a
jmp 0x45c929
leaq 0x8(%rsp), %rdi
callq 0x13e890
cmpl $0x2, %eax
jne 0x45c870
orl $0x4000, %ebp # imm = 0x4000
leaq 0x8(%rsp), %rdi
callq 0x143510
leaq 0x68(%rsp), %rdi
callq 0x4543be
movq %fs:0x28, %rax
cmpq 0x70(%rsp), %rax
jne 0x45c991
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c8ca
lock
decl (%rax)
jne 0x45c8ca
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
leaq 0x20(%rsp), %rdi
callq 0x143510
orl $0x30000, %r15d # imm = 0x30000
testb %bl, %bl
cmovnel %r15d, %ebp
jmp 0x45c87a
cmpl $0x3, %eax
setne %al
cmpl $0x1, %ebx
setne %cl
orb %al, %cl
jne 0x45c929
leaq 0x157096(%rip), %rsi # 0x5b3990
leaq 0x50(%rsp), %rdi
movq $-0x1, %rdx
callq 0x144940
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x45c98c
leaq 0x50(%rsp), %rsi
callq 0x4545aa
movb $0x1, %r14b
testq %rax, %rax
jne 0x45c95b
jmp 0x45c92c
xorl %r14d, %r14d
cmpl $0x2, %ebx
jl 0x45c94f
leaq 0x8(%rsp), %rdi
callq 0x13e890
cmpl $0x2, %eax
sete %cl
testb %r14b, %r14b
movl %ecx, %r14d
je 0x45c865
jmp 0x45c95b
testb %r14b, %r14b
je 0x45c870
xorl %r14d, %r14d
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x45c97e
lock
decl (%rax)
jne 0x45c97e
movq 0x50(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
testb %r14b, %r14b
jne 0x45c86a
jmp 0x45c870
movb $0x1, %r14b
jmp 0x45c92c
callq 0x13a8c0
| /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::OpenGLExtensions(d->m_extensions);
} | 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_extensions & int(extension)) != 0;
} | 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 },
{ "EXT", 4 },
{ "ANGLE", 6 },
{ "NV", 3 },
};
if (!function) {
char fn[512];
size_t size = strlen(funcName);
Q_ASSERT(size < 500);
memcpy(fn, funcName, size);
char *ext = fn + size;
for (const auto &e : extensions) {
memcpy(ext, e.name, e.len);
function = context->getProcAddress(fn);
if (function)
break;
}
}
return function;
} | 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 0x13ad10
movq %r15, %rdi
callq 0x13c0e0
movq %rax, %r12
movl $0x200, %ecx # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x13d870
leaq (%rsp,%r12), %r15
xorl %r12d, %r12d
leaq 0x280760(%rip), %r13 # 0x6de700
movq (%r12,%r13), %rsi
movslq 0x8(%r12,%r13), %rdx
movq %r15, %rdi
callq 0x137aa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144ff0
testq %rax, %rax
jne 0x45dfcf
leaq 0x10(%r12), %rcx
cmpq $0x40, %r12
movq %rcx, %r12
jne 0x45dfa0
movq %fs:0x28, %rcx
cmpq 0x208(%rsp), %rcx
jne 0x45dff3
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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
// is enough (e.g. iOS explicitly documents it), while certain drivers only work
// properly when doing glFinish().
d->flushIsSufficientToSyncContexts = false; // default to false, not guaranteed by the spec
const char *vendor = (const char *) glGetString(GL_VENDOR);
if (vendor) {
static const char *const flushEnough[] = { "Apple", "ATI", "Intel", "NVIDIA" };
for (size_t i = 0; i < sizeof(flushEnough) / sizeof(const char *); ++i) {
if (strstr(vendor, flushEnough[i])) {
d->flushIsSufficientToSyncContexts = true;
break;
}
}
}
}
if (d->flushIsSufficientToSyncContexts)
glFlush();
else
glFinish();
} | 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
movslq (%r12,%r13), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x13cf20
testq %rax, %rax
jne 0x45e175
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x45e155
jmp 0x45e17d
movb $0x1, 0xb59(%r15)
movzbl 0xb59(%r15), %eax
movq (%rbx), %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x90(%rcx,%rax,8)
| /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->d_func()->m_resources.value(this, nullptr));
if (!resource) {
resource = new T(context);
insert(context, resource);
}
return resource;
} | 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 = 0x100000000
movq %r14, %rdi
callq 0x13ed30
movq 0x8(%r12), %rax
movq %r15, 0x8(%rsp)
movq 0xb0(%rax), %rdi
testq %rdi, %rdi
je 0x45e228
leaq 0x8(%rsp), %rsi
callq 0x456fc2
testq %rax, %rax
je 0x45e228
movq 0x8(%rax), %r12
testq %r12, %r12
jne 0x45e24e
movl $0xb78, %edi # imm = 0xB78
callq 0x1387d0
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x45e27a
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x13d220
movq %r14, %rdi
callq 0x1407a0
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x45e275
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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 %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4608c2
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x460b9a
nop
| /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;
tempContext.setFormat(fmt);
if (tempContext.create())
fmt = tempContext.format();
else
qWarning("QRhiGles2: Failed to create temporary context");
QOffscreenSurface *s = new QOffscreenSurface;
s->setFormat(fmt);
s->create();
return s;
} | 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, (%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x1492e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1426f0
movq %r14, %rdi
callq 0x13a5f0
testb %al, %al
je 0x461b4a
leaq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x141760
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x139390
movq %rbx, %rdi
callq 0x143510
movl $0x28, %edi
callq 0x1387d0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1397e0
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144990
movq %rbx, %rdi
callq 0x13c380
leaq 0x10(%rsp), %rdi
callq 0x140b10
movq %r14, %rdi
callq 0x143510
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x461b51
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x15febe
jmp 0x461aec
callq 0x13a8c0
| /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_cast<QSurface *>(maybeWindow) : fallbackSurface;
#else
return fallbackSurface;
#endif
} | 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, (%r14)
movq 0x20(%r15), %rax
cmpb $-0x1, (%rax)
je 0x46455b
xorl %r12d, %r12d
jmp 0x4645a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %r12d, %r12d
jmp 0x464597
movq 0x10(%r15), %rdx
movl $0x1, %ecx
xorl %r12d, %r12d
cmpq %rcx, %rdx
je 0x464594
movq %rcx, %rsi
shrq $0x7, %rsi
leaq (%rsi,%rsi,8), %rsi
shlq $0x4, %rsi
addq %rax, %rsi
movl %ecx, %edi
andl $0x7f, %edi
incq %rcx
cmpb $-0x1, (%rdi,%rsi)
je 0x464567
decq %rcx
movq %rcx, %r12
jmp 0x464597
xorl %r15d, %r15d
movq %r15, %rax
orq %r12, %rax
je 0x464623
movq 0x20(%r15), %rax
movq %r12, %rcx
shrq $0x7, %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdx
movl %r12d, %esi
andl $0x7f, %esi
movq 0x80(%rax,%rcx), %rax
movzbl (%rsi,%rdx), %ecx
shll $0x5, %ecx
movl 0x18(%rax,%rcx), %edi
movq 0x190(%rbx), %rax
movq (%rax), %rax
callq *0x228(%rax)
movq 0x10(%r15), %rax
decq %rax
cmpq %r12, %rax
je 0x464613
incq %r12
movq %r12, %rcx
shrq $0x7, %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
addq 0x20(%r15), %rcx
movl %r12d, %edx
andl $0x7f, %edx
cmpb $-0x1, (%rdx,%rcx)
je 0x4645ea
jmp 0x464619
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %r15, %r15
jne 0x4645a3
testq %r12, %r12
jne 0x4645a3
movq %r14, %rdi
callq 0x4744f4
addq $0x870, %rbx # imm = 0x870
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x47458c
nop
| /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)");
return;
}
const size_t dataOffset = headerSize;
QGles2PipelineCacheDataHeader header;
memcpy(&header, data.constData(), headerSize);
const quint32 rhiId = pipelineCacheRhiId();
if (header.rhiId != rhiId) {
qCDebug(QRHI_LOG_INFO, "setPipelineCacheData: The data is for a different QRhi version or backend (%u, %u)",
rhiId, header.rhiId);
return;
}
const quint32 arch = quint32(sizeof(void*));
if (header.arch != arch) {
qCDebug(QRHI_LOG_INFO, "setPipelineCacheData: Architecture does not match (%u, %u)",
arch, header.arch);
return;
}
if (header.programBinaryCount == 0)
return;
const size_t driverStrLen = qMin(sizeof(header.driver) - 1, size_t(driverInfoStruct.deviceName.size()));
if (strncmp(header.driver, driverInfoStruct.deviceName.constData(), driverStrLen)) {
qCDebug(QRHI_LOG_INFO, "setPipelineCacheData: OpenGL vendor/renderer/version does not match");
return;
}
if (data.size() < qsizetype(dataOffset + header.dataSize)) {
qCDebug(QRHI_LOG_INFO, "setPipelineCacheData: Invalid blob size (data incomplete)");
return;
}
m_pipelineCache.clear();
const char *p = data.constData() + dataOffset;
for (quint32 i = 0; i < header.programBinaryCount; ++i) {
quint32 len = 0;
memcpy(&len, p, 4);
p += 4;
QByteArray key(len, Qt::Uninitialized);
memcpy(key.data(), p, len);
p += len;
memcpy(&len, p, 4);
p += 4;
QByteArray data(len, Qt::Uninitialized);
memcpy(data.data(), p, len);
p += len;
quint32 format;
memcpy(&format, p, 4);
p += 4;
m_pipelineCache.insert(key, { format, data });
}
qCDebug(QRHI_LOG_INFO, "Seeded pipeline cache with %d program binaries", int(m_pipelineCache.size()));
} | 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), %rax
leaq 0x60(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x1520af(%rip), %rsi # 0x5b6bfa
xorl %eax, %eax
callq 0x13c920
jmp 0x464ca4
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x464b6d
movq 0x28a9c3(%rip), %rsi # 0x6ef530
leaq 0x60(%rsp), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
callq 0x137aa0
movl 0x28(%rbx), %ebp
shll $0x18, %ebp
orl $0x60a00, %ebp # imm = 0x60A00
movl (%r15), %r15d
cmpl %ebp, %r15d
jne 0x464c25
movl 0x64(%rsp), %ebp
cmpl $0x8, %ebp
jne 0x464c61
cmpl $0x0, 0x68(%rsp)
je 0x464ca4
movq 0x290(%rbx), %rsi
movq 0x298(%rbx), %rax
movl $0xef, %edx
cmpq %rdx, %rax
cmovbq %rax, %rdx
leaq 0x70(%rsp), %rdi
testq %rsi, %rsi
jne 0x464bda
movq 0x28a956(%rip), %rsi # 0x6ef530
callq 0x139a40
testl %eax, %eax
je 0x464ccd
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), %rax
leaq 0x40(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x1520a4(%rip), %rsi # 0x5b6cc4
jmp 0x464b4b
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), %rax
leaq 0x40(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x151fdc(%rip), %rsi # 0x5b6c36
movl %ebp, %edx
movl %r15d, %ecx
jmp 0x464c9d
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), %rax
leaq 0x40(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x151ff3(%rip), %rsi # 0x5b6c89
movl $0x8, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x13c920
movq %fs:0x28, %rax
cmpq 0x160(%rsp), %rax
jne 0x464f15
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x6c(%rsp), %eax
addq $0x100, %rax # imm = 0x100
cmpq %rax, %r12
jae 0x464d16
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), %rax
leaq 0x40(%rsp), %rdi
movl $0x2, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rdi)
movl $0x0, 0x14(%rdi)
movq %rax, 0x18(%rdi)
leaq 0x151ff7(%rip), %rsi # 0x5b6d08
jmp 0x464b4b
addq $0x870, %rbx # imm = 0x870
movq %rbx, %rdi
callq 0x47458c
movq 0x8(%r14), %rbp
testq %rbp, %rbp
jne 0x464d35
movq 0x28a7fb(%rip), %rbp # 0x6ef530
addq $0x100, %rbp # imm = 0x100
xorl %r15d, %r15d
leaq 0x20(%rsp), %r14
movl (%rbp), %r12d
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x30(%rsp)
movaps 0x10f922(%rip), %xmm0 # 0x574680
movaps %xmm0, 0x20(%rsp)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x139be0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x464d81
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x464d93
movq 0x30(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x144b20
addq $0x4, %rbp
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x137aa0
movl (%rbp,%r12), %r13d
movabsq $-0x5555555555555556, %rax # imm = 0xAAAAAAAAAAAAAAAA
movq %rax, 0x10(%rsp)
movaps 0x10f8be(%rip), %xmm0 # 0x574680
movaps %xmm0, (%rsp)
movq %rsp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x139be0
movq (%rsp), %rax
testq %rax, %rax
je 0x464de3
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x464df5
movq 0x10(%rsp), %rsi
movq %rsp, %rdi
movl $0x1, %edx
callq 0x144b20
addq %r12, %rbp
addq $0x4, %rbp
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x137aa0
movl (%rbp,%r13), %eax
movl %eax, 0x40(%rsp)
movq (%rsp), %rax
movq %rax, 0x48(%rsp)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x50(%rsp)
testq %rax, %rax
je 0x464e30
lock
incl (%rax)
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x40(%rsp), %rdx
callq 0x477ec6
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x464e63
lock
decl (%rax)
jne 0x464e63
movq 0x48(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq (%rsp), %rax
testq %rax, %rax
je 0x464e84
lock
decl (%rax)
jne 0x464e84
movq (%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x464ea7
lock
decl (%rax)
jne 0x464ea7
movq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
addq %r13, %rbp
addq $0x4, %rbp
incl %r15d
cmpl 0x68(%rsp), %r15d
jb 0x464d44
callq 0x34a1c4
movb 0x10(%rax), %cl
testb $0x1, %cl
je 0x464ca4
movq 0x8(%rax), %rax
movl $0x2, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x44(%rsp)
movl $0x0, 0x54(%rsp)
movq %rax, 0x58(%rsp)
movq (%rbx), %rax
testq %rax, %rax
je 0x464efb
movl 0x8(%rax), %edx
jmp 0x464efd
xorl %edx, %edx
leaq 0x151e3e(%rip), %rsi # 0x5b6d42
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
callq 0x13c920
jmp 0x464ca4
callq 0x13a8c0
| /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::EnableTimestamps) && caps.timestamps) {
if (!ofr.tsQueries[0])
f->glGenQueries(2, ofr.tsQueries);
}
addBoundaryCommand(&ofr.cbWrapper, QGles2CommandBuffer::Command::BeginFrame, ofr.tsQueries[0]);
*cb = &ofr.cbWrapper;
return QRhi::FrameOpSuccess;
} | 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 %bpl, 0x3c0(%r14)
movq %rbx, 0x3d0(%r14)
movq %r13, %rdi
callq 0x4745d8
leaq 0x630(%r14), %rdi
movl %ebx, 0x3e8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x3d8(%r14)
movups %xmm0, 0x3f0(%r14)
movq %rbx, 0x3fd(%r14)
callq 0x4751a2
leaq 0x638(%r14), %rdi
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x13ad10
testb $0x8, 0x148(%r14)
je 0x468c4d
testb $0x40, 0x250(%r14)
je 0x468c4d
cmpl $0x0, 0x860(%r14)
jne 0x468c4d
leaq 0x860(%r14), %rsi
movq 0x190(%r14), %rax
movq (%rax), %rax
movl $0x2, %edi
callq *0x4b8(%rax)
movl 0x860(%r14), %ebp
movl 0x31c(%r14), %ebx
cmpl 0x318(%r14), %ebx
jne 0x468cec
movq %r13, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movslq %ebx, %r15
leaq 0x400(%r15), %rax
movl %eax, 0x318(%r14)
movl $0x68, %ecx
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x13cd50
movq %rax, %r12
movq 0x310(%r14), %r13
testq %r13, %r13
je 0x468cc8
imulq $0x68, %r15, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x137aa0
movq %r13, %rdi
callq 0x13bae0
movl 0x31c(%r14), %ebx
movq %r12, 0x310(%r14)
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r13
jmp 0x468cf3
movzbl 0x2b8(%r14), %eax
leal 0x1(,%rax,2), %eax
jmp 0x468d16
movq 0x310(%r14), %r12
leal 0x1(%rbx), %eax
movl %eax, 0x31c(%r14)
movslq %ebx, %rax
imulq $0x68, %rax, %rax
movl $0x0, (%r12,%rax)
movl %ebp, 0x8(%r12,%rax)
movq %r13, (%r15)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 == QGles2CommandBuffer::NoPass);
if (resourceUpdates)
enqueueResourceUpdates(cb, resourceUpdates);
enqueueBarriersForPass(cbD);
cbD->recordingPass = QGles2CommandBuffer::ComputePass;
cbD->resetCachedState();
} | 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 # imm = 0x358
movl $0x100, %edx # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x13ad10
| /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(targetForDataOps, 0, copySize, bufferData);
} else {
memcpy(data.data(), bufferData, copySize);
}
} | 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(%rax)
movq 0x190(%r15), %rax
movl 0x44(%r14), %edi
movl %ebp, %edx
movq (%rax), %rax
movq 0x1d0(%rax), %rax
xorl %esi, %esi
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x470332
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x470344
leaq 0x48(%r14), %rdi
movq 0x58(%r14), %rsi
movl $0x1, %edx
callq 0x144b20
movq 0x50(%r14), %rdi
movl %ebp, %edx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x137aa0
| /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: UsedWithSwapChainOnly is meaningless when importing an existing native object");
if (!rhiD->ensureContext())
return false;
renderbuffer = src.object;
owns = false;
generation += 1;
rhiD->registerResource(this);
return true;
} | 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
callq 0x34de06
movl %eax, 0x50(%rbx)
testb $0x1, 0x40(%rbx)
jne 0x470904
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
callq 0x461de6
testb %al, %al
je 0x4708e5
movl %r14d, 0x48(%rbx)
movb $0x0, 0x54(%rbx)
incl 0x58(%rbx)
leaq 0x7(%rsp), %rdx
movb $0x1, (%rdx)
subq $-0x80, %r15
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
movq %r15, %rdi
callq 0x35d060
movb $0x1, %r12b
jmp 0x4708e5
xorl %r12d, %r12d
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x47090b
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x16034c
jmp 0x4708a5
callq 0x13a8c0
| /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 %rax, 0x448(%rbx)
leaq 0x458(%rbx), %rax
movq %rax, 0x450(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x5498(%rbx)
movl $0x0, 0x54a8(%rbx)
popq %rbx
retq
| /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) {
rhiD->releaseQueue.append(e);
rhiD->unregisterResource(this);
}
} | 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)
movq %rax, 0x140(%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x473257
leaq 0x2c0(%r14), %r15
movq 0x2d0(%r14), %rsi
leaq 0x4(%rsp), %rdx
movq %r15, %rdi
callq 0x47d0c6
movq %r15, %rdi
callq 0x47d1b0
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
subq $-0x80, %r14
movq %r14, %rdi
callq 0x35c2d6
movq %fs:0x28, %rax
cmpq 0x18(%rsp), %rax
jne 0x473271
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13a8c0
| /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), %r14
leaq 0x520(%rbx), %rax
cmpq %rax, %r14
je 0x47384b
movq 0x508(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movq %r14, %rdi
callq 0x1387a0
movq 0x4d8(%rbx), %r15
movq 0x4e0(%rbx), %r14
testq %r15, %r15
jle 0x47387d
incq %r15
movq %r14, %rdi
callq 0x354d4e
addq $0x8, %r14
decq %r15
cmpq $0x1, %r15
ja 0x473861
movq 0x4e0(%rbx), %r14
leaq 0x4e8(%rbx), %rax
cmpq %rax, %r14
je 0x47389c
movq 0x4d0(%rbx), %rsi
shlq $0x3, %rsi
movq %r14, %rdi
callq 0x1387a0
movq 0x460(%rbx), %rsi
movq 0x468(%rbx), %rdi
callq 0x475114
movq 0x468(%rbx), %rdi
leaq 0x470(%rbx), %rax
cmpq %rax, %rdi
je 0x4738d6
movq 0x458(%rbx), %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq 0x1387a0
leaq 0x350(%rbx), %rdi
callq 0x475b9e
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdi
callq 0x475162
movq 0x50(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x473909
movq 0x40(%rbx), %rsi
shlq $0x4, %rsi
callq 0x1387a0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x473917
callq 0x13bae0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x144890
| /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), %rcx
movq %rcx, 0x18(%rsp)
testq %rax, %rax
je 0x4747a8
lock
incl (%rax)
leaq 0x470(%rbx), %rdx
leaq 0x8(%rsp), %r14
movl $0x4, %esi
movq %r14, %rcx
callq 0x4754b2
movq (%r14), %rax
testq %rax, %rax
je 0x4747f5
lock
decl (%rax)
jne 0x4747f5
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0x143f00
jmp 0x4747f5
leaq 0x470(%rbx), %rdx
movl $0x4, %esi
callq 0x475690
movq 0x460(%rbx), %rax
movq 0x468(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movq -0x10(%rcx,%rax,8), %rax
testq %rax, %rax
jne 0x474818
movq 0x27ad18(%rip), %rax # 0x6ef530
movq %fs:0x28, %rcx
cmpq 0x20(%rsp), %rcx
jne 0x474830
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /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
cmpb $-0x1, (%r9,%r8)
je 0x474981
decq %rsi
movq %rsi, %rdx
retq
xorl %eax, %eax
xorl %edx, %edx
retq
xorl %eax, %eax
retq
| /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>::isRelocatable) {
std::memmove(static_cast<void *>(d_first), static_cast<const void *>(first), n * sizeof(T));
} else { // generic version has to be used
if (d_first < first) {
q_relocate_overlap_n_left_move(first, n, d_first);
} else { // first < d_first
auto rfirst = std::make_reverse_iterator(first + n);
auto rd_first = std::make_reverse_iterator(d_first + n);
q_relocate_overlap_n_left_move(rfirst, n, rd_first);
}
}
} | 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::decreaseAction())
return false;
QAccessibleValueInterface *valueIface = iface->valueInterface();
if (!valueIface)
return false;
bool success;
const QVariant currentVariant = valueIface->currentValue();
double stepSize = valueIface->minimumStepSize().toDouble(&success);
if (!success || qFuzzyIsNull(stepSize)) {
const double min = valueIface->minimumValue().toDouble(&success);
if (!success)
return false;
const double max = valueIface->maximumValue().toDouble(&success);
if (!success)
return false;
stepSize = (max - min) / 10; // this is pretty arbitrary, we just need to provide something
const int typ = currentVariant.userType();
if (typ != QMetaType::Float && typ != QMetaType::Double) {
// currentValue is an integer. Round it up to ensure stepping in case it was below 1
stepSize = qCeil(stepSize);
}
}
const double current = currentVariant.toDouble(&success);
if (!success)
return false;
if (actionName == QAccessibleActionInterface::decreaseAction())
stepSize = -stepSize;
valueIface->setCurrentValue(current + stepSize);
return true;
} | 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
movq %r12, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
movq %r12, %rdi
movl $0x1, %ecx
callq 0x140aa0
movl %eax, %ebp
movq %r12, %rdi
callq 0x17ddb4
testb %bpl, %bpl
je 0x486c4c
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movb $0x1, %bl
jmp 0x486dec
callq 0x1386e0
movq 0x10(%rbx), %rdi
cmpq 0x10(%rax), %rdi
jne 0x486c6f
movq 0x8(%rbx), %rsi
movq 0x8(%rax), %rcx
movq %rdi, %rdx
callq 0x13e180
testb %al, %al
jne 0x486c9a
callq 0x13cc00
movq 0x10(%rbx), %rdi
cmpq 0x10(%rax), %rdi
jne 0x486dea
movq 0x8(%rbx), %rsi
movq 0x8(%rax), %rcx
movq %rdi, %rdx
callq 0x13e180
testb %al, %al
je 0x486dea
movq (%r14), %rax
movq %r14, %rdi
movl $0x2, %esi
callq *0xa0(%rax)
testq %rax, %rax
je 0x486dea
movq %rax, %r14
leaq 0x1f(%rsp), %r15
movb $-0x56, (%r15)
movapd 0xed9b8(%rip), %xmm0 # 0x574680
leaq 0x40(%rsp), %rdi
movapd %xmm0, 0x10(%rdi)
movapd %xmm0, (%rdi)
movq (%rax), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x13e050
movapd %xmm0, (%rsp)
movq %r12, %rdi
callq 0x13e600
movapd (%rsp), %xmm2
cmpb $0x1, (%r15)
jne 0x486d46
movapd 0xeda55(%rip), %xmm0 # 0x574770
xorpd %xmm2, %xmm0
movapd %xmm0, %xmm1
cmpnlesd %xmm2, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
movsd 0xede74(%rip), %xmm0 # 0x574bb0
ucomisd %xmm1, %xmm0
jb 0x486e21
movq (%r14), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x28(%rax)
leaq 0x1f(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13e050
movsd %xmm0, 0x10(%rsp)
movq %r15, %rdi
callq 0x13e600
cmpb $0x1, (%r12)
jne 0x486e76
movq (%r14), %rax
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
leaq 0x1f(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13e050
movapd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x13e600
cmpb $0x1, (%r12)
jne 0x486e76
movapd (%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
divsd 0x119bb4(%rip), %xmm0 # 0x5a0980
movapd %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3ce810
andl $-0x21, %eax
cmpl $0x6, %eax
jne 0x486e0f
movapd (%rsp), %xmm2
jmp 0x486e21
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq 0x68(%rsp), %rax
jne 0x486ebb
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movapd (%rsp), %xmm0
callq 0x1470b0
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm2
movapd %xmm2, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x1f(%rsp), %r15
movq %r15, %rsi
callq 0x13e050
cmpb $0x1, (%r15)
jne 0x486e76
movsd %xmm0, 0x10(%rsp)
callq 0x13cc00
movq 0x10(%rbx), %rdi
cmpq 0x10(%rax), %rdi
jne 0x486e7a
movq 0x8(%rbx), %rsi
movq 0x8(%rax), %rcx
movq %rdi, %rdx
callq 0x13e180
testb %al, %al
je 0x486e7a
movapd (%rsp), %xmm1
xorpd 0xed8fc(%rip), %xmm1 # 0x574770
jmp 0x486e7f
xorl %ebx, %ebx
jmp 0x486eac
movapd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x1450c0
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x13e600
movb $0x1, %bl
leaq 0x40(%rsp), %rdi
callq 0x13e600
jmp 0x486dec
callq 0x13a8c0
| /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 %r14, %rsi
callq 0x488312
movq %r15, %rdi
callq 0x487c42
movq %rax, %r14
movq %r15, %rdi
callq 0x487c6e
movb $0x1, %bpl
cmpq %rax, %r14
je 0x4875a6
cmpq %rbx, 0x8(%r14)
je 0x4875a8
addq $0x10, %r14
jmp 0x487595
jmp 0x4875ad
movl (%r14), %ebx
xorl %ebp, %ebp
movq (%rsp), %rax
testq %rax, %rax
je 0x4875ce
lock
decl (%rax)
jne 0x4875ce
movq (%rsp), %rdi
movl $0x10, %esi
movl $0x10, %edx
callq 0x143f00
testb %bpl, %bpl
je 0x4875d5
xorl %ebx, %ebx
movq %fs:0x28, %rax
cmpq 0x20(%rsp), %rax
jne 0x4875f2
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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)...);
++m_size;
return iterator(result.it);
} | 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 0xebab0(%rip), %xmm0 # 0x574680
movaps %xmm0, (%r13)
movq (%rsi), %rsi
movq %r13, %rdi
callq 0x488e50
movq (%r13), %rax
movq 0x8(%r13), %rcx
movq 0x20(%rax), %rax
movq %rcx, %rdx
shrq $0x7, %rdx
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rsi
andl $0x7f, %ecx
movq 0x80(%rax,%rdx), %rbp
movzbl (%rcx,%rsi), %r15d
cmpb $0x0, 0x10(%r13)
je 0x488c3f
movl $0x18, %edi
callq 0x1387d0
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
shll $0x4, %r15d
movq 0x8(%rbp,%r15), %rcx
movq %rax, 0x8(%rbp,%r15)
movq %rcx, 0x10(%rax)
jmp 0x488c6e
shll $0x4, %r15d
movl $0x18, %edi
callq 0x1387d0
movq 0x8(%rsp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%r12), %rcx
movq %rcx, (%rbp,%r15)
movq %rax, 0x8(%rbp,%r15)
incq 0x8(%r14)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
testq %rcx, %rcx
je 0x488cc4
movq 0x20(%rcx), %rcx
movq %rax, %rdx
shrq $0x7, %rdx
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rsi
andl $0x7f, %eax
movq 0x80(%rcx,%rdx), %rcx
movzbl (%rax,%rsi), %eax
shll $0x4, %eax
addq %rcx, %rax
addq $0x8, %rax
movq %rax, 0x10(%rbx)
movq %fs:0x28, %rax
cmpq 0x30(%rsp), %rax
jne 0x488ce6
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
nop
| /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 = newBucketCount;
size_t oldNSpans = oldBucketCount >> SpanConstants::SpanShift;
for (size_t s = 0; s < oldNSpans; ++s) {
Span &span = oldSpans[s];
for (size_t index = 0; index < SpanConstants::NEntries; ++index) {
if (!span.hasNode(index))
continue;
Node &n = span.at(index);
auto it = findBucket(n.key);
Q_ASSERT(it.isUnused());
Node *newNode = it.insert();
new (newNode) Node(std::move(n));
}
span.freeData();
}
delete[] oldSpans;
} | 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
subb %al, %cl
movl $0x1, %r14d
shlq %cl, %r14
movq 0x10(%rbx), %r15
movq 0x20(%rbx), %r13
movq %r14, %rdi
callq 0x48a11c
movq %rax, 0x20(%rbx)
movq %r14, 0x10(%rbx)
cmpq $0x80, %r15
jae 0x489fd7
testq %r13, %r13
jne 0x48a0c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shrq $0x7, %r15
xorl %eax, %eax
movq %r13, %rbp
movq %r13, 0x8(%rsp)
movq %r15, (%rsp)
movq %rax, 0x10(%rsp)
leaq (%rax,%rax,8), %r12
shlq $0x4, %r12
addq %r13, %r12
xorl %r15d, %r15d
movzbl (%rbp,%r15), %r13d
cmpq $0xff, %r13
je 0x48a071
movq 0x80(%r12), %r14
shll $0x4, %r13d
leaq (%r14,%r13), %rsi
movq 0x18(%rbx), %rax
movl (%r14,%r13), %ecx
movq %rax, %rdx
shrq $0x20, %rdx
xorq %rax, %rdx
xorq %rcx, %rdx
movabsq $-0x2917014799a6026d, %rcx # imm = 0xD6E8FEB86659FD93
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
imulq %rcx, %rax
movq %rax, %rdx
shrq $0x20, %rdx
xorq %rax, %rdx
movq %rbx, %rdi
callq 0x48818c
movq %rax, %rdi
movq %rdx, %rsi
callq 0x48a1be
movups (%r14,%r13), %xmm0
movups %xmm0, (%rax)
incq %r15
cmpq $0x80, %r15
jne 0x489ffc
movq 0x80(%r12), %rdi
testq %rdi, %rdi
je 0x48a09f
callq 0x13bae0
movq $0x0, 0x80(%r12)
movq 0x10(%rsp), %rax
incq %rax
addq $0x90, %rbp
movq (%rsp), %r15
cmpq %r15, %rax
movq 0x8(%rsp), %r13
jne 0x489fe9
leaq -0x8(%r13), %rbx
movq -0x8(%r13), %r14
testq %r14, %r14
je 0x48a0f9
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%rax,8), %r15
movq -0x10(%r13,%r15), %rdi
testq %rdi, %rdi
je 0x48a0f0
callq 0x13bae0
movq $0x0, -0x10(%r13,%r15)
addq $-0x90, %r15
jne 0x48a0d8
shlq $0x4, %r14
leaq (%r14,%r14,8), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x136e80
nop
| /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, %rdi
callq 0x137fb0
jmp 0x48b96e
movl $0x1, (%rbx)
xorl %r14d, %r14d
movq %r14, 0x8(%rbx)
movq $0x80, 0x10(%rbx)
movl $0x98, %edi
callq 0x13cd50
movq $0x1, (%rax)
leaq 0x8(%rax), %rcx
movq %r14, 0x88(%rax)
movw $0x0, 0x90(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rax)
movdqu %xmm0, 0x18(%rax)
movdqu %xmm0, 0x28(%rax)
movdqu %xmm0, 0x38(%rax)
movdqu %xmm0, 0x48(%rax)
movdqu %xmm0, 0x58(%rax)
movdqu %xmm0, 0x68(%rax)
movdqu %xmm0, 0x78(%rax)
movq %rcx, 0x20(%rbx)
callq 0x13fbc0
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /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 # 0x70c7c8
leaq 0x12cd59(%rip), %rsi # 0x5b9b73
movq %r14, %rdx
movl $0x1, %ecx
callq 0x13e1c0
movq (%r14), %rax
testq %rax, %rax
je 0x48ce47
lock
decl (%rax)
jne 0x48ce47
movq (%rsp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x143f00
movb $-0x1, 0x27f972(%rip) # 0x70c7c0
movq %fs:0x28, %rax
cmpq 0x40(%rsp), %rax
jne 0x48ce66
addq $0x48, %rsp
popq %rbx
popq %r14
retq
callq 0x13a8c0
nop
| /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 QKeySequence");
return s;
}
s >> keys[i];
}
qAtomicDetach(keysequence.d);
std::copy(keys, keys + MaxKeys, QT_MAKE_CHECKED_ARRAY_ITERATOR(keysequence.d->key, MaxKeys));
return s;
} | 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 0x498b28
leaq 0x10(%rsp), %r15
xorl %r12d, %r12d
movl $0x4, %ebp
movq %rbx, %rdi
callq 0x13c4d0
testb %al, %al
jne 0x498ba1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13f5f0
incq %r12
movl 0xc(%rsp), %eax
cmpl $0x4, %eax
cmovael %ebp, %eax
addq $0x4, %r15
cmpq %rax, %r12
jb 0x498af7
movq (%r14), %r15
movl (%r15), %eax
cmpl $0x1, %eax
je 0x498b62
movl $0x14, %edi
callq 0x1387d0
movl $0x1, (%rax)
movups 0x4(%r15), %xmm0
movups %xmm0, 0x4(%rax)
movq %rax, (%r14)
lock
decl (%r15)
jne 0x498b62
movl $0x14, %esi
movq %r15, %rdi
callq 0x137fb0
movq (%r14), %rax
movl $0x5, %ecx
xorl %edx, %edx
movl 0x10(%rsp,%rdx), %esi
movl %esi, 0x4(%rax,%rdx)
decq %rcx
addq $0x4, %rdx
cmpq $0x1, %rcx
ja 0x498b6c
movq %fs:0x28, %rax
cmpq 0x28(%rsp), %rax
jne 0x498ba8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x161130
jmp 0x498b81
callq 0x13a8c0
| /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))
bd->removeBinding_helper();
}
this->val = t;
} | 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 0x4a30ea
movq %r14, %rdi
callq 0x13aac0
testb %al, %al
jne 0x4a30f2
movq %r15, %rdi
callq 0x13fa70
movl %ebx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nop
| /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, %r15 # imm = 0xFFFF000000000000
movl %ecx, %r12d
shlq $0x3, %r12
xorl %r13d, %r13d
leaq (%r14,%r13), %rdi
callq 0x191fa6
orq %r15, %rax
movq %rax, (%rbx,%r13)
addq $0x8, %r13
cmpq %r13, %r12
jne 0x4ace8e
jmp 0x4ad09f
xorl %edx, %edx
cmpl $0x4, %ecx
jl 0x4ad04d
leal -0x3(%rcx), %esi
leaq (%rbx,%rax,8), %rdi
addq $0x10, %rdi
xorl %edx, %edx
pmovsxbw 0x11184b(%rip), %xmm2 # 0x5be718
movaps 0xeba7c(%rip), %xmm3 # 0x598950
pxor %xmm4, %xmm4
movdqa 0xc7970(%rip), %xmm5 # 0x574850
movdqa 0x1117e8(%rip), %xmm6 # 0x5be6d0
movdqu 0x10(%r14,%rdx,8), %xmm1
xorl %r8d, %r8d
ptest %xmm2, %xmm1
movdqu (%r14,%rdx,8), %xmm0
sete %r9b
ptest %xmm2, %xmm0
jne 0x4acf1d
movb %r9b, %r8b
pxor %xmm7, %xmm7
pxor %xmm8, %xmm8
testl %r8d, %r8d
jne 0x4ad034
xorl %r8d, %r8d
ptest %xmm2, %xmm0
setb %r9b
ptest %xmm2, %xmm1
jae 0x4acf4e
movb %r9b, %r8b
testl %r8d, %r8d
je 0x4acf4e
por %xmm2, %xmm0
por %xmm2, %xmm1
movdqa %xmm0, %xmm7
movdqa %xmm1, %xmm8
jmp 0x4ad034
movdqa %xmm0, %xmm7
psrlq $0x30, %xmm7
movdqa %xmm1, %xmm8
psrlq $0x30, %xmm8
packusdw %xmm8, %xmm7
cvtdq2ps %xmm7, %xmm8
rcpps %xmm8, %xmm7
mulps %xmm7, %xmm8
mulps %xmm7, %xmm8
addps %xmm7, %xmm7
subps %xmm8, %xmm7
mulps %xmm3, %xmm7
pmovzxwd %xmm0, %xmm8 # xmm8 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero
movdqa %xmm0, %xmm9
punpckhwd %xmm4, %xmm9 # xmm9 = xmm9[4],xmm4[4],xmm9[5],xmm4[5],xmm9[6],xmm4[6],xmm9[7],xmm4[7]
pmovzxwd %xmm1, %xmm10 # xmm10 = xmm1[0],zero,xmm1[1],zero,xmm1[2],zero,xmm1[3],zero
movdqa %xmm1, %xmm11
punpckhwd %xmm4, %xmm11 # xmm11 = xmm11[4],xmm4[4],xmm11[5],xmm4[5],xmm11[6],xmm4[6],xmm11[7],xmm4[7]
movaps %xmm7, %xmm12
shufps $0x0, %xmm7, %xmm12 # xmm12 = xmm12[0,0],xmm7[0,0]
movaps %xmm7, %xmm13
shufps $0x55, %xmm7, %xmm13 # xmm13 = xmm13[1,1],xmm7[1,1]
movaps %xmm7, %xmm14
shufps $0xaa, %xmm7, %xmm14 # xmm14 = xmm14[2,2],xmm7[2,2]
shufps $0xff, %xmm7, %xmm7 # xmm7 = xmm7[3,3,3,3]
cvtdq2ps %xmm8, %xmm8
mulps %xmm12, %xmm8
cvtps2dq %xmm8, %xmm8
cvtdq2ps %xmm9, %xmm9
mulps %xmm13, %xmm9
cvtps2dq %xmm9, %xmm9
packusdw %xmm9, %xmm8
cvtdq2ps %xmm10, %xmm9
mulps %xmm14, %xmm9
cvtps2dq %xmm9, %xmm9
cvtdq2ps %xmm11, %xmm10
mulps %xmm7, %xmm10
cvtps2dq %xmm10, %xmm7
packusdw %xmm7, %xmm9
pxor %xmm5, %xmm0
pcmpgtd %xmm6, %xmm0
por %xmm2, %xmm8
pxor %xmm5, %xmm1
pcmpgtd %xmm6, %xmm1
por %xmm2, %xmm9
movdqa %xmm2, %xmm7
blendvpd %xmm0, %xmm8, %xmm7
movdqa %xmm2, %xmm8
movdqa %xmm1, %xmm0
blendvpd %xmm0, %xmm9, %xmm8
movdqu %xmm7, -0x10(%rdi,%rdx,8)
movdqu %xmm8, (%rdi,%rdx,8)
addq $0x4, %rdx
cmpq %rsi, %rdx
jb 0x4acee8
cmpl %ecx, %edx
jge 0x4ad09f
movabsq $-0x1000000000000, %r15 # imm = 0xFFFF000000000000
movl %edx, %edx
movslq %ecx, %r12
leaq 0x1(%rdx), %r13
leaq (,%rdx,8), %rcx
leaq (%rcx,%rax,8), %rax
addq %rax, %rbx
leaq (%r14,%rdx,8), %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x191fa6
orq %r15, %rax
movq %rax, (%rbx,%rbp,8)
cmpl $0x1, %ebp
ja 0x4ad09f
movq %r13, %rax
addq %rbp, %rax
incq %rbp
addq $0x8, %r14
cmpq %r12, %rax
jl 0x4ad079
movq %fs:0x28, %rax
cmpq 0x10(%rsp), %rax
jne 0x4ad0be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13a8c0
| /qt[P]qtbase/src/gui/painting/qdrawhelper_sse4.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.